public void Should_call_the_message_handler_again()
{
var responded = new FutureMessage <Message <string> >();
LocalBus.Endpoint.SendRequest(new Message <int> {
Body = 27
}, LocalBus, x =>
{
x.Handle <Message <string> >(responded.Set);
});
responded.IsAvailable(8.Seconds()).ShouldBeTrue();
responded.Message.Body.ShouldEqual("27");
responded = new FutureMessage <Message <string> >();
LocalBus.Endpoint.SendRequest(new Message <int> {
Body = 69
}, LocalBus, x =>
{
x.Handle <Message <string> >(responded.Set);
});
responded.IsAvailable(8.Seconds()).ShouldBeTrue();
responded.Message.Body.ShouldEqual("69");
}
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 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");
}
protected override void EstablishContext()
{
base.EstablishContext();
_faultFuture = new FutureMessage <Fault <PingMessage, Guid> >();
LocalBus.SubscribeHandler <PingMessage>(message =>
{
using (new TransactionScope())
{
}
});
LocalBus.SubscribeHandler <Fault <PingMessage, Guid> >(message =>
{
if (_faultFuture.IsAvailable(TimeSpan.Zero))
{
return;
}
_faultFuture.Set(message);
});
LocalBus.ShouldHaveRemoteSubscriptionFor <PingMessage>();
LocalBus.ShouldHaveRemoteSubscriptionFor <Fault <PingMessage, Guid> >();
_ping = new PingMessage();
LocalBus.Publish(_ping);
}
public void A_clean_method_of_a_request_reply_should_be_possible()
{
var ponged = new FutureMessage<PongMessage>();
RemoteBus.SubscribeHandler<PingMessage>(x =>
{
// timing issue here it seems, but that's what Respond() is for, to RESPOND to messages
// and not publish responses
RemoteBus.ShouldHaveSubscriptionFor<PongMessage>();
RemoteBus.Publish(new PongMessage(x.CorrelationId));
});
LocalBus.ShouldHaveSubscriptionFor<PingMessage>();
var ping = new PingMessage();
LocalBus.PublishRequest(ping, x =>
{
x.Handle<PongMessage>(message =>
{
message.CorrelationId.ShouldEqual(ping.CorrelationId);
ponged.Set(message);
});
x.HandleTimeout(8.Seconds(), () => { });
});
ponged.IsAvailable(8.Seconds()).ShouldBeTrue("No ping response received");
}
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 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();
}
}
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 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 A_response_should_be_published_if_no_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);
});
LocalBus.Publish(ping);
pong.IsAvailable(8.Seconds()).ShouldBeTrue("No pong generated");
consumer.ShouldHaveReceivedMessage(pong.Message, 8.Seconds());
otherConsumer.ShouldHaveReceivedMessage(pong.Message, 8.Seconds());
}
public void Should_support_the_asynchronous_programming_model()
{
var pongReceived = new FutureMessage<PongMessage>();
var pingReceived = new FutureMessage<PingMessage>();
var callbackCalled = new FutureMessage<IAsyncResult>();
RemoteBus.SubscribeHandler<PingMessage>(x =>
{
pingReceived.Set(x);
RemoteBus.MessageContext<PingMessage>().Respond(new PongMessage(x.CorrelationId));
});
var ping = new PingMessage();
var timeout = 8.Seconds();
LocalBus.BeginPublishRequest(ping, callbackCalled.Set, null, x =>
{
x.Handle<PongMessage>(message =>
{
message.CorrelationId.ShouldEqual(ping.CorrelationId, "The response correlationId did not match");
pongReceived.Set(message);
});
x.SetTimeout(timeout);
});
callbackCalled.IsAvailable(timeout).ShouldBeTrue("The callback was not called");
LocalBus.EndRequest(callbackCalled.Message);
pingReceived.IsAvailable(timeout).ShouldBeTrue("The ping was not received");
pongReceived.IsAvailable(timeout).ShouldBeTrue("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.SubscribeHandler<PingMessage>(x =>
{
pingReceived.Set(x);
RemoteBus.MessageContext<PingMessage>().Respond(new PongMessage(x.CorrelationId));
});
var ping = new PingMessage();
var timeout = 8.Seconds();
LocalBus.PublishRequest(ping, x =>
{
x.Handle<PongMessage>(message =>
{
message.CorrelationId.ShouldEqual(ping.CorrelationId, "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 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 A_consumer_is_being_tested()
{
_test = TestFactory.ForHandler<InputMessage>()
.New(x =>
{
x.Handler((bus,message) =>
{
bus.MessageContext<InputMessage>().Respond(new OutputMessage());
});
x.Send(new InputMessage(), c => c.SendResponseTo(_test.Scenario.Bus));
x.Send(new InputMessage(), c => c.SendResponseTo(_test.Scenario.Bus));
});
_test.Execute();
_test.Received.Any<InputMessage>().ShouldBeTrue();
_test.Sent.Any<OutputMessage>().ShouldBeTrue();
_future = new FutureMessage<ReceivedMessageTraceList>();
_test.Scenario.Bus.GetMessageTrace(_test.Scenario.Bus.ControlBus.Endpoint, _future.Set);
_future.IsAvailable(8.Seconds()).ShouldBeTrue();
_list = _future.Message;
}
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_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()
{
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()));
}
private void OnFutureMessage(FutureMessage evt)
{
var node = new FutureMessageNode(evt.Id, evt.Message, evt.ActorRef);
if (this._map.TryAdd(evt.Id, node))
{
this._queue.Enqueue(node, evt.FireTime);
}
}
protected override void EstablishContext()
{
base.EstablishContext();
_faultFuture = new FutureMessage<Fault<PingMessage, Guid>>();
LocalBus.Subscribe<PingMessage>(message => { throw new NotSupportedException("I am a naughty consumer! I go boom!"); });
LocalBus.Subscribe<Fault<PingMessage, Guid>>(message => _faultFuture.Set(message));
_ping = new PingMessage();
LocalBus.Publish(_ping);
}
private void MakeSagaDown()
{
MakeSagaSuspect();
var fm = new FutureMessage<TimeoutExpired>();
RemoteBus.Subscribe<TimeoutExpired>(fm.Set);
Thread.Sleep(500);
LocalBus.Publish(new TimeoutExpired {CorrelationId = _id, Tag = 2});
fm.IsAvailable(1.Seconds()).ShouldBeTrue();
var saga = Repository.Where(x => x.CorrelationId == _id).First();
saga.CurrentState.ShouldEqual(HealthSaga.Down, "MakeSagaDown failed");
}
protected override void EstablishContext()
{
base.EstablishContext();
_future = new FutureMessage<PingMessage>();
LocalBus.Subscribe<PingMessage>(message => _future.Set(message));
_ping = new PingMessage();
LocalBus.Publish(_ping);
}
protected override void EstablishContext()
{
base.EstablishContext();
_future = new FutureMessage <PingMessage>();
LocalBus.SubscribeHandler <PingMessage>(message => _future.Set(message));
_ping = new PingMessage();
LocalBus.Publish(_ping);
}
protected override void EstablishContext()
{
base.EstablishContext();
_faultFuture = new FutureMessage <Fault <PingMessage, Guid> >();
LocalBus.Subscribe <PingMessage>(message => { throw new NotSupportedException("I am a naughty consumer! I go boom!"); });
LocalBus.Subscribe <Fault <PingMessage, Guid> >(message => _faultFuture.Set(message));
_ping = new PingMessage();
LocalBus.Publish(_ping);
}
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 MakeSagaSuspect()
{
LocalBus.Publish(new EndpointCameOnline(_id, LocalBus.ControlBus.Endpoint.Uri,LocalBus.Endpoint.Uri, 0));
var fm = new FutureMessage<TimeoutExpired>();
RemoteBus.Subscribe<TimeoutExpired>(fm.Set);
Thread.Sleep(5000);
LocalBus.Publish(new TimeoutExpired {CorrelationId = _id, Tag = 1});
fm.IsAvailable(5.Seconds()).ShouldBeTrue();
var saga = Repository.Where(x => x.CorrelationId == _id).FirstOrDefault();
saga.ShouldNotBeNull();
saga.CurrentState.ShouldEqual(HealthSaga.Suspect, "MakeSagaSuspect failed");
}
public void Should_Parse_FutureMessage_Culture_Independent(string cultureName)
{
// Arrange
TestHelper.SetThreadCulture(cultureName);
var message = "@ESU18,@ESZ18,@ESH19,@ESM19,@ESU19,";
// Act
var futureMessageParsed = FutureMessage.Parse(message);
var futureMessage = new Future("@ESU18", "@ES", new DateTime(2018, 09, 01));
// Assert
Assert.AreEqual(futureMessageParsed.Chains.First(), futureMessage);
}
public void Configuring_a_service_bus_easily()
{
FutureMessage<PingMessage> received;
using (IServiceBus bus = ServiceBusFactory.New(x => { x.ReceiveFrom("loopback://localhost/queue"); }))
{
received = new FutureMessage<PingMessage>();
bus.SubscribeHandler<PingMessage>(received.Set);
bus.Publish(new PingMessage());
received.IsAvailable(8.Seconds()).ShouldBeTrue();
}
}
public void Configuring_a_service_bus_easily()
{
using (var bus = ServiceBusFactory.New(x => { x.ReceiveFrom("loopback://localhost/queue"); }))
{
var received = new FutureMessage <PingMessage>();
bus.SubscribeHandler <PingMessage>(received.Set);
bus.Publish(new PingMessage());
received.IsAvailable(8.Seconds()).ShouldBeTrue();
}
}
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 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");
}
}
protected override void EstablishContext()
{
base.EstablishContext();
_ping = new PingMessage();
_future = new FutureMessage<PingMessage, Guid>(_ping.CorrelationId);
RemoteBus.SubscribeHandler<PingMessage>(message => { _future.Set(message); });
LocalBus.ShouldHaveRemoteSubscriptionFor<PingMessage>();
LocalBus.Publish(_ping);
}
public void If_a_saga_is_suspect_a_pingtimeout_should_make_it_down()
{
MakeSagaSuspect();
var fm = new FutureMessage<TimeoutExpired>();
RemoteBus.Subscribe<TimeoutExpired>(fm.Set);
Thread.Sleep(250);
LocalBus.Publish(new TimeoutExpired {CorrelationId = _id, Tag = 2});
fm.IsAvailable(100.Seconds()).ShouldBeTrue("never got message");
Thread.Sleep(100000);
var saga = Repository.Where(x => x.CorrelationId == _id).First();
saga.CurrentState.ShouldEqual(HealthSaga.Down);
}
public void The_destination_address_should_pass()
{
FutureMessage<PingMessage> received = new FutureMessage<PingMessage>();
LocalBus.Subscribe<PingMessage>(message =>
{
Assert.AreEqual(LocalBus.Endpoint.Uri, CurrentMessage.Headers.DestinationAddress);
received.Set(message);
});
LocalBus.Publish(new PingMessage());
Assert.IsTrue(received.IsAvailable(5.Seconds()), "No message was received");
}
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 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 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_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();
}
private void MakeSagaDown()
{
MakeSagaSuspect();
var fm = new FutureMessage <TimeoutExpired>();
RemoteBus.Subscribe <TimeoutExpired>(fm.Set);
Thread.Sleep(500);
LocalBus.Publish(new TimeoutExpired {
CorrelationId = _id, Tag = 2
});
fm.IsAvailable(1.Seconds()).ShouldBeTrue();
var saga = Repository.Where(x => x.CorrelationId == _id).First();
saga.CurrentState.ShouldEqual(HealthSaga.Down, "MakeSagaDown failed");
}
public void The_message_type_should_be_properly_set_on_the_message_envelope()
{
PingMessage ping = new PingMessage();
FutureMessage <PingMessage> received = new FutureMessage <PingMessage>();
RemoteBus.Subscribe <PingMessage>(message =>
{
Assert.AreEqual(typeof(PingMessage).ToMessageName(), CurrentMessage.Headers.MessageType);
received.Set(message);
});
LocalBus.Publish(ping);
Assert.IsTrue(received.IsAvailable(3.Seconds()), "Timeout waiting for message");
}
public void MakeSagaSuspect()
{
LocalBus.Publish(new EndpointCameOnline(_id, LocalBus.ControlBus.Endpoint.Uri, LocalBus.Endpoint.Uri, 0));
var fm = new FutureMessage <TimeoutExpired>();
RemoteBus.Subscribe <TimeoutExpired>(fm.Set);
Thread.Sleep(5000);
LocalBus.Publish(new TimeoutExpired {
CorrelationId = _id, Tag = 1
});
fm.IsAvailable(5.Seconds()).ShouldBeTrue();
var saga = Repository.Where(x => x.CorrelationId == _id).FirstOrDefault();
saga.ShouldNotBeNull();
saga.CurrentState.ShouldEqual(HealthSaga.Suspect, "MakeSagaSuspect failed");
}
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_fault_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().FaultAddress);
received.Set(message);
});
LocalBus.Publish(ping, context => context.SendFaultTo(LocalBus.Endpoint.Address.Uri));
Assert.IsTrue(received.IsAvailable(10.Seconds()), "Timeout waiting for message");
}
public void The_response_address_should_be_properly_set_on_the_message_envelope()
{
PingMessage ping = new PingMessage();
FutureMessage <PingMessage> received = new FutureMessage <PingMessage>();
RemoteBus.Subscribe <PingMessage>(message =>
{
Assert.AreEqual(LocalBus.Endpoint.Uri, CurrentMessage.Headers.ResponseAddress);
received.Set(message);
});
LocalBus.Publish(ping, context => context.SendResponseTo(LocalBus.Endpoint.Uri));
Assert.IsTrue(received.IsAvailable(3.Seconds()), "Timeout waiting for message");
}
public void If_a_saga_is_suspect_a_pingtimeout_should_make_it_down()
{
MakeSagaSuspect();
var fm = new FutureMessage <TimeoutExpired>();
RemoteBus.Subscribe <TimeoutExpired>(fm.Set);
Thread.Sleep(250);
LocalBus.Publish(new TimeoutExpired {
CorrelationId = _id, Tag = 2
});
fm.IsAvailable(100.Seconds()).ShouldBeTrue("never got message");
Thread.Sleep(100000);
var saga = Repository.Where(x => x.CorrelationId == _id).First();
saga.CurrentState.ShouldEqual(HealthSaga.Down);
}
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_leave_the_message_in_the_queue_if_an_exception_is_thrown()
{
FutureMessage <PingMessage> future = new FutureMessage <PingMessage>();
RemoteBus.Subscribe <PingMessage>(m =>
{
future.Set(m);
throw new ApplicationException("Boing!");
});
var message = new PingMessage();
LocalBus.Publish(message);
future.IsAvailable(_timeout).ShouldBeTrue("Message was not received");
RemoteEndpoint.ShouldNotContain(message);
}
public void ShouldNotReTryCookFoodMessage()
{
var publisherMock = new Mock <IPublisher>();
FutureMessage msg = null;
publisherMock.Setup(x => x.Publish(It.IsAny <FutureMessage>()))
.Callback <FutureMessage>(r => msg = r);
var regularMidget = new RegularMidget(publisherMock.Object);
var msgToDeliver = new CookFood(new Order(), "cu");
regularMidget.Handle(new OrderCooked(new Order(), string.Empty));
regularMidget.Handle(new FutureMessage(msgToDeliver, DateTime.MaxValue));
publisherMock.Verify(p => p.Publish(It.IsAny <FutureMessage>()), Times.Never);
publisherMock.Verify(p => p.Publish(It.IsAny <CookFood>()), Times.Never);
publisherMock.Verify(p => p.Publish(It.IsAny <PriceOrdered>()));
}
public void The_timeout_should_be_added_to_the_storage()
{
var timedOut = new FutureMessage <TimeoutExpired>();
LocalBus.SubscribeHandler <TimeoutExpired>(timedOut.Set);
LocalBus.HasSubscription <TimeoutExpired>(8.Seconds()).Any()
.ShouldBeTrue("No subscription");
LocalBus.Publish(new ScheduleTimeout(_correlationId, 2.Seconds()));
Stopwatch watch = Stopwatch.StartNew();
timedOut.IsAvailable(8.Seconds()).ShouldBeTrue("Did not get timeout message");
watch.Stop();
Debug.WriteLine(string.Format("Timeout took {0}ms", watch.ElapsedMilliseconds));
}
public void A_clean_method_of_a_request_reply_should_be_possible()
{
FutureMessage<PongMessage> ponged = new FutureMessage<PongMessage>();
LocalBus.SubscribeHandler<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 The_retry_count_should_be_properly_set_on_the_message_envelope()
{
PingMessage ping = new PingMessage();
FutureMessage <PingMessage> received = new FutureMessage <PingMessage>();
var retryCount = 69;
RemoteBus.Subscribe <PingMessage>(message =>
{
Assert.AreEqual(retryCount, CurrentMessage.Headers.RetryCount);
received.Set(message);
});
LocalBus.Publish(ping, context => context.SetRetryCount(retryCount));
Assert.IsTrue(received.IsAvailable(3.Seconds()), "Timeout waiting for message");
}
public void The_timeout_should_be_added_to_the_storage()
{
var timedOut = new FutureMessage<TimeoutExpired>();
LocalBus.SubscribeHandler<TimeoutExpired>(timedOut.Set);
LocalBus.HasSubscription<TimeoutExpired>(8.Seconds()).Any()
.ShouldBeTrue("No subscription");
LocalBus.Publish(new ScheduleTimeout(_correlationId, 2.Seconds()));
Stopwatch watch = Stopwatch.StartNew();
timedOut.IsAvailable(8.Seconds()).ShouldBeTrue("Did not get timeout message");
watch.Stop();
Debug.WriteLine(string.Format("Timeout took {0}ms", watch.ElapsedMilliseconds));
}
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 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 ShouldReTryCookFoodMessage()
{
var publisherMock = new Mock <IPublisher>();
FutureMessage msg = null;
publisherMock.Setup(x => x.Publish(It.IsAny <FutureMessage>()))
.Callback <FutureMessage>(r => msg = r);
var regularMidget = new RegularMidget(publisherMock.Object);
var msgToDeliver = new CookFood(new Order(), "cu");
regularMidget.Handle(new FutureMessage(msgToDeliver, DateTime.MaxValue));
publisherMock.Verify(p => p.Publish(It.IsAny <FutureMessage>()));
publisherMock.Verify(p => p.Publish(It.IsAny <CookFood>()));
msg.MessageToDeliver.MessageId
.ShouldEqual(msgToDeliver.MessageId);
}
public void Should_work_through_the_saga()
{
var response = new FutureMessage <OrderDetailsReceived>();
const string orderId = "ABC123";
const string customerId = "12345";
LocalBus.Subscribe <OrderDetailsReceived>(message =>
{
response.Set(message);
},
x => x.OrderId == orderId && x.CustomerId == customerId);
RetrieveOrderDetails request = new RetrieveOrderDetailsRequest(customerId, orderId);
LocalBus.Publish(request, x => x.SendResponseTo(LocalBus.Endpoint));
Assert.IsTrue(response.WaitUntilAvailable(555.Seconds()), "The response was not received");
Assert.AreEqual(orderId, response.Message.OrderId);
Assert.AreEqual(customerId, response.Message.CustomerId);
}
public void Should_return_the_matching_details_for_the_order()
{
var response = new FutureMessage <OrderDetailsResponse>();
LocalBus.Subscribe <OrderDetailsResponse>(response.Set);
const string orderId = "ABC123";
const string customerId = "12345";
var request = new SendOrderDetailsRequest
{
RequestId = CombGuid.Generate(),
CustomerId = customerId,
OrderId = orderId,
};
LocalBus.Publish(request, x => x.SendResponseTo(LocalBus.Endpoint));
Assert.IsTrue(response.WaitUntilAvailable(5.Seconds()), "The response was not received");
Assert.AreEqual(orderId, response.Message.OrderId);
Assert.AreEqual(customerId, response.Message.CustomerId);
}
protected override void EstablishContext()
{
base.EstablishContext();
_ping = new PingMessage();
_faultFuture = new FutureMessage <Fault <PingMessage, Guid> >();
_future = new FutureMessage <PingMessage, Guid>(_ping.CorrelationId);
LocalBus.SubscribeHandler <PingMessage>(message =>
{
_future.Set(message);
throw new NotSupportedException("I am a naughty consumer! I go boom!");
});
LocalBus.SubscribeHandler <Fault <PingMessage, Guid> >(message => _faultFuture.Set(message));
LocalBus.Publish(_ping);
_future.WaitUntilAvailable(1.Seconds());
}
public void A_consumer_is_being_tested()
{
_test = TestFactory.ForHandler <InputMessage>()
.New(x =>
{
x.Handler((context, message) => context.Respond(new OutputMessage()));
x.Send(new InputMessage(), (scenario, context) => context.SendResponseTo(scenario.Bus));
x.Send(new InputMessage(), (scenario, context) => context.SendResponseTo(scenario.Bus));
});
_test.Execute();
_test.Received.Any <InputMessage>().ShouldBeTrue();
_test.Sent.Any <OutputMessage>().ShouldBeTrue();
_future = new FutureMessage <ReceivedMessageTraceList>();
_test.Scenario.Bus.GetMessageTrace(_test.Scenario.Bus.ControlBus.Endpoint, _future.Set);
_future.IsAvailable(8.Seconds()).ShouldBeTrue();
_list = _future.Message;
}
protected override void EstablishContext()
{
base.EstablishContext();
_faultFuture = new FutureMessage <Fault <PingMessage, Guid> >();
LocalBus.SubscribeHandler <PingMessage>(message => { throw new NotSupportedException("I am a naughty consumer! I go boom!"); });
LocalBus.SubscribeHandler <Fault <PingMessage, Guid> >(message =>
{
if (_faultFuture.IsAvailable(TimeSpan.Zero))
{
return;
}
_faultFuture.Set(message);
});
LocalBus.ShouldHaveRemoteSubscriptionFor <PingMessage>();
LocalBus.ShouldHaveRemoteSubscriptionFor <Fault <PingMessage, Guid> >();
_ping = new PingMessage();
LocalBus.Publish(_ping);
}
