public async Task Given_sku_stock_with_amount_When_reserve_first_time()
{
var reserveTime = TimeSpan.FromMilliseconds(100);
Reservation aggregateReserve;
FutureEventScheduledEvent reserveExpirationFutureEvent = null;
var aggregateId = Guid.NewGuid();
var reservationStartTime = BusinessDateTime.Now;
ReserveStockCommand reserveStockCommand;
var expirationDate = reservationStartTime + reserveTime;
var initialQuantity = 50;
var addedQuantity = 10;
var scenario = await AggregateScenario.New <SkuStock, SkuStockCommandsHandler>()
.Given(new SkuStockCreated(aggregateId, Guid.NewGuid(), initialQuantity, reserveTime),
new StockAdded(aggregateId, addedQuantity, "test batch 2"))
.When(reserveStockCommand = new ReserveStockCommand(aggregateId, Guid.NewGuid(), 10, reservationStartTime))
.Then(new StockReserved(reserveStockCommand.StockId,
reserveStockCommand.CustomerId,
expirationDate,
reserveStockCommand.Quantity),
new FutureEventScheduledEvent(Any.GUID,
aggregateId,
expirationDate,
new ReserveExpired(aggregateId, reserveStockCommand.CustomerId),
nameof(SkuStock)))
.Run().Check();
// Then_stock_reserved_event_should_be_raised()
scenario.Aggregate.Reservations.TryGetValue(reserveStockCommand.CustomerId, out aggregateReserve);
if (aggregateReserve != null)
{
reserveExpirationFutureEvent = scenario.Aggregate.FutureEvents.FirstOrDefault();
}
var reserveExpiredEvent = reserveExpirationFutureEvent?.Event as ReserveExpired;
// Aggregate_quantity_should_be_decreased_by_command_amount()
Assert.Equal(initialQuantity + addedQuantity - reserveStockCommand.Quantity, scenario.Aggregate.Quantity);
//Reserve_expiration_event_should_exist()
Assert.NotNull(reserveExpiredEvent);
//Reserve_expiration_event_should_have_reserve_id()
Assert.Equal(reserveStockCommand.CustomerId, reserveExpiredEvent?.ReserveId);
//Reserve_expiration_future_event_should_exist()
Assert.NotNull(reserveExpirationFutureEvent);
// Reserve_expiration_future_event_should_have_reservation_expiration_date()
Assert.Equal(aggregateReserve.ExpirationDate, reserveExpirationFutureEvent.RaiseTime);
//Then_aggregate_reservation_for_stock_should_have_correct_expiration_date()
Assert.Equal(expirationDate, aggregateReserve.ExpirationDate);
//Then_aggregate_reservation_for_stock_should_have_correct_quanity()
Assert.Equal(reserveStockCommand.Quantity, aggregateReserve.Quantity);
//Then_aggregate_reservation_should_be_added()
Assert.NotNull(aggregateReserve);
// Then_reservation_should_be_added_in_aggregate()
Assert.NotEmpty(scenario.Aggregate.Reservations);
}
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()
}
