public void The_saga_should_be_subscribable()
{
var unsubscribeAction = LocalBus.Subscribe <CreateCustomerSaga>();
unsubscribeAction();
}
public void Multiple_Local_Services_Should_Be_Available()
{
ManualResetEvent _updateEvent = new ManualResetEvent(false);
LocalBus.Subscribe <UpdateMessage>(msg => _updateEvent.Set());
ManualResetEvent _deleteEvent = new ManualResetEvent(false);
LocalBus.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(4), true), Is.True,
"Timeout expired waiting for message");
Assert.That(_updateEvent.WaitOne(TimeSpan.FromSeconds(4), true), Is.True,
"Timeout expired waiting for message");
}
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");
}
protected override void EstablishContext()
{
base.EstablishContext();
_sagaId = Guid.NewGuid();
_repository = SetupSagaRepository <SimpleSaga>(ObjectBuilder);
_initiateSimpleSagaUnsubscribe = MockRepository.GenerateMock <UnsubscribeAction>();
_completeSimpleSagaUnsubscribe = MockRepository.GenerateMock <UnsubscribeAction>();
_subscriptionEvent = MockRepository.GenerateMock <ISubscriptionEvent>();
_subscriptionEvent.Expect(x => x.SubscribedTo <InitiateSimpleSaga>()).Repeat.Any().Return(() =>
{
_initiateSimpleSagaUnsubscribe();
return(true);
});
_subscriptionEvent.Expect(x => x.SubscribedTo <CompleteSimpleSaga>()).Repeat.Any().Return(() =>
{
_completeSimpleSagaUnsubscribe();
return(true);
});
LocalBus.InboundPipeline.Configure(x => x.Register(_subscriptionEvent));
_remove = LocalBus.Subscribe <SimpleSaga>();
PipelineViewer.Trace(LocalBus.InboundPipeline);
}
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 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 Perform_a_large_request_response_pool()
{
const int repeatCount = 20000;
int responsesReceived = 0;
ManualResetEvent completed = new ManualResetEvent(false);
LocalBus.Subscribe <PingMessage>(x => CurrentMessage.Respond(new PongMessage(x.CorrelationId)));
LocalBus.Subscribe <PongMessage>(x =>
{
if (Interlocked.Increment(ref responsesReceived) == repeatCount)
{
completed.Set();
}
});
Thread.Sleep(3.Seconds());
Stopwatch stopwatch = Stopwatch.StartNew();
for (int index = 0; index < repeatCount; index++)
{
LocalBus.Publish(new PingMessage());
}
bool success = completed.WaitOne(60.Seconds(), true);
stopwatch.Stop();
Trace.WriteLine(string.Format("Elapsed Time for {0} messages = {1}", repeatCount * 2, stopwatch.Elapsed));
Trace.WriteLine(string.Format("Messages Per Second = {0}", repeatCount * 2000 / stopwatch.ElapsedMilliseconds));
}
public void A_message_should_only_reach_the_consumer_if_the_filter_passes_it_forward()
{
MessageFilter <RequestMessage> filter = new MessageFilter <RequestMessage>(delegate { return(false); }, _consumer);
LocalBus.Subscribe(filter);
RemoteBus.Publish(_message);
Assert.That(_passed.WaitOne(TimeSpan.FromSeconds(1), true), Is.False, "Timeout waiting for message handler to be called");
}
protected override void EstablishContext()
{
base.EstablishContext();
ObjectBuilder
.Stub(x => x.GetInstance <OrderDetailsWebServiceProxy>())
.Return(new OrderDetailsWebServiceProxy());
LocalBus.Subscribe <OrderDetailsWebServiceProxy>();
}
protected override void EstablishContext()
{
base.EstablishContext();
_sagaId = Guid.NewGuid();
_repository = SetupSagaRepository <SimpleSaga>(ObjectBuilder);
LocalBus.Subscribe <SimpleSaga>();
}
public void A_simple_saga_exists_and_is_waiting_for_approval()
{
LocalBus.Subscribe <SimpleSaga>();
AddExistingSaga(SagaId, x =>
{
x.CustomerId = CustomerId;
x.SetCurrentState(SimpleSaga.WaitingForApproval);
});
}
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();
_sagaId = Guid.NewGuid();
_repository = SetupSagaRepository <SimpleSaga>(ObjectBuilder);
_remove = LocalBus.Subscribe <SimpleSaga>();
PipelineViewer.Trace(LocalBus.InboundPipeline);
}
public void It_should_be_received_by_one_subscribed_consumer_on_the_same_bus()
{
var consumer = new TestMessageConsumer <PingMessage>();
LocalBus.Subscribe(consumer);
var message = new PingMessage();
LocalBus.Publish(message);
consumer.ShouldHaveReceivedMessage(message, _timeout);
}
public void A_simple_bus_should_be_able_to_subscribe_and_publish()
{
TestMessageConsumer <PingMessage> consumer = new TestMessageConsumer <PingMessage>();
LocalBus.Subscribe(consumer);
PingMessage message = new PingMessage();
LocalBus.Publish(message);
consumer.ShouldHaveReceivedMessage(message, 500.Milliseconds());
}
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 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 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 Should_properly_register_the_consumers_for_each_endpoint()
{
var firstSub = new FirstSybsystem();
var secondSub = new SecondSubsystem();
LocalBus.Subscribe(firstSub);
LocalBus.Subscribe(secondSub);
Thread.Sleep(2500);
var inspector = new CorrelatedRouterPipelineInspector();
RemoteBus.OutboundPipeline.Inspect(inspector);
inspector.PipelineHasRightRoutings.ShouldBeTrue("OutboundPipeline on publisher should contains 'CorrelatedMessageSinkRouter' for IncomingMessage with 'FirstSybsystemCorrelationId' and 'SecondSubsystemCorrelationId' correlations id's.");
}
public void The_message_should_be_delivered_to_a_local_subscriber()
{
ManualResetEvent _updateEvent = new ManualResetEvent(false);
LocalBus.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 I_Should_be_able_to_subscribe()
{
Consumer c = new Consumer(LocalBus);
LocalBus.Subscribe(c);
SpecialGroup group = MessageGroup.Build <SpecialGroup>()
.Add(new PingMessage())
.Add(new PongMessage());
LocalBus.Publish(group);
Assert.That(c.Received.WaitOne(TimeSpan.FromSeconds(5), true), Is.True, "No message received by consumer");
}
public void The_response_address_should_pass()
{
FutureMessage <PingMessage> received = new FutureMessage <PingMessage>();
LocalBus.Subscribe <PingMessage>(message =>
{
Assert.AreEqual(LocalBus.Endpoint.Uri, CurrentMessage.Headers.ResponseAddress);
received.Set(message);
});
LocalBus.Publish(new PingMessage(), context => context.SendResponseTo(LocalBus));
Assert.IsTrue(received.IsAvailable(5.Seconds()), "No message was received");
}
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 The_batch_should_not_be_dispatched()
{
ObjectBuilder.Stub(x => x.GetInstance <TestBatchConsumer <IndividualBatchMessage, Guid> >())
.Return(new TestBatchConsumer <IndividualBatchMessage, Guid>());
LocalBus.Subscribe <TestBatchConsumer <IndividualBatchMessage, Guid> >();
Guid batchId = Guid.NewGuid();
const int batchLength = 0;
LocalBus.Publish(new IndividualBatchMessage(batchId, batchLength));
TestBatchConsumer <IndividualBatchMessage, Guid> .AnyShouldHaveReceivedBatch(batchId, 115.Seconds());
}
public void The_timeout_should_be_added_to_the_storage()
{
var _timedOut = new ManualResetEvent(false);
LocalBus.Subscribe <TimeoutExpired>(x => _timedOut.Set());
LocalBus.Publish(new ScheduleTimeout(_correlationId, 1.Seconds()));
Stopwatch watch = Stopwatch.StartNew();
Assert.IsTrue(_timedOut.WaitOne(TimeSpan.FromSeconds(5), true));
watch.Stop();
Debug.WriteLine(string.Format("Timeout took {0}ms", watch.ElapsedMilliseconds));
}
public void The_method_should_be_called_for_each_destination_endpoint()
{
LocalBus.Subscribe <PingMessage>(x => { });
var ping = new PingMessage();
List <Uri> consumers = new List <Uri>();
LocalBus.Publish(ping, x =>
{
x.ForEachSubscriber <PingMessage>((message, endpoint) => consumers.Add(endpoint.Uri));
});
Assert.AreEqual(1, consumers.Count);
Assert.AreEqual(LocalBus.Endpoint.Uri, consumers[0]);
}
public void The_exception_should_not_disrupt_the_flow_of_messages()
{
CrashingService service = new CrashingService();
LocalBus.Subscribe(service);
LocalEndpoint.Send(new BogusMessage());
CrashingService.Received.WaitOne(5.Seconds(), true).ShouldBeTrue("No message received");
CrashingService.Received.Reset();
LocalEndpoint.Send(new LegitMessage());
CrashingService.LegitReceived.WaitOne(5.Seconds(), true).ShouldBeTrue("No message received");
}
public void The_method_should_not_carry_over_to_the_next_call_context()
{
var ping = new PingMessage();
List <Uri> consumers = new List <Uri>();
LocalBus.Publish(ping, x =>
{
x.ForEachSubscriber <PingMessage>((message, endpoint) => consumers.Add(endpoint.Uri));
});
LocalBus.Subscribe <PingMessage>(x => { });
LocalBus.Publish(ping);
Assert.AreEqual(0, consumers.Count);
}
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 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);
}
