public async Task Handle_CreditCardDoesNotExist_CreateSalesOrder(
[Frozen] Mock <ISalesOrderIntegrationEventService> salesOrderIntegrationEventServiceMock,
[Frozen] Mock <IRepository <Core.Entities.SalesOrder> > salesOrderRepositoryMock,
[Frozen] Mock <IRepository <Core.Entities.CreditCard> > creditCardRepositoryMock,
CreateSalesOrderCommandHandler sut,
CreateSalesOrderCommand command
)
{
//Arrange
command.OrderItems.ForEach(_ => _.Discount = 0);
creditCardRepositoryMock.Setup(_ => _.GetBySpecAsync(
It.IsAny <GetCreditCardSpecification>(),
It.IsAny <CancellationToken>()
))
.ReturnsAsync((Core.Entities.CreditCard)null);
//Act
var result = await sut.Handle(command, CancellationToken.None);
//Assert
result.Should().BeTrue();
salesOrderIntegrationEventServiceMock.Verify(_ => _.AddAndSaveEventAsync(
It.IsAny <IntegrationEvent>())
);
salesOrderRepositoryMock.Verify(_ => _.AddAsync(
It.IsAny <Core.Entities.SalesOrder>(),
It.IsAny <CancellationToken>())
);
}
public ActionResult PlaceOrder()
{
var basket = HttpContext.Cache.Get("basket") as Basket;
if (basket == null)
{
TempData.Add("message", "You have nothing in your basket");
return(View("Fail"));
}
var createSalesOrderCommand = new CreateSalesOrderCommand(
new Money((decimal)7.5, Currency.GBP));
_commandProcessor.Process(createSalesOrderCommand);
foreach (var item in basket.GetItems())
{
_commandProcessor.Process(
new AddItemsToSalesOrderCommand(
createSalesOrderCommand.Id,
new Sku(item.Description),
item.Quantity,
new Money((decimal)1.25, Currency.GBP)));
}
basket.Clear();
TempData.Add("message", "Thank you for your order. :)");
return(View("Win"));
}
public async Task <IActionResult> CreateSalesOrder([FromBody] CreateSalesOrderCommand model)
{
try
{
return(await _mediator.Send(model));
}
catch (Exception ex)
{
_logger.LogError(ex, "Error in {0}", HttpContext.Request.Path);
return(BadRequest(ErrorMessages.InternalExceptionModel));
}
}
/// <summary>
/// Integration event handler which starts the create order process
/// </summary>
/// <param name="@event">
/// Integration event message which is sent by the
/// basket.api once it has successfully process the
/// order items.
/// </param>
/// <returns></returns>
public async Task Handle(UserCheckoutAcceptedIntegrationEvent @event)
{
using (LogContext.PushProperty("IntegrationEventContext", $"{@event.Id}-{application.AppName}"))
{
logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppName} - ({@IntegrationEvent})", @event.Id, application.AppName, @event);
var result = false;
if (@event.RequestId != Guid.Empty)
{
using (LogContext.PushProperty("IdentifiedCommandId", @event.RequestId))
{
var createSalesOrderCommand = new CreateSalesOrderCommand(
@event.BasketItems, @event.UserId, @event.UserName,
@event.CustomerNumber, @event.ShipMethod,
mapper.Map <AddressDto>(@event.BillToAddress),
mapper.Map <AddressDto>(@event.ShipToAddress),
@event.CardNumber, @event.CardHolderName, @event.CardExpiration,
@event.CardSecurityNumber, @event.CardType
);
var requestCreateOrder = new IdentifiedCommand <CreateSalesOrderCommand, bool>(createSalesOrderCommand, @event.RequestId);
logger.LogInformation(
"----- Sending command: {CommandName} - {IdProperty}: {CommandId} ({@Command})",
requestCreateOrder.GetGenericTypeName(),
nameof(requestCreateOrder.Id),
requestCreateOrder.Id,
requestCreateOrder
);
result = await mediator.Send(requestCreateOrder);
if (result)
{
logger.LogInformation("----- CreateSalesOrderCommand succeeded - RequestId: {RequestId}", @event.RequestId);
}
else
{
logger.LogWarning("CreateSalesOrderCommand failed - RequestId: {RequestId}", @event.RequestId);
}
}
}
else
{
logger.LogWarning("Invalid IntegrationEvent - RequestId is missing - {@IntegrationEvent}", @event);
}
}
}
public async Task Handle_NoActiveTransaction_InvokeExecute(
[Frozen] Mock <IDbContext> mockDbContext,
TransactionBehavior <CreateSalesOrderCommand, bool> sut,
CreateSalesOrderCommand command,
RequestHandlerDelegate <bool> next
)
{
//Arrange
//Act
var result = await sut.Handle(command, CancellationToken.None, next);
//Assert
mockDbContext.Verify(_ => _.Execute(
It.IsAny <Func <Task> >()
));
}
public async Task Handle_ActiveTransaction_InvokeNext(
[Frozen] Mock <IDbContext> mockDbContext,
TransactionBehavior <CreateSalesOrderCommand, bool> sut,
CreateSalesOrderCommand command,
RequestHandlerDelegate <bool> next
)
{
//Arrange
mockDbContext.Setup(_ => _.HasActiveTransaction)
.Returns(true);
//Act
var result = await sut.Handle(command, CancellationToken.None, next);
//Assert
result.Should().Be(await next.Invoke());
mockDbContext.Verify(_ => _.Execute(
It.IsAny <Func <Task> >()
), Times.Never);
}
public async Task Execute(CreateSalesOrderCommand command)
{
var message = new CreateSalesOrderMessage(command.SalesOrderKey, command.CustomerKey, command.WarehouseKey);
var salesOrderGrain = GrainFactory.GetGrain <ISalesOrderGrain>(command.SalesOrderKey);
// var referenceList = await SalesOrdersObserverFactory.CreateObjectReference(new SalesOrderListObserver());
// var referenceDashboard = await SalesOrdersObserverFactory.CreateObjectReference(new OrdersDashboardObserver());
// await salesOrderGrain.Subscribe(referenceList);
// await salesOrderGrain.Subscribe(referenceDashboard);
await salesOrderGrain.Create(message);
var customerGrain = GrainFactory.GetGrain <ICustomerGrain>(command.CustomerKey);
var tax = await customerGrain.GetSaleTax();
await salesOrderGrain.AssignTax(tax);
// await salesOrderGrain.Unsubscribe(referenceDashboard);
// await salesOrderGrain.Unsubscribe(referenceList);
_subscribers.Notify(x => x.Notify(message.SalesOrderKey));
}
public void Handle_ExceptionOccurred_ThrowException(
[Frozen] Mock <IDbContext> mockDbContext,
TransactionBehavior <CreateSalesOrderCommand, bool> sut,
CreateSalesOrderCommand command,
RequestHandlerDelegate <bool> next
)
{
//Arrange
mockDbContext.Setup(_ => _.Execute(
It.IsAny <Func <Task> >())
)
.ThrowsAsync(new Exception());
//Act
Func <Task> func = async() => await sut.Handle(command, CancellationToken.None, next);
//Assert
func.Should().Throw <Exception>();
mockDbContext.Verify(_ => _.Execute(
It.IsAny <Func <Task> >()
));
}
public async Task Handle_CreditCardExists_CreateSalesOrder(
[Frozen] Mock <ISalesOrderIntegrationEventService> salesOrderIntegrationEventServiceMock,
[Frozen] Mock <IRepository <Core.Entities.SalesOrder> > salesOrderRepositoryMock,
[Frozen] Mock <IRepository <Core.Entities.CreditCard> > creditCardRepositoryMock,
CreateSalesOrderCommandHandler sut,
CreateSalesOrderCommand command,
Core.Entities.CreditCard creditCard,
DateTime expirationDate
)
{
//Arrange
command.OrderItems.ForEach(_ => _.Discount = 0);
creditCard.ExpMonth = byte.Parse(expirationDate.Month.ToString());
creditCard.ExpYear = short.Parse(expirationDate.Year.ToString());
creditCardRepositoryMock.Setup(_ => _.GetBySpecAsync(
It.IsAny <GetCreditCardSpecification>(),
It.IsAny <CancellationToken>()
))
.ReturnsAsync(creditCard);
//Act
var result = await sut.Handle(command, CancellationToken.None);
//Assert
result.Should().BeTrue();
salesOrderIntegrationEventServiceMock.Verify(_ => _.AddAndSaveEventAsync(
It.IsAny <IntegrationEvent>())
);
salesOrderRepositoryMock.Verify(_ => _.AddAsync(
It.IsAny <Core.Entities.SalesOrder>(),
It.IsAny <CancellationToken>())
);
}
public async Task <IActionResult> CreateSalesOrderAsync([FromBody] CreateSalesOrderCommand createSalesOrderCommand) => base.Ok(await mediator.Send <bool>(createSalesOrderCommand));
