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 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, }); } }
/// <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 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 JobAccountCRUDTest() { 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-jobaccountcrud-server"); string resGroupName = TestUtilities.GenerateName("csm-rg-jobaccountcrud"); string serverLocation = "Southeast Asia"; string adminLogin = "******"; string adminPass = "******"; string version = "12.0"; // Variables for database create string databaseName = TestUtilities.GenerateName("csm-sql-jobaccountcrud-db"); string databaseCollation = "Japanese_Bushu_Kakusu_100_CS_AS_KS_WS"; string databaseEdition = "Standard"; long databaseMaxSize = 5L * 1024L * 1024L * 1024L; // 5 GB Guid dbSloS1 = SqlConstants.DbSloS1; // Variables for job account create string jobAccountName = TestUtilities.GenerateName("csm-sql-jobaccountcrud-jobaccount"); // 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); ////////////////////////////////////////////////////////////////////// // Create database for test. // Create all options. var createDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, databaseName, new DatabaseCreateOrUpdateParameters() { Location = serverLocation, Properties = new DatabaseCreateOrUpdateProperties() { Collation = databaseCollation, Edition = databaseEdition, MaxSizeBytes = databaseMaxSize, RequestedServiceObjectiveId = dbSloS1 }, }); TestUtilities.ValidateOperationResponse(createDbResponse, HttpStatusCode.Created); ////////////////////////////////////////////////////////////////////// // Create job account test. var createJobResonse = sqlClient.JobAccounts.CreateOrUpdate(resGroupName, serverName, jobAccountName, new JobAccountCreateOrUpdateParameters { Location = serverLocation, Properties = new JobAccountCreateOrUpdateProperties { DatabaseId = createDbResponse.Database.Id } }); TestUtilities.ValidateOperationResponse(createJobResonse, HttpStatusCode.Created); VerifyJobAccountInformation(createJobResonse.JobAccount, jobAccountName, createDbResponse.Database.Id); ////////////////////////////////////////////////////////////////////// // Get job account test var getJobAccountResponse = sqlClient.JobAccounts.Get(resGroupName, serverName, jobAccountName); TestUtilities.ValidateOperationResponse(getJobAccountResponse); VerifyJobAccountInformation(getJobAccountResponse.JobAccount, jobAccountName, createDbResponse.Database.Id); ////////////////////////////////////////////////////////////////////// // List job account test var listJobAccountResponse = sqlClient.JobAccounts.List(resGroupName, serverName); TestUtilities.ValidateOperationResponse(listJobAccountResponse); Assert.Equal(1, listJobAccountResponse.Count()); VerifyJobAccountInformation(listJobAccountResponse.JobAccounts[0], jobAccountName, createDbResponse.Database.Id); ////////////////////////////////////////////////////////////////////// // Delete job account test var deleteJobAccountResponse = sqlClient.JobAccounts.Delete(resGroupName, serverName, jobAccountName); TestUtilities.ValidateOperationResponse(deleteJobAccountResponse); } finally { // Clean up the resource group. resClient.ResourceGroups.Delete(resGroupName); } } }
private void ValidateImportExport(bool createServer = true, bool createDatabase = true, bool createFirewallRule = true, string operationName = "Export", bool missingFields = false, HttpStatusCode expectedStatueCode = HttpStatusCode.Accepted) { var handler = new BasicDelegatingHandler(); // Management Clients var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler); var resClient = Sql2ScenarioHelper.GetResourceClient(handler); // Variables for server create string serverName = TestUtilities.GenerateName("csm-sql-ie"); string resGroupName = TestUtilities.GenerateName("csm-rg-servercrud"); string serverLocation = "North Europe"; string adminLogin = "******"; string adminPass = "******"; string version = "12.0"; // Variables for database create string databaseName = TestUtilities.GenerateName("csm-sql-db_ie"); string databaseEdition = "Standard"; long databaseMaxSize = 5L * 1024L * 1024L * 1024L; // 5 GB Guid dbSloS1 = new Guid("1b1ebd4d-d903-4baa-97f9-4ea675f5e928"); // S1 string serviceObjectiveName = "S1"; // Create firewall test. string firewallRuleName = TestUtilities.GenerateName("sql-fwrule"); string startIp1 = "0.0.0.0"; string endIp1 = "255.255.255.255"; string storageKey = "StorageKey"; string storageKeyType = "StorageAccessKey"; string exportBacpacLink = string.Format(CultureInfo.InvariantCulture, "http://test.blob.core.windows.net/databases/{0}.bacpac", databaseName); string importBacpacLink = "http://test.blob.core.windows.net/databases/test.bacpac"; string testMode = Environment.GetEnvironmentVariable("AZURE_TEST_MODE"); if (testMode == "Record") { string importBacpacBaseUrl = Environment.GetEnvironmentVariable("TEST_EXPORT_BACPAC"); storageKey = Environment.GetEnvironmentVariable("TEST_STORAGE_KEY"); exportBacpacLink = string.Format(CultureInfo.InvariantCulture, "{0}/{1}.bacpac", importBacpacBaseUrl, databaseName); importBacpacLink = Environment.GetEnvironmentVariable("TEST_IMPORT_BACPAC"); Assert.False(string.IsNullOrWhiteSpace(storageKey), "Environment variable TEST_EXPORT_BACPAC has not been set"); Assert.False(string.IsNullOrWhiteSpace(importBacpacBaseUrl), "Environment variable TEST_EXPORT_BACPAC has not been set"); Assert.False(string.IsNullOrWhiteSpace(importBacpacLink), "Environment variable TEST_IMPORT_BACPAC has not been set"); } // Create the resource group. resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup() { Location = serverLocation, }); try { ////////////////////////////////////////////////////////////////////// // Create server if (createServer) { var createResponse = sqlClient.Servers.CreateOrUpdate(resGroupName, serverName, new ServerCreateOrUpdateParameters() { Location = serverLocation, Properties = new ServerCreateOrUpdateProperties() { AdministratorLogin = adminLogin, AdministratorLoginPassword = adminPass, Version = version, } }); TestUtilities.ValidateOperationResponse(createResponse, HttpStatusCode.Created); } ////////////////////////////////////////////////////////////////////// // Create database if (createServer && createDatabase) { var createDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, databaseName, new DatabaseCreateOrUpdateParameters() { Location = serverLocation, Properties = new DatabaseCreateOrUpdateProperties() { Edition = databaseEdition, MaxSizeBytes = databaseMaxSize, RequestedServiceObjectiveId = dbSloS1 }, }); TestUtilities.ValidateOperationResponse(createDbResponse, HttpStatusCode.Created); } ////////////////////////////////////////////////////////////////////// // Create firewall rule if (createServer && createFirewallRule) { var firewallCreate = sqlClient.FirewallRules.CreateOrUpdate(resGroupName, serverName, firewallRuleName, new FirewallRuleCreateOrUpdateParameters() { Properties = new FirewallRuleCreateOrUpdateProperties() { StartIpAddress = startIp1, EndIpAddress = endIp1, } }); TestUtilities.ValidateOperationResponse(firewallCreate, HttpStatusCode.Created); } ////////////////////////////////////////////////////////////////////// //Import Export try { ImportExportResponse importExportResponse = null; if (operationName == ExportOperationName) { ExportRequestParameters parameters = new ExportRequestParameters() { AdministratorLogin = adminLogin, AdministratorLoginPassword = adminPass }; if (!missingFields) { parameters.StorageKey = storageKey; parameters.StorageKeyType = storageKeyType; parameters.StorageUri = new Uri(exportBacpacLink); } importExportResponse = sqlClient.ImportExport.Export(resGroupName, serverName, databaseName, parameters); } else if (operationName == ImportOperationName) { ImportRequestParameters parameters = new ImportRequestParameters() { AdministratorLogin = adminLogin, AdministratorLoginPassword = adminPass, StorageKey = storageKey, StorageKeyType = storageKeyType, StorageUri = new Uri(importBacpacLink), DatabaseName = databaseName }; if (!missingFields) { parameters.DatabaseMaxSize = databaseMaxSize; parameters.Edition = databaseEdition; parameters.ServiceObjectiveName = serviceObjectiveName; } importExportResponse = sqlClient.ImportExport.Import(resGroupName, serverName, parameters); } else if (operationName == ImportExistingDbOperationName) { ImportExtensionRequestParameteres parameters = new ImportExtensionRequestParameteres() { Properties = new ImportExtensionProperties { AdministratorLogin = adminLogin, AdministratorLoginPassword = adminPass, StorageKey = storageKey, StorageKeyType = storageKeyType, StorageUri = new Uri(importBacpacLink) } }; importExportResponse = sqlClient.ImportExport.ImportToExistingDatabase(resGroupName, serverName, databaseName, parameters); } if (expectedStatueCode == HttpStatusCode.Accepted) { Assert.Equal(importExportResponse.Status, OperationStatus.InProgress); ImportExportOperationStatusResponse statusResponse = sqlClient.ImportExport.GetImportExportOperationStatus(importExportResponse.OperationStatusLink); while (statusResponse.Status == Microsoft.Azure.OperationStatus.InProgress) { statusResponse = sqlClient.ImportExport.GetImportExportOperationStatus(importExportResponse.OperationStatusLink); if (statusResponse.Status == Microsoft.Azure.OperationStatus.InProgress) { ValidateImportExportOperationStatusResponseProperties(statusResponse); } } Assert.Equal(statusResponse.Status, OperationStatus.Succeeded); ValidateImportExportOperationStatusResponseProperties(statusResponse.Properties); } TestUtilities.ValidateOperationResponse(importExportResponse, expectedStatueCode); } catch (CloudException exception) { Assert.Equal(exception.Response.StatusCode, expectedStatueCode); } if (operationName == ImportOperationName && !createDatabase && !missingFields) { DatabaseGetResponse databaseGetResponse = sqlClient.Databases.Get(resGroupName, serverName, databaseName); TestUtilities.ValidateOperationResponse(databaseGetResponse); } } finally { // Clean up the resource group. resClient.ResourceGroups.Delete(resGroupName); } }
public void SyncGroupCRUDTest() { 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 resource group create string resGroupName = TestUtilities.GenerateName("csm-rg-sgcrud"); string resourceGroupLocation = "West US"; // Variables for server create string serverName = TestUtilities.GenerateName("csm-sql-sgcrud-server"); string serverLocation = "West US 2"; // Variables for database create string databaseName = TestUtilities.GenerateName("csm-sql-sgcrud-db"); string syncDatabaseName = TestUtilities.GenerateName("csm-sql-sgcrud-syncdb"); // Variables for sync group 1 create string syncGroupName = TestUtilities.GenerateName("csm-sql-sgcrud-syncgroup"); string adminLogin = "******"; string adminPass = "******"; int interval1 = 300; int interval2 = 200; string subscriptionId = sqlClient.Credentials.SubscriptionId; string syncDatabaseId = string.Format("/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Sql/servers/{2}/databases/{3}", subscriptionId, resGroupName, serverName, syncDatabaseName); ConflictResolutionPolicyType conflictResolutionPolicy1 = ConflictResolutionPolicyType.HubWin; // Create the resource group. resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup() { Location = resourceGroupLocation, }); try { ////////////////////////////////////////////////////////////////////// // Create server for test var createServerResponse = CreateServerForTest(resGroupName, serverName, serverLocation); TestUtilities.ValidateOperationResponse(createServerResponse, HttpStatusCode.Created); ////////////////////////////////////////////////////////////////////// // Create database for test var createDbResponse = CreateDatabaseForTest(resGroupName, serverName, databaseName, serverLocation); TestUtilities.ValidateOperationResponse(createDbResponse, HttpStatusCode.Created); ////////////////////////////////////////////////////////////////////// // Create sync database for test var createDbResponse2 = CreateDatabaseForTest(resGroupName, serverName, syncDatabaseName, serverLocation); TestUtilities.ValidateOperationResponse(createDbResponse2, HttpStatusCode.Created); ////////////////////////////////////////////////////////////////////// // Create sync group 1 for test var createSyncGroupResponse1 = sqlClient.DataSync.CreateOrUpdateSyncGroup(resGroupName, serverName, databaseName, new SyncGroupCreateOrUpdateParameters() { SyncGroupName = syncGroupName, Properties = new SyncGroupCreateOrUpdateProperties() { Interval = interval1, ConflictResolutionPolicy = conflictResolutionPolicy1, SyncDatabaseId = syncDatabaseId, HubDatabaseUserName = adminLogin, HubDatabasePassword = adminPass }, }); // Verify the the response from the service contains the right information TestUtilities.ValidateOperationResponse(createSyncGroupResponse1, HttpStatusCode.Created); VerifySyncGroupInformation(createSyncGroupResponse1.SyncGroup, interval1, syncDatabaseId, adminLogin, conflictResolutionPolicy1); ////////////////////////////////////////////////////////////////////// // Get the sync group var getSyncGroup1 = sqlClient.DataSync.GetSyncGroup(resGroupName, serverName, databaseName, syncGroupName); TestUtilities.ValidateOperationResponse(getSyncGroup1); VerifySyncGroupInformation(getSyncGroup1.SyncGroup, interval1, syncDatabaseId, adminLogin, conflictResolutionPolicy1); ////////////////////////////////////////////////////////////////////// // Get all sync groups var listSyncGroup1 = sqlClient.DataSync.ListSyncGroup(resGroupName, serverName, databaseName); TestUtilities.ValidateOperationResponse(listSyncGroup1); Assert.Equal(1, listSyncGroup1.SyncGroups.Count); VerifySyncGroupInformation(listSyncGroup1.SyncGroups[0], interval1, syncDatabaseId, adminLogin, conflictResolutionPolicy1); ////////////////////////////////////////////////////////////////////// // Update description and schema of sync group 2 test var updateSyncGroup1 = sqlClient.DataSync.UpdateSyncGroup(resGroupName, serverName, databaseName, new SyncGroupCreateOrUpdateParameters() { SyncGroupName = syncGroupName, Properties = new SyncGroupCreateOrUpdateProperties() { Interval = interval2 }, }); // Verify the the response from the service contains the right information TestUtilities.ValidateOperationResponse(updateSyncGroup1); // Get the sync group after updating var getSyncGroup2 = sqlClient.DataSync.GetSyncGroup(resGroupName, serverName, databaseName, syncGroupName); TestUtilities.ValidateOperationResponse(getSyncGroup2); VerifySyncGroupInformation(getSyncGroup2.SyncGroup, interval2, syncDatabaseId, adminLogin, conflictResolutionPolicy1); var refreshSchemaResponse = sqlClient.DataSync.InvokeSyncHubSchemaRefresh(resGroupName, serverName, databaseName, syncGroupName); TestUtilities.ValidateOperationResponse(refreshSchemaResponse); ////////////////////////////////////////////////////////////////////// // Get full schema of member database of a hub database var getSyncMemberSchema1 = sqlClient.DataSync.GetSyncHubSchema(resGroupName, serverName, databaseName, syncGroupName); TestUtilities.ValidateOperationResponse(getSyncMemberSchema1); ////////////////////////////////////////////////////////////////////// // Get log of sync group var getSyncGroupLog = sqlClient.DataSync.ListSyncGroupLog(resGroupName, serverName, databaseName, new SyncGroupLogGetParameters { SyncGroupName = syncGroupName, StartTime = "9/16/2016 11:31:12", EndTime = "9/16/2016 12:31:00", Type = LogType.All.ToString() }); TestUtilities.ValidateOperationResponse(getSyncGroupLog); VerifySyncGroupLogInformation(getSyncGroupLog); ////////////////////////////////////////////////////////////////////// // Delete sync group test. var deleteSyncGroup1 = sqlClient.DataSync.DeleteSyncGroup(resGroupName, serverName, databaseName, syncGroupName); TestUtilities.ValidateOperationResponse(deleteSyncGroup1); sqlClient.Servers.Delete(resGroupName, serverName); } finally { // Clean up the resource group. resClient.ResourceGroups.Delete(resGroupName); } } }
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); } } }
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 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 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); } } }
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 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 SyncMemberCRUDTest() { 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 resource group create string resGroupName = TestUtilities.GenerateName("csm-rg-smcrud"); string resourceGroupLocation = "West US"; // Variables for server create string serverName = TestUtilities.GenerateName("csm-sql-smcrud-server"); string serverLocation = "West US 2"; // Variables for database create string databaseName = TestUtilities.GenerateName("csm-sql-smcrud-db"); string syncDatabaseName = TestUtilities.GenerateName("csm-sql-smcrud-syncdb"); string memberDatabaseName = TestUtilities.GenerateName("csm-sql-smcrud-memberdb"); string memberFullDNSServerName = serverName + ".sqltest-eg1.mscds.com"; // Variables for sync group create string syncGroupName = TestUtilities.GenerateName("csm-sql-smcrud-syncgroup"); string adminLogin = "******"; string adminPass = "******"; int interval = 300; ConflictResolutionPolicyType conflictResolutionPolicy = ConflictResolutionPolicyType.Memberwin; string subscriptionId = sqlClient.Credentials.SubscriptionId; string syncDatabaseId = string.Format("/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Sql/servers/{2}/databases/{3}", subscriptionId, resGroupName, serverName, syncDatabaseName); // Variables for sync member creation string syncMemberName1 = TestUtilities.GenerateName("csm-sql-smcrud-sm"); SyncDirectionEnum syncDirection = SyncDirectionEnum.Bidirectional; DatabaseTypeEnum databaseType = DatabaseTypeEnum.AzureSqlDatabase; SyncMemberGeneralParameters syncMemberGeneralParameter = new SyncMemberGeneralParameters() { SyncGroupName = syncGroupName, SyncMemberName = syncMemberName1 }; // Create the resource group. resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup() { Location = resourceGroupLocation, }); try { ////////////////////////////////////////////////////////////////////// // Create server for test var createServerResponse = CreateServerForTest(resGroupName, serverName, serverLocation); TestUtilities.ValidateOperationResponse(createServerResponse, HttpStatusCode.Created); ////////////////////////////////////////////////////////////////////// // Create database for test var createDbResponse = CreateDatabaseForTest(resGroupName, serverName, databaseName, serverLocation); TestUtilities.ValidateOperationResponse(createDbResponse, HttpStatusCode.Created); ////////////////////////////////////////////////////////////////////// // Create sync database for test var createDbResponse2 = CreateDatabaseForTest(resGroupName, serverName, syncDatabaseName, serverLocation); TestUtilities.ValidateOperationResponse(createDbResponse2, HttpStatusCode.Created); ////////////////////////////////////////////////////////////////////// // Create member database for test var createMemberDbResponse = CreateDatabaseForTest(resGroupName, serverName, memberDatabaseName, serverLocation); TestUtilities.ValidateOperationResponse(createMemberDbResponse, HttpStatusCode.Created); ////////////////////////////////////////////////////////////////////// // Create sync group for test var createSyncGroupResponse = sqlClient.DataSync.CreateOrUpdateSyncGroup(resGroupName, serverName, databaseName, new SyncGroupCreateOrUpdateParameters() { SyncGroupName = syncGroupName, Properties = new SyncGroupCreateOrUpdateProperties() { Interval = interval, ConflictResolutionPolicy = conflictResolutionPolicy, SyncDatabaseId = syncDatabaseId, }, }); ////////////////////////////////////////////////////////////////////// // Create sync member for test var createSyncMemberResponse = sqlClient.DataSync.CreateOrUpdateSyncMember(resGroupName, serverName, databaseName, new SyncMemberCreateOrUpdateParameters() { SyncGroupName = syncGroupName, SyncMemberName = syncMemberName1, Properties = new SyncMemberCreateOrUpdateProperties() { SyncDirection = syncDirection, DatabaseType = databaseType, DatabaseName = memberDatabaseName, ServerName = memberFullDNSServerName, UserName = adminLogin, Password = adminPass, }, }); // Verify the the response from the service contains the right information TestUtilities.ValidateOperationResponse(createSyncMemberResponse, HttpStatusCode.Created); VerifySyncMemberInformation(createSyncMemberResponse.SyncMember, syncDirection, databaseType, memberFullDNSServerName, memberDatabaseName); ////////////////////////////////////////////////////////////////////// // Get the sync member var getSyncMember1 = sqlClient.DataSync.GetSyncMember(resGroupName, serverName, databaseName, syncMemberGeneralParameter); TestUtilities.ValidateOperationResponse(getSyncMember1); VerifySyncMemberInformation(getSyncMember1.SyncMember, syncDirection, databaseType, memberFullDNSServerName, memberDatabaseName); ////////////////////////////////////////////////////////////////////// // List all sync members var listSyncMember = sqlClient.DataSync.ListSyncMember(resGroupName, serverName, databaseName, syncGroupName); TestUtilities.ValidateOperationResponse(listSyncMember); Assert.Equal(1, listSyncMember.SyncMembers.Count); VerifySyncMemberInformation(listSyncMember.SyncMembers[0], syncDirection, databaseType, memberFullDNSServerName, memberDatabaseName); ////////////////////////////////////////////////////////////////////// // Update sync member test var updateSyncMember1 = sqlClient.DataSync.UpdateSyncMember(resGroupName, serverName, databaseName, new SyncMemberCreateOrUpdateParameters() { SyncGroupName = syncGroupName, SyncMemberName = syncMemberName1, Properties = new SyncMemberCreateOrUpdateProperties() { DatabaseType = DatabaseTypeEnum.AzureSqlDatabase, UserName = adminLogin, Password = adminPass }, }); // Verify the the response from the service contains the right information TestUtilities.ValidateOperationResponse(updateSyncMember1); var refreshSchemaResponse = sqlClient.DataSync.InvokeSyncMemberSchemaRefresh(resGroupName, serverName, databaseName, syncMemberGeneralParameter); TestUtilities.ValidateOperationResponse(refreshSchemaResponse); ////////////////////////////////////////////////////////////////////// // Get full schema of member database of sync member var getSyncMemberSchema1 = sqlClient.DataSync.GetSyncMemberSchema(resGroupName, serverName, databaseName, syncMemberGeneralParameter); TestUtilities.ValidateOperationResponse(getSyncMemberSchema1); ////////////////////////////////////////////////////////////////////// // Delete sync member test. var deleteSyncMember1 = sqlClient.DataSync.DeleteSyncMember(resGroupName, serverName, databaseName, syncMemberGeneralParameter); TestUtilities.ValidateOperationResponse(deleteSyncMember1); ////////////////////////////////////////////////////////////////////// // Delete sync group. var deleteSyncGroup1 = sqlClient.DataSync.DeleteSyncGroup(resGroupName, serverName, databaseName, syncGroupName); sqlClient.Servers.Delete(resGroupName, serverName); } finally { // Clean up the resource group. resClient.ResourceGroups.Delete(resGroupName); } } }
public void SyncAgentCRUDTest() { 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 resource group create string resGroupName = TestUtilities.GenerateName("csm-rg-sacrud"); string resourceGroupLocation = "West US"; // Variables for server create string serverName = TestUtilities.GenerateName("csm-sql-sacrud-server"); string serverLocation = "West US 2"; // Variables for database create string databaseName = TestUtilities.GenerateName("csm-sql-sacrud-db"); string syncDatabaseName = TestUtilities.GenerateName("csm-sql-sacrud-syncdb"); string subscriptionId = sqlClient.Credentials.SubscriptionId; string syncDatabaseId = string.Format("/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Sql/servers/{2}/databases/{3}", subscriptionId, resGroupName, serverName, syncDatabaseName); // Variables for sync agent creation string syncAgentName1 = TestUtilities.GenerateName("csm-sql-sacrud-syncagent"); // Create the resource group. resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup() { Location = resourceGroupLocation, }); try { ////////////////////////////////////////////////////////////////////// // Create server for test var createServerResponse = CreateServerForTest(resGroupName, serverName, serverLocation); TestUtilities.ValidateOperationResponse(createServerResponse, HttpStatusCode.Created); ////////////////////////////////////////////////////////////////////// // Create database for test var createDbResponse = CreateDatabaseForTest(resGroupName, serverName, databaseName, serverLocation); TestUtilities.ValidateOperationResponse(createDbResponse, HttpStatusCode.Created); ////////////////////////////////////////////////////////////////////// // Create sync database for test var createDbResponse2 = CreateDatabaseForTest(resGroupName, serverName, syncDatabaseName, serverLocation); TestUtilities.ValidateOperationResponse(createDbResponse2, HttpStatusCode.Created); ////////////////////////////////////////////////////////////////////// // Create sync agent 1 for test var createSyncAgentResponse1 = sqlClient.DataSync.CreateOrUpdateSyncAgent(resGroupName, serverName, syncAgentName1, new SyncAgentCreateOrUpdateParameters() { Properties = new SyncAgentCreateOrUpdateProperties() { SyncDatabaseId = syncDatabaseId }, }); // Verify the the response from the service contains the right information TestUtilities.ValidateOperationResponse(createSyncAgentResponse1, HttpStatusCode.Created); VerifySyncAgentInformation(createSyncAgentResponse1.SyncAgent, syncDatabaseId); ////////////////////////////////////////////////////////////////////// // Get the sync agent var getSyncAgent1 = sqlClient.DataSync.GetSyncAgent(resGroupName, serverName, syncAgentName1); TestUtilities.ValidateOperationResponse(getSyncAgent1); VerifySyncAgentInformation(getSyncAgent1.SyncAgent, syncDatabaseId); ////////////////////////////////////////////////////////////////////// // List all sync agents var listSyncAgent1 = sqlClient.DataSync.ListSyncAgent(resGroupName, serverName); TestUtilities.ValidateOperationResponse(listSyncAgent1); Assert.Equal(1, listSyncAgent1.SyncAgents.Count); ////////////////////////////////////////////////////////////////////// // Create sync agent key for test var createSyncAgentKeyResponse = sqlClient.DataSync.CreateSyncAgentKey(resGroupName, serverName, syncAgentName1); // Verify the the response from the service contains the right information TestUtilities.ValidateOperationResponse(createSyncAgentKeyResponse); Assert.NotNull(createSyncAgentKeyResponse.SyncAgentKey); ////////////////////////////////////////////////////////////////////// // Get sync agent linked databases var getSyncAgentLinkedDatabaseResponse = sqlClient.DataSync.ListSyncAgentLinkedDatabase(resGroupName, serverName, syncAgentName1); // Verify the the response from the service contains the right information TestUtilities.ValidateOperationResponse(getSyncAgentLinkedDatabaseResponse); Assert.Equal(HttpStatusCode.OK, getSyncAgentLinkedDatabaseResponse.StatusCode); ////////////////////////////////////////////////////////////////////// // Delete sync agent test. var deleteSyncAgent1 = sqlClient.DataSync.DeleteSyncAgent(resGroupName, serverName, syncAgentName1); TestUtilities.ValidateOperationResponse(deleteSyncAgent1); sqlClient.Servers.Delete(resGroupName, serverName); } finally { // Clean up the resource group. resClient.ResourceGroups.Delete(resGroupName); } } }
public void DatabaseReadScaleTest() { 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 = "csm-sql-dbreadscalecrud-server2"; string resGroupName = "csm-rg-dbreadscalecrud"; string serverLocation = "Southeast Asia"; string adminLogin = "******"; string adminPass = "******"; string version = "12.0"; // Variables for database create string databaseName = "csm-sql-dbreadscalecrud-db"; string databaseEditionPremium = "Premium"; long databaseMaxSize = 5L * 1024L * 1024L * 1024L; // 5 GB var readScaleEnabled = "Enabled"; var readScaleDisabled = "Disabled"; // 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, } }); var createDbResponse1 = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, databaseName, new DatabaseCreateOrUpdateParameters() { Location = serverLocation, Properties = new DatabaseCreateOrUpdateProperties() { Edition = databaseEditionPremium, MaxSizeBytes = databaseMaxSize, ReadScale = readScaleEnabled, }, }); TestUtilities.ValidateOperationResponse(createDbResponse1, HttpStatusCode.Created); Assert.Equal(createDbResponse1.Database.Properties.ReadScale, readScaleEnabled); //Update Read Scale Option var updateDb = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, databaseName, new DatabaseCreateOrUpdateParameters() { Location = serverLocation, Properties = new DatabaseCreateOrUpdateProperties() { ReadScale = readScaleDisabled }, }); TestUtilities.ValidateOperationResponse(updateDb); Assert.Equal(updateDb.Database.Properties.ReadScale, readScaleDisabled); // Get first database var getDb1 = sqlClient.Databases.Get(resGroupName, serverName, databaseName); TestUtilities.ValidateOperationResponse(getDb1); Assert.Equal(getDb1.Database.Properties.ReadScale, readScaleDisabled); } finally { // Clean up the resource group. resClient.ResourceGroups.Delete(resGroupName); } } }