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 bool Visit <TMessage, TKey>(TestCorrelatedConsumer <TMessage, TKey> obj)
where TMessage : class, CorrelatedBy <Guid>
{
Trace.WriteLine(string.Format("TestCorrelatedConsumer<TMessage,TKey> - {0}({1})", typeof(TMessage).FullName, typeof(TKey).FullName));
return(true);
}
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 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 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 for_correlated_subscriptions_but_not_when_another_exists()
{
Guid pongGuid = Guid.NewGuid();
_subscriptionEvent.Expect(x => x.SubscribedTo <PongMessage, Guid>(pongGuid)).Repeat.Twice().Return(() =>
{
_unsubscribe();
return(true);
});
var consumer = new TestCorrelatedConsumer <PongMessage, Guid>(pongGuid);
var otherConsumer = new TestCorrelatedConsumer <PongMessage, Guid>(pongGuid);
var remove = _pipeline.Subscribe(consumer);
var removeOther = _pipeline.Subscribe(otherConsumer);
remove();
_subscriptionEvent.VerifyAllExpectations();
_unsubscribe.AssertWasNotCalled(x => x());
_unsubscribe.BackToRecord();
_unsubscribe.Replay();
removeOther();
_unsubscribe.AssertWasCalled(x => x());
}
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 It_should_be_received_by_an_interested_correlated_consumer()
{
PingMessage message = new PingMessage();
TestCorrelatedConsumer<PingMessage, Guid> consumer = new TestCorrelatedConsumer<PingMessage, Guid>(message.CorrelationId);
RemoteBus.SubscribeInstance(consumer);
LocalBus.Publish(message);
consumer.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_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 for_correlated_subscriptions()
{
Guid pongGuid = Guid.NewGuid();
_subscriptionEvent.Expect(x => x.SubscribedTo<PongMessage,Guid>(pongGuid)).Return(() =>
{
_unsubscribe();
return true;
});
var consumer = new TestCorrelatedConsumer<PongMessage, Guid>(pongGuid);
_pipeline.ConnectInstance(consumer);
_subscriptionEvent.VerifyAllExpectations();
}
public void for_correlated_subscriptions()
{
Guid pongGuid = Guid.NewGuid();
_subscriptionEvent.Expect(x => x.SubscribedTo <PongMessage, Guid>(pongGuid)).Return(() =>
{
_unsubscribe();
return(true);
});
var consumer = new TestCorrelatedConsumer <PongMessage, Guid>(pongGuid);
_pipeline.Subscribe(consumer);
_subscriptionEvent.VerifyAllExpectations();
}
public void A_reply_should_be_received_by_the_requestor()
{
ObjectBuilder.Stub(x => x.GetInstance<TestReplyService<PingMessage, Guid, PongMessage>>())
.Return(new TestReplyService<PingMessage, Guid, PongMessage> {Bus = RemoteBus});
RemoteBus.Subscribe<TestReplyService<PingMessage, Guid, PongMessage>>();
PingMessage message = new PingMessage();
TestCorrelatedConsumer<PongMessage, Guid> consumer = new TestCorrelatedConsumer<PongMessage, Guid>(message.CorrelationId);
LocalBus.Subscribe(consumer);
LocalBus.Publish(message);
TestConsumerBase<PingMessage>.AnyShouldHaveReceivedMessage(message, _timeout);
consumer.ShouldHaveReceivedMessage(new PongMessage(message.CorrelationId), _timeout);
}
public void A_reply_should_be_received_by_the_requestor()
{
RemoteBus.ShouldHaveRemoteSubscriptionFor<PingMessage>();
LocalBus.ShouldHaveRemoteSubscriptionFor<PingMessage>();
var message = new PingMessage();
var consumer = new TestCorrelatedConsumer<PongMessage, Guid>(message.CorrelationId);
LocalBus.SubscribeInstance(consumer);
RemoteBus.ShouldHaveRemoteSubscriptionFor<PongMessage>();
LocalBus.Publish(message);
TestConsumerBase<PingMessage>.AnyShouldHaveReceivedMessage(message, _timeout);
consumer.ShouldHaveReceivedMessage(new PongMessage(message.CorrelationId), _timeout);
}
public void A_reply_should_be_received_by_the_requestor()
{
RemoteBus.ShouldHaveRemoteSubscriptionFor <PingMessage>();
LocalBus.ShouldHaveRemoteSubscriptionFor <PingMessage>();
var message = new PingMessage();
var consumer = new TestCorrelatedConsumer <PongMessage, Guid>(message.CorrelationId);
LocalBus.SubscribeInstance(consumer);
RemoteBus.ShouldHaveRemoteSubscriptionFor <PongMessage>();
LocalBus.Publish(message);
TestConsumerBase <PingMessage> .AnyShouldHaveReceivedMessage(message, _timeout);
consumer.ShouldHaveReceivedMessage(new PongMessage(message.CorrelationId), _timeout);
}
public void Correlated_subscription_benchmark()
{
var consumer = new TestCorrelatedConsumer <PingMessage, Guid>(Guid.NewGuid());
UnsubscribeAction token = _pipeline.ConnectInstance(consumer);
token();
Stopwatch overall = Stopwatch.StartNew();
for (int i = 0; i < 10000; i++)
{
token = _pipeline.ConnectInstance(consumer);
token();
}
overall.Stop();
Trace.WriteLine("Elapsed Time: " + overall.Elapsed);
}
public void It_should_be_received_by_both_receivers()
{
PingMessage message = new PingMessage();
var remoteConsumer = new TestCorrelatedConsumer<PingMessage, Guid>(message.CorrelationId);
RemoteBus.Subscribe(remoteConsumer);
var localConsumer = new TestCorrelatedConsumer<PingMessage, Guid>(message.CorrelationId);
LocalBus.Subscribe(localConsumer);
// okay so a shared endpoint results in only one service bus in the process getting the message
LocalBus.Publish(message);
LocalBus.Publish(message);
remoteConsumer.ShouldHaveReceivedMessage(message, _timeout);
localConsumer.ShouldHaveReceivedMessage(message, _timeout);
}
public void It_should_be_received_by_both_receivers()
{
PingMessage message = new PingMessage();
var remoteConsumer = new TestCorrelatedConsumer <PingMessage, Guid>(message.CorrelationId);
RemoteBus.Subscribe(remoteConsumer);
var localConsumer = new TestCorrelatedConsumer <PingMessage, Guid>(message.CorrelationId);
LocalBus.Subscribe(localConsumer);
// okay so a shared endpoint results in only one service bus in the process getting the message
LocalBus.Publish(message);
LocalBus.Publish(message);
remoteConsumer.ShouldHaveReceivedMessage(message, _timeout);
localConsumer.ShouldHaveReceivedMessage(message, _timeout);
}
public void A_reply_should_be_received_by_the_requestor()
{
ObjectBuilder.Stub(x => x.GetInstance <TestReplyService <PingMessage, Guid, PongMessage> >())
.Return(new TestReplyService <PingMessage, Guid, PongMessage> {
Bus = RemoteBus
});
RemoteBus.Subscribe <TestReplyService <PingMessage, Guid, PongMessage> >();
PingMessage message = new PingMessage();
TestCorrelatedConsumer <PongMessage, Guid> consumer = new TestCorrelatedConsumer <PongMessage, Guid>(message.CorrelationId);
LocalBus.Subscribe(consumer);
LocalBus.Publish(message);
TestConsumerBase <PingMessage> .AnyShouldHaveReceivedMessage(message, _timeout);
consumer.ShouldHaveReceivedMessage(new PongMessage(message.CorrelationId), _timeout);
}
public void Correlated_subscriptions_should_make_happy_sounds()
{
var message = new PingMessage();
var consumer = new TestCorrelatedConsumer <PingMessage, Guid>(message.CorrelationId);
var negativeConsumer = new TestCorrelatedConsumer <PingMessage, Guid>(Guid.Empty);
var token = _pipeline.ConnectInstance(consumer);
token += _pipeline.ConnectInstance(negativeConsumer);
PipelineViewer.Trace(_pipeline);
_pipeline.Dispatch(message);
consumer.ShouldHaveReceivedMessage(message, 0.Seconds());
negativeConsumer.ShouldNotHaveReceivedMessage(message, 0.Seconds());
token();
PipelineViewer.Trace(_pipeline);
}
public void for_correlated_subscriptions_but_not_when_another_exists()
{
Guid pongGuid = Guid.NewGuid();
_subscriptionEvent.Expect(x => x.SubscribedTo<PongMessage, Guid>(pongGuid)).Repeat.Twice().Return(() =>
{
_unsubscribe();
return true;
});
var consumer = new TestCorrelatedConsumer<PongMessage, Guid>(pongGuid);
var otherConsumer = new TestCorrelatedConsumer<PongMessage, Guid>(pongGuid);
var remove = _pipeline.Subscribe(consumer);
var removeOther = _pipeline.Subscribe(otherConsumer);
remove();
_subscriptionEvent.VerifyAllExpectations();
_unsubscribe.AssertWasNotCalled(x => x());
_unsubscribe.BackToRecord();
_unsubscribe.Replay();
removeOther();
_unsubscribe.AssertWasCalled(x => x());
}
public void Correlated_subscriptions_should_make_happy_sounds()
{
PingMessage message = new PingMessage();
TestCorrelatedConsumer<PingMessage, Guid> consumer = new TestCorrelatedConsumer<PingMessage, Guid>(message.CorrelationId);
TestCorrelatedConsumer<PingMessage, Guid> negativeConsumer = new TestCorrelatedConsumer<PingMessage, Guid>(Guid.Empty);
var token = _pipeline.Subscribe(consumer);
token += _pipeline.Subscribe(negativeConsumer);
PipelineViewer.Trace(_pipeline);
_pipeline.Dispatch(message);
consumer.ShouldHaveReceivedMessage(message, 0.Seconds());
negativeConsumer.ShouldNotHaveReceivedMessage(message, 0.Seconds());
token();
PipelineViewer.Trace(_pipeline);
}
public void Correlated_subscription_benchmark()
{
TestCorrelatedConsumer<PingMessage, Guid> consumer = new TestCorrelatedConsumer<PingMessage, Guid>(Guid.NewGuid());
UnsubscribeAction token = _pipeline.Subscribe(consumer);
token();
Stopwatch overall = Stopwatch.StartNew();
for (int i = 0; i < 10000; i++)
{
token = _pipeline.Subscribe(consumer);
token();
}
overall.Stop();
Trace.WriteLine("Elapsed Time: " + overall.Elapsed);
}
public void It_should_not_be_received_by_an_uninterested_correlated_consumer()
{
TestCorrelatedConsumer<PingMessage, Guid> consumer = new TestCorrelatedConsumer<PingMessage, Guid>(Guid.NewGuid());
RemoteBus.SubscribeInstance(consumer);
PingMessage message = new PingMessage();
LocalBus.Publish(message);
consumer.ShouldNotHaveReceivedMessage(message, _timeout);
}
