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; }