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_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 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 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 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 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_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_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");
}
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_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 Should_not_complete_timeout_if_handler_completes()
{
var pongReceived = new FutureMessage <PongMessage>();
var continueCalled = new FutureMessage <Task <PongMessage> >();
var timeoutCalled = new FutureMessage <PingMessage>();
TimeSpan timeout = 8.Seconds();
var ping = new PingMessage();
ITaskRequest <PingMessage> request = LocalBus.PublishRequestAsync(ping, x =>
{
x.HandleTimeout(4.Seconds(), timeoutCalled.Set);
x.Handle <PongMessage>(pongReceived.Set)
.ContinueWith(continueCalled.Set);
});
pongReceived.IsAvailable(timeout).ShouldBeTrue("The pong was not received");
request.Task.Wait(timeout).ShouldBeTrue("Task was not completed");
request.GetResponseTask <PongMessage>().Wait(timeout).ShouldBeTrue("The response task was not completed");
continueCalled.IsAvailable(timeout).ShouldBeTrue("The continuation was not called");
timeoutCalled.IsAvailable(2.Seconds()).ShouldBeFalse("The timeout should not have been called");
}
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 A_consumer_type_should_be_created_to_receive_the_message()
{
var fm = new FutureMessage <PingMessage>();
LocalBus.SubscribeConsumer <PingHandler>(() => new PingHandler(fm));
RemoteBus.ShouldHaveSubscriptionFor <PingMessage>();
int old = PingHandler.Pinged;
RemoteBus.Publish(new PingMessage());
fm.IsAvailable(1.Seconds());
Assert.That(PingHandler.Pinged, Is.GreaterThan(old));
}
public void A_consumer_object_should_receive_the_message()
{
FutureMessage <PingMessage> fm = new FutureMessage <PingMessage>();
PingHandler handler = new PingHandler(fm);
LocalBus.Subscribe(handler);
int old = PingHandler.Pinged;
RemoteBus.Publish(new PingMessage());
fm.IsAvailable(1.Seconds());
Assert.That(PingHandler.Pinged, Is.GreaterThan(old));
}
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 Should_call_timeout_callback_if_timeout_occurs_and_not_fault()
{
var continueCalled = new FutureMessage <PingMessage>();
var ping = new PingMessage();
ITaskRequest <PingMessage> request = LocalBus.PublishRequestAsync(ping, x =>
{
//
x.HandleTimeout(1.Seconds(), continueCalled.Set);
});
request.Task.Wait(8.Seconds()).ShouldBeTrue("Should have completed successfully");
continueCalled.IsAvailable(8.Seconds()).ShouldBeTrue("The timeout continuation was not called");
}
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 <Func <PingMessage, Action <PingMessage> > >();
getter.Expect(x => x(ping)).Return(called.Set);
LocalBus.SubscribeConsumer <PingMessage>(getter);
LocalBus.Publish(ping);
called.IsAvailable(3.Seconds()).ShouldBeTrue();
}
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 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 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 A_consumer_type_should_be_created_to_receive_the_message()
{
FutureMessage <PingMessage> fm = new FutureMessage <PingMessage>();
PingHandler ph = new PingHandler(fm);
ObjectBuilder.Stub(x => x.GetInstance <PingHandler>()).Return(ph);
ObjectBuilder.Stub(x => x.GetInstance <PingHandler>(new Hashtable())).IgnoreArguments().Return(ph);
LocalBus.Subscribe <PingHandler>();
int old = PingHandler.Pinged;
RemoteBus.Publish(new PingMessage());
fm.IsAvailable(1.Seconds());
Assert.That(PingHandler.Pinged, Is.GreaterThan(old));
}
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 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 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 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 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 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");
}
