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");
}
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());
}
protected override void EstablishContext()
{
base.EstablishContext();
_ping = new PingMessage();
_future = new FutureMessage <PingMessage, Guid>(_ping.CorrelationId);
_unsubscribe = RemoteBus.SubscribeHandler <PingMessage>(message => { _future.Set(message); });
RemoteBus.ShouldHaveRemoteSubscriptionFor <PingMessage>();
LocalBus.ShouldHaveRemoteSubscriptionFor <PingMessage>();
Trace.WriteLine("LocalBus");
LocalBus.OutboundPipeline.Trace();
Trace.WriteLine("RemoteBus");
RemoteBus.OutboundPipeline.Trace();
LocalBus.Publish(_ping);
}
public void Adding_many_dynamic_and_removing_should_retain_dynamics()
{
var dynamicA = new FutureMessage <A>();
var dynamicB = new FutureMessage <B>();
var dynamicC = new FutureMessage <C>();
var dynamicD = new FutureMessage <D>();
UnsubscribeAction subscriptionA = RemoteBus.SubscribeHandler <A>(dynamicA.Set);
UnsubscribeAction subscriptionB = RemoteBus.SubscribeHandler <B>(dynamicB.Set);
UnsubscribeAction subscriptionC = RemoteBus.SubscribeHandler <C>(dynamicC.Set);
UnsubscribeAction subscriptionD = RemoteBus.SubscribeHandler <D>(dynamicD.Set);
LocalBus.HasSubscription <D>(8.Seconds()).Any().ShouldBeTrue("No D subscription");
try
{
subscriptionA().ShouldBeFalse("A static not remaining");
subscriptionB().ShouldBeFalse("B static not remaining");
subscriptionC().ShouldBeFalse("C static not remaining");
LocalBus.Publish(new A());
LocalBus.Publish(new B());
LocalBus.Publish(new C());
LocalBus.Publish(new D());
_receivedA.IsAvailable(8.Seconds()).ShouldBeTrue("A not received");
_receivedB.IsAvailable(8.Seconds()).ShouldBeTrue("B not received");
_receivedC.IsAvailable(8.Seconds()).ShouldBeTrue("C not received");
dynamicD.IsAvailable(8.Seconds()).ShouldBeTrue("D should have been received");
}
finally
{
subscriptionD();
}
}
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_not_remove_any_existing_subscriptions()
{
RemoteBus.SubscribeHandler <A>(x => { });
RemoteBus.Dispose();
ThreadUtil.Sleep(2.Seconds());
LocalBus.ShouldHaveRemoteSubscriptionFor <A>();
}
public void A_message_is_published_one_the_local_bus()
{
_received = new Future <A>();
RemoteBus.SubscribeHandler <A>(message => _received.Complete(message));
Thread.Sleep(3.Seconds());
LocalBus.Publish(new A
{
StringA = "ValueA",
});
}
public void It_should_be_received_by_one_subscribed_message_handler()
{
var messageConsumer = new TestMessageConsumer <PingMessage>();
RemoteBus.SubscribeHandler <PingMessage>(messageConsumer.MessageHandler);
LocalBus.ShouldHaveSubscriptionFor <PingMessage>();
var message = new PingMessage();
LocalBus.Publish(message);
messageConsumer.ShouldHaveReceivedMessage(message, _timeout);
}
public void Dynamic_should_receive_the_message()
{
var receivedDynamic = new FutureMessage <A>();
UnsubscribeAction subscription = RemoteBus.SubscribeHandler <A>(receivedDynamic.Set);
using (subscription.Disposable())
{
LocalBus.Publish(new A());
receivedDynamic.IsAvailable(8.Seconds()).ShouldBeTrue("Dynamic not received");
_receivedA.IsAvailable(8.Seconds()).ShouldBeTrue("Static not received");
}
}
public void Should_remove_any_previous_subscriptions()
{
RemoteBus.SubscribeHandler <A>(x => { });
RemoteBus.ShouldHaveSubscriptionFor <A>();
LocalBus.ShouldHaveRemoteSubscriptionFor <A>();
RemoteBus.Dispose();
ThreadUtil.Sleep(2.Seconds());
SetupRemoteBus();
LocalBus.ShouldNotHaveSubscriptionFor <A>();
}
public void Static_should_remain_after_dynamic_removed()
{
var receivedDynamic = new FutureMessage <A>();
UnsubscribeAction subscription = RemoteBus.SubscribeHandler <A>(receivedDynamic.Set);
var result = subscription();
result.ShouldBeFalse("Should still have a static subscription");
LocalBus.Publish(new A());
receivedDynamic.IsAvailable(8.Seconds()).ShouldBeFalse("Dynamic should not have received");
_receivedA.IsAvailable(8.Seconds()).ShouldBeTrue("Static not received");
}
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.Publish(ping, context => context.SendResponseTo(LocalBus.Endpoint.Address.Uri));
Assert.IsTrue(received.IsAvailable(10.Seconds()), "Timeout waiting for message");
}
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.Publish(ping);
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_destination_address_should_be_properly_set_on_the_message_envelope()
{
var ping = new PingMessage();
var received = new FutureMessage <PingMessage>();
RemoteBus.SubscribeHandler <PingMessage>(message =>
{
Assert.AreEqual(RemoteBus.Endpoint.Address.Uri, LocalBus.Context().DestinationAddress);
received.Set(message);
});
LocalBus.ShouldHaveSubscriptionFor <PingMessage>();
LocalBus.Publish(ping);
Assert.IsTrue(received.IsAvailable(10.Seconds()), "Timeout waiting for message");
}
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 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 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.Publish(ping, context => context.SetRetryCount(retryCount));
Assert.IsTrue(received.IsAvailable(10.Seconds()), "Timeout waiting for message");
}
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));
}
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_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);
}
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);
}
protected override void EstablishContext()
{
base.EstablishContext();
var sagaRepository = new InMemorySagaRepository <ClaimRequestSaga>();
//these subscriptions are to replace the Timeout Service
RemoteBus.SubscribeHandler <ScheduleTimeout>(
x =>
{
RemoteBus.ShouldHaveSubscriptionFor <TimeoutScheduled>();
RemoteBus.Publish(new TimeoutScheduled {
CorrelationId = x.CorrelationId, TimeoutAt = x.TimeoutAt
});
});
RemoteBus.SubscribeHandler <CancelTimeout>(
x =>
{
RemoteBus.ShouldHaveSubscriptionFor <TimeoutCancelled>();
RemoteBus.Publish(new TimeoutCancelled {
CorrelationId = x.CorrelationId
});
}
);
//RemoteBus.SubscribeHandler<ClaimRequestCreatedPendingVerificationEvent>(x =>
// {
// Debug.WriteLine("Claim Created Pending Verification event received.");
// });
RemoteBus.SubscribeSaga(sagaRepository);
//event messages that the Saga is subscribed to
LocalBus.ShouldHaveSubscriptionFor <ClaimRequestCreatedPendingVerificationEvent>();
LocalBus.ShouldHaveSubscriptionFor <CardUseVerifiedEvent>();
LocalBus.ShouldHaveSubscriptionFor <TimeoutExpired>();
}
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");
}
