public void WillCallBackAfterTimeHasElapsed()
{
var justSomeCorrelationId = Guid.NewGuid().ToString();
var justSomeSubCorrelationId = Guid.NewGuid().ToString();
client.Send(new TimeoutRequest
{
CorrelationId = justSomeCorrelationId,
CustomData = justSomeSubCorrelationId,
Timeout = 2.Seconds()
});
var timeoutExpired = false;
handlerActivator
.Handle <TimeoutReply>(m =>
{
Assert.AreEqual(justSomeCorrelationId, m.CorrelationId, "Correlation ID was wrong");
Assert.AreEqual(justSomeSubCorrelationId, m.CustomData, "Custom data was wrong");
timeoutExpired = true;
});
Thread.Sleep(2.5.Seconds());
timeoutExpired.ShouldBe(true);
}
public void CanMakeSimpleDeferralOfMessages()
{
// arrange
var messages = new List <Tuple <string, DateTime> >();
handlerActivator.Handle <MessageWithText>(m => messages.Add(new Tuple <string, DateTime>(m.Text, DateTime.UtcNow)));
var timeOfDeferral = DateTime.UtcNow;
var acceptedTolerance = 2.Seconds();
// act
bus.Defer(10.Seconds(), new MessageWithText {
Text = "deferred 10 seconds"
});
bus.Defer(5.Seconds(), new MessageWithText {
Text = "deferred 5 seconds"
});
Thread.Sleep(10.Seconds() + acceptedTolerance + acceptedTolerance);
// assert
messages.Count.ShouldBe(2);
messages[0].Item1.ShouldBe("deferred 5 seconds");
messages[0].Item2.ElapsedSince(timeOfDeferral).ShouldBeGreaterThan(5.Seconds() - acceptedTolerance);
messages[0].Item2.ElapsedSince(timeOfDeferral).ShouldBeLessThan(5.Seconds() + acceptedTolerance);
messages[1].Item1.ShouldBe("deferred 10 seconds");
messages[1].Item2.ElapsedSince(timeOfDeferral).ShouldBeGreaterThan(10.Seconds() - acceptedTolerance);
messages[1].Item2.ElapsedSince(timeOfDeferral).ShouldBeLessThan(10.Seconds() + acceptedTolerance);
}
public void CanPreserveCustomHeadersOnDeferredMessage()
{
// arrange
var deferredMessageReceived = new ManualResetEvent(false);
IDictionary <string, object> receivedHeaders = null;
handlerActivator.Handle <MessageWithText>(m =>
{
receivedHeaders = MessageContext.GetCurrent().Headers;
deferredMessageReceived.Set();
});
var message = new MessageWithText {
Text = "hello"
};
bus.AttachHeader(message, Headers.UserName, "joe");
bus.AttachHeader(message, "test-custom1", "bimmelim!");
bus.AttachHeader(message, "test-custom2", "w00t!");
// act
bus.Defer(1.Seconds(), message);
deferredMessageReceived.WaitUntilSetOrDie(3.Seconds());
// assert
receivedHeaders.ShouldNotBe(null);
receivedHeaders.ShouldContainKeyAndValue(Headers.UserName, "joe");
receivedHeaders.ShouldContainKeyAndValue("test-custom1", "bimmelim!");
receivedHeaders.ShouldContainKeyAndValue("test-custom2", "w00t!");
}
public void CanRequestReplyViaGateway()
{
// arrange
var resetEvent = new ManualResetEvent(false);
orderSystemHandlerActivator.Handle <JustSomeRequest>(req =>
{
Console.WriteLine("Got request for {0}", req.ForWhat);
orderSystem.Reply(new JustSomeReply {
What = "you got " + req.ForWhat
});
});
priceDeskHandlerActivator.Handle <JustSomeReply>(rep =>
{
Console.WriteLine("Got reply with {0}", rep.What);
resetEvent.Set();
});
// act
priceDesk.Send(new JustSomeRequest {
ForWhat = "beers!!!11 what else????"
});
// assert
var timeout = 5.Seconds();
Assert.That(resetEvent.WaitOne(timeout), Is.True, "Oh noes, reset event wasn't set within timeout of {0}", timeout);
}
public void DoesNotReturnTheSameTimeoutMultipleTimes()
{
// arrange
var receivedCorrelationIds = new List <string>();
var correlationIdWeCanRecognize = Guid.NewGuid().ToString();
handlerActivator.Handle <TimeoutReply>(reply => receivedCorrelationIds.Add(reply.CorrelationId));
// act
client.Send(new TimeoutRequest
{
CorrelationId = correlationIdWeCanRecognize,
Timeout = 2.Seconds(),
});
Thread.Sleep(5.Seconds());
// assert
receivedCorrelationIds.Count.ShouldBe(1);
}
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"
});
}
public void CanProperlyCommitUnitOfWork()
{
// arrange
handlerActivatorForTesting.Handle <string>(str => unitOfWorkManager.RegisterEvent("Handled message: " + str));
// act
receiveMessages.Deliver(MessageWith("hello there!"));
worker.Start();
Thread.Sleep(500);
worker.Stop();
// assert
unitOfWorkManager.Events
.ShouldBe(new[]
{
"Unit of work created: 1",
"Handled message: hello there!",
"1: committed",
"1: disposed",
});
}
public void PricedeskCanSendOrdersToOrdersystemViaGateway()
{
// arrange
var resetEvent = new ManualResetEvent(false);
orderSystemHandlerActivator.Handle <PlaceOrderRequest>(req =>
{
if (req.What == "beer" && req.HowMuch == 12)
{
resetEvent.Set();
}
});
var timeout = 5.Seconds();
// act
pricedesk.Send(new PlaceOrderRequest {
What = "beer", HowMuch = 12
});
// assert
Assert.That(resetEvent.WaitOne(timeout), Is.True, "Request was not received in order system within timeout of {0}", timeout);
}
public void IgnoresAutoCorrelationWhenCorrelationIsExplicitlySetUp(bool abandonReply)
{
// arrange
var anotherSaga = new AnotherSaga(sagaBus, abandonReply);
sagaHandlerActivator.UseHandler(anotherSaga);
serviceHandlerActivator.Handle <RequestWithCorrelationId>(req => serviceBus.Reply(new ReplyWithCorrelationId {
Correlationid = req.Correlationid
}));
// act
initiatorBus.Send(new InitiateRequestReply());
Thread.Sleep(3.Seconds());
// assert
sagaPersister.Count().ShouldBe(1);
var sagaData = sagaPersister.Single();
sagaData.ShouldBeTypeOf <SomeSagaData>();
((SomeSagaData)sagaData).GotTheReply.ShouldBe(!abandonReply);
}
public void SendersInputQueueUsesGlobalAddressing()
{
// arrange
var resetEvent = new ManualResetEvent(false);
var returnAddress = "";
recipientHandlers.Handle <string>(s =>
{
returnAddress = MessageContext.GetCurrent().ReturnAddress;
resetEvent.Set();
});
// act
sender.Routing.Send(RecipientInputQueueName, "yo dawg!!");
// assert
Assert.That(resetEvent.WaitOne(1.Seconds()), Is.True, "The message was not received withing timeout of 1 second");
returnAddress.ShouldBe(SenderInputQueueName + "@" + Environment.MachineName);
}
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 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 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 CanMoveMessageToErrorQueueForExceptionsInHooks(string whenToThrow)
{
// arrange
var senderBus = CreateBus(SenderQueueName, new HandlerActivatorForTesting()).Start(1);
var errorQueue = GetMessageQueue(ReceiverErrorQueueName);
var activator = new HandlerActivatorForTesting();
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;
}
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!");
}
