public void A_consumer_is_subscribed_to_a_message()
{
Consumer = new ConsumerOf <SimpleMessage>();
RemoteBus.Subscribe(Consumer);
LocalBus.ShouldHaveSubscriptionFor <SimpleMessage>();
}
public void The_message_should_be_delivered_to_a_remote_subscriber_with_a_reply()
{
ManualResetEvent _updateEvent = new ManualResetEvent(false);
Action <UpdateMessage> handler =
msg =>
{
_updateEvent.Set();
RemoteBus.Publish(new UpdateAcceptedMessage());
};
ManualResetEvent _repliedEvent = new ManualResetEvent(false);
RemoteBus.Subscribe(handler);
LocalBus.Subscribe <UpdateAcceptedMessage>(
delegate { _repliedEvent.Set(); });
UpdateMessage um = new UpdateMessage();
LocalBus.Publish(um);
Assert.That(_updateEvent.WaitOne(TimeSpan.FromSeconds(3), true), Is.True,
"Timeout expired waiting for message");
Assert.That(_repliedEvent.WaitOne(TimeSpan.FromSeconds(3), true), Is.True, "NO response message received");
}
public void Multiple_messages_should_be_delivered_to_the_appropriate_remote_subscribers()
{
ManualResetEvent _updateEvent = new ManualResetEvent(false);
RemoteBus.Subscribe <UpdateMessage>(
delegate { _updateEvent.Set(); });
ManualResetEvent _deleteEvent = new ManualResetEvent(false);
RemoteBus.Subscribe <DeleteMessage>(
delegate { _deleteEvent.Set(); });
DeleteMessage dm = new DeleteMessage();
LocalBus.Publish(dm);
UpdateMessage um = new UpdateMessage();
LocalBus.Publish(um);
Assert.That(_deleteEvent.WaitOne(TimeSpan.FromSeconds(6), true), Is.True,
"Timeout expired waiting for message");
Assert.That(_updateEvent.WaitOne(TimeSpan.FromSeconds(6), true), Is.True,
"Timeout expired waiting for message");
}
public void A_response_should_be_sent_directly_if_a_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, context => context.SendResponseTo(LocalBus));
Assert.IsTrue(pong.IsAvailable(3.Seconds()), "No pong generated");
consumer.ShouldHaveReceivedMessage(pong.Message, 3.Seconds());
otherConsumer.ShouldNotHaveReceivedMessage(pong.Message, 1.Seconds());
}
public void Should_not_remove_any_existing_subscriptions()
{
RemoteBus.Subscribe <A>(x => { });
RemoteBus.Dispose();
ThreadUtil.Sleep(2.Seconds());
LocalBus.ShouldHaveSubscriptionFor <A>();
}
public void A_pong_service()
{
PingService = new ConsumerOf <Ping>(ping =>
{
// Response with a pong to the ping
CurrentMessage.Respond(new Pong(ping.CorrelationId));
});
RemoteBus.Subscribe(PingService);
}
public void A_state_machine_based_saga_should_automatically_wire_up_subscriptions()
{
RemoteBus.Subscribe <AutoStateMachineSaga>();
PipelineViewer.Trace(RemoteBus.InboundPipeline);
PipelineViewer.Trace(RemoteBus.OutboundPipeline);
Assert.AreEqual(0, _repository.Where(x => true).Count());
RemoteBus.Publish(new RegisterUser(_transactionId, _username, _password, _displayName, _email));
for (int i = 0; i < 20; i++)
{
if (_repository.Where(x => true).Count() == 1)
{
break;
}
Thread.Sleep(100);
}
Assert.AreEqual(1, _repository.Where(x => true).Count());
foreach (AutoStateMachineSaga saga in _repository.Where(x => true))
{
saga.CurrentState.ShouldEqual(AutoStateMachineSaga.WaitingForEmailValidation);
}
_repository
.Where(x => x.CorrelationId == _transactionId)
.Select(x => x.CurrentState)
.First()
.ShouldEqual(AutoStateMachineSaga.WaitingForEmailValidation);
RemoteBus.Publish(new UserValidated(_transactionId));
for (int i = 0; i < 20; i++)
{
if (_repository.Where(x => x.CorrelationId == _transactionId).Select(x => x.CurrentState).First() == AutoStateMachineSaga.Completed)
{
break;
}
Thread.Sleep(100);
}
_repository
.Where(x => x.CorrelationId == _transactionId)
.Select(x => x.CurrentState)
.First()
.ShouldEqual(AutoStateMachineSaga.Completed);
}
protected override void EstablishContext()
{
base.EstablishContext();
var sagaRepository = SetupSagaRepository <RegisterUserSaga>(ObjectBuilder);
// this just shows that you can easily respond to the message
RemoteBus.Subscribe <SendUserVerificationEmail>(
x => RemoteBus.Publish(new UserVerificationEmailSent(x.CorrelationId, x.Email)));
RemoteBus.Subscribe <RegisterUserSaga>();
}
public void It_should_be_received_by_one_subscribed_message_handler()
{
TestMessageConsumer <PingMessage> messageConsumer = new TestMessageConsumer <PingMessage>();
RemoteBus.Subscribe <PingMessage>(messageConsumer.MessageHandler);
PingMessage message = new PingMessage();
LocalBus.Publish(message);
messageConsumer.ShouldHaveReceivedMessage(message, _timeout);
}
public void It_should_be_received_by_an_interested_correlated_consumer()
{
PingMessage message = new PingMessage();
TestCorrelatedConsumer <PingMessage, Guid> consumer = new TestCorrelatedConsumer <PingMessage, Guid>(message.CorrelationId);
RemoteBus.Subscribe(consumer);
LocalBus.Publish(message);
consumer.ShouldHaveReceivedMessage(message, _timeout);
}
public void It_should_be_received_by_a_component()
{
ObjectBuilder.Stub(x => x.GetInstance <TestMessageConsumer <PingMessage> >()).Return(new TestMessageConsumer <PingMessage>());
RemoteBus.Subscribe <TestMessageConsumer <PingMessage> >();
PingMessage message = new PingMessage();
LocalBus.Publish(message);
TestConsumerBase <PingMessage> .AnyShouldHaveReceivedMessage(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.Subscribe(consumer);
PingMessage message = new PingMessage();
LocalBus.Publish(message);
consumer.ShouldNotHaveReceivedMessage(message, _timeout);
}
public void It_should_be_received_by_one_subscribed_consumer()
{
var consumer = new TestMessageConsumer <PingMessage>();
RemoteBus.Subscribe(consumer);
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 Should_deliver_the_message_to_an_interested_consumer()
{
var first = new Future <FirstMessageContract>();
RemoteBus.Subscribe <FirstMessageContract>(first.Complete);
PipelineViewer.Trace(RemoteBus.InboundPipeline);
var message = new SomeMessageContract("Joe", 27);
LocalBus.Publish(message);
first.IsAvailable(1.Seconds()).ShouldBeTrue();
}
public void The_message_should_be_delivered_to_a_remote_subscriber()
{
ManualResetEvent _updateEvent = new ManualResetEvent(false);
RemoteBus.Subscribe <UpdateMessage>(
delegate { _updateEvent.Set(); });
UpdateMessage um = new UpdateMessage();
LocalBus.Publish(um);
Assert.That(_updateEvent.WaitOne(TimeSpan.FromSeconds(3), true), Is.True,
"Timeout expired waiting for message");
}
public void Should_deliver_the_message_once_the_endpoint_is_available()
{
var received = new Future <PingMessage>();
using (RemoteBus.Subscribe <PingMessage>(received.Complete).Disposable())
{
Thread.Sleep(100);
var ping = new PingMessage();
LocalBus.Publish(ping);
received.IsAvailable(5.Seconds()).ShouldBeTrue();
}
}
protected override void EstablishContext()
{
base.EstablishContext();
_repository = SetupSagaRepository <AutoStateMachineSaga>(ObjectBuilder);
// this just shows that you can easily respond to the message
RemoteBus.Subscribe <SendUserVerificationEmail>(
x => RemoteBus.Publish(new UserVerificationEmailSent(x.CorrelationId, x.Email)));
_transactionId = CombGuid.Generate();
_username = "******";
_password = "******";
_email = "*****@*****.**";
_displayName = "Joe Blow";
}
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 It_should_be_received_by_multiple_subscribed_consumers()
{
var localConsumer = new TestMessageConsumer <PingMessage>();
LocalBus.Subscribe(localConsumer);
var remoteConsumer = new TestMessageConsumer <PingMessage>();
RemoteBus.Subscribe(remoteConsumer);
PingMessage message = new PingMessage();
LocalBus.Publish(message);
localConsumer.ShouldHaveReceivedMessage(message, _timeout);
remoteConsumer.ShouldHaveReceivedMessage(message, _timeout);
}
public void The_system_should_be_ready_to_use_before_getting_underway()
{
var consumer = new TestMessageConsumer <PingMessage>();
var unsubscribeAction = RemoteBus.Subscribe(consumer);
Thread.Sleep(1000);
DumpPipelines();
var message = new PingMessage();
LocalBus.Publish(message);
consumer.ShouldHaveReceivedMessage(message, 500.Milliseconds());
unsubscribeAction();
}
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 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");
}
protected void RunTest()
{
var batchConsumer = new TestBatchConsumer <IndividualBatchMessage, Guid>();
RemoteBus.Subscribe(batchConsumer);
Guid batchId = Guid.NewGuid();
for (int i = 0; i < _batchSize; i++)
{
IndividualBatchMessage message = new IndividualBatchMessage(batchId, _batchSize);
LocalBus.Publish(message);
}
batchConsumer.ShouldHaveReceivedBatch(_timeout);
}
public void It_should_not_be_received_by_an_uninterested_consumer()
{
TestMessageConsumer <PingMessage> messageConsumer = new TestMessageConsumer <PingMessage>();
RemoteBus.Subscribe <PingMessage>(messageConsumer.MessageHandler, x => false);
TestMessageConsumer <PingMessage> consumer = new TestMessageConsumer <PingMessage>();
RemoteBus.Subscribe(consumer);
PingMessage message = new PingMessage();
LocalBus.Publish(message);
consumer.ShouldHaveReceivedMessage(message, _timeout);
messageConsumer.ShouldNotHaveReceivedMessage(message, TimeSpan.FromSeconds(1));
}
public void It_should_leave_the_message_in_the_queue_if_an_exception_is_thrown()
{
var consumer = new TestSelectiveConsumer <PingMessage>(x => false);
RemoteBus.Subscribe(consumer);
var realConsumer = new TestMessageConsumer <PingMessage>();
LocalBus.Subscribe(realConsumer);
var message = new PingMessage();
LocalBus.Publish(message);
realConsumer.ShouldHaveReceivedMessage(message, _timeout);
consumer.ShouldNotHaveReceivedMessage(message, _timeout);
}
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");
}
protected void RunTest()
{
ObjectBuilder.Stub(x => x.GetInstance <TestBatchConsumer <IndividualBatchMessage, Guid> >())
.Return(new TestBatchConsumer <IndividualBatchMessage, Guid>());
RemoteBus.Subscribe <TestBatchConsumer <IndividualBatchMessage, Guid> >();
Guid batchId = Guid.NewGuid();
for (int i = 0; i < _batchSize; i++)
{
IndividualBatchMessage message = new IndividualBatchMessage(batchId, _batchSize);
LocalBus.Publish(message);
}
TestBatchConsumer <IndividualBatchMessage, Guid> .AnyShouldHaveReceivedBatch(batchId, _timeout);
}
// [ExpectedException(typeof(SemaphoreFullException))] //TODO: Bad Exception
public void The_batch_should_throw_an_error()
{
_batchSize = 1;
var timeoutConsumer = new TestMessageConsumer <BatchTimeout <IndividualBatchMessage, Guid> >();
RemoteBus.Subscribe(timeoutConsumer);
var batchConsumer = new TestBatchConsumer <IndividualBatchMessage, Guid>();
RemoteBus.Subscribe(batchConsumer);
Guid batchId = Guid.NewGuid();
IndividualBatchMessage message = new IndividualBatchMessage(batchId, _batchSize);
LocalBus.Publish(message);
LocalBus.Publish(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);
}