public void Should_ignore_a_response_that_was_not_for_us() { var pongReceived = new FutureMessage <PongMessage>(); var pingReceived = new FutureMessage <PingMessage>(); var badResponse = new FutureMessage <PongMessage>(); LocalBus.SubscribeHandler <PongMessage>(pongReceived.Set); RemoteBus.SubscribeContextHandler <PingMessage>(x => { pingReceived.Set(x.Message); RemoteBus.Publish(new PongMessage { TransactionId = x.Message.TransactionId }); }); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); var ping = new PingMessage(); TimeSpan timeout = 8.Seconds(); Assert.Throws <RequestTimeoutException>(() => { RemoteBus.Endpoint.SendRequest(ping, LocalBus, x => { x.Handle <PongMessage>(badResponse.Set); x.SetTimeout(timeout); }); }); pingReceived.IsAvailable(timeout).ShouldBeTrue("The ping was not received"); pongReceived.IsAvailable(timeout).ShouldBeTrue("The pong was not received"); badResponse.IsAvailable(2.Seconds()).ShouldBeFalse("Should not have received a response"); }
public void Should_call_timeout_callback_if_timeout_occurs() { var pongCompleted = new FutureMessage <PongMessage>(); var pongCancelled = new FutureMessage <bool>(); Task <PongMessage> pongTask; var ping = new PingMessage(); ITaskRequest <PingMessage> request = LocalBus.PublishRequestAsync(ping, x => { x.SetTimeout(1.Seconds()); pongTask = x.Handle <PongMessage>(message => { }); pongTask.ContinueWith(t => pongCompleted.Set(t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); pongTask.ContinueWith((Task t) => pongCancelled.Set(t.IsCanceled), TaskContinuationOptions.OnlyOnCanceled); }); var aggregateException = Assert.Throws <AggregateException>(() => request.Task.Wait(8.Seconds())); Assert.IsInstanceOf <RequestTimeoutException>(aggregateException.InnerExceptions.First()); pongCompleted.IsAvailable(1.Seconds()).ShouldBeFalse("We only asked to be notified on success"); pongCancelled.IsAvailable(1.Seconds()).ShouldBeTrue("We like to know we were cancelled due to timeout"); }
public void A_response_should_be_sent_directly_if_a_reply_address_is_specified() { var ping = new PingMessage(); var otherConsumer = new TestMessageConsumer <PongMessage>(); RemoteBus.SubscribeInstance(otherConsumer); var consumer = new TestCorrelatedConsumer <PongMessage, Guid>(ping.CorrelationId); LocalBus.SubscribeInstance(consumer); var pong = new FutureMessage <PongMessage>(); RemoteBus.SubscribeHandler <PingMessage>(message => { pong.Set(new PongMessage(message.CorrelationId)); RemoteBus.Context().Respond(pong.Message); }); RemoteBus.ShouldHaveRemoteSubscriptionFor <PongMessage>(); LocalBus.ShouldHaveRemoteSubscriptionFor <PongMessage>(); LocalBus.ShouldHaveRemoteSubscriptionFor <PingMessage>(); LocalBus.Publish(ping, context => context.SendResponseTo(LocalBus)); Assert.IsTrue(pong.IsAvailable(8.Seconds()), "No pong generated"); consumer.ShouldHaveReceivedMessage(pong.Message, 8.Seconds()); otherConsumer.ShouldNotHaveReceivedMessage(pong.Message, 1.Seconds()); }
public void A_response_should_be_published_if_no_reply_address_is_specified() { PingMessage ping = new PingMessage(); TestMessageConsumer <PongMessage> otherConsumer = new TestMessageConsumer <PongMessage>(); RemoteBus.Subscribe(otherConsumer); TestCorrelatedConsumer <PongMessage, Guid> consumer = new TestCorrelatedConsumer <PongMessage, Guid>(ping.CorrelationId); LocalBus.Subscribe(consumer); FutureMessage <PongMessage> pong = new FutureMessage <PongMessage>(); RemoteBus.Subscribe <PingMessage>(message => { pong.Set(new PongMessage(message.CorrelationId)); CurrentMessage.Respond(pong.Message); }); LocalBus.Publish(ping); Assert.IsTrue(pong.IsAvailable(3.Seconds()), "No pong generated"); consumer.ShouldHaveReceivedMessage(pong.Message, 3.Seconds()); otherConsumer.ShouldHaveReceivedMessage(pong.Message, 1.Seconds()); }
public void Should_throw_an_exception_if_a_fault_was_published() { var pongReceived = new FutureMessage <PongMessage>(); var faultReceived = new FutureMessage <Fault <PingMessage> >(); var pingReceived = new FutureMessage <PingMessage>(); RemoteBus.SubscribeContextHandler <PingMessage>(x => { pingReceived.Set(x.Message); throw new InvalidOperationException("This should carry over to the calling request"); }); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); var ping = new PingMessage(); TimeSpan timeout = Debugger.IsAttached ? 5.Minutes() : 24.Seconds(); LocalBus.PublishRequest(ping, x => { x.Handle <PongMessage>(pongReceived.Set); x.HandleFault(faultReceived.Set); x.SetTimeout(timeout); }); pingReceived.IsAvailable(timeout).ShouldBeTrue("The ping was not received"); faultReceived.IsAvailable(timeout).ShouldBeTrue("The fault was not received"); pongReceived.IsAvailable(1.Seconds()).ShouldBeFalse("The pong was not received"); }
public void Should_use_a_clean_syntax_following_standard_conventions() { var pongReceived = new FutureMessage <PongMessage>(); var pingReceived = new FutureMessage <PingMessage>(); RemoteBus.SubscribeContextHandler <PingMessage>(x => { pingReceived.Set(x.Message); x.Respond(new PongMessage { TransactionId = x.Message.TransactionId }); }); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); var ping = new PingMessage(); TimeSpan timeout = 8.Seconds(); LocalBus.PublishRequest(ping, x => { x.Handle <PongMessage>(message => { message.TransactionId.ShouldEqual(ping.TransactionId, "The response correlationId did not match"); pongReceived.Set(message); }); x.SetTimeout(timeout); }); pingReceived.IsAvailable(timeout).ShouldBeTrue("The ping was not received"); pongReceived.IsAvailable(timeout).ShouldBeTrue("The pong was not received"); }
public void The_retry_count_should_be_set_on_the_message() { var future = new FutureMessage <PingMessage>(); bool first = true; LocalBus.SubscribeHandler <PingMessage>(message => { if (first) { Assert.AreEqual(0, LocalBus.Context().RetryCount); LocalBus.MessageContext <PingMessage>().RetryLater(); first = false; } else { Assert.AreEqual(1, LocalBus.Context().RetryCount); future.Set(message); } }); LocalBus.ShouldHaveRemoteSubscriptionFor <PingMessage>(); LocalBus.Publish(new PingMessage()); Assert.IsTrue(future.IsAvailable(20.Seconds())); }
public void The_retry_count_should_be_set_on_the_message() { FutureMessage <PingMessage> future = new FutureMessage <PingMessage>(); bool first = true; LocalBus.Subscribe <PingMessage>(message => { if (first) { Assert.AreEqual(0, CurrentMessage.Headers.RetryCount); CurrentMessage.RetryLater(); first = false; } else { Assert.AreEqual(1, CurrentMessage.Headers.RetryCount); future.Set(message); } }); LocalBus.Publish(new PingMessage()); Assert.IsTrue(future.IsAvailable(5.Seconds())); }
public void Should_support_send_as_well() { var pongReceived = new FutureMessage <PongMessage>(); var pingReceived = new FutureMessage <PingMessage>(); RemoteBus.SubscribeContextHandler <PingMessage>(x => { pingReceived.Set(x.Message); x.Respond(new PongMessage { TransactionId = x.Message.TransactionId }); }); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); var ping = new PingMessage(); TimeSpan timeout = 8.Seconds(); RemoteBus.Endpoint.SendRequest(ping, LocalBus, x => { x.Handle <PongMessage>(message => { message.TransactionId.ShouldEqual(ping.TransactionId, "The response correlationId did not match"); pongReceived.Set(message); }); x.SetTimeout(timeout); }); pingReceived.IsAvailable(timeout).ShouldBeTrue("The ping was not received"); pongReceived.IsAvailable(timeout).ShouldBeTrue("The pong was not received"); }
protected override void ConfigureLocalBus(ServiceBusConfigurator configurator) { base.ConfigureLocalBus(configurator); _received = new FutureMessage <IProxyMe>(); configurator.Subscribe(x => { x.Handler <IProxyMe>((message) => _received.Set(message)); }); }
public void Consume(IConsumeContext <SecureCommand> context) { IConsumeContext <UserCredentials> credentials; if (context.TryGetContext(out credentials)) { CredentialsReceived.Set(credentials.Message); } }
public void Subscring_to_an_endpoint_should_accept_and_dispatch_messages() { FutureMessage <PingMessage> fm = new FutureMessage <PingMessage>(); bool workDid = false; LocalBus.Subscribe <PingMessage>( (msg) => { workDid = true; fm.Set(msg); }, delegate { return(true); }); RemoteBus.Publish(_message); fm.IsAvailable(1.Seconds()); Assert.That(workDid, Is.True, "Lazy Test!"); }
public void The_destination_address_should_pass() { var received = new FutureMessage <PingMessage>(); LocalBus.SubscribeHandler <PingMessage>(message => { Assert.AreEqual(LocalBus.Endpoint.Address.Uri, LocalBus.Context().DestinationAddress); received.Set(message); }); LocalBus.Publish(new PingMessage()); Assert.IsTrue(received.IsAvailable(5.Seconds()), "No message was received"); }
public void The_source_address_should_pass() { FutureMessage <PingMessage> received = new FutureMessage <PingMessage>(); LocalBus.Subscribe <PingMessage>(message => { Assert.AreEqual(LocalBus.Endpoint.Uri, CurrentMessage.Headers.SourceAddress); received.Set(message); }); LocalBus.Publish(new PingMessage()); Assert.IsTrue(received.IsAvailable(5.Seconds()), "No message was received"); }
public void Should_request_an_instance_of_the_consumer_for_each_message() { var called = new FutureMessage <PingMessage>(); var ping = new PingMessage(); var getter = MockRepository.GenerateMock <HandlerSelector <PingMessage> >(); getter.Expect(x => x(null)).IgnoreArguments().Return(x => called.Set(x.Message)); LocalBus.SubscribeHandlerSelector(getter); LocalBus.Publish(ping); called.IsAvailable(3.Seconds()).ShouldBeTrue(); }
public void A_random_header_should_pass() { Guid id = Guid.NewGuid(); var received = new FutureMessage <PingMessage>(); LocalBus.SubscribeHandler <PingMessage>(message => { Assert.AreEqual(id.ToString(), LocalBus.Context().Headers["RequestId"]); received.Set(message); }); LocalBus.Publish(new PingMessage(), context => context.SetHeader("RequestId", id.ToString())); Assert.IsTrue(received.IsAvailable(5.Seconds()), "No message was received"); }
public void The_correlation_id_should_pass() { Guid id = Guid.NewGuid(); var received = new FutureMessage <PingMessage>(); LocalBus.SubscribeHandler <PingMessage>(message => { Assert.AreEqual(id.ToString(), LocalBus.Context().CorrelationId); received.Set(message); }); LocalBus.Publish(new PingMessage(), context => context.SetCorrelationId(id.ToString())); Assert.IsTrue(received.IsAvailable(5.Seconds()), "No message was received"); }
public void Should_throw_a_handler_exception_on_the_calling_thread_using_async() { var pongReceived = new FutureMessage <PongMessage>(); var pingReceived = new FutureMessage <PingMessage>(); var callbackCalled = new FutureMessage <IAsyncResult>(); RemoteBus.SubscribeContextHandler <PingMessage>(x => { pingReceived.Set(x.Message); x.Respond(new PongMessage { TransactionId = x.Message.TransactionId }); }); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); var ping = new PingMessage(); TimeSpan timeout = 18.Seconds(); LocalBus.BeginPublishRequest(ping, callbackCalled.Set, null, x => { x.Handle <PongMessage>(message => { pongReceived.Set(message); throw new InvalidOperationException("I got it, but I am naughty with it."); }); x.SetTimeout(timeout); }); pingReceived.IsAvailable(timeout).ShouldBeTrue("The ping was not received"); pongReceived.IsAvailable(timeout).ShouldBeTrue("The pong was not received"); callbackCalled.IsAvailable(timeout).ShouldBeTrue("Called was not called"); var exception = Assert.Throws <RequestException>( () => { LocalBus.EndPublishRequest <PingMessage>(callbackCalled.Message); }, "A request exception should have been thrown"); exception.Response.ShouldBeAnInstanceOf <PongMessage>(); exception.InnerException.ShouldBeAnInstanceOf <InvalidOperationException>(); }
public void A_clean_method_of_a_request_reply_should_be_possible() { FutureMessage <PongMessage> ponged = new FutureMessage <PongMessage>(); LocalBus.Subscribe <PingMessage>(x => LocalBus.Publish(new PongMessage(x.CorrelationId))); PingMessage ping = new PingMessage(); LocalBus.MakeRequest(bus => bus.Publish(ping, context => context.SendResponseTo(bus))) .When <PongMessage>().RelatedTo(ping.CorrelationId).IsReceived(pong => { Assert.AreEqual(ping.CorrelationId, pong.CorrelationId); ponged.Set(pong); }) .TimeoutAfter(5.Seconds()) .Send(); Assert.IsTrue(ponged.IsAvailable(1.Seconds()), "No response received"); }
public void Any_type_of_send_should_be_supported() { RemoteBus.Subscribe <PingMessage>(x => RemoteBus.Publish(new PongMessage(x.CorrelationId))); PingMessage ping = new PingMessage(); FutureMessage <PongMessage> ponged = new FutureMessage <PongMessage>(); LocalBus.MakeRequest(bus => RemoteBus.Endpoint.Send(ping, context => context.SendResponseTo(bus))) .When <PongMessage>().RelatedTo(ping.CorrelationId).IsReceived(pong => { Assert.AreEqual(ping.CorrelationId, pong.CorrelationId); ponged.Set(pong); }) .TimeoutAfter(5.Seconds()) .Send(); Assert.IsTrue(ponged.IsAvailable(1.Seconds()), "No response received"); }
public void Should_support_the_asynchronous_programming_model() { var pongReceived = new FutureMessage <PongMessage>(); var pingReceived = new FutureMessage <PingMessage>(); var callbackCalled = new FutureMessage <IAsyncResult>(); RemoteBus.SubscribeContextHandler <PingMessage>(x => { pingReceived.Set(x.Message); x.Respond(new PongMessage { TransactionId = x.Message.TransactionId }); }); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); var ping = new PingMessage(); TimeSpan timeout = 18.Seconds(); LocalBus.BeginPublishRequest(ping, callbackCalled.Set, null, x => { x.Handle <PongMessage>(message => { message.TransactionId.ShouldEqual(ping.TransactionId, "The response correlationId did not match"); pongReceived.Set(message); }); x.SetTimeout(timeout); }); pingReceived.IsAvailable(timeout).ShouldBeTrue("The ping was not received"); pongReceived.IsAvailable(timeout).ShouldBeTrue("The pong was not received"); callbackCalled.IsAvailable(timeout).ShouldBeTrue("The callback was not called"); bool result = LocalBus.EndPublishRequest <PingMessage>(callbackCalled.Message); Assert.IsTrue(result, "EndRequest should be true"); }
public void Should_allow_publish_request_with_custom_headers() { var pongReceived = new FutureMessage <PongMessage>(); var pingReceived = new FutureMessage <PingMessage>(); RemoteBus.SubscribeContextHandler <PingMessage>(x => { pingReceived.Set(x.Message); var transactionIdFromHeader = new Guid(x.Headers["PingTransactionId"]); x.Respond(new PongMessage { TransactionId = transactionIdFromHeader }); }); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); var ping = new PingMessage { TransactionId = Guid.NewGuid() }; TimeSpan timeout = 8.Seconds(); LocalBus.PublishRequest(ping, x => { x.Handle <PongMessage>(message => { message.TransactionId.ShouldEqual(ping.TransactionId, "The response correlationId did not match"); pongReceived.Set(message); }); x.SetTimeout(timeout); }, ctx => { ctx.SetHeader("PingTransactionId", ping.TransactionId.ToString()); }); pingReceived.IsAvailable(timeout).ShouldBeTrue("The ping was not received"); pongReceived.IsAvailable(timeout).ShouldBeTrue("The pong was not received"); }
public void A_conditional_consumer_should_not_get_the_message_if_it_is_not_wanted() { FutureMessage <PongMessage> invalidPong = new FutureMessage <PongMessage>(); FutureMessage <PongMessage> validPong = new FutureMessage <PongMessage>(); LocalBus.Subscribe <PingMessage>(x => LocalBus.Publish(new PongMessage(x.CorrelationId))); LocalBus.Subscribe <PongMessage>(message => validPong.Set(message)); PingMessage ping = new PingMessage(); LocalBus.MakeRequest(bus => bus.Publish(ping, context => context.SendResponseTo(bus))) .When <PongMessage>().And(message => false).IsReceived(pong => { invalidPong.Set(pong); }) .TimeoutAfter(3.Seconds()) .Send(); Assert.IsTrue(validPong.IsAvailable(1.Seconds()), "Should have accepted message"); Assert.IsFalse(invalidPong.IsAvailable(1.Seconds()), "Should not have accepted message"); }
public void An_asynchronous_model_should_be_supported() { PingMessage ping = new PingMessage(); ManualResetEvent mre = new ManualResetEvent(false); FutureMessage <PongMessage> ponged = new FutureMessage <PongMessage>(); LocalBus.MakeRequest(bus => LocalBus.Endpoint.Send(ping, context => context.SendResponseTo(bus))) .When <PongMessage>().RelatedTo(ping.CorrelationId).IsReceived(pong => { ponged.Set(pong); }) .TimeoutAfter(5.Seconds()) .OnTimeout(() => mre.Set()) .BeginSend((state) => mre.Set(), null); LocalBus.Subscribe <PingMessage>(x => LocalBus.Publish(new PongMessage(x.CorrelationId))); Assert.IsTrue(mre.WaitOne(5.Seconds(), true)); Assert.IsTrue(ponged.IsAvailable(1.Seconds())); }
public void When_an_asynchronous_timeout_occurs_we_should_get_our_timeout_action_called() { PingMessage ping = new PingMessage(); ManualResetEvent mre = new ManualResetEvent(false); FutureMessage <PongMessage> ponged = new FutureMessage <PongMessage>(); LocalBus.MakeRequest(bus => LocalBus.Endpoint.Send(ping, context => context.SendResponseTo(bus))) .When <PongMessage>().RelatedTo(ping.CorrelationId).IsReceived(pong => { ponged.Set(pong); }) .OnTimeout(() => { mre.Set(); }) .TimeoutAfter(2.Seconds()) .BeginSend((state) => { }, null); Assert.IsTrue(mre.WaitOne(10.Seconds(), true)); Assert.IsFalse(ponged.IsAvailable(0.Seconds())); }
public void Should_do_something_nicely() { var ding = new PingMessage(); var future = new FutureMessage <PingMessage>(); var bus = MockRepository.GenerateMock <IServiceBus>(); bus.Stub(x => x.Publish <PingMessage>(null)).Callback <PingMessage>(message => { if (message != ding) { Assert.Fail("Bugger me"); } future.Set(message); return(true); }); bus.Publish(ding); future.IsAvailable(TimeSpan.Zero).ShouldBeTrue(); }
public void Should_call_the_timeout_handler_and_not_throw_an_exception() { var pongReceived = new FutureMessage <PongMessage>(); var pingReceived = new FutureMessage <PingMessage>(); var timeoutCalled = new FutureMessage <bool>(); RemoteBus.SubscribeHandler <PingMessage>(pingReceived.Set); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); var ping = new PingMessage(); TimeSpan timeout = 2.Seconds(); LocalBus.PublishRequest(ping, x => { x.Handle <PongMessage>(pongReceived.Set); x.HandleTimeout(timeout, () => timeoutCalled.Set(true)); }); pingReceived.IsAvailable(timeout).ShouldBeTrue("The ping was not received"); pongReceived.IsAvailable(timeout).ShouldBeFalse("The pong should not have been received"); timeoutCalled.IsAvailable(timeout).ShouldBeTrue("The timeout handler was not called"); }
public void Consume(Fault <Hello, Guid> message) { _fault.Set(message); }
public void Consume(IConsumeContext <A> message) { Called.Set(message.Message); }
public void Consume(PingMessage message) { _pinged++; _fm.Set(message); }