public void Should_contain_two_messages_should_be_correlated_by_tag_and_id()
{
Guid timeoutId = Guid.NewGuid();
LocalBus.Publish(new ScheduleTimeout(timeoutId, 10.Seconds(), 1));
TimeoutSaga firstTimeout = _timeoutSagaRepository.ShouldContainSaga(x => x.TimeoutId == timeoutId && x.Tag == 1);
firstTimeout.ShouldBeInState(TimeoutSaga.WaitingForTime);
LocalBus.Publish(new CancelTimeout {
CorrelationId = timeoutId, Tag = 1
});
LocalBus.Publish(new ScheduleTimeout(timeoutId, 10.Seconds(), 2));
TimeoutSaga secondTimeout = _timeoutSagaRepository.ShouldContainSaga(x => x.TimeoutId == timeoutId && x.Tag == 2);
secondTimeout.ShouldBeInState(TimeoutSaga.WaitingForTime);
firstTimeout.ShouldBeInState(TimeoutSaga.Completed);
Trace.WriteLine("Sagas:");
foreach (TimeoutSaga saga in _timeoutSagaRepository.Where(x => true))
{
Trace.WriteLine("Saga: " + saga.CorrelationId + ", TimeoutId: " + saga.TimeoutId + ", Tag: " + saga.Tag +
", State: " + saga.CurrentState.Name);
}
}
protected Task <Guid?> ShouldContainSaga(Guid correlatedId, State currentState)
{
var result = _sagaRepository.ShouldContainSaga(
x => x.ParentCorrelationId == correlatedId &&
MassTransitSagaHelper.GetCurrentState(x, _saga).Result == currentState,
TestTimeout);
return(result);
}
public async Task Should_cancel_when_the_order_is_submitted()
{
Task <ConsumeContext <CartRemoved> > handler = ConnectPublishHandler <CartRemoved>();
var memberNumber = NewId.NextGuid().ToString();
await InputQueueSendEndpoint.Send <CartItemAdded>(new { MemberNumber = memberNumber });
Guid?saga = await _repository.ShouldContainSaga(x => x.MemberNumber == memberNumber &&
GetCurrentState(x) == _machine.Active, TestTimeout);
Assert.IsTrue(saga.HasValue);
await InputQueueSendEndpoint.Send <OrderSubmitted>(new { MemberNumber = memberNumber });
ConsumeContext <CartRemoved> removed = await handler;
await Task.Delay(3000);
}
public async Task Calls_clearingApi()
{
var sagaId = Guid.NewGuid();
_clearingApi.ProcessRequest(Arg.Any <AuthorizationRequest>()).Returns(new AuthorizationResponse());
var req = await Bus.Request(InputQueueAddress, new AuthorizationRequest { TransactionId = sagaId }, x =>
{
x.Handle <AuthorizationResponse>();
x.Timeout = TestTimeout;
}, TestCancellationToken);
await req.Task;
var saga = await _repository.ShouldContainSaga(x => x.CorrelationId == sagaId, TestTimeout);
Assert.IsTrue(saga.HasValue);
_clearingApi.Received().ProcessRequest(Arg.Any <AuthorizationRequest>());
}
public async Task Should_properly_map_to_the_instance()
{
Guid id = NewId.NextGuid();
await Bus.Publish <BeginTransaction>(new
{
TransactionId = id
});
Guid?saga = await _repository.ShouldContainSaga(state => state.TransactionId == id && state.CurrentState == _machine.Active, TestTimeout);
Assert.IsTrue(saga.HasValue);
await Bus.Publish <CommitTransaction>(new
{
TransactionId = id
});
saga = await _repository.ShouldContainSaga(state => state.TransactionId == id && state.CurrentState == _machine.Final, TestTimeout);
Assert.IsTrue(saga.HasValue);
}
public async Task Should_cancel_when_the_order_is_submitted()
{
Task <ConsumeContext <CartRemoved> > handler = SubscribeHandler <CartRemoved>();
CartItemAdded cartItemAdded = new CartItemAddedCommand
{
MemberNumber = Guid.NewGuid().ToString()
};
await InputQueueSendEndpoint.Send(cartItemAdded);
Guid?saga = await _repository.ShouldContainSaga(x => x.MemberNumber == cartItemAdded.MemberNumber &&
GetCurrentState(x) == _machine.Active, TestTimeout);
Assert.IsTrue(saga.HasValue);
await InputQueueSendEndpoint.Send(new OrderSubmittedEvent(cartItemAdded.MemberNumber));
ConsumeContext <CartRemoved> removed = await handler;
await Task.Delay(3000);
}
public async Task Moves_saga_to_AuthorizationFlow_Pending()
{
var newCcDepositRequest = NewCcDepositRequest();
var req = await Bus.Request(InputQueueAddress, newCcDepositRequest, x =>
{
x.Handle <CcDepositResponse>();
x.Timeout = TestTimeout;
}, TestCancellationToken);
await req.Task;
await _repository.ShouldContainSaga(x => Equals(x.CurrentState, _machine.AuthorizationFlow.Pending), TestTimeout);
}
public async Task Should_handle_a_double_state()
{
Guid sagaId = Guid.NewGuid();
await Bus.Publish(new Start
{
CorrelationId = sagaId
});
Guid?saga = await _repository.ShouldContainSaga(sagaId, TestTimeout);
Assert.IsTrue(saga.HasValue);
await Bus.Publish(new Stop
{
CorrelationId = sagaId
});
saga =
await _repository.ShouldContainSaga(x => x.CorrelationId == sagaId && Equals(x.CurrentState, _machine.Final), TestTimeout);
Assert.IsTrue(saga.HasValue);
}
public async Task Should_report_from_diagnostic_source()
{
_telemetryClient.TrackTrace("Submitting Order");
var submitted = SubscribeHandler <OrderObserved>();
await Bus.Publish <SubmitOrder>(new { OrderId = InVar.Id }, x => x.ResponseAddress = Bus.Address);
var context = await submitted;
var saga = await _repository.ShouldContainSaga(x => x.CorrelationId == context.Message.OrderId && Equals(x.CurrentState, _machine.PendingApproval),
TestTimeout);
Assert.IsTrue(saga.HasValue);
}
public async Task Should_receive_the_published_message()
{
Task <ConsumeContext <StartupComplete> > messageReceived = SubscribeHandler <StartupComplete>();
var message = new Start("Joe");
await InputQueueSendEndpoint.Send(message);
ConsumeContext <StartupComplete> received = await messageReceived;
Assert.AreEqual(message.CorrelationId, received.Message.TransactionId);
Assert.IsTrue(received.InitiatorId.HasValue, "The initiator should be copied from the CorrelationId");
Assert.AreEqual(received.InitiatorId.Value, message.CorrelationId, "The initiator should be the saga CorrelationId");
Assert.AreEqual(received.SourceAddress, InputQueueAddress, "The published message should have the input queue source address");
Guid?saga =
await _repository.ShouldContainSaga(x => x.CorrelationId == message.CorrelationId && Equals(x.CurrentState, _machine.Running), TestTimeout);
Assert.IsTrue(saga.HasValue);
}
public void A_nice_interface_should_be_available_for_defining_saga_locators()
{
_repository.ShouldContainSaga(_sagaId);
}
