public async Task ShouldSendResponseToBrokerWhenUserJwtIsValid()
{
object expectedErrors = null;
Guid expectedBody = Guid.Empty;
await harness.Start();
try
{
var requestClient = await harness.ConnectRequestClient <ICheckTokenRequest>();
var response = await requestClient.GetResponse <IOperationResult <Guid> >(new
{
UserJwt = userJwt
});
Assert.IsTrue(response.Message.IsSuccess);
Assert.AreEqual(expectedErrors, response.Message.Errors);
Assert.AreEqual(expectedBody, response.Message.Body);
Assert.IsTrue(consumerTestHarness.Consumed.Select <ICheckTokenRequest>().Any());
}
finally
{
await harness.Stop();
}
}
public async Task Should_Respond_With_Rejected_If_Test()
{
//assert
var orderId = NewId.NextGuid();
var customerNumber = "TEST123";
var requestClient = await _harness.ConnectRequestClient <SubmitOrder>();
//act
var response = await requestClient.GetResponse <OrderSubmissionRejected>(new OrderSubmissionRejected()
{
OrderId = orderId,
Timestamp = InVar.Timestamp,
CustomerNumber = customerNumber
});
await _harness.InputQueueSendEndpoint.Send <SubmitOrder>(new SubmitOrder
{
OrderId = orderId,
Timestamp = InVar.Timestamp,
CustomerNumber = customerNumber
});
//assert
response.Message.OrderId.Should().Be(orderId);
_consumer.Consumed.Select <SubmitOrder>().Any().Should().BeTrue();
_harness.Sent.Select <OrderSubmissionRejected>().Any().Should().BeTrue();
}
public async Task Should_Respond_To_Status_Checks()
{
//arrange
var orderId = NewId.NextGuid();
var customerNumber = "12345";
//act
await _harness.Bus.Publish <OrderSubmitted>(new OrderSubmitted
{
OrderId = orderId,
Timestamp = InVar.Timestamp,
CustomerNumber = customerNumber
});
//assert
_saga.Created.Select(x => x.CorrelationId == orderId).Any().Should().BeTrue();
var instanceId = await _saga.Exists(orderId, x => x.Submitted);
instanceId.Should().NotBeNull();
var requestClient = await _harness.ConnectRequestClient <CheckOrder>();
var response = await requestClient.GetResponse <OrderStatus>(new OrderStatus
{
OrderId = orderId
});
response.Message.State.Should().Be(_orderStateMachine.Submitted.Name);
}
public async Task Should_respond_with_rejected_if_test_customer_number()
{
var harness = new InMemoryTestHarness();
var consumer = harness.Consumer <SubmitOrderConsumer>();
await harness.Start();
try
{
var orderId = NewId.NextGuid();
var requestClient = await harness.ConnectRequestClient <ISubmitOrder>();
var response = await requestClient.GetResponse <OrderSubmissionRejected>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = customerNumberFail
});
Assert.That(response.Message.OrderId, Is.EqualTo(orderId));
Assert.That(consumer.Consumed.Select <ISubmitOrder>().Any(), Is.True);
Assert.That(harness.Sent.Select <OrderSubmissionRejected>().Any(), Is.True);
}
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 Should_response_with_accept_if_test_user_DO_NOT_TEST_THIS()
{
var harness = new InMemoryTestHarness();
var consumer = harness.Consumer <SubmitOrderConsumer>();
await harness.Start();
try
{
var orderId = NewId.NextGuid();
var requestClient = await harness.ConnectRequestClient <SubmitOrder>();
var response = await requestClient.GetResponse <OrderSubmissionAccepted>(new
{
OrderId = orderId,
Timestamp = InVar.Timestamp,
CustomerNumber = "TEST",
});
Assert.That(response.Message.OrderId, Is.EqualTo(orderId));
Assert.That(consumer.Consumed.Select <SubmitOrder>().Any(), Is.True);
// 시스템이 OrderSubmissionRejected 를 전송했는지 확인.
Assert.That(harness.Sent.Select <OrderSubmissionAccepted>().Any(), Is.True);
}
finally
{
await harness.Stop();
}
}
public async Task Should_respond_with_acceptance_if_ok()
{
var harness = new InMemoryTestHarness();
var consumer = harness.Consumer <SubmitOrderConsumer>();
await harness.Start();
try
{
var orderId = NewId.NextGuid();
var requestClient = await harness.ConnectRequestClient <SubmitOrder>();
var response = await requestClient.GetResponse <OrderSubmissionAccepted>(new {
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = "12345"
});
await harness.InputQueueSendEndpoint.Send <SubmitOrder>(new {
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = "12345"
});
Assert.Equal(response.Message.OrderId, orderId);
Assert.True(consumer.Consumed.Select <SubmitOrder>().Any());
Assert.True(harness.Sent.Select <OrderSubmissionAccepted>().Any());
}
finally
{
await harness.Stop();
}
}
public async Task SubmitOrderConsumer_Accepted()
{
var harness = new InMemoryTestHarness();
harness.Consumer <SubmitOrderConsumer>();
try
{
await harness.Start();
var orderId = NewId.NextGuid();
var requestClientSubmitOrder = await harness.ConnectRequestClient <ISubmitOrder>();
var(accepted, rejected) =
await requestClientSubmitOrder.GetResponse <IOrderAccepted, IOrderRejected>(new
{
OrderId = orderId,
Amount = 900
});
harness.Consumed.Select <ISubmitOrder>().Any().Should().Be.True();
accepted.IsCompletedSuccessfully.Should().Be.True();
rejected.IsCompletedSuccessfully.Should().Be.False();
harness.Published.Select <IOrderAcceptedEvent>().Any().Should().Be.True();
}
finally
{
await harness.Stop();
}
}
public async Task Should_respond_with_acceptance_if_ok()
{
var harness = new InMemoryTestHarness();
var consumer = harness.Consumer <SubmitOrderConsumer>();
await harness.Start();
try
{
var orderId = NewId.NextGuid();
// use this for request/response scenarios
var requestClient = await harness.ConnectRequestClient <SubmitOrderCommand>();
var response = await requestClient.GetResponse <OrderSubmissionAcceptedResponse>(new
{
OrderId = orderId,
InVar.Timestamp,
Customer = "1234"
});
response.Message.OrderId.IsSameOrEqualTo(orderId);
consumer.Consumed.Select <SubmitOrderCommand>().Any().Should().BeTrue();
harness.Sent.Select <OrderSubmissionAcceptedResponse>().Any().Should().BeTrue();
// harness.Published.Select<OrderSubmittedEvent>().Any().Should().BeTrue();
}
finally
{
await harness.Stop();
}
}
public async Task Should_respond_with_rejected_if_test()
{
var harness = new InMemoryTestHarness {
TestTimeout = TimeSpan.FromSeconds(3)
};
var consumer = harness.Consumer <SubmitOrderConsumer>();
await harness.Start();
try
{
var orderId = NewId.NextGuid();
// use this for request/response scenarios
var requestClient = await harness.ConnectRequestClient <SubmitOrderCommand>();
var response = await requestClient.GetResponse <OrderSubmissionRejectedResponse>(new
{
OrderId = orderId,
InVar.Timestamp,
Customer = "TEST1234"
});
response.Message.OrderId.IsSameOrEqualTo(orderId);
consumer.Consumed.Select <SubmitOrderCommand>().Any().Should().BeTrue();
harness.Sent.Select <OrderSubmissionRejectedResponse>().Any().Should().BeTrue();
}
finally
{
await harness.Stop();
}
}
public async Task Should_respond_with_rejection_if_test_file()
{
// Arrange (Given)
var harness = new InMemoryTestHarness();
var consumer = harness.Consumer <SubmitFileInfoConsumer>();
await harness.Start();
try
{
var fileId = NewId.NextGuid();
var requestClient = await harness.ConnectRequestClient <SubmitFileInfo>();
// Act (When)
var response = await requestClient.GetResponse <FileInfoSubmissionRejected>(new
{
FileId = fileId,
InVar.Timestamp,
FileName = "TEST.file",
Folder = "c:/folder/"
});
// Assert (Then)
Assert.Equal <Guid>(response.Message.FileId, fileId);
Assert.True(consumer.Consumed.Select <SubmitFileInfo>().Any());
Assert.True(harness.Sent.Select <FileInfoSubmissionRejected>().Any());
}
finally
{
await harness.Stop();
}
}
public async Task Should_consume_submit_order_commands()
{
var harness = new InMemoryTestHarness()
{
TestTimeout = TimeSpan.FromSeconds(5)
};
var consumer = harness.Consumer <SubmitOrderConsumer>();
await harness.Start();
try
{
var orderId = NewId.NextGuid();
var requestClient = await harness.ConnectRequestClient <ISubmitOrder>();
await harness.InputQueueSendEndpoint.Send <ISubmitOrder>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = customerNumber
});
Assert.That(consumer.Consumed.Select <ISubmitOrder>().Any(), Is.True);
Assert.That(harness.Sent.Select <OrderSubmissionAccepted>().Any(), Is.False);
Assert.That(harness.Sent.Select <OrderSubmissionRejected>().Any(), Is.False);
}
finally
{
await harness.Stop();
}
}
public async Task Should_publish_order_submitted_event()
{
var harness = new InMemoryTestHarness()
{
};
var consumer = harness.Consumer <SubmitOrderConsumer>();
await harness.Start();
try
{
var orderId = NewId.NextGuid();
var requestClient = await harness.ConnectRequestClient <ISubmitOrder>();
await harness.InputQueueSendEndpoint.Send <ISubmitOrder>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = customerNumber
});
Assert.That(harness.Published.Select <OrderSubmitted>().Any(), Is.True);
}
finally
{
await harness.Stop();
}
}
public async Task Should_respond_with_rejected_if_customer_is_test()
{
var harness = new InMemoryTestHarness();
ConsumerTestHarness <SubmitOrderConsumer> consumer = harness.Consumer <SubmitOrderConsumer>();
await harness.Start();
try
{
Guid orderId = NewId.NextGuid();
IRequestClient <SubmitOrder> requestClient = await harness.ConnectRequestClient <SubmitOrder>();
Response <OrderSubmissionRejected> response = await requestClient.GetResponse <OrderSubmissionRejected>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = "TEST12345"
});
// assert
response.Message.OrderId.Should().Be(orderId);
consumer.Consumed.Select <SubmitOrder>().Should().NotBeNullOrEmpty();
harness.Sent.Select <OrderSubmissionRejected>().Should().NotBeNullOrEmpty();
}
finally
{
await harness.Stop();
}
}
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_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_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 Should_respond_to_status_checks()
{
var harness = new InMemoryTestHarness();
var orderStateMachine = new OrderStateMachine();
StateMachineSagaTestHarness <OrderState, OrderStateMachine> saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(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);
var requestClient = await harness.ConnectRequestClient <CheckOrder>();
var response = await requestClient.GetResponse <OrderStatus>(new
{
OrderId = orderId
});
response.Message.State.Should().Be(orderStateMachine.Submitted.Name);
}
finally
{
await harness.Stop();
}
}
public async Task Should_respond_to_status_checks()
{
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
var requestClient = await harness.ConnectRequestClient <CheckOrder>();
var response = await requestClient.GetResponse <OrderStatus>(new { OrderId = orderId });
Assert.Equal(orderStateMachine.Submitted.Name, response.Message.State);
}
finally
{
await harness.Stop();
}
}
public async Task Should_respond_to_status_checks()
{
// 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);
var requestClient = await harness.ConnectRequestClient <CheckFileInfo>();
var response = await requestClient.GetResponse <FileStatus>(new { FileId = fileId });
Assert.Equal(response.Message.State, fileHandlerStateMachine.Submitted.Name);
}
finally
{
await harness.Stop();
}
}
