public async Task Handle_GivenValidRequest_ShouldCreateOrder()
{
// Arrange
var command = new CreateOrderCommand
{
Description = "Desc",
Price = "123",
Quantity = "123",
Status = "Active",
};
var customersRepository = new EfDeletableEntityRepository <Customer>(this.dbContext);
var sut = new CreateOrderCommandHandler(
this.deletableEntityRepository,
customersRepository);
// Act
var id = await sut.Handle(command, It.IsAny <CancellationToken>());
// Assert
var createdOrder = this.deletableEntityRepository
.AllAsNoTracking()
.SingleOrDefault(x => x.Description == "Desc");
createdOrder.CustomerId.ShouldBe(1);
createdOrder.Description.ShouldBe("Desc");
createdOrder.TotalAmount.ShouldBe(123);
}
static void Main(string[] args)
{
EventStoreLoader.SetupEventStore(EventStoreLoader.StartConflictOption.Connect);
var connection = EventStoreLoader.Connection;
var bus = new FakeBus();
var queue = new ReadmodelPublisher();
var orderCreatedHandler = new CreateOrderCommandHandler(
new Repository <Order>(
new Disruptor.ReadModel.Tests.Infrastructure.EventStore(connection, queue)));
var orderItemAddedHandler = new AddItemToOrderCommandHandler(
new Repository <Order>(
new Disruptor.ReadModel.Tests.Infrastructure.EventStore(connection, queue)));
bus.RegisterAsyncHandler <CreateOrderCommand>(orderCreatedHandler.HandleAsync);
bus.RegisterAsyncHandler <AddItemToCardCommand>(orderItemAddedHandler.HandleAsync);
TestSendCommandAndFillupReadmodel(queue, bus);
EventStoreLoader.TeardownEventStore(false, true);
}
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)
});
_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_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 Handle_success()
{
//arrange
var order = new Order(
new List <OrderItem> {
new OrderItem("001", "product 001", 1, 12.34m),
new OrderItem("002", "product 002", 2, 23.45m)
},
"customerId", "customerName", "*****@*****.**", "phone", "address", "additionalAddress", "district", "city", "state", "12345-678");
CancellationToken token = default(CancellationToken);
CreateOrderCommand command = new CreateOrderCommand(new List <CreateOrderCommandItem>
{
new CreateOrderCommandItem("001", "product 001", 1, 12.34m),
new CreateOrderCommandItem("002", "product 002", 2, 23.45m)
}
, "customerId", "customerName", "*****@*****.**", "phone", "address", "additionalAddress", "district", "city", "state", "12345-678");
IdentifiedCommand <CreateOrderCommand, bool> request = new IdentifiedCommand <CreateOrderCommand, bool>(command, Guid.NewGuid());
orderRepositoryMock
.Setup(r => r.CreateOrUpdate(It.IsAny <Order>()))
.ReturnsAsync(order)
.Verifiable();
var handler = new CreateOrderCommandHandler(loggerMock.Object, orderRepositoryMock.Object, busMock.Object, configurationMock.Object);
//act
bool result = await handler.Handle(request, token);
//assert
Assert.True(result);
orderRepositoryMock.Verify();
}
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 Handler_returns_false_if_order_is_not_persisted()
{
var buyer = "1234";
var fakeOrderCmd = this.FakeOrderRequestWithBuyer(new Dictionary <string, object>()
{
["cardExpiration"] = DateTime.UtcNow.AddYears(1)
});
this._orderRepositoryMock
.Setup(orderRepo => orderRepo.GetAsync(It.IsAny <int>()))
.Returns(Task.FromResult(this.FakeOrder()));
this._orderRepositoryMock
.Setup(orderRepo => orderRepo.UnitOfWork.SaveChangesAsync(CancellationToken.None))
.Returns(Task.FromResult(1));
this._identityServiceMock
.Setup(ism => ism.GetUserIdentity())
.Returns(buyer);
var handler = new CreateOrderCommandHandler(
this._mediatorMock.Object,
this._orderRepositoryMock.Object,
this._identityServiceMock.Object);
var result = await handler.Handle(fakeOrderCmd);
Assert.False(result);
}
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 <Order>(FakeOrder()));
_orderRepositoryMock.Setup(buyerRepo => buyerRepo.UnitOfWork.SaveChangesAsync(default(CancellationToken)))
.Returns(Task.FromResult(1));
// _identityServiceMock.Setup(svc => svc.GetUserIdentity()).Returns(buyerId);
var LoggerMock = new Mock <ILogger <CreateOrderCommandHandler> >();
//Act
// var handler = new CreateOrderCommandHandler(_mediator.Object, _orderingIntegrationEventService.Object, _orderRepositoryMock.Object, _identityServiceMock.Object, LoggerMock.Object);
var handler = new CreateOrderCommandHandler(_mediator.Object, _orderingIntegrationEventService.Object, _orderRepositoryMock.Object, LoggerMock.Object);
var cltToken = new System.Threading.CancellationToken();
var result = await handler.Handle(fakeOrderCmd, cltToken);
//Assert
Assert.False(result);
}
public async Task CreateOrderCommand_UserDoesNotExist_ShouldThrowException()
{
var sut = new CreateOrderCommandHandler(_context, _mapper);
await sut.Handle(new CreateOrderCommand { CreatedByUserId = Guid.NewGuid() }, CancellationToken.None)
.ShouldThrowAsync <NotFoundException>();
}
public UserCheckoutEventHandler(IEventBus eventBus,
CreateOrderCommandHandler orderCommandHandler,
CreateBuyerCommandHandler buyerCommandHandler)
{
_eventBus = eventBus;
_orderCommandHandler = orderCommandHandler;
_buyerCommandHandler = buyerCommandHandler;
}
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 CreateOrderCommandHandlerTest()
{
orderRepository = new Mock <IOrderRepository>();
bus = new Mock <IBus>();
mapper = new Mock <IMapper>();
command = new CreateOrderCommand();
commandHandler = new CreateOrderCommandHandler(mapper.Object, orderRepository.Object, bus.Object);
order = new Order();
}
public CheckOutEventHandler(IEventBusPublisher eventBusPublisher,
CreateOrderCommandHandler orderCommandHandler,
ILogger <CheckOutEventHandler> logger,
TelemetryClient telemetryClient)
{
_eventBusPublisher = eventBusPublisher;
_orderCommandHandler = orderCommandHandler;
_logger = logger;
_telemetryClient = telemetryClient;
}
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 CreateOrderTests(ITestOutputHelper testOutputHelper)
{
_testOutputHelper = testOutputHelper;
_paymentProviderFactory = new Mock <IOrderPaymentProviderFactory>();
_paymentProvider = new Mock <IPaymentProvider>();
_unitOfWork = new Mock <IUnitOfWork>();
_cartItemRepository = new Mock <IRepository <CartItem, Guid> >();
_orderRepository = new Mock <IRepository <Order, long> >();
_orderItemRepository = new Mock <IRepository <OrderItem, long> >();
_handler = new CreateOrderCommandHandler(_cartItemRepository.Object, _orderRepository.Object,
_paymentProviderFactory.Object, _unitOfWork.Object);
}
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 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 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 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 AddOrderCommandHandlerFixture()
{
UserQueryServiceMock = new Mock <IUserQueryService>();
ShipmentQueryServiceMock = new Mock <IShipmentQueryService>();
OrderDiscountQueryServiceMock = new Mock <IOrderDiscountQueryService>();
ProductOrderQueryServiceMock = new Mock <IProductOrderQueryService>();
AddressQueryServiceMock = new Mock <IAddressQueryService>();
OrderCommandServiceMock = new Mock <IOrderFactory>();
EmailServiceMock = new Mock <IEmailService>();
PaymentsRepositoryMock = new Mock <IPaymentsRepository>();
Sut = new CreateOrderCommandHandler(UserQueryServiceMock.Object, ShipmentQueryServiceMock.Object,
OrderDiscountQueryServiceMock.Object,
ProductOrderQueryServiceMock.Object, AddressQueryServiceMock.Object, OrderCommandServiceMock.Object,
EmailServiceMock.Object, PaymentsRepositoryMock.Object);
Request = Fixture.Build <CreateOrderCommandModel>()
.With(x => x.UserId, Guid.NewGuid)
.Create();
}
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);
}
