public async Task Handle_return_false_if_order_is_not_persisted()
{
var buyerId = "1234";
var fakeOrderCmd = FakeOrderRequestWithBuyer(new Dictionary <string, object>
{
["cardExpiration"] = DateTime.Now.AddYears(1)
});
_buyerRepositoryMock.Setup(buyerRepo => buyerRepo.FindAsync(buyerId))
.Returns(Task.FromResult <Buyer>(FakeBuyer()));
_buyerRepositoryMock.Setup(buyerRepo => buyerRepo.UnitOfWork.SaveChangesAsync(default(CancellationToken)))
.Returns(Task.FromResult(1));
_orderRepositoryMock.Setup(or => or.Add(FakeOrder())).Returns(FakeOrder());
_orderRepositoryMock.Setup(or => or.UnitOfWork.SaveChangesAsync(default(CancellationToken)))
.Returns(Task.FromResult(0));
_identityServiceMock.Setup(svc => svc.GetUserIdentity()).Returns(buyerId);
//Act
var handler = new CreateOrderCommandHandler(_buyerRepositoryMock.Object, _orderRepositoryMock.Object, _identityServiceMock.Object);
var result = await handler.Handle(fakeOrderCmd);
//Assert
Assert.False(result);
}
public async Task Handle_throws_exception_when_order_expired()
{
var buyerId = "1234";
var fakeOrderCmd = FakeOrderRequestWithBuyer(new Dictionary <string, object>
{
["cardExpiration"] = DateTime.Now.AddYears(-1)
});
// Arrange
_buyerRepositoryMock.Setup(buyerRepo => buyerRepo.FindAsync(buyerId))
.Returns(Task.FromResult <Buyer>(FakeBuyer()));
_buyerRepositoryMock.Setup(buyerRepo => buyerRepo.UnitOfWork.SaveChangesAsync(default(CancellationToken)))
.Returns(Task.FromResult(1));
_orderRepositoryMock.Setup(or => or.Add(FakeOrder()))
.Returns(FakeOrder());
_orderRepositoryMock.Setup(or => or.UnitOfWork.SaveChangesAsync(default(CancellationToken)))
.Returns(Task.FromResult(1));
_identityServiceMock.Setup(svc => svc.GetUserIdentity()).Returns(buyerId);
//Act
var handler = new CreateOrderCommandHandler(_buyerRepositoryMock.Object, _orderRepositoryMock.Object, _identityServiceMock.Object);
//Assert
await Assert.ThrowsAsync <ArgumentException>(async() => await handler.Handle(fakeOrderCmd));
}
public async Task Handle_return_false_if_order_is_not_persisted()
{
var buyerId = "1234";
var fakeOrderCmd = FakeOrderRequestWithBuyer(new Dictionary <string, object>
{
["cardExpiration"] = DateTime.Now.AddYears(1)
});
_orderRepositoryMock.Setup(orderRepo => orderRepo.GetAsync(It.IsAny <int>()))
.Returns(Task.FromResult <global::Order.Domain.AggregatesModel.OrderAggregate.Order>(FakeOrder()));
_orderRepositoryMock.Setup(buyerRepo => buyerRepo.UnitOfWork.SaveChangesAsync(default(CancellationToken)))
.Returns(Task.FromResult(1));
_identityServiceMock.Setup(svc => svc.GetUserIdentity()).Returns(buyerId);
//Act
var handler = new CreateOrderCommandHandler(_mediator.Object, _orderRepositoryMock.Object, _identityServiceMock.Object);
var cltToken = new System.Threading.CancellationToken();
var result = await handler.Handle(fakeOrderCmd, cltToken);
//Assert
Assert.False(result);
}
public async Task CreateOrderCommand_AddressDoesNotExist_ShouldThrowException()
{
var sut = new CreateOrderCommandHandler(_context, _mapper);
var currentUser = _context.User.First();
await sut.Handle(new CreateOrderCommand { CreatedByUserId = currentUser.Id, AddressId = Guid.NewGuid() },
CancellationToken.None)
.ShouldThrowAsync <NotFoundException>();
}
public async Task Handle_GivenNullRequest_ShouldThrowArgumentNullException()
{
// Arrange
var sut = new CreateOrderCommandHandler(
this.deletableEntityRepository,
It.IsAny <EfDeletableEntityRepository <Customer> >());
// Act & Assert
await Should.ThrowAsync <ArgumentNullException>(sut.Handle(null, It.IsAny <CancellationToken>()));
}
public static void Run([QueueTrigger("commandqueue")] string myQueueItem, ILogger log)
{
log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
var command = JsonConvert.DeserializeObject <CreateOrderCommand>(myQueueItem);
var orderDbContext = new OrderDbContext();
var createOrderCommandHandler = new CreateOrderCommandHandler(orderDbContext);
createOrderCommandHandler.Handle(command);
}
public async Task Handle_guid_is_empty()
{
//arrange
CancellationToken token = default(System.Threading.CancellationToken);
IdentifiedCommand <CreateOrderCommand, bool> request = new IdentifiedCommand <CreateOrderCommand, bool>(new CreateOrderCommand(), Guid.Empty);
var handler = new CreateOrderCommandHandler(loggerMock.Object, orderRepositoryMock.Object, busMock.Object, configurationMock.Object);
//act
//assert
await Assert.ThrowsAsync <ArgumentException>(async() => await handler.Handle(request, token));
}
public async Task Handle_items_is_empty()
{
//arrange
CancellationToken token = default(CancellationToken);
CreateOrderCommand command = new CreateOrderCommand();
IdentifiedCommand <CreateOrderCommand, bool> request = new IdentifiedCommand <CreateOrderCommand, bool>(command, Guid.NewGuid());
var handler = new CreateOrderCommandHandler(loggerMock.Object, orderRepositoryMock.Object, busMock.Object, configurationMock.Object);
//act
//assert
await Assert.ThrowsAsync <NoItemsException>(async() => await handler.Handle(request, token));
}
public async Task SaveAsync()
{
var dataAccess = new OrderDataAccess(this.Context);
//Act
var sutCreate = new CreateOrderCommandHandler(dataAccess);
var resultCreate = await sutCreate.Handle(new CreateOrderCommand
{
Data = OrderTestData.OrderDataDTO
}, CancellationToken.None);
Assert.IsTrue(resultCreate.Succeeded);
}
public async Task CreateOrderHandlerWorks()
{
var warrantyServiceMock = new Mock <IWarrantyService>();
var handler = new CreateOrderCommandHandler(itemsRepository, ordersRepository, _mockDbContext, warrantyServiceMock.Object);
var guid = Guid.NewGuid();
SeedDb(guid);
var result = await handler.Handle(new CreateOrderCommand { Model = "2", Size = "2" }, It.IsAny <CancellationToken>());
Assert.That(result.IsCompleted);
Assert.That(_mockDbContext.Items.Find(2).AvailableCount == 1, $"{_mockDbContext.Items.Find(2).AvailableCount}");
Assert.That((await ordersRepository.GetById(guid)).Canceled == false);
}
public async Task CreateOrderCommandHandler_Success()
{
//Arrange
mapper.Setup(x => x.Map <Order>(command)).Returns(order);
orderRepository.Setup(x => x.SaveAllAsync()).Returns(Task.FromResult(true));
//Act
var action = await commandHandler.Handle(command, It.IsAny <CancellationToken>());
//Assert
orderRepository.Verify(x => x.Add(order), Times.Once);
bus.Verify(x => x.Publish(It.IsAny <OrderCreatedEvent>(), It.IsAny <CancellationToken>()), Times.Once);
Assert.Equal(Unit.Value, action);
}
public async Task Handle_invalid_user_data(string customerId, string customerName, string customerEmail, string customerPhone, string customerAddress, string customerAdditionalAddress, string customerDistrict, string customerCity, string customerState, string customerZipCode)
{
//arrange
CancellationToken token = default(CancellationToken);
CreateOrderCommand command = new CreateOrderCommand(new List <CreateOrderCommandItem>
{
new CreateOrderCommandItem("001", "product 001", 1, 12.34m)
}
, customerId, customerName, customerEmail, customerPhone, customerAddress, customerAdditionalAddress, customerDistrict, customerCity, customerState, customerZipCode);
IdentifiedCommand <CreateOrderCommand, bool> request = new IdentifiedCommand <CreateOrderCommand, bool>(command, Guid.NewGuid());
var handler = new CreateOrderCommandHandler(loggerMock.Object, orderRepositoryMock.Object, busMock.Object, configurationMock.Object);
//act
//assert
await Assert.ThrowsAsync <InvalidUserDataException>(async() => await handler.Handle(request, token));
}
public async Task Handle_invalid_item(string productCodigo, string productNome, int productQuantity, decimal productUnitPrice)
{
//arrange
CancellationToken token = default(CancellationToken);
CreateOrderCommand command = new CreateOrderCommand(new List <CreateOrderCommandItem>
{
new CreateOrderCommandItem(productCodigo, productNome, productQuantity, productUnitPrice)
}
, "customerId", "customerName", "*****@*****.**", "phone", "address", "additionalAddress", "district", "city", "state", "12345-678");
IdentifiedCommand <CreateOrderCommand, bool> request = new IdentifiedCommand <CreateOrderCommand, bool>(command, Guid.NewGuid());
var handler = new CreateOrderCommandHandler(loggerMock.Object, orderRepositoryMock.Object, busMock.Object, configurationMock.Object);
//act
//assert
await Assert.ThrowsAsync <InvalidItemException>(async() => await handler.Handle(request, token));
}
public async void ItShould_Create_Order()
{
//Arrange
var mockRopo = new Mock <IOrderRepository>();
var expected = new Fixture().Create <Task <OrderConfirmation> >();
mockRopo.Setup(x => x.CreateOrderAsync(It.IsAny <Order>())).Returns(expected);
//act
Order order = new Order();
CreateOrder createOrder = new CreateOrder(order);
var sut = new CreateOrderCommandHandler(mockRopo.Object);
var actual = await sut.Handle(createOrder, new CancellationToken());
//Assert
mockRopo.VerifyAll();
Assert.NotNull(actual);
}
public async Task GetAllAsync()
{
var dataAccess = new OrderDataAccess(this.Context);
//Act
var sutCreate = new CreateOrderCommandHandler(dataAccess);
var resultCreate = await sutCreate.Handle(new CreateOrderCommand
{
Data = OrderTestData.OrderDataDTO
}, CancellationToken.None);
//Act
var sutGetAll = new GetOrdersQueryHandler(dataAccess);
var resultGetAll = await sutGetAll.Handle(new GetOrdersQuery(), CancellationToken.None);
Assert.IsTrue(resultGetAll?.Data.Count == 1);
}
public async Task Handle_GivenInvalidRequest_ShouldThrowNotFoundException()
{
// Arrange
var command = new CreateOrderCommand
{
Description = "Desc",
Quantity = "123",
Status = "Active",
};
var customersRepository = new EfDeletableEntityRepository <Customer>(this.dbContext);
var sut = new CreateOrderCommandHandler(
this.deletableEntityRepository,
customersRepository);
// Act & Assert
await Should.ThrowAsync <NotFoundException>(sut.Handle(command, It.IsAny <CancellationToken>()));
}
public async Task CreateOrderCommand_AfterModelHasBeenValidated_OrderCountShouldIncrementBy1()
{
var sut = new CreateOrderCommandHandler(_context, _mapper);
var orderCountBeforeAct = _context.Order.ToList().Count;
var currentUser = _context.User.First();
var currentAddress = _context.Address.First(x => x.UserId == currentUser.Id);
await sut.Handle(
new CreateOrderCommand
{
CreatedByUserId = currentUser.Id, AddressId = currentAddress.Id, Make = "Audi", Model = "A7",
Trim = "14", Registration = "X55 XXX", Tyre = "Tyre", Year = "2012", Description = "Desc"
},
CancellationToken.None);
var orderCountAfterAct = _context.Order.ToList().Count;
orderCountAfterAct.ShouldBe(orderCountBeforeAct + 1);
}
public async Task GetAsync()
{
var dataAccess = new OrderDataAccess(this.Context);
//Act
var sutCreate = new CreateOrderCommandHandler(dataAccess);
var resultCreate = await sutCreate.Handle(new CreateOrderCommand
{
Data = OrderTestData.OrderDataDTO
}, CancellationToken.None);
//Act
var sutGet = new GetOrderQueryHandler(dataAccess);
var resultGet = await sutGet.Handle(new GetOrderQuery
{
Id = resultCreate.Data.Id
}, CancellationToken.None);
Assert.IsTrue(resultGet?.Data != null);
}
public async Task DeleteAsync()
{
var dataAccess = new OrderDataAccess(this.Context, Mapper());
//Act
var sutCreate = new CreateOrderCommandHandler(dataAccess);
var resultCreate = await sutCreate.Handle(new CreateOrderCommand
{
Data = OrderTestData.OrderDTO
}, CancellationToken.None);
//Act
var sutDelete = new DeleteOrderCommandHandler(dataAccess);
var outcomeDelete = await sutDelete.Handle(new DeleteOrderCommand
{
Id = resultCreate.Data.Id
}, CancellationToken.None);
//Assert
Assert.IsTrue(outcomeDelete.Succeeded);
}
public async Task Handle_RequestCorretlyFilled_Success()
{
// Arrange
var requiredBinWidth = 226; //4 - mug, 1 - photoBook
var orderNumber = 1;
var productItemsRequest = new List <ProductItemsRequest>()
{
new ProductItemsRequest()
{
ItemNumber = 5,
Quantity = 5
},
new ProductItemsRequest()
{
ItemNumber = 4,
Quantity = 2
},
};
MockOrderRepository(orderNumber);
MockProductItemRepository();
var commandHandler = new CreateOrderCommandHandler(
_mockOrderRepository.Object,
_mockProductItemRepository.Object,
_packageService);
var request = new CreateOrderRequest(orderNumber, productItemsRequest);
// Act
var result = await commandHandler.Handle(request);
// Assert
Assert.NotNull(result);
Assert.Equal(requiredBinWidth, result.RequiredBinWidth);
}
public async Task HandleAsync(MessageEvent messageEvent)
{
// https://stackoverflow.com/questions/43124722/application-insights-custom-trackrequest-is-creating-duplicate-messages
var requestTelemetry = new RequestTelemetry
{
Name = "CheckOutEventHandler invoked from EventBus"
};
_telemetryClient.TrackRequest(requestTelemetry);
string correlationToken = null;
try
{
correlationToken = messageEvent.CorrelationToken;
var checkedOutEvent = messageEvent as CheckOutEvent;
_logger.LogInformation($"Invoked CheckOutEventHandler in Ordering.API for Request {correlationToken} ");
_telemetryClient.TrackEvent(
$"Event: Invoked CheckOutEventHandler in Ordering.API for Request {correlationToken}");
if (checkedOutEvent == null)
{
_logger.LogError(
$"Publishing EmptyBasketEvent from CheckOutEventHandler in Ordering.API for Request {correlationToken} ");
throw new Exception(
$"Exception in CheckOutEventHandler: 'CheckOutEvent is Null' for Request {correlationToken}");
}
_telemetryClient.TrackEvent(
$"Event: CheckOutEventHandler invoked: BasketID:{checkedOutEvent.OrderInformationModel.BasketId}");
var createOrderCommand = new CreateOrderCommand(
checkedOutEvent.OrderInformationModel.BasketId,
checkedOutEvent.OrderInformationModel.CheckoutId,
checkedOutEvent.OrderInformationModel.Buyer.Username,
checkedOutEvent.OrderInformationModel.Total,
checkedOutEvent.OrderInformationModel.Buyer.FirstName,
checkedOutEvent.OrderInformationModel.Buyer.LastName,
checkedOutEvent.OrderInformationModel.Buyer.Address,
checkedOutEvent.OrderInformationModel.Buyer.City,
checkedOutEvent.OrderInformationModel.Buyer.State,
checkedOutEvent.OrderInformationModel.Buyer.PostalCode,
checkedOutEvent.OrderInformationModel.Buyer.Phone,
checkedOutEvent.OrderInformationModel.Buyer.Email,
checkedOutEvent.OrderInformationModel.Payment.CreditCardNumber,
checkedOutEvent.OrderInformationModel.Payment.SecurityCode,
checkedOutEvent.OrderInformationModel.Payment.CardholderName,
checkedOutEvent.OrderInformationModel.Payment.ExpirationDate,
checkedOutEvent.CorrelationToken = correlationToken,
// Is this cool Linq? Generated from Resharper. It iterates through lineItem collection and projects an orderDetailDto for each item
// Map collection of CheckOutEventLineItems to collection of OderDetailDtos
checkedOutEvent.OrderInformationModel.LineItems.Select(lineItem => new OrderDetailDto
{
Artist = lineItem.Artist,
Title = lineItem.Title,
Quantity = lineItem.Quantity,
UnitPrice = decimal.Parse(lineItem.UnitPrice),
AlbumId = lineItem.ProductId
}).ToList()
);
// Invoke Command that creates order
var orderId = await _orderCommandHandler.Handle(createOrderCommand);
checkedOutEvent.OrderInformationModel.OrderSystemId = orderId;
_telemetryClient.TrackEvent(
$"Event: CheckOutEventHandler: Buyer created:{orderId}");
//************** Publish Event *************************
// Publish event to clear basket for this order from Basket service
var emptyCartEvent = new EmptyBasketEvent
{
BasketID = checkedOutEvent.OrderInformationModel.BasketId,
CorrelationToken = correlationToken
};
_logger.LogInformation(
$"Publishing EmptyBasketEvent from CheckOutEventHandler in Ordering.API for Request {correlationToken} ");
_telemetryClient.TrackEvent(
$"Event: Publishing EmptyBasketEvent from CheckOutEventHandler for orderid:{orderId}");
await _eventBusPublisher.Publish <EmptyBasketEvent>(emptyCartEvent);
}
catch (Exception ex)
{
throw new Exception(
$"Exception in CheckOutEventHandler: {ex.Message} for Request {correlationToken}");
}
await Task.CompletedTask;
}
public async Task Handle_IncorrectRequestedItemNumber_EntityNotFoundServiceException()
{
// Arrange
var orderNumber = 1;
var productItemsRequest = new List <ProductItemsRequest>()
{
new ProductItemsRequest()
{
ItemNumber = 5,
Quantity = 5
},
new ProductItemsRequest()
{
ItemNumber = 4,
Quantity = 2
},
};
MockOrderRepository(orderNumber);
_mockProductItemRepository
.Setup(x => x.GetListByProductNumberAsync(It.IsAny <IEnumerable <int> >(), default))
.Throws <ProductItemFoundRepositoryException>();
var commandHandler = new CreateOrderCommandHandler(
_mockOrderRepository.Object,
_mockProductItemRepository.Object,
_packageService);
var request = new CreateOrderRequest(orderNumber, productItemsRequest);
// Act & Assert
await Assert.ThrowsAsync <EntityNotFoundServiceException>(async() => await commandHandler.Handle(request));
}
public async Task Handle_OrderNumberAlreadyExist_OrderNumberAlreadyExistServiceException()
{
// Arrange
var orderNumber = 1;
var productItemsRequest = new List <ProductItemsRequest>()
{
new ProductItemsRequest()
{
ItemNumber = 5,
Quantity = 5
},
new ProductItemsRequest()
{
ItemNumber = 4,
Quantity = 2
},
};
_mockOrderRepository.Setup(x => x.AddAsync(It.IsAny <Order>(), default))
.Throws <OrderNumberAlreadyExistRepositoryException>();
MockProductItemRepository();
var commandHandler = new CreateOrderCommandHandler(
_mockOrderRepository.Object,
_mockProductItemRepository.Object,
_packageService);
var request = new CreateOrderRequest(orderNumber, productItemsRequest);
// Act & Assert
await Assert.ThrowsAsync <OrderNumberAlreadyExistServiceException>(async() => await commandHandler.Handle(request));
}
public async Task HandleAsync(Message message)
{
try
{
// Interrogate the message
// Get the Event Type
message.UserProperties.TryGetValue("Event", out var eventType);
// Get the CorrelationToken
message.UserProperties.TryGetValue("correlationToken", out var correlationToken);
// Get the message body
var body = Encoding.UTF8.GetString(message.Body);
// Deserialize the message body into the event class
var checkOut = JsonConvert.DeserializeObject <UserCheckoutEvent>(body);
// Create Command (data) object that follows simple CQRS pattern
var createOrderCommand = new CreateOrderCommand(
checkOut.CustomerId,
checkOut.BasketId,
checkOut.OrderDate,
checkOut.UserName,
checkOut.Total,
checkOut.OrderDetails);
// Invoke Command that creates order
var orderId = await _orderCommandHandler.Handle(createOrderCommand);
// Create Buyer Command (data) object that follows simple CQRS pattern
var createBuyerCommand = new CreateBuyerCommand(orderId,
checkOut.UserName,
checkOut.BuyerInformation.FirstName,
checkOut.BuyerInformation.LastName,
checkOut.BuyerInformation.Address,
checkOut.BuyerInformation.City,
checkOut.BuyerInformation.State,
checkOut.BuyerInformation.PostalCode,
checkOut.BuyerInformation.Country,
checkOut.BuyerInformation.Phone,
checkOut.BuyerInformation.Email);
// Invoke Command that creates buyer
await _buyerCommandHandler.Handle(createBuyerCommand);
//************** Publish Event *************************
// Publish event to clear basket for this order from Basket service
var emptyCartEvent = new EmptyBasketEvent
{
BasketID = checkOut.BasketId,
CorrelationToken = correlationToken?.ToString()
};
await _eventBus.Publish(emptyCartEvent,
MessageEventEnum.InvokeEmptyBasketEvent,
correlationToken?.ToString());
}
catch (Exception ex)
{
throw new Exception($"Exception executing UserCheckoutEvent in Eventhandler : {ex.Message}");
}
await Task.CompletedTask;
}
