private AggregateScenario <Order> GivenNewOrder()
{
var scenario = AggregateScenario.New(new OrderCommandsHandler(new InMemorySequenceProvider()));
scenario.Given(new OrderCreated(Guid.NewGuid(), 123, Guid.NewGuid()));
return(scenario);
}
public async Task Given_sku_stock_with_amount_and_reserve_When_reserve_expires()
{
var aggregateId = Guid.NewGuid();
var customerId = Guid.NewGuid();
var reservationStartTime = BusinessDateTime.Now;
var reserveTime = TimeSpan.FromMilliseconds(100);
var expirationDate = reservationStartTime + reserveTime;
var futureEventId = Guid.NewGuid();
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"),
new StockReserved(aggregateId, customerId, expirationDate, 5),
new FutureEventScheduledEvent(futureEventId,
aggregateId,
expirationDate,
new ReserveExpired(aggregateId, customerId)))
.When(new RaiseScheduledDomainEventCommand(futureEventId, aggregateId, Guid.NewGuid()))
.Then(new ReserveExpired(aggregateId, customerId),
new FutureEventOccuredEvent(Any.GUID, futureEventId, aggregateId))
.Run();
scenario.Check();
//Then reserved stock quantity should be returned to sku stock
Assert.Equal(initialQuantity + addedQuantity, scenario.Aggregate.Quantity);
//Then_reservation should be removed from aggregate
Assert.Empty(scenario.Aggregate.Reservations);
//Then expiration events should be raised
}
public async Task When_withdraw_too_much_Not_enough_money_error_is_occured()
{
var scenario = AggregateScenario.New <Account, AccountCommandsHandler>();
await scenario.Given(new AccountCreated(scenario.Aggregate.Id, Guid.NewGuid(), 34),
new AccountReplenish(scenario.Aggregate.Id, Guid.NewGuid(), new Money(100)))
.When(new PayForOrderCommand(scenario.Aggregate.Id, new Money(10000), Guid.NewGuid()))
.Run()
.CommandShouldThrow <NotEnoughMoneyException>();
}
public async Task When_add_sku_not_belonging_to_stock_should_throw_exception()
{
var id = Guid.NewGuid();
await AggregateScenario.New <SkuStock, SkuStockCommandsHandler>()
.Given(new SkuStockCreated(id, _skuId, 50, TimeSpan.FromMilliseconds(100)))
.When(new AddToStockCommand(id, Guid.NewGuid(), 10, "test batch"))
.Run()
.CommandShouldThrow <InvalidSkuAddException>();
}
public async Task When_order_completes_it_chages_status_to_paid()
{
var scenario = AggregateScenario.New(new OrderCommandsHandler(new InMemorySequenceProvider()));
await scenario.Given(new OrderCreated(scenario.Aggregate.Id, 123, Guid.NewGuid()),
new OrderCompleted(scenario.Aggregate.Id, OrderStatus.Paid))
.Run();
Assert.Equal(OrderStatus.Paid, scenario.Aggregate.Status);
}
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 When_defined_scenario_executes_command_with_excpetion_it_throws_command_exception()
{
var aggregateId = Guid.NewGuid().ToString();
await AggregateScenario.New <Balloon, BalloonCommandHandler>()
.When(new PlanTitleWriteAndBlowCommand(43, aggregateId, TimeSpan.FromMilliseconds(50)))
.Run()
.Check().CommandShouldThrow((Predicate <BalloonException>)null);
}
public async Task When_add_negative_amount_should_throw_exception()
{
var id = Guid.NewGuid();
await AggregateScenario.New <SkuStock, SkuStockCommandsHandler>()
.Given(new SkuStockCreated(id, _skuId, 50, TimeSpan.FromMilliseconds(100)))
.When(new AddToStockCommand(id, _skuId, -10, "test batch"))
.Run()
.CommandShouldThrow <ArgumentException>();
}
public async Task When_completed_order_try_complete_it_throws_exeption()
{
var scenario = AggregateScenario.New(new OrderCommandsHandler(new InMemorySequenceProvider()));
await scenario.Given(new OrderCreated(scenario.Aggregate.Id, 123, Guid.NewGuid()),
new OrderCompleted(scenario.Aggregate.Id, OrderStatus.Paid))
.When(new CompleteOrderCommand(scenario.Aggregate.Id))
.Run()
.CommandShouldThrow <CannotCompleteAlreadyClosedOrderException>();
}
public async Task When_take_too_many_should_throw_exception()
{
var id = Guid.NewGuid();
await AggregateScenario.New <SkuStock, SkuStockCommandsHandler>()
.Given(new SkuStockCreated(id, _skuId, 50, TimeSpan.FromMilliseconds(100)),
new StockAdded(id, 10, "test batch 2"))
.When(new TakeFromStockCommand(id, 100))
.Run()
.CommandShouldThrow <OutOfStockException>();
}
[InlineData("fact(5)", 120D, "fact")] //factorial
public async Task Given_term_expression_with_build_in_functions_When_calculating_Then_answer_is_provided(
string expression, double answer, params string[] functionUsed)
{
await AggregateScenario.New <Calculator>()
.When(new CalculateExpression("myCalc", expression, new Parameter[] { }))
.Then(new CalculationPerformed("myCalc", 0, expression, new Parameter[] { }, answer, functionUsed))
.Run
.Local(_log)
.Check();
}
public async Task When_creating_stock_with_negative_number_error_is_raised()
{
await AggregateScenario.New <SkuStock, SkuStockCommandsHandler>()
.When(new CreateSkuStockCommand(Guid.NewGuid(),
Guid.NewGuid(),
-10,
"test batch",
TimeSpan.FromDays(1)))
.Run()
.CommandShouldThrow <ArgumentException>();
}
public async Task When_defined_scenario_it_checks_for_produced_events_properties()
{
var aggregateId = Guid.NewGuid().ToString();
await AggregateScenario.New <Balloon, BalloonCommandHandler>()
.When(new InflateNewBallonCommand(42, aggregateId))
.Then(new BalloonCreated("420", aggregateId))
.Run()
.Check()
.ShouldThrow <ProducedEventsDifferException>();
}
public async Task When_creating_order_with_negative_number_it_throws_exception()
{
var sequenceNumberMock = new Mock <ISequenceProvider>();
sequenceNumberMock.Setup(p => p.GetNext(It.IsAny <string>())).Returns(-1);
await AggregateScenario.New(new OrderCommandsHandler(sequenceNumberMock.Object))
.When(new CreateOrderCommand(Guid.NewGuid(), Guid.NewGuid()))
.Run()
.CommandShouldThrow <NegativeOrderNumberException>();
}
public async Task When_creating_new_sku()
{
var id = Guid.NewGuid();
CreateNewSkuCommand cmd;
await AggregateScenario.New(new SkuCommandsHandler(new InMemorySequenceProvider()))
.When(cmd = new CreateNewSkuCommand("testSku", "tesstArticle", id, new Money(100)))
.Then(new SkuCreated(id, cmd.Name, cmd.Article, 1, new Money(100)))
.Run()
.Check();
}
public static async Task Main(string[] args)
{
// await AwaitScenario.RunSingleTask();
// await AwaitScenario.RunWhenAll();
// await AwaitScenario.RunMultipleTasks();
// await AwaitScenario.RunSingleVoidTask();
await AggregateScenario.RunAggregateAwaited();
await AggregateScenario.RunAggregateNonAwaited();
}
private void CreateAggregateScenario()
{
var aggregateScenario = new AggregateScenario(AggregateScenarios)
{
CreateTime = DateTime.Now,
UpdateTime = DateTime.Now,
Name = DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss")
};
_repository.Add(aggregateScenario);
}
public async Task When_defined_scenario_try_execute_missing_command_on_default_handler_it_throws_exception()
{
var aggregateId = Guid.NewGuid().ToString();
await AggregateScenario.New <Balloon, BalloonCommandHandler>()
.When(new CreateBalanceCommand(42, aggregateId))
.Then(new BalloonCreated("420", aggregateId),
new BalloonTitleChanged("42", aggregateId))
.Run()
.Check().CommandShouldThrow((Predicate <CannotFindAggregateCommandHandlerExeption>)null);
}
public async Task Given_order_with_items_When_calculate_total_Then_calculate_total_event_is_raised()
{
var sourceId = Guid.NewGuid();
await AggregateScenario.New(new OrderCommandsHandler(new InMemorySequenceProvider()))
.Given(new OrderCreated(sourceId, 123, Guid.NewGuid()),
new ItemAdded(sourceId, Guid.NewGuid(), 1, new Money(50), 1))
.When(new CalculateOrderTotalCommand(sourceId))
.Then(new OrderTotalCalculated(sourceId, new Money(50)))
.Run()
.Check();
}
public async Task When_completed_order_try_add_items_it_throws_exeption()
{
var scenario = AggregateScenario.New(new OrderCommandsHandler(new InMemorySequenceProvider()));
await scenario.Given(new OrderCreated(scenario.Aggregate.Id, 123, Guid.NewGuid()),
new OrderCompleted(scenario.Aggregate.Id, OrderStatus.Paid))
.When(new AddItemToOrderCommand(scenario.Aggregate.Id,
Guid.NewGuid(),
123,
new Money(1)))
.Run()
.CommandShouldThrow <CantAddItemsToClosedOrder>();
}
public async Task When_defined_scenario_executes_command_with_exception_it_throws_command_exception()
{
var name = "Circle";
var aggregateScenarioBuilder = AggregateScenario.New <Cat>()
.Name(nameof(When_defined_scenario_executes_command_with_exception_it_throws_command_exception))
.When(new Cat.GetNewCatCommand(name),
new Cat.PetCommand(name));
var local = Run(aggregateScenarioBuilder);
await local
.Check()
.ShouldThrow <Cat.IsUnhappyException>();
}
public async Task When_defined_scenario_try_execute_missing_command_it_throws_exception()
{
var aggregateId = "test_aggregate";
var aggregateScenarioBuilder = AggregateScenario.New <Cat>()
.Name(nameof(When_defined_scenario_try_execute_missing_command_it_throws_exception))
.When(new WrongCommand(aggregateId));
var run = Run(aggregateScenarioBuilder);
await run
.Check()
.ShouldThrow <UnknownCommandException>();
}
public void When_add_bad_formed_custom_function_Then_exception_is_raised()
{
AggregateScenario.New <Calculator>()
.When(new AddFunction("myCalc",
new FunctionDefinition("test",
2,
"Test function",
"sub(add(a,b),c)",
new string[] { })))
.Run
.Local(_log)
.ShouldThrow <Exception>();
}
public async Task When_add_custom_function_Then_can_use_it()
{
var functionDefinition = new FunctionDefinition("test",
3,
"Test function",
"sub(add(a,b),c)",
"a", "b", "c");
await AggregateScenario.New <Calculator>()
.Given(new CalculatorCreated("myCalc", 0))
.When(new AddFunction("myCalc", functionDefinition))
.Then(new FunctionAdded("myCalc", functionDefinition, 1))
.Run
.Local(_log)
.Check();
}
public async Task When_adding_stock_Aggregate_quantity_should_be_increased_by_command_amount()
{
AddToStockCommand command;
SkuStockCreated created;
StockAdded added;
var id = Guid.NewGuid();
var scenario = await AggregateScenario.New <SkuStock, SkuStockCommandsHandler>()
.Given(created = new SkuStockCreated(id, _skuId, 50, TimeSpan.FromMilliseconds(100)),
added = new StockAdded(id, 10, "test batch 2"))
.When(command = new AddToStockCommand(id, _skuId, 10, "test batch"))
.Then(new StockAdded(id, command.Quantity, command.BatchArticle))
.Run();
Assert.Equal(command.Quantity + created.Quantity + added.Quantity, scenario.Aggregate.Quantity);
}
public async Task When_creating_stock_Then_stock_created_event_is_raised()
{
var id = Guid.NewGuid();
CreateSkuStockCommand cmd;
var scenario = await AggregateScenario.New <SkuStock, SkuStockCommandsHandler>()
.When(cmd = new CreateSkuStockCommand(id, Guid.NewGuid(), 10, "test batch", TimeSpan.FromMinutes(1)))
.Then(new SkuStockCreated(id, cmd.SkuId, cmd.Quantity, cmd.ReserveTime))
.Run()
.Check();
//Quantity_is_passed_to_aggregate()
Assert.Equal(cmd.Quantity, scenario.Aggregate.Quantity);
//SkuId_is_passed_to_aggregate()
Assert.Equal(cmd.SkuId, scenario.Aggregate.SkuId);
}
public async Task When_defined_scenario_it_checks_for_produced_events_count()
{
var aggregateId = "Radja";
var aggregateScenarioBuilder = AggregateScenario.New <Cat>()
.Name(nameof(When_defined_scenario_it_checks_for_produced_events_count))
.When(new Cat.GetNewCatCommand(aggregateId))
.Then(new Cat.Born(aggregateId),
new Cat.Feeded(aggregateId));
var local = Run(aggregateScenarioBuilder);
await local
.Check()
.ShouldThrow <ProducedEventsCountMismatchException>();
}
public async Task When_account_replenished_Then_amount_should_be_increased()
{
ReplenishAccountByCardCommand command;
Money initialAmount;
var scenario = AggregateScenario.New <Account, AccountCommandsHandler>();
await scenario.Given(new AccountCreated(scenario.Aggregate.Id, Guid.NewGuid(), 123),
new AccountReplenish(scenario.Aggregate.Id, Guid.NewGuid(), initialAmount = new Money(100)))
.When(command = new ReplenishAccountByCardCommand(scenario.Aggregate.Id, new Money(12), "xxx123"))
.Then(new AccountReplenish(scenario.Aggregate.Id, command.Id, command.Amount))
.Run()
.Check();
Assert.Equal(initialAmount + command.Amount, scenario.Aggregate.Amount);
}
public async Task SkuStock_take_When_adding_stock()
{
var id = Guid.NewGuid();
TakeFromStockCommand cmd;
var scenario = await AggregateScenario.New <SkuStock, SkuStockCommandsHandler>()
.Given(new SkuStockCreated(id, _skuId, 50, TimeSpan.FromMilliseconds(100)),
new StockAdded(id, 10, "test batch 2"))
.When(cmd = new TakeFromStockCommand(id, 10))
.Then(new StockTaken(id, cmd.Quantity))
.Run()
.Check();
//Aggregate_quantity_should_be_decreased_by_command_amount()
Assert.Equal(60 - cmd.Quantity, scenario.Aggregate.Quantity);
}
public async Task When_defined_scenario_it_checks_for_produced_events_properties()
{
var aggregateId = "Mailk";
var builder = AggregateScenario.New <Cat>()
.Name(nameof(When_defined_scenario_it_checks_for_produced_events_properties))
.When(new Cat.GetNewCatCommand(aggregateId))
.Then(new Cat.Born(aggregateId));
var local = Run(builder);
await local
.Check()
.ShouldThrow <ProducedEventsDifferException>();
}
