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 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 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 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 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 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 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 ServerBlobAuditingPolicyLifecycleTest()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
Sql2ScenarioHelper.RunServerTestInEnvironment(new BasicDelegatingHandler(), "12.0", TestServerAuditingApis);
}
}
public void ServerSecurityAlertPolicyLifecycleTest()
{
using (var context = UndoContext.Current)
{
context.Start();
Sql2ScenarioHelper.RunServerTestInEnvironment(new BasicDelegatingHandler(), "12.0", TestServerSecurityAlertApis);
}
}
public void DatabaseAuditingPolicyLifecycleTest()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
Sql2ScenarioHelper.RunDatabaseTestInEnvironment(new BasicDelegatingHandler(), "2.0", TestDatabaseAuditingAPIs);
}
}
/// <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 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 PositiveTestWithRecommendedDatabase()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
Sql2ScenarioHelper.RunDatabaseTestInEnvironment(
new BasicDelegatingHandler(),
currentVersion,
serverLocation,
UpgradeServerWithRecommendedDatabase);
}
}
public void PositiveTestEmptyServer()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
Sql2ScenarioHelper.RunServerTestInEnvironment(
new BasicDelegatingHandler(),
currentVersion,
serverLocation,
UpgradeEmptyServer);
}
}
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 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 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 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 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 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 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");
}
}
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 ListPoolsExpanded()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
Sql2ScenarioHelper.RunServerTestInEnvironment(
handler,
"12.0",
(sqlClient, resGroupName, server) =>
{
var response = sqlClient.RecommendedElasticPools.ListExpanded(resGroupName, server.Name, "databases,metrics");
TestUtilities.ValidateOperationResponse(response, HttpStatusCode.OK);
Assert.Equal(2, response.RecommendedElasticPools.Count());
Assert.Equal(0, response.RecommendedElasticPools[0].Properties.Databases.Count);
Assert.Equal(3, response.RecommendedElasticPools[0].Properties.Metrics.Count);
Assert.Equal(1, response.RecommendedElasticPools[1].Properties.Databases.Count);
Assert.Equal(3, response.RecommendedElasticPools[1].Properties.Metrics.Count);
});
}
}
public void GetDatabasesExpanded()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
Sql2ScenarioHelper.RunServerTestInEnvironment(
handler,
"12.0",
(sqlClient, resGroupName, server) =>
{
var response = sqlClient.Databases.GetExpanded(resGroupName, server.Name, "AutoScaleSterlingTest4", "upgradeHint,serviceTierAdvisors");
TestUtilities.ValidateOperationResponse(response, HttpStatusCode.OK);
Assert.Equal("AutoScaleSterlingTest4", response.Database.Name);
Assert.Equal("S2", response.Database.Properties.UpgradeHint.TargetServiceLevelObjective);
Assert.Equal(1, response.Database.Properties.ServiceTierAdvisors.Count);
Assert.Equal("S3", response.Database.Properties.ServiceTierAdvisors[0].Properties.UsageBasedRecommendationServiceLevelObjective);
Assert.Equal(4, response.Database.Properties.ServiceTierAdvisors[0].Properties.ServiceLevelObjectiveUsageMetrics.Count);
});
}
}
