public void A_consumer_is_subscribed_to_a_message()
{
Consumer = new ConsumerOf <SimpleMessage>();
RemoteBus.SubscribeInstance(Consumer);
LocalBus.ShouldHaveSubscriptionFor <SimpleMessage>();
}
public void A_consumer_is_subscribed_to_a_message()
{
Consumer = new ConsumerOf<SimpleMessage>();
RemoteBus.SubscribeInstance(Consumer);
LocalBus.ShouldHaveRemoteSubscriptionFor<SimpleMessage>();
}
public void an_interface_based_message_is_published()
{
supertypeConsumer = new ConsumerOf <SpecialSwedishRat>();
subtypeConsumer = new ConsumerOf <SvenskSkogsråtta>();
var details = new AccountDetails();
PublisherBus = SetupServiceBus(details.BuildUri("When_publishing_subsuper_publisher"), cfg =>
{
cfg.SetPurgeOnStartup(true);
cfg.UseAzureServiceBusRouting();
});
SubscriberBus = SetupServiceBus(details.BuildUri("When_publishing_subtype_interfaces_single_publish_and_subscribing_supertype_subscriber"), cfg =>
{
cfg.SetPurgeOnStartup(true);
cfg.Subscribe(s =>
{
s.Instance(supertypeConsumer).Transient();
s.Instance(subtypeConsumer).Transient();
});
cfg.UseAzureServiceBusRouting();
});
// wait for the inbound transport to become ready before publishing
SubscriberBus.Endpoint.InboundTransport.Receive(c1 => c2 => { }, 1.Milliseconds());
PublisherBus.Publish <SpecialSwedishRat>(new DanneDenGråafläckigaRåttan
{
SoundsLike = "meeeäää",
GömmerSigIMyllan = true,
AnimalTag = new byte[] { 1, 2, 3 }
});
}
public async Task Fails_twice()
{
var cancellationToken = CancellationToken.None;
var message = MessageStub(1);
var messageHandler = new Mock <IMessageHandlerOf <PurchaseOrder> >();
messageHandler.SetupSequence(handler =>
handler.HandleAsync(It.IsAny <PurchaseOrder>(), It.IsAny <CancellationToken>()))
.ThrowsAsync(new Exception())
.ThrowsAsync(new Exception());
var mqConfiguration = _configuration.For <Configuration.RabbitMQ>();
_sut = new ConsumerOf <PurchaseOrder>(messageHandler.Object,
mqConfiguration, cancellationToken, Logger);
_sut.Start(Service.BootStrapBroker(mqConfiguration));
MessagePublish(message, mqConfiguration);
await Task.Delay(TimeSpan.FromSeconds(10), cancellationToken);
messageHandler.Verify(handler =>
handler.HandleAsync(It.Is <PurchaseOrder>(__ => __.Id == message.Id), cancellationToken),
Times.Exactly(2));
//The broker was dlx-ed with no errors
Assert.Equal(0U, GetMessageCount(Configuration.RabbitMQ.Queue(mqConfiguration)));
Assert.Equal(1U, GetMessageCount(Configuration.RabbitMQ.DlQueue(mqConfiguration)));
}
public void a_rat_is_sent_to_a_hungry_cat()
{
rat_id = CombGuid.Generate();
received_rat = new Future <Rat>();
cat = new ConsumerOf <Rat>(a_large_rat_actually =>
{
Console.WriteLine("Miaooo!!!");
Console.WriteLine(a_large_rat_actually.Sound + "!!!");
Console.WriteLine("Cat: chase! ...");
Console.WriteLine("*silence*");
Console.WriteLine("Cat: *Crunch chrunch*");
received_rat.Complete(a_large_rat_actually);
});
cat_nap_unsubscribes = RemoteBus.SubscribeInstance(cat);
// we need to make sure this bus is up before sending to it
RemoteBus.Endpoint.InboundTransport.Receive(ctx => c => { }, 4.Seconds());
LocalBus.GetEndpoint(RemoteUri).Send <Rat>(new
{
Sound = "Eeeek",
CorrelationId = rat_id
});
}
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_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_pong_service()
{
PingService = new ConsumerOf<Ping>(ping =>
{
// Response with a pong to the ping
RemoteBus.Context().Respond(new Pong(ping.CorrelationId));
});
RemoteBus.SubscribeInstance(PingService);
}
public void A_pong_service()
{
PingService = new ConsumerOf <Ping>(ping =>
{
// Response with a pong to the ping
RemoteBus.Context().Respond(new Pong(ping.CorrelationId));
});
RemoteBus.SubscribeInstance(PingService);
}
public void Publishing_to_a_remote_subscriber()
{
Consumer = new ConsumerOf <SimpleMessage>();
_unsubscribeAction = RemoteBus.SubscribeInstance(Consumer);
RemoteBus.ShouldHaveSubscriptionFor <SimpleMessage>();
LocalBus.ShouldHaveSubscriptionFor <SimpleMessage>();
_message = new SimpleMessage();
LocalBus.Publish(_message);
}
public void Subscribing_an_object_instance_to_the_bus()
{
_consumer = new ConsumerOf<PingMessage>();
object instance = _consumer;
_bus = ServiceBusFactory.New(x =>
{
x.ReceiveFrom("loopback://localhost/mt_test");
x.Subscribe(s => s.Instance(instance));
});
_ping = new PingMessage();
_bus.Publish(_ping);
}
public void Subscribing_an_object_instance_to_the_bus()
{
_consumer = new ConsumerOf <PingMessage>();
object instance = _consumer;
_bus = ServiceBusFactory.New(x =>
{
x.ReceiveFrom("loopback://localhost/mt_test");
x.Subscribe(s => s.Instance(instance));
});
_ping = new PingMessage();
_bus.Publish(_ping);
}
public void A_consumer_is_subscribed_to_a_message()
{
Consumer = new ConsumerOf<SimpleMessage>();
RemoteBus.Subscribe(Consumer);
}
public void A_consumer_is_subscribed_to_a_message()
{
Consumer = new ConsumerOf<SimpleMessage>();
LocalBus.SubscribeInstance(Consumer);
}
public void A_consumer_is_subscribed_to_a_message()
{
Consumer = new ConsumerOf <SimpleMessage>();
LocalBus.Subscribe(Consumer);
}
public void Should_have_received_the_message()
{
ConsumerOf <PingMessage> .AnyShouldHaveReceivedMessage(_ping, 12.Seconds());
}
