public void SetUp()
{
mockBuilder = new MockBuilder();
requestMessage = new TestRequestMessage();
responseMessage = new TestResponseMessage();
var correlationId = "";
mockBuilder.NextModel.Stub(x => x.BasicPublish(null, null, false, false, null, null))
.IgnoreArguments()
.WhenCalled(invocation =>
{
var properties = (IBasicProperties)invocation.Arguments[4];
correlationId = properties.CorrelationId;
});
var task = mockBuilder.Bus.RequestAsync <TestRequestMessage, TestResponseMessage>(requestMessage);
DeliverMessage(correlationId);
task.Wait();
responseMessage = task.Result;
}
public void SetUp()
{
mockBuilder = new MockBuilder();
requestMessage = new TestRequestMessage();
responseMessage = new TestResponseMessage();
var correlationId = "";
mockBuilder.NextModel.Stub(x => x.BasicPublish(null, null, false, null, null))
.IgnoreArguments()
.WhenCalled(invocation =>
{
var properties = (IBasicProperties)invocation.Arguments[3];
correlationId = properties.CorrelationId;
});
var task = mockBuilder.Bus.RequestAsync<TestRequestMessage, TestResponseMessage>(requestMessage);
DeliverMessage(correlationId);
task.Wait();
responseMessage = task.Result;
}
/// <summary>
/// Helper method to create a test message from its content.
/// </summary>
/// <param name="messageContent">Stream with the content of the message.</param>
/// <param name="testConfiguration">The test configuration.</param>
/// <param name="payloadKind">The payload kind to use to compute and set the content type header; or null if no content type header should be set.</param>
/// <param name="customContentTypeHeader">A custom content type header to be used in the message.</param>
/// <param name="urlResolver">Url resolver to add to the test message created.</param>
/// <returns>Newly created test message.</returns>
protected TestMessage CreateInputMessageFromStream(
TestStream messageContent,
WriterTestConfiguration testConfiguration,
ODataPayloadKind?payloadKind,
string customContentTypeHeader,
IODataUrlResolver urlResolver)
{
TestMessage message;
if (testConfiguration.IsRequest)
{
if (urlResolver != null)
{
message = new TestRequestMessageWithUrlResolver(messageContent, urlResolver, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
}
else
{
message = new TestRequestMessage(messageContent, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
}
}
else
{
if (urlResolver != null)
{
message = new TestResponseMessageWithUrlResolver(messageContent, urlResolver, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
}
else
{
message = new TestResponseMessage(messageContent, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
}
}
return(message);
}
public void Should_be_able_to_do_basic_request_response()
{
const string expectedResult = "Sending back 'Ninja!!'";
var autoResetEvent = new AutoResetEvent(false);
bus.Respond <TestRequestMessage, TestResponseMessage>(request =>
{
var response = new TestResponseMessage
{
Text = string.Format("Sending back '{0}'", request.Text)
};
return(response);
});
var actualResult = string.Empty;
using (var channel = bus.OpenPublishChannel())
{
var request = new TestRequestMessage {
Text = "Ninja!!"
};
channel.Request <TestRequestMessage, TestResponseMessage>(
request,
response =>
{
actualResult = response.Text;
autoResetEvent.Set();
});
}
// give the bus a chance to deliver the message
autoResetEvent.WaitOne(1000);
actualResult.ShouldEqual(expectedResult);
}
public void Should_be_able_to_do_basic_request_async_cancellation()
{
const string expectedResult = "Sending back 'Ninja!!'";
var autoResetEvent = new AutoResetEvent(false);
bus.Respond<TestRequestMessage, TestResponseMessage>(request =>
{
var response = new TestResponseMessage
{
Text = string.Format("Sending back '{0}'", request.Text)
};
return response;
});
using (var channel = bus.OpenPublishChannel())
{
var request = new TestRequestMessage { Text = "Ninja!!" };
var cancellationSource = new CancellationTokenSource();
var responseTask = channel.RequestAsync<TestRequestMessage, TestResponseMessage>(request, cancellationSource.Token);
responseTask.ContinueWith(t =>
{
autoResetEvent.Set();
}, TaskContinuationOptions.OnlyOnCanceled);
cancellationSource.Cancel();
}
// give the bus a chance to deliver the message
Assert.IsTrue(autoResetEvent.WaitOne(1000));
}
public void Should_be_able_to_do_basic_request_async()
{
const string expectedResult = "Sending back 'Ninja!!'";
var autoResetEvent = new AutoResetEvent(false);
bus.Respond<TestRequestMessage, TestResponseMessage>(request =>
{
var response = new TestResponseMessage
{
Text = string.Format("Sending back '{0}'", request.Text)
};
return response;
});
var actualResult = string.Empty;
using (var channel = bus.OpenPublishChannel())
{
var request = new TestRequestMessage { Text = "Ninja!!" };
var responseTask = channel.RequestAsync<TestRequestMessage, TestResponseMessage>(request);
responseTask.ContinueWith(t =>
{
actualResult = t.Result.Text;
autoResetEvent.Set();
});
}
// give the bus a chance to deliver the message
autoResetEvent.WaitOne(1000);
actualResult.ShouldEqual(expectedResult);
}
public void Should_be_able_to_do_basic_request_async_cancellation()
{
const string expectedResult = "Sending back 'Ninja!!'";
var autoResetEvent = new AutoResetEvent(false);
bus.Respond <TestRequestMessage, TestResponseMessage>(request =>
{
var response = new TestResponseMessage
{
Text = string.Format("Sending back '{0}'", request.Text)
};
return(response);
});
using (var channel = bus.OpenPublishChannel())
{
var request = new TestRequestMessage {
Text = "Ninja!!"
};
var cancellationSource = new CancellationTokenSource();
var responseTask = channel.RequestAsync <TestRequestMessage, TestResponseMessage>(request, cancellationSource.Token);
responseTask.ContinueWith(t =>
{
autoResetEvent.Set();
}, TaskContinuationOptions.OnlyOnCanceled);
cancellationSource.Cancel();
}
// give the bus a chance to deliver the message
Assert.IsTrue(autoResetEvent.WaitOne(1000));
}
public void Initialize(IBus bus)
{
bus.Subscribe <TestRequestMessage>("subscriptionId", requestMessage =>
{
var responseMessage = new TestResponseMessage
{
Text = requestMessage.Text
};
bus.Publish(responseMessage);
});
}
public void MessageReaderConstructorArgumentValidationTest()
{
TestRequestMessage requestMessage = new TestRequestMessage(new MemoryStream());
TestResponseMessage responseMessage = new TestResponseMessage(new MemoryStream());
this.CombinatorialEngineProvider.RunCombinations(
settingsActionTestCases,
(settingsAction) =>
{
TestMessage message = settingsAction.Response
? (TestMessage)responseMessage
: (TestMessage)requestMessage;
// Verify that relative BaseUri will fail
this.Assert.ExpectedException(
() => settingsAction.Action(message, new ODataMessageReaderSettings {
BaseUri = new Uri("foo", UriKind.Relative)
}),
ODataExpectedExceptions.ODataException("ReaderValidationUtils_MessageReaderSettingsBaseUriMustBeNullOrAbsolute", "foo/"),
this.ExceptionVerifier);
// Verify the None UndeclaredPropertyBehaviorKinds works on both request and response.
this.Assert.ExpectedException(
() => settingsAction.Action(message, new ODataMessageReaderSettings {
UndeclaredPropertyBehaviorKinds = ODataUndeclaredPropertyBehaviorKinds.None
}),
null,
this.ExceptionVerifier);
// Verify the IgnoreUndeclaredValueProperty UndeclaredPropertyBehaviorKinds fails on requests.
this.Assert.ExpectedException(
() => settingsAction.Action(message, new ODataMessageReaderSettings {
UndeclaredPropertyBehaviorKinds = ODataUndeclaredPropertyBehaviorKinds.IgnoreUndeclaredValueProperty
}),
settingsAction.Response ? null : ODataExpectedExceptions.ODataException("ReaderValidationUtils_UndeclaredPropertyBehaviorKindSpecifiedOnRequest"),
this.ExceptionVerifier);
// Verify the ReportUndeclaredLinkProperty UndeclaredPropertyBehaviorKinds fails on requests.
this.Assert.ExpectedException(
() => settingsAction.Action(message, new ODataMessageReaderSettings {
UndeclaredPropertyBehaviorKinds = ODataUndeclaredPropertyBehaviorKinds.ReportUndeclaredLinkProperty
}),
settingsAction.Response ? null : ODataExpectedExceptions.ODataException("ReaderValidationUtils_UndeclaredPropertyBehaviorKindSpecifiedOnRequest"),
this.ExceptionVerifier);
// Verify the IgnoreUndeclaredValueProperty | ReportUndeclaredLinkProperty UndeclaredPropertyBehaviorKinds fails on requests.
this.Assert.ExpectedException(
() => settingsAction.Action(message, new ODataMessageReaderSettings {
UndeclaredPropertyBehaviorKinds = ODataUndeclaredPropertyBehaviorKinds.IgnoreUndeclaredValueProperty | ODataUndeclaredPropertyBehaviorKinds.ReportUndeclaredLinkProperty
}),
settingsAction.Response ? null : ODataExpectedExceptions.ODataException("ReaderValidationUtils_UndeclaredPropertyBehaviorKindSpecifiedOnRequest"),
this.ExceptionVerifier);
});
}
public void Initialize(IBus bus)
{
bus.SubscribeAsync <TestRequestMessage>("id", requestMessage =>
{
var responseMessage = new TestResponseMessage
{
Text = requestMessage.Text
};
return(Task.Factory.StartNew(() => bus.Publish(responseMessage)));
});
}
private ODataMessageWriter CreateMessageWriter(bool useModel)
{
var responseMessage = new TestResponseMessage(this.stream);
var writerSettings = new ODataMessageWriterSettings {
DisableMessageStreamDisposal = true
};
writerSettings.SetServiceDocumentUri(new Uri("http://host/service"));
var model = useModel ? this.GetModel() : null;
return(new ODataMessageWriter(responseMessage, writerSettings, model));
}
private MaterializeAtom CreateMaterializer <T>(string content, string contentType, ProjectionPlan plan)
{
ResponseInfo info = new ResponseInfo(new RequestInfo(this.context), MergeOption.AppendOnly);
QueryComponents qc = new QueryComponents(this.serviceUri, Util.ODataVersion4, typeof(T), null, null);
Dictionary <string, string> headers = new Dictionary <string, string>();
headers.Add(XmlConstants.HttpContentType, contentType);
var bytes = System.Text.Encoding.UTF8.GetBytes(content);
TestResponseMessage responseMessage = new TestResponseMessage(headers, HttpStatusCode.OK, () => new System.IO.MemoryStream(bytes));
return(new MaterializeAtom(info, qc, plan, responseMessage, ODataPayloadKind.Unsupported));
}
public void TestResponseXml()
{
var response = new TestResponseMessage()
{
ADateTime = DateTime.UtcNow,
AnEnum = ResponseEnumValues.Two,
ANumber = 42,
Success = true,
Message = "This is a test message"
};
Trace.WriteLine($"response message xml:\n{response.ToXmlString()}");
}
public void TestResponseSerialization()
{
var responseMessage = new TestResponseMessage()
{
ADateTime = DateTime.UtcNow,
AGuid = Guid.NewGuid(),
AnEnum = ResponseEnumValues.One,
ANumber = 42,
Message = "A message",
Success = true
};
Trace.WriteLine($"response message:\n{responseMessage.ToYamlString()}");
}
public void Initialize(IBus bus)
{
bus.Subscribe<TestRequestMessage>("subscriptionId", requestMessage =>
{
var responseMessage = new TestResponseMessage
{
Text = requestMessage.Text
};
using (var publishChannel = bus.OpenPublishChannel())
{
publishChannel.Publish(responseMessage);
}
});
}
public void Initialize(IBus bus)
{
bus.Subscribe <TestRequestMessage>("subscriptionId", requestMessage =>
{
var responseMessage = new TestResponseMessage
{
Text = requestMessage.Text
};
using (var publishChannel = bus.OpenPublishChannel())
{
publishChannel.Publish(responseMessage);
}
});
}
public void Initialize(IBus bus)
{
bus.SubscribeAsync<TestRequestMessage>("id", requestMessage =>
{
var responseMessage = new TestResponseMessage
{
Text = requestMessage.Text
};
return Task.Factory.StartNew(() =>
{
using (var publishChannel = bus.OpenPublishChannel())
{
publishChannel.Publish(responseMessage);
}
});
});
}
/// <summary>
/// Helper method to create a test message from its content.
/// </summary>
/// <param name="messageContent">Stream with the content of the message.</param>
/// <param name="testConfiguration">The test configuration.</param>
/// <param name="payloadKind">The payload kind to use to compute and set the content type header; or null if no content type header should be set.</param>
/// <param name="customContentTypeHeader">A custom content type header to be used in the message.</param>
/// <param name="urlResolver">Url resolver to add to the test message created.</param>
/// <returns>Newly created test message.</returns>
public static TestMessage CreateInputMessageFromStream(
TestStream messageContent,
ReaderTestConfiguration testConfiguration,
ODataPayloadKind?payloadKind,
string customContentTypeHeader,
IODataUrlResolver urlResolver)
{
TestMessage message;
if (testConfiguration.IsRequest)
{
if (urlResolver != null)
{
message = new TestRequestMessageWithUrlResolver(messageContent, urlResolver, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
}
else
{
message = new TestRequestMessage(messageContent, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
}
}
else
{
if (urlResolver != null)
{
message = new TestResponseMessageWithUrlResolver(messageContent, urlResolver, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
}
else
{
message = new TestResponseMessage(messageContent, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
}
}
// set the OData-Version header
message.SetHeader(ODataConstants.ODataVersionHeader, testConfiguration.Version.ToText());
if (customContentTypeHeader != null)
{
message.SetHeader(ODataConstants.ContentTypeHeader, customContentTypeHeader);
}
else if (payloadKind.HasValue)
{
message.SetContentType(testConfiguration.Format, payloadKind.Value);
}
return(message);
}
public void Initialize(IBus bus)
{
bus.SubscribeAsync <TestRequestMessage>("id", requestMessage =>
{
var responseMessage = new TestResponseMessage
{
Text = requestMessage.Text
};
return(Task.Factory.StartNew(() =>
{
using (var publishChannel = bus.OpenPublishChannel())
{
publishChannel.Publish(responseMessage);
}
}));
});
}
/// <summary>
/// Creates an <see cref="ODataMessageReader"/> from the specified <paramref name="memoryStream"/>.
/// </summary>
/// <param name="memoryStream">The <see cref="MemoryStream"/> used as input for the message reader.</param>
/// <returns>An <see cref="ODataMessageReader"/> instance.</returns>
private ODataMessageReader CreateMessageReader(MemoryStream memoryStream)
{
// Create a test message around the memory stream, set the content-type header and then create
// the message reader
if (this.IsResponse)
{
TestResponseMessage responseMessage = new TestResponseMessage(memoryStream, TestMessageFlags.NoAsynchronous);
responseMessage.SetHeader(ODataConstants.ContentTypeHeader, "multipart/mixed; boundary=" + this.BatchBoundary);
return(new ODataMessageReader(responseMessage));
}
else
{
TestRequestMessage requestMessage = new TestRequestMessage(memoryStream, TestMessageFlags.NoAsynchronous);
requestMessage.SetHeader(ODataConstants.ContentTypeHeader, "multipart/mixed; boundary=" + this.BatchBoundary);
return(new ODataMessageReader(requestMessage));
}
}
/// <summary>
/// Traces interesting information if on test failure.
/// </summary>
/// <param name="testConfiguration">The test configuration to use.</param>
protected void TraceFailureInformation(ReaderTestConfiguration testConfiguration)
{
try
{
Trace.WriteLine("----- HTTP Message start ------------------------------------------");
// Create the input message again so that we can read it.
TestMessage message = this.CreateInputMessage(testConfiguration);
TestRequestMessage requestMessage = message as TestRequestMessage;
if (requestMessage != null)
{
Trace.WriteLine(requestMessage.Method.ToString() + " " + requestMessage.Url + " HTTP/1.1");
}
TestResponseMessage responseMessage = message as TestResponseMessage;
if (responseMessage != null)
{
Trace.WriteLine(responseMessage.StatusCode.ToString());
}
foreach (var header in message.Headers)
{
Trace.WriteLine(header.Key + ": " + header.Value);
}
Trace.WriteLine("");
Trace.WriteLine(this.DumpInputMessageContent(testConfiguration));
Trace.WriteLine("----- HTTP Message end --------------------------------------------");
string additionalDescription = this.DumpAdditionalTestDescriptions(testConfiguration);
if (!string.IsNullOrEmpty(additionalDescription))
{
Trace.WriteLine("");
Trace.WriteLine("----- Additional test description ---------------------------------");
Trace.WriteLine(additionalDescription);
}
}
catch (Exception innerException)
{
// Ignore all exceptions here since we want to fail with the original test exception.
Trace.WriteLine("Failed to dump the test message.");
Trace.WriteLine(innerException);
}
}
public void Should_request_closures_work()
{
var countdownEvent = new CountdownEvent(3);
bus.Respond <TestRequestMessage, TestResponseMessage>(request =>
{
var response = new TestResponseMessage
{
Text = request.Text + "--" + request.Text
};
return(response);
});
var results = new string[3];
using (var channel = bus.OpenPublishChannel())
{
var requestTexts = new[] { "one", "two", "three" };
for (int i = 0; i < 3; i++)
{
var request = new TestRequestMessage {
Text = requestTexts[i]
};
var index = i;
channel.Request <TestRequestMessage, TestResponseMessage>(
request,
response =>
{
results[index] = response.Text;
Console.WriteLine("Got response '{0}' on index: {1}", response.Text, index);
countdownEvent.Signal();
});
}
}
// give the bus a chance to deliver the message
countdownEvent.Wait(1000);
results[0].ShouldEqual("one--one");
results[1].ShouldEqual("two--two");
results[2].ShouldEqual("three--three");
}
/// <summary>
/// Helper method to create <see cref="ODataMessageReader"/> instance.
/// </summary>
/// <param name="message">The test message to use.</param>
/// <param name="model">The model to use.</param>
/// <param name="testConfiguration">The test configuration.</param>
/// <returns>The test wrapper for the newly created message reader.</returns>
public static ODataMessageReaderTestWrapper CreateMessageReader(
TestMessage message,
IEdmModel model,
ReaderTestConfiguration testConfiguration)
{
ODataMessageReader messageReader;
if (testConfiguration.IsRequest)
{
TestRequestMessage requestMessage = (TestRequestMessage)message;
messageReader = new ODataMessageReader(requestMessage, testConfiguration.MessageReaderSettings, model);
}
else
{
TestResponseMessage responseMessage = (TestResponseMessage)message;
messageReader = new ODataMessageReader(responseMessage, testConfiguration.MessageReaderSettings, model);
}
return(new ODataMessageReaderTestWrapper(messageReader, testConfiguration.MessageReaderSettings, testConfiguration, message));
}
public void TestResponseXml()
{
var response = new TestResponseMessage()
{
ADateTime = DateTime.UtcNow,
AnEnum = ResponseEnumValues.Two,
ANumber = 42,
Success = true,
Message = "This is a test message"
};
var serializer = new DataContractSerializer(typeof(TestResponseMessage));
var stream = new MemoryStream();
serializer.WriteObject(stream, response);
stream.Seek(0, SeekOrigin.Begin);
var reader = new StreamReader(stream);
var result = reader.ReadToEnd();
Trace.WriteLine($"response message xml:\n{result}");
}
public void Should_request_closures_work()
{
var countdownEvent = new CountdownEvent(3);
bus.Respond<TestRequestMessage, TestResponseMessage>(request =>
{
var response = new TestResponseMessage
{
Text = request.Text + "--" + request.Text
};
return response;
});
var results = new string[3];
using (var channel = bus.OpenPublishChannel())
{
var requestTexts = new[] {"one", "two", "three"};
for (int i = 0; i < 3; i++)
{
var request = new TestRequestMessage { Text = requestTexts[i] };
var index = i;
channel.Request<TestRequestMessage, TestResponseMessage>(
request,
response =>
{
results[index] = response.Text;
Console.WriteLine("Got response '{0}' on index: {1}", response.Text, index);
countdownEvent.Signal();
});
}
}
// give the bus a chance to deliver the message
countdownEvent.Wait();
results[0].ShouldEqual("one--one");
results[1].ShouldEqual("two--two");
results[2].ShouldEqual("three--three");
}
public When_a_request_is_sent()
{
mockBuilder = new MockBuilder();
requestMessage = new TestRequestMessage();
responseMessage = new TestResponseMessage();
var correlationId = "";
mockBuilder.NextModel.WhenForAnyArgs(x => x.BasicPublish(null, null, false, null, null))
.Do(invocation =>
{
var properties = (IBasicProperties)invocation[3];
correlationId = properties.CorrelationId;
});
var task = mockBuilder.Bus.RequestAsync <TestRequestMessage, TestResponseMessage>(requestMessage);
DeliverMessage(correlationId);
task.Wait();
responseMessage = task.Result;
}
public void MessageReaderConstructorArgumentValidationTest()
{
TestRequestMessage requestMessage = new TestRequestMessage(new MemoryStream());
TestResponseMessage responseMessage = new TestResponseMessage(new MemoryStream());
this.CombinatorialEngineProvider.RunCombinations(
settingsActionTestCases,
(settingsAction) =>
{
TestMessage message = settingsAction.Response
? (TestMessage)responseMessage
: (TestMessage)requestMessage;
// Verify that relative BaseUri will fail
this.Assert.ExpectedException(
() => settingsAction.Action(message, new ODataMessageReaderSettings {
BaseUri = new Uri("foo", UriKind.Relative)
}),
ODataExpectedExceptions.ODataException("ReaderValidationUtils_MessageReaderSettingsBaseUriMustBeNullOrAbsolute", "foo/"),
this.ExceptionVerifier);
var settings = new ODataMessageReaderSettings();
settings.Validations |= ValidationKinds.ThrowOnUndeclaredPropertyForNonOpenType;
this.Assert.ExpectedException(
() => settingsAction.Action(message, settings),
null,
this.ExceptionVerifier);
settings.Validations &= ~ValidationKinds.ThrowOnUndeclaredPropertyForNonOpenType;
this.Assert.ExpectedException(
() => settingsAction.Action(message, settings),
settingsAction.Response ? null : ODataExpectedExceptions.ODataException("ReaderValidationUtils_UndeclaredPropertyBehaviorKindSpecifiedOnRequest"),
this.ExceptionVerifier);
});
}
static void ResponseHandler(TestResponseMessage response)
{
Console.WriteLine("Response: {0}", response.Text);
latencyRecorder.RegisterResponse(response.Id);
}
static void ResponseHandler(TestResponseMessage response)
{
latencyRecorder.RegisterResponse(response.Id);
}
static void ResponseHandler(TestResponseMessage response)
{
Console.WriteLine("Got Response: '{0}'", response.Text);
}
static void ResponseHandler(TestResponseMessage response)
{
Console.WriteLine("Response: {0}", response.Text);
latencyRecorder.RegisterResponse(response.Id);
}
private ODataMessageWriter CreateMessageWriter(bool useModel)
{
var responseMessage = new TestResponseMessage(this.stream);
var writerSettings = new ODataMessageWriterSettings { DisableMessageStreamDisposal = true };
writerSettings.SetServiceDocumentUri(new Uri("http://host/service"));
var model = useModel ? this.GetModel() : null;
return new ODataMessageWriter(responseMessage, writerSettings, model);
}
static void ResponseHandler(TestResponseMessage response)
{
latencyRecorder.RegisterResponse(response.Id);
}
