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