public SkuStock_reserved_tests()// Given_sku_created_and_stock_added_and_stock_reserved_messages_When_projected()
{
_stockCreatedEvent = new SkuStockCreated(Guid.NewGuid(), Guid.NewGuid(), 1, TimeSpan.FromDays(2));
_stockAddedEvent = new StockAdded(_stockCreatedEvent.SourceId, 15, "test pack");
_stockReservedEvent = new StockReserved(_stockCreatedEvent.SourceId, Guid.NewGuid(), DateTime.Now.AddDays(1), 7);
ProjectionBuilder.Handle(_stockCreatedEvent).Wait();
ProjectionBuilder.Handle(_stockAddedEvent).Wait();
ProjectionBuilder.Handle(_stockReservedEvent).Wait();
}
public SkuStock_reserve_taken_tests()// Given_sku_created_and_stock_added_and_stock_reserved_messages_When_projected()
{
var stockId = Guid.NewGuid();
_stockCreatedEvent = new SkuStockCreated(stockId, Guid.NewGuid(), 1, TimeSpan.FromDays(2));
_stockReservedEvent = new StockReserved(stockId, Guid.NewGuid(), DateTime.Now.AddDays(1), 7);
_stockReserveTakenEvent = new StockReserveTaken(stockId, _stockReservedEvent.ReserveId);
ProjectionBuilder.Handle(_stockCreatedEvent).Wait();
ProjectionBuilder.Handle(_stockReservedEvent).Wait();
ProjectionBuilder.Handle(_stockReserveTakenEvent).Wait();
}
public async Task Given_sku_created_and_stock_added_and_stock_reserved_messages_When_projected()
{
var sourceId = Guid.NewGuid();
await ProjectionBuilder.Handle(new SkuStockCreated(sourceId, Guid.NewGuid(), 1, TimeSpan.FromDays(2)));
await ProjectionBuilder.Handle(new StockAdded(sourceId, 15, "test pack"));
var stockReserved = new StockReserved(sourceId, Guid.NewGuid(), DateTime.Now.AddDays(1), 7);
await ProjectionBuilder.Handle(stockReserved);
//When_project_reserve_again_error_is_occured()
await ProjectionBuilder.Handle(stockReserved)
.ShouldThrow <ArgumentException>();
}
public async Task Given_sku_created_and_stock_added_and_stock_reserved_messages_When_projected()
{
var stockId = Guid.NewGuid();
var stockCreatedEvent = new SkuStockCreated(stockId, Guid.NewGuid(), 1, TimeSpan.FromDays(2));
var stockReservedEvent = new StockReserved(stockId, Guid.NewGuid(), DateTime.Now.AddDays(1), 7);
var stockReserveTakenEvent = new StockReserveTaken(stockId, stockReservedEvent.ReserveId);
await ProjectionBuilder.Handle(stockCreatedEvent);
await ProjectionBuilder.Handle(stockReservedEvent);
await ProjectionBuilder.Handle(stockReserveTakenEvent);
await Assert.ThrowsAsync <ReserveEntryNotFoundException>(() => ProjectionBuilder.Handle(stockReserveTakenEvent));
}
public async Task Given_sku_stock_with_amount_and_reserve_When_renew_reserve()
{
var aggregateId = Guid.NewGuid();
var customerId = Guid.NewGuid();
var reservationStartTime = BusinessDateTime.Now;
var reserveTime = TimeSpan.FromMilliseconds(100);
var expirationDate = reservationStartTime + reserveTime;
ReserveStockCommand reserveStockCommand;
StockReserved stockReservedEvent;
var scenario = AggregateScenario.New <SkuStock, SkuStockCommandsHandler>();
await scenario.Given(new SkuStockCreated(aggregateId, Guid.NewGuid(), 50, reserveTime),
new StockAdded(aggregateId, 10, "test batch 2"),
stockReservedEvent = new StockReserved(aggregateId, customerId, expirationDate, 5),
new FutureEventScheduledEvent(Guid.NewGuid(),
aggregateId,
expirationDate,
new ReserveExpired(aggregateId, customerId))).
When(reserveStockCommand =
new ReserveStockCommand(aggregateId, customerId, 10, reservationStartTime)).
Then(new ReserveRenewed(scenario.Aggregate.Id, customerId),
new FutureEventCanceledEvent(Any.GUID, scenario.Aggregate.Id, nameof(SkuStock)),
new StockReserved(scenario.Aggregate.Id,
customerId,
expirationDate,
reserveStockCommand.Quantity + stockReservedEvent.Quantity),
new FutureEventScheduledEvent(Any.GUID,
scenario.Aggregate.Id,
expirationDate,
new ReserveExpired(scenario.Aggregate.Id, customerId),
nameof(SkuStock))).
Run().
Check();
var reservation = scenario.Aggregate.Reservations[customerId];
//Then_aggregate_reservation_quantity_is_sum_of_initial_and_new_reservations()
Assert.Equal(reserveStockCommand.Quantity + stockReservedEvent.Quantity, reservation.Quantity);
//Then_Aggregate_Reservation_should_have_new_expiration_time()
Assert.Equal(expirationDate, reservation.ExpirationDate);
//Then_Aggregate_Reservation_should_remain_for_same_customer()
Assert.NotNull(reservation);
//Then_correct_events_should_be_raised()
}
public async Task Given_sku_created_and_stock_added_and_stock_reserved_messages_When_projected_twice()
{
var stockId = Guid.NewGuid();
var stockCreatedEvent = new SkuStockCreated(stockId, Guid.NewGuid(), 1, TimeSpan.FromDays(2));
var stockAddedEvent = new StockAdded(stockId, 15, "test pack");
var stockReservedEvent = new StockReserved(stockId, Guid.NewGuid(), DateTime.Now.AddDays(1), 7);
var reserveCanceledEvent = new ReserveCanceled(stockId, stockReservedEvent.ReserveId);
await ProjectionBuilder.Handle(stockCreatedEvent);
await ProjectionBuilder.Handle(stockAddedEvent);
await ProjectionBuilder.Handle(stockReservedEvent);
await ProjectionBuilder.Handle(reserveCanceledEvent);
await ProjectionBuilder.Handle(reserveCanceledEvent)
.ShouldThrow <ReserveEntryNotFoundException>();
}
public Task Consume(ConsumeContext <BasketCheckedOut> context)
{
var basket = context.Message.Basket;
//unabele to do this query, will have to do a number of selects
//var itemIds = basket.Items.Select(x => x.Id).ToList();
//var stockItems = _documentSession.Query<StockItem>().Where(x => itemIds.Any(id => id == x.Id)).ToList();
var reserved = new ReservedStock()
{
Id = basket.Id
};
foreach (var basketItem in basket.Items)
{
//var stockItem = stockItems.FirstOrDefault(x => x.Id == basketItem.Id);
var stockItem = _documentSession.Query <StockItem>().First(x => x.Id == basketItem.Id);
if (stockItem.Quantity < basketItem.Quantity)
{
continue;
}
reserved.Items.Add(basketItem.Id, basketItem.Quantity);
stockItem.Quantity -= basketItem.Quantity;
}
_documentSession.Insert(reserved);
_documentSession.SaveChanges();
var reservedStock = new StockReserved()
{
Id = reserved.Id,
Items = reserved.Items
};
_bus.Publish(reservedStock);
return(Task.CompletedTask);
}
public async Task Handle(StockReserved msg, IMessageMetadata metadata = null)
{
using (var context = _contextFactory())
{
var skuStock = await context.SkuStocks.FindAsync(msg.SourceId);
if (skuStock == null)
{
throw new SkuStockEntryNotFoundException(msg.SourceId);
}
var reserve = new SkuReserve
{
Created = msg.CreatedTime,
CustomerId = msg.ReserveId,
ExpirationDate = msg.ExpirationDate,
Quantity = msg.Quantity,
SkuId = skuStock.SkuId,
StockId = msg.SourceId
};
var history = CreateHistory(skuStock, StockOperation.Reserved, msg.Quantity);
skuStock.AvailableQuantity -= msg.Quantity;
skuStock.ReservedQuantity += msg.Quantity;
skuStock.CustomersReservationsTotal++;
skuStock.LastModified = msg.CreatedTime;
FillNewQuantities(history, skuStock);
context.StockHistory.Add(history);
context.StockReserves.Add(reserve);
await context.SaveChangesAsync();
}
}
