public void A_consumer_is_subscribed_to_a_message()
{
Consumer = new ConsumerOf <SimpleMessage>();
RemoteBus.SubscribeInstance(Consumer);
LocalBus.ShouldHaveRemoteSubscriptionFor <SimpleMessage>();
}
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());
}
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()));
}
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);
}
protected override void EstablishContext()
{
base.EstablishContext();
LocalBus.ShouldHaveRemoteSubscriptionFor <PingMessage>();
_pingReceived = new FutureMessage <PingMessage>();
}
public void Should_not_remove_any_existing_subscriptions()
{
RemoteBus.SubscribeHandler <A>(x => { });
RemoteBus.Dispose();
ThreadUtil.Sleep(2.Seconds());
LocalBus.ShouldHaveRemoteSubscriptionFor <A>();
}
public void Should_remove_any_previous_subscriptions()
{
RemoteBus.SubscribeHandler <A>(x => { });
RemoteBus.ShouldHaveSubscriptionFor <A>();
LocalBus.ShouldHaveRemoteSubscriptionFor <A>();
RemoteBus.Dispose();
ThreadUtil.Sleep(2.Seconds());
SetupRemoteBus();
LocalBus.ShouldNotHaveSubscriptionFor <A>();
}
public void The_system_should_be_ready_to_use_before_getting_underway()
{
var consumer = new TestMessageConsumer <PingMessage>();
var unsubscribeAction = RemoteBus.SubscribeInstance(consumer);
LocalBus.ShouldHaveRemoteSubscriptionFor <PingMessage>();
var message = new PingMessage();
LocalBus.Publish(message);
consumer.ShouldHaveReceivedMessage(message, 8.Seconds());
unsubscribeAction();
}
private void SetupHealthService()
{
_healthSagaHealthSagaRepository = SetupSagaRepository <HealthSaga>();
HealthService = new HealthService(RemoteBus, _healthSagaHealthSagaRepository);
HealthService.Start();
Thread.Sleep(500);
LocalBus.ShouldHaveRemoteSubscriptionFor <EndpointCameOnline>();
LocalBus.ShouldHaveRemoteSubscriptionFor <Heartbeat>();
LocalBus.ShouldHaveRemoteSubscriptionFor <EndpointWentOffline>();
LocalBus.ShouldHaveRemoteSubscriptionFor <TimeoutExpired>();
LocalBus.ShouldHaveRemoteSubscriptionFor <PingEndpointResponse>();
}
public void Removing_a_subscription_twice_should_not_have_a_negative_impact()
{
Guid clientId = CombGuid.Generate();
Uri clientUri = new Uri("loopback://localhost/monster_beats");
var subscription = new SubscriptionInformation(clientId, 1, typeof(PingMessage), RemoteBus.Endpoint.Address.Uri);
LocalControlBus.Endpoint.Send(new AddSubscriptionClient(clientId, clientUri, clientUri));
LocalControlBus.Endpoint.Send(new AddSubscription(subscription));
LocalBus.ShouldHaveRemoteSubscriptionFor <PingMessage>();
LocalControlBus.Endpoint.Send(new RemoveSubscription(subscription));
LocalControlBus.Endpoint.Send(new RemoveSubscription(subscription));
LocalBus.ShouldNotHaveSubscriptionFor <PingMessage>();
}
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 Should_create_outbound_sink_for_route()
{
var address = new Uri("loopback://localhost/test_target");
var configurator = new RoutingConfigurator();
configurator.Route <PingMessage>().To(address);
configurator.Route <PongMessage>().To(address);
IBusService busService = configurator.Create(LocalBus);
busService.Start(LocalBus);
LocalBus.ShouldHaveRemoteSubscriptionFor <PingMessage>();
LocalBus.ShouldHaveRemoteSubscriptionFor <PongMessage>();
busService.Stop();
LocalBus.ShouldNotHaveSubscriptionFor <PingMessage>();
busService.Dispose();
}
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);
}
public void Should_have_a_subscription_for_the_pending_command()
{
LocalBus.ShouldHaveRemoteSubscriptionFor <FirstPending>();
}
public void Should_have_a_subscription_for_the_first_command()
{
LocalBus.ShouldHaveRemoteSubscriptionFor <FirstCommand>();
}
