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 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 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); }
/// <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); }