protected override void DoSetUp()
{
sender = CreateBus(SenderInputQueueName, new HandlerActivatorForTesting()).Start(1);
recipientHandlers = new HandlerActivatorForTesting();
recipient = CreateBus(RecipientInputQueueName, recipientHandlers).Start(1);
}
protected override void DoSetUp()
{
// this one is in DMZ
pricedeskInputQueue = "test.pricedesk.input";
pricedesk = CreateBus(pricedeskInputQueue, new HandlerActivatorForTesting());
// and this one is inside
ordersystemInputQueue = "test.ordersystem.input";
orderSystemHandlerActivator = new HandlerActivatorForTesting();
ordersystem = CreateBus(ordersystemInputQueue, orderSystemHandlerActivator);
// so we set up a one-way gateway service on each side:
gatewayInDmz = new GatewayService
{
ListenQueue = "test.rebus.dmz.gateway",
DestinationUri = "http://localhost:18080",
};
gatewayInside = new GatewayService
{
ListenUri = "http://+:18080",
DestinationQueue = ordersystemInputQueue
};
gatewayInDmz.Start();
gatewayInside.Start();
pricedesk.Start(1);
ordersystem.Start(1);
}
public void AndItShouldNotDoThat()
{
var handlerActivator = new HandlerActivatorForTesting();
var pipelineInspector = new TrivialPipelineInspector();
var handleDeferredMessage = Mock<IHandleDeferredMessage>();
var dispatcher = new Dispatcher(new InMemorySagaPersister(),
handlerActivator,
new InMemorySubscriptionStorage(),
pipelineInspector,
handleDeferredMessage);
dispatcher.Dispatch(new TimeoutReply
{
CorrelationId = TimeoutReplyHandler.TimeoutReplySecretCorrelationId,
CustomData = TimeoutReplyHandler.Serialize(new Message { Id = "1" })
});
dispatcher.Dispatch(new TimeoutReply
{
CustomData = TimeoutReplyHandler.Serialize(new Message { Id = "2" })
});
handleDeferredMessage.AssertWasCalled(x => x.Dispatch(Arg<Message>.Is.Anything), x => x.Repeat.Once());
handleDeferredMessage.AssertWasCalled(x => x.Dispatch(Arg<Message>.Matches(y => y.Id == "1")));
}
public void AndItShouldNotDoThat()
{
var handlerActivator = new HandlerActivatorForTesting();
var pipelineInspector = new TrivialPipelineInspector();
var handleDeferredMessage = new MockDeferredMessageHandler();
var dispatcher = new Dispatcher(new InMemorySagaPersister(),
handlerActivator,
new InMemorySubscriptionStorage(),
pipelineInspector,
handleDeferredMessage,
null);
dispatcher.Dispatch(new TimeoutReply
{
CorrelationId = TimeoutReplyHandler.TimeoutReplySecretCorrelationId,
CustomData = TimeoutReplyHandler.Serialize(new Message { Id = "1" })
});
dispatcher.Dispatch(new TimeoutReply
{
CustomData = TimeoutReplyHandler.Serialize(new Message { Id = "2" })
});
handleDeferredMessage.DispatchedMessages.Count.ShouldBe(1);
var dispatchedMessage = handleDeferredMessage.DispatchedMessages[0];
dispatchedMessage.ShouldBeOfType<Message>();
((Message)dispatchedMessage).Id.ShouldBe("1");
}
public void AndItShouldNotDoThat()
{
var handlerActivator = new HandlerActivatorForTesting();
var pipelineInspector = new TrivialPipelineInspector();
var handleDeferredMessage = new MockDeferredMessageHandler();
var dispatcher = new Dispatcher(new InMemorySagaPersister(),
handlerActivator,
new InMemorySubscriptionStorage(),
pipelineInspector,
handleDeferredMessage);
dispatcher.Dispatch(new TimeoutReply
{
CorrelationId = TimeoutReplyHandler.TimeoutReplySecretCorrelationId,
CustomData = TimeoutReplyHandler.Serialize(new Message {
Id = "1"
})
});
dispatcher.Dispatch(new TimeoutReply
{
CustomData = TimeoutReplyHandler.Serialize(new Message {
Id = "2"
})
});
handleDeferredMessage.DispatchedMessages.Count.ShouldBe(1);
var dispatchedMessage = handleDeferredMessage.DispatchedMessages[0];
dispatchedMessage.ShouldBeTypeOf <Message>();
((Message)dispatchedMessage).Id.ShouldBe("1");
}
protected override void DoSetUp()
{
receiveMessages = new MessageReceiverForTesting(new JsonMessageSerializer());
handlerActivatorForTesting = new HandlerActivatorForTesting();
worker = CreateWorker(receiveMessages, handlerActivatorForTesting);
}
public void DoesNotReceiveTheSameMessageOverAndOver()
{
const string receiverInputQueueName = "rabbit.acktest.receiver";
var receivedNumbers = new ConcurrentBag <int>();
// arrange
var receiverHandler = new HandlerActivatorForTesting()
.Handle <Tuple <int> >(t => receivedNumbers.Add(t.Item1));
var receiver = CreateBus(receiverInputQueueName, receiverHandler);
var sender = CreateBus("rabbit.acktest.sender", new HandlerActivatorForTesting());
receiver.Start(1);
sender.Start(1);
// act
// assert
Thread.Sleep(0.5.Seconds());
Assert.That(receivedNumbers.Count, Is.EqualTo(0));
sender.Routing.Send(receiverInputQueueName, Tuple.Create(23));
Thread.Sleep(5.Seconds());
Assert.That(receivedNumbers.Count, Is.EqualTo(1), "Expected one single number in the bag - got {0}", string.Join(", ", receivedNumbers));
Assert.That(receivedNumbers, Contains.Item(23), "Well, just expected 23 to be there");
}
protected override void DoSetUp()
{
sender = CreateBus(SenderInputQueueName, new HandlerActivatorForTesting()).Start(1);
recipientHandlers = new HandlerActivatorForTesting();
recipient = CreateBus(RecipientInputQueueName, recipientHandlers).Start(1);
}
protected override void DoSetUp()
{
timeoutService = new TimeoutService(new InMemoryTimeoutStorage());
timeoutService.Start();
handlerActivator = new HandlerActivatorForTesting();
client = CreateBus("test.rebus.timeout.client", handlerActivator).Start(1);
}
protected override void DoSetUp()
{
receiveMessages = new MessageReceiverForTesting(new JsonMessageSerializer());
activateHandlers = new HandlerActivatorForTesting();
inspectHandlerPipeline = new RearrangeHandlersPipelineInspector();
worker = CreateWorker(receiveMessages, activateHandlers, inspectHandlerPipeline);
}
protected override void DoSetUp()
{
timeoutService = new TimeoutService(new InMemoryTimeoutStorage());
timeoutService.Start();
handlerActivator = new HandlerActivatorForTesting();
client = CreateBus("test.rebus.timeout.client", handlerActivator).Start(1);
}
protected override void DoSetUp()
{
persister = new SagaDataPersisterForTesting();
activator = new HandlerActivatorForTesting();
dispatcher = new Dispatcher(persister, activator,
new InMemorySubscriptionStorage(),
new TrivialPipelineInspector(),
new DeferredMessageHandlerForTesting());
}
public void MessageWithTimeToLiveWillDisappearFromErrorQueueAsWell()
{
// arrange
var senderBus = CreateBus(SenderQueueName, new HandlerActivatorForTesting()).Start(1);
var errorQueue = GetMessageQueue(ReceiverErrorQueueName);
var deadLetterQueue = GetMessageQueueFromPath(string.Format(@"FormatName:DIRECT=OS:{0}\SYSTEM$;DEADLETTER", Environment.MachineName));
var deadLetterQueue2 = GetMessageQueueFromPath(string.Format(@"FormatName:DIRECT=OS:{0}\SYSTEM$;DEADXACT", Environment.MachineName));
var activator = new HandlerActivatorForTesting()
.Handle <string>(s =>
{
throw new OmfgExceptionThisIsBad("whoahhh!");
});
CreateBus(ReceiverQueueName, activator, new InMemorySubscriptionStorage(), new SagaDataPersisterForTesting(),
ReceiverErrorQueueName).Start(1);
const string message = "HELLO!";
senderBus.AttachHeader(message, Headers.TimeToBeReceived, "00:00:02");
senderBus.Routing.Send(ReceiverQueueName, message);
Thread.Sleep(3.Seconds());
ReceivedTransportMessage transportMessage = null;
try
{
transportMessage = (ReceivedTransportMessage)errorQueue.Receive(3.Seconds()).Body;
}
catch (Exception e)
{
Console.WriteLine(e);
}
try
{
transportMessage = (ReceivedTransportMessage)deadLetterQueue.Receive(3.Seconds()).Body;
}
catch (Exception e)
{
Console.WriteLine(e);
}
try
{
transportMessage = (ReceivedTransportMessage)deadLetterQueue2.Receive(3.Seconds()).Body;
}
catch (Exception e)
{
Console.WriteLine(e);
}
transportMessage.ShouldBe(null);
}
protected override void DoSetUp()
{
activator = new HandlerActivatorForTesting();
pipelineInspector = new RearrangeHandlersPipelineInspector();
dispatcher = new Dispatcher(new InMemorySagaPersister(),
activator,
new InMemorySubscriptionStorage(),
pipelineInspector,
new DeferredMessageHandlerForTesting());
}
protected override void DoSetUp()
{
activator = new HandlerActivatorForTesting();
storeSagaData = Mock <IStoreSagaData>();
dispatcher = new Dispatcher(storeSagaData,
activator,
new InMemorySubscriptionStorage(),
new RearrangeHandlersPipelineInspector(),
new DeferredMessageHandlerForTesting());
}
public void MessageHandlingIsTransactional()
{
// arrange
const string senderQueue = "test.commitrollback.sender";
const string middlemanQueue = "test.commitrollback.middleman";
const string recipient1Queue = "test.commitrollback.recipient1";
const string recipient2Queue = "test.commitrollback.recipient2";
// sender
var sender = factory.CreateBus(senderQueue, new HandlerActivatorForTesting());
// middleman
var failCounter = 0;
var middlemanHandlerActivator = new HandlerActivatorForTesting();
var middleman = factory.CreateBus(middlemanQueue, middlemanHandlerActivator);
middlemanHandlerActivator.Handle <string>(str =>
{
failCounter++;
middleman.Advanced.Routing.Send(recipient1Queue, string.Format("mr. 1, this is my fail count: {0}", failCounter));
middleman.Advanced.Routing.Send(recipient2Queue, string.Format("mr. 2, this is my fail count: {0}", failCounter));
if (failCounter < 3)
{
throw new ApplicationException("oh noes!!!!");
}
});
// two recipients
var recipient1Received = new List <string>();
var recipient2Received = new List <string>();
factory.CreateBus(recipient1Queue, new HandlerActivatorForTesting().Handle <string>(recipient1Received.Add));
factory.CreateBus(recipient2Queue, new HandlerActivatorForTesting().Handle <string>(recipient2Received.Add));
factory.StartAll();
Thread.Sleep(0.5.Seconds());
// act
sender.Advanced.Routing.Send(middlemanQueue, "hello there my man!");
Thread.Sleep(2.Seconds());
// assert
failCounter.ShouldBe(3);
recipient1Received.ShouldBe(new List <string> {
"mr. 1, this is my fail count: 3"
});
recipient2Received.ShouldBe(new List <string> {
"mr. 2, this is my fail count: 3"
});
}
void CreateBus(string inputQueueName, HandlerActivatorForTesting handlerActivator)
{
var queue = factory.GetQueue(inputQueueName);
var bus = new RebusBus(handlerActivator, queue.Item1, queue.Item2, new InMemorySubscriptionStorage(),
new InMemorySagaPersister(),
this, new JsonMessageSerializer(), new TrivialPipelineInspector(),
new ErrorTracker(inputQueueName + ".error"));
disposables.Add(bus);
bus.Start();
}
protected override void DoSetUp()
{
handlerActivator = new HandlerActivatorForTesting();
bus = CreateBus("test.deferral", handlerActivator).Start(1);
timeoutService = new TimeoutService(new InMemoryTimeoutStorage());
timeoutService.Start();
RebusLoggerFactory.Current = new ConsoleLoggerFactory(false)
{
MinLevel = LogLevel.Warn
};
}
protected override void DoSetUp()
{
RebusLoggerFactory.Current = new ConsoleLoggerFactory(true) {MinLevel = LogLevel.Info};
receiveMessages = new MessageReceiverForTesting(new JsonMessageSerializer());
handlerActivatorForTesting = new HandlerActivatorForTesting();
unitOfWorkManager = new UnitOfWorkManagerForTesting();
worker = CreateWorker(receiveMessages, handlerActivatorForTesting,
unitOfWorkManagers: new IUnitOfWorkManager[] {unitOfWorkManager},
errorTracker: new ErrorTracker("error") {MaxRetries = 1});
}
public void PublishSubscribeWorks()
{
var publisherInputQueue = "test.publisher";
var publisherBus = CreateBus(publisherInputQueue, new HandlerActivatorForTesting()).Start();
var firstSubscriberResetEvent = new AutoResetEvent(false);
var secondSubscriberResetEvent = new AutoResetEvent(false);
var firstSubscriberInputQueue = "test.subscriber1";
var firstSubscriberHandlerFactory = new HandlerActivatorForTesting()
.Handle <string>(s =>
{
if (s == "hello peeps!")
{
firstSubscriberResetEvent.Set();
}
});
var firstSubscriberBus =
(RebusBus)CreateBus(firstSubscriberInputQueue, firstSubscriberHandlerFactory).Start();
firstSubscriberBus.Routing.Subscribe <string>(publisherInputQueue);
var secondSubscriberInputQueue = "test.subscriber2";
var secondSubscriberHandlerFactory = new HandlerActivatorForTesting()
.Handle <string>(s =>
{
if (s == "hello peeps!")
{
secondSubscriberResetEvent.Set();
}
});
var secondSubscriberBus =
(RebusBus)CreateBus(secondSubscriberInputQueue, secondSubscriberHandlerFactory).Start();
secondSubscriberBus.Routing.Subscribe <string>(publisherInputQueue);
// allow the publisher to receive the subscriptions....
Thread.Sleep(500);
publisherBus.Publish("hello peeps!");
if (!firstSubscriberResetEvent.WaitOne(TimeSpan.FromSeconds(3)))
{
Assert.Fail("First subscriber did not receive the event");
}
if (!secondSubscriberResetEvent.WaitOne(TimeSpan.FromSeconds(3)))
{
Assert.Fail("Second subscriber did not receive the event");
}
}
protected override void DoSetUp()
{
activateHandlers = new HandlerActivatorForTesting();
determineDestination = Mock <IDetermineDestination>();
sendMessages = Mock <ISendMessages>();
serializeMessages = new JsonMessageSerializer();
storeSagaData = Mock <IStoreSagaData>();
receiveMessages = new MessageReceiverForTesting(serializeMessages);
inspectHandlerPipeline = new TrivialPipelineInspector();
storeSubscriptions = Mock <IStoreSubscriptions>();
bus = CreateTheBus();
bus.Start();
}
protected override void DoSetUp()
{
activateHandlers = new HandlerActivatorForTesting();
determineMessageOwnership = Mock<IDetermineMessageOwnership>();
sendMessages = Mock<ISendMessages>();
serializeMessages = new JsonMessageSerializer();
storeSagaData = Mock<IStoreSagaData>();
receiveMessages = new MessageReceiverForTesting(serializeMessages);
inspectHandlerPipeline = new TrivialPipelineInspector();
storeSubscriptions = Mock<IStoreSubscriptions>();
bus = CreateTheBus();
bus.Start();
}
protected override void DoSetUp()
{
receiveMessages = new MessageReceiverForTesting(new JsonMessageSerializer());
handlerActivatorForTesting = new HandlerActivatorForTesting();
unitOfWorkManager = new UnitOfWorkManagerForTesting();
worker = CreateWorker(receiveMessages, handlerActivatorForTesting,
unitOfWorkManagers: new IUnitOfWorkManager[] { unitOfWorkManager },
errorTracker: new ErrorTracker("error")
{
MaxRetries = 1
});
}
protected override void DoSetUp()
{
receiveMessages = new MessageReceiverForTesting(new JsonMessageSerializer());
handlerActivatorForTesting = new HandlerActivatorForTesting();
worker = new Worker(new ErrorTracker("error"),
receiveMessages,
handlerActivatorForTesting,
new InMemorySubscriptionStorage(),
new JsonMessageSerializer(),
new InMemorySagaPersister(),
new TrivialPipelineInspector(), "Just some test worker",
new DeferredMessageHandlerForTesting());
}
protected override void DoSetUp()
{
var serializer = new JsonMessageSerializer();
receiveMessages = new MessageReceiverForTesting(serializer);
activateHandlers = new HandlerActivatorForTesting();
inspectHandlerPipeline = new RearrangeHandlersPipelineInspector();
worker = new Worker(new ErrorTracker("error"),
receiveMessages,
activateHandlers,
new InMemorySubscriptionStorage(),
serializer,
new SagaDataPersisterForTesting(),
inspectHandlerPipeline, "Just some test worker",
new DeferredMessageHandlerForTesting());
}
protected override void DoSetUp()
{
// this is the bus hosting the saga
sagaHandlerActivator = new HandlerActivatorForTesting();
sagaPersister = new InMemorySagaPersister();
sagaBus = CreateBus(SagaBusInputQueueName, sagaHandlerActivator, new InMemorySubscriptionStorage(), sagaPersister, "error").Start(1);
// this is the "service bus", i.e. just some request/reply-enabled service somewhere
serviceHandlerActivator = new HandlerActivatorForTesting();
serviceBus = CreateBus(ServiceBusInputQueueName, serviceHandlerActivator).Start(1);
// this is just a bus from the outside that can initiate everything
initiatorBus = CreateBus("test.autocorrelation.initiator", new HandlerActivatorForTesting()).Start(1);
timeoutService = new TimeoutService(new InMemoryTimeoutStorage());
timeoutService.Start();
}
protected override void DoSetUp()
{
RebusLoggerFactory.Current = new ConsoleLoggerFactory(true)
{
MinLevel = LogLevel.Info
};
receiveMessages = new MessageReceiverForTesting(new JsonMessageSerializer());
handlerActivatorForTesting = new HandlerActivatorForTesting();
unitOfWorkManager = new UnitOfWorkManagerForTesting();
worker = CreateWorker(receiveMessages, handlerActivatorForTesting,
unitOfWorkManagers: new IUnitOfWorkManager[] { unitOfWorkManager },
errorTracker: new ErrorTracker("error")
{
MaxRetries = 1
});
}
public void CanDoIt()
{
var resetEvent = new ManualResetEvent(false);
var stringMessageWasReceived = false;
var activator = new HandlerActivatorForTesting()
.Handle<string>(str =>
{
stringMessageWasReceived = true;
resetEvent.Set();
});
var bus = CreateBus(InputQueueName, activator).Start();
bus.Advanced.Routing.Send(InputQueueName + "@" + Environment.MachineName, "wolla my friend!");
resetEvent.WaitUntilSetOrDie(5.Seconds(), "Did not receive the message");
stringMessageWasReceived.ShouldBe(true);
}
protected override void DoSetUp()
{
RebusLoggerFactory.Current = new ConsoleLoggerFactory(false)
{
MinLevel = LogLevel.Info
};
// this one is in DMZ
priceDeskInputQueue = "test.pricedesk.input";
priceDeskHandlerActivator = new HandlerActivatorForTesting();
priceDesk = CreateBus(priceDeskInputQueue, priceDeskHandlerActivator);
// and this one is inside
orderSystemInputQueue = "test.ordersystem.input";
orderSystemHandlerActivator = new HandlerActivatorForTesting();
orderSystem = CreateBus(orderSystemInputQueue, orderSystemHandlerActivator);
priceDeskGatewayInputQueue = "test.rebus.pricedesk.gateway";
MsmqUtil.PurgeQueue(priceDeskGatewayInputQueue);
orderSystemGatewayInputQueue = "test.rebus.ordersystem.gateway";
MsmqUtil.PurgeQueue(orderSystemGatewayInputQueue);
// so we set up a one-way gateway service on each side:
// - the outbound is on the DMZ side
priceDeskGatewayService = new GatewayService
{
ListenQueue = priceDeskGatewayInputQueue,
DestinationUri = "http://localhost:" + TestCategories.AvailableHttpPort,
};
// and the inbound is on the network domain side
orderSystemGatewayService = new GatewayService
{
ListenUri = "http://+:" + TestCategories.AvailableHttpPort,
DestinationQueue = orderSystemInputQueue,
};
priceDeskGatewayService.Start();
orderSystemGatewayService.Start();
priceDesk.Start(1);
orderSystem.Start(1);
}
public void CanDoIt()
{
var resetEvent = new ManualResetEvent(false);
var stringMessageWasReceived = false;
var activator = new HandlerActivatorForTesting()
.Handle <string>(str =>
{
stringMessageWasReceived = true;
resetEvent.Set();
});
var bus = CreateBus(InputQueueName, activator).Start();
bus.Advanced.Routing.Send(InputQueueName + "@" + Environment.MachineName, "wolla my friend!");
resetEvent.WaitUntilSetOrDie(5.Seconds(), "Did not receive the message");
stringMessageWasReceived.ShouldBe(true);
}
protected override void DoSetUp()
{
DropCollection("sagas");
var msmqMessageQueue = new MsmqMessageQueue("test.dispatcher.and.mongo");
handlers = new HandlerActivatorForTesting().UseHandler(new MySaga());
var persister = new MongoDbSagaPersister(ConnectionString)
.SetCollectionName <MySagaData>("sagas");
bus = new RebusBus(handlers, msmqMessageQueue,
msmqMessageQueue, new InMemorySubscriptionStorage(),
persister,
null,
new JsonMessageSerializer(),
new TrivialPipelineInspector(),
new ErrorTracker("error"))
.Start(1);
}
protected override void DoSetUp()
{
RebusLoggerFactory.Current = new ConsoleLoggerFactory(false) { MinLevel = LogLevel.Info };
// this one is in DMZ
priceDeskInputQueue = "test.pricedesk.input";
priceDeskHandlerActivator = new HandlerActivatorForTesting();
priceDesk = CreateBus(priceDeskInputQueue, priceDeskHandlerActivator);
// and this one is inside
orderSystemInputQueue = "test.ordersystem.input";
orderSystemHandlerActivator = new HandlerActivatorForTesting();
orderSystem = CreateBus(orderSystemInputQueue, orderSystemHandlerActivator);
priceDeskGatewayInputQueue = "test.rebus.pricedesk.gateway";
MsmqUtil.PurgeQueue(priceDeskGatewayInputQueue);
orderSystemGatewayInputQueue = "test.rebus.ordersystem.gateway";
MsmqUtil.PurgeQueue(orderSystemGatewayInputQueue);
// so we set up a one-way gateway service on each side:
// - the outbound is on the DMZ side
priceDeskGatewayService = new GatewayService
{
ListenQueue = priceDeskGatewayInputQueue,
DestinationUri = "http://localhost:8080",
};
// and the inbound is on the network domain side
orderSystemGatewayService = new GatewayService
{
ListenUri = "http://+:8080",
DestinationQueue = orderSystemInputQueue,
};
priceDeskGatewayService.Start();
orderSystemGatewayService.Start();
priceDesk.Start(1);
orderSystem.Start(1);
}
public void RequestReplyWorks()
{
var requestorGotMessageEvent = new ManualResetEvent(false);
var requestorBus = CreateBus(RequestorQueueName,
new HandlerActivatorForTesting().Handle <string>(
str => requestorGotMessageEvent.Set()));
var replierHandlerFactory = new HandlerActivatorForTesting();
var replierBus = CreateBus(ReplierQueueName, replierHandlerFactory);
replierHandlerFactory.Handle <string>(str => replierBus.Reply("pong!"));
requestorBus.Start();
replierBus.Start();
requestorBus.Routing.Send(ReplierQueueName, "ping?");
if (!requestorGotMessageEvent.WaitOne(TimeSpan.FromSeconds(3)))
{
Assert.Fail("Requestor did not receive a reply within timeout");
}
}
public void ShouldWork()
{
var store = new EmbeddableDocumentStore
{
RunInMemory = true
};
store.Initialize();
var activator = new HandlerActivatorForTesting();
var checker = new CheckCallsMade();
var bus = CreateBus(Queue, activator, new InMemorySubscriptionStorage(), new RavenDbSagaPersister(store), "errors").Start(1);
activator.UseHandler(() => new TheSaga(bus, checker));
bus.Send(new TheFirstMessage());
Thread.Sleep(5000);
Assert.IsTrue(checker.First, "First should be called");
Assert.IsTrue(checker.Second, "Second should be called");
Assert.IsTrue(checker.Third, "Third should be called");
}
protected override void DoSetUp()
{
timeoutManagerFactory = new TTimeoutManagerFactory();
timeoutManagerFactory.Initialize(new TBusFactory());
handlerActivator = new HandlerActivatorForTesting();
bus = timeoutManagerFactory.CreateBus("test.deferral", handlerActivator);
var logFileName = string.Format("log-{0}-{1}.txt", typeof(TTimeoutManagerFactory).Name, typeof(TBusFactory).Name);
var logFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, logFileName);
if (File.Exists(logFilePath))
{
File.Delete(logFilePath);
}
RebusLoggerFactory.Current = new GhettoFileLoggerFactory(logFilePath)
.WithFilter(m => m.LoggerType == typeof(InMemoryTimeoutStorage));
timeoutManagerFactory.StartAll();
}
protected override void DoSetUp()
{
RebusLoggerFactory.Current = new ConsoleLoggerFactory(false)
{
MinLevel = LogLevel.Warn
};
// this one is in DMZ
pricedeskInputQueue = "test.pricedesk.input";
pricedesk = CreateBus(pricedeskInputQueue, new HandlerActivatorForTesting());
// and this one is inside
ordersystemInputQueue = "test.ordersystem.input";
orderSystemHandlerActivator = new HandlerActivatorForTesting();
ordersystem = CreateBus(ordersystemInputQueue, orderSystemHandlerActivator);
outboundListenQueue = "test.rebus.dmz.gateway";
MsmqUtil.PurgeQueue(outboundListenQueue);
// so we set up a one-way gateway service on each side:
// - the outbound is on the DMZ side
outbound = new GatewayService
{
ListenQueue = outboundListenQueue,
DestinationUri = "http://localhost:8080",
};
// and the inbound is on the network domain side
inbound = new GatewayService
{
ListenUri = "http://+:8080",
DestinationQueue = ordersystemInputQueue
};
outbound.Start();
inbound.Start();
pricedesk.Start(1);
ordersystem.Start(1);
}
public void CanDoIt()
{
var resetEvent = new ManualResetEvent(false);
var stringMessageWasReceived = false;
var activator = new HandlerActivatorForTesting()
.Handle<string>(str =>
{
stringMessageWasReceived = true;
resetEvent.Set();
});
var bus = CreateBus(InputQueueName, activator).Start();
bus.Advanced.Routing.Send(InputQueueName + "@" + Environment.MachineName, "wolla my friend!");
var timeout = TimeSpan.FromSeconds(5);
if (!resetEvent.WaitOne(timeout))
{
Assert.Fail("Did not received the message withing timeout of {0}", timeout);
}
stringMessageWasReceived.ShouldBe(true);
}
protected override void DoSetUp()
{
RebusLoggerFactory.Current = new ConsoleLoggerFactory(false)
{
MinLevel = LogLevel.Warn
};
MsmqUtil.Delete(PriceDeskInputQueue);
MsmqUtil.Delete(OrderSystemInputQueue);
MsmqUtil.Delete(GatewayListeningQueue);
// this one is in DMZ
pricedesk = CreateBus(PriceDeskInputQueue, new HandlerActivatorForTesting());
// and this one is inside
orderSystemHandlerActivator = new HandlerActivatorForTesting();
ordersystem = CreateBus(OrderSystemInputQueue, orderSystemHandlerActivator);
// so we set up a one-way gateway service on each side:
gatewayInDmz = new GatewayService
{
ListenQueue = GatewayListeningQueue,
DestinationUri = "http://localhost:18080",
};
gatewayInside = new GatewayService
{
ListenUri = "http://+:18080",
DestinationQueue = OrderSystemInputQueue
};
gatewayInDmz.Start();
gatewayInside.Start();
pricedesk.Start(1);
ordersystem.Start(1);
}
public void CanDoIt()
{
var resetEvent = new ManualResetEvent(false);
var stringMessageWasReceived = false;
var activator = new HandlerActivatorForTesting()
.Handle <string>(str =>
{
stringMessageWasReceived = true;
resetEvent.Set();
});
var bus = CreateBus(InputQueueName, activator).Start();
bus.Advanced.Routing.Send(InputQueueName + "@" + Environment.MachineName, "wolla my friend!");
var timeout = TimeSpan.FromSeconds(5);
if (!resetEvent.WaitOne(timeout))
{
Assert.Fail("Did not received the message withing timeout of {0}", timeout);
}
stringMessageWasReceived.ShouldBe(true);
}
public void RequestReplyWorks()
{
var requestorGotMessageEvent = new ManualResetEvent(false);
var requestorBus = CreateBus(RequestorQueueName,
new HandlerActivatorForTesting().Handle<string>(
str => requestorGotMessageEvent.Set()));
var replierHandlerFactory = new HandlerActivatorForTesting();
var replierBus = CreateBus(ReplierQueueName, replierHandlerFactory);
replierHandlerFactory.Handle<string>(str => replierBus.Reply("pong!"));
requestorBus.Start();
replierBus.Start();
requestorBus.Routing.Send(ReplierQueueName, "ping?");
if (!requestorGotMessageEvent.WaitOne(TimeSpan.FromSeconds(3)))
{
Assert.Fail("Requestor did not receive a reply within timeout");
}
}
protected override void DoSetUp()
{
receiveMessages = new MessageReceiverForTesting(new JsonMessageSerializer());
handlerActivatorForTesting = new HandlerActivatorForTesting();
unitOfWorkManager = new UnitOfWorkManagerForTesting();
worker = CreateWorker(receiveMessages, handlerActivatorForTesting,
unitOfWorkManagers: new IUnitOfWorkManager[] {unitOfWorkManager},
errorTracker: new ErrorTracker("error") {MaxRetries = 1});
}
protected override void DoSetUp()
{
RebusLoggerFactory.Current = new ConsoleLoggerFactory(false) { MinLevel = LogLevel.Warn };
// this one is in DMZ
pricedeskInputQueue = "test.pricedesk.input";
pricedesk = CreateBus(pricedeskInputQueue, new HandlerActivatorForTesting());
// and this one is inside
ordersystemInputQueue = "test.ordersystem.input";
orderSystemHandlerActivator = new HandlerActivatorForTesting();
ordersystem = CreateBus(ordersystemInputQueue, orderSystemHandlerActivator);
outboundListenQueue = "test.rebus.dmz.gateway";
MsmqUtil.PurgeQueue(outboundListenQueue);
// so we set up a one-way gateway service on each side:
// - the outbound is on the DMZ side
outbound = new GatewayService
{
ListenQueue = outboundListenQueue,
DestinationUri = "http://localhost:" + TestCategories.AvailableHttpPort,
};
// and the inbound is on the network domain side
inbound = new GatewayService
{
ListenUri = "http://+:" + TestCategories.AvailableHttpPort,
DestinationQueue = ordersystemInputQueue
};
outbound.Start();
inbound.Start();
pricedesk.Start(1);
ordersystem.Start(1);
}
protected override void DoSetUp()
{
// this one is in DMZ
pricedeskInputQueue = "test.pricedesk.input";
pricedesk = CreateBus(pricedeskInputQueue, new HandlerActivatorForTesting());
// and this one is inside
ordersystemInputQueue = "test.ordersystem.input";
orderSystemHandlerActivator = new HandlerActivatorForTesting();
ordersystem = CreateBus(ordersystemInputQueue, orderSystemHandlerActivator);
// so we set up a one-way gateway service on each side:
gatewayInDmz = new GatewayService
{
ListenQueue = "test.rebus.dmz.gateway",
DestinationUri = "http://localhost:18080",
};
gatewayInside = new GatewayService
{
ListenUri = "http://+:18080",
DestinationQueue = ordersystemInputQueue
};
gatewayInDmz.Start();
gatewayInside.Start();
pricedesk.Start(1);
ordersystem.Start(1);
}
protected override void DoSetUp()
{
receiveMessages = new MessageReceiverForTesting(new JsonMessageSerializer());
handlerActivatorForTesting = new HandlerActivatorForTesting();
unitOfWorkManager = new UnitOfWorkManagerForTesting();
worker = new Worker(new ErrorTracker("error") {MaxRetries = 1},
receiveMessages,
handlerActivatorForTesting,
new InMemorySubscriptionStorage(),
new JsonMessageSerializer(),
new InMemorySagaPersister(),
new TrivialPipelineInspector(), "Just some test worker",
new DeferredMessageHandlerForTesting(),
new IncomingMessageMutatorPipelineForTesting(),
null,
new IUnitOfWorkManager[] {unitOfWorkManager});
}
public void CanMoveMessageToErrorQueueForExceptionsInHooks(string whenToThrow)
{
// arrange
var senderBus = CreateBus(SenderQueueName, new HandlerActivatorForTesting()).Start(1);
var errorQueue = GetMessageQueue(ReceiverErrorQueueName);
var activator = new HandlerActivatorForTesting().Handle<string>(s => { });
var bus = CreateBus(ReceiverQueueName, activator,
new InMemorySubscriptionStorage(), new SagaDataPersisterForTesting(),
ReceiverErrorQueueName);
switch (whenToThrow)
{
case "beforeTransport":
bus.Events.BeforeTransportMessage += (_, __) =>
{
throw new Exception("HELLO!");
};
break;
case "afterTransport":
bus.Events.AfterTransportMessage += (_, __, ___) =>
{
throw new Exception("HELLO!");
};
break;
case "beforeLogical":
bus.Events.BeforeMessage += (_, __) =>
{
throw new Exception("HELLO!");
};
break;
case "afterLogical":
bus.Events.AfterMessage += (_, __, ___) =>
{
throw new Exception("HELLO!");
};
break;
case "poison":
// make sure the poison event gets raised
activator.Handle<string>(str =>
{
throw new Exception("HELLO!");
});
bus.Events.PoisonMessage += (_, __, ___) =>
{
throw new Exception("HELLO!");
};
break;
case "commitHook":
activator.Handle<string>(str => Transaction.Current
.EnlistVolatile(new ThingToEnlistThatWillFailOn(commit: true),
EnlistmentOptions.None));
break;
case "rollbackHook":
activator.Handle<string>(str =>
{
Transaction.Current
.EnlistVolatile(new ThingToEnlistThatWillFailOn(rollback: true),
EnlistmentOptions.None);
throw new Exception("HELLO!");
});
break;
case "prepareHook":
activator.Handle<string>(str => Transaction.Current
.EnlistVolatile(new ThingToEnlistThatWillFailOn(prepare: true),
EnlistmentOptions.None));
break;
case "inDoubtHook":
activator.Handle<string>(str => Transaction.Current
.EnlistVolatile(new ThingToEnlistThatWillFailOn(inDoubt: true),
EnlistmentOptions.None));
break;
}
bus.Start(1);
senderBus.Routing.Send(ReceiverQueueName, "HELLO!");
var transportMessage = (ReceivedTransportMessage)errorQueue.Receive(TimeSpan.FromSeconds(3)).Body;
var errorMessage = serializer.Deserialize(transportMessage);
errorMessage.Messages[0].ShouldBe("HELLO!");
errorMessage.GetHeader(Headers.SourceQueue).ShouldBe(ReceiverQueueName + "@" + Environment.MachineName);
errorMessage.GetHeader(Headers.ErrorMessage).ShouldContain("System.Exception: HELLO!");
}
public void MessageWithTimeToLiveWillDisappearFromErrorQueueAsWell()
{
// arrange
var senderBus = CreateBus(SenderQueueName, new HandlerActivatorForTesting()).Start(1);
var errorQueue = GetMessageQueue(ReceiverErrorQueueName);
var deadLetterQueue = GetMessageQueueFromPath(string.Format(@"FormatName:DIRECT=OS:{0}\SYSTEM$;DEADLETTER", Environment.MachineName));
var deadLetterQueue2 = GetMessageQueueFromPath(string.Format(@"FormatName:DIRECT=OS:{0}\SYSTEM$;DEADXACT", Environment.MachineName));
var activator = new HandlerActivatorForTesting()
.Handle<string>(s =>
{
throw new OmfgExceptionThisIsBad("whoahhh!");
});
CreateBus(ReceiverQueueName, activator, new InMemorySubscriptionStorage(), new SagaDataPersisterForTesting(),
ReceiverErrorQueueName).Start(1);
const string message = "HELLO!";
senderBus.AttachHeader(message, Headers.TimeToBeReceived, "00:00:02");
senderBus.Routing.Send(ReceiverQueueName, message);
Thread.Sleep(3.Seconds());
ReceivedTransportMessage transportMessage = null;
try
{
transportMessage = (ReceivedTransportMessage)errorQueue.Receive(3.Seconds()).Body;
}
catch (Exception e)
{
Console.WriteLine(e);
}
try
{
transportMessage = (ReceivedTransportMessage)deadLetterQueue.Receive(3.Seconds()).Body;
}
catch (Exception e)
{
Console.WriteLine(e);
}
try
{
transportMessage = (ReceivedTransportMessage)deadLetterQueue2.Receive(3.Seconds()).Body;
}
catch (Exception e)
{
Console.WriteLine(e);
}
transportMessage.ShouldBe(null);
}
protected override void DoSetUp()
{
RebusLoggerFactory.Current = new ConsoleLoggerFactory(false) { MinLevel = LogLevel.Warn };
MsmqUtil.Delete(PriceDeskInputQueue);
MsmqUtil.Delete(OrderSystemInputQueue);
MsmqUtil.Delete(GatewayListeningQueue);
// this one is in DMZ
pricedesk = CreateBus(PriceDeskInputQueue, new HandlerActivatorForTesting());
// and this one is inside
orderSystemHandlerActivator = new HandlerActivatorForTesting();
ordersystem = CreateBus(OrderSystemInputQueue, orderSystemHandlerActivator);
// so we set up a one-way gateway service on each side:
gatewayInDmz = new GatewayService
{
ListenQueue = GatewayListeningQueue,
DestinationUri = "http://localhost:18080",
};
gatewayInside = new GatewayService
{
ListenUri = "http://+:18080",
DestinationQueue = OrderSystemInputQueue
};
gatewayInDmz.Start();
gatewayInside.Start();
pricedesk.Start(1);
ordersystem.Start(1);
}
public void DoesNotReceiveTheSameMessageOverAndOver()
{
const string receiverInputQueueName = "rabbit.acktest.receiver";
var receivedNumbers = new ConcurrentBag<int>();
// arrange
var receiverHandler = new HandlerActivatorForTesting()
.Handle<Tuple<int>>(t => receivedNumbers.Add(t.Item1));
var receiver = CreateBus(receiverInputQueueName, receiverHandler);
var sender = CreateBus("rabbit.acktest.sender", new HandlerActivatorForTesting());
receiver.Start(1);
sender.Start(1);
// act
// assert
Thread.Sleep(0.5.Seconds());
Assert.That(receivedNumbers.Count, Is.EqualTo(0));
sender.Routing.Send(receiverInputQueueName, Tuple.Create(23));
Thread.Sleep(5.Seconds());
Assert.That(receivedNumbers.Count, Is.EqualTo(1), "Expected one single number in the bag - got {0}", string.Join(", ", receivedNumbers));
Assert.That(receivedNumbers, Contains.Item(23), "Well, just expected 23 to be there");
}
public void RebusRaisesEventsInAllTheRightPlacesWhenReceivingMessages()
{
var events = new List<string>();
var receiverHandlerActivator = new HandlerActivatorForTesting()
.Handle<string>(str =>
{
events.Add("Handling message: " + str);
if (str == "throw")
{
throw new ApplicationException("w00t!");
}
});
var receiver = CreateBus(ReceiverInputQueueName, receiverHandlerActivator).Start(1);
receiver.Events.BeforeTransportMessage += (b, m) => events.Add("Before message");
receiver.Events.AfterTransportMessage += (b, e, m) => events.Add(string.Format("After message: {0} - has context: {1}", e, MessageContext.HasCurrent));
receiver.Events.PoisonMessage += (b, m, i) => events.Add(string.Format("Poison! - {0} exceptions caught", i.Exceptions.Length));
var sender = CreateBus(SenderInputQueueName, new HandlerActivatorForTesting()).Start(1);
sender.Routing.Send(ReceiverInputQueueName, "test");
sender.Routing.Send(ReceiverInputQueueName, "throw");
Thread.Sleep(1.Seconds());
receiver.SetNumberOfWorkers(0);
Thread.Sleep(1.Seconds());
Console.WriteLine(@"------------------------------------------------
Events:
{0}
------------------------------------------------", string.Join(Environment.NewLine, events.Select(e =>
{
var str = e.Replace(Environment.NewLine, "////");
return str.Length > 80 ? str.Substring(0, 80) + "(...)" : str;
})));
var eventsPerOrdinaryMessage = 3;
var eventsToMovePoisonMessage = 1;
events.Count.ShouldBe(eventsPerOrdinaryMessage
+ 5 * eventsPerOrdinaryMessage
+ eventsToMovePoisonMessage);
events[0].ShouldBe("Before message");
events[1].ShouldBe("Handling message: test");
events[2].ShouldBe("After message: - has context: True");
events[3].ShouldBe("Before message");
events[4].ShouldBe("Handling message: throw");
events[5].ShouldStartWith("After message: ");
events[5].ShouldContain("System.ApplicationException: w00t!");
events[6].ShouldBe("Before message");
events[7].ShouldBe("Handling message: throw");
events[8].ShouldStartWith("After message: ");
events[8].ShouldContain("System.ApplicationException: w00t!");
events[9].ShouldBe("Before message");
events[10].ShouldBe("Handling message: throw");
events[11].ShouldStartWith("After message: ");
events[11].ShouldContain("System.ApplicationException: w00t!");
events[12].ShouldBe("Before message");
events[13].ShouldBe("Handling message: throw");
events[14].ShouldStartWith("After message: ");
events[14].ShouldContain("System.ApplicationException: w00t!");
events[15].ShouldBe("Before message");
events[16].ShouldBe("Handling message: throw");
events[17].ShouldStartWith("After message: ");
events[17].ShouldContain("System.ApplicationException: w00t!");
events[18].ShouldBe("Poison! - 5 exceptions caught");
}
public void PublishSubscribeWorks()
{
var publisherBus = CreateBus(PublisherInputQueue, new HandlerActivatorForTesting()).Start();
var firstSubscriberResetEvent = new AutoResetEvent(false);
var secondSubscriberResetEvent = new AutoResetEvent(false);
var firstSubscriberHandlerFactory = new HandlerActivatorForTesting()
.Handle<string>(s =>
{
if (s == "hello peeps!")
{
firstSubscriberResetEvent.Set();
}
});
var firstSubscriberBus =
CreateBus(FirstSubscriberInputQueue, firstSubscriberHandlerFactory).Start();
firstSubscriberBus.Routing.Subscribe<string>(PublisherInputQueue);
var secondSubscriberHandlerFactory = new HandlerActivatorForTesting()
.Handle<string>(s =>
{
if (s == "hello peeps!")
{
secondSubscriberResetEvent.Set();
}
});
var secondSubscriberBus =
CreateBus(SecondSubscriberInputQueue, secondSubscriberHandlerFactory).Start();
secondSubscriberBus.Routing.Subscribe<string>(PublisherInputQueue);
// allow the publisher to receive the subscriptions....
Thread.Sleep(500);
publisherBus.Publish("hello peeps!");
if (!firstSubscriberResetEvent.WaitOne(TimeSpan.FromSeconds(3)))
{
Assert.Fail("First subscriber did not receive the event");
}
if (!secondSubscriberResetEvent.WaitOne(TimeSpan.FromSeconds(3)))
{
Assert.Fail("Second subscriber did not receive the event");
}
}
public void RebusRaisesEventsInAllTheRightPlaces()
{
var events = new List<string>();
var receiverInputQueueName = "events.receiver";
var receiverHandlerActivator = new HandlerActivatorForTesting()
.Handle<string>(str =>
{
events.Add("Handling message: " + str);
if (str == "throw")
{
throw new ApplicationException("w00t!");
}
});
var receiver = CreateBus(receiverInputQueueName, receiverHandlerActivator).Start(1);
receiver.BeforeMessage += m => events.Add("Before message");
receiver.AfterMessage += (e, m) => events.Add("After message: " + e);
receiver.PoisonMessage += m => events.Add("Poison!");
var sender = CreateBus("events.sender", new HandlerActivatorForTesting()).Start(1);
sender.Send(receiverInputQueueName, "test");
sender.Send(receiverInputQueueName, "throw");
Thread.Sleep(500);
events.ForEach(Console.WriteLine);
var eventsPerOrdinaryMessage = 3;
var eventsToMovePoisonMessage = 3;
events.Count.ShouldBe(eventsPerOrdinaryMessage
+ 5 * eventsPerOrdinaryMessage
+ eventsToMovePoisonMessage);
events[0].ShouldBe("Before message");
events[1].ShouldBe("Handling message: test");
events[2].ShouldBe("After message: ");
events[eventsPerOrdinaryMessage].ShouldBe("Before message");
events[6].ShouldBe("Before message");
events[9].ShouldBe("Before message");
events[12].ShouldBe("Before message");
events[15].ShouldBe("Before message");
events[4].ShouldBe("Handling message: throw");
events[7].ShouldBe("Handling message: throw");
events[10].ShouldBe("Handling message: throw");
events[13].ShouldBe("Handling message: throw");
events[16].ShouldBe("Handling message: throw");
events[5].ShouldStartWith("After message: ");
events[5].ShouldContain("System.ApplicationException: w00t!");
events[8].ShouldStartWith("After message: ");
events[8].ShouldContain("System.ApplicationException: w00t!");
events[11].ShouldStartWith("After message: ");
events[11].ShouldContain("System.ApplicationException: w00t!");
events[14].ShouldStartWith("After message: ");
events[14].ShouldContain("System.ApplicationException: w00t!");
events[17].ShouldStartWith("After message: ");
events[17].ShouldContain("System.ApplicationException: w00t!");
events[18].ShouldBe("Before message");
events[19].ShouldBe("Poison!");
events[20].ShouldBe("After message: ");
}
