public void Ctor_should_properly_set_repository_property()
{
var mock = new Mock <IRepository>().Object;
var saga = new TestableSaga(mock);
Assert.Equal(mock, saga.Repository);
}
public async Task TestBasicSaga()
{
var testableSaga = new TestableSaga <ShippingPolicy, ShippingPolicyData>();
var placeResult = await testableSaga.Handle(new OrderPlaced { OrderId = "abc" });
var billResult = await testableSaga.Handle(new OrderBilled { OrderId = "abc" });
Assert.That(placeResult.Completed, Is.False);
Assert.That(billResult.Completed, Is.False);
// Snapshots of data should still be assertable even after multiple operations have occurred.
Assert.That(placeResult.SagaDataSnapshot.OrderId, Is.EqualTo("abc"));
Assert.That(placeResult.SagaDataSnapshot.Placed, Is.True);
Assert.That(placeResult.SagaDataSnapshot.Billed, Is.False);
var noResults = await testableSaga.AdvanceTime(TimeSpan.FromMinutes(10));
Assert.That(noResults.Length, Is.EqualTo(0));
var timeoutResults = await testableSaga.AdvanceTime(TimeSpan.FromHours(1));
Assert.That(timeoutResults.Length, Is.EqualTo(1));
var shipped = timeoutResults.First().FindPublishedMessage <OrderShipped>();
Assert.That(shipped.OrderId == "abc");
}
public async Task TestDealyedMessages()
{
var testableSaga = new TestableSaga <DelaySaga, Data>();
var corrId = Guid.NewGuid().ToString().Substring(0, 8);
var startResult = await testableSaga.Handle(new Start { CorrId = corrId });
Assert.That(startResult.Context.TimeoutMessages.Count, Is.EqualTo(1)); // Just timeout
Assert.That(startResult.Context.SentMessages.Count, Is.EqualTo(2)); // Both
Assert.That(startResult.SagaDataSnapshot.RegularTimeoutReceived, Is.False);
Assert.That(startResult.SagaDataSnapshot.DelayedCommandReceived, Is.False);
var timeout = startResult.FindTimeoutMessage <RegularTimeout>();
var delayed = startResult.FindSentMessage <DelayedCmd>();
Assert.That(timeout, Is.Not.Null);
Assert.That(delayed, Is.Not.Null);
Assert.That(delayed.CorrId, Is.EqualTo(corrId));
var timeoutResults = await testableSaga.AdvanceTime(TimeSpan.FromMinutes(30));
var timeoutResult = timeoutResults.Single();
Assert.That(timeoutResult.SagaDataSnapshot.RegularTimeoutReceived, Is.True);
Assert.That(timeoutResult.SagaDataSnapshot.DelayedCommandReceived, Is.False);
var delayedCmdResults = await testableSaga.AdvanceTime(TimeSpan.FromMinutes(30));
var delayedCmdResult = delayedCmdResults.Single();
Assert.That(delayedCmdResult.SagaDataSnapshot.RegularTimeoutReceived, Is.True);
Assert.That(delayedCmdResult.SagaDataSnapshot.DelayedCommandReceived, Is.True);
}
public void Ctor_should_properly_set_properties()
{
var bus = new Mock <IBus>().Object;
var repository = new Mock <IRepository>().Object;
var saga = new TestableSaga(bus, repository);
Assert.Equal(bus, saga.Bus);
Assert.Equal(repository, saga.Repository);
}
public async Task MarkStartedSagaAsComplete()
{
var saga = new TestableSaga <TestSaga, TestSagaData>();
var result = await saga.Handle(new StartSagaMessage()
{
CorrelationId = Guid.NewGuid()
});
Assert.IsTrue(result.Completed);
}
public async Task TestHeaderMappings()
{
var testableSaga = new TestableSaga <HeaderSaga, HeaderSagaData>();
var correlationId = Guid.NewGuid().ToString().Substring(0, 8);
var result = await testableSaga.Handle(new HeaderMessage(), messageHeaders : new Dictionary <string, string> {
{ "X-My-Correlation-Id", correlationId }
});
Assert.That(result.Completed, Is.False);
Assert.That(result.SagaDataSnapshot.CorrId, Is.EqualTo(correlationId));
Assert.That(result.SagaDataSnapshot.HeaderMessageReceived, Is.True);
}
public async Task ShouldEnqueueMessageForProcessing()
{
var testableSaga = new TestableSaga <MySaga, MyData>();
var startResult = await testableSaga.Handle(new StartMsg { CorrId = "abc" });
Assert.That(startResult.Context.SentMessages.Count, Is.EqualTo(1));
Assert.That(testableSaga.QueueLength, Is.EqualTo(1));
Assert.That(testableSaga.QueuePeek().Type, Is.EqualTo(typeof(SendToSelfCmd)));
var continueResult = await testableSaga.HandleQueuedMessage();
var doneEvt = continueResult.FindPublishedMessage <DoneEvent>();
Assert.That(doneEvt.CorrId, Is.EqualTo("abc"));
}
public async Task ExternalHandlerShouldSupplyReplyMessage()
{
var testableSaga = new TestableSaga <MySaga, MyData>();
testableSaga.SimulateReply <RunStep1Command, Step1Response>(cmd => new Step1Response());
var startResult = await testableSaga.Handle(new StartMsg { CorrId = "abc" });
Assert.That(startResult.Context.SentMessages.Count, Is.EqualTo(1));
Assert.That(testableSaga.QueueLength, Is.EqualTo(1));
Assert.That(testableSaga.QueuePeek().Type, Is.EqualTo(typeof(Step1Response)));
var continueResult = await testableSaga.HandleQueuedMessage();
var doneEvt = continueResult.FindPublishedMessage <DoneEvent>();
Assert.That(doneEvt.CorrId, Is.EqualTo("abc"));
}
public async Task TestReplyMessageApi()
{
var testableSaga = new TestableSaga <MySaga, MyData>();
var processId = Guid.NewGuid().ToString().Substring(0, 8);
var startResult = await testableSaga.Handle(new StartMsg { ProcessId = processId });
var step1Cmd = startResult.FindSentMessage <Step1Cmd>();
Assert.That(step1Cmd, Is.Not.Null);
Assert.That(startResult.SagaDataSnapshot.ReplyReceived, Is.False);
var sagaId = startResult.SagaId;
var endResult = await testableSaga.HandleReply(sagaId, new Step1Reply());
Assert.That(endResult.SagaDataSnapshot.ReplyReceived, Is.True);
}
public async Task TestWithDifferentCorrelationIds()
{
var testableSaga = new TestableSaga <ShippingPolicy, ShippingPolicyData>();
var placeResultA = await testableSaga.Handle(new OrderPlaced { OrderId = "abc" });
var billedResultB = await testableSaga.Handle(new OrderBilled { OrderId = "def" });
Assert.That(placeResultA.Completed, Is.False);
Assert.That(billedResultB.Completed, Is.False);
Assert.That(placeResultA.SagaId, Is.Not.EqualTo(billedResultB.SagaId));
var billedResultA = await testableSaga.Handle(new OrderBilled { OrderId = "abc" });
var shipped = billedResultA.FindPublishedMessage <OrderShipped>();
Assert.That(shipped.OrderId == "abc");
}
