private void ValidateLoadingPlaceAmountOfSpace(PackToDelivery pack, LoadingPlace loadingPlace)
{
if (pack.ProductsQuantity > (loadingPlace.AmountOfSpace - loadingPlace.LoadedQuantity))
{
throw new LackOfSpaceException();
}
}
private async Task ChangePackStatusToReadyToSend(PackToDelivery pack, int orderId)
{
pack.PackStatus = PackStatus.Ready_To_Send;
await packToDeliveryRepo.SaveAllAsync();
await bus.Publish(new ChangeOrderStatusEvent(orderId, OrderStatus.ReadyToSend));
}
public async Task LoadPackCommandHandler_Success()
{
//Arrange
int productsQuantity = 50;
int loadedQuantity = 0;
var packToDelivery = new PackToDelivery {
ProductsQuantity = productsQuantity
};
var loadingPlace = new LoadingPlace {
LoadedQuantity = loadedQuantity, AmountOfSpace = productsQuantity
};
packToDeliveryRepo.Setup(x => x.GetByConditionFirst(It.IsAny <Expression <Func <PackToDelivery, bool> > >()))
.Returns(Task.FromResult(packToDelivery));
loadingPlaceRepo.Setup(x => x.GetByConditionFirst(It.IsAny <Expression <Func <LoadingPlace, bool> > >()))
.Returns(Task.FromResult(loadingPlace));
//Act
var action = await commandHandler.Handle(command, It.IsAny <CancellationToken>());
//Assert
Assert.Equal(Unit.Value, action);
loadingPlaceRepo.Verify(x => x.SaveAllAsync(), Times.Once);
bus.Verify(x => x.Publish(It.IsAny <ChangeOrderStatusEvent>(), It.IsAny <CancellationToken>()), Times.Once);
}
public PackReadyToSendConsumerTest()
{
packToDeliveryRepo = new Mock <IPackToDeliveryRepo>();
bus = new Mock <IBus>();
logger = new Mock <ILogger <PackReadyToSendConsumer> >();
consumer = new PackReadyToSendConsumer(packToDeliveryRepo.Object, bus.Object, logger.Object);
context = GetContext();
pack = new PackToDelivery();
}
public ProductionFinishedConsumerTest()
{
customerOrderService = new Mock <ICustomerOrderService>();
packToDeliveryRepo = new Mock <IPackToDeliveryRepo>();
logger = new Mock <ILogger <ProductionFinishedConsumer> >();
consumer = new ProductionFinishedConsumer(customerOrderService.Object, packToDeliveryRepo.Object, logger.Object);
packToDelivery = new PackToDelivery();
context = GetContext();
}
public GetPackQueryHandlerTest()
{
packToDeliveryRepo = new Mock <IPackToDeliveryRepo>();
mapper = new Mock <IMapper>();
query = new GetPackQuery(packId);
queryHandler = new GetPackQueryHandler(packToDeliveryRepo.Object, mapper.Object);
packToDelivery = new PackToDelivery {
Id = packId
};
packDto = new GetPackDto {
Id = packId
};
}
private async Task CreateNewPackToDelivery(ConsumeContext <ProductionFinishedEvent> context)
{
var order = await GetOrder(context.Message.OrderId, context.Message.Token);
var packToDelivery = new PackToDelivery
{
OrderId = context.Message.OrderId,
PostCode = order.PostCode,
City = order.City,
Street = order.Street,
HouseNumber = order.HouseNumber,
PhoneNumber = order.PhoneNumber,
ProductsQuantity = context.Message.ProductsQuantity,
PackStatus = PackStatus.Waiting
};
packToDeliveryRepo.Add(packToDelivery);
}
public async Task LoadPackCommandHandler_ThrowsLackOfSpaceException()
{
//Arrange
int productsQuantity = 100;
int loadedQuantity = 50;
var packToDelivery = new PackToDelivery {
ProductsQuantity = productsQuantity
};
var loadingPlace = new LoadingPlace {
LoadedQuantity = loadedQuantity, AmountOfSpace = productsQuantity
};
packToDeliveryRepo.Setup(x => x.GetByConditionFirst(It.IsAny <Expression <Func <PackToDelivery, bool> > >()))
.Returns(Task.FromResult(packToDelivery));
loadingPlaceRepo.Setup(x => x.GetByConditionFirst(It.IsAny <Expression <Func <LoadingPlace, bool> > >()))
.Returns(Task.FromResult(loadingPlace));
//Assert
await Assert.ThrowsAsync <LackOfSpaceException>(() => commandHandler.Handle(command, It.IsAny <CancellationToken>()));
}
private void IncreaseLoadingPlaceLoadedQuantity(PackToDelivery pack, LoadingPlace loadingPlace)
{
loadingPlace.LoadedQuantity += pack.ProductsQuantity;
loadingPlace.LoadingPlaceStatus = LoadingPlaceStatus.Loading;
}
private void SetPackLoadingPlace(PackToDelivery pack, LoadingPlace loadingPlace)
{
pack.LoadingPlace = loadingPlace;
pack.PackStatus = PackStatus.Ready_To_Send;
}
