public void GetRecoverableDatabaseNonExistentDb()
{
var testSession = MockServerHelper.DefaultSessionCollection.GetSession(
"UnitTest.GetRecoverableDatabaseNonExistentDb");
ServerTestHelper.SetDefaultTestSessionSettings(testSession);
testSession.RequestValidator =
new Action <HttpMessage, HttpMessage.Request>(
(expected, actual) =>
{
Assert.AreEqual(expected.RequestInfo.Method, actual.Method);
Assert.IsTrue(
actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue),
"Missing proper UserAgent string.");
});
using (var exceptionManager = new AsyncExceptionManager())
{
using (new MockHttpServer(
exceptionManager, MockHttpServer.DefaultHttpsServerPrefixUri, testSession))
{
powershell.InvokeBatchScript(
@"Get-AzureSqlRecoverableDatabase " +
@"-ServerName $serverName " +
@"-DatabaseName testdbnonexistent");
}
Assert.AreEqual(
1, powershell.Streams.Error.Count,
"Expecting errors");
Assert.AreEqual(
1, powershell.Streams.Warning.Count,
"Expecting tracing IDs");
Assert.AreEqual(
string.Format(
CultureInfo.InvariantCulture,
"Resource with the name '{0}' does not exist. To continue, specify a valid resource name.",
"testdbnonexistent"),
powershell.Streams.Error.First().Exception.Message,
"Unexpected error message");
Assert.IsTrue(
powershell.Streams.Warning[0].Message.StartsWith("Request Id"),
"Expecting Client Request Id");
}
}
/// <summary>
/// Helper function to remove the test databases.
/// </summary>
public static void RemoveTestDatabasesWithCertAuth(System.Management.Automation.PowerShell powershell)
{
HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession(
"UnitTest.Common.RemoveTestDatabasesWithCertAuth");
ServerTestHelper.SetDefaultTestSessionSettings(testSession);
testSession.RequestValidator =
new Action <HttpMessage, HttpMessage.Request>(
(expected, actual) =>
{
Assert.AreEqual(expected.RequestInfo.Method, actual.Method);
Assert.IsTrue(
actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue),
"Missing proper UserAgent string.");
});
using (AsyncExceptionManager exceptionManager = new AsyncExceptionManager())
{
using (new MockHttpServer(
exceptionManager,
MockHttpServer.DefaultHttpsServerPrefixUri,
testSession))
{
powershell.InvokeBatchScript(
@"Remove-AzureSqlDatabase " +
@"-ServerName $serverName " +
@"-DatabaseName testdb1 " +
@"-Force");
powershell.InvokeBatchScript(
@"Remove-AzureSqlDatabase " +
@"-ServerName $serverName " +
@"-DatabaseName testdb2 " +
@"-Force");
powershell.InvokeBatchScript(
@"Remove-AzureSqlDatabase " +
@"-ServerName $serverName " +
@"-DatabaseName testdb3 " +
@"-Force");
}
powershell.Streams.ClearStreams();
}
}
public void InitializeTest()
{
TestStartTime = DateTime.Now;
// This test uses the https endpoint, setup the certificates.
MockHttpServer.SetupCertificates();
PowerShell = System.Management.Automation.PowerShell.Create();
Subscription = UnitTestHelper.SetupUnitTestSubscription(PowerShell);
// Set names for the servers we'll use in PowerShell.
PowerShell.Runspace.SessionStateProxy.SetVariable(
"homeServerName", HomeServer);
PowerShell.Runspace.SessionStateProxy.SetVariable(
"partnerServerName", PartnerServer);
// Create a new server
HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession(
string.Format("UnitTest.{0}.{1}", TestContext.FullyQualifiedTestClassName, TestContext.TestName));
ServerTestHelper.SetDefaultTestSessionSettings(testSession);
// When testing production use RDFE
// testSession.ServiceBaseUri = new Uri("https://management.core.windows.net");
// When testing OneBox use Mock RDFE:
if (IsRunningAgainstOneBox)
{
testSession.ServiceBaseUri = new Uri("https://management.dev.mscds.com:12346/");
}
testSession.RequestValidator =
new Action <HttpMessage, HttpMessage.Request>(
(expected, actual) =>
{
Assert.AreEqual(expected.RequestInfo.Method, actual.Method);
Assert.IsTrue(
actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue),
"Missing proper UserAgent string.");
});
ExceptionManager = new AsyncExceptionManager();
MockHttpServer = new MockHttpServer(ExceptionManager, MockHttpServer.DefaultHttpsServerPrefixUri,
testSession);
}
public async Task ServerHandlerTest()
{
var request = new RequestMessage(123, "add", JToken.FromObject(new { x = 20, y = 35 }));
(var ss, var cs) = FullDuplexStream.CreatePair();
using (var clientReader = new StreamReader(cs))
using (var clientWriter = new StreamWriter(cs))
using (var serverReader = new ByLineTextMessageReader(ss))
using (var serverWriter = new ByLineTextMessageWriter(ss))
{
async Task <ResponseMessage> WaitForResponse()
{
var sw = Stopwatch.StartNew();
var content = await clientReader.ReadLineAsync();
Output.WriteLine($"Received response in {sw.Elapsed}.");
return((ResponseMessage)Message.LoadJson(content));
}
async Task <ResponseMessage> SendRequest(MessageId messageId)
{
request.Id = messageId;
request.WriteJson(clientWriter);
clientWriter.WriteLine();
await clientWriter.FlushAsync();
var response = await WaitForResponse();
Assert.Equal(messageId, response.Id);
Assert.Null(response.Error);
Assert.Equal(55, (int)response.Result);
return(response);
}
using (var server = new ServerTestHelper(this, serverReader, serverWriter,
StreamRpcServerHandlerOptions.None))
{
await SendRequest(123);
await SendRequest("abc");
}
}
}
public async Task ConsistentResponseSequenceTest()
{
(var ss, var cs) = FullDuplexStream.CreatePair();
using (var clientReader = new ByLineTextMessageReader(cs))
using (var clientWriter = new ByLineTextMessageWriter(cs))
using (var serverReader = new ByLineTextMessageReader(ss))
using (var serverWriter = new ByLineTextMessageWriter(ss))
using (var client = new ClientTestHelper(clientReader, clientWriter))
{
using (var server = new ServerTestHelper(this, serverReader, serverWriter,
StreamRpcServerHandlerOptions.None))
{
// The responses are ordered by the time of completion.
var delayTask =
client.ClientStub.DelayAsync(TimeSpan.FromMilliseconds(200), CancellationToken.None);
var addTask = client.ClientStub.AddAsync(3, -4);
var result = await addTask;
Assert.Equal(-1, result);
// addTask completes first.
Assert.False(delayTask.IsCompleted);
await delayTask;
}
using (var server = new ServerTestHelper(this, serverReader, serverWriter,
StreamRpcServerHandlerOptions.ConsistentResponseSequence))
{
// The responses are in the same order as the requests.
var delayTask =
client.ClientStub.DelayAsync(TimeSpan.FromMilliseconds(200), CancellationToken.None);
var addTask = client.ClientStub.AddAsync(10, 20);
await Task.Delay(100);
// addTask is held up.
Assert.False(addTask.IsCompleted);
await delayTask;
var result = await addTask;
Assert.Equal(30, result);
}
}
}
public async Task PartwiseStreamInteropTest()
{
(var ss, var cs) = FullDuplexStream.CreatePair();
using (var clientReader = new ByLineTextMessageReader(cs))
using (var clientWriter = new ByLineTextMessageWriter(cs))
using (var serverReader = new ByLineTextMessageReader(ss))
using (var serverWriter = new ByLineTextMessageWriter(ss))
using (var server = new ServerTestHelper(this, serverReader, serverWriter,
StreamRpcServerHandlerOptions.None))
using (var client = new ClientTestHelper(clientReader, clientWriter))
{
var e = Assert.Raises <MessageEventArgs>(h => client.ClientHandler.MessageSending += h,
h => client.ClientHandler.MessageSending -= h,
() => client.ClientStub.One());
Assert.Equal("one", ((RequestMessage)e.Arguments.Message).Method);
e = Assert.Raises <MessageEventArgs>(h => client.ClientHandler.MessageReceiving += h,
h => client.ClientHandler.MessageReceiving -= h,
() => client.ClientStub.One());
Assert.Equal(new JValue(1), ((ResponseMessage)e.Arguments.Message).Result);
await TestRoutines.TestStubAsync(client.ClientStub);
await TestRoutines.TestStubAsync(client.ClientExceptionStub);
}
}
public void RestoreAzureSqlDatabaseWithRestorableDroppedDatabaseObjectWithCertAuth()
{
DropTestDatabases();
var deletionDate = DateTime.UtcNow;
var restorePoint = deletionDate - TimeSpan.FromMinutes(1);
var testSession = MockServerHelper.DefaultSessionCollection.GetSession(
"UnitTests.RestoreAzureSqlDatabaseWithRestorableDroppedDatabaseObjectWithCertAuth");
ServerTestHelper.SetDefaultTestSessionSettings(testSession);
testSession.RequestValidator =
new Action <HttpMessage, HttpMessage.Request>(
(expected, actual) =>
{
Assert.AreEqual(expected.RequestInfo.Method, actual.Method);
Assert.IsTrue(
actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue),
"Missing proper UserAgent string.");
});
using (var exceptionManager = new AsyncExceptionManager())
{
Collection <PSObject> droppedDatabase, operation;
using (new MockHttpServer(
exceptionManager, MockHttpServer.DefaultHttpsServerPrefixUri, testSession))
{
droppedDatabase = powershell.InvokeBatchScript(
@"$database = $(Get-AzureSqlDatabase -ServerName $serverName -RestorableDropped)[0];" +
@"$database");
}
Assert.AreEqual(0, powershell.Streams.Error.Count, "Errors during run!");
Assert.AreEqual(0, powershell.Streams.Warning.Count, "Warnings during run!");
powershell.Streams.ClearStreams();
var droppedDatabaseObject = (RestorableDroppedDatabase)droppedDatabase[0].BaseObject;
using (new MockHttpServer(
exceptionManager, MockHttpServer.DefaultHttpsServerPrefixUri, testSession))
{
operation = powershell.InvokeBatchScript(
@"$database | Start-AzureSqlDatabaseRestore " +
@"-TargetDatabaseName testdb1-restored");
}
Assert.AreEqual(0, powershell.Streams.Error.Count, "Errors during run!");
Assert.AreEqual(0, powershell.Streams.Warning.Count, "Warnings during run!");
powershell.Streams.ClearStreams();
// Expecting one operation object
Assert.AreEqual(1, operation.Count, "Expecting one operation object");
Assert.IsTrue(
operation[0].BaseObject is RestoreDatabaseOperation,
"Expecting a RestoreDatabaseOperation object");
var operationObject = (RestoreDatabaseOperation)operation[0].BaseObject;
Assert.IsTrue(
operationObject.RequestID != Guid.Empty,
"Expecting a non-empty operation ID");
Assert.IsTrue(operationObject.SourceDatabaseName == droppedDatabaseObject.Name);
Assert.IsTrue(operationObject.SourceDatabaseDeletionDate == droppedDatabaseObject.DeletionDate);
}
}
public void AzureSqlDatabaseServerQuotaCertAuthTest()
{
// This test uses the https endpoint, setup the certificates.
MockHttpServer.SetupCertificates();
using (PowerShell powershell = PowerShell.Create())
{
// Setup the subscription used for the test
WindowsAzureSubscription subscription =
UnitTestHelper.SetupUnitTestSubscription(powershell);
powershell.Runspace.SessionStateProxy.SetVariable(
"serverName",
SqlDatabaseTestSettings.Instance.ServerV2);
// Create a new server
HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession(
"UnitTest.AzureSqlDatabaseServerQuotaCertAuthTest");
ServerTestHelper.SetDefaultTestSessionSettings(testSession);
testSession.RequestValidator =
new Action <HttpMessage, HttpMessage.Request>(
(expected, actual) =>
{
Assert.AreEqual(expected.RequestInfo.Method, actual.Method);
Assert.IsTrue(
actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue),
"Missing proper UserAgent string.");
Assert.IsTrue(
UnitTestHelper.GetUnitTestClientCertificate().Equals(actual.Certificate),
"Expected correct client certificate");
});
Collection <PSObject> getQuota1 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabaseServerQuota -ServerName $serverName"));
});
Collection <PSObject> getQuota2 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabaseServerQuota -ServerName $serverName -QuotaName premium_databases"));
});
Assert.AreEqual(0, powershell.Streams.Error.Count, "Unexpected Errors during run!");
Assert.AreEqual(0, powershell.Streams.Warning.Count, "Unexpected Warnings during run!");
// Validate Get-AzureSqlDatabaseServerQuota
var quotas = getQuota1.Select(x => ((IEnumerable)x.BaseObject).Cast <Model.SqlDatabaseServerQuotaContext>().Single()).ToArray();
Assert.AreEqual(1, quotas.Length, "Expecting one server quota");
Assert.IsNotNull(quotas[0], "Expecting a server quota.");
Assert.AreEqual("premium_databases", quotas[0].Name);
Assert.AreEqual(SqlDatabaseTestSettings.Instance.ServerV2, quotas[0].ServerName);
Assert.AreEqual("Microsoft.SqlAzure.ServerQuota", quotas[0].Type);
Assert.AreEqual("1000", quotas[0].Value);
Assert.AreEqual("Normal", quotas[0].State);
quotas = getQuota2.Select(x => ((IEnumerable)x.BaseObject).Cast <Model.SqlDatabaseServerQuotaContext>().Single()).ToArray();
Assert.AreEqual(1, quotas.Length, "Expecting server quota");
Assert.IsNotNull(quotas[0], "Expecting a server quota.");
Assert.AreEqual("premium_databases", quotas[0].Name);
Assert.AreEqual(SqlDatabaseTestSettings.Instance.ServerV2, quotas[0].ServerName);
Assert.AreEqual("Microsoft.SqlAzure.ServerQuota", quotas[0].Type);
Assert.AreEqual("1000", quotas[0].Value);
Assert.AreEqual("Normal", quotas[0].State);
}
}
public void RecoverAzureSqlDatabaseWithDatabaseName()
{
var testSession = MockServerHelper.DefaultSessionCollection.GetSession(
"UnitTests.RecoverAzureSqlDatabaseWithDatabaseName");
ServerTestHelper.SetDefaultTestSessionSettings(testSession);
testSession.RequestValidator =
new Action <HttpMessage, HttpMessage.Request>(
(expected, actual) =>
{
Assert.AreEqual(expected.RequestInfo.Method, actual.Method);
Assert.IsTrue(
actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue),
"Missing proper UserAgent string.");
Assert.IsTrue(
UnitTestHelper.GetUnitTestClientCertificate().Equals(actual.Certificate),
"Expected correct client certificate");
});
using (var exceptionManager = new AsyncExceptionManager())
{
Collection <PSObject> operation;
using (new MockHttpServer(
exceptionManager, MockHttpServer.DefaultHttpsServerPrefixUri, testSession))
{
operation = powershell.InvokeBatchScript(
@"Start-AzureSqlDatabaseRecovery " +
@"-SourceServerName $serverName " +
@"-SourceDatabaseName testdb1 " +
@"-TargetDatabaseName testdb1-restored");
}
Assert.AreEqual(0, powershell.Streams.Error.Count, "Errors during run!");
Assert.AreEqual(0, powershell.Streams.Warning.Count, "Warnings during run!");
powershell.Streams.ClearStreams();
// Expecting one operation object
Assert.AreEqual(1, operation.Count, "Expecting one operation object");
Assert.IsInstanceOfType(
operation[0].BaseObject, typeof(RecoverDatabaseOperation),
"Expecting a RecoverDatabaseOperation object");
var operationObject = (RecoverDatabaseOperation)operation[0].BaseObject;
Guid operationId;
Assert.IsTrue(
Guid.TryParse(operationObject.Id, out operationId),
"Expecting a operation ID that's a GUID");
Assert.AreNotEqual(
Guid.Empty, operationId,
"Expecting an operation ID that's not an empty GUID");
Assert.AreEqual(
operationObject.SourceDatabaseName, "testdb1",
"Source database name mismatch");
Assert.AreEqual(
operationObject.TargetServerName, serverName,
"Target server name mismatch");
Assert.AreEqual(
operationObject.TargetDatabaseName, "testdb1-restored",
"Target database name mismatch");
}
}
public void AzureSqlDatabaseCertTests()
{
// This test uses the https endpoint, setup the certificates.
MockHttpServer.SetupCertificates();
using (PowerShell powershell = PowerShell.Create())
{
// Setup the subscription used for the test
WindowsAzureSubscription subscription =
UnitTestHelper.SetupUnitTestSubscription(powershell);
powershell.Runspace.SessionStateProxy.SetVariable(
"serverName",
SqlDatabaseTestSettings.Instance.ServerName);
// Create a new server
HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession(
"UnitTest.AzureSqlDatabaseCertTests");
ServerTestHelper.SetDefaultTestSessionSettings(testSession);
testSession.RequestValidator =
new Action <HttpMessage, HttpMessage.Request>(
(expected, actual) =>
{
Assert.AreEqual(expected.RequestInfo.Method, actual.Method);
Assert.IsTrue(
actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue),
"Missing proper UserAgent string.");
Assert.IsTrue(
UnitTestHelper.GetUnitTestClientCertificate().Equals(actual.Certificate),
"Expected correct client certificate");
});
Collection <PSObject> newDatabaseResult1 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"New-AzureSqlDatabase" +
@" -ServerName $serverName" +
@" -DatabaseName testdbcert1"));
});
Collection <PSObject> newDatabaseResult2 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"New-AzureSqlDatabase" +
@" -ServerName $serverName" +
@" -DatabaseName testdbcert2" +
@" -Edition Business" +
@" -MaxSizeGB 10" +
@" -Collation Japanese_CI_AS"));
});
// Create a database of size 100MB Default Edition (Web)
Collection <PSObject> newDatabaseResult3 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"New-AzureSqlDatabase" +
@" -ServerName $serverName" +
@" -DatabaseName testdbcert4" +
@" -MaxSizeBytes 104857600"));
});
Collection <PSObject> getDatabaseResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabase" +
@" $serverName"));
});
Collection <PSObject> getSingleDatabaseResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabase" +
@" $serverName" +
@" -DatabaseName testdbcert1"));
});
Collection <PSObject> getSingleDatabaseResult2 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabase" +
@" $serverName" +
@" -DatabaseName testdbcert4"));
});
Collection <PSObject> setDatabaseNameResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable("db", newDatabaseResult1.FirstOrDefault());
return(powershell.InvokeBatchScript(
@"$db | Set-AzureSqlDatabase" +
@" -NewDatabaseName testdbcert3" +
@" -PassThru"));
});
Collection <PSObject> setDatabaseSizeResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable("db", newDatabaseResult1.FirstOrDefault());
return(powershell.InvokeBatchScript(
@"$db | Set-AzureSqlDatabase" +
@" -MaxSizeGB 5" +
@" -PassThru"));
});
Collection <PSObject> setDatabaseSizeResult2 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"Set-AzureSqlDatabase" +
@" -ServerName $serverName" +
@" -DatabaseName testdbcert4" +
@" -MaxSizeBytes 1073741824" +
@" -passthru"));
});
Collection <PSObject> P1 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"$P1 = Get-AzureSqlDatabaseServiceObjective" +
@" -Server $serverName" +
@" -ServiceObjectiveName ""P1""",
@"$P1"));
});
Collection <PSObject> P2 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.InvokeBatchScript(
@"$SLO = Get-AzureSqlDatabaseServiceObjective" +
@" -Server $serverName");
return(powershell.InvokeBatchScript(
@"$P2 = Get-AzureSqlDatabaseServiceObjective" +
@" -Server $serverName" +
@" -ServiceObjective $SLO[2]",
@"$P2"));
});
Collection <PSObject> setDatabaseSlo = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"Set-AzureSqlDatabase" +
@" -ServerName $serverName" +
@" -DatabaseName testdbcert4" +
@" -Edition Premium" +
@" -MaxSizeGb 10" +
@" -ServiceObjective $P2" +
@" -passthru" +
@" -Force"));
});
Collection <PSObject> newPremiumP1DatabaseResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"New-AzureSqlDatabase" +
@" -ServerName $serverName" +
@" -DatabaseName ""testdbcertPremiumDBP1""" +
@" -Edition Premium" +
@" -ServiceObjective $P1"));
});
Collection <PSObject> newPremiumP2DatabaseResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"New-AzureSqlDatabase" +
@" -ServerName $serverName" +
@" -DatabaseName ""testdbcertPremiumDBP2""" +
@" -Edition Premium" +
@" -ServiceObjective $P2"));
});
// There is a known issue about the Get-AzureSqlDatabaseOperation that it returns all
// operations which has the required database name no matter it's been deleted and recreated.
// So when run it against the mock session, please use the hard coded testsDBName.
// Run against onebox, please use the one with NewGuid().
// This unit test should be updated once that behavior get changed which was already been
// created as a task.
string getOperationDbName = null;
if (testSession.ServiceBaseUri == null)
{
getOperationDbName = "testdbcertGetOperationDbName_551f9692-e85f-4dcd-9fe1-7e5c6af67a6f";
}
else
{
getOperationDbName = "testdbcertGetOperationDbName_" + Guid.NewGuid().ToString();
}
Collection <PSObject> newOperationDbResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
string.Format(
CultureInfo.InvariantCulture,
@"$getOperationDb = New-AzureSqlDatabase" +
@" -ServerName $serverName" +
@" -DatabaseName ""{0}""",
getOperationDbName),
@"$getOperationDb"));
});
Collection <PSObject> getDatabaseOperationByDbResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
string.Format(
CultureInfo.InvariantCulture,
@"Get-AzureSqlDatabaseOperation" +
@" -ServerName $serverName" +
@" -Database $getOperationDb")));
});
Collection <PSObject> getDatabaseOperationByNameResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
string.Format(
CultureInfo.InvariantCulture,
@"$getOperation = Get-AzureSqlDatabaseOperation" +
@" -ServerName $serverName" +
@" -DatabaseName ""{0}""",
getOperationDbName),
@"$getOperation"));
});
Collection <PSObject> getDatabaseOperationByIdResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
string.Format(
CultureInfo.InvariantCulture,
@"Get-AzureSqlDatabaseOperation" +
@" -ServerName $serverName" +
@" -OperationGuid $getOperation[0].Id")));
});
Collection <PSObject> removeDatabaseResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable("db1", newDatabaseResult1.FirstOrDefault());
powershell.Runspace.SessionStateProxy.SetVariable("db2", newDatabaseResult2.FirstOrDefault());
powershell.Runspace.SessionStateProxy.SetVariable("db3", newDatabaseResult3.FirstOrDefault());
powershell.Runspace.SessionStateProxy.SetVariable("premiumP1", newPremiumP1DatabaseResult.FirstOrDefault());
powershell.Runspace.SessionStateProxy.SetVariable("premiumP2", newPremiumP2DatabaseResult.FirstOrDefault());
powershell.Runspace.SessionStateProxy.SetVariable("operationDb", newOperationDbResult.FirstOrDefault());
powershell.InvokeBatchScript(@"$db1 | Remove-AzureSqlDatabase -Force");
powershell.InvokeBatchScript(@"$db2 | Remove-AzureSqlDatabase -Force");
powershell.InvokeBatchScript(@"$db3 | Remove-AzureSqlDatabase -Force");
powershell.InvokeBatchScript(@"$premiumP1 | Remove-AzureSqlDatabase -Force");
powershell.InvokeBatchScript(@"$premiumP2 | Remove-AzureSqlDatabase -Force");
powershell.InvokeBatchScript(@"$operationDb | Remove-AzureSqlDatabase -Force");
return(powershell.InvokeBatchScript(@"Get-AzureSqlDatabase $serverName"));
});
Assert.AreEqual(0, powershell.Streams.Error.Count, "Unexpected Errors during run!");
Assert.AreEqual(0, powershell.Streams.Warning.Count, "Unexpected Warnings during run!");
// Validate New-AzureSqlDatabase
Database[] databases = new Database[] { newDatabaseResult1.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
// Note: Because the object is piped, this is the final state of the
// database object, after all the Set- cmdlet has run.
DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert3", "Web", 5, 5368709120L, "SQL_Latin1_General_CP1_CI_AS", "Shared", false, DatabaseTestHelper.SharedSloGuid);
databases = new Database[] { newDatabaseResult2.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert2", "Business", 10, 10737418240L, "Japanese_CI_AS", "Shared", false, DatabaseTestHelper.SharedSloGuid);
databases = new Database[] { newDatabaseResult3.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert4", "Web", 0, 104857600L, "SQL_Latin1_General_CP1_CI_AS", "Shared", false, DatabaseTestHelper.SharedSloGuid);
// Validate Get-AzureSqlDatabase
databases = getDatabaseResult.Select(r => r.BaseObject as Database).ToArray();
Assert.AreEqual(4, databases.Length, "Expecting 4 databases");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
Assert.IsNotNull(databases[1], "Expecting a Database object.");
Assert.IsNotNull(databases[2], "Expecting a Database object.");
Assert.IsNotNull(databases[3], "Expecting a Database object.");
DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "master", "System", 5, 5368709120L, "SQL_Latin1_General_CP1_CI_AS", "System", true, DatabaseTestHelper.SystemSloGuid);
DatabaseTestHelper.ValidateDatabaseProperties(databases[1], "testdbcert1", "Web", 1, 1073741824L, "SQL_Latin1_General_CP1_CI_AS", "Shared", false, DatabaseTestHelper.SharedSloGuid);
DatabaseTestHelper.ValidateDatabaseProperties(databases[2], "testdbcert2", "Business", 10, 10737418240L, "Japanese_CI_AS", "Shared", false, DatabaseTestHelper.SharedSloGuid);
DatabaseTestHelper.ValidateDatabaseProperties(databases[3], "testdbcert4", "Web", 0, 104857600L, "SQL_Latin1_General_CP1_CI_AS", "Shared", false, DatabaseTestHelper.SharedSloGuid);
databases = new Database[] { getSingleDatabaseResult.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert1", "Web", 1, 1073741824L, "SQL_Latin1_General_CP1_CI_AS", "Shared", false, DatabaseTestHelper.SharedSloGuid);
databases = new Database[] { getSingleDatabaseResult2.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert4", "Web", 0, 104857600L, "SQL_Latin1_General_CP1_CI_AS", "Shared", false, DatabaseTestHelper.SharedSloGuid);
// Validate Set-AzureSqlDatabase
databases = new Database[] { setDatabaseNameResult.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert3", "Web", 1, 1073741824L, "SQL_Latin1_General_CP1_CI_AS", "Shared", false, DatabaseTestHelper.SharedSloGuid);
databases = new Database[] { setDatabaseSizeResult.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert3", "Web", 5, 5368709120L, "SQL_Latin1_General_CP1_CI_AS", "Shared", false, DatabaseTestHelper.SharedSloGuid);
databases = new Database[] { setDatabaseSizeResult2.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert4", "Web", 1, 1073741824L, "SQL_Latin1_General_CP1_CI_AS", "Shared", false, DatabaseTestHelper.SharedSloGuid);
databases = new Database[] { setDatabaseSlo.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert4", "Premium", 10, 10737418240L, "SQL_Latin1_General_CP1_CI_AS", "P2", false, DatabaseTestHelper.SharedSloGuid);
// Validate New-AzureSqlDatabase for Premium Edition Database
VerifyCreatePremiumDb(newPremiumP1DatabaseResult, "testdbcertPremiumDBP1", (P1.Single().BaseObject as ServiceObjective).Id.ToString());
VerifyCreatePremiumDb(newPremiumP2DatabaseResult, "testdbcertPremiumDBP2", (P2.Single().BaseObject as ServiceObjective).Id.ToString());
// Validate Get-AzureSqlDatabaseServiceObjective
var SLOP1 = P1.Single().BaseObject as ServiceObjective;
Assert.AreEqual("P1", SLOP1.Name);
Assert.AreEqual("Premium P1 resource allocation.", SLOP1.Description);
Assert.IsNotNull(SLOP1.DimensionSettings, "Expecting some Dimension Setting objects.");
Assert.AreEqual(1, SLOP1.DimensionSettings.Count(), "Expecting 1 Dimension Setting.");
Assert.AreEqual("Premium P1 resource allocation.", SLOP1.DimensionSettings[0].Description, "Expecting Dimension Setting description as Resource capacity is reserved.");
var SLOP2 = P2.Single().BaseObject as ServiceObjective;
Assert.AreEqual("P2", SLOP2.Name);
Assert.AreEqual(SLOP2.Description, "Premium P2 resource allocation.");
Assert.IsNotNull(SLOP2.DimensionSettings, "Expecting some Dimension Setting objects.");
Assert.AreEqual(1, SLOP2.DimensionSettings.Count(), "Expecting 1 Dimension Setting.");
Assert.AreEqual("Premium P2 resource allocation.", SLOP2.DimensionSettings[0].Description, "Expecting Dimension Setting description as Resource capacity is reserved.");
// Validate Get-AzureSqlDatabaseOperation
VerifyGetAzureSqlDatabaseOperation(getOperationDbName, getDatabaseOperationByDbResult);
VerifyGetAzureSqlDatabaseOperation(getOperationDbName, getDatabaseOperationByNameResult);
VerifyGetAzureSqlDatabaseOperation(getOperationDbName, getDatabaseOperationByIdResult);
// Validate Remove-AzureSqlDatabase
databases = new Database[] { removeDatabaseResult.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting no databases");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "master", "System", 5, 5368709120L, "SQL_Latin1_General_CP1_CI_AS", "System", true, DatabaseTestHelper.SystemSloGuid);
}
}
public void AzureSqlDatabaseEditionsTests()
{
// This test uses the https endpoint, setup the certificates.
MockHttpServer.SetupCertificates();
using (PowerShell powershell = PowerShell.Create())
{
// Setup the subscription used for the test
WindowsAzureSubscription subscription =
UnitTestHelper.SetupUnitTestSubscription(powershell);
powershell.Runspace.SessionStateProxy.SetVariable(
"serverName",
SqlDatabaseTestSettings.Instance.ServerV2);
// Create a new server
HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession(
"UnitTest.AzureSqlDatabaseEditionsTests");
ServerTestHelper.SetDefaultTestSessionSettings(testSession);
testSession.RequestValidator =
new Action <HttpMessage, HttpMessage.Request>(
(expected, actual) =>
{
Assert.AreEqual(expected.RequestInfo.Method, actual.Method);
Assert.IsTrue(
actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue),
"Missing proper UserAgent string.");
Assert.IsTrue(
UnitTestHelper.GetUnitTestClientCertificate().Equals(actual.Certificate),
"Expected correct client certificate");
});
Collection <PSObject> newDatabaseResult1 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"($db = New-AzureSqlDatabase -ServerName $serverName -DatabaseName testdbeditions1)"));
});
Collection <PSObject> newDatabaseResult2 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"New-AzureSqlDatabase" +
@" -ServerName $serverName" +
@" -DatabaseName testdbeditions2" +
@" -Edition Standard"));
});
Collection <PSObject> newDatabaseResult3 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"($db3 = New-AzureSqlDatabase" +
@" -ServerName $serverName" +
@" -DatabaseName testdbeditions3" +
@" -Edition Basic)"));
});
Collection <PSObject> newDatabaseResult4 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"New-AzureSqlDatabase" +
@" -ServerName $serverName" +
@" -DatabaseName testdbeditions4" +
@" -Edition Premium"));
});
Collection <PSObject> serviceObjectives = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"($so = Get-AzureSqlDatabaseServiceObjective -Server $serverName)"));
});
Collection <PSObject> newDatabaseResult5 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"New-AzureSqlDatabase" +
@" -ServerName $serverName" +
@" -DatabaseName testdbeditions5" +
@" -Edition Standard" +
@" -ServiceObjective $so[0]"));
});
Collection <PSObject> getSingleDatabaseResult1 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabase $serverName -DatabaseName testdbeditions1"));
});
Collection <PSObject> getSingleDatabaseResult2 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"$db | Get-AzureSqlDatabase"));
});
Collection <PSObject> setDatabaseObjective1 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"Set-AzureSqlDatabase -ServerName $serverName -DatabaseName testdbeditions2 -ServiceObjective $so[0] -Force"));
});
Collection <PSObject> setDatabaseObjective2 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"Set-AzureSqlDatabase -ServerName $serverName -DatabaseName $db3.Name -Edition Standard -MaxSizeGB 1 -Force"));
});
Collection <PSObject> getDatabaseResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabase" +
@" $serverName"));
});
Collection <PSObject> removeDatabaseResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable("db1", newDatabaseResult1.FirstOrDefault());
powershell.Runspace.SessionStateProxy.SetVariable("db2", newDatabaseResult2.FirstOrDefault());
powershell.Runspace.SessionStateProxy.SetVariable("db3", newDatabaseResult3.FirstOrDefault());
powershell.Runspace.SessionStateProxy.SetVariable("db4", newDatabaseResult4.FirstOrDefault());
powershell.Runspace.SessionStateProxy.SetVariable("db5", newDatabaseResult5.FirstOrDefault());
powershell.InvokeBatchScript(@"$db1 | Remove-AzureSqlDatabase -Force");
powershell.InvokeBatchScript(@"$db2 | Remove-AzureSqlDatabase -Force");
powershell.InvokeBatchScript(@"$db3 | Remove-AzureSqlDatabase -Force");
powershell.InvokeBatchScript(@"$db4 | Remove-AzureSqlDatabase -Force");
powershell.InvokeBatchScript(@"$db5 | Remove-AzureSqlDatabase -Force");
return(powershell.InvokeBatchScript(@"Get-AzureSqlDatabase $serverName"));
});
Assert.AreEqual(0, powershell.Streams.Error.Count, "Unexpected Errors during run!");
Assert.AreEqual(0, powershell.Streams.Warning.Count, "Unexpected Warnings during run!");
// Validate New-AzureSqlDatabase
Database[] databases = new Database[] { newDatabaseResult1.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbeditions1", "Basic", 0, 104857600L, "SQL_Latin1_General_CP1_CI_AS", "Basic", false, DatabaseTestHelper.BasicSloGuid);
databases = new Database[] { newDatabaseResult2.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbeditions2", "", -1, -1, "SQL_Latin1_General_CP1_CI_AS", "S1", false, DatabaseTestHelper.StandardS1SloGuid);
databases = new Database[] { newDatabaseResult3.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbeditions3", "Basic", 0, 104857600L, "SQL_Latin1_General_CP1_CI_AS", "Basic", false, DatabaseTestHelper.BasicSloGuid);
databases = new Database[] { newDatabaseResult4.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbeditions4", "", -1, -1, "SQL_Latin1_General_CP1_CI_AS", "P1", false, DatabaseTestHelper.PremiumP1SloGuid);
databases = new Database[] { newDatabaseResult5.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbeditions5", "", -1, -1, "SQL_Latin1_General_CP1_CI_AS", "S2", false, DatabaseTestHelper.StandardS2SloGuid);
// Validate Get-AzureSqlDatabase
databases = getDatabaseResult.Select(r => r.BaseObject as Database).ToArray();
Assert.AreEqual(6, databases.Length, "Expecting 3 databases");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
Assert.IsNotNull(databases[1], "Expecting a Database object.");
Assert.IsNotNull(databases[2], "Expecting a Database object.");
Assert.IsNotNull(databases[3], "Expecting a Database object.");
Assert.IsNotNull(databases[4], "Expecting a Database object.");
Assert.IsNotNull(databases[5], "Expecting a Database object.");
DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "master", "System", 5, 5368709120L, "SQL_Latin1_General_CP1_CI_AS", "System", true, DatabaseTestHelper.SystemSloGuid);
DatabaseTestHelper.ValidateDatabaseProperties(databases[1], "testdbeditions1", "Basic", 0, 104857600L, "SQL_Latin1_General_CP1_CI_AS", "Basic", false, DatabaseTestHelper.BasicSloGuid);
DatabaseTestHelper.ValidateDatabaseProperties(databases[2], "testdbeditions2", "Standard", 0, 524288000L, "SQL_Latin1_General_CP1_CI_AS", "S2", false, DatabaseTestHelper.StandardS2SloGuid);
DatabaseTestHelper.ValidateDatabaseProperties(databases[3], "testdbeditions3", "Standard", 1, 1073741824L, "SQL_Latin1_General_CP1_CI_AS", "S1", false, DatabaseTestHelper.StandardS1SloGuid);
DatabaseTestHelper.ValidateDatabaseProperties(databases[4], "testdbeditions4", "Premium", 10, 10737418240L, "SQL_Latin1_General_CP1_CI_AS", "P1", false, DatabaseTestHelper.PremiumP1SloGuid);
DatabaseTestHelper.ValidateDatabaseProperties(databases[5], "testdbeditions5", "Standard", 2, 2147483648L, "SQL_Latin1_General_CP1_CI_AS", "S2", false, DatabaseTestHelper.StandardS2SloGuid);
// Validate Get-AzureSqlDatabaseServiceObjective
var sos = serviceObjectives.Select(x => x.BaseObject as ServiceObjective).ToArray();
Assert.AreEqual(10, sos.Count());
ValidateServiceObjectiveProperties(sos[0], "S2", "Standard S2 resource allocation.", 1, "Standard S2 resource allocation.");
ValidateServiceObjectiveProperties(sos[1], "P1", "Premium P1 resource allocation.", 1, "Premium P1 resource allocation.");
ValidateServiceObjectiveProperties(sos[2], "P2", "Premium P2 resource allocation.", 1, "Premium P2 resource allocation.");
ValidateServiceObjectiveProperties(sos[3], "Basic", "Basic resource allocation.", 1, "Basic resource allocation.");
ValidateServiceObjectiveProperties(sos[4], "S1", "Standard S1 resource allocation.", 1, "Standard S1 resource allocation.");
ValidateServiceObjectiveProperties(sos[5], "P3 deprecated", "Premium P3 deprecated resource allocation.", 1, "Premium P3 deprecated resource allocation.");
ValidateServiceObjectiveProperties(sos[6], "P3", "Premium P3 resource allocation.", 1, "Premium P3 resource allocation.");
ValidateServiceObjectiveProperties(sos[7], "System", "Used for master database only.", 1, "Used for master database only.");
ValidateServiceObjectiveProperties(sos[8], "System Standard", "Used for master database only.", 1, "Shared resource allocation.");
ValidateServiceObjectiveProperties(sos[9], "Shared", "Shared resource allocation.", 1, "Shared resource allocation.");
// Validate Remove-AzureSqlDatabase
databases = new Database[] { removeDatabaseResult.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting no databases");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "master", "System", 5, 5368709120L, "SQL_Latin1_General_CP1_CI_AS", "System", true, DatabaseTestHelper.SystemSloGuid);
}
}
public void ImportExportAzureSqlDatabaseTestv12()
{
using (System.Management.Automation.PowerShell powershell =
System.Management.Automation.PowerShell.Create())
{
// Setup the subscription used for the test
AzureSubscription subscription =
UnitTestHelper.SetupUnitTestSubscription(powershell);
// Set the necessary session variables
powershell.Runspace.SessionStateProxy.SetVariable(
"serverName",
SqlDatabaseTestSettings.Instance.ServerName);
powershell.Runspace.SessionStateProxy.SetVariable(
"sourceDB",
SqlDatabaseTestSettings.Instance.SourceDatabaseName);
powershell.Runspace.SessionStateProxy.SetVariable(
"targetDB",
SqlDatabaseTestSettings.Instance.TargetDatabaseName);
powershell.Runspace.SessionStateProxy.SetVariable(
"credential",
new PSCredential(
SqlDatabaseTestSettings.Instance.UserName,
SqlDatabaseTestSettings.Instance.SecurePassword));
powershell.Runspace.SessionStateProxy.SetVariable(
"storageAccountName",
SqlDatabaseTestSettings.Instance.StorageName);
powershell.Runspace.SessionStateProxy.SetVariable(
"storageAccountKey",
SqlDatabaseTestSettings.Instance.AccessKey);
powershell.Runspace.SessionStateProxy.SetVariable(
"storageContainerName",
SqlDatabaseTestSettings.Instance.ContainerName);
// Create a new server
HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession(
"UnitTest.ImportExportAzureSqlDatabaseTestsv12");
ServerTestHelper.SetDefaultTestSessionSettings(testSession);
testSession.RequestValidator =
new Action <HttpMessage, HttpMessage.Request>(
(expected, actual) =>
{
Assert.AreEqual(expected.RequestInfo.Method, actual.Method);
string expectedRequestText = RequestTextToString(expected.RequestInfo);
string actualRequestText = RequestTextToString(actual);
// When checking out from GitHub, different new line setting may lead to different char \r\n or \n
// Replace them with String.Empty before comparison
Assert.AreEqual(
Regex.Replace(expectedRequestText, @"\s+", String.Empty),
Regex.Replace(actualRequestText, @"\s+", String.Empty));
Assert.IsTrue(
actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue),
"Missing proper UserAgent string.");
});
StorageCredentials credential = new StorageCredentials(SqlDatabaseTestSettings.Instance.StorageName, SqlDatabaseTestSettings.Instance.AccessKey);
string blobEndpoint = String.Format("https://{0}.blob.{1}/", SqlDatabaseTestSettings.Instance.StorageName, "core.windows.net");
string tableEndpoint = String.Format("https://{0}.table.{1}/", SqlDatabaseTestSettings.Instance.StorageName, "core.windows.net");
string queueEndpoint = String.Format("http://{0}.queue.{1}/", SqlDatabaseTestSettings.Instance.StorageName, "core.windows.net");
string fileEndpoint = String.Format("https://{0}.file.{1}/", SqlDatabaseTestSettings.Instance.StorageName, "core.windows.net");
CloudStorageAccount account = new CloudStorageAccount(credential, new Uri(blobEndpoint), new Uri(queueEndpoint), new Uri(tableEndpoint), new Uri(fileEndpoint));
AzureStorageContext storageContext = new AzureStorageContext(account);
// Tell the sql auth factory to create a v12 context (skip checking sql version using select query).
//
SqlAuthContextFactory.sqlVersion = SqlAuthContextFactory.SqlVersion.v12;
Collection <PSObject> databaseContext = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable(
"manageUrl",
MockHttpServer.DefaultServerPrefixUri.AbsoluteUri);
return(powershell.InvokeBatchScript(
@"New-AzureSqlDatabaseServerContext" +
@" -ServerName $serverName" +
@" -ManageUrl $manageUrl" +
@" -Credential $credential"));
});
Collection <PSObject> startExportResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable("storageContext", storageContext);
powershell.Runspace.SessionStateProxy.SetVariable(
"databaseContext",
databaseContext.FirstOrDefault());
return(powershell.InvokeBatchScript(
@"Start-AzureSqlDatabaseExport" +
@" -SqlConnectionContext $databaseContext" +
@" -DatabaseName $sourceDB" +
@" -StorageContext $storageContext" +
@" -StorageContainerName $storageContainerName" +
@" -BlobName backup1"));
});
// Wait here for operation to finish
Collection <PSObject> getExportStatusResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable(
"exportResult",
startExportResult.FirstOrDefault());
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabaseImportExportStatus" +
@" -ServerName $serverName" +
@" -RequestId $exportResult.RequestGuid" +
@" -Username $exportResult.SqlCredentials.UserName" +
@" -Password $exportResult.SqlCredentials.Password"));
});
Collection <PSObject> startImportResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"Start-AzureSqlDatabaseImport" +
@" -SqlConnectionContext $databaseContext" +
@" -DatabaseName $targetDB" +
@" -Edition Business" +
@" -DatabaseMaxSize 10" +
@" -StorageContext $storageContext" +
@" -StorageContainerName $storageContainerName" +
@" -BlobName backup1"));
});
// Wait here for import to finish
Collection <PSObject> getImportStatusResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable(
"importResult",
startImportResult.FirstOrDefault());
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabaseImportExportStatus" +
@" -ServerName $serverName" +
@" -RequestId $importResult.RequestGuid" +
@" -Username $importResult.SqlCredentials.UserName" +
@" -Password $importResult.SqlCredentials.Password"));
});
Assert.AreEqual(0, powershell.Streams.Error.Count, "Unexpected Errors during run!");
Assert.AreEqual(0, powershell.Streams.Warning.Count, "Unexpected Warnings during run!");
}
}
public void ImportExportAzureSqlDatabaseTests()
{
using (PowerShell powershell = PowerShell.Create())
{
// Setup the subscription used for the test
WindowsAzureSubscription subscription =
UnitTestHelper.SetupUnitTestSubscription(powershell);
// Set the necessary session variables
powershell.Runspace.SessionStateProxy.SetVariable(
"serverName",
SqlDatabaseTestSettings.Instance.ServerName);
powershell.Runspace.SessionStateProxy.SetVariable(
"sourceDB",
SqlDatabaseTestSettings.Instance.SourceDatabaseName);
powershell.Runspace.SessionStateProxy.SetVariable(
"targetDB",
SqlDatabaseTestSettings.Instance.TargetDatabaseName);
powershell.Runspace.SessionStateProxy.SetVariable(
"credential",
new PSCredential(
SqlDatabaseTestSettings.Instance.UserName,
SqlDatabaseTestSettings.Instance.SecurePassword));
powershell.Runspace.SessionStateProxy.SetVariable(
"storageAccountName",
SqlDatabaseTestSettings.Instance.StorageName);
powershell.Runspace.SessionStateProxy.SetVariable(
"storageAccountKey",
SqlDatabaseTestSettings.Instance.AccessKey);
powershell.Runspace.SessionStateProxy.SetVariable(
"storageContainerName",
SqlDatabaseTestSettings.Instance.ContainerName);
// Create a new server
HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession(
"UnitTest.ImportExportAzureSqlDatabaseTests");
ServerTestHelper.SetDefaultTestSessionSettings(testSession);
//testSession.ServiceBaseUri = new Uri("https://management.core.windows.net");
testSession.RequestValidator =
new Action <HttpMessage, HttpMessage.Request>(
(expected, actual) =>
{
Assert.AreEqual(expected.RequestInfo.Method, actual.Method);
string expectedRequestText = RequestTextToString(expected.RequestInfo);
string actualRequestText = RequestTextToString(actual);
// When checking out from GitHub, different new line setting may lead to different char \r\n or \n
// Replace them with String.Empty before comparison
Assert.AreEqual(
Regex.Replace(expectedRequestText, @"\s+", String.Empty),
Regex.Replace(actualRequestText, @"\s+", String.Empty));
Assert.IsTrue(
actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue),
"Missing proper UserAgent string.");
});
PSObject storageContext = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"New-AzureStorageContext" +
@" -StorageAccountName $storageAccountName" +
@" -StorageAccountKey $storageAccountKey"));
}).FirstOrDefault();
//testSession.ServiceBaseUri = new Uri("https://lqtqbo6kkp.database.windows.net");
Collection <PSObject> databaseContext = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable(
"manageUrl",
MockHttpServer.DefaultServerPrefixUri.AbsoluteUri);
return(powershell.InvokeBatchScript(
@"New-AzureSqlDatabaseServerContext" +
@" -ServerName $serverName" +
@" -ManageUrl $manageUrl" +
@" -Credential $credential"));
});
//testSession.ServiceBaseUri = new Uri("https://management.core.windows.net");
Collection <PSObject> startExportResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable("storageContext", storageContext);
powershell.Runspace.SessionStateProxy.SetVariable(
"databaseContext",
databaseContext.FirstOrDefault());
return(powershell.InvokeBatchScript(
@"Start-AzureSqlDatabaseExport" +
@" -SqlConnectionContext $databaseContext" +
@" -DatabaseName $sourceDB" +
@" -StorageContext $storageContext" +
@" -StorageContainerName $storageContainerName" +
@" -BlobName backup1"));
});
Collection <PSObject> getExportStatusResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable(
"exportResult",
startExportResult.FirstOrDefault());
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabaseImportExportStatus" +
@" -ServerName $serverName" +
@" -RequestId $exportResult.RequestGuid" +
@" -Username $exportResult.SqlCredentials.UserName" +
@" -Password $exportResult.SqlCredentials.Password"));
});
Collection <PSObject> startImportResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"Start-AzureSqlDatabaseImport" +
@" -SqlConnectionContext $databaseContext" +
@" -DatabaseName $targetDB" +
@" -Edition Business" +
@" -DatabaseMaxSize 10" +
@" -StorageContext $storageContext" +
@" -StorageContainerName $storageContainerName" +
@" -BlobName backup1"));
});
Collection <PSObject> getImportStatusResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable(
"importResult",
startImportResult.FirstOrDefault());
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabaseImportExportStatus" +
@" -ServerName $serverName" +
@" -RequestId $importResult.RequestGuid" +
@" -Username $importResult.SqlCredentials.UserName" +
@" -Password $importResult.SqlCredentials.Password"));
});
Assert.AreEqual(0, powershell.Streams.Error.Count, "Unexpected Errors during run!");
Assert.AreEqual(0, powershell.Streams.Warning.Count, "Unexpected Warnings during run!");
}
}
public void AzureSqlDatabaseServerFirewallTests()
{
// This test uses the https endpoint, setup the certificates.
MockHttpServer.SetupCertificates();
using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create())
{
// Setup the subscription used for the test
AzureSubscription subscription =
UnitTestHelper.SetupUnitTestSubscription(powershell);
powershell.Runspace.SessionStateProxy.SetVariable(
"serverName",
SqlDatabaseTestSettings.Instance.ServerName);
// Create a new server
HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession(
"UnitTest.AzureSqlDatabaseServerFirewallTests");
ServerTestHelper.SetDefaultTestSessionSettings(testSession);
testSession.RequestValidator =
new Action <HttpMessage, HttpMessage.Request>(
(expected, actual) =>
{
Assert.AreEqual(expected.RequestInfo.Method, actual.Method);
Assert.IsTrue(
actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue),
"Missing proper UserAgent string.");
});
Collection <PSObject> newFirewallRuleResult1 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"New-AzureSqlDatabaseServerFirewallRule" +
@" -ServerName $serverName" +
@" -RuleName Rule1" +
@" -StartIpAddress 0.0.0.0" +
@" -EndIpAddress 1.1.1.1"));
});
Collection <PSObject> newFirewallRuleResult2 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"New-AzureSqlDatabaseServerFirewallRule" +
@" -ServerName $serverName" +
@" -RuleName Rule2" +
@" -StartIpAddress 1.1.1.1" +
@" -EndIpAddress 2.2.2.2"));
});
Collection <PSObject> getFirewallRuleResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabaseServerFirewallRule $serverName"));
});
Collection <PSObject> setFirewallResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable("fw", newFirewallRuleResult1);
powershell.InvokeBatchScript(
@"$fw | Set-AzureSqlDatabaseServerFirewallRule" +
@" -StartIpAddress 2.2.2.2" +
@" -EndIpAddress 3.3.3.3");
return(powershell.InvokeBatchScript(
@"$fw | Get-AzureSqlDatabaseServerFirewallRule"));
});
Collection <PSObject> removeFirewallResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable("rules", getFirewallRuleResult);
powershell.InvokeBatchScript(
@"$rules | Remove-AzureSqlDatabaseServerFirewallRule" +
@" -Force");
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabaseServerFirewallRule $serverName"));
});
Assert.AreEqual(0, powershell.Streams.Error.Count, "Unexpected Errors during run!");
Assert.AreEqual(0, powershell.Streams.Warning.Count, "Unexpected Warnings during run!");
// Validate New- and Get-AzureSqlDatabaseServerFirewallRule
SqlDatabaseServerFirewallRuleContext[] firewallRules = getFirewallRuleResult
.Select(r => r.BaseObject as SqlDatabaseServerFirewallRuleContext)
.ToArray();
Assert.AreEqual(2, firewallRules.Length, "Expecting two firewall rules");
Assert.IsNotNull(firewallRules[0],
"Expecting a SqlDatabaseServerFirewallRuleContext object.");
Assert.IsNotNull(firewallRules[1],
"Expecting a SqlDatabaseServerFirewallRuleContext object.");
Assert.AreEqual(SqlDatabaseTestSettings.Instance.ServerName, firewallRules[0].ServerName);
Assert.AreEqual("Rule1", firewallRules[0].RuleName);
Assert.AreEqual("0.0.0.0", firewallRules[0].StartIpAddress);
Assert.AreEqual("1.1.1.1", firewallRules[0].EndIpAddress);
Assert.AreEqual("Success", firewallRules[0].OperationStatus);
Assert.AreEqual(SqlDatabaseTestSettings.Instance.ServerName, firewallRules[1].ServerName);
Assert.AreEqual("Rule2", firewallRules[1].RuleName);
Assert.AreEqual("1.1.1.1", firewallRules[1].StartIpAddress);
Assert.AreEqual("2.2.2.2", firewallRules[1].EndIpAddress);
Assert.AreEqual("Success", firewallRules[1].OperationStatus);
// Validate Set-AzureSqlDatabaseServerFirewallRule
SqlDatabaseServerFirewallRuleContext firewallRule =
setFirewallResult.Single().BaseObject as SqlDatabaseServerFirewallRuleContext;
Assert.IsNotNull(firewallRule, "Expecting a SqlDatabaseServerFirewallRuleContext object");
Assert.AreEqual(SqlDatabaseTestSettings.Instance.ServerName, firewallRule.ServerName);
Assert.AreEqual("Rule1", firewallRule.RuleName);
Assert.AreEqual("2.2.2.2", firewallRule.StartIpAddress);
Assert.AreEqual("3.3.3.3", firewallRule.EndIpAddress);
Assert.AreEqual("Success", firewallRule.OperationStatus);
// Validate Remove-AzureSqlDatabaseServerFirewallRule
Assert.AreEqual(0, removeFirewallResult.Count,
"Expect all firewall rules are dropped.");
}
}
public void AzureSqlDatabaseCertTests()
{
// This test uses the https endpoint, setup the certificates.
MockHttpServer.SetupCertificates();
using (PowerShell powershell = PowerShell.Create())
{
// Setup the subscription used for the test
WindowsAzureSubscription subscription =
UnitTestHelper.SetupUnitTestSubscription(powershell);
powershell.Runspace.SessionStateProxy.SetVariable(
"serverName",
SqlDatabaseTestSettings.Instance.ServerName);
// Create a new server
HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession(
"UnitTest.AzureSqlDatabaseCertTests");
ServerTestHelper.SetDefaultTestSessionSettings(testSession);
// Uncomment one of these two when testing against onebox or production
// When testing production use RDFE
// testSession.ServiceBaseUri = new Uri("https://management.core.windows.net");
// When testing onebox use Mock RDFE
// testSession.ServiceBaseUri = new Uri("https://management.dev.mscds.com:12346/MockRDFE/");
testSession.RequestValidator =
new Action <HttpMessage, HttpMessage.Request>(
(expected, actual) =>
{
Assert.AreEqual(expected.RequestInfo.Method, actual.Method);
Assert.IsTrue(
actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue),
"Missing proper UserAgent string.");
Assert.IsTrue(
UnitTestHelper.GetUnitTestClientCertificate().Equals(actual.Certificate),
"Expected correct client certificate");
});
Collection <PSObject> newDatabaseResult1 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"New-AzureSqlDatabase" +
@" -ServerName $serverName" +
@" -DatabaseName testdbcert1"));
});
Collection <PSObject> newDatabaseResult2 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"New-AzureSqlDatabase" +
@" -ServerName $serverName" +
@" -DatabaseName testdbcert2" +
@" -Edition Business" +
@" -MaxSizeGB 10" +
@" -Collation Japanese_CI_AS"));
});
Collection <PSObject> getDatabaseResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabase" +
@" $serverName"));
});
Collection <PSObject> getSingleDatabaseResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabase" +
@" $serverName" +
@" -DatabaseName testdbcert1"));
});
Collection <PSObject> setDatabaseNameResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable("db", newDatabaseResult1.FirstOrDefault());
return(powershell.InvokeBatchScript(
@"$db | Set-AzureSqlDatabase" +
@" -NewDatabaseName testdbcert3" +
@" -PassThru"));
});
Collection <PSObject> setDatabaseSizeResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable("db", newDatabaseResult1.FirstOrDefault());
return(powershell.InvokeBatchScript(
@"$db | Set-AzureSqlDatabase" +
@" -MaxSizeGB 5" +
@" -PassThru"));
});
Collection <PSObject> P1 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"$P1 = Get-AzureSqlDatabaseServiceObjective" +
@" -Server $serverName" +
@" -ServiceObjectiveName ""Reserved P1""",
@"$P1"));
});
Collection <PSObject> P2 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.InvokeBatchScript(
@"$SLO = Get-AzureSqlDatabaseServiceObjective" +
@" -Server $serverName");
return(powershell.InvokeBatchScript(
@"$P2 = Get-AzureSqlDatabaseServiceObjective" +
@" -Server $serverName" +
@" -ServiceObjective $SLO[1]",
@"$P2"));
});
Collection <PSObject> newPremiumP1DatabaseResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
string.Format(
CultureInfo.InvariantCulture,
@"New-AzureSqlDatabase" +
@" -ServerName {0}" +
@" -DatabaseName ""testdbcertPremiumDBP1""" +
@" -Edition Premium" +
@" -ServiceObjective $P1",
"testserver")));
});
Collection <PSObject> newPremiumP2DatabaseResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
string.Format(
CultureInfo.InvariantCulture,
@"New-AzureSqlDatabase" +
@" -ServerName {0}" +
@" -DatabaseName ""testdbcertPremiumDBP2""" +
@" -Edition Premium" +
@" -ServiceObjective $P2",
"testserver")));
});
// There is a known issue about the Get-AzureSqlDatabaseOperation that it returns all
// operations which has the required database name no matter it's been deleted and recreated.
// So when run it against the mock session, please use the hard coded testsDBName.
// Run against onebox, please use the one with NewGuid().
// This unit test should be updated once that behavior get changed which was already been
// created as a task.
//string getOperationDbName = "testdbcertGetOperationDbName_" + Guid.NewGuid().ToString();
string getOperationDbName = "testdbcertGetOperationDbName_5d8b5785-0490-402c-b42f-6a5f5d6fbed8";
Collection <PSObject> newOperationDbResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
string.Format(
CultureInfo.InvariantCulture,
@"$getOperationDb = New-AzureSqlDatabase" +
@" -ServerName testserver" +
@" -DatabaseName ""{0}""",
getOperationDbName),
@"$getOperationDb"));
});
Collection <PSObject> getDatabaseOperationByDbResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
string.Format(
CultureInfo.InvariantCulture,
@"Get-AzureSqlDatabaseOperation" +
@" -ServerName testserver" +
@" -Database $getOperationDb")));
});
Collection <PSObject> getDatabaseOperationByNameResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
string.Format(
CultureInfo.InvariantCulture,
@"$getOperation = Get-AzureSqlDatabaseOperation" +
@" -ServerName testserver" +
@" -DatabaseName ""{0}""",
getOperationDbName),
@"$getOperation"));
});
Collection <PSObject> getDatabaseOperationByIdResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
string.Format(
CultureInfo.InvariantCulture,
@"Get-AzureSqlDatabaseOperation" +
@" -ServerName testserver" +
@" -OperationGuid $getOperation[0].Id")));
});
Collection <PSObject> removeDatabaseResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable("db1", newDatabaseResult1.FirstOrDefault());
powershell.Runspace.SessionStateProxy.SetVariable("db2", newDatabaseResult2.FirstOrDefault());
powershell.Runspace.SessionStateProxy.SetVariable("premiumP1", newPremiumP1DatabaseResult.FirstOrDefault());
powershell.Runspace.SessionStateProxy.SetVariable("premiumP2", newPremiumP2DatabaseResult.FirstOrDefault());
powershell.Runspace.SessionStateProxy.SetVariable("operationDb", newOperationDbResult.FirstOrDefault());
powershell.InvokeBatchScript(
@"$db1 | Remove-AzureSqlDatabase" +
@" -Force");
powershell.InvokeBatchScript(
@"$db2 | Remove-AzureSqlDatabase" +
@" -Force");
powershell.InvokeBatchScript(
@"$premiumP1 | Remove-AzureSqlDatabase" +
@" -Force");
powershell.InvokeBatchScript(
@"$premiumP2 | Remove-AzureSqlDatabase" +
@" -Force");
powershell.InvokeBatchScript(
@"$operationDb | Remove-AzureSqlDatabase" +
@" -Force");
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabase" +
@" $serverName"));
});
Assert.AreEqual(0, powershell.Streams.Error.Count, "Unexpected Errors during run!");
Assert.AreEqual(0, powershell.Streams.Warning.Count, "Unexpected Warnings during run!");
// Validate New-AzureSqlDatabase
Database[] databases = new Database[] { newDatabaseResult1.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0],
"Expecting a Database object.");
// Note: Because the object is piped, this is the final state of the
// database object, after all the Set- cmdlet has run.
Assert.AreEqual("testdbcert3", databases[0].Name);
Assert.AreEqual("Web", databases[0].Edition);
Assert.AreEqual(5, databases[0].MaxSizeGB);
Assert.AreEqual("SQL_Latin1_General_CP1_CI_AS", databases[0].CollationName);
databases = new Database[] { newDatabaseResult2.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0],
"Expecting a Database object.");
Assert.AreEqual("testdbcert2", databases[0].Name);
Assert.AreEqual("Business", databases[0].Edition);
Assert.AreEqual(10, databases[0].MaxSizeGB);
Assert.AreEqual("Japanese_CI_AS", databases[0].CollationName);
// Validate Get-AzureSqlDatabase
databases = getDatabaseResult.Select(r => r.BaseObject as Database).ToArray();
Assert.AreEqual(3, databases.Length, "Expecting 3 databases");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
Assert.IsNotNull(databases[1], "Expecting a Database object.");
Assert.IsNotNull(databases[2], "Expecting a Database object.");
Assert.AreEqual("master", databases[0].Name);
Assert.AreEqual("Web", databases[0].Edition);
Assert.AreEqual(5, databases[0].MaxSizeGB);
Assert.AreEqual("SQL_Latin1_General_CP1_CI_AS", databases[0].CollationName);
Assert.AreEqual(true, databases[0].IsSystemObject);
Assert.AreEqual("testdbcert1", databases[1].Name);
Assert.AreEqual("Web", databases[1].Edition);
Assert.AreEqual(1, databases[1].MaxSizeGB);
Assert.AreEqual("SQL_Latin1_General_CP1_CI_AS", databases[1].CollationName);
Assert.AreEqual(false, databases[1].IsSystemObject);
Assert.AreEqual("testdbcert2", databases[2].Name);
Assert.AreEqual("Business", databases[2].Edition);
Assert.AreEqual(10, databases[2].MaxSizeGB);
Assert.AreEqual("Japanese_CI_AS", databases[2].CollationName);
Assert.AreEqual(false, databases[2].IsSystemObject);
databases = new Database[] { getSingleDatabaseResult.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0],
"Expecting a Database object.");
Assert.AreEqual("testdbcert1", databases[0].Name);
Assert.AreEqual("Web", databases[0].Edition);
Assert.AreEqual(1, databases[0].MaxSizeGB);
Assert.AreEqual("SQL_Latin1_General_CP1_CI_AS", databases[0].CollationName);
// Validate Set-AzureSqlDatabase
databases = new Database[] { setDatabaseNameResult.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0],
"Expecting a Database object.");
Assert.AreEqual("testdbcert3", databases[0].Name);
Assert.AreEqual("Web", databases[0].Edition);
Assert.AreEqual(1, databases[0].MaxSizeGB);
Assert.AreEqual("SQL_Latin1_General_CP1_CI_AS", databases[0].CollationName);
databases = new Database[] { setDatabaseSizeResult.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0],
"Expecting a Database object.");
Assert.AreEqual("testdbcert3", databases[0].Name);
Assert.AreEqual("Web", databases[0].Edition);
Assert.AreEqual(5, databases[0].MaxSizeGB);
Assert.AreEqual("SQL_Latin1_General_CP1_CI_AS", databases[0].CollationName);
// Validate New-AzureSqlDatabase for Premium Edition Database
VerifyCreatePremiumDb(newPremiumP1DatabaseResult, "testdbcertPremiumDBP1", (P1.Single().BaseObject as ServiceObjective).Id.ToString());
VerifyCreatePremiumDb(newPremiumP2DatabaseResult, "testdbcertPremiumDBP2", (P2.Single().BaseObject as ServiceObjective).Id.ToString());
// Validate Get-AzureSqlDatabaseServiceObjective
var SLOP1 = P1.Single().BaseObject as ServiceObjective;
Assert.AreEqual(SLOP1.Name, "Reserved P1");
Assert.AreEqual(SLOP1.Description, "Resource capacity is reserved.");
Assert.IsNotNull(SLOP1.DimensionSettings, "Expecting some Dimension Setting objects.");
Assert.AreEqual(SLOP1.DimensionSettings.Count(), 1, "Expecting 1 Dimension Setting.");
Assert.AreEqual(SLOP1.DimensionSettings[0].Description, "Resource capacity is reserved.", "Expecting Dimension Setting description as Resource capacity is reserved.");
var SLOP2 = P2.Single().BaseObject as ServiceObjective;
Assert.AreEqual(SLOP2.Name, "Reserved P2");
Assert.AreEqual(SLOP2.Description, "Resource capacity is reserved.");
Assert.IsNotNull(SLOP2.DimensionSettings, "Expecting some Dimension Setting objects.");
Assert.AreEqual(SLOP2.DimensionSettings.Count(), 1, "Expecting 1 Dimension Setting.");
Assert.AreEqual(SLOP2.DimensionSettings[0].Description, "Resource capacity is reserved.", "Expecting Dimension Setting description as Resource capacity is reserved.");
// Validate Get-AzureSqlDatabaseOperation
VerifyGetAzureSqlDatabaseOperation(getOperationDbName, getDatabaseOperationByDbResult);
VerifyGetAzureSqlDatabaseOperation(getOperationDbName, getDatabaseOperationByNameResult);
VerifyGetAzureSqlDatabaseOperation(getOperationDbName, getDatabaseOperationByIdResult);
// Validate Remove-AzureSqlDatabase
databases = new Database[] { removeDatabaseResult.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting no databases");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
Assert.AreEqual("master", databases[0].Name);
Assert.AreEqual("Web", databases[0].Edition);
Assert.AreEqual(5, databases[0].MaxSizeGB);
Assert.AreEqual("SQL_Latin1_General_CP1_CI_AS", databases[0].CollationName);
}
}
public void GetRestorableDroppedDatabaseWithCertAuth()
{
var testSession = MockServerHelper.DefaultSessionCollection.GetSession(
"UnitTest.GetRestorableDroppedDatabaseWithCertAuth");
ServerTestHelper.SetDefaultTestSessionSettings(testSession);
testSession.RequestValidator =
new Action <HttpMessage, HttpMessage.Request>(
(expected, actual) =>
{
Assert.AreEqual(expected.RequestInfo.Method, actual.Method);
Assert.IsTrue(
actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue),
"Missing proper UserAgent string.");
});
using (var exceptionManager = new AsyncExceptionManager())
{
Collection <PSObject> databases, database1, database2;
using (new MockHttpServer(exceptionManager, MockHttpServer.DefaultHttpsServerPrefixUri, testSession))
{
databases = powershell.InvokeBatchScript(
@"Get-AzureSqlDatabase -RestorableDropped -ServerName $serverName");
}
Assert.AreEqual(0, powershell.Streams.Error.Count, "Errors during run!");
Assert.AreEqual(0, powershell.Streams.Warning.Count, "Warnings during run!");
powershell.Streams.ClearStreams();
// Expecting testdb1, testdb2, possibly dropped databases from previous runs
Assert.IsTrue(
databases.Count >= 2,
"Expecting at-least two RestorableDroppedDatabase objects");
Assert.IsTrue(
databases[0].BaseObject is RestorableDroppedDatabase,
"Expecting a RestorableDroppedDatabase object");
Assert.IsTrue(
databases[1].BaseObject is RestorableDroppedDatabase,
"Expecting a RestorableDroppedDatabase object");
var database1Object = (RestorableDroppedDatabase)databases[0].BaseObject;
var database1DeletionDate = database1Object.DeletionDate.ToUniversalTime().ToString(deletionDateStringFormat);
var database2Object = (RestorableDroppedDatabase)databases[1].BaseObject;
var database2DeletionDate = database2Object.DeletionDate.ToUniversalTime().ToString(deletionDateStringFormat);
using (new MockHttpServer(
exceptionManager, MockHttpServer.DefaultHttpsServerPrefixUri, testSession))
{
database1 = powershell.InvokeBatchScript(
@"Get-AzureSqlDatabase -RestorableDropped " +
@"-ServerName $serverName " +
@"-DatabaseName " + database1Object.Name + @" " +
@"-DatabaseDeletionDate " + database1DeletionDate);
database2 = powershell.InvokeBatchScript(
@"Get-AzureSqlDatabase -RestorableDropped " +
@"-ServerName $serverName " +
@"-DatabaseName " + database2Object.Name + @" " +
@"-DatabaseDeletionDate " + database2DeletionDate);
}
Assert.IsTrue(
database1.Single().BaseObject is RestorableDroppedDatabase,
"Expecting a RestorableDroppedDatabase object");
var refreshedDatabase1Object = (RestorableDroppedDatabase)database1.Single().BaseObject;
Assert.AreEqual(
database1Object.Name, refreshedDatabase1Object.Name,
"Expected db name to be " + database1Object.Name);
Assert.IsTrue(
database2.Single().BaseObject is RestorableDroppedDatabase,
"Expecting a RestorableDroppedDatabase object");
var refreshedDatabase2Object = (RestorableDroppedDatabase)database2.Single().BaseObject;
Assert.AreEqual(
database2Object.Name, refreshedDatabase2Object.Name,
"Expected db name to be " + database2Object.Name);
Assert.AreEqual(
database2Object.Edition, refreshedDatabase2Object.Edition,
"Expected edition to be " + database2Object.Edition);
Assert.AreEqual(
database2Object.MaxSizeBytes, refreshedDatabase2Object.MaxSizeBytes,
"Expected max size to be " + database2Object.MaxSizeBytes);
}
}
public void GetRecoverableDatabaseWithCertAuthByPipe()
{
var testSession = MockServerHelper.DefaultSessionCollection.GetSession(
"UnitTest.GetRecoverableDatabaseWithCertAuthByPipe");
ServerTestHelper.SetDefaultTestSessionSettings(testSession);
testSession.RequestValidator =
new Action <HttpMessage, HttpMessage.Request>(
(expected, actual) =>
{
Assert.AreEqual(expected.RequestInfo.Method, actual.Method);
Assert.IsTrue(
actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue),
"Missing proper UserAgent string.");
Assert.IsTrue(
UnitTestHelper.GetUnitTestClientCertificate().Equals(actual.Certificate),
"Expected correct client certificate");
});
using (var exceptionManager = new AsyncExceptionManager())
{
Collection <PSObject> databases, database1, database2;
using (new MockHttpServer(
exceptionManager, MockHttpServer.DefaultHttpsServerPrefixUri, testSession))
{
databases = powershell.InvokeBatchScript(
@"Get-AzureSqlRecoverableDatabase " +
@"-TargetServerName $serverName");
}
Assert.AreEqual(0, powershell.Streams.Error.Count, "Errors during run!");
Assert.AreEqual(0, powershell.Streams.Warning.Count, "Warnings during run!");
powershell.Streams.ClearStreams();
// Expecting testdb1, testdb2, possibly dropped databases from previous runs
Assert.IsTrue(
databases.Count >= 2,
"Expecting at-least two RecoverableDatabase objects");
Assert.IsTrue(
databases[0].BaseObject is RecoverableDatabase,
"Expecting a RecoverableDatabase object");
Assert.IsTrue(
databases[1].BaseObject is RecoverableDatabase,
"Expecting a RecoverableDatabase object");
var database1Object = (RecoverableDatabase)databases[0].BaseObject;
var database2Object = (RecoverableDatabase)databases[1].BaseObject;
using (new MockHttpServer(
exceptionManager, MockHttpServer.DefaultHttpsServerPrefixUri, testSession))
{
powershell.InvokeBatchScript(
@"$testdb1 = Get-AzureSqlRecoverableDatabase " +
@"-TargetServerName $serverName " +
@"-SourceDatabaseName " + database1Object.Name);
powershell.InvokeBatchScript(
@"$testdb2 = Get-AzureSqlRecoverableDatabase " +
@"-TargetServerName $serverName " +
@"-SourceDatabaseName " + database2Object.Name);
database1 = powershell.InvokeBatchScript(
@"$testdb1 | Get-AzureSqlRecoverableDatabase");
database2 = powershell.InvokeBatchScript(
@"$testdb2 | Get-AzureSqlRecoverableDatabase");
}
Assert.IsTrue(
database1.Single().BaseObject is RecoverableDatabase,
"Expecting a RecoverableDatabase object");
var refreshedDatabase1Object = (RecoverableDatabase)database1.Single().BaseObject;
Assert.AreEqual(
database1Object.Name, refreshedDatabase1Object.Name,
"Expected db name to be " + database1Object.Name);
Assert.IsTrue(
database2.Single().BaseObject is RecoverableDatabase,
"Expecting a RecoverableDatabase object");
var refreshedDatabase2Object = (RecoverableDatabase)database2.Single().BaseObject;
Assert.AreEqual(
database2Object.Name, refreshedDatabase2Object.Name,
"Expected db name to be " + database2Object.Name);
Assert.AreEqual(
database2Object.Edition, refreshedDatabase2Object.Edition,
"Expected edition to be " + database2Object.Edition);
}
}
/// <summary>
/// Helper function to create the test databases.
/// </summary>
public static void CreateTestDatabasesWithCertAuth(System.Management.Automation.PowerShell powershell)
{
HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession(
"UnitTest.Common.CreateTestDatabasesWithCertAuth");
ServerTestHelper.SetDefaultTestSessionSettings(testSession);
testSession.RequestValidator =
new Action <HttpMessage, HttpMessage.Request>(
(expected, actual) =>
{
Assert.AreEqual(expected.RequestInfo.Method, actual.Method);
Assert.IsTrue(
actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue),
"Missing proper UserAgent string.");
});
using (AsyncExceptionManager exceptionManager = new AsyncExceptionManager())
{
Collection <PSObject> database1, database2, database3;
using (new MockHttpServer(
exceptionManager,
MockHttpServer.DefaultHttpsServerPrefixUri,
testSession))
{
database1 = powershell.InvokeBatchScript(
@"$testdb1 = New-AzureSqlDatabase " +
@"-ServerName $serverName " +
@"-DatabaseName testdb1 " +
@"-Force",
@"$testdb1");
database2 = powershell.InvokeBatchScript(
@"$testdb2 = New-AzureSqlDatabase " +
@"-ServerName $serverName " +
@"-DatabaseName testdb2 " +
@"-Collation Japanese_CI_AS " +
@"-Edition Standard " +
@"-MaxSizeGB 5 " +
@"-Force",
@"$testdb2");
database3 = powershell.InvokeBatchScript(
@"$testdb3 = New-AzureSqlDatabase " +
@"-ServerName $serverName " +
@"-DatabaseName testdb3 " +
@"-MaxSizeBytes 104857600 " +
@"-Force",
@"$testdb3");
}
Assert.AreEqual(0, powershell.Streams.Error.Count, "Errors during run!");
Assert.AreEqual(0, powershell.Streams.Warning.Count, "Warnings during run!");
powershell.Streams.ClearStreams();
Services.Server.Database database = database1.Single().BaseObject as Services.Server.Database;
Assert.IsTrue(database != null, "Expecting a Database object");
DatabaseTestHelper.ValidateDatabaseProperties(database, "testdb1", "Standard", 250, 268435456000L, "SQL_Latin1_General_CP1_CI_AS", "S0", false, DatabaseTestHelper.StandardS0SloGuid);
database = database2.Single().BaseObject as Services.Server.Database;
Assert.IsTrue(database != null, "Expecting a Database object");
DatabaseTestHelper.ValidateDatabaseProperties(database, "testdb2", "Standard", 250, 268435456000L, "Japanese_CI_AS", "S0", false, DatabaseTestHelper.StandardS0SloGuid);
database = database3.Single().BaseObject as Services.Server.Database;
Assert.IsTrue(database != null, "Expecting a Database object");
DatabaseTestHelper.ValidateDatabaseProperties(database, "testdb3", "Standard", 0, 104857600L, "SQL_Latin1_General_CP1_CI_AS", "S0", false, DatabaseTestHelper.StandardS0SloGuid);
}
}
public static void SET_ClassInitialize(TestContext context)
{
ServerTestHelper.ClassInitialize(context);
}
public void AzureSqlDatabaseCertTests()
{
// This test uses the https endpoint, setup the certificates.
MockHttpServer.SetupCertificates();
using (PowerShell powershell = PowerShell.Create())
{
// Setup the subscription used for the test
WindowsAzureSubscription subscription =
UnitTestHelper.SetupUnitTestSubscription(powershell);
powershell.Runspace.SessionStateProxy.SetVariable(
"serverName",
SqlDatabaseTestSettings.Instance.ServerName);
// Create a new server
HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession(
"UnitTest.AzureSqlDatabaseCertTests");
ServerTestHelper.SetDefaultTestSessionSettings(testSession);
//testSession.ServiceBaseUri = new Uri("https://management.core.windows.net");
testSession.RequestValidator =
new Action <HttpMessage, HttpMessage.Request>(
(expected, actual) =>
{
Assert.AreEqual(expected.RequestInfo.Method, actual.Method);
Assert.IsTrue(
actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue),
"Missing proper UserAgent string.");
Assert.IsTrue(
UnitTestHelper.GetUnitTestClientCertificate().Equals(actual.Certificate),
"Expected correct client certificate");
});
Collection <PSObject> newDatabaseResult1 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"New-AzureSqlDatabase" +
@" -ServerName $serverName" +
@" -DatabaseName testdbcert1"));
});
Collection <PSObject> newDatabaseResult2 = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"New-AzureSqlDatabase" +
@" -ServerName $serverName" +
@" -DatabaseName testdbcert2" +
@" -Edition Business" +
@" -MaxSizeGB 10" +
@" -Collation Japanese_CI_AS"));
});
Collection <PSObject> getDatabaseResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabase" +
@" $serverName"));
});
Collection <PSObject> getSingleDatabaseResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabase" +
@" $serverName" +
@" -DatabaseName testdbcert1"));
});
Collection <PSObject> setDatabaseNameResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable("db", newDatabaseResult1.FirstOrDefault());
return(powershell.InvokeBatchScript(
@"$db | Set-AzureSqlDatabase" +
@" -NewDatabaseName testdbcert3" +
@" -PassThru"));
});
Collection <PSObject> setDatabaseSizeResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable("db", newDatabaseResult1.FirstOrDefault());
return(powershell.InvokeBatchScript(
@"$db | Set-AzureSqlDatabase" +
@" -MaxSizeGB 5" +
@" -PassThru"));
});
Collection <PSObject> removeDatabaseResult = MockServerHelper.ExecuteWithMock(
testSession,
MockHttpServer.DefaultHttpsServerPrefixUri,
() =>
{
powershell.Runspace.SessionStateProxy.SetVariable("db1", newDatabaseResult1.FirstOrDefault());
powershell.Runspace.SessionStateProxy.SetVariable("db2", newDatabaseResult2.FirstOrDefault());
powershell.InvokeBatchScript(
@"$db1 | Remove-AzureSqlDatabase" +
@" -Force");
powershell.InvokeBatchScript(
@"$db2 | Remove-AzureSqlDatabase" +
@" -Force");
return(powershell.InvokeBatchScript(
@"Get-AzureSqlDatabase" +
@" $serverName"));
});
Assert.AreEqual(0, powershell.Streams.Error.Count, "Unexpected Errors during run!");
Assert.AreEqual(0, powershell.Streams.Warning.Count, "Unexpected Warnings during run!");
// Validate New-AzureSqlDatabase
Database[] databases = new Database[] { newDatabaseResult1.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0],
"Expecting a Database object.");
// Note: Because the object is piped, this is the final state of the
// database object, after all the Set- cmdlet has run.
Assert.AreEqual("testdbcert3", databases[0].Name);
Assert.AreEqual("Web", databases[0].Edition);
Assert.AreEqual(5, databases[0].MaxSizeGB);
Assert.AreEqual("SQL_Latin1_General_CP1_CI_AS", databases[0].CollationName);
databases = new Database[] { newDatabaseResult2.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0],
"Expecting a Database object.");
Assert.AreEqual("testdbcert2", databases[0].Name);
Assert.AreEqual("Business", databases[0].Edition);
Assert.AreEqual(10, databases[0].MaxSizeGB);
Assert.AreEqual("Japanese_CI_AS", databases[0].CollationName);
// Validate Get-AzureSqlDatabase
databases = getDatabaseResult.Single().BaseObject as Database[];
Assert.AreEqual(3, databases.Length, "Expecting three databases");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
Assert.IsNotNull(databases[1], "Expecting a Database object.");
Assert.IsNotNull(databases[2], "Expecting a Database object.");
Assert.AreEqual("master", databases[0].Name);
Assert.AreEqual("Web", databases[0].Edition);
Assert.AreEqual(5, databases[0].MaxSizeGB);
Assert.AreEqual("SQL_Latin1_General_CP1_CI_AS", databases[0].CollationName);
Assert.AreEqual(true, databases[0].IsSystemObject);
Assert.AreEqual("testdbcert1", databases[1].Name);
Assert.AreEqual("Web", databases[1].Edition);
Assert.AreEqual(1, databases[1].MaxSizeGB);
Assert.AreEqual("SQL_Latin1_General_CP1_CI_AS", databases[1].CollationName);
Assert.AreEqual(false, databases[1].IsSystemObject);
Assert.AreEqual("testdbcert2", databases[2].Name);
Assert.AreEqual("Business", databases[2].Edition);
Assert.AreEqual(10, databases[2].MaxSizeGB);
Assert.AreEqual("Japanese_CI_AS", databases[2].CollationName);
Assert.AreEqual(false, databases[2].IsSystemObject);
databases = new Database[] { getSingleDatabaseResult.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0],
"Expecting a Database object.");
Assert.AreEqual("testdbcert1", databases[0].Name);
Assert.AreEqual("Web", databases[0].Edition);
Assert.AreEqual(1, databases[0].MaxSizeGB);
Assert.AreEqual("SQL_Latin1_General_CP1_CI_AS", databases[0].CollationName);
// Validate Set-AzureSqlDatabase
databases = new Database[] { setDatabaseNameResult.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0],
"Expecting a Database object.");
Assert.AreEqual("testdbcert3", databases[0].Name);
Assert.AreEqual("Web", databases[0].Edition);
Assert.AreEqual(1, databases[0].MaxSizeGB);
Assert.AreEqual("SQL_Latin1_General_CP1_CI_AS", databases[0].CollationName);
databases = new Database[] { setDatabaseSizeResult.Single().BaseObject as Database };
Assert.AreEqual(1, databases.Length, "Expecting one database");
Assert.IsNotNull(databases[0],
"Expecting a Database object.");
Assert.AreEqual("testdbcert3", databases[0].Name);
Assert.AreEqual("Web", databases[0].Edition);
Assert.AreEqual(5, databases[0].MaxSizeGB);
Assert.AreEqual("SQL_Latin1_General_CP1_CI_AS", databases[0].CollationName);
// Validate Remove-AzureSqlDatabase
databases = removeDatabaseResult.Single().BaseObject as Database[];
Assert.AreEqual(1, databases.Length, "Expecting no databases");
Assert.IsNotNull(databases[0], "Expecting a Database object.");
Assert.AreEqual("master", databases[0].Name);
Assert.AreEqual("Web", databases[0].Edition);
Assert.AreEqual(5, databases[0].MaxSizeGB);
Assert.AreEqual("SQL_Latin1_General_CP1_CI_AS", databases[0].CollationName);
}
}
