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); }); } }