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() { 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() { 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() { 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); }
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: "); }