public void RequestMessagePipelineShouldFireHandlers()
{
var preRequestHandledCount = 0;
var postRequestHandledCount = 0;
var handled = false;
var message = new TestRequestMessage
{
PreRequestAction = () =>
{
preRequestHandledCount++;
},
HandlerAction = () =>
{
handled = true;
},
PostRequestAction = () =>
{
postRequestHandledCount++;
}
};
_dispatcher.Handle(message);
preRequestHandledCount.ShouldBe(3);
postRequestHandledCount.ShouldBe(3);
handled.ShouldBe(true);
}
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 Initialize(IBus bus)
{
bus.Subscribe <StartMessage>("simpleSaga", startMessage =>
{
Console.WriteLine("StartMessage: {0}", startMessage.Text);
var firstProcessedMessage = startMessage.Text + " - initial process ";
var request = new TestRequestMessage {
Text = firstProcessedMessage
};
using (var publishChannel = bus.OpenPublishChannel())
{
publishChannel.Request <TestRequestMessage, TestResponseMessage>(request, response =>
{
Console.WriteLine("TestResponseMessage: {0}", response.Text);
var secondProcessedMessage = response.Text + " - final process ";
var endMessage = new EndMessage {
Text = secondProcessedMessage
};
using (var publishChannel2 = bus.OpenPublishChannel())
{
publishChannel2.Publish(endMessage);
}
});
}
});
}
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;
}
public void RequestMessagePipelineShouldFireHandlers()
{
var preRequestHandledCount = 0;
var postRequestHandledCount = 0;
var handled = false;
var message = new TestRequestMessage
{
PreRequestAction = () =>
{
preRequestHandledCount++;
},
HandlerAction = () =>
{
handled = true;
},
PostRequestAction = () =>
{
postRequestHandledCount++;
}
};
_dispatcher.Handle(message);
preRequestHandledCount.ShouldBe(3);
postRequestHandledCount.ShouldBe(3);
handled.ShouldBe(true);
}
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 async Task <object> TestMethod2(long numberParameter1, [FromBody] TestRequestMessage testRequest, string scenario, bool booleanParameter2 = false, string textParameter3 = null)
{
var response = _mockEngine.Invoke(scenario,
new
{
numberParameter1 = numberParameter1,
testRequest = testRequest,
scenario = scenario,
booleanParameter2 = booleanParameter2,
textParameter3 = textParameter3
});
if (response.Content != null)
{
return(response.Content);
}
else
{
var httpResponseMessage = new HttpResponseMessage(response.StatusCode)
{
ReasonPhrase = response.ReasonPhrase
};
throw new HttpResponseException(httpResponseMessage);
}
}
[Test] // todo: sometimes fails so fix this
public void Register_request_message_in_current_scope()
{
// Create container with AsyncExecutionFlowScopeContext which works across async/await boundaries.
// In case of MVC it may be changed to HttpContextScopeContext.
var container = new Container(scopeContext: new AsyncExecutionFlowScopeContext());
container.Register <A>();
const int parallelRequestCount = 20;
var tasks = new Task[parallelRequestCount];
for (var i = 0; i < parallelRequestCount; i++)
{
tasks[i] = Task.Run(async() =>
{
var message = new TestRequestMessage();
using (var scope = container.OpenScope())
{
// It will replace request instance inside current scope, keep all resolution cache, etc intact. It is fast.
//scope.RegisterInstance(message, Reuse.InCurrentScope, IfAlreadyRegistered.Replace);
scope.UseInstance(message);
var a = scope.Resolve <A>();
Assert.AreSame(message, a.Message);
await Task.Delay(5);//processing request
Assert.IsNotNull(a.Message);
Assert.AreSame(a.Message, scope.Resolve <A>().Message);
}
});
}
Task.WaitAll(tasks);
}
/// <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_simple_request_response_lots()
{
const int numberOfCalls = 1000;
var countdownEvent = new CountdownEvent(numberOfCalls);
var count = 0;
for (int i = 0; i < numberOfCalls; i++)
{
var request = new TestRequestMessage {
Text = "Hello from the client! " + i.ToString()
};
using (var publishChannel = bus.OpenPublishChannel())
{
publishChannel.Request <TestRequestMessage, TestResponseMessage>(request, response =>
{
Console.WriteLine("Got response: '{0}'", response.Text);
count++;
countdownEvent.Signal();
});
}
}
countdownEvent.Wait(15000);
count.ShouldEqual(numberOfCalls);
}
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);
}
private static TestResponseMessage SenRequest(TestRequestMessage request)
{
Console.WriteLine($"接收到的请求消息：{request.Text}");
return(new TestResponseMessage {
Text = $"Reply - {request.Text}"
});
}
public async Task Send_1000_MessageResponses()
{
var timer = Stopwatch.StartNew();
var responseList = new List <Task <TestResponseMessage> >();
for (var i = 0; i < 1000; i++)
{
var request = new TestRequestMessage {
Value = 2,
};
responseList.Add(client.Send(request)
.GetResponseAsync <TestResponseMessage>());
}
await Task.WhenAll(responseList);
foreach (var responseTask in responseList)
{
Assert.That(responseTask.Result.Value, Is.EqualTo(4));
}
timer.Stop();
var count = responseList.Count;
await TestContext.Out.WriteLineAsync($"Sent {count:N0} request/response messages in {timer.Elapsed}.");
}
public void TestMatchingFirstAction()
{
var requestMessage = new TestRequestMessage();
var response = SendTestMessageAndReadAsync("/api/MockTest/TestMethod1", 1, requestMessage, "test1", false, "My text parameter3");
response.Wait();
Trace.WriteLine($"response message:\n{response.Result.ToYamlString()}");
}
public void TestMatchingThirdAction()
{
var requestMessage = new TestRequestMessage();
var response = SendTestMessageAsync("/api/mocktest/testMethod1", 3, requestMessage, "test1", true, "My text parameter3");
response.Wait();
Assert.AreEqual(HttpStatusCode.InternalServerError, response.Result.StatusCode, "Should have returned an internal server error");
}
public void TestDynamicResponse()
{
var mockTestControler = new MockTestController();
var requestMessage = new TestRequestMessage();
var response = mockTestControler.TestMethod2(5, requestMessage, "test1", true, "My text parameter3");
response.Wait();
Trace.WriteLine($"response message:\n{response.Result.ToYamlString()}");
}
public void Should_be_able_to_do_simple_request_response()
{
var request = new TestRequestMessage {Text = "Hello from the client! "};
Console.WriteLine("Making request");
var response = bus.Request<TestRequestMessage, TestResponseMessage>(request);
Console.WriteLine("Got response: '{0}'", response.Text);
}
public void ShouldBeAbleToHandleVoidRequest()
{
var message = new TestRequestMessage {
Data = "before"
};
_dispatcher.Handle(message);
message.Data.ShouldBe("handled");
}
public void TestMatchingFirstAction()
{
var mockTestControler = new MockTestController();
var requestMessage = new TestRequestMessage();
var response = mockTestControler.TestMethod1(1, requestMessage, "test1", false, "My text parameter3");
response.Wait();
Trace.WriteLine($"response message:\n{response.Result.ToYamlString()}");
}
public async Task SendMessageResponse()
{
var request = new TestRequestMessage {
Value = 2,
};
var response = await client.Send(request)
.GetResponseAsync <TestResponseMessage>();
Assert.That(response.Value, Is.EqualTo(4));
}
public void Can_call_publish_inside_a_subscribe_handler()
{
var bus = RabbitHutch.CreateBus("host=localhost");
// setup the Saga
Console.WriteLine("Setting up the Saga");
bus.Subscribe <StartMessage>("simpleSaga", startMessage =>
{
Console.WriteLine("Saga got StartMessage: {0}", startMessage.Text);
var firstProcessedMessage = startMessage.Text + " - initial process ";
var request = new TestRequestMessage {
Text = firstProcessedMessage
};
bus.Request <TestRequestMessage, TestResponseMessage>(request, response =>
{
Console.WriteLine("Saga got Response: {0}", response.Text);
var secondProcessedMessage = response.Text + " - final process ";
var endMessage = new EndMessage {
Text = secondProcessedMessage
};
bus.Publish(endMessage);
});
});
// setup the RPC endpoint
Console.WriteLine("Setting up the RPC endpoint");
bus.Respond <TestRequestMessage, TestResponseMessage>(request =>
{
Console.WriteLine("RPC got Request: {0}", request.Text);
return(new TestResponseMessage {
Text = request.Text + " Responded! "
});
});
// setup the final subscription
Console.WriteLine("Setting up the final subscription");
var autoResetEvent = new AutoResetEvent(false);
bus.Subscribe <EndMessage>("inline_saga_spike", endMessage =>
{
Console.WriteLine("Test got EndMessage: {0}", endMessage.Text);
autoResetEvent.Set();
});
// now kick it off
Console.WriteLine("Test is publishing StartMessage");
bus.Publish(new StartMessage {
Text = "Hello Saga!! "
});
// give the message time to run through the process
autoResetEvent.WaitOne(1000);
}
public void Should_be_able_to_do_simple_request_response()
{
var request = new TestRequestMessage {
Text = "Hello from the client! "
};
Console.WriteLine("Making request");
var response = bus.Request <TestRequestMessage, TestResponseMessage>(request);
Console.WriteLine("Got response: '{0}'", response.Text);
}
public void TestRequestYaml()
{
var request = new TestRequestMessage()
{
ANumber = 42,
AString = "This is a test string",
AList = new List <string>(new string[] { "One", "Two", "Three" })
};
Trace.WriteLine($"request message yaml:\n{request.ToYamlString()}");
}
public void Can_call_publish_inside_a_subscribe_handler()
{
var bus = RabbitHutch.CreateBus("host=localhost");
// setup the Saga
Console.WriteLine("Setting up the Saga");
bus.Subscribe<StartMessage>("simpleSaga", startMessage =>
{
Console.WriteLine("Saga got StartMessage: {0}", startMessage.Text);
var firstProcessedMessage = startMessage.Text + " - initial process ";
var request = new TestRequestMessage { Text = firstProcessedMessage };
using (var publishChannel = bus.OpenPublishChannel())
{
publishChannel.Request<TestRequestMessage, TestResponseMessage>(request, response =>
{
Console.WriteLine("Saga got Response: {0}", response.Text);
var secondProcessedMessage = response.Text + " - final process ";
var endMessage = new EndMessage {Text = secondProcessedMessage};
using (var publishChannel2 = bus.OpenPublishChannel())
{
publishChannel2.Publish(endMessage);
}
});
}
});
// setup the RPC endpoint
Console.WriteLine("Setting up the RPC endpoint");
bus.Respond<TestRequestMessage, TestResponseMessage>(request =>
{
Console.WriteLine("RPC got Request: {0}", request.Text);
return new TestResponseMessage {Text = request.Text + " Responded! "};
});
// setup the final subscription
Console.WriteLine("Setting up the final subscription");
var autoResetEvent = new AutoResetEvent(false);
bus.Subscribe<EndMessage>("inline_saga_spike", endMessage =>
{
Console.WriteLine("Test got EndMessage: {0}", endMessage.Text);
autoResetEvent.Set();
});
// now kick it off
Console.WriteLine("Test is publishing StartMessage");
using (var publishChannel = bus.OpenPublishChannel())
{
publishChannel.Publish(new StartMessage { Text = "Hello Saga!! " });
}
// give the message time to run through the process
autoResetEvent.WaitOne(1000);
}
public When_a_request_is_sent_but_an_exception_is_thrown_by_responder()
{
correlationId = Guid.NewGuid().ToString();
mockBuilder = new MockBuilder(
c => c.Register <ICorrelationIdGenerationStrategy>(
_ => new StaticCorrelationIdGenerationStrategy(correlationId)
)
);
requestMessage = new TestRequestMessage();
}
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.Subscribe<StartMessage>("id", startMessage =>
{
var request = new TestRequestMessage {Text = startMessage.Text};
bus.Request<TestRequestMessage, TestResponseMessage>(request, response =>
{
var endMessage = new EndMessage {Text = response.Text};
bus.Publish(endMessage);
});
});
}
public void TestEngineReady()
{
var requestMessage = new TestRequestMessage();
var task = httpClient.GetAsync("/api/MockTest/EngineReady");
task.Wait();
HttpResponseMessage response = task.Result;
response.EnsureSuccessStatusCode();
Trace.WriteLine($"response message:\n{response.ToYamlString()}");
}
public void TestMessageHandlerResponse()
{
var requestMessage = new TestRequestMessage();
var response = SendTestMessageAndReadDynamicAsync("/api/mocktest/testMethod3", 5, requestMessage, "test1", false, "My text parameter3");
response.Wait();
Trace.WriteLine($"response message:\n{response.Result.ToYamlString()}");
Assert.Fail("The result is not serializing to yaml"); // TBD: need to fix this
}
public void TestDynamicResponse()
{
var requestMessage = new TestRequestMessage();
var response = SendTestMessageAndReadDynamicAsync("/api/mocktest/testMethod2", 5, requestMessage, "test1", false, "My text parameter3");
response.Wait();
dynamic result = response.Result;
Trace.WriteLine($"response message:\n{response.Result.ToYamlString()}");
Assert.AreEqual("101", result.storeNumber);
}
public When_a_request_is_sent_but_an_exception_is_thrown_by_responder()
{
mockBuilder = new MockBuilder();
requestMessage = new TestRequestMessage();
mockBuilder.NextModel.WhenForAnyArgs(x => x.BasicPublish(null, null, false, null, null))
.Do(invocation =>
{
var properties = (IBasicProperties)invocation[3];
_correlationId = properties.CorrelationId;
});
}
public void SetUp()
{
mockBuilder = new MockBuilder();
requestMessage = new TestRequestMessage();
mockBuilder.NextModel.Stub(x => x.BasicPublish(null, null, false, false, null, null))
.IgnoreArguments()
.WhenCalled(invocation =>
{
var properties = (IBasicProperties)invocation.Arguments[4];
_correlationId = properties.CorrelationId;
});
}
public void SetUp()
{
mockBuilder = new MockBuilder();
requestMessage = new TestRequestMessage();
mockBuilder.NextModel.Stub(x => x.BasicPublish(null, null, false, false, null, null))
.IgnoreArguments()
.WhenCalled(invocation =>
{
var properties = (IBasicProperties)invocation.Arguments[4];
_correlationId = properties.CorrelationId;
});
}
public void TestRequestJson()
{
var request = new TestRequestMessage()
{
ANumber = 42,
AString = "This is a test string",
AList = new List <string>(new string[] { "One", "Two", "Three" })
};
var serializer = new JsonSerializer();
var stringWriter = new StringWriter();
serializer.Serialize(stringWriter, request);
Trace.WriteLine($"request message json:\n{stringWriter.ToString()}");
}
public void Should_be_able_to_do_simple_request_response_that_throws_on_server()
{
var request = new TestRequestMessage
{
Text = "Hello from the client! ",
CausesExceptionInServer = true
};
Console.WriteLine("Making request");
bus.RequestAsync <TestRequestMessage, TestResponseMessage>(request).ContinueWith(response =>
Console.WriteLine("Got response: '{0}'", response.Result.Text));
Thread.Sleep(500);
}
public void TestMatching101Action()
{
var mockTestControler = new MockTestController();
var requestMessage = new TestRequestMessage();
try
{
var response = mockTestControler.TestMethod1(101, requestMessage, "test1", true, "My text parameter3");
response.Wait();
Trace.WriteLine($"response message:\n{response.Result.ToYamlString()}");
}
catch (System.AggregateException e)
{
throw e.InnerException;
}
}
public void Initialize(IBus bus)
{
bus.Subscribe<StartMessage>("simpleSaga", startMessage =>
{
Console.WriteLine("StartMessage: {0}", startMessage.Text);
var firstProcessedMessage = startMessage.Text + " - initial process ";
var request = new TestRequestMessage { Text = firstProcessedMessage };
bus.Request<TestRequestMessage, TestResponseMessage>(request, response =>
{
Console.WriteLine("TestResponseMessage: {0}", response.Text);
var secondProcessedMessage = response.Text + " - final process ";
var endMessage = new EndMessage { Text = secondProcessedMessage };
bus.Publish(endMessage);
});
});
}
public void Should_be_able_to_do_simple_request_response_lots()
{
const int numberOfCalls = 5000;
var countdownEvent = new CountdownEvent(numberOfCalls);
var count = 0;
for (int i = 0; i < numberOfCalls; i++)
{
var request = new TestRequestMessage { Text = "Hello from the client! " + i.ToString() };
bus.RequestAsync<TestRequestMessage, TestResponseMessage>(request).ContinueWith(response =>
{
Console.WriteLine("Got response: '{0}'", response.Result.Text);
count++;
countdownEvent.Signal();
});
}
countdownEvent.Wait(15000);
count.ShouldEqual(numberOfCalls);
}
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 static TestResponseMessage HandleRequest(TestRequestMessage request)
{
Console.WriteLine("Handling request: {0}", request.Text);
return new TestResponseMessage{ Text = request.Text + " all done!" };
}
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");
}
public void ConvertFixObjectToFixMessage_ReturnsCorrectString_ForTestRequestMessage()
{
var messageObject = new TestRequestMessage("Client", "Bank", 7, "Attempt1");
string result = new FixParser().ConvertFixObjectToFixMessage(messageObject);
string expected = "8=FIXT1.1\u00019=33\u000135=1\u000149=Client\u000156=Bank\u000134=7\u0001112=\u000110=210\u0001";
result.Should().Be(expected);
}
public void Should_be_able_to_do_simple_request_response_that_throws_on_server()
{
var request = new TestRequestMessage
{
Text = "Hello from the client! ",
CausesExceptionInServer = true
};
Console.WriteLine("Making request");
bus.RequestAsync<TestRequestMessage, TestResponseMessage>(request).ContinueWith(response =>
Console.WriteLine("Got response: '{0}'", response.Result.Text));
Thread.Sleep(500);
}
public void Should_be_able_to_do_simple_request_response()
{
var autoResetEvent = new AutoResetEvent(false);
var request = new TestRequestMessage {Text = "Hello from the client! "};
Console.WriteLine("Making request");
using (var publishChannel = bus.OpenPublishChannel())
{
publishChannel.Request<TestRequestMessage, TestResponseMessage>(request, response =>
{
Console.WriteLine("Got response: '{0}'", response.Text);
autoResetEvent.Set();
});
}
autoResetEvent.WaitOne(1000);
}
public void Should_throw_an_exception_at_consumer_on_simple_request_response_that_throws_on_server()
{
var request = new TestRequestMessage
{
Text = "Hello from the client! ",
CausesExceptionInServer = true,
ExceptionInServerMessage = "This should be the original exception message!"
};
Console.WriteLine("Making request");
try
{
bus.RequestAsync<TestRequestMessage, TestResponseMessage>(request).Wait(1000);
}
catch (AggregateException e)
{
throw e.InnerException;
}
}
public void Should_be_able_to_do_simple_request_response_lots()
{
const int numberOfCalls = 1000;
var countdownEvent = new CountdownEvent(numberOfCalls);
var count = 0;
for (int i = 0; i < numberOfCalls; i++)
{
var request = new TestRequestMessage { Text = "Hello from the client! " + i.ToString() };
using (var publishChannel = bus.OpenPublishChannel())
{
publishChannel.Request<TestRequestMessage, TestResponseMessage>(request, response =>
{
Console.WriteLine("Got response: '{0}'", response.Text);
count++;
countdownEvent.Signal();
});
}
}
countdownEvent.Wait(15000);
count.ShouldEqual(numberOfCalls);
}
public void Should_be_able_to_do_simple_request_response_that_throws_on_response_consumer()
{
var autoResetEvent = new AutoResetEvent(false);
var request = new TestRequestMessage { Text = "Hello from the client! " };
Console.WriteLine("Making request");
bus.RequestAsync<TestRequestMessage, TestResponseMessage>(request).ContinueWith(response =>
{
Console.WriteLine("Got response: '{0}'", response.Result.Text);
autoResetEvent.Set();
throw new SomeRandomException("Something very bad just happened!");
});
autoResetEvent.WaitOne(1000);
}
public void Should_be_able_to_do_simple_request_response_that_takes_a_long_time()
{
var autoResetEvent = new AutoResetEvent(false);
var request = new TestRequestMessage
{
Text = "Hello from the client! ",
CausesServerToTakeALongTimeToRespond = true
};
Console.WriteLine("Making request");
bus.RequestAsync<TestRequestMessage, TestResponseMessage>(request).ContinueWith(response =>
{
Console.WriteLine("Got response: '{0}'", response.Result.Text);
autoResetEvent.Set();
});
autoResetEvent.WaitOne(10000);
}
public void ShouldBeAbleToHandleVoidRequest()
{
var message = new TestRequestMessage { Data = "before" };
_dispatcher.Handle(message);
message.Data.ShouldBe("handled");
}
/// <summary>
/// The main processing state: the client is successfully logged on
/// and we process its requests until Logout.
/// </summary>
public void LoggedOn()
{
// Messages from client
Receive<HeartbeatMessage>(message =>
{
_lastHeartbeatArrivalTime = DateTime.UtcNow; //TODO: The server could timestamp messages as they arrive to avoid checking the time here?
_inboundSequenceNumber = message.MessageSequenceNumber;
});
Receive<LogoutMessage>(message =>
{
_log.Debug("Received Logout message from client.");
_inboundSequenceNumber = message.MessageSequenceNumber;
_fixInterpreterActor.Tell(new LogoutMessage(_serverCompID, _clientCompID, _outboundSequenceNumber++));
BecomeShutDown();
});
Receive<QuoteRequestMessage>(message =>
{
if (_instrumentOfferRates != null &&
_instrumentOfferRates.ContainsKey(message.Symbol))
{
_log.Debug("Responding to RFQ for " + message.Symbol);
string quoteID = "Quote" + _outboundSequenceNumber;
var quote = new QuoteMessage(_serverCompID, _clientCompID,
_outboundSequenceNumber++, message.QuoteReqID, quoteID,
message.Symbol, _instrumentOfferRates[message.Symbol]);
_fixInterpreterActor.Tell(quote);
}
else
{
_log.Error("Unable to quote client for requested instrument: " +
message.Symbol);
//TODO: Implement unable to quote message
}
});
// Exogenous system messages
Receive<Shutdown>(message =>
{
_log.Debug("Shutting down.");
_fixInterpreterActor.Tell(new LogoutMessage(_serverCompID, _clientCompID, _outboundSequenceNumber++));
BecomeWaitingForClientLogout();
});
// Internal messages
Receive<SendHeartbeat>(message =>
{
_log.Debug("Sending heartbeat message.");
var heartbeatMessage = new HeartbeatMessage(_serverCompID, _clientCompID,
_outboundSequenceNumber++);
_fixInterpreterActor.Tell(heartbeatMessage);
});
Receive<PerformAdmin>(message =>
{
// Check a heartbeat was received in the last 2 * heartbeat interval,
// otherwise assume connection is lost and shut down.
// This is the only method employed to check the connection.
if (DateTime.UtcNow - _lastHeartbeatArrivalTime > _heartbeatInterval + _heartbeatInterval)
{
_log.Debug("Heartbeat message has not been received from client.");
_log.Debug("Sending TestRequest to client.");
var testRequest = new TestRequestMessage(_serverCompID, _clientCompID,
_outboundSequenceNumber++, "1");
_fixInterpreterActor.Tell(testRequest);
// We expect to receive a heartbeat with matching TestReqID
BecomeWaitingForTestRequestResponse();
}
});
}
public void Should_be_able_to_do_simple_request_response_that_throws_on_server()
{
var request = new TestRequestMessage
{
Text = "Hello from the client! ",
CausesExceptionInServer = true
};
Console.WriteLine("Making request");
using (var publishChannel = bus.OpenPublishChannel())
{
publishChannel.Request<TestRequestMessage, TestResponseMessage>(request, response =>
Console.WriteLine("Got response: '{0}'", response.Text));
}
Thread.Sleep(500);
}
