public void Should_throw_a_timeout_exception_if_no_response_received() { var pongReceived = new FutureMessage <PongMessage>(); var pingReceived = new FutureMessage <PingMessage>(); RemoteBus.SubscribeHandler <PingMessage>(pingReceived.Set); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); var ping = new PingMessage(); TimeSpan timeout = 2.Seconds(); Assert.Throws <RequestTimeoutException>(() => { LocalBus.PublishRequest(ping, x => { x.Handle <PongMessage>(pongReceived.Set); x.SetTimeout(timeout); }); }, "A timeout exception should have been thrown"); pingReceived.IsAvailable(timeout).ShouldBeTrue("The ping was not received"); pongReceived.IsAvailable(timeout).ShouldBeFalse("The pong should not have been received"); }
public void Should_throw_a_timeout_exception_for_async_when_end_is_called() { var pongReceived = new FutureMessage <PongMessage>(); var pingReceived = new FutureMessage <PingMessage>(); var callbackCalled = new FutureMessage <IAsyncResult>(); RemoteBus.SubscribeHandler <PingMessage>(pingReceived.Set); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); var ping = new PingMessage(); TimeSpan timeout = 2.Seconds(); LocalBus.BeginPublishRequest(ping, callbackCalled.Set, null, x => { x.Handle <PongMessage>(pongReceived.Set); x.SetTimeout(timeout); }); callbackCalled.IsAvailable(8.Seconds()).ShouldBeTrue("Callback was not invoked"); Assert.Throws <RequestTimeoutException>(() => { LocalBus.EndRequest(callbackCalled.Message); }, "A timeout exception should have been thrown"); pingReceived.IsAvailable(timeout).ShouldBeTrue("The ping was not received"); pongReceived.IsAvailable(timeout).ShouldBeFalse("The pong should not have been received"); }
protected override void EstablishContext() { base.EstablishContext(); LocalBus.ShouldHaveSubscriptionFor <A>(); LocalBus.ShouldHaveSubscriptionFor <B>(); }
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_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 A_consumer_is_subscribed_to_a_message() { Consumer = new ConsumerOf <SimpleMessage>(); RemoteBus.SubscribeInstance(Consumer); LocalBus.ShouldHaveSubscriptionFor <SimpleMessage>(); }
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 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 EstablishContext() { base.EstablishContext(); LocalBus.ShouldHaveSubscriptionFor <Message>(); LocalBus.ShouldHaveSubscriptionFor <BaseMessage>(); LocalBus.Publish(new Message()); }
public void Should_not_remove_any_existing_subscriptions() { RemoteBus.Subscribe <A>(x => { }); RemoteBus.Dispose(); ThreadUtil.Sleep(2.Seconds()); LocalBus.ShouldHaveSubscriptionFor <A>(); }
public void Publishing_to_a_remote_subscriber() { Consumer = new ConsumerOf <SimpleMessage>(); _unsubscribeAction = RemoteBus.SubscribeInstance(Consumer); RemoteBus.ShouldHaveSubscriptionFor <SimpleMessage>(); LocalBus.ShouldHaveSubscriptionFor <SimpleMessage>(); _message = new SimpleMessage(); LocalBus.Publish(_message); }
public void It_should_be_received_by_a_component() { RemoteBus.SubscribeConsumer <TestMessageConsumer <PingMessage> >(); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); var message = new PingMessage(); LocalBus.Publish(message); TestConsumerBase <PingMessage> .AnyShouldHaveReceivedMessage(message, _timeout); }
public void It_should_be_received_by_an_interested_correlated_consumer() { var message = new PingMessage(); var consumer = new TestCorrelatedConsumer <PingMessage, Guid>(message.CorrelationId); RemoteBus.SubscribeInstance(consumer); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); LocalBus.Publish(message); consumer.ShouldHaveReceivedMessage(message, _timeout); }
public void Should_be_able_to_read_xml_when_using_json() { Assert.IsTrue(RemoteBus.ShouldHaveSubscriptionFor <B>().Any()); Assert.IsTrue(LocalBus.ShouldHaveSubscriptionFor <A>().Any()); LocalBus.GetEndpoint(RemoteUri).Send(new A { Key = "Hello" }); _requestReceived.WaitUntilCompleted(8.Seconds()).ShouldBeTrue(); _responseReceived.WaitUntilCompleted(8.Seconds()).ShouldBeTrue(); }
public void It_should_be_received_by_one_subscribed_consumer() { var consumer = new TestMessageConsumer <PingMessage>(); RemoteBus.SubscribeInstance(consumer); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); var message = new PingMessage(); LocalBus.Publish(message); consumer.ShouldHaveReceivedMessage(message, _timeout); }
public void Should_remove_any_previous_subscriptions() { RemoteBus.Subscribe <A>(x => { }); LocalBus.ShouldHaveSubscriptionFor <A>(); RemoteBus.Dispose(); ThreadUtil.Sleep(1.Seconds()); SetupRemoteBus(); LocalBus.ShouldNotHaveSubscriptionFor <A>(); }
public void It_should_be_received_by_one_subscribed_message_handler() { TestMessageConsumer <PingMessage> messageConsumer = new TestMessageConsumer <PingMessage>(); RemoteBus.SubscribeHandler <PingMessage>(messageConsumer.MessageHandler); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); PingMessage message = new PingMessage(); LocalBus.Publish(message); messageConsumer.ShouldHaveReceivedMessage(message, _timeout); }
public void It_should_not_be_received_by_an_uninterested_correlated_consumer() { TestCorrelatedConsumer <PingMessage, Guid> consumer = new TestCorrelatedConsumer <PingMessage, Guid>(Guid.NewGuid()); RemoteBus.SubscribeInstance(consumer); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); PingMessage message = new PingMessage(); LocalBus.Publish(message); consumer.ShouldNotHaveReceivedMessage(message, _timeout); }
public void Should_deliver_the_message_to_an_interested_consumer() { var first = new Future <FirstMessageContract>(); RemoteBus.SubscribeHandler <FirstMessageContract>(first.Complete); LocalBus.ShouldHaveSubscriptionFor <FirstMessageContract>(); PipelineViewer.Trace(RemoteBus.InboundPipeline); var message = new SomeMessageContract("Joe", 27); LocalBus.Publish(message); first.WaitUntilCompleted(1.Seconds()).ShouldBeTrue(); }
public void The_response_address_should_be_properly_set_on_the_message_envelope() { var ping = new PingMessage(); var received = new FutureMessage <PingMessage>(); RemoteBus.SubscribeHandler <PingMessage>(message => { Assert.AreEqual(LocalBus.Endpoint.Address.Uri, LocalBus.Context().ResponseAddress); received.Set(message); }); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); LocalBus.Publish(ping, context => context.SendResponseTo(LocalBus.Endpoint.Address.Uri)); Assert.IsTrue(received.IsAvailable(10.Seconds()), "Timeout waiting for message"); }
public void The_method_should_be_called_for_each_destination_endpoint_when_there_are_multiple() { RemoteBus.SubscribeHandler <PingMessage>(x => { }); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); LocalBus.SubscribeHandler <PingMessage>(x => { }); var ping = new PingMessage(); var consumers = new List <Uri>(); LocalBus.Publish(ping, x => { x.ForEachSubscriber(address => consumers.Add(address.Uri)); }); Assert.AreEqual(2, consumers.Count); Assert.IsTrue(consumers.Contains(LocalBus.Endpoint.Address.Uri)); Assert.IsTrue(consumers.Contains(RemoteBus.Endpoint.Address.Uri)); }
public void The_message_type_should_be_properly_set_on_the_message_envelope() { var ping = new PingMessage(); var received = new FutureMessage <PingMessage>(); RemoteBus.SubscribeHandler <PingMessage>(message => { Assert.AreEqual(typeof(PingMessage).ToMessageName(), LocalBus.Context().MessageType); received.Set(message); }); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); LocalBus.Publish(ping); Assert.IsTrue(received.IsAvailable(10.Seconds()), "Timeout waiting for message"); }
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 Should_deliver_the_message_to_an_both_interested_consumers() { var first = new Future <FirstMessageContract>(); var second = new Future <SecondMessageContract>(); // These can't be on the same bus, because we only send a message to an endpoint once // maybe we can do something here by changing the outbound context to keep track of tmessage/endpoint uri RemoteBus.SubscribeHandler <FirstMessageContract>(first.Complete); LocalBus.SubscribeHandler <SecondMessageContract>(second.Complete); LocalBus.ShouldHaveSubscriptionFor <FirstMessageContract>(); var message = new SomeMessageContract("Joe", 27); LocalBus.Publish(message); first.WaitUntilCompleted(1.Seconds()).ShouldBeTrue(); second.WaitUntilCompleted(1.Seconds()).ShouldBeTrue(); }
public void It_should_be_received_by_multiple_subscribed_consumers() { TestMessageConsumer <PingMessage> consumer = new TestMessageConsumer <PingMessage>(); RemoteBus.SubscribeInstance(consumer); TestMessageConsumer <PingMessage> messageConsumer = new TestMessageConsumer <PingMessage>(); RemoteBus.SubscribeHandler <PingMessage>(messageConsumer.MessageHandler); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); PingMessage message = new PingMessage(); LocalBus.Publish(message); consumer.ShouldHaveReceivedMessage(message, _timeout); messageConsumer.ShouldHaveReceivedMessage(message, _timeout); }
public void It_should_not_be_received_by_an_uninterested_consumer() { var messageConsumer = new TestMessageConsumer <PingMessage>(); RemoteBus.SubscribeHandler <PingMessage>(messageConsumer.MessageHandler, x => false); var consumer = new TestMessageConsumer <PingMessage>(); RemoteBus.SubscribeInstance(consumer); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); var message = new PingMessage(); LocalBus.Publish(message); consumer.ShouldHaveReceivedMessage(message, _timeout); messageConsumer.ShouldNotHaveReceivedMessage(message, TimeSpan.FromSeconds(1)); }
public void The_retry_count_should_be_properly_set_on_the_message_envelope() { var ping = new PingMessage(); var received = new FutureMessage <PingMessage>(); int retryCount = 69; RemoteBus.SubscribeHandler <PingMessage>(message => { Assert.AreEqual(retryCount, LocalBus.Context().RetryCount); received.Set(message); }); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); LocalBus.Publish(ping, context => context.SetRetryCount(retryCount)); Assert.IsTrue(received.IsAvailable(10.Seconds()), "Timeout waiting for message"); }
public void It_should_leave_the_message_in_the_queue_if_an_exception_is_thrown() { FutureMessage <PingMessage> future = new FutureMessage <PingMessage>(); RemoteBus.SubscribeHandler <PingMessage>(m => { future.Set(m); throw new ApplicationException("Boing!"); }); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); var message = new PingMessage(); LocalBus.Publish(message); future.IsAvailable(_timeout).ShouldBeTrue("Message was not received"); RemoteEndpoint.ShouldNotContain(message); }
protected override void EstablishContext() { base.EstablishContext(); InMemorySagaRepository <RegisterUserSaga> sagaRepository = SetupSagaRepository <RegisterUserSaga>(); // this just shows that you can easily respond to the message RemoteBus.SubscribeHandler <SendUserVerificationEmail>( x => { RemoteBus.ShouldHaveSubscriptionFor <UserVerificationEmailSent>(); RemoteBus.Publish(new UserVerificationEmailSent(x.CorrelationId, x.Email)); }); RemoteBus.SubscribeSaga(sagaRepository); LocalBus.ShouldHaveSubscriptionFor <RegisterUser>(); LocalBus.ShouldHaveSubscriptionFor <UserVerificationEmailSent>(); LocalBus.ShouldHaveSubscriptionFor <UserValidated>(); }
public void It_should_not_rollback_a_send_if_an_exception_is_thrown() { var consumer = new TestMessageConsumer <PongMessage>(); LocalBus.SubscribeInstance(consumer); var message = new PingMessage(); var response = new PongMessage(message.CorrelationId); RemoteBus.SubscribeHandler <PingMessage>(m => { RemoteBus.Publish(response); throw new ApplicationException("Boing!"); }); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); RemoteBus.ShouldHaveSubscriptionFor <PongMessage>(); LocalBus.Publish(message); consumer.ShouldHaveReceivedMessage(response, _timeout); }