public async Task Should_create_a_state_instance()
{
// Arrange (Given)
var harness = new InMemoryTestHarness();
var fileHandlerStateMachine = new FileHandlerStateMachine();
var saga = harness.StateMachineSaga <FileHandlerState, FileHandlerStateMachine>(fileHandlerStateMachine);
await harness.Start();
try
{
var fileId = NewId.NextGuid();
await harness.Bus.Publish <FileInfoSubmitted>(new
{
FileId = fileId,
Timestamp = InVar.Timestamp,
FileName = "filename.file",
Folder = "c:/folder/"
});
var instanceID = await saga.Exists(fileId, x => x.Submitted);
var instance = saga.Sagas.Contains(instanceID.Value);
Assert.NotNull(instanceID);
Assert.True(saga.Created.Select(x => x.CorrelationId == fileId).Any());
}
finally
{
await harness.Stop();
}
}
public async Task Should_insert_new_state_instance_on_submitted()
{
var orderStateMachine = new OrderStateMachine();
var harness = new InMemoryTestHarness {
TestTimeout = TimeSpan.FromSeconds(5)
};
var saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(orderStateMachine);
await harness.Start();
try
{
var orderId = NewId.NextGuid();
await harness.Bus.Publish <IOrderSubmitted>(new
{
OrderId = orderId,
ExternalOrderId = "00000001"
});
Assert.That(saga.Created.Select(x => x.CorrelationId == orderId).Any(), Is.True);
var instanceId = await saga.Exists(orderId, x => x.Submitted);
Assert.That(instanceId, Is.Not.Null);
var instance = saga.Sagas.Contains(instanceId.Value);
Assert.That(instance.ExternalOrderId, Is.EqualTo("00000001"));
}
finally
{
await harness.Stop();
}
}
public SagaSampleStateMachineTests(DefaultWebHostTestFixture fixture, ITestOutputHelper output)
{
_testOffset = TimeSpan.Zero;
_harness = new InMemoryTestHarness();
_harness.OnConfigureInMemoryBus += ConfigureInMemoryBus;
var machine = new SagaSampleStateMachine();
_stateMachineSagaTestHarness = _harness.StateMachineSaga <SagaSampleInstanceState, SagaSampleStateMachine>(machine);
_harness.Start().Wait();
fixture.Output = output;
_client = fixture.CreateClient();
_fixture = fixture;
_output = output;
var inputQueueAddress = _harness.InputQueueAddress;
var requestClient = _harness.CreateRequestClient <SagaStatusRequestedEvent>();
MockedObjects.SagaStatusRequestClient.Setup(e => e.GetResponse <SagaStatus, SagaStatusNotFound>(It.IsAny <SagaStatusRequestedEvent>(), It.IsAny <CancellationToken>(), It.IsAny <RequestTimeout>()))
.Returns((SagaStatusRequestedEvent o, CancellationToken token, RequestTimeout timeout) =>
{
return(requestClient.GetResponse <SagaStatus, SagaStatusNotFound>(o));
});
MockedObjects.IPublishEndpoint.Setup(e => e.Publish(It.IsAny <SagaStartedEvent>(), It.IsAny <CancellationToken>()))
.Returns((SagaStartedEvent o, CancellationToken token) =>
{
return(_harness.Bus.Publish(o));
});
}
public async Task Should_handle_the_initial_state()
{
var harness = new InMemoryTestHarness();
StateMachineSagaTestHarness <Instance, TestStateMachine> saga = harness.StateMachineSaga <Instance, TestStateMachine>(_machine);
Guid sagaId = Guid.NewGuid();
await harness.Start();
try
{
await harness.InputQueueSendEndpoint.Send(new Start
{
CorrelationId = sagaId
});
Assert.IsTrue(harness.Consumed.Select <Start>().Any(), "Message not received");
Instance instance = saga.Created.Contains(sagaId);
Assert.IsNotNull(instance, "Saga instance not found");
Assert.AreEqual(instance.CurrentState, _machine.Running);
}
finally
{
await harness.Stop();
}
}
public async Task Should_create_a_state_instance()
{
var orderStateMachine = new OrderStateMachine();
var harness = new InMemoryTestHarness {
TestTimeout = TimeSpan.FromSeconds(5)
};
var saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(new OrderStateMachine());
await harness.Start();
try
{
var orderId = NewId.NextGuid();
await harness.Bus.Publish <OrderSubmitted>(new {
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = "123456"
});
var instance = saga.Created.Contains(orderId);
await saga.Exists(orderId, x => x.Submitted); //race condtion wait for state change
Assert.True(saga.Created.Select(x => x.CorrelationId == orderId).Any());
Assert.NotNull(instance);
Assert.Equal(orderStateMachine.Submitted.Name, instance.CurrentState);
}
finally
{
await harness.Stop();
}
}
public async Task Should_create_a_state_instance()
{
var orderStateMachine = new OrderStateMachine();
var harness = new InMemoryTestHarness();
var saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(orderStateMachine);
await harness.Start();
try
{
var orderId = NewId.NextGuid();
await harness.Bus.Publish <IOrderSubmitted>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = "12345"
});
Assert.That(saga.Created.Select(x => x.CorrelationId == orderId).Any(), Is.True);
var instanceId = await saga.Exists(orderId, x => x.Submitted);
Assert.That(instanceId, Is.Not.Null);
var instance = saga.Sagas.Contains(instanceId.Value);
Assert.That(instance.CustomerNumber, Is.EqualTo("12345"));
}
finally
{
await harness.Stop();
}
}
public async Task Should_respond_to_status_checks()
{
var harness = new InMemoryTestHarness();
var orderStateMachine = new OrderStateMachine();
var saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(orderStateMachine);
await harness.Start();
try
{
var orderId = NewId.NextGuid();
await harness.Bus.Publish <OrderSubmitted>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = customerNumber
});
Assert.That(saga.Created.Select(x => x.CorrelationId == orderId).Any(), Is.True);
var instanceId = await saga.Exists(orderId, x => x.Submitted);
Assert.That(instanceId, Is.Not.Null);
var requestClient = await harness.ConnectRequestClient <CheckOrder>();
var response = await requestClient.GetResponse <OrderStatus>(new
{
OrderId = orderId
});
Assert.That(response.Message.State, Is.EqualTo(orderStateMachine.Submitted.Name));
}
finally
{
await harness.Stop();
}
}
public async Task Test_thing()
{
var harness = new InMemoryTestHarness();
harness.OnConfigureInMemoryBus += Harness_OnConfigureInMemoryBus;
var saga = harness.StateMachineSaga(new TestSagaStateMachine(), new InMemorySagaRepository <TestSagaState>(), "saga");
var consumer = harness.Consumer <TestConsumer>("consumer");
await harness.Start();
try
{
var values = Enumerable.Range(0, 16).Select(i => Guid.NewGuid()).ToArray();
var response = await harness.Bus.Request <TestSagaRequest, TestSagaResponse>(new TestSagaRequest()
{
CorrelationId = Guid.NewGuid(), Values = values
});
response.Message.Values.Should().HaveCount(16);
}
finally
{
await harness.Stop();
}
}
public async Task Should_create_a_state_instance()
{
var harness = new InMemoryTestHarness();
StateMachineSagaTestHarness <OrderState, OrderStateMachine> saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(new OrderStateMachine());
await harness.Start();
try
{
Guid orderId = NewId.NextGuid();
await harness.Bus.Publish <OrderSubmitted>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = "12345"
});
Guid?instanceId = await saga.Exists(orderId, x => x.Submitted);
instanceId.Should().Be(orderId);
OrderState instance = saga.Sagas.Contains(instanceId.Value);
instance.CustomerNumber.Should().Be("12345");
}
finally
{
await harness.Stop();
}
}
public async Task Should_handle_the_stop_state()
{
var harness = new InMemoryTestHarness();
StateMachineSagaTestHarness <Instance, TestStateMachine> saga = harness.StateMachineSaga <Instance, TestStateMachine>(_machine);
var sagaId = Guid.NewGuid();
await harness.Start();
try
{
await harness.InputQueueSendEndpoint.Send(new Start { CorrelationId = sagaId });
await harness.InputQueueSendEndpoint.Send(new Stop { CorrelationId = sagaId });
Assert.IsTrue(harness.Consumed.Select <Start>().Any(), "Start not received");
Assert.IsTrue(harness.Consumed.Select <Stop>().Any(), "Stop not received");
var instance = saga.Created.ContainsInState(sagaId, _machine, _machine.Final);
Assert.IsNotNull(instance, "Saga instance not found");
}
finally
{
await harness.Stop();
}
}
public async Task SetUp()
{
_harness = new InMemoryTestHarness {
TestTimeout = TimeSpan.FromSeconds(5)
};
_orderStateMachine = new OrderStateMachine();
_saga = _harness.StateMachineSaga <OrderState, OrderStateMachine>(_orderStateMachine);
await _harness.Start();
}
public async Task InitializeTestHarness()
{
_harness = new InMemoryTestHarness();
_machine = new LifeStateMachine();
_sagaHarness = _harness.StateMachineSaga <LifeState, LifeStateMachine>(_machine);
// Note: This style can be used in old test environments, where InitializeTestHarness may not be async.
//_harness.Start().Wait();
await _harness.Start();
}
public StateMachine_Specs()
{
_sagaId = Guid.NewGuid();
_assemblyName = Assembly.GetExecutingAssembly().GetName().Name;
_harness = new InMemoryTestHarness();
_repository = new EventStoreSagaRepository <Instance>(EventStoreFixture.Connection);
var machine = new TestStateMachine();
_harness.StateMachineSaga(machine, _repository);
}
public virtual async Task BeforeEachTest()
{
TestHarness = new InMemoryTestHarness {
TestTimeout = TimeSpan.FromSeconds(4)
};
StateMachine = new GreetingsStateMachine();
SagaTestHarness =
TestHarness.StateMachineSaga <GreetingsState, GreetingsStateMachine>(StateMachine);
await TestHarness.Start();
}
public async Task Should_update_info_when_submitted_after_any_other_state()
{
var harness = new InMemoryTestHarness {
TestTimeout = TimeSpan.FromSeconds(3)
};
var orderStateMachine = new OrderStateMachine();
var saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(orderStateMachine);
await harness.Start();
try
{
var orderId = Guid.NewGuid();
await harness.Bus.Publish <OrderSubmittedEvent>(new
{
OrderId = orderId
});
var instance = await saga.Exists(orderId, x => x.Submitted);
instance.Should().NotBeNull();
await harness.Bus.Publish <OrderAcceptedEvent>(new
{
OrderId = orderId,
InVar.Timestamp,
});
instance = await saga.Exists(orderId, x => x.Accepted);
instance.Should().NotBeNull();
var timestamp = new DateTime(2020, 01, 01);
await harness.Bus.Publish <OrderSubmittedEvent>(new
{
OrderId = orderId,
CustomerNumber = "0987",
Timestamp = timestamp
});
instance = await saga.Exists(orderId, x => x.Accepted);
instance.Should().NotBeNull();
var data = saga.Sagas.Contains(orderId);
data.SubmitDate.Should().Be(timestamp);
data.CustomerNumber.Should().Be("0987");
}
finally
{
await harness.Stop();
}
}
public async Task LivingSearchStateMachine_Should_Be_Tested()
{
var config = new MessageBusConfig
{
PubmedParserQueueName = "pubmedParser",
PubmedSearchQueueName = "pubmedSearch",
RabbitMqConfig = new RabbitMqConfig
{
SchemeName = "rabbitmq",
Hostname = "localhost",
Username = "******",
Password = "******"
}
};
var machine = new LivingSearchStateMachine(config);
var harness = new InMemoryTestHarness();
var sagaHarness = harness.StateMachineSaga <LivingSearchState, LivingSearchStateMachine>(machine);
var saga = harness.Saga <LivingSearchState>();
await harness.Start();
try
{
Guid sagaId = NewId.NextGuid();
await harness.Bus.Publish <ILivingSearchEnabledOnProjectEvent>(new
{
ProjectId = default(Guid),
LivingSearchId = sagaId,
SearchString = default(string),
UpdateInterval = default(int),
BatchSize = default(int),
SearchEngineName = default(string),
SystematicSearchPrefix = default(string)
});
// did the endpoint consume the message
Assert.NotNull(harness.Sent);
Assert.True(harness.Consumed.Select <ILivingSearchEnabledOnProjectEvent>().Any());
// did the actual consumer consume the message
Assert.True(sagaHarness.Consumed.Select <ILivingSearchEnabledOnProjectEvent>().Any());
var instance = sagaHarness.Created.ContainsInState(sagaId, machine, machine.Initial);
Assert.NotNull(instance);
}
finally
{
await harness.Stop();
}
}
public StateMachine_Specs(EventStoreFixture fixture)
{
_fixture = fixture;
_sagaId = Guid.NewGuid();
_harness = new InMemoryTestHarness();
_repository = new EventStoreSagaRepository <Instance>(_fixture.Connection);
_machine = new TestStateMachine();
_saga = _harness.StateMachineSaga(_machine, _repository);
TaskUtil.Await(StartHarness);
}
public async Task Setup()
{
correlationId = Guid.NewGuid();
stateMachine = new GameStateMachine(new Mock <ILogger <GameStateMachine> >().Object,
Options.Create(new RabbitMQConfiguration
{
Endpoint = "rabbitmq://localhost"
}));
harness = new InMemoryTestHarness();
sagaTestHarness = harness.StateMachineSaga <GameSaga, GameStateMachine>(stateMachine);
await harness.Start();
}
public async Task Should_respond_when_file_deleted()
{
// Arrange (Given)
var harness = new InMemoryTestHarness();
var fileHandlerStateMachine = new FileHandlerStateMachine();
var saga = harness.StateMachineSaga <FileHandlerState, FileHandlerStateMachine>(fileHandlerStateMachine);
await harness.Start();
try
{
var fileId = NewId.NextGuid();
await harness.Bus.Publish <FileInfoSubmitted>(new
{
FileId = fileId,
Timestamp = InVar.Timestamp,
FileName = "filename.file",
Folder = "c:/folder/"
});
Assert.True(saga.Created.Select(x => x.CorrelationId == fileId).Any());
var instanceId = await saga.Exists(fileId, x => x.Submitted);
Assert.NotNull(instanceId);
var instance = saga.Sagas.Contains(instanceId.Value);
await harness.Bus.Publish <FileDeletedFromOriginFolder>(new
{
FileId = fileId,
FileName = "filename.file",
Folder = "c:/folder/"
});
instanceId = await saga.Exists(fileId, x => x.DeletedFromOriginFolder);
var requestClient = await harness.ConnectRequestClient <CheckFileInfo>();
var response = await requestClient.GetResponse <FileStatus>(new { FileId = fileId });
Assert.Equal(response.Message.State, fileHandlerStateMachine.DeletedFromOriginFolder.Name);
}
finally
{
await harness.Stop();
}
}
public async Task Should_create_a_state_instance()
{
var harness = new InMemoryTestHarness()
{
TestTimeout = TimeSpan.FromSeconds(1)
};
var orderStateMachine = new OrderStateMachine();
var saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(orderStateMachine);
await harness.Start();
var orderId = NewId.NextGuid();
var customerNumber = "1234";
try
{
// 아래는 "없는 걸" 테스트 하므로, Timeout 문제 발생함. 따라서 test harness에 timeout 을 주었다.
Assert.That(saga.Created.Select(x => x.CorrelationId == orderId).Any(), Is.False);
await harness.Bus.Publish <OrderSubmitted>(new
{
OrderId = orderId,
Timestamp = InVar.Timestamp,
CustomerNumber = customerNumber
});
Assert.That(saga.Created.Select(x => x.CorrelationId == orderId).Any(), Is.True);
// 비동기 코드에 대한 테스트는 항상 Race Condition이 있을 수 있다.
// 으래 코드는 `Task.Delay()` 가 없으면 실패한다. (테스트 코드가 실행되는 속도가 메시지 처리되는 속도 보다 빠르기 때문)
// await Task.Delay(TimeSpan.FromSeconds(1));
// var instance = saga.Created.Contains(orderId);
// Assert.That(instance, Is.Not.Null);
// Assert.That(instance.CurrentState, Is.EqualTo(orderStateMachine.Submitted.Name));
// 따라서, Masstransit Test Harness Saga 는 "특정 saga 가 특정 상태가 되기를 대기 하게 할 수 있다.
// orderId 의 correlation id 를 가지는 saga 가 submitted 상태에 있을 때 가지 대기
var instanceId = await saga.Exists(orderId, x => x.Submitted, timeout : null); // timeout 을 null 로 주면, Test harness의 TestTimeout 값이 사용됨.
Assert.That(instanceId, Is.Not.Null);
var instance = saga.Sagas.Contains(instanceId.Value);
Assert.That(instance.CustomerNumber, Is.EqualTo(customerNumber));
}
finally
{
await harness.Stop();
}
}
public void Test_BillingMessageMachine_SendMessage(string printJobName, string activityTypeCode, string issueSystemCode)
{
// arrange
var printJobService = MockRepository.GenerateMock <IPrintJobService>();
var logger = MockRepository.GenerateMock <IMessageLogger>();
var harness = new InMemoryTestHarness();
var machine = new BillingMessageMachine(printJobService, logger);
var saga = harness.StateMachineSaga <BillingMessageState, BillingMessageMachine>(machine);
printJobService
.Expect(p => p.GetPolicyTransactions("A123456", "58f31946b12b441892cd798973aab87e"))
.Return(Task.FromResult <string>(this.transactionStatusValidXml.ToString()));
printJobService
.Expect(p => p.PostPrintJobRequest(Arg.Is("A123456"), Arg.Is("00"), Arg.Is("1"), Arg.Is(printJobName), Arg <string> .Is.Anything, Arg.Is("58f31946b12b441892cd798973aab87e")))
.Return(Task.FromResult <string>("printed!"));
var accountActivity = new AccountActivity
{
ActivityTypeCode = activityTypeCode,
Policy = new Policy
{
PolicyNumber = "A123456",
Mod = "00",
IssueSystemCode = issueSystemCode
}
};
// act
harness.Start().Wait();
harness.Bus.Publish <IAccountActivity>(accountActivity).Wait();
// wait for the publish to do its thing, the Wait() above doesn't guarantee much.
var receivedMessage = harness.Consumed.Select <IAccountActivity>().FirstOrDefault();
// assert
printJobService.VerifyAllExpectations();
logger.VerifyAllExpectations();
receivedMessage.Exception.ShouldBeNull();
harness.Consumed.Count().ShouldEqual(1);
harness.Published.Count().ShouldEqual(1);
harness.Sent.Count().ShouldEqual(0);
saga.Consumed.Count().ShouldEqual(1);
// cleanup
harness.Stop().Wait();
}
public StateMachineSpecs(DynamoDbEventStoreFixture fixture)
{
_knownEventTypes = new KnownEventTypes();
_knownEventTypes.RegisterTypes(typeof(ProcessStarted), typeof(ProcessStopped), typeof(SomeStringAssigned));
_fixture = fixture;
_sagaId = Guid.NewGuid();
_harness = new InMemoryTestHarness();
_repository = new DynamoDbSagaRepository <Instance>(_fixture.Connection, _fixture.Options, _knownEventTypes);
_machine = new TestStateMachine();
_saga = _harness.StateMachineSaga(_machine, _repository);
TaskUtil.Await(StartHarness);
}
public async Task Should_be_cancelled_when_CustomerAccountClosed()
{
var harness = new InMemoryTestHarness()
{
TestTimeout = TimeSpan.FromSeconds(1)
};
var orderStateMachine = new OrderStateMachine();
var saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(orderStateMachine);
await harness.Start();
var orderId = NewId.NextGuid();
var customerNumber = "1234";
try
{
// 아래는 "없는 걸" 테스트 하므로, Timeout 문제 발생함. 따라서 test harness에 timeout 을 주었다.
Assert.That(saga.Created.Select(x => x.CorrelationId == orderId).Any(), Is.False);
await harness.Bus.Publish <OrderSubmitted>(new
{
OrderId = orderId,
Timestamp = InVar.Timestamp,
CustomerNumber = customerNumber
});
Assert.That(saga.Created.Select(x => x.CorrelationId == orderId).Any(), Is.True);
var instanceId = await saga.Exists(orderId, x => x.Submitted);
Assert.That(instanceId, Is.Not.Null);
await harness.Bus.Publish <CustomerAccountClosed>(new
{
//CustomerId = NewId.NextGuid(), // 상관없는 필드.
Timestamp = InVar.Timestamp,
CustomerNumber = customerNumber,
});
instanceId = await saga.Exists(orderId, x => x.Cancelled);
Assert.That(instanceId, Is.Not.Null);
}
finally
{
await harness.Stop();
}
}
public void Test_BillingMessageMachine_SendMessage_InvalidCode(string printJobName, string activityTypeCode, string issueSystemCode)
{
// arrange
var printJobService = MockRepository.GenerateMock <IPrintJobService>();
var logger = MockRepository.GenerateMock <IMessageLogger>();
var harness = new InMemoryTestHarness();
var machine = new BillingMessageMachine(printJobService, logger);
var saga = harness.StateMachineSaga <BillingMessageState, BillingMessageMachine>(machine);
var accountActivity = new AccountActivity
{
ActivityTypeCode = activityTypeCode,
Policy = new Policy
{
PolicyNumber = "A123456",
Mod = "00",
IssueSystemCode = issueSystemCode
}
};
// act
harness.Start().Wait();
harness.Bus.Publish <IAccountActivity>(accountActivity).Wait();
// wait for the publish to do its thing, the Wait() above doesn't guarantee much.
var receivedMessage = harness.Consumed.Select <IAccountActivity>().FirstOrDefault();
// assert
var message = logger.GetArgumentsForCallsMadeOn <IMessageLogger>(x => x.Log(Arg <Log> .Is.Anything, Arg <string> .Is.Null, Arg <string> .Is.Null, Arg <string> .Is.Null));
Log argumentLog = (Log)message[0][0];
LogMessage logMessage = argumentLog.Messages[0];
Assert.AreEqual(logMessage.Category, Constants.Logging.CATEGORY);
Assert.AreEqual(logMessage.Severity, SeverityType.Information);
printJobService.AssertWasNotCalled(p => p.GetPolicyTransactions(Arg <string> .Is.Anything, Arg <string> .Is.Anything));
printJobService.VerifyAllExpectations();
receivedMessage.Exception.ShouldBeNull();
harness.Consumed.Count().ShouldEqual(1);
harness.Published.Count().ShouldEqual(1);
harness.Sent.Count().ShouldEqual(0);
saga.Consumed.Count().ShouldEqual(1);
// cleanup
harness.Stop().Wait();
}
public async Task Should_cancel_order_when_account_closed()
{
var orderStateMachine = new OrderStateMachine();
var harness = new InMemoryTestHarness {
TestTimeout = TimeSpan.FromSeconds(2)
};
var saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(orderStateMachine);
await harness.Start();
try
{
var orderId = NewId.NextGuid();
const string customerNumber = "12345";
await harness.Bus.Publish <OrderSubmittedEvent>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = customerNumber
});
saga.Created.Select(x => x.CorrelationId == orderId).Any().Should().BeTrue();
var instanceId = await saga.Exists(orderId, x => x.Submitted);
instanceId.Should().NotBeNull();
await harness.Bus.Publish <CustomerAccountClosedEvent>(new
{
CustomerId = InVar.Id,
CustomerNumber = customerNumber
});
instanceId = await saga.Exists(orderId, x => x.Cancelled);
instanceId.Should().NotBeNull();
}
finally
{
await harness.Stop();
}
}
public async Task Should_respond_to_status_check_requested_event()
{
var harness = new InMemoryTestHarness {
TestTimeout = TimeSpan.FromSeconds(3)
};
var orderStateMachine = new OrderStateMachine();
var orderSaga = harness.StateMachineSaga <OrderState, OrderStateMachine>(orderStateMachine);
await harness.Start();
try
{
var orderId = NewId.NextGuid();
await harness.Bus.Publish <OrderSubmittedEvent>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = "1234"
});
orderSaga.Created
.Select(s => s.CorrelationId == orderId)
.Any()
.Should().BeTrue();
var instanceId = await orderSaga.Exists(orderId, s => s.Submitted);
instanceId.Should().NotBeNull();
var requestClient = await harness.ConnectRequestClient <CheckOrderRequestedEvent>();
var response = await requestClient.GetResponse <OrderStatusResponse>(new
{
OrderId = orderId
});
orderSaga.Consumed.Select <CheckOrderRequestedEvent>().Any().Should().BeTrue();
response.Message.State.Should().Be(orderStateMachine.Submitted.Name);
}
finally
{
await harness.Stop();
}
}
public async Task Should_accept_when_order_is_accepted()
{
var orderStateMachine = new OrderStateMachine();
var harness = new InMemoryTestHarness();
var saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(orderStateMachine);
EndpointConvention.Map <MyTestCommand>(new Uri("loopback://localhost/my-test-command"));
await harness.Start();
try
{
var orderId = NewId.NextGuid();
await harness.Bus.Publish <OrderSubmitted>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = "12345"
});
Assert.That(saga.Created.Select(x => x.CorrelationId == orderId).Any(), Is.True);
var instanceId = await saga.Exists(orderId, x => x.Submitted);
Assert.That(instanceId, Is.Not.Null);
await harness.Bus.Publish <OrderAccepted>(new
{
OrderId = orderId,
InVar.Timestamp,
});
instanceId = await saga.Exists(orderId, x => x.Accepted);
Assert.That(instanceId, Is.Not.Null);
}
finally
{
await harness.Stop();
}
}
public async Task Should_respond_to_status_check()
{
var harness = new InMemoryTestHarness()
{
TestTimeout = TimeSpan.FromSeconds(1)
};
var orderStateMachine = new OrderStateMachine();
var saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(orderStateMachine);
await harness.Start();
var orderId = NewId.NextGuid();
var customerNumber = "1234";
try
{
// 아래는 "없는 걸" 테스트 하므로, Timeout 문제 발생함. 따라서 test harness에 timeout 을 주었다.
Assert.That(saga.Created.Select(x => x.CorrelationId == orderId).Any(), Is.False);
await harness.Bus.Publish <OrderSubmitted>(new
{
OrderId = orderId,
Timestamp = InVar.Timestamp,
CustomerNumber = customerNumber
});
Assert.That(saga.Created.Select(x => x.CorrelationId == orderId).Any(), Is.True);
var requestClient = await harness.ConnectRequestClient <CheckOrder>();
var response = await requestClient.GetResponse <OrderStatus>(new
{
OrderId = orderId
});
Assert.That(response.Message.State, Is.EqualTo(orderStateMachine.Submitted.Name));
}
finally
{
await harness.Stop();
}
}
public async Task SubmitOrderConsumer_Accepted()
{
var orderStateMachine = new OrderStateMachine();
var harness = new InMemoryTestHarness();
var saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(orderStateMachine);
try
{
await harness.Start();
var orderId = NewId.NextGuid();
await harness.Bus.Publish <IOrderAcceptedEvent>(new
{
OrderId = orderId,
CreationDateTime = InVar.Timestamp,
Amount = 900
});
saga.Created.Select(x => x.CorrelationId == orderId).Any().Should().Be.True();
var correlationId = await saga.Exists(orderId, x => x.Created);
correlationId.HasValue.Should().Be.True();
var instance = saga.Sagas.Contains(correlationId.Value);
instance.CurrentState.Should().Be.EqualTo("Created");
instance.CorrelationId.Should().Be.EqualTo(orderId);
instance.Amount.Should().Be.EqualTo(900);
harness.Sent.Select <IRequestValidateOrder>().Any().Should().Be.True();
harness.Published.Select <IRequestValidateOrder>().Any().Should().Be.False();
}
finally
{
await harness.Stop();
}
}
public async Task Should_cancel_when_customer_account_closed()
{
var orderStateMachine = new OrderStateMachine();
var harness = new InMemoryTestHarness();
var saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(orderStateMachine);
await harness.Start();
try
{
var orderId = NewId.NextGuid();
await harness.Bus.Publish <IOrderSubmitted>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = "12345"
});
Assert.That(saga.Created.Select(x => x.CorrelationId == orderId).Any(), Is.True);
var instanceId = await saga.Exists(orderId, x => x.Submitted);
Assert.That(instanceId, Is.Not.Null);
await harness.Bus.Publish <ICustomerAccountClosed>(new
{
CustomerId = InVar.Id,
CustomerNumber = "12345"
});
instanceId = await saga.Exists(orderId, x => x.Canceled);
Assert.That(instanceId, Is.Not.Null);
}
finally
{
await harness.Stop();
}
}