/// <summary>
/// The non-boilerplated test code of the APIs for managing the lifecycle of a given database's data masking policy. It is meant to be called with a name of an already exisiting database (and therefore already existing
/// server and resource group). This test does not create these resources and does not remove them.
/// </summary>
private void TestDataMaskingPolicyAPIs(SqlManagementClient sqlClient, string resourceGroupName, Server server, Database database)
{
DataMaskingPolicyGetResponse getDefaultPolicyResponse = sqlClient.DataMasking.GetPolicy(resourceGroupName, server.Name, database.Name);
DataMaskingPolicyProperties properties = getDefaultPolicyResponse.DataMaskingPolicy.Properties;
// Verify that the initial Get request contains the default policy.
TestUtilities.ValidateOperationResponse(getDefaultPolicyResponse, HttpStatusCode.OK);
VerifyDataMaskingPolicyInformation(MakeDefaultDataMaskingPolicyProperties(), properties);
// Modify the policy properties, send and receive, see it its still ok
properties.DataMaskingState = "Enabled";
properties.ExemptPrincipals = "principal1;principal2";
DataMaskingPolicyCreateOrUpdateParameters updateParams = new DataMaskingPolicyCreateOrUpdateParameters();
updateParams.Properties = properties;
var updateResponse = sqlClient.DataMasking.CreateOrUpdatePolicy(resourceGroupName, server.Name, database.Name, updateParams);
// Verify that the initial Get request of contains the default policy.
TestUtilities.ValidateOperationResponse(updateResponse, HttpStatusCode.OK);
DataMaskingPolicyGetResponse getUpdatedPolicyResponse = sqlClient.DataMasking.GetPolicy(resourceGroupName, server.Name, database.Name);
DataMaskingPolicyProperties updatedProperties = getUpdatedPolicyResponse.DataMaskingPolicy.Properties;
// Verify that the Get request contains the updated policy.
TestUtilities.ValidateOperationResponse(getUpdatedPolicyResponse, HttpStatusCode.OK);
VerifyDataMaskingPolicyInformation(properties, updatedProperties);
}
/// <summary>
/// The non-boilerplated test code of the APIs for managing the lifecycle of a given database's security alert policy. It is meant to be called with a name of an already existing database (and therefore already existing
/// server and resource group). This test does not create these resources and does not remove them.
/// </summary>
private static void TestDatabaseSecurityAlertApis(SqlManagementClient sqlClient, string resourceGroupName, Server server, Database database)
{
var getDefaultDatabaseSecurityAlertPolicyResponse = sqlClient.SecurityAlertPolicy.GetDatabaseSecurityAlertPolicy(resourceGroupName, server.Name, database.Name);
var properties = getDefaultDatabaseSecurityAlertPolicyResponse.SecurityAlertPolicy.Properties;
// Verify that the initial Get request contains the default policy.
TestUtilities.ValidateOperationResponse(getDefaultDatabaseSecurityAlertPolicyResponse);
VerifySecurityAlertPolicyInformation(GetDefaultDatabaseSecurityAlertProperties(), properties);
// Modify the policy properties, send and receive, see it its still ok
ChangeSecurityAlertPolicy(properties);
var updateParams = new DatabaseSecurityAlertPolicyCreateOrUpdateParameters { Properties = properties };
var updateResponse = sqlClient.SecurityAlertPolicy.CreateOrUpdateDatabaseSecurityAlertPolicy(resourceGroupName, server.Name, database.Name, updateParams);
// Verify that the initial Get request contains the default policy.
TestUtilities.ValidateOperationResponse(updateResponse);
var getUpdatedPolicyResponse = sqlClient.SecurityAlertPolicy.GetDatabaseSecurityAlertPolicy(resourceGroupName, server.Name, database.Name);
var updatedProperties = getUpdatedPolicyResponse.SecurityAlertPolicy.Properties;
// Verify that the Get request contains the updated policy.
TestUtilities.ValidateOperationResponse(getUpdatedPolicyResponse);
VerifySecurityAlertPolicyInformation(properties, updatedProperties);
}
/// <summary>
/// The non-boilerplated test code of the APIs for managing the lifecycle of a given database's auditing policy. It is meant to be called with a name of an already existing database (and therefore already existing
/// server and resource group). This test does not create these resources and does not remove them.
/// </summary>
private void TestDatabaseAuditingAPIs(SqlManagementClient sqlClient, string resourceGroupName, Server server, Database database)
{
DatabaseAuditingPolicyGetResponse getDefaultDatabasePolicyResponse = sqlClient.AuditingPolicy.GetDatabasePolicy(resourceGroupName, server.Name, database.Name);
DatabaseAuditingPolicyProperties properties = getDefaultDatabasePolicyResponse.AuditingPolicy.Properties;
// Verify that the initial Get request contains the default policy.
TestUtilities.ValidateOperationResponse(getDefaultDatabasePolicyResponse, HttpStatusCode.OK);
VerifyDatabaseAuditingPolicyInformation(GetDefaultDatabaseAuditProperties(), properties);
// Modify the policy properties, send and receive, see it its still ok
ChangeDataBaseAuditPolicy(properties);
DatabaseAuditingPolicyCreateOrUpdateParameters updateParams =
new DatabaseAuditingPolicyCreateOrUpdateParameters {Properties = properties};
var updateResponse = sqlClient.AuditingPolicy.CreateOrUpdateDatabasePolicy(resourceGroupName, server.Name, database.Name, updateParams);
// Verify that the initial Get request contains the default policy.
TestUtilities.ValidateOperationResponse(updateResponse, HttpStatusCode.OK);
DatabaseAuditingPolicyGetResponse getUpdatedPolicyResponse = sqlClient.AuditingPolicy.GetDatabasePolicy(resourceGroupName, server.Name, database.Name);
DatabaseAuditingPolicyProperties updatedProperties = getUpdatedPolicyResponse.AuditingPolicy.Properties;
// Verify that the Get request contains the updated policy.
TestUtilities.ValidateOperationResponse(getUpdatedPolicyResponse, HttpStatusCode.OK);
VerifyDatabaseAuditingPolicyInformation(properties, updatedProperties);
}
/// <summary>
/// Create Azure Sql Server SQL2X Queue database
/// </summary>
/// <returns>MVC View</returns>
//[HttpGet("CreateDatabase")]
public ActionResult CreateDatabase()
{
if (IsLocal)
{
DatabaseCreate("NorSolutionPim");
}
else
{
SqlManagementClient sqlClient = AzureSqlClient();
var newDb = new Microsoft.Azure.Management.Sql.Models.Database {
Location = "East US 2",
LicenseType = "BasePrice",
Sku = new Sku(name: "Basic")
};
sqlClient.Databases.CreateOrUpdate(
resourceGroupName: "Default-SQL-EastUS2",
serverName: "sqlServerName",
databaseName: "NorSolutionPim",
parameters: newDb
);
}
return(View());
}
/// <summary>
/// The non-boilerplated test code of the APIs for managing the lifecycle of a given database's secure connection policy.
/// It is meant to be called with a name of an already exisiting database (and therefore already existing server and resource group).
/// </summary>
private void TestSecureConnectionAPIs(SqlManagementClient sqlClient, string resourceGroupName, Server server, Database database)
{
DatabaseSecureConnectionPolicyGetResponse getDefaultSecureConnectionPolicyResponse = sqlClient.SecureConnection.GetDatabasePolicy(resourceGroupName, server.Name, database.Name);
DatabaseSecureConnectionPolicyProperties properties = getDefaultSecureConnectionPolicyResponse.SecureConnectionPolicy.Properties;
// Verify that the initial Get request contains the default policy.
TestUtilities.ValidateOperationResponse(getDefaultSecureConnectionPolicyResponse, HttpStatusCode.OK);
VerifySecureConnectionPolicyInformation(getDefaultSecureConnectionPolicyProperties(server.Name), properties);
// Modify the policy properties, send and receive, see it its still ok
properties.SecurityEnabledAccess = "Required";
DatabaseSecureConnectionPolicyCreateOrUpdateParameters updateParams = new DatabaseSecureConnectionPolicyCreateOrUpdateParameters();
updateParams.Properties = ConvertToSecureConnectionPolicyCreateProperties(properties);
var updateResponse = sqlClient.SecureConnection.CreateOrUpdateDatabasePolicy(resourceGroupName, server.Name, database.Name, updateParams);
// Verify that the initial Get request of contains the default policy.
TestUtilities.ValidateOperationResponse(updateResponse, HttpStatusCode.OK);
DatabaseSecureConnectionPolicyGetResponse getUpdatedPolicyResponse = sqlClient.SecureConnection.GetDatabasePolicy(resourceGroupName, server.Name, database.Name);
DatabaseSecureConnectionPolicyProperties updatedProperties = getUpdatedPolicyResponse.SecureConnectionPolicy.Properties;
// Verify that the Get request contains the updated policy.
TestUtilities.ValidateOperationResponse(getUpdatedPolicyResponse, HttpStatusCode.OK);
VerifySecureConnectionPolicyInformation(properties, updatedProperties);
}
/// <summary>
/// Remove Azure SQL server SQL2X Queue database
/// </summary>
/// <returns>MVC View</returns>
//[HttpGet("RemoveDatabase")]
public ActionResult RemoveDatabase()
{
if (IsLocal)
{
DatabaseDelete("NorSolutionPim");
}
else
{
SqlManagementClient sqlClient = AzureSqlClient();
var newDb = new Microsoft.Azure.Management.Sql.Models.Database {
Location = "East US 2"
};
sqlClient.Databases.Delete(
resourceGroupName: "Default-SQL-EastUS2",
serverName: "sqlServerName",
databaseName: "NorSolutionPim"
);
}
return(View());
}
/// <summary>
/// The non-boilerplated test code of the APIs for managing the lifecycle of a given database's blob auditing policy. It is meant to be called with a name of an already existing database (and therefore already existing
/// server and resource group). This test does not create these resources and does not remove them.
/// </summary>
private void TestDatabaseAuditingApis(SqlManagementClient sqlClient, string resourceGroupName, Server server, Database database)
{
BlobAuditingGetResponse getDefaultDatabasePolicyResponse = sqlClient.BlobAuditing.GetDatabaseBlobAuditingPolicy(resourceGroupName, server.Name, database.Name);
var properties = getDefaultDatabasePolicyResponse.AuditingPolicy.Properties;
// Verify that the initial Get request contains the default policy.
TestUtilities.ValidateOperationResponse(getDefaultDatabasePolicyResponse);
VerifyAuditingPolicyInformation(GetDefaultBlobAuditProperties(), properties);
// Modify the policy properties, send and receive, see it its still ok
var updateParams = new BlobAuditingCreateOrUpdateParameters { Properties = properties };
var updateResponse = sqlClient.BlobAuditing.CreateOrUpdateDatabasePolicy(resourceGroupName, server.Name, database.Name, updateParams);
// Verify that the initial Get request contains the default policy.
TestUtilities.ValidateOperationResponse(updateResponse);
var getUpdatedPolicyResponse = sqlClient.BlobAuditing.GetDatabaseBlobAuditingPolicy(resourceGroupName, server.Name, database.Name);
var updatedProperties = getUpdatedPolicyResponse.AuditingPolicy.Properties;
// Verify that the Get request contains the updated policy.
TestUtilities.ValidateOperationResponse(getUpdatedPolicyResponse);
VerifyAuditingPolicyInformation(properties, updatedProperties);
}
/// <summary>
/// The non-boilerplated test code of the APIs for managing the lifecycle data masking rules.
/// It is meant to be called with a name of an already exisiting database (and therefore already existing server and resource group).
/// This test does not create these resources and does not remove them.
/// The flow is:
/// 1) Create policy (it's a prereq)
/// 2) Create rule1, validate its creation and its content by doing another GET call
/// 3) Update rule1, validate the update by doing another GET call
/// 4) Create rule2, validate its creation and its content
/// 5) Get the list of rules, see that there are two and each one of them has the right content
/// 6) Delete rule1, see that we get OK
/// 8) List the rules, see that we now have one rule there and it is rule 2
/// </summary>
/// <param name="sqlClient">The sqlClient</param>
/// <param name="resourceGroupName">The resource group name to use in this test</param>
/// <param name="server">The server to use in this test</param>
/// <param name="database">The database to use in this test</param>
private void TestDataMaskingRuleAPIs(SqlManagementClient sqlClient, string resourceGroupName, Server server, Database database)
{
DataMaskingPolicyCreateOrUpdateParameters policyParams = new DataMaskingPolicyCreateOrUpdateParameters();
policyParams.Properties = MakeDefaultDataMaskingPolicyProperties();
policyParams.Properties.DataMaskingState = "Enabled";
sqlClient.DataMasking.CreateOrUpdatePolicy(resourceGroupName, server.Name, database.Name, policyParams);
int ruleCounter = 1;
DataMaskingRuleCreateOrUpdateParameters ruleParams = new DataMaskingRuleCreateOrUpdateParameters();
string serverName = server.Properties.FullyQualifiedDomainName;
string uid = server.Properties.AdministratorLogin;
string pwd = server.Properties.AdministratorLoginPassword;
string dbName = database.Name;
string connString = string.Format("Server={0};uid={1}; pwd={2};Database={3};Integrated Security=False;", serverName, uid, pwd, dbName);
var conn = new SqlConnection();
conn.ConnectionString = connString;
string tableName = "table1", columnName = "column1";
string firewallRuleName = TestUtilities.GenerateName("all");
string startIp1 = "1.1.1.1";
string endIp1 = "255.255.255.255";
sqlClient.FirewallRules.CreateOrUpdate(resourceGroupName, serverName.Split('.').ElementAt(0), firewallRuleName, new FirewallRuleCreateOrUpdateParameters()
{
Properties = new FirewallRuleCreateOrUpdateProperties()
{
StartIpAddress = startIp1,
EndIpAddress = endIp1,
}
});
CreateDatabaseContents(conn, tableName, columnName);
ruleParams.Properties = MakeRuleProperties(ruleCounter++ ,tableName, columnName);
string rule1Name = ruleParams.Properties.Id;
var createRuleResponse = sqlClient.DataMasking.CreateOrUpdateRule(resourceGroupName, server.Name, database.Name, rule1Name, ruleParams);
// Verify that the initial create request went well.
TestUtilities.ValidateOperationResponse(createRuleResponse, HttpStatusCode.OK);
var getAfterCreateResponse = sqlClient.DataMasking.GetRule(resourceGroupName, server.Name, database.Name, rule1Name);
TestUtilities.ValidateOperationResponse(getAfterCreateResponse, HttpStatusCode.OK);
VerifyDataMaskingRuleInformation(getAfterCreateResponse.DataMaskingRule.Properties, ruleParams.Properties);
// Modify the policy properties, send and receive, see it its still ok
string updatedTableName = "tbl2";
CreateDatabaseContents(conn, updatedTableName, columnName);
ruleParams.Properties.TableName = updatedTableName;
var updateResponse = sqlClient.DataMasking.CreateOrUpdateRule(resourceGroupName, server.Name, database.Name, rule1Name, ruleParams);
TestUtilities.ValidateOperationResponse(updateResponse, HttpStatusCode.OK);
var getAfterUpdateResponse = sqlClient.DataMasking.GetRule(resourceGroupName, server.Name, database.Name, rule1Name);
TestUtilities.ValidateOperationResponse(getAfterUpdateResponse, HttpStatusCode.OK);
VerifyDataMaskingRuleInformation(getAfterUpdateResponse.DataMaskingRule.Properties, ruleParams.Properties);
DataMaskingRuleCreateOrUpdateParameters ruleParams2 = new DataMaskingRuleCreateOrUpdateParameters();
tableName = "table2";
columnName = "column2";
CreateDatabaseContents(conn, tableName, columnName);
ruleParams2.Properties = MakeRuleProperties(ruleCounter++, tableName, columnName);
string rule2Name = ruleParams2.Properties.Id;
createRuleResponse = sqlClient.DataMasking.CreateOrUpdateRule(resourceGroupName, server.Name, database.Name, rule2Name, ruleParams2);
TestUtilities.ValidateOperationResponse(updateResponse, HttpStatusCode.OK);
DataMaskingRuleListResponse listResponse = sqlClient.DataMasking.List(resourceGroupName, server.Name, database.Name);
TestUtilities.ValidateOperationResponse(listResponse, HttpStatusCode.OK);
Assert.Equal(2, listResponse.DataMaskingRules.Count);
VerifyDataMaskingRuleInformation(listResponse.DataMaskingRules.FirstOrDefault(r => r.Properties.Id == rule1Name).Properties, ruleParams.Properties);
VerifyDataMaskingRuleInformation(listResponse.DataMaskingRules.FirstOrDefault(r => r.Properties.Id == rule2Name).Properties, ruleParams2.Properties);
AzureOperationResponse deleteResponse = sqlClient.DataMasking.Delete(resourceGroupName, server.Name, database.Name, rule1Name);
TestUtilities.ValidateOperationResponse(deleteResponse, HttpStatusCode.OK);
DataMaskingRuleListResponse listAfterDeleteResponse = sqlClient.DataMasking.List(resourceGroupName, server.Name, database.Name);
TestUtilities.ValidateOperationResponse(listAfterDeleteResponse, HttpStatusCode.OK);
Assert.Equal(listAfterDeleteResponse.DataMaskingRules.Count, 1);
VerifyDataMaskingRuleInformation(listResponse.DataMaskingRules.FirstOrDefault(r => r.Properties.Id == rule2Name).Properties, ruleParams2.Properties);
}
/// <summary>
/// Verify that the Database object matches the provided values
/// </summary>
/// <param name="serverLocation">The expected server location</param>
/// <param name="databaseCollation">The expected database collation</param>
/// <param name="databaseEdition">The expected database edition</param>
/// <param name="databaseMaxSize">The expected database max size</param>
/// <param name="currentSlo">The expected database service objective</param>
/// <param name="db">The actual database object</param>
private static void VerifyDatabaseInformation(Database db, string serverLocation, string databaseCollation, string databaseEdition, long databaseMaxSize, Guid requestedSlo, Guid currentSlo, string status = null)
{
Assert.Equal(serverLocation, db.Location);
Assert.Equal(databaseCollation, db.Properties.Collation);
Assert.Equal(databaseEdition, db.Properties.Edition);
Assert.Equal(databaseMaxSize, db.Properties.MaxSizeBytes);
Assert.Equal(requestedSlo.ToString(), db.Properties.RequestedServiceObjectiveId);
Assert.Equal(currentSlo.ToString(), db.Properties.CurrentServiceObjectiveId);
if(status != null)
{
Assert.Equal(status, db.Properties.Status);
}
}
/// <summary>
/// The non-boilerplated test code of the APIs for managing the lifecycle data masking rules.
/// It is meant to be called with a name of an already exisiting database (and therefore already existing server and resource group).
/// This test does not create these resources and does not remove them.
/// The flow is:
/// 1) Create policy (it's a prereq)
/// 2) Create rule1, validate its creation and its content by doing another GET call
/// 3) Update rule1, validate the update by doing another GET call
/// 4) Create rule2, validate its creation and its content
/// 5) Get the list of rules, see that there are two and each one of them has the right content
/// 6) Delete rule1, see that we get OK
/// 8) List the rules, see that we now have one rule there and it is rule 2
/// </summary>
/// <param name="sqlClient">The sqlClient</param>
/// <param name="resourceGroupName">The resource group name to use in this test</param>
/// <param name="server">The server to use in this test</param>
/// <param name="database">The database to use in this test</param>
private void TestDataMaskingRuleAPIs(SqlManagementClient sqlClient, string resourceGroupName, Server server, Database database)
{
DataMaskingPolicyCreateOrUpdateParameters policyParams = new DataMaskingPolicyCreateOrUpdateParameters();
policyParams.Properties = MakeDefaultDataMaskingPolicyProperties();
policyParams.Properties.DataMaskingState = "Enabled";
sqlClient.DataMasking.CreateOrUpdatePolicy(resourceGroupName, server.Name, database.Name, policyParams);
int ruleCounter = 1;
DataMaskingRuleCreateOrUpdateParameters ruleParams = new DataMaskingRuleCreateOrUpdateParameters();
string serverName = server.Properties.FullyQualifiedDomainName;
string uid = server.Properties.AdministratorLogin;
string pwd = server.Properties.AdministratorLoginPassword;
string dbName = database.Name;
string connString = string.Format("Server={0};uid={1}; pwd={2};Database={3};Integrated Security=False;", serverName, uid, pwd, dbName);
var conn = new SqlConnection();
conn.ConnectionString = connString;
string tableName = "table1", columnName = "column1";
string firewallRuleName = TestUtilities.GenerateName("all");
string startIp1 = "1.1.1.1";
string endIp1 = "255.255.255.255";
sqlClient.FirewallRules.CreateOrUpdate(resourceGroupName, serverName.Split('.').ElementAt(0), firewallRuleName, new FirewallRuleCreateOrUpdateParameters()
{
Properties = new FirewallRuleCreateOrUpdateProperties()
{
StartIpAddress = startIp1,
EndIpAddress = endIp1,
}
});
CreateDatabaseContents(conn, tableName, columnName);
Func<DataMaskingRuleCreateOrUpdateParameters, Func<DataMaskingRule, bool>> isRuleOnColumn = (DataMaskingRuleCreateOrUpdateParameters parms) =>
{
return (DataMaskingRule r1) =>
{
return parms.Properties.ColumnName == r1.Properties.ColumnName &&
parms.Properties.TableName == r1.Properties.TableName &&
parms.Properties.SchemaName == r1.Properties.SchemaName;
};
};
ruleParams.Properties = MakeRuleProperties(ruleCounter++ ,tableName, columnName);
string rule1Name = ruleParams.Properties.Id;
var createRuleResponse = sqlClient.DataMasking.CreateOrUpdateRule(resourceGroupName, server.Name, database.Name, rule1Name, ruleParams);
TestUtilities.ValidateOperationResponse(createRuleResponse, HttpStatusCode.OK);
var listAfterCreateResponse = sqlClient.DataMasking.List(resourceGroupName, server.Name, database.Name);
TestUtilities.ValidateOperationResponse(listAfterCreateResponse, HttpStatusCode.OK);
Assert.Equal(1, listAfterCreateResponse.DataMaskingRules.Count);
DataMaskingRule receivedRule = listAfterCreateResponse.DataMaskingRules.FirstOrDefault(isRuleOnColumn(ruleParams));
VerifyDataMaskingRuleInformation(receivedRule.Properties, ruleParams.Properties);
// Modify the policy properties, send and receive, see it its still ok
ruleParams.Properties.PrefixSize = "2";
ruleParams.Properties.ReplacementString = "ABC";
ruleParams.Properties.SuffixSize = "1";
var updateRuleResponse = sqlClient.DataMasking.CreateOrUpdateRule(resourceGroupName, server.Name, database.Name, rule1Name, ruleParams);
TestUtilities.ValidateOperationResponse(updateRuleResponse, HttpStatusCode.OK);
var listUpdateResponse = sqlClient.DataMasking.List(resourceGroupName, server.Name, database.Name);
TestUtilities.ValidateOperationResponse(listUpdateResponse, HttpStatusCode.OK);
Assert.Equal(1, listUpdateResponse.DataMaskingRules.Count);
var updatedRule = listUpdateResponse.DataMaskingRules.FirstOrDefault(isRuleOnColumn(ruleParams));
VerifyDataMaskingRuleInformation(updatedRule.Properties, ruleParams.Properties);
DataMaskingRuleCreateOrUpdateParameters ruleParams2 = new DataMaskingRuleCreateOrUpdateParameters();
tableName = "table2";
columnName = "column2";
CreateDatabaseContents(conn, tableName, columnName);
ruleParams2.Properties = MakeRuleProperties(ruleCounter++, tableName, columnName);
string rule2Name = ruleParams2.Properties.Id;
var createSecondRuleResponse = sqlClient.DataMasking.CreateOrUpdateRule(resourceGroupName, server.Name, database.Name, rule2Name, ruleParams2);
TestUtilities.ValidateOperationResponse(createSecondRuleResponse, HttpStatusCode.OK);
DataMaskingRuleListResponse listAfterSecondCreateResponse = sqlClient.DataMasking.List(resourceGroupName, server.Name, database.Name);
TestUtilities.ValidateOperationResponse(listAfterSecondCreateResponse, HttpStatusCode.OK);
Assert.Equal(2, listAfterSecondCreateResponse.DataMaskingRules.Count);
updatedRule = listUpdateResponse.DataMaskingRules.FirstOrDefault(isRuleOnColumn(ruleParams));
VerifyDataMaskingRuleInformation(updatedRule.Properties, ruleParams.Properties);
var receivedSecondRule = listAfterSecondCreateResponse.DataMaskingRules.FirstOrDefault(isRuleOnColumn(ruleParams2));
VerifyDataMaskingRuleInformation(receivedSecondRule.Properties, ruleParams2.Properties);
AzureOperationResponse deleteResponse = sqlClient.DataMasking.Delete(resourceGroupName, server.Name, database.Name, rule1Name);
TestUtilities.ValidateOperationResponse(deleteResponse, HttpStatusCode.OK);
DataMaskingRuleListResponse listAfterDeleteResponse = sqlClient.DataMasking.List(resourceGroupName, server.Name, database.Name);
TestUtilities.ValidateOperationResponse(listAfterDeleteResponse, HttpStatusCode.OK);
Assert.Equal(listAfterDeleteResponse.DataMaskingRules.Count, 1);
var receivedAfterDelete = listAfterSecondCreateResponse.DataMaskingRules.FirstOrDefault(isRuleOnColumn(ruleParams2));
VerifyDataMaskingRuleInformation(receivedAfterDelete.Properties, ruleParams2.Properties);
}
/// <summary>
/// The non-boilerplated test code of the APIs for managing the lifecycle data masking rules.
/// It is meant to be called with a name of an already exisiting database (and therefore already existing server and resource group).
/// This test does not create these resources and does not remove them.
/// The flow is:
/// 1) Create policy (it's a prereq)
/// 2) Create rule1, validate its creation and its content by doing another GET call
/// 3) Update rule1, validate the update by doing another GET call
/// 4) Create rule2, validate its creation and its content
/// 5) Get the list of rules, see that there are two and each one of them has the right content
/// 6) Delete rule1, see that we get OK
/// 8) List the rules, see that we now have one rule there and it is rule 2
/// </summary>
/// <param name="sqlClient">The sqlClient</param>
/// <param name="resourceGroupName">The resource group name to use in this test</param>
/// <param name="server">The server to use in this test</param>
/// <param name="database">The database to use in this test</param>
private void TestDataMaskingRuleAPIs(SqlManagementClient sqlClient, string resourceGroupName, Server server, Database database)
{
DataMaskingPolicyCreateOrUpdateParameters policyParams = new DataMaskingPolicyCreateOrUpdateParameters();
policyParams.Properties = MakeDefaultDataMaskingPolicyProperties();
policyParams.Properties.MaskingLevel = "Relaxed";
sqlClient.DataMasking.CreateOrUpdatePolicy(resourceGroupName, server.Name, database.Name, policyParams);
int ruleCounter = 1;
DataMaskingRuleCreateOrUpdateParameters ruleParams = new DataMaskingRuleCreateOrUpdateParameters();
ruleParams.Properties = MakeRuleProperties(ruleCounter++);
string rule1Name = ruleParams.Properties.Id;
var createRuleResponse = sqlClient.DataMasking.CreateOrUpdateRule(resourceGroupName, server.Name, database.Name, rule1Name, ruleParams);
// Verify that the initial create request went well.
TestUtilities.ValidateOperationResponse(createRuleResponse, HttpStatusCode.OK);
var getAfterCreateResponse = sqlClient.DataMasking.GetRule(resourceGroupName, server.Name, database.Name, rule1Name);
TestUtilities.ValidateOperationResponse(getAfterCreateResponse, HttpStatusCode.OK);
VerifyDataMaskingRuleInformation(getAfterCreateResponse.DataMaskingRule.Properties, ruleParams.Properties);
// Modify the policy properties, send and receive, see it its still ok
ruleParams.Properties.TableName = "tbl2";
var updateResponse = sqlClient.DataMasking.CreateOrUpdateRule(resourceGroupName, server.Name, database.Name, rule1Name, ruleParams);
TestUtilities.ValidateOperationResponse(updateResponse, HttpStatusCode.OK);
var getAfterUpdateResponse = sqlClient.DataMasking.GetRule(resourceGroupName, server.Name, database.Name, rule1Name);
TestUtilities.ValidateOperationResponse(getAfterUpdateResponse, HttpStatusCode.OK);
VerifyDataMaskingRuleInformation(getAfterUpdateResponse.DataMaskingRule.Properties, ruleParams.Properties);
DataMaskingRuleCreateOrUpdateParameters ruleParams2 = new DataMaskingRuleCreateOrUpdateParameters();
ruleParams2.Properties = MakeRuleProperties(ruleCounter++);
string rule2Name = ruleParams2.Properties.Id;
createRuleResponse = sqlClient.DataMasking.CreateOrUpdateRule(resourceGroupName, server.Name, database.Name, rule2Name, ruleParams2);
TestUtilities.ValidateOperationResponse(updateResponse, HttpStatusCode.OK);
DataMaskingRuleListResponse listResponse = sqlClient.DataMasking.List(resourceGroupName, server.Name, database.Name);
TestUtilities.ValidateOperationResponse(listResponse, HttpStatusCode.OK);
Assert.Equal(2, listResponse.DataMaskingRules.Count);
VerifyDataMaskingRuleInformation(listResponse.DataMaskingRules.FirstOrDefault(r => r.Name == rule1Name).Properties, ruleParams.Properties);
VerifyDataMaskingRuleInformation(listResponse.DataMaskingRules.FirstOrDefault(r => r.Name == rule2Name).Properties, ruleParams2.Properties);
AzureOperationResponse deleteResponse = sqlClient.DataMasking.Delete(resourceGroupName, server.Name, database.Name, rule1Name);
TestUtilities.ValidateOperationResponse(deleteResponse, HttpStatusCode.OK);
DataMaskingRuleListResponse listAfterDeleteResponse = sqlClient.DataMasking.List(resourceGroupName, server.Name, database.Name);
TestUtilities.ValidateOperationResponse(listAfterDeleteResponse, HttpStatusCode.OK);
Assert.Equal(listAfterDeleteResponse.DataMaskingRules.Count, 1);
VerifyDataMaskingRuleInformation(listResponse.DataMaskingRules.FirstOrDefault(r => r.Name == rule2Name).Properties, ruleParams2.Properties);
}
/// <summary>
/// Create upgrade start parameters for testing
/// </summary>
/// <param name="version">The version to upgrade the server to</param>
/// <param name="scheduleUpgradeAfter">The earliest time to upgrade the server</param>
/// <param name="database">The database to map to new edition and SLO. Target SLO and edition are in the constants at the top of this file</param>
/// <returns>The server upgrade start parameters object</returns>
private ServerUpgradeStartParameters CreateUpgradeStartParameters(
string version = upgradedVersion,
DateTime? scheduleUpgradeAfter = null,
Database database = null)
{
var parameters = new ServerUpgradeStartParameters()
{
Properties = new ServerUpgradeProperties()
{
Version = version,
ScheduleUpgradeAfterUtcDateTime = scheduleUpgradeAfter
}
};
if (database != null)
{
parameters.Properties.DatabaseCollection = new List<RecommendedDatabaseProperties>()
{
new RecommendedDatabaseProperties()
{
Name = database.Name,
TargetServiceLevelObjective = targetServiceLevelObjective,
TargetEdition = targetEdition
}
};
}
return parameters;
}
/// <summary>
/// Implementation of the negative test for upgrade server.
/// </summary>
/// <param name="sqlClient">The SQL Management client</param>
/// <param name="resourceGroupName">The resource group containing the server to upgrade</param>
/// <param name="server">The server to upgrade</param>
/// <param name="database">The database under server that will be mapped to new edition and SLO</param>
private void UpgradeServerNegative(SqlManagementClient sqlClient, string resourceGroupName, Server server, Database database)
{
// Null or empty parameter for upgrade
Assert.Throws<ArgumentNullException>(() => sqlClient.ServerUpgrades.Start(resourceGroupName, server.Name, null));
Assert.Throws<ArgumentNullException>(() => sqlClient.ServerUpgrades.Start(resourceGroupName, server.Name, new ServerUpgradeStartParameters()));
// Invalid version
var invalidVersionParameters = CreateUpgradeStartParameters(version: "13.0");
Assert.Throws<CloudException>(() => sqlClient.ServerUpgrades.Start(resourceGroupName, server.Name, invalidVersionParameters));
// Invalid ScheduleAfter time
var invalidScheduleParameters = CreateUpgradeStartParameters(scheduleUpgradeAfter: DateTime.UtcNow);
Assert.Throws<CloudException>(() => sqlClient.ServerUpgrades.Start(resourceGroupName, server.Name, invalidScheduleParameters));
// Invalid edition
var invalidEditionParameters = CreateUpgradeStartParameters(database: database);
invalidEditionParameters.Properties.DatabaseCollection[0].TargetEdition = "InvalidEdition";
Assert.Throws<CloudException>(() => sqlClient.ServerUpgrades.Start(resourceGroupName, server.Name, invalidEditionParameters));
// Invalid edition and slo combination
var mismatchedSloAndEditionParameters = CreateUpgradeStartParameters(database: database);
mismatchedSloAndEditionParameters.Properties.DatabaseCollection[0].TargetEdition = "Premium";
mismatchedSloAndEditionParameters.Properties.DatabaseCollection[0].TargetServiceLevelObjective = "S0";
Assert.Throws<CloudException>(() => sqlClient.ServerUpgrades.Start(resourceGroupName, server.Name, mismatchedSloAndEditionParameters));
}
/// <summary>
/// Implementation of the positive test to upgrade server and poll for upgrade status until the upgrade is completed.
/// The test server has 1 database that will be mapped to a new edition and SLO after the upgrade
/// </summary>
/// <param name="sqlClient">The SQL Management client</param>
/// <param name="resourceGroupName">The resource group containing the server to upgrade</param>
/// <param name="server">The server to upgrade</param>
/// <param name="database">The database under server that will be mapped to new edition and SLO</param>
private void UpgradeServer(SqlManagementClient sqlClient, string resourceGroupName, Server server, Database database)
{
var parameters = CreateUpgradeStartParameters(database: database);
var startResponse = sqlClient.ServerUpgrades.Start(resourceGroupName, server.Name, parameters);
Assert.True(startResponse.StatusCode == HttpStatusCode.Accepted);
// Get server upgrade status
while (true)
{
var getUpgradeResponse = sqlClient.ServerUpgrades.Get(resourceGroupName, server.Name);
if (getUpgradeResponse.StatusCode == HttpStatusCode.OK)
{
Debug.WriteLine(getUpgradeResponse);
break;
}
// status must be Queued or InProgress
Assert.True(getUpgradeResponse.Status.Equals(upgradeStatusQueued, StringComparison.InvariantCultureIgnoreCase) ||
getUpgradeResponse.Status.Equals(upgradeStatusInProgress, StringComparison.InvariantCultureIgnoreCase));
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(UpgradePollingTimeInSeconds));
}
// Make sure that server has new version
var serverGetResponse = sqlClient.Servers.Get(resourceGroupName, server.Name);
TestUtilities.ValidateOperationResponse(serverGetResponse);
Assert.Equal(serverGetResponse.Server.Properties.Version, upgradedVersion);
if (database != null)
{
// Make sure that database has new edition
var databaseGetResponse = sqlClient.Databases.Get(resourceGroupName, server.Name, database.Name);
TestUtilities.ValidateOperationResponse(databaseGetResponse);
Assert.Equal(databaseGetResponse.Database.Properties.Edition, targetEdition);
}
}
/// <summary>
/// Create upgrade start parameters for testing
/// </summary>
/// <param name="version">The version to upgrade the server to</param>
/// <param name="scheduleUpgradeAfter">The earliest time to upgrade the server</param>
/// <param name="recommendedDatabase">The database to map to new edition and SLO. Target SLO and edition are in the constants at the top of this file</param>
/// <param name="databaseInElasticPool">The database to be put in new elastic pool. Elastic pool properties are in the constants at the top of this file</param>
/// <returns>The server upgrade start parameters object</returns>
private ServerUpgradeStartParameters CreateUpgradeStartParameters(
string version = upgradedVersion,
DateTime? scheduleUpgradeAfter = null,
Database recommendedDatabase = null,
Database databaseInElasticPool = null)
{
var parameters = new ServerUpgradeStartParameters()
{
Properties = new ServerUpgradeProperties()
{
Version = version,
ScheduleUpgradeAfterUtcDateTime = scheduleUpgradeAfter
}
};
if (recommendedDatabase != null)
{
parameters.Properties.DatabaseCollection = new List<RecommendedDatabaseProperties>()
{
new RecommendedDatabaseProperties()
{
Name = recommendedDatabase.Name,
TargetServiceLevelObjective = targetServiceLevelObjective,
TargetEdition = targetEdition
}
};
}
if (databaseInElasticPool != null)
{
parameters.Properties.ElasticPoolCollection = new List<UpgradeRecommendedElasticPoolProperties>()
{
// Create an elastic pool with default values and contain only the provided database
new UpgradeRecommendedElasticPoolProperties()
{
Name = TestUtilities.GenerateName("csm-ep-"),
Edition = targetEdition,
Dtu = defaultElasticPoolDtu,
StorageMb = defaultElasticPoolStorageMb,
DatabaseDtuMax = defaultElasticPoolDatabaseDtuMax,
DatabaseDtuMin = defaultElasticPoolDatabaseDtuMin,
DatabaseCollection = new List<string>() { databaseInElasticPool.Name }
}
};
}
return parameters;
}
/// <summary>
/// Implementation of the positive test to upgrade server and poll for upgrade status until the upgrade is completed.
/// The test server has 1 database that will be put into a new elastic pool after the upgrade
/// </summary>
/// <param name="sqlClient">The SQL Management client</param>
/// <param name="resourceGroupName">The resource group containing the server to upgrade</param>
/// <param name="server">The server to upgrade</param>
/// <param name="databaseInElasticPool">The database under server that will be put into a new elastic pool</param>
private void UpgradeServerWithElasticPool(SqlManagementClient sqlClient, string resourceGroupName, Server server, Database databaseInElasticPool)
{
var parameters = CreateUpgradeStartParameters(databaseInElasticPool: databaseInElasticPool);
var startResponse = sqlClient.ServerUpgrades.Start(resourceGroupName, server.Name, parameters);
Assert.True(startResponse.StatusCode == HttpStatusCode.Accepted);
// Get server upgrade status
while (true)
{
var getUpgradeResponse = sqlClient.ServerUpgrades.Get(resourceGroupName, server.Name);
if (getUpgradeResponse.StatusCode == HttpStatusCode.OK)
{
Debug.WriteLine(getUpgradeResponse);
break;
}
// status must be Queued or InProgress
Assert.True(getUpgradeResponse.Status.Equals(upgradeStatusQueued, StringComparison.InvariantCultureIgnoreCase) ||
getUpgradeResponse.Status.Equals(upgradeStatusInProgress, StringComparison.InvariantCultureIgnoreCase));
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(upgradePollingTimeInSeconds));
}
// Make sure that server has new version
var serverGetResponse = sqlClient.Servers.Get(resourceGroupName, server.Name);
TestUtilities.ValidateOperationResponse(serverGetResponse);
Assert.Equal(serverGetResponse.Server.Properties.Version, upgradedVersion);
if (databaseInElasticPool != null)
{
// Make sure that elastic pool has desired properties
var elasticPoolListGetResponse = sqlClient.ElasticPools.List(resourceGroupName, server.Name);
TestUtilities.ValidateOperationResponse(elasticPoolListGetResponse);
Assert.Equal(elasticPoolListGetResponse.ElasticPools.Count, 1);
var elasticPool = elasticPoolListGetResponse.ElasticPools.FirstOrDefault();
var expectedElasticPool = parameters.Properties.ElasticPoolCollection.FirstOrDefault();
Assert.Equal(elasticPool.Name, expectedElasticPool.Name);
Assert.Equal(elasticPool.Properties.Dtu, expectedElasticPool.Dtu);
Assert.Equal(elasticPool.Properties.DatabaseDtuMin, expectedElasticPool.DatabaseDtuMin);
Assert.Equal(elasticPool.Properties.DatabaseDtuMax, expectedElasticPool.DatabaseDtuMax);
Assert.Equal(elasticPool.Properties.Edition, expectedElasticPool.Edition);
Assert.Equal(elasticPool.Properties.StorageMB, expectedElasticPool.StorageMb);
}
}
