public void GetPoolByName()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
Sql2ScenarioHelper.RunServerTestInEnvironment(
handler,
"12.0",
(sqlClient, resGroupName, server) =>
{
var response = sqlClient.RecommendedElasticPools.Get(resGroupName, server.Name, "ElasticPool1");
TestUtilities.ValidateOperationResponse(response, HttpStatusCode.OK);
ValidateRecommendedElasticPool(response.RecommendedElasticPool,
"ElasticPool1",
"Microsoft.Sql/servers/recommendedElasticPools",
"Standard",
1000f,
100.6f,
200.5f,
1000.3f,
DateTime.Parse("2014-11-01T00:00:00"),
DateTime.Parse("2014-11-15T00:00:00"),
900.2f,
350.0f);
});
}
}
public void ServerAuditingPolicyLifecycleTest()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
Sql2ScenarioHelper.RunServerTestInEnvironment(new BasicDelegatingHandler(), "2.0", TestServerAuditingAPIs);
}
}
public void ServerSecurityAlertPolicyLifecycleTest()
{
using (var context = UndoContext.Current)
{
context.Start();
Sql2ScenarioHelper.RunServerTestInEnvironment(new BasicDelegatingHandler(), "12.0", TestServerSecurityAlertApis);
}
}
public void PositiveTestEmptyServer()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
Sql2ScenarioHelper.RunServerTestInEnvironment(
new BasicDelegatingHandler(),
currentVersion,
serverLocation,
UpgradeEmptyServer);
}
}
public void GetDatabasesForPool()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
Sql2ScenarioHelper.RunServerTestInEnvironment(
handler,
"12.0",
(sqlClient, resGroupName, server) =>
{
var response = sqlClient.RecommendedElasticPools.ListDatabases(resGroupName, server.Name, "ElasticPool1");
TestUtilities.ValidateOperationResponse(response, HttpStatusCode.OK);
Assert.Equal(1, response.Databases.Count());
Assert.Equal("28acaef5-d228-4660-bb67-546ec8482496", response.Databases[0].Properties.DatabaseId);
});
}
}
public void ListPoolsExpanded()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
Sql2ScenarioHelper.RunServerTestInEnvironment(
handler,
"12.0",
(sqlClient, resGroupName, server) =>
{
var response = sqlClient.RecommendedElasticPools.ListExpanded(resGroupName, server.Name, "databases,metrics");
TestUtilities.ValidateOperationResponse(response, HttpStatusCode.OK);
Assert.Equal(2, response.RecommendedElasticPools.Count());
Assert.Equal(0, response.RecommendedElasticPools[0].Properties.Databases.Count);
Assert.Equal(3, response.RecommendedElasticPools[0].Properties.Metrics.Count);
Assert.Equal(1, response.RecommendedElasticPools[1].Properties.Databases.Count);
Assert.Equal(3, response.RecommendedElasticPools[1].Properties.Metrics.Count);
});
}
}
public void GetDatabasesExpanded()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
Sql2ScenarioHelper.RunServerTestInEnvironment(
handler,
"12.0",
(sqlClient, resGroupName, server) =>
{
var response = sqlClient.Databases.GetExpanded(resGroupName, server.Name, "AutoScaleSterlingTest4", "upgradeHint,serviceTierAdvisors");
TestUtilities.ValidateOperationResponse(response, HttpStatusCode.OK);
Assert.Equal("AutoScaleSterlingTest4", response.Database.Name);
Assert.Equal("S2", response.Database.Properties.UpgradeHint.TargetServiceLevelObjective);
Assert.Equal(1, response.Database.Properties.ServiceTierAdvisors.Count);
Assert.Equal("S3", response.Database.Properties.ServiceTierAdvisors[0].Properties.UsageBasedRecommendationServiceLevelObjective);
Assert.Equal(4, response.Database.Properties.ServiceTierAdvisors[0].Properties.ServiceLevelObjectiveUsageMetrics.Count);
});
}
}
public void GetServiceTierAdvisors()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
Sql2ScenarioHelper.RunServerTestInEnvironment(
handler,
"12.0",
(sqlClient, resGroupName, server) =>
{
var response = sqlClient.ServiceTierAdvisors.Get(resGroupName, server.Name, "AdventureWorks2012", "Current");
TestUtilities.ValidateOperationResponse(response, HttpStatusCode.OK);
Assert.Equal("current", response.ServiceTierAdvisor.Name);
Assert.Equal("Web", response.ServiceTierAdvisor.Properties.CurrentServiceLevelObjective);
Assert.Equal("Basic", response.ServiceTierAdvisor.Properties.UsageBasedRecommendationServiceLevelObjective);
Assert.Equal(4, response.ServiceTierAdvisor.Properties.ServiceLevelObjectiveUsageMetrics.Count);
Assert.Equal("Basic", response.ServiceTierAdvisor.Properties.ServiceLevelObjectiveUsageMetrics[0].ServiceLevelObjective);
});
}
}
public void GetMetricsForPool()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
Sql2ScenarioHelper.RunServerTestInEnvironment(
handler,
"12.0",
(sqlClient, resGroupName, server) =>
{
var response = sqlClient.RecommendedElasticPools.ListMetrics(resGroupName, server.Name, "ElasticPool1");
TestUtilities.ValidateOperationResponse(response, HttpStatusCode.OK);
Assert.Equal(3, response.RecommendedElasticPoolsMetrics.Count());
ValidateRecommendedElasticPoolMetric(
response.RecommendedElasticPoolsMetrics[0],
DateTime.Parse("4/1/2015 12:00:00 AM"),
100.5f,
15.4f);
});
}
}
public void FailoverGroupCrud()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
string failoverGroupName = TestUtilities.GenerateName("csm-sql-fgcrud1");
string failoverGroup2Name = TestUtilities.GenerateName("csm-sql-fgcrud2");
string serverName = TestUtilities.GenerateName("csm-sql-fgcrud-server");
string partnerServerName = TestUtilities.GenerateName("csm-sql-fgcrud-server");
// Create the resource group.
//resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup()
//{
// Location = serverLocation,
//});
Sql2ScenarioHelper.RunServerTestInEnvironment(
handler,
"12.0",
"North Europe",
(sqlClient, resGroupName, server) =>
{
// Variables for partner server create
string serverLocation = "North Europe";
string adminLogin = "******";
string adminPass = "******";
string version = "12.0";
// Create partner server for test.
var createServerResponse = sqlClient.Servers.CreateOrUpdate(resGroupName, partnerServerName, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
});
// Create Failover Group Test with all values specified (Default values)
ReadOnlyEndpoint readOnlyEndpoint = new ReadOnlyEndpoint();
readOnlyEndpoint.FailoverPolicy = "Disabled";
ReadWriteEndpoint readWriteEndpoint = new ReadWriteEndpoint();
readWriteEndpoint.FailoverPolicy = "Automatic";
readWriteEndpoint.FailoverWithDataLossGracePeriodMinutes = 5;
FailoverGroupPartnerServer partnerServer = new FailoverGroupPartnerServer();
partnerServer.ReplicationRole = "Secondary";
partnerServer.Id = createServerResponse.Server.Id;
partnerServer.Location = "North Europe";
List <FailoverGroupPartnerServer> partnerServers = new List <FailoverGroupPartnerServer>();
partnerServers.Add(partnerServer);
var failoverGroup1Properties = new FailoverGroupCreateOrUpdateProperties()
{
ReadOnlyEndpoint = readOnlyEndpoint,
ReadWriteEndpoint = readWriteEndpoint,
PartnerServers = partnerServers,
};
var failoverGroup1 = sqlClient.FailoverGroups.CreateOrUpdate(resGroupName, server.Name, failoverGroupName, new FailoverGroupCreateOrUpdateParameters()
{
Location = server.Location,
Properties = failoverGroup1Properties
});
TestUtilities.ValidateOperationResponse(failoverGroup1, HttpStatusCode.Created);
var failoverGroup2 = sqlClient.FailoverGroups.CreateOrUpdate(resGroupName, server.Name, failoverGroup2Name, new FailoverGroupCreateOrUpdateParameters()
{
Location = server.Location,
Properties = failoverGroup1Properties
});
TestUtilities.ValidateOperationResponse(failoverGroup2, HttpStatusCode.Created);
ValidateFailoverGroup(
failoverGroup2.FailoverGroup,
failoverGroup2Name,
readOnlyEndpoint.FailoverPolicy,
readWriteEndpoint.FailoverPolicy,
readWriteEndpoint.FailoverWithDataLossGracePeriodMinutes,
partnerServer.ReplicationRole,
partnerServer.Id);
//////////////////////////////////////////////////////////////////////
// Update Failover Group Test
failoverGroup1Properties.ReadOnlyEndpoint.FailoverPolicy = "Enabled";
failoverGroup1Properties.ReadWriteEndpoint.FailoverPolicy = "Manual";
failoverGroup1Properties.ReadWriteEndpoint.FailoverWithDataLossGracePeriodMinutes = null;
var failoverGroup3 = sqlClient.FailoverGroups.CreateOrUpdate(resGroupName, server.Name, failoverGroupName, new FailoverGroupCreateOrUpdateParameters()
{
Location = server.Location,
Properties = failoverGroup1Properties
});
TestUtilities.ValidateOperationResponse(failoverGroup3, HttpStatusCode.Created);
ValidateFailoverGroup(
failoverGroup3.FailoverGroup,
failoverGroupName,
failoverGroup1Properties.ReadOnlyEndpoint.FailoverPolicy,
failoverGroup1Properties.ReadWriteEndpoint.FailoverPolicy,
failoverGroup1Properties.ReadWriteEndpoint.FailoverWithDataLossGracePeriodMinutes,
failoverGroup1Properties.PartnerServers.First().ReplicationRole,
failoverGroup1Properties.PartnerServers.First().Id);
//////////////////////////////////////////////////////////////////////
// Get Failover group.
var failoverGroup4 = sqlClient.FailoverGroups.Get(resGroupName, server.Name, failoverGroupName);
TestUtilities.ValidateOperationResponse(failoverGroup4, HttpStatusCode.Created);
ValidateFailoverGroup(
failoverGroup3.FailoverGroup,
failoverGroupName,
failoverGroup1Properties.ReadOnlyEndpoint.FailoverPolicy,
failoverGroup1Properties.ReadWriteEndpoint.FailoverPolicy,
failoverGroup1Properties.ReadWriteEndpoint.FailoverWithDataLossGracePeriodMinutes,
failoverGroup1Properties.PartnerServers.First().ReplicationRole,
failoverGroup1Properties.PartnerServers.First().Id);
//////////////////////////////////////////////////////////////////////
// Get Failover Groups Test.
var failoverGroups = sqlClient.FailoverGroups.List(resGroupName, server.Name);
TestUtilities.ValidateOperationResponse(failoverGroups, HttpStatusCode.OK);
Assert.Equal(2, failoverGroups.FailoverGroups.Count);
//////////////////////////////////////////////////////////////////////
// Delete Failover Group Test.
//var resp = sqlClient.FailoverGroups.Delete(resGroupName, server.Name, failoverGroupName);
//TestUtilities.ValidateOperationResponse(resp, HttpStatusCode.OK);
//var resp2 = sqlClient.FailoverGroups.Delete(resGroupName, server.Name, failoverGroup2Name);
//TestUtilities.ValidateOperationResponse(resp2, HttpStatusCode.OK);
});
}
}
public void FailoverGroupDatabaseOperations()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
string failoverGroupName = TestUtilities.GenerateName("csm-sql-fgdb");
string serverName = TestUtilities.GenerateName("csm-sql-fgdb-server");
var databaseName = TestUtilities.GenerateName("csm-sql-fgdb-db");
var database2Name = TestUtilities.GenerateName("csm-sql-fgdb-db");
Sql2ScenarioHelper.RunServerTestInEnvironment(
handler,
"12.0",
"North Europe",
(sqlClient, resGroupName, server) =>
{
// Variables for partner server create
string serverLocation = "North Europe";
string adminLogin = "******";
string adminPass = "******";
string version = "12.0";
//////////////////////////////////////////////////////////////////////
// Create server for test.
var createServerResponse = sqlClient.Servers.CreateOrUpdate(resGroupName, serverName, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
});
//////////////////////////////////////////////////////////////////////
// Create Failover Group with all values specified (Default values)
ReadOnlyEndpoint readOnlyEndpoint = new ReadOnlyEndpoint();
readOnlyEndpoint.FailoverPolicy = "Disabled";
ReadWriteEndpoint readWriteEndpoint = new ReadWriteEndpoint();
readWriteEndpoint.FailoverPolicy = "Automatic";
readWriteEndpoint.FailoverWithDataLossGracePeriodMinutes = 5;
FailoverGroupPartnerServer partnerServer = new FailoverGroupPartnerServer();
partnerServer.ReplicationRole = "Secondary";
partnerServer.Id = createServerResponse.Server.Id;
partnerServer.Location = "North Europe";
List <FailoverGroupPartnerServer> partnerServers = new List <FailoverGroupPartnerServer>();
partnerServers.Add(partnerServer);
var failoverGroup1Properties = new FailoverGroupCreateOrUpdateProperties()
{
ReadOnlyEndpoint = readOnlyEndpoint,
ReadWriteEndpoint = readWriteEndpoint,
PartnerServers = partnerServers,
};
var failoverGroup1 = sqlClient.FailoverGroups.CreateOrUpdate(resGroupName, server.Name, failoverGroupName, new FailoverGroupCreateOrUpdateParameters()
{
Location = server.Location,
Properties = failoverGroup1Properties
});
TestUtilities.ValidateOperationResponse(failoverGroup1, HttpStatusCode.Created);
////////////////////////////////////////////////////////////////////
// Create database
var db1 = sqlClient.Databases.CreateOrUpdate(resGroupName, server.Name, databaseName, new DatabaseCreateOrUpdateParameters()
{
Location = server.Location,
Properties = new DatabaseCreateOrUpdateProperties()
{
Edition = "Premium"
}
});
TestUtilities.ValidateOperationResponse(db1, HttpStatusCode.Created);
var db2 = sqlClient.Databases.CreateOrUpdate(resGroupName, server.Name, database2Name, new DatabaseCreateOrUpdateParameters()
{
Location = server.Location,
Properties = new DatabaseCreateOrUpdateProperties()
{
Edition = "Basic"
}
});
TestUtilities.ValidateOperationResponse(db2, HttpStatusCode.Created);
//Add database ids into a list
List <string> dbs = new List <string>();
dbs.Add(db1.Database.Id);
dbs.Add(db2.Database.Id);
//////////////////////////////////////////////////////////////////////
// Move database into failover group
var moveResult = sqlClient.FailoverGroups.PatchUpdate(resGroupName, server.Name, failoverGroupName, new FailoverGroupPatchUpdateParameters()
{
Location = server.Location,
Properties = new FailoverGroupPatchUpdateProperties
{
Databases = dbs,
}
});
TestUtilities.ValidateOperationResponse(moveResult, HttpStatusCode.OK);
Assert.True(VerifyDbsEqual(moveResult.FailoverGroup.Properties.Databases, dbs));
//////////////////////////////////////////////////////////////////////
// Delete databases from failover group
dbs.RemoveAt(1);
var removeResult = sqlClient.FailoverGroups.PatchUpdate(resGroupName, server.Name, failoverGroupName, new FailoverGroupPatchUpdateParameters()
{
Location = server.Location,
Properties = new FailoverGroupPatchUpdateProperties
{
Databases = dbs,
}
});
TestUtilities.ValidateOperationResponse(moveResult, HttpStatusCode.OK);
Assert.True(VerifyDbsEqual(removeResult.FailoverGroup.Properties.Databases, dbs));
//////////////////////////////////////////////////////////////////////
// Failover Test.
//var failoverResult = sqlClient.FailoverGroups.Failover(resGroupName, server.Name, failoverGroupName);
//TestUtilities.ValidateOperationResponse(failoverResult, HttpStatusCode.OK);
//var failoverWithDatalossResult = sqlClient.FailoverGroups.ForceFailoverAllowDataLoss(resGroupName, server.Name, failoverGroupName);
//TestUtilities.ValidateOperationResponse(failoverWithDatalossResult, HttpStatusCode.OK);
});
}
}
public void ElasticPoolCrud()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
string resPoolName = TestUtilities.GenerateName("csm-sql-respoolcrud");
string resPool2Name = TestUtilities.GenerateName("csm-sql-respoolcrud");
Sql2ScenarioHelper.RunServerTestInEnvironment(
handler,
"12.0",
(sqlClient, resGroupName, server) =>
{
//////////////////////////////////////////////////////////////////////
// Create Elastic Pool Test with all values specified (Default values)
var pool1Properties = new ElasticPoolCreateOrUpdateProperties()
{
Edition = "Standard",
Dtu = 200,
DatabaseDtuMax = 100,
DatabaseDtuMin = 10,
StorageMB = 204800
};
var pool1 = sqlClient.ElasticPools.CreateOrUpdate(resGroupName, server.Name, resPoolName, new ElasticPoolCreateOrUpdateParameters()
{
Location = server.Location,
Properties = pool1Properties
});
TestUtilities.ValidateOperationResponse(pool1, HttpStatusCode.Created);
ValidateElasticPool(
pool1.ElasticPool,
resPoolName,
pool1Properties.Edition,
pool1Properties.DatabaseDtuMax,
pool1Properties.DatabaseDtuMin,
pool1Properties.Dtu,
pool1Properties.StorageMB);
var pool2Properties = new ElasticPoolCreateOrUpdateProperties()
{
Edition = "Standard",
};
var pool2 = sqlClient.ElasticPools.CreateOrUpdate(resGroupName, server.Name, resPool2Name, new ElasticPoolCreateOrUpdateParameters()
{
Location = server.Location,
Properties = pool2Properties
});
TestUtilities.ValidateOperationResponse(pool2, HttpStatusCode.Created);
ValidateElasticPool(
pool2.ElasticPool,
resPool2Name,
pool1Properties.Edition,
100,
0,
200,
204800);
//////////////////////////////////////////////////////////////////////
// Update Elastic Pool Test
pool1Properties.Dtu = 200;
pool1Properties.DatabaseDtuMax = 50;
pool1Properties.DatabaseDtuMin = 0;
var pool3 = sqlClient.ElasticPools.CreateOrUpdate(resGroupName, server.Name, resPoolName, new ElasticPoolCreateOrUpdateParameters()
{
Location = server.Location,
Properties = pool1Properties
});
TestUtilities.ValidateOperationResponse(pool3, HttpStatusCode.OK);
ValidateElasticPool(
pool3.ElasticPool,
resPoolName,
pool1Properties.Edition,
pool1Properties.DatabaseDtuMax,
pool1Properties.DatabaseDtuMin,
pool1Properties.Dtu,
pool1Properties.StorageMB);
//////////////////////////////////////////////////////////////////////
// Get Elastic Pool Test.
var pool4 = sqlClient.ElasticPools.Get(resGroupName, server.Name, resPoolName);
TestUtilities.ValidateOperationResponse(pool4, HttpStatusCode.OK);
ValidateElasticPool(
pool4.ElasticPool,
resPoolName,
pool3.ElasticPool.Properties.Edition,
pool3.ElasticPool.Properties.DatabaseDtuMax,
pool3.ElasticPool.Properties.DatabaseDtuMin,
pool3.ElasticPool.Properties.Dtu,
pool3.ElasticPool.Properties.StorageMB);
//////////////////////////////////////////////////////////////////////
// Get Elastic Pool Test.
var pools = sqlClient.ElasticPools.List(resGroupName, server.Name);
TestUtilities.ValidateOperationResponse(pools, HttpStatusCode.OK);
Assert.Equal(2, pools.ElasticPools.Count);
//////////////////////////////////////////////////////////////////////
// Get Elastic Pool Activity Test.
var activity = sqlClient.ElasticPools.ListActivity(resGroupName, server.Name, resPoolName);
TestUtilities.ValidateOperationResponse(activity, HttpStatusCode.OK);
Assert.True(activity.ElasticPoolActivities.Count > 0);
//////////////////////////////////////////////////////////////////////
// Delete Elastic Pool Test.
var resp = sqlClient.ElasticPools.Delete(resGroupName, server.Name, pool1.ElasticPool.Name);
TestUtilities.ValidateOperationResponse(resp, HttpStatusCode.OK);
resp = sqlClient.ElasticPools.Delete(resGroupName, server.Name, pool2.ElasticPool.Name);
TestUtilities.ValidateOperationResponse(resp, HttpStatusCode.OK);
});
}
}
public void ElasticPoolDatabaseOperations()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
string resPoolName = TestUtilities.GenerateName("csm-sql-respoolcrud");
Sql2ScenarioHelper.RunServerTestInEnvironment(
handler,
"12.0",
(sqlClient, resGroupName, server) =>
{
//////////////////////////////////////////////////////////////////////
// Create Elastic Pool Test with all values specified (Default values)
var pool1Properties = new ElasticPoolCreateOrUpdateProperties()
{
Edition = "Standard",
Dtu = 200,
DatabaseDtuMax = 100,
DatabaseDtuMin = 10,
StorageMB = 204800
};
var pool1 = sqlClient.ElasticPools.CreateOrUpdate(resGroupName, server.Name, resPoolName, new ElasticPoolCreateOrUpdateParameters()
{
Location = server.Location,
Properties = pool1Properties
});
TestUtilities.ValidateOperationResponse(pool1, HttpStatusCode.Created);
////////////////////////////////////////////////////////////////////
// Create database in Elastic Pool
var databaseName = TestUtilities.GenerateName("csm-sql-respoolcrud");
var db1 = sqlClient.Databases.CreateOrUpdate(resGroupName, server.Name, databaseName, new DatabaseCreateOrUpdateParameters()
{
Location = server.Location,
Properties = new DatabaseCreateOrUpdateProperties()
{
ElasticPoolName = pool1.ElasticPool.Name,
}
});
TestUtilities.ValidateOperationResponse(db1, HttpStatusCode.Created);
//////////////////////////////////////////////////////////////////////
// Move database into Elastic Pool
var database2Name = TestUtilities.GenerateName("csm-sql-respoolcrud");
var db2 = sqlClient.Databases.CreateOrUpdate(resGroupName, server.Name, database2Name, new DatabaseCreateOrUpdateParameters()
{
Location = server.Location,
Properties = new DatabaseCreateOrUpdateProperties()
{
Edition = "Basic"
}
});
TestUtilities.ValidateOperationResponse(db2, HttpStatusCode.Created);
var moveResult = sqlClient.Databases.CreateOrUpdate(resGroupName, server.Name, database2Name, new DatabaseCreateOrUpdateParameters()
{
Location = server.Location,
Properties = new DatabaseCreateOrUpdateProperties()
{
ElasticPoolName = pool1.ElasticPool.Name,
}
});
TestUtilities.ValidateOperationResponse(moveResult, HttpStatusCode.OK);
//////////////////////////////////////////////////////////////////////
// Get database acitivity
var activity = sqlClient.ElasticPools.ListDatabaseActivity(resGroupName, server.Name, resPoolName);
TestUtilities.ValidateOperationResponse(moveResult, HttpStatusCode.OK);
Assert.True(activity.ElasticPoolDatabaseActivities.Count > 0);
});
}
}
public void ServerAdministratorCRUDTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
Sql2ScenarioHelper.RunServerTestInEnvironment(
handler,
"12.0",
"North Europe",
(sqlClient, resGroupName, server) =>
{
string AdministratorDefaultType = "activeDirectory";
string ActiveDirectoryDefaultName = "activeDirectory";
string activeDirectoryServerAdminLogin = "******";
Guid activeDirectoryServerAdminSid = new Guid("4dc34af5-6a71-4838-a983-14cdf8852ff9");
Guid activeDirectoryTenantId = new Guid("A0C03064-E4CB-4AB8-AF32-12203273FF1D");
///////////////////////////////////////////////////////////////////////
// Update Azure SQL Server Active Directory Administrator
var createResponse = sqlClient.ServerAdministrators.CreateOrUpdate(resGroupName, server.Name, ActiveDirectoryDefaultName, new ServerAdministratorCreateOrUpdateParameters()
{
Properties = new ServerAdministratorCreateOrUpdateProperties()
{
Login = activeDirectoryServerAdminLogin,
Sid = activeDirectoryServerAdminSid,
AdministratorType = AdministratorDefaultType,
TenantId = activeDirectoryTenantId,
},
});
TestUtilities.ValidateOperationResponse(createResponse, HttpStatusCode.OK);
VerifyServerAdministratorInformation(activeDirectoryServerAdminLogin, activeDirectoryServerAdminSid, activeDirectoryTenantId, createResponse.ServerAdministrator);
// Get single server active directory administrator
var getAdminResponse = sqlClient.ServerAdministrators.Get(resGroupName, server.Name, ActiveDirectoryDefaultName);
// Verify that the Get request contains the right information.
TestUtilities.ValidateOperationResponse(getAdminResponse, HttpStatusCode.OK);
VerifyServerAdministratorInformation(activeDirectoryServerAdminLogin, activeDirectoryServerAdminSid, activeDirectoryTenantId, getAdminResponse.Administrator);
// Get list Azure SQL Server Active Directory Administrator
var getAdminResponseList = sqlClient.ServerAdministrators.List(resGroupName, server.Name);
//There should only be one Azure SQL Server Active Directory Administrator
Assert.Equal(getAdminResponseList.Administrators.Count, 1);
// Verify that the Get request contains the right information.
TestUtilities.ValidateOperationResponse(getAdminResponseList, HttpStatusCode.OK);
VerifyServerAdministratorInformation(activeDirectoryServerAdminLogin, activeDirectoryServerAdminSid, activeDirectoryTenantId, getAdminResponseList.Administrators[0]);
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
// Delete Azure SQL Server Active Directory Administrator Test
var deleteResponse = sqlClient.ServerAdministrators.Delete(resGroupName, server.Name, ActiveDirectoryDefaultName);
// Verify that the delete operation works.
TestUtilities.ValidateOperationResponse(deleteResponse, HttpStatusCode.NoContent);
/////////////////////////////////////////////////////////////////////
// Verify that the Azure SQL Active Directory administrator is deleted.
var getNoAdminResponse = sqlClient.ServerAdministrators.List(resGroupName, server.Name);
TestUtilities.ValidateOperationResponse(getNoAdminResponse, HttpStatusCode.OK);
// There should be no Azure SQL Server Active Directory Administrator after delete
Assert.Empty(getNoAdminResponse.Administrators);
});
}
}
