/// <summary>
/// Set the default mock session settings to modify request and responses.
/// </summary>
/// <param name="testSession"></param>
public static void SetDefaultTestSessionSettings(HttpSession testSession)
{
testSession.ServiceBaseUri = MockServerHelper.CommonServiceBaseUri;
testSession.SessionProperties["Servername"] = "myserver01";
testSession.SessionProperties["Username"] = "******";
testSession.SessionProperties["Password"] = "******";
testSession.ResponseModifier =
new Action<HttpMessage>(
(message) =>
{
DatabaseTestHelper.FixODataResponseUri(
message.ResponseInfo,
testSession.ServiceBaseUri,
MockHttpServer.DefaultServerPrefixUri);
});
testSession.RequestModifier =
new Action<HttpMessage.Request>(
(request) =>
{
DatabaseTestHelper.FixODataRequestPayload(
request,
testSession.ServiceBaseUri,
MockHttpServer.DefaultServerPrefixUri);
});
}
/// <summary>
/// Initializes a new instance of the <see cref="MockHttpServer" /> class that record or
/// playback responses for requests in a session.
/// </summary>
/// <param name="exceptionManager">
/// The exception manager that captures all async exceptions.
/// </param>
/// <param name="baseUri">The server prefix to use.</param>
/// <param name="session">The object that stores request/response information.</param>
public MockHttpServer(
AsyncExceptionManager exceptionManager,
Uri baseUri,
HttpSession session)
: this(exceptionManager, baseUri)
{
this.stopListenerUri = new Uri(baseUri, Guid.NewGuid().ToString());
this.listener = this.CreateListener(
context => HandleMockRequest(
context,
this.baseUri,
session),
int.MaxValue);
}
/// <summary>
/// Set the default mock session settings to modify request and responses.
/// </summary>
/// <param name="testSession"></param>
public static void SetDefaultTestSessionSettings(HttpSession testSession)
{
testSession.ServiceBaseUri = ServerTestHelper.CommonServiceBaseUri;
testSession.RequestModifier =
new Action<HttpMessage.Request>(
(request) =>
{
});
testSession.ResponseModifier =
new Action<HttpMessage>(
(message) =>
{
});
}
/// <summary>
/// Set the default mock session settings to modify request and responses.
/// </summary>
/// <param name="testSession"></param>
public static void SetDefaultTestSessionSettings(HttpSession testSession)
{
testSession.ServiceBaseUri = ServerTestHelper.CommonServiceBaseUri;
testSession.RequestModifier =
new Action<HttpMessage.Request>(
(request) =>
{
// To run the tests targetting production uncomment the below line and substitute in a valid subscription ID.
// request.RequestUri = new Uri(request.RequestUri.OriginalString.Replace("00000000-0000-0000-0001-000000000001", "<subscription_id>"));
});
testSession.ResponseModifier =
new Action<HttpMessage>(
(message) =>
{
});
}
/// <summary>
/// The async delegate that handles an incoming request, passing it through to a real
/// service and record the response if <paramref name="serviceBaseUri"/> was specified,
/// or plays back responses from a pre-recorded <paramref name="session"/> if it was not.
/// </summary>
/// <param name="context">The context for the incoming request.</param>
/// <param name="baseUri">The incoming request's base Uri.</param>
/// <param name="session">The object that stores request/response information.</param>
private static void HandleMockRequest(
HttpListenerContext context,
Uri baseUri,
HttpSession session)
{
if (session.ServiceBaseUri != null)
{
// Issue the request to a real service and record the response
HttpMessage message = GetResponseInfoFromService(
context.Request,
baseUri,
session.ServiceBaseUri,
session);
session.Messages.RecordMessage(message);
}
// Construct the mock response from responses in the session.
HttpMessage recordedMessage = session.Messages.GetMessage(context.Request.Url);
if (session.RequestValidator != null)
{
HttpMessage.Request actualRequestInfo = ConstructRequestInfo(context.Request);
session.RequestValidator(recordedMessage, actualRequestInfo);
}
if (session.ResponseModifier != null)
{
session.ResponseModifier(recordedMessage);
}
ConstructListenerResponse(recordedMessage.ResponseInfo, baseUri, context.Response);
context.Response.Close();
}
/// <summary>
/// Retrieves an <see cref="HttpMessage"/> object from a real service.
/// </summary>
/// <param name="request">The request to mimic on the real service.</param>
/// <param name="baseUri">The request's base Uri.</param>
/// <param name="serviceBaseUri">The real service's base Uri.</param>
/// <param name="session">The object that stores request/response information.</param>
/// <returns>An <see cref="HttpMessage"/> object containing the request/response.</returns>
private static HttpMessage GetResponseInfoFromService(
HttpListenerRequest request,
Uri baseUri,
Uri serviceBaseUri,
HttpSession session)
{
// Construct the request to make
HttpMessage message = new HttpMessage();
message.RequestInfo = ConstructRequestInfo(request);
// Clone the request and modify it for the real service
HttpMessage.Request requestToSend = message.RequestInfo.Clone();
requestToSend.RequestUri = ChangeUriBase(request.Url, baseUri, serviceBaseUri);
if (session.RequestModifier != null)
{
session.RequestModifier(requestToSend);
}
HttpWebResponse response = MakeServiceRequest(requestToSend);
message.ResponseInfo = ConstructResponseInfo(serviceBaseUri, response);
return message;
}
/// <summary>
/// Helper function to create premium database in the powershell environment provided.
/// </summary>
/// <param name="powershell">The powershell environment</param>
/// <param name="testSession">The test session</param>
private static void TestCreatePremiumDatabase(System.Management.Automation.PowerShell powershell, HttpSession testSession)
{
using (AsyncExceptionManager exceptionManager = new AsyncExceptionManager())
{
Collection<PSObject> premiumDB_P1, PremiumDB_P2;
using (new MockHttpServer(
exceptionManager,
MockHttpServer.DefaultServerPrefixUri,
testSession))
{
powershell.InvokeBatchScript(
@"$P1 = Get-AzureSqlDatabaseServiceObjective" +
@" -Context $context" +
@" -ServiceObjectiveName ""P1""");
powershell.InvokeBatchScript(
@"$P2 = Get-AzureSqlDatabaseServiceObjective " +
@"-Context $context" +
@" -ServiceObjectiveName ""P2""");
premiumDB_P1 = powershell.InvokeBatchScript(
@"$premiumDB_P1 = New-AzureSqlDatabase " +
@"-Context $context " +
@"-DatabaseName NewAzureSqlPremiumDatabaseTests_P1 " +
@"-Edition Premium " +
@"-ServiceObjective $P1 ");
premiumDB_P1 = powershell.InvokeBatchScript("$PremiumDB_P1");
powershell.InvokeBatchScript(
@"$PremiumDB_P2 = New-AzureSqlDatabase " +
@"-Context $context " +
@"-DatabaseName NewAzureSqlPremiumDatabaseTests_P2 " +
@"-Collation Japanese_CI_AS " +
@"-Edition Premium " +
@"-ServiceObjective $P2 " +
@"-MaxSizeGB 10 " +
@"-Force");
PremiumDB_P2 = powershell.InvokeBatchScript("$PremiumDB_P2");
}
Assert.AreEqual(0, powershell.Streams.Error.Count, "Errors during run!");
Assert.AreEqual(0, powershell.Streams.Warning.Count, "Warnings during run!");
powershell.Streams.ClearStreams();
Assert.IsTrue(
premiumDB_P1.Single().BaseObject is Services.Server.Database,
"Expecting a Database object");
Services.Server.Database databaseP1 =
(Services.Server.Database)premiumDB_P1.Single().BaseObject;
Assert.AreEqual("NewAzureSqlPremiumDatabaseTests_P1", databaseP1.Name, "Expected db name to be NewAzureSqlPremiumDatabaseTests_P1");
Assert.IsTrue(
PremiumDB_P2.Single().BaseObject is Services.Server.Database,
"Expecting a Database object");
Services.Server.Database databaseP2 =
(Services.Server.Database)PremiumDB_P2.Single().BaseObject;
Assert.AreEqual("NewAzureSqlPremiumDatabaseTests_P2", databaseP2.Name, "Expected db name to be NewAzureSqlPremiumDatabaseTests_P2");
Assert.AreEqual(
"Japanese_CI_AS",
databaseP2.CollationName,
"Expected collation to be Japanese_CI_AS");
Assert.AreEqual("Premium", databaseP2.Edition, "Expected edition to be Premium");
Assert.AreEqual(10, databaseP2.MaxSizeGB, "Expected max size to be 10 GB");
}
}
