public void ElasticPoolMetricsOperations()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// This test requires that an elastic pool has been created and has metrics ready
// To prevent requiring putting something like a Sleep(10 minutes) in the code
// this test requires the server/elastic pool be pre-created with metrics data available.
string resGroupName = "test-group";
string serverName = "groupserver1";
string elasticPoolName = "testpool2";
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var metrics = sqlClient.ElasticPools.ListMetrics(
resGroupName,
serverName,
elasticPoolName,
"name.value eq 'cpu_percent' or name.value eq 'log_write_percent'",
"PT5M",
DateTime.Parse("2015-04-22T04:00:00Z").ToUniversalTime().ToString("O"),
DateTime.Parse("2015-04-22T05:00:00Z").ToUniversalTime().ToString("O"));
TestUtilities.ValidateOperationResponse(metrics, HttpStatusCode.OK);
Assert.True(metrics.Metrics.Count > 0);
}
}
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 DatabaseLTRPolicyTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
string serverName = "hchung-testsvr";
string resGroupName = "hchung";
string databaseName = "hchung-testdb";
sqlClient.DatabaseBackup.CreateOrUpdateDatabaseBackupLongTermRetentionPolicy(resGroupName, serverName, databaseName, "Default", new DatabaseBackupLongTermRetentionPolicyCreateOrUpdateParameters()
{
Location = "North Europe",
Properties = new DatabaseBackupLongTermRetentionPolicyProperties()
{
State = "Enabled",
RecoveryServicesBackupPolicyResourceId = "/subscriptions/e5e8af86-2d93-4ebd-8eb5-3b0184daa9de/resourceGroups/hchung/providers/Microsoft.RecoveryServices/vaults/hchung-testvault/backupPolicies/hchung-testpolicy",
}
});
DatabaseBackupLongTermRetentionPolicyGetResponse resp = sqlClient.DatabaseBackup.GetDatabaseBackupLongTermRetentionPolicy(resGroupName, serverName, databaseName, "Default");
Assert.NotNull(resp.DatabaseBackupLongTermRetentionPolicy.Properties.RecoveryServicesBackupPolicyResourceId);
}
}
public void UpdateState()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var updateParams = new RecommendedIndexUpdateParameters
{
Properties = new RecommendedIndexUpdateProperties
{
State = "Pending"
}
};
var response = sqlClient.RecommendedIndexes.Update(ResourceGroupName, ServerName, DatabaseName, Schema,
TableName, IndexName, updateParams);
var index = response.RecommendedIndex;
ValidateRecommendedIndex(index, "Pending");
updateParams.Properties.State = "Active";
sqlClient.RecommendedIndexes.Update(ResourceGroupName, ServerName, DatabaseName, Schema, TableName,
IndexName, updateParams);
}
}
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 UpdateState()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var updateParams = new RecommendedIndexUpdateParameters
{
Properties = new RecommendedIndexUpdateProperties
{
State = "Pending"
}
};
var response = sqlClient.RecommendedIndexes.Update(ResourceGroupName, ServerName, DatabaseName, Schema,
TableName, IndexName, updateParams);
var index = response.RecommendedIndex;
ValidateRecommendedIndex(index, "Pending");
updateParams.Properties.State = "Active";
sqlClient.RecommendedIndexes.Update(ResourceGroupName, ServerName, DatabaseName, Schema, TableName,
IndexName, updateParams);
}
}
public void ServerLTRVaultTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Use a preconfigured runner server/db in order to test this
// Create a resource group/server/db/vault with the following details prior to running this test
string serverName = "hchung-testsvr";
string resGroupName = "hchung";
sqlClient.DatabaseBackup.CreateOrUpdateBackupLongTermRetentionVault(resGroupName, serverName, "RegisteredVault", new BackupLongTermRetentionVaultCreateOrUpdateParameters()
{
Location = "North Europe",
Properties = new BackupLongTermRetentionVaultProperties()
{
RecoveryServicesVaultResourceId = "/subscriptions/e5e8af86-2d93-4ebd-8eb5-3b0184daa9de/resourceGroups/hchung/providers/Microsoft.RecoveryServices/vaults/hchung-testvault",
}
});
BackupLongTermRetentionVaultGetResponse resp = sqlClient.DatabaseBackup.GetBackupLongTermRetentionVault(resGroupName, serverName, "RegisteredVault");
Assert.NotNull(resp.BackupLongTermRetentionVault.Properties.RecoveryServicesVaultResourceId);
}
}
public void ElasticPoolMetricDefinitionsOperations()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// This test requires that an elastic pool has been created and has metrics ready
// To prevent requiring putting something like a Sleep(10 minutes) in the code
// this test requires the server/elastic pool be pre-created with metrics data available.
string resGroupName = "test-group";
string serverName = "groupserver1";
string elasticPoolName = "testpool2";
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var metrics = sqlClient.ElasticPools.ListMetricDefinitions(
resGroupName,
serverName,
elasticPoolName);
TestUtilities.ValidateOperationResponse(metrics, HttpStatusCode.OK);
Assert.True(metrics.MetricDefinitions.Count > 0);
}
}
public void GeoBackupPolicyTest()
{
// Test params
string resourceGroupName = "TestRG";
string serverName = "testsvr-alazad";
string databaseName = "testdwdb";
string serverLocation = "North Europe";
string geoBackupPolicyName = "Default";
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Retrieve current state of the policy
GeoBackupPolicyGetResponse resp = sqlClient.DatabaseBackup.GetGeoBackupPolicy(resourceGroupName, serverName, databaseName, geoBackupPolicyName);
GeoBackupPolicy initialGeoBackupPolicy = resp.GeoBackupPolicy;
Assert.NotNull(initialGeoBackupPolicy);
// Disable policy
sqlClient.DatabaseBackup.CreateOrUpdateGeoBackupPolicy(resourceGroupName, serverName, databaseName, geoBackupPolicyName, new GeoBackupPolicyCreateOrUpdateParameters
{
Location = serverLocation,
Properties = new GeoBackupPolicyProperties()
{
State = "Disabled",
}
});
// Verify policy is Disabled
resp = sqlClient.DatabaseBackup.GetGeoBackupPolicy(resourceGroupName, serverName, databaseName, geoBackupPolicyName);
Assert.Equal("Disabled", resp.GeoBackupPolicy.Properties.State);
// Enable policy
sqlClient.DatabaseBackup.CreateOrUpdateGeoBackupPolicy(resourceGroupName, serverName, databaseName, geoBackupPolicyName, new GeoBackupPolicyCreateOrUpdateParameters
{
Location = serverLocation,
Properties = new GeoBackupPolicyProperties()
{
State = "Enabled",
}
});
// Verify policy is Enabled
resp = sqlClient.DatabaseBackup.GetGeoBackupPolicy(resourceGroupName, serverName, databaseName, geoBackupPolicyName);
Assert.Equal("Enabled", resp.GeoBackupPolicy.Properties.State);
// Reset policy to its original value
sqlClient.DatabaseBackup.CreateOrUpdateGeoBackupPolicy(resourceGroupName, serverName, databaseName, geoBackupPolicyName, new GeoBackupPolicyCreateOrUpdateParameters
{
Location = serverLocation,
Properties = initialGeoBackupPolicy.Properties,
});
}
}
public void ServerCommunicationLinkCrud()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
string commLinkName = TestUtilities.GenerateName("csm-sql-commlinkcrud-");
Sql2ScenarioHelper.RunTwoServersTestInEnvironment(
handler,
"12.0",
false,
(sqlClient, resGroupName, server1, server2) =>
{
//////////////////////////////////////////////////////////////////////
// Create Test
var linkProperties = new ServerCommunicationLinkCreateOrUpdateProperties()
{
PartnerServer = server2.Name
};
var link1 = sqlClient.CommunicationLinks.CreateOrUpdate(resGroupName, server1.Name, commLinkName, new ServerCommunicationLinkCreateOrUpdateParameters()
{
Location = server1.Location,
Properties = linkProperties
});
TestUtilities.ValidateOperationResponse(link1, HttpStatusCode.Created);
ValidateServerCommunicationLink(
link1.ServerCommunicationLink,
commLinkName,
linkProperties.PartnerServer);
//////////////////////////////////////////////////////////////////////
// Get Test.
var link2 = sqlClient.CommunicationLinks.Get(resGroupName, server1.Name, commLinkName);
TestUtilities.ValidateOperationResponse(link2, HttpStatusCode.OK);
ValidateServerCommunicationLink(
link2.ServerCommunicationLink,
commLinkName,
linkProperties.PartnerServer);
//////////////////////////////////////////////////////////////////////
// List Test.
var links = sqlClient.CommunicationLinks.List(resGroupName, server1.Name);
TestUtilities.ValidateOperationResponse(links, HttpStatusCode.OK);
Assert.Equal(1, links.ServerCommunicationLinks.Count);
//////////////////////////////////////////////////////////////////////
// Delete Test.
var resp = sqlClient.CommunicationLinks.Delete(resGroupName, server1.Name, link1.ServerCommunicationLink.Name);
TestUtilities.ValidateOperationResponse(resp, HttpStatusCode.OK);
});
}
}
public void ServerCommunicationLinkCrud()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
string commLinkName = TestUtilities.GenerateName("csm-sql-commlinkcrud-");
Sql2ScenarioHelper.RunTwoServersTestInEnvironment(
handler,
"12.0",
false,
(sqlClient, resGroupName, server1, server2) =>
{
//////////////////////////////////////////////////////////////////////
// Create Test
var linkProperties = new ServerCommunicationLinkCreateOrUpdateProperties()
{
PartnerServer = server2.Name
};
var link1 = sqlClient.CommunicationLinks.CreateOrUpdate(resGroupName, server1.Name, commLinkName, new ServerCommunicationLinkCreateOrUpdateParameters()
{
Location = server1.Location,
Properties = linkProperties
});
TestUtilities.ValidateOperationResponse(link1, HttpStatusCode.Created);
ValidateServerCommunicationLink(
link1.ServerCommunicationLink,
commLinkName,
linkProperties.PartnerServer);
//////////////////////////////////////////////////////////////////////
// Get Test.
var link2 = sqlClient.CommunicationLinks.Get(resGroupName, server1.Name, commLinkName);
TestUtilities.ValidateOperationResponse(link2, HttpStatusCode.OK);
ValidateServerCommunicationLink(
link2.ServerCommunicationLink,
commLinkName,
linkProperties.PartnerServer);
//////////////////////////////////////////////////////////////////////
// List Test.
var links = sqlClient.CommunicationLinks.List(resGroupName, server1.Name);
TestUtilities.ValidateOperationResponse(links, HttpStatusCode.OK);
Assert.Equal(1, links.ServerCommunicationLinks.Count);
//////////////////////////////////////////////////////////////////////
// Delete Test.
var resp = sqlClient.CommunicationLinks.Delete(resGroupName, server1.Name, link1.ServerCommunicationLink.Name);
TestUtilities.ValidateOperationResponse(resp, HttpStatusCode.OK);
});
}
}
/// <summary>
/// Responsible for creating a resource group, and within it two SQL database servers, as well as creating a SqlClient for the given handler.
/// Once these are created, this method calls the given test with the created sql client, the names of the resource group and servers.
/// This method does not removes the created resources !!! it should be run in an undo context that wraps the call to this method.
/// </summary>
/// <param name="handler">A delegation handler to create a Sql client based on it</param>
/// <param name="serverVersion">The version of the server being created</param>
/// <param name="serverLocation">The location of the server being created</param>
/// <param name="secondaryServerLocation">The location of the second server being created</param>
/// <param name="test">A function that receives a sql client, names of a created resource group and server</param>
public static void RunTwoServersTestInEnvironment(BasicDelegatingHandler handler, string serverVersion, string serverLocation, string secondaryServerLocation, Action <SqlManagementClient, string, Server, Server> test)
{
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Variables for server create.
string resGroupName = TestUtilities.GenerateName("csm-sql-rg-");
string server1Name = TestUtilities.GenerateName("csm-sql-server-");
string server2Name = TestUtilities.GenerateName("csm-sql-server-");
string adminLogin = "******";
string adminPass = "******";
string version = serverVersion;
// Create the resource group(s)
resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup()
{
Location = serverLocation,
});
try
{
//////////////////////////////////////////////////////////////////////
// Create servers for test.
var server1 =
sqlClient.Servers.CreateOrUpdate(resGroupName, server1Name, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
}).Server;
var server2 =
sqlClient.Servers.CreateOrUpdate(resGroupName, server2Name, new ServerCreateOrUpdateParameters()
{
Location = secondaryServerLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
}).Server;
test(sqlClient, resGroupName, server1, server2);
}
finally
{
// Clean up the resource group(s)
resClient.ResourceGroups.DeleteAsync(resGroupName);
}
}
public void GetSingleRecommendedActionForServerAdvisor()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var response = sqlClient.ServerRecommendedActions.Get(ResourceGroupName, ServerName, AdvisorName, RecommendedActionName);
ValidateSingleRecommendedAction(response.RecommendedAction, ServerRecommendedActionType);
}
}
public void GetSingleAdvisorForServer()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var response = sqlClient.ServerAdvisors.Get(ResourceGroupName, ServerName, AdvisorName, expand: null);
ValidateSingleAdvisor(response.Advisor, ServerAdvisorType);
}
}
public void ListAdvisorsForElasticPool()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var response = sqlClient.ElasticPoolAdvisors.List(ResourceGroupName, ServerName, ElasticPoolName, expand: null);
ValidateAdvisorList(response.Advisors, ElasticPoolAdvisorType);
}
}
public void GetSingleAdvisorForServer()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var response = sqlClient.ServerAdvisors.Get(ResourceGroupName, ServerName, AdvisorName, expand: null);
ValidateSingleAdvisor(response.Advisor, ServerAdvisorType);
}
}
public void ListRecommendedActionsForDatabaseAdvisor()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var response = sqlClient.DatabaseRecommendedActions.List(ResourceGroupName, ServerName, DatabaseName, AdvisorName);
ValidateRecommendedActionList(response.RecommendedActions, DatabaseRecommendedActionType);
}
}
public void GetSingleRecommendedActionForServerAdvisor()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var response = sqlClient.ServerRecommendedActions.Get(ResourceGroupName, ServerName, AdvisorName, RecommendedActionName);
ValidateSingleRecommendedAction(response.RecommendedAction, ServerRecommendedActionType);
}
}
public void ListAdvisorsForServerExpandedWithRecommendedActions()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var response = sqlClient.ServerAdvisors.List(ResourceGroupName, ServerName, expand: ExpandKey);
ValidateAdvisorList(response.Advisors, ServerAdvisorType);
ValidatePresenceOfRecommendedActions(response);
}
}
public void ListAdvisorsForServerExpandedWithRecommendedActions()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var response = sqlClient.ServerAdvisors.List(ResourceGroupName, ServerName, expand: ExpandKey);
ValidateAdvisorList(response.Advisors, ServerAdvisorType);
ValidatePresenceOfRecommendedActions(response);
}
}
public void ListAllIndexesForServer()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var response = sqlClient.Databases.ListExpanded(ResourceGroupName, ServerName, Expand);
var index =
response.Databases[1].Properties.Schemas[0].Properties.Tables[0].Properties.RecommendedIndexes[0];
ValidateRecommendedIndex(index, "Active");
}
}
public void GetSingleRecommendation()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var response = sqlClient.RecommendedIndexes.Get(ResourceGroupName, ServerName, DatabaseName, Schema,
TableName, IndexName);
var index = response.RecommendedIndex;
ValidateRecommendedIndex(index, "Active");
}
}
public void RestoreTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Variables for server creation.
string serverName = "hchung-testsvr2";
string resGroupName = "hchung-test2";
string standardDatabaseName = "hchung-testdb-geo2";
string serverLocation = "Southeast Asia";
// Create or update standard database
var createDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, standardDatabaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
},
});
TestUtilities.ValidateOperationResponse(createDbResponse, HttpStatusCode.Created);
//////////////////////////////////////////////////////////////////////
string databaseId = createDbResponse.Database.Id;
// If first run on a live cluster, wait 10 minutes for backup to be taken (set a breakpoint to stop execution here). The time of the restore will also need to be updated if running on a a live cluster.
string timeString = "2016-02-24T00:00:00";
DateTime restorePointInTime = DateTime.Parse(timeString);
var restoreDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, standardDatabaseName + "_" + timeString, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
SourceDatabaseId = databaseId,
RestorePointInTime = restorePointInTime,
CreateMode = "PointInTimeRestore"
}
});
TestUtilities.ValidateOperationResponse(restoreDbResponse, HttpStatusCode.Created);
}
}
public void ListAllIndexesForServer()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var response = sqlClient.Databases.ListExpanded(ResourceGroupName, ServerName, Expand);
var index =
response.Databases[1].Properties.Schemas[0].Properties.Tables[0].Properties.RecommendedIndexes[0];
ValidateRecommendedIndex(index, "Active");
}
}
public void GetSingleRecommendation()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var response = sqlClient.RecommendedIndexes.Get(ResourceGroupName, ServerName, DatabaseName, Schema,
TableName, IndexName);
var index = response.RecommendedIndex;
ValidateRecommendedIndex(index, "Active");
}
}
public void ServerDisasterRecoveryConfigurationCrud()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
string failoverAliasName = TestUtilities.GenerateName("csm-sql-drc-alias-");
Sql2ScenarioHelper.RunTwoServersTestInEnvironment(
handler,
"12.0",
true,
(sqlClient, resGroupName, server1, server2) =>
{
validateDrcNotExist(sqlClient, resGroupName, server1.Name, failoverAliasName);
validateDrcNotExist(sqlClient, resGroupName, server2.Name, failoverAliasName);
// Create and verify
//
ServerDisasterRecoveryConfigurationCreateOrUpdateResponse createResponse = CreateDrc(sqlClient, resGroupName, server1, server2, failoverAliasName);
TestUtilities.ValidateOperationResponse(createResponse, HttpStatusCode.Created);
GetAndValidateDrc(sqlClient, resGroupName, server1.Name, failoverAliasName, server2.Name, true);
GetAndValidateDrc(sqlClient, resGroupName, server2.Name, failoverAliasName, server1.Name, false);
// Invalid failover, then valid failover and verify
//
Assert.Throws<Hyak.Common.CloudException>(() => sqlClient.ServerDisasterRecoveryConfigurations.Failover(resGroupName, server1.Name, failoverAliasName));
AzureOperationResponse failoverResponse = sqlClient.ServerDisasterRecoveryConfigurations.Failover(resGroupName, server2.Name, failoverAliasName);
TestUtilities.ValidateOperationResponse(failoverResponse);
GetAndValidateDrc(sqlClient, resGroupName, server1.Name, failoverAliasName, server2.Name, false);
GetAndValidateDrc(sqlClient, resGroupName, server2.Name, failoverAliasName, server1.Name, true);
// Delete and verify
//
AzureOperationResponse deleteResponse = sqlClient.ServerDisasterRecoveryConfigurations.Delete(resGroupName, server1.Name, failoverAliasName);
TestUtilities.ValidateOperationResponse(deleteResponse);
validateDrcNotExist(sqlClient, resGroupName, server1.Name, failoverAliasName);
validateDrcNotExist(sqlClient, resGroupName, server2.Name, failoverAliasName);
});
}
}
public void ServerDisasterRecoveryConfigurationCrud()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
string failoverAliasName = TestUtilities.GenerateName("csm-sql-drc-alias-");
Sql2ScenarioHelper.RunTwoServersTestInEnvironment(
handler,
"12.0",
true,
(sqlClient, resGroupName, server1, server2) =>
{
validateDrcNotExist(sqlClient, resGroupName, server1.Name, failoverAliasName);
validateDrcNotExist(sqlClient, resGroupName, server2.Name, failoverAliasName);
// Create and verify
//
ServerDisasterRecoveryConfigurationCreateOrUpdateResponse createResponse = CreateDrc(sqlClient, resGroupName, server1, server2, failoverAliasName);
TestUtilities.ValidateOperationResponse(createResponse, HttpStatusCode.Created);
GetAndValidateDrc(sqlClient, resGroupName, server1.Name, failoverAliasName, server2.Name, true);
GetAndValidateDrc(sqlClient, resGroupName, server2.Name, failoverAliasName, server1.Name, false);
// Invalid failover, then valid failover and verify
//
Assert.Throws <Hyak.Common.CloudException>(() => sqlClient.ServerDisasterRecoveryConfigurations.Failover(resGroupName, server1.Name, failoverAliasName));
AzureOperationResponse failoverResponse = sqlClient.ServerDisasterRecoveryConfigurations.Failover(resGroupName, server2.Name, failoverAliasName);
TestUtilities.ValidateOperationResponse(failoverResponse);
GetAndValidateDrc(sqlClient, resGroupName, server1.Name, failoverAliasName, server2.Name, false);
GetAndValidateDrc(sqlClient, resGroupName, server2.Name, failoverAliasName, server1.Name, true);
// Delete and verify
//
AzureOperationResponse deleteResponse = sqlClient.ServerDisasterRecoveryConfigurations.Delete(resGroupName, server1.Name, failoverAliasName);
TestUtilities.ValidateOperationResponse(deleteResponse);
validateDrcNotExist(sqlClient, resGroupName, server1.Name, failoverAliasName);
validateDrcNotExist(sqlClient, resGroupName, server2.Name, failoverAliasName);
});
}
}
public void UpdateStatusOfServerAdvisor()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
AdvisorUpdateParameters updateParameters = new AdvisorUpdateParameters()
{
Properties = new AdvisorUpdateProperties()
{
AutoExecuteStatus = "Disabled"
}
};
var response = sqlClient.ServerAdvisors.Update(ResourceGroupName, ServerName, AdvisorName, updateParameters);
ValidateSingleAdvisor(response.Advisor, ServerAdvisorType, expectedAutoExecuteStatus: "Disabled");
}
}
/// <summary>
/// Responsible for creating a resource group, and within it a SQL database server, as well as creating a SqlClient for the given handler.
/// Once these are created, this method calls the given test with the created sql client, the names of the resource group and server.
/// This method does not removes the created resources !!! it should be run in an undo context that wraps the call to this method.
/// </summary>
/// <param name="handler">A delegation handler to create a Sql client based on it</param>
/// <param name="serverVersion">The version of the server being created</param>
/// <param name="serverLocation">The location of the server being created</param>
/// <param name="test">A function that receives a sql client, names of a created resource group and server</param>
public static void RunServerTestInEnvironment(BasicDelegatingHandler handler, string serverVersion, string serverLocation, Action<SqlManagementClient, string, Server> test)
{
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Variables for server create
string serverName = TestUtilities.GenerateName("csm-sql-server-");
string resGroupName = TestUtilities.GenerateName("csm-sql-rg-");
string adminLogin = "******";
string adminPass = "******";
string version = serverVersion;
// Create the resource group.
resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup()
{
Location = serverLocation,
});
try
{
//////////////////////////////////////////////////////////////////////
// Create server for test.
var server = sqlClient.Servers.CreateOrUpdate(resGroupName, serverName, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
}).Server;
test(sqlClient, resGroupName, server);
}
finally
{
// Clean up the resource group.
resClient.ResourceGroups.Delete(resGroupName);
}
}
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);
});
}
}
private static ServerGetResponse CreateServerForTest(string resGroupName, string serverName, string serverLocation)
{
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
string adminLogin = "******";
string adminPass = "******";
string version = "12.0";
return(sqlClient.Servers.CreateOrUpdate(resGroupName, serverName, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
}));
}
private static DatabaseCreateOrUpdateResponse CreateDatabaseForTest(string resGroupName, string serverName, string databaseName, string serverLocation)
{
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
string databaseCollation = "SQL_Latin1_General_CP1_CI_AS";
string databaseEdition = "Standard";
long databaseMaxSize = 5L * 1024L * 1024L * 1024L; // 5 GB
return(sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, databaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
Collation = databaseCollation,
Edition = databaseEdition,
MaxSizeBytes = databaseMaxSize,
RequestedServiceObjectiveId = SqlConstants.DbSloS1
},
}));
}
public void UpdateServerRecommendedActionState()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
RecommendedActionUpdateParameters updateParameters = new RecommendedActionUpdateParameters()
{
Properties = new RecommendedActionUpdateProperties()
{
State = new RecommendedActionUpdateStateInfo()
{
CurrentValue = "Pending"
}
}
};
var response = sqlClient.ServerRecommendedActions.Update(ResourceGroupName, ServerName, AdvisorName, RecommendedActionName, updateParameters);
ValidateSingleRecommendedAction(response.RecommendedAction, ServerRecommendedActionType, expectedState: "Pending");
}
}
public void UpdateServerRecommendedActionState()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
RecommendedActionUpdateParameters updateParameters = new RecommendedActionUpdateParameters()
{
Properties = new RecommendedActionUpdateProperties()
{
State = new RecommendedActionUpdateStateInfo()
{
CurrentValue = "Pending"
}
}
};
var response = sqlClient.ServerRecommendedActions.Update(ResourceGroupName, ServerName, AdvisorName, RecommendedActionName, updateParameters);
ValidateSingleRecommendedAction(response.RecommendedAction, ServerRecommendedActionType, expectedState: "Pending");
}
}
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 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 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 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 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 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 RestoreTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Variables for server creation.
string serverName = "hchung-testsvr2";
string resGroupName = "hchung-test2";
string standardDatabaseName = "hchung-testdb-geo2";
string serverLocation = "Southeast Asia";
// Create or update standard database
var createDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, standardDatabaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
},
});
TestUtilities.ValidateOperationResponse(createDbResponse, HttpStatusCode.Created);
//////////////////////////////////////////////////////////////////////
string databaseId = createDbResponse.Database.Id;
// If first run on a live cluster, wait 10 minutes for backup to be taken (set a breakpoint to stop execution here). The time of the restore will also need to be updated if running on a a live cluster.
string timeString = "2016-02-24T00:00:00";
DateTime restorePointInTime = DateTime.Parse(timeString);
var restoreDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, standardDatabaseName + "_" + timeString, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
SourceDatabaseId = databaseId,
RestorePointInTime = restorePointInTime,
CreateMode = "PointInTimeRestore"
}
});
TestUtilities.ValidateOperationResponse(restoreDbResponse, HttpStatusCode.Created);
}
}
public void ListDeletedDatabaseBackupTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Variables for server creation.
string serverName = "csm-sql-backup31415";
string resGroupName = "csm-rg-backup31415";
string serverLocation = "North Europe";
string adminLogin = "******";
string adminPass = "******";
string version = "12.0";
// Constants for Azure SQL standard database creation.
var standardDefaultDatabaseSize = 1L * 1024L * 1024L * 1024L; // 1 GB
var standardDatabaseName = "csm-sql-backup-db31415";
string standardDatabaseEdition = "Standard";
// Create the resource group.
resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup()
{
Location = serverLocation,
});
//////////////////////////////////////////////////////////////////////
// Create server for test.
var createResponse = sqlClient.Servers.CreateOrUpdate(resGroupName, serverName, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
});
// Verify the the response from the service contains the right information
TestUtilities.ValidateOperationResponse(createResponse, HttpStatusCode.Created);
//////////////////////////////////////////////////////////////////////
// Create standard database
var createDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, standardDatabaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
MaxSizeBytes = standardDefaultDatabaseSize,
Edition = standardDatabaseEdition,
RequestedServiceObjectiveId = SqlConstants.DbSloS0,
},
});
TestUtilities.ValidateOperationResponse(createDbResponse, HttpStatusCode.Created);
//////////////////////////////////////////////////////////////////////
// If first run on a live cluster, wait 10 minutes for backup to be taken (set a breakpoint to stop execution here)
var deleteDbResponse = sqlClient.Databases.Delete(resGroupName, serverName, standardDatabaseName);
TestUtilities.ValidateOperationResponse(deleteDbResponse, HttpStatusCode.OK);
DeletedDatabaseBackupListResponse deletedDatabaseBackups = sqlClient.DatabaseBackup.ListDeletedDatabaseBackups(resGroupName, serverName);
Assert.True(deletedDatabaseBackups.DeletedDatabaseBackups.Count > 0);
var restoreDroppedDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, standardDatabaseName + "_restored", new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
SourceDatabaseId = deletedDatabaseBackups.DeletedDatabaseBackups[0].Id,
RestorePointInTime = deletedDatabaseBackups.DeletedDatabaseBackups[0].Properties.DeletionDate,
CreateMode = "Restore"
}
});
TestUtilities.ValidateOperationResponse(restoreDroppedDbResponse, HttpStatusCode.Created);
}
}
public void ListGeoBackupsTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Use a preconfigured runner server/db in order to test this
// Create a resource group/server/db with the following details prior to running this test
// If first run on a live cluster, wait several hours for the geo pair to be created
string serverName = "csm-sql-backup-geo31415seasia";
string resGroupName = "csm-rg-backup-geo31415seasia";
string serverLocation = "Southeast Asia";
string standardDatabaseName = "csm-sql-backup-geo-db31415";
string adminLogin = "******";
string adminPass = "******";
string version = "12.0";
var standardDefaultDatabaseSize = 1L * 1024L * 1024L * 1024L; // 1 GB
string standardDatabaseEdition = "Standard";
// Create the resource group.
resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup()
{
Location = serverLocation,
});
var createResponse = sqlClient.Servers.CreateOrUpdate(resGroupName, serverName, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
});
var createDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, standardDatabaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
MaxSizeBytes = standardDefaultDatabaseSize,
Edition = standardDatabaseEdition,
RequestedServiceObjectiveId = SqlConstants.DbSloS0,
},
});
GeoBackupListResponse geoBackups = sqlClient.DatabaseBackup.ListGeoBackups(resGroupName, serverName);
Assert.True(geoBackups.GeoBackups.Count >= 1);
var geoRestoreDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, standardDatabaseName + "_georestored", new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
SourceDatabaseId = geoBackups.GeoBackups[0].Id,
CreateMode = "Recovery"
}
});
TestUtilities.ValidateOperationResponse(geoRestoreDbResponse, HttpStatusCode.Created);
}
}
public void ListDeletedDatabaseBackupTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Variables for server creation.
string serverName = "csm-sql-backup31415";
string resGroupName = "csm-rg-backup31415";
string serverLocation = "North Europe";
string adminLogin = "******";
string adminPass = "******";
string version = "12.0";
// Constants for Azure SQL standard database creation.
var standardDefaultDatabaseSize = 1L * 1024L * 1024L * 1024L; // 1 GB
Guid dbSloS0 = new Guid("f1173c43-91bd-4aaa-973c-54e79e15235b "); // S0
var standardDatabaseName = "csm-sql-backup-db31415";
string standardDatabaseEdition = "Standard";
// Create the resource group.
resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup()
{
Location = serverLocation,
});
//////////////////////////////////////////////////////////////////////
// Create server for test.
var createResponse = sqlClient.Servers.CreateOrUpdate(resGroupName, serverName, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
});
// Verify the the response from the service contains the right information
TestUtilities.ValidateOperationResponse(createResponse, HttpStatusCode.Created);
//////////////////////////////////////////////////////////////////////
// Create standard database
var createDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, standardDatabaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
MaxSizeBytes = standardDefaultDatabaseSize,
Edition = standardDatabaseEdition,
RequestedServiceObjectiveId = dbSloS0,
},
});
TestUtilities.ValidateOperationResponse(createDbResponse, HttpStatusCode.Created);
//////////////////////////////////////////////////////////////////////
// If first run on a live cluster, wait 10 minutes for backup to be taken (set a breakpoint to stop execution here)
var deleteDbResponse = sqlClient.Databases.Delete(resGroupName, serverName, standardDatabaseName);
TestUtilities.ValidateOperationResponse(deleteDbResponse, HttpStatusCode.OK);
DeletedDatabaseBackupListResponse deletedDatabaseBackups = sqlClient.DatabaseBackup.ListDeletedDatabaseBackups(resGroupName, serverName);
Assert.True(deletedDatabaseBackups.DeletedDatabaseBackups.Count > 0);
var restoreDroppedDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, standardDatabaseName + "_restored", new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
SourceDatabaseId = deletedDatabaseBackups.DeletedDatabaseBackups[0].Id,
RestorePointInTime = deletedDatabaseBackups.DeletedDatabaseBackups[0].Properties.DeletionDate,
CreateMode = "Restore"
}
});
TestUtilities.ValidateOperationResponse(restoreDroppedDbResponse, HttpStatusCode.Created);
}
}
public void ListRestorePointsTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Variables for server creation.
string serverName = TestUtilities.GenerateName("csm-sql-backup");
string resGroupName = TestUtilities.GenerateName("csm-rg-backup");
string serverLocation = "Japan East";
string adminLogin = "******";
string adminPass = "******";
string version = "12.0";
// Constants for Azure SQL Data Warehouse database creation.
var defaultDatabaseSize = 250L * 1024L * 1024L * 1024L; // 250 GB
Guid dwSlo = new Guid("4E63CB0E-91B9-46FD-B05C-51FDD2367618 "); // DW100
var databaseName = TestUtilities.GenerateName("csm-sql-backup-dwdb");
string databaseEdition = "DataWarehouse";
// Constants for Azure SQL standard database creation.
var standardDefaultDatabaseSize = 1L * 1024L * 1024L * 1024L; // 1 GB
Guid dbSloS0 = new Guid("f1173c43-91bd-4aaa-973c-54e79e15235b "); // S0
var standardDatabaseName = TestUtilities.GenerateName("csm-sql-backup-db");
string standardDatabaseEdition = "Standard";
// Create the resource group.
resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup()
{
Location = serverLocation,
});
try
{
//////////////////////////////////////////////////////////////////////
// Create server for test.
var createResponse = sqlClient.Servers.CreateOrUpdate(resGroupName, serverName, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
});
// Verify the the response from the service contains the right information
TestUtilities.ValidateOperationResponse(createResponse, HttpStatusCode.Created);
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Create database test.
// Create data warehouse database
var createDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, databaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
MaxSizeBytes = defaultDatabaseSize,
Edition = databaseEdition,
RequestedServiceObjectiveId = dwSlo,
},
});
TestUtilities.ValidateOperationResponse(createDbResponse, HttpStatusCode.Created);
// Create standard database
createDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, standardDatabaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
MaxSizeBytes = standardDefaultDatabaseSize,
Edition = standardDatabaseEdition,
RequestedServiceObjectiveId = dbSloS0,
},
});
TestUtilities.ValidateOperationResponse(createDbResponse, HttpStatusCode.Created);
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Get restore points for data warehouse database.
RestorePointListResponse restorePointsListResponse = sqlClient.DatabaseBackup.ListRestorePoints(resGroupName, serverName, databaseName);
// Creating a data warehouse database should not have any discrete restore points right after.
TestUtilities.ValidateOperationResponse(restorePointsListResponse, HttpStatusCode.OK);
ValidateRestorePointListResponse(restorePointsListResponse, true, 0);
///////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Get restore points for standard database.
restorePointsListResponse = sqlClient.DatabaseBackup.ListRestorePoints(resGroupName, serverName, standardDatabaseName);
TestUtilities.ValidateOperationResponse(restorePointsListResponse, HttpStatusCode.OK);
ValidateRestorePointListResponse(restorePointsListResponse, false, 1);
///////////////////////////////////////////////////////////////////////
}
finally
{
// Clean up the resource group.
resClient.ResourceGroups.Delete(resGroupName);
}
}
}
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 FirewallCRUDTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Variables for server create
string serverName = TestUtilities.GenerateName("csm-sql-firewallcrud");
string resGroupName = TestUtilities.GenerateName("csm-rg-firewallcrud");
string serverLocation = "West US";
string adminLogin = "******";
string adminPass = "******";
string version = "12.0";
// Create the resource group.
resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup()
{
Location = serverLocation,
});
try
{
//////////////////////////////////////////////////////////////////////
// Create server for test.
var createResponse = sqlClient.Servers.CreateOrUpdate(resGroupName, serverName, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
});
// Verify the the response from the service contains the right information
TestUtilities.ValidateOperationResponse(createResponse, HttpStatusCode.Created);
VerifyServerInformation(serverName, serverLocation, adminLogin, adminPass, version, createResponse.Server);
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Create firewall test.
string firewallRuleName = TestUtilities.GenerateName("sql-fwrule");
string startIp1 = "1.2.3.4";
string endIp1 = "2.3.4.5";
string startIp2 = "10.20.30.40";
string endIp2 = "20.30.40.50";
// Create standard firewall rule.
var firewallCreate = sqlClient.FirewallRules.CreateOrUpdate(resGroupName, serverName, firewallRuleName, new FirewallRuleCreateOrUpdateParameters()
{
Properties = new FirewallRuleCreateOrUpdateProperties()
{
StartIpAddress = startIp1,
EndIpAddress = endIp1,
}
});
TestUtilities.ValidateOperationResponse(firewallCreate, HttpStatusCode.Created);
FirewallRule rule = firewallCreate.FirewallRule;
VerifyFirewallRuleInformation(firewallRuleName, startIp1, endIp1, rule);
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Get firewall Test
// Get single firewall rule
var getFirewall = sqlClient.FirewallRules.Get(resGroupName, serverName, firewallRuleName);
// Verify that the Get request contains the right information.
TestUtilities.ValidateOperationResponse(getFirewall, HttpStatusCode.OK);
VerifyFirewallRuleInformation(firewallRuleName, startIp1, endIp1, getFirewall.FirewallRule);
// List all firewall rules
var listResponse = sqlClient.FirewallRules.List(resGroupName, serverName);
TestUtilities.ValidateOperationResponse(listResponse);
Assert.Equal(1, listResponse.FirewallRules.Count);
VerifyFirewallRuleInformation(firewallRuleName, startIp1, endIp1, listResponse.FirewallRules[0]);
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
// Update firewall Test
var updateResponse = sqlClient.FirewallRules.CreateOrUpdate(resGroupName, serverName, firewallRuleName, new FirewallRuleCreateOrUpdateParameters()
{
Properties = new FirewallRuleCreateOrUpdateProperties()
{
StartIpAddress = startIp2,
EndIpAddress = endIp2,
},
});
TestUtilities.ValidateOperationResponse(updateResponse, HttpStatusCode.OK);
VerifyFirewallRuleInformation(firewallRuleName, startIp2, endIp2, updateResponse.FirewallRule);
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
// Delete firewall Test
var deleteResponse = sqlClient.FirewallRules.Delete(resGroupName, serverName, firewallRuleName);
// Verify that the delete operation works.
TestUtilities.ValidateOperationResponse(deleteResponse, HttpStatusCode.OK);
/////////////////////////////////////////////////////////////////////
}
finally
{
// Clean up the resource group.
resClient.ResourceGroups.Delete(resGroupName);
}
}
}
public void DatabaseActivationTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Variables for server creation.
string serverName = TestUtilities.GenerateName("csm-sql-activation");
string resGroupName = TestUtilities.GenerateName("csm-rg-activation");
string serverLocation = "Southeast Asia";
string adminLogin = "******";
string adminPass = "******";
string version = "12.0";
// Constants for database creation.
var defaultDatabaseSize = 250L * 1024L * 1024L * 1024L; // 250 GB
Guid dwSlo = new Guid("4E63CB0E-91B9-46FD-B05C-51FDD2367618 "); // DW100
var defaultCollation = "SQL_Latin1_General_CP1_CI_AS";
var databaseName = TestUtilities.GenerateName("csm-sql-activation-db");
string databaseEdition = "DataWarehouse";
// Create the resource group.
resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup()
{
Location = serverLocation,
});
try
{
//////////////////////////////////////////////////////////////////////
// Create server for test.
var createResponse = sqlClient.Servers.CreateOrUpdate(resGroupName, serverName, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
});
// Verify the the response from the service contains the right information
TestUtilities.ValidateOperationResponse(createResponse, HttpStatusCode.Created);
VerifyServerInformation(serverName, serverLocation, adminLogin, adminPass, version, createResponse.Server);
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Create database test.
// Create only required
var createDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, databaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
MaxSizeBytes = defaultDatabaseSize,
Edition = databaseEdition,
RequestedServiceObjectiveId = dwSlo,
},
});
TestUtilities.ValidateOperationResponse(createDbResponse, HttpStatusCode.Created);
VerifyDatabaseInformation(createDbResponse.Database, serverLocation, defaultCollation, databaseEdition, defaultDatabaseSize, dwSlo, dwSlo);
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Pause database.
var pauseResponse = sqlClient.DatabaseActivation.Pause(resGroupName, serverName, databaseName);
TestUtilities.ValidateOperationResponse(pauseResponse, HttpStatusCode.OK);
VerifyDatabaseInformation(pauseResponse.Database, serverLocation, defaultCollation, databaseEdition, defaultDatabaseSize, dwSlo, dwSlo, "Paused");
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
// Resume database.
var resumeResponse = sqlClient.DatabaseActivation.Resume(resGroupName, serverName, databaseName);
TestUtilities.ValidateOperationResponse(resumeResponse, HttpStatusCode.OK);
VerifyDatabaseInformation(resumeResponse.Database, serverLocation, defaultCollation, databaseEdition, defaultDatabaseSize, dwSlo, dwSlo, "Online");
///////////////////////////////////////////////////////////////////////
}
finally
{
// Clean up the resource group.
resClient.ResourceGroups.Delete(resGroupName);
}
}
}
/// <summary>
/// Responsible for creating a resource group, and within it a SQL database server, as well as creating a SqlClient for the given handler.
/// Once these are created, this method calls the given test with the created sql client, the names of the resource group and server.
/// This method does not removes the created resources !!! it should be run in an undo context that wraps the call to this method.
/// </summary>
/// <param name="handler">A delegation handler to create a Sql client based on it</param>
/// <param name="serverVersion">The version of the server being created</param>
/// <param name="test">A function that receives a sql client, names of a created resource group and server</param>
public static void RunServerTestInEnvironment(BasicDelegatingHandler handler, string serverVersion, Action<SqlManagementClient, string, Server> test)
{
RunServerTestInEnvironment(handler, serverVersion, TestEnvironmentRegion, test);
}
public void TransparentDataEncryptionCRUDTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Variables for server create
string serverName = TestUtilities.GenerateName("csm-sql-transparentdataencryptioncrud");
string resGroupName = TestUtilities.GenerateName("csm-rg-transparentdataencryptioncrud");
string serverLocation = "Japan East";
string adminLogin = "******";
string adminPass = "******";
string version = "12.0";
var defaultDatabaseSize = 1L * 1024L * 1024L * 1024L; // 1 GB
Guid dbSloS0 = new Guid("f1173c43-91bd-4aaa-973c-54e79e15235b "); // S0
var defaultCollation = "SQL_Latin1_General_CP1_CI_AS";
var databaseName = TestUtilities.GenerateName("csm-sql-tde-db");
string databaseEdition = "Standard";
// Create the resource group.
resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup()
{
Location = serverLocation,
});
try
{
//////////////////////////////////////////////////////////////////////
// Create server for test.
var createResponse = sqlClient.Servers.CreateOrUpdate(resGroupName, serverName, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
});
// Verify the the response from the service contains the right information
TestUtilities.ValidateOperationResponse(createResponse, HttpStatusCode.Created);
VerifyServerInformation(serverName, serverLocation, adminLogin, adminPass, version, createResponse.Server);
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Create database test.
// Create only required
var createDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, databaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
MaxSizeBytes = defaultDatabaseSize,
},
});
TestUtilities.ValidateOperationResponse(createDbResponse, HttpStatusCode.Created);
VerifyDatabaseInformation(createDbResponse.Database, serverLocation, defaultCollation, databaseEdition, defaultDatabaseSize, dbSloS0, dbSloS0);
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Get transparent data encryption Test
// Get single transparent data encryption
var getTde = sqlClient.TransparentDataEncryption.Get(resGroupName, serverName, databaseName);
// Verify that the Get request contains the right information.
TestUtilities.ValidateOperationResponse(getTde, HttpStatusCode.OK);
VerifyTransparentDataEncryptionInformation(TransparentDataEncryptionStates.Disabled, getTde.TransparentDataEncryption);
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
// Update Transparent Data Encryption Test
var updateResponse = sqlClient.TransparentDataEncryption.CreateOrUpdate(resGroupName, serverName, databaseName, new TransparentDataEncryptionCreateOrUpdateParameters
{
Properties = new TransparentDataEncryptionCreateOrUpdateProperties()
{
State = TransparentDataEncryptionStates.Enabled,
},
});
///////////////////////////////////////////////////////////////////////
// Get Transparent Data Encryption Activity Test
var activities = sqlClient.TransparentDataEncryption.ListActivity(resGroupName, serverName, databaseName);
TestUtilities.ValidateOperationResponse(activities, HttpStatusCode.OK);
Assert.True(activities.TransparentDataEncryptionActivities.Count > 0);
var transparentDataEncryptionActivity = activities.TransparentDataEncryptionActivities[0];
VerifyTransparentDataEncryptionActivityInformation(TransparentDataEncryptionActivityStates.Encrypting, transparentDataEncryptionActivity);
// Get single transparent data encryption
getTde = sqlClient.TransparentDataEncryption.Get(resGroupName, serverName, databaseName);
TestUtilities.ValidateOperationResponse(updateResponse, HttpStatusCode.OK);
VerifyTransparentDataEncryptionInformation(TransparentDataEncryptionStates.Enabled, getTde.TransparentDataEncryption);
///////////////////////////////////////////////////////////////////////
}
finally
{
// Clean up the resource group.
resClient.ResourceGroups.Delete(resGroupName);
}
}
}
/// <summary>
/// Responsible for creating a resource group, within it a SQL database server and a database, as well as creating a SqlClient for
/// the given handler.
/// Once these are created, this method calls the given test with the created sql client, the names of the resource group, server and
/// database.
/// This method does not removes the created resources !!! it should be run in an undo context that wraps the call to this method.
/// </summary>
/// <param name="handler">A delegation handler to create a Sql client based on it</param>
/// <param name="serverVersion">The version of the server being created</param>
/// <param name="serverLocation">The location of the server being created</param>
/// <param name="test">A function that receives a sql client, names of a created resource group, server and database</param>
public static void RunDatabaseTestInEnvironment(BasicDelegatingHandler handler, string serverVersion, string serverLocation, Action<SqlManagementClient, string, Server, Database> test)
{
var testAdapter = new Action<SqlManagementClient, string, Server>((sqlClient, rgName, server) => RunDbTest(sqlClient, rgName, server, test));
RunServerTestInEnvironment(handler, serverVersion, serverLocation, testAdapter);
}
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);
});
}
}
/// <summary>
/// Responsible for creating a resource group, and within it two SQL database servers, as well as creating a SqlClient for the given handler.
/// Once these are created, this method calls the given test with the created sql client, the names of the resource group and servers.
/// This method does not removes the created resources !!! it should be run in an undo context that wraps the call to this method.
/// </summary>
/// <param name="handler">A delegation handler to create a Sql client based on it</param>
/// <param name="serverVersion">The version of the server being created</param>
/// <param name="test">A function that receives a sql client, names of a created resource group and server</param>
public static void RunTwoServersTestInEnvironment(BasicDelegatingHandler handler, string serverVersion, bool useDifferentEnvironments, Action<SqlManagementClient, string, Server, Server> test)
{
RunTwoServersTestInEnvironment(handler, serverVersion, TestEnvironmentRegion, useDifferentEnvironments ? TestEnvironmentSecondaryRegion: TestEnvironmentRegion, test);
}
public void ListGeoBackupsTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Use a preconfigured runner server/db in order to test this
// Create a resource group/server/db with the following details prior to running this test
// If first run on a live cluster, wait several hours for the geo pair to be created
string serverName = "csm-sql-backup-geo31415seasia";
string resGroupName = "csm-rg-backup-geo31415seasia";
string serverLocation = "Southeast Asia";
string standardDatabaseName = "csm-sql-backup-geo-db31415";
string adminLogin = "******";
string adminPass = "******";
string version = "12.0";
var standardDefaultDatabaseSize = 1L * 1024L * 1024L * 1024L; // 1 GB
Guid dbSloS0 = new Guid("f1173c43-91bd-4aaa-973c-54e79e15235b "); // S0
string standardDatabaseEdition = "Standard";
// Create the resource group.
resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup()
{
Location = serverLocation,
});
var createResponse = sqlClient.Servers.CreateOrUpdate(resGroupName, serverName, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
});
var createDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, standardDatabaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
MaxSizeBytes = standardDefaultDatabaseSize,
Edition = standardDatabaseEdition,
RequestedServiceObjectiveId = dbSloS0,
},
});
GeoBackupListResponse geoBackups = sqlClient.DatabaseBackup.ListGeoBackups(resGroupName, serverName);
Assert.True(geoBackups.GeoBackups.Count >= 1);
var geoRestoreDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, standardDatabaseName + "_georestored", new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
SourceDatabaseId = geoBackups.GeoBackups[0].Id,
CreateMode = "Recovery"
}
});
TestUtilities.ValidateOperationResponse(geoRestoreDbResponse, HttpStatusCode.Created);
}
}
public void ListRecommendedActionsForDatabaseAdvisor()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var response = sqlClient.DatabaseRecommendedActions.List(ResourceGroupName, ServerName, DatabaseName, AdvisorName);
ValidateRecommendedActionList(response.RecommendedActions, DatabaseRecommendedActionType);
}
}
public void ListRestorePointsTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Variables for server creation.
string serverName = TestUtilities.GenerateName("csm-sql-backup");
string resGroupName = TestUtilities.GenerateName("csm-rg-backup");
string serverLocation = "Japan East";
string adminLogin = "******";
string adminPass = "******";
string version = "12.0";
// Constants for Azure SQL Data Warehouse database creation.
var defaultDatabaseSize = 250L * 1024L * 1024L * 1024L; // 250 GB
Guid dwSlo = new Guid("4E63CB0E-91B9-46FD-B05C-51FDD2367618 "); // DW100
var databaseName = TestUtilities.GenerateName("csm-sql-backup-dwdb");
string databaseEdition = "DataWarehouse";
// Constants for Azure SQL standard database creation.
var standardDefaultDatabaseSize = 1L * 1024L * 1024L * 1024L; // 1 GB
var standardDatabaseName = TestUtilities.GenerateName("csm-sql-backup-db");
string standardDatabaseEdition = "Standard";
// Create the resource group.
resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup()
{
Location = serverLocation,
});
try
{
//////////////////////////////////////////////////////////////////////
// Create server for test.
var createResponse = sqlClient.Servers.CreateOrUpdate(resGroupName, serverName, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
});
// Verify the the response from the service contains the right information
TestUtilities.ValidateOperationResponse(createResponse, HttpStatusCode.Created);
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Create database test.
// Create data warehouse database
var createDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, databaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
MaxSizeBytes = defaultDatabaseSize,
Edition = databaseEdition,
RequestedServiceObjectiveId = dwSlo,
},
});
TestUtilities.ValidateOperationResponse(createDbResponse, HttpStatusCode.Created);
// Create standard database
createDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, standardDatabaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
MaxSizeBytes = standardDefaultDatabaseSize,
Edition = standardDatabaseEdition,
RequestedServiceObjectiveId = SqlConstants.DbSloS0,
},
});
TestUtilities.ValidateOperationResponse(createDbResponse, HttpStatusCode.Created);
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Get restore points for data warehouse database.
RestorePointListResponse restorePointsListResponse = sqlClient.DatabaseBackup.ListRestorePoints(resGroupName, serverName, databaseName);
// Creating a data warehouse database should not have any discrete restore points right after.
TestUtilities.ValidateOperationResponse(restorePointsListResponse, HttpStatusCode.OK);
ValidateRestorePointListResponse(restorePointsListResponse, true, 0);
///////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Get restore points for standard database.
restorePointsListResponse = sqlClient.DatabaseBackup.ListRestorePoints(resGroupName, serverName, standardDatabaseName);
TestUtilities.ValidateOperationResponse(restorePointsListResponse, HttpStatusCode.OK);
ValidateRestorePointListResponse(restorePointsListResponse, false, 1);
///////////////////////////////////////////////////////////////////////
}
finally
{
// Clean up the resource group.
resClient.ResourceGroups.Delete(resGroupName);
}
}
}
public void DatabaseCRUDTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Variables for server create
string serverName = TestUtilities.GenerateName("csm-sql-dbcrud-server");
string resGroupName = TestUtilities.GenerateName("csm-rg-dbcrud");
string serverLocation = "Japan East";
string adminLogin = "******";
string adminPass = "******";
string version = "12.0";
// Default values
var defaultCollation = "SQL_Latin1_General_CP1_CI_AS";
var defaultEdition = "Standard";
var defaultDatabaseSize = 1L * 1024L * 1024L * 1024L; // 1 GB
var defaultGuid = new Guid("dd6d99bb-f193-4ec1-86f2-43d3bccbc49c");
// Variables for database create
string databaseName = TestUtilities.GenerateName("csm-sql-dbcrud-db");
string databaseCollation = "Japanese_Bushu_Kakusu_100_CS_AS_KS_WS";
string databaseEdition = "Standard";
long databaseMaxSize = 5L * 1024L * 1024L * 1024L; // 5 GB
Guid dbSloShared = new Guid("910b4fcb-8a29-4c3e-958f-f7ba794388b2"); // Web / Business
Guid dbSloBasic = new Guid("dd6d99bb-f193-4ec1-86f2-43d3bccbc49c"); // Basic
Guid dbSloS0 = new Guid("f1173c43-91bd-4aaa-973c-54e79e15235b "); // S0
Guid dbSloS1 = new Guid("1b1ebd4d-d903-4baa-97f9-4ea675f5e928"); // S1
Guid dbSloS2 = new Guid("455330e1-00cd-488b-b5fa-177c226f28b7"); // S2
var databaseName2 = TestUtilities.GenerateName("csm-sql-dbcrud-db");
var databaseMaxSize2 = defaultDatabaseSize / 2L;
var dbEditionBasic = "Basic";
// Create the resource group.
resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup()
{
Location = serverLocation,
});
try
{
//////////////////////////////////////////////////////////////////////
// Create server for test.
var createServerResponse = sqlClient.Servers.CreateOrUpdate(resGroupName, serverName, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
});
// Verify the the response from the service contains the right information
TestUtilities.ValidateOperationResponse(createServerResponse, HttpStatusCode.Created);
VerifyServerInformation(serverName, serverLocation, adminLogin, adminPass, version, createServerResponse.Server);
//////////////////////////////////////////////////////////////////////
// Get Service objectives
// var serviceObjectivesResponse = sqlClient.ServiceObjectives.List(resGroupName, serverName);
// TestUtilities.ValidateOperationResponse(serviceObjectivesResponse, HttpStatusCode.OK);
//////////////////////////////////////////////////////////////////////
// Create database test.
// Create all options.
var createDbResponse1 = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, databaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
Collation = databaseCollation,
Edition = databaseEdition,
MaxSizeBytes = databaseMaxSize,
RequestedServiceObjectiveId = dbSloS1
},
});
TestUtilities.ValidateOperationResponse(createDbResponse1, HttpStatusCode.Created);
VerifyDatabaseInformation(createDbResponse1.Database, serverLocation, databaseCollation, databaseEdition, databaseMaxSize, dbSloS1, dbSloS1);
// Create only required
var createDbResponse2 = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, databaseName2, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
MaxSizeBytes = defaultDatabaseSize,
},
});
TestUtilities.ValidateOperationResponse(createDbResponse2, HttpStatusCode.Created);
VerifyDatabaseInformation(createDbResponse2.Database, serverLocation, defaultCollation, databaseEdition, defaultDatabaseSize, dbSloS0, dbSloS0);
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Get database test.
// Get first database
var getDatabase1 = sqlClient.Databases.Get(resGroupName, serverName, databaseName);
TestUtilities.ValidateOperationResponse(getDatabase1);
VerifyDatabaseInformation(getDatabase1.Database, serverLocation, databaseCollation, databaseEdition, databaseMaxSize, dbSloS1, dbSloS1);
// Get second database
var getDatabase2 = sqlClient.Databases.Get(resGroupName, serverName, databaseName2);
TestUtilities.ValidateOperationResponse(getDatabase2);
VerifyDatabaseInformation(getDatabase2.Database, serverLocation, defaultCollation, defaultEdition, defaultDatabaseSize, dbSloS0, dbSloS0);
// Get all databases
var listDatabase1 = sqlClient.Databases.List(resGroupName, serverName);
TestUtilities.ValidateOperationResponse(listDatabase1);
Assert.Equal(3, listDatabase1.Databases.Count);
//Get database by ID
var getById = sqlClient.Databases.GetById(resGroupName, serverName, getDatabase1.Database.Properties.DatabaseId);
TestUtilities.ValidateOperationResponse(getById);
Assert.Equal(1, getById.Databases.Count);
VerifyDatabaseInformation(getById.Databases[0], serverLocation, databaseCollation, databaseEdition, databaseMaxSize, dbSloS1, dbSloS1);
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Update database test.
// Update SLO
var updateDb1 = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, databaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
RequestedServiceObjectiveId = dbSloS2
},
});
TestUtilities.ValidateOperationResponse(updateDb1);
VerifyDatabaseInformation(updateDb1.Database, serverLocation, databaseCollation, databaseEdition, databaseMaxSize, dbSloS2, dbSloS2);
//Update Size
var updateDb2 = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, databaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
MaxSizeBytes = defaultDatabaseSize,
},
});
TestUtilities.ValidateOperationResponse(updateDb2);
VerifyDatabaseInformation(updateDb2.Database, serverLocation, databaseCollation, databaseEdition, defaultDatabaseSize, dbSloS2, dbSloS2);
//Update Edition + SLO
var updateDb3 = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, databaseName2, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
Edition = dbEditionBasic,
RequestedServiceObjectiveId = dbSloBasic,
},
});
TestUtilities.ValidateOperationResponse(updateDb3);
VerifyDatabaseInformation(updateDb3.Database, serverLocation, defaultCollation, "Basic", defaultDatabaseSize, dbSloBasic, dbSloBasic);
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Delete database test.
var deleteDb1 = sqlClient.Databases.Delete(resGroupName, serverName, databaseName);
TestUtilities.ValidateOperationResponse(deleteDb1, HttpStatusCode.OK);
var deleteDb2 = sqlClient.Databases.Delete(resGroupName, serverName, databaseName2);
TestUtilities.ValidateOperationResponse(deleteDb2, HttpStatusCode.OK);
//////////////////////////////////////////////////////////////////////
}
finally
{
// Clean up the resource group.
resClient.ResourceGroups.Delete(resGroupName);
}
}
}
public void ServerCRUDTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Variables for server create
string serverName = TestUtilities.GenerateName("csm-sql-servercrud");
string resGroupName = TestUtilities.GenerateName("csm-rg-servercrud");
string serverLocation = "West US";
string adminLogin = "******";
string adminPass = "******";
string adminPass2 = "S3c0ndP455";
string version = "12.0";
// Create the resource group.
resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup()
{
Location = serverLocation,
});
try
{
//////////////////////////////////////////////////////////////////////
// Create server Test.
var createResponse = sqlClient.Servers.CreateOrUpdate(resGroupName, serverName, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
});
// Verify the the response from the service contains the right information
TestUtilities.ValidateOperationResponse(createResponse, HttpStatusCode.Created);
VerifyServerInformation(serverName, serverLocation, adminLogin, adminPass, version, createResponse.Server);
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Get Server Test
// Get single server
var getResponse = sqlClient.Servers.Get(resGroupName, serverName);
// Verify that the Get request contains the right information.
TestUtilities.ValidateOperationResponse(getResponse, HttpStatusCode.OK);
VerifyServerInformation(serverName, serverLocation, adminLogin, null, version, getResponse.Server);
// List all servers
var listResponse = sqlClient.Servers.List(resGroupName);
TestUtilities.ValidateOperationResponse(listResponse);
Assert.Equal(1, listResponse.Servers.Count);
VerifyServerInformation(serverName, serverLocation, adminLogin, null, version, listResponse.Servers[0]);
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
// Update Server Test
var updateResponse = sqlClient.Servers.CreateOrUpdate(resGroupName, serverName, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLoginPassword = adminPass2,
},
});
TestUtilities.ValidateOperationResponse(updateResponse, HttpStatusCode.OK);
VerifyServerInformation(serverName, serverLocation, adminLogin, adminPass2, version, updateResponse.Server);
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
// Delete Server Test
var deleteResponse = sqlClient.Servers.Delete(resGroupName, serverName);
// Verify that the delete operation works.
TestUtilities.ValidateOperationResponse(deleteResponse, HttpStatusCode.NoContent);
/////////////////////////////////////////////////////////////////////
}
finally
{
// Clean up the resource group.
resClient.ResourceGroups.Delete(resGroupName);
}
}
}
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);
});
}
}
