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 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 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 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 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,
});
}
}
/// <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 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 ListRecommendedActionsForDatabaseAdvisor()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var response = sqlClient.DatabaseRecommendedActions.List(ResourceGroupName, ServerName, DatabaseName, AdvisorName);
ValidateRecommendedActionList(response.RecommendedActions, DatabaseRecommendedActionType);
}
}
public void GetSingleRecommendedActionForServerAdvisor()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var response = sqlClient.ServerRecommendedActions.Get(ResourceGroupName, ServerName, AdvisorName, RecommendedActionName);
ValidateSingleRecommendedAction(response.RecommendedAction, ServerRecommendedActionType);
}
}
public void ListAdvisorsForServerExpandedWithRecommendedActions()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var response = sqlClient.ServerAdvisors.List(ResourceGroupName, ServerName, expand: ExpandKey);
ValidateAdvisorList(response.Advisors, ServerAdvisorType);
ValidatePresenceOfRecommendedActions(response);
}
}
public void GetSingleRecommendation()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var response = sqlClient.RecommendedIndexes.Get(ResourceGroupName, ServerName, DatabaseName, Schema,
TableName, IndexName);
var index = response.RecommendedIndex;
ValidateRecommendedIndex(index, "Active");
}
}
public void RestoreTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Variables for server creation.
string serverName = "hchung-testsvr2";
string resGroupName = "hchung-test2";
string standardDatabaseName = "hchung-testdb-geo2";
string serverLocation = "Southeast Asia";
// Create or update standard database
var createDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, standardDatabaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
},
});
TestUtilities.ValidateOperationResponse(createDbResponse, HttpStatusCode.Created);
//////////////////////////////////////////////////////////////////////
string databaseId = createDbResponse.Database.Id;
// If first run on a live cluster, wait 10 minutes for backup to be taken (set a breakpoint to stop execution here). The time of the restore will also need to be updated if running on a a live cluster.
string timeString = "2016-02-24T00:00:00";
DateTime restorePointInTime = DateTime.Parse(timeString);
var restoreDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, standardDatabaseName + "_" + timeString, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
SourceDatabaseId = databaseId,
RestorePointInTime = restorePointInTime,
CreateMode = "PointInTimeRestore"
}
});
TestUtilities.ValidateOperationResponse(restoreDbResponse, HttpStatusCode.Created);
}
}
public void ListAllIndexesForServer()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var handler = new BasicDelegatingHandler();
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var response = sqlClient.Databases.ListExpanded(ResourceGroupName, ServerName, Expand);
var index =
response.Databases[1].Properties.Schemas[0].Properties.Tables[0].Properties.RecommendedIndexes[0];
ValidateRecommendedIndex(index, "Active");
}
}
public void 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");
}
}
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 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 LocationCapabilitiesTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
string regionName = "North Europe";
var capabilities = sqlClient.Capabilities.Get(regionName);
TestUtilities.ValidateOperationResponse(capabilities);
// Make sure the right region is returned
Assert.True(NormalizedRegionName(capabilities.Capabilities.Name) == NormalizedRegionName(regionName));
// Ensure at least one server version is returned
var supportedVersions = capabilities.Capabilities.SupportedServerVersions;
Assert.True(supportedVersions.Count > 0, string.Format("Location : '{0}' does not have any available server versions.", regionName));
// Validate all the supported versions
foreach (var version in capabilities.Capabilities.SupportedServerVersions)
{
Assert.True(!string.IsNullOrEmpty(version.Name));
Assert.True(!string.IsNullOrEmpty(version.Status));
// Ensure that at least one edition is available for the server version
Assert.True(version.SupportedEditions.Count > 0, string.Format("Server version: '{0}' does not have any available editions", version.Name));
// Validate the available editions
foreach (var edition in version.SupportedEditions)
{
Assert.True(!string.IsNullOrEmpty(edition.Name));
Assert.True(!string.IsNullOrEmpty(edition.Status));
// Ensure that the edition has at least one SLO available
Assert.True(edition.SupportedServiceObjectives.Count > 0, string.Format("Edition: '{0}.{1}' does not have any available SLOs", version.Name, edition.Name));
// Validate the avialable max sizes.
foreach (var slo in edition.SupportedServiceObjectives)
{
Assert.True(!string.IsNullOrEmpty(slo.Name));
Assert.True(!string.IsNullOrEmpty(slo.Status));
Assert.True(Guid.Empty != slo.Id);
// Ensure that the SLO has at least 1 max size available.
Assert.True(slo.SupportedMaxSizes.Count > 0, string.Format("SLO: '{0}.{1},{2}' does not have any available max sizes", version.Name, edition.Name, slo.Name));
foreach (var maxSize in slo.SupportedMaxSizes)
{
Assert.True(maxSize.Limit > 0);
Assert.True(!string.IsNullOrEmpty(maxSize.Unit));
Assert.True(!string.IsNullOrEmpty(maxSize.Status));
}
}
}
}
}
}
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 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 ListGeoBackupsTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Use a preconfigured runner server/db in order to test this
// Create a resource group/server/db with the following details prior to running this test
// If first run on a live cluster, wait several hours for the geo pair to be created
string serverName = "csm-sql-backup-geo31415seasia";
string resGroupName = "csm-rg-backup-geo31415seasia";
string serverLocation = "Southeast Asia";
string standardDatabaseName = "csm-sql-backup-geo-db31415";
string adminLogin = "******";
string adminPass = "******";
string version = "12.0";
var standardDefaultDatabaseSize = 1L * 1024L * 1024L * 1024L; // 1 GB
string standardDatabaseEdition = "Standard";
// Create the resource group.
resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup()
{
Location = serverLocation,
});
var createResponse = sqlClient.Servers.CreateOrUpdate(resGroupName, serverName, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
});
var createDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, standardDatabaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
MaxSizeBytes = standardDefaultDatabaseSize,
Edition = standardDatabaseEdition,
RequestedServiceObjectiveId = SqlConstants.DbSloS0,
},
});
GeoBackupListResponse geoBackups = sqlClient.DatabaseBackup.ListGeoBackups(resGroupName, serverName);
Assert.True(geoBackups.GeoBackups.Count >= 1);
var geoRestoreDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, standardDatabaseName + "_georestored", new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
SourceDatabaseId = geoBackups.GeoBackups[0].Id,
CreateMode = "Recovery"
}
});
TestUtilities.ValidateOperationResponse(geoRestoreDbResponse, HttpStatusCode.Created);
}
}
public void ListDeletedDatabaseBackupTest()
{
var handler = new BasicDelegatingHandler();
using (UndoContext context = UndoContext.Current)
{
context.Start();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Variables for server creation.
string serverName = "csm-sql-backup31415";
string resGroupName = "csm-rg-backup31415";
string serverLocation = "North Europe";
string adminLogin = "******";
string adminPass = "******";
string version = "12.0";
// Constants for Azure SQL standard database creation.
var standardDefaultDatabaseSize = 1L * 1024L * 1024L * 1024L; // 1 GB
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 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);
}
}
}
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 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 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);
}
}
}
