private static Task AfterScheduledEventOccures(TestFutureEventsAggregate aggregate,
FutureEventScheduledEvent futureEventEnvelop,
ScheduleEventInFutureCommand testCommand)
{
var producedEvent = aggregate.GetEvent <ValueChangedSuccessfullyEvent>();
aggregate.ApplyEvent(producedEvent);
var futureEventOccuredEvent = aggregate.GetEvent <FutureEventOccuredEvent>();
aggregate.ApplyEvent(futureEventOccuredEvent);
//Future_event_occurance_has_same_id_as_future_event()
Assert.Equal(futureEventEnvelop.Id, futureEventOccuredEvent.FutureEventId);
//Future_event_applies_to_aggregate()
Assert.Equal(producedEvent.Value, aggregate.Value);
//Future_event_envelop_has_id_different_from_aggregate()
Assert.NotEqual(futureEventEnvelop.Id, aggregate.Id);
//Future_event_sourceId_is_aggregate_id()
Assert.Equal(futureEventEnvelop.SourceId, aggregate.Id);
//Future_event_payload_is_aggregate_original_event()
Assert.Equal(((ValueChangedSuccessfullyEvent)futureEventEnvelop.Event).Id, producedEvent.Id);
//Future_event_contains_data_from_command()
Assert.Equal(testCommand.Value, producedEvent.Value);
return(Task.CompletedTask);
}
public void Handle(FutureEventScheduledEvent futureEventScheduledEvent, IMessageMetadata messageMetadata)
{
var message = futureEventScheduledEvent;
Guid scheduleId = message.Id;
Guid aggregateId = message.Event.SourceId;
var description = $"Aggregate {typeof(TAggregate).Name} id = {aggregateId} scheduled future event " +
$"{scheduleId} with payload type {message.Event.GetType().Name} on time {message.RaiseTime}\r\n" +
$"Future event: {message.ToPropsString()}";
var scheduleKey = CreateScheduleKey(scheduleId, aggregateId, description);
var command = new RaiseScheduledDomainEventCommand(message.Id, message.SourceId, Guid.NewGuid());
var metadata = messageMetadata.CreateChild(command.Id,
new ProcessEntry(GetType().Name,
"Scheduling raise future event command",
"FutureEventScheduled event occured"));
var confirmationEventType = typeof(IMessageMetadataEnvelop<>).MakeGenericType(message.Event.GetType());
var scheduleEvent = new ScheduleCommand(command,
scheduleKey,
new ExtendedExecutionOptions(message.RaiseTime,
confirmationEventType,
message.Event.SourceId,
nameof(DomainEvent.SourceId)),
metadata);
_schedulerActorRef.Handle(scheduleEvent);
}
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 void When_cancel_existing_scheduled_future_event()
{
_aggregate = new TestAggregate(Guid.NewGuid());
var testValue = "value D";
_aggregate.ScheduleInFuture(DateTime.Now.AddSeconds(400), testValue);
_futureEvent = _aggregate.GetEvent <FutureEventScheduledEvent>();
_aggregate.ClearEvents();
_aggregate.CancelFutureEvents("will not be found in any future event");
}
public void When_raising_future_event()
{
_testCommand = new ScheduleEventInFutureCommand(DateTime.Now, Guid.NewGuid(), "test value");
_aggregate = new TestAggregate(_testCommand.AggregateId);
_aggregate.ScheduleInFuture(_testCommand.RaiseTime, _testCommand.Value);
_futureEventEnvelop = _aggregate.GetEvent <FutureEventScheduledEvent>();
_aggregate.RaiseScheduledEvent(_futureEventEnvelop.Id);
_producedEvent = _aggregate.GetEvent <TestDomainEvent>();
_futureEventOccuredEvent = _aggregate.GetEvent <FutureEventOccuredEvent>();
}
public void When_cancel_existing_scheduled_future_event()
{
_aggregate = new TestAggregate(Guid.NewGuid());
var testValue = "value D";
_aggregate.ScheduleInFuture(DateTime.Now.AddSeconds(400), testValue);
_aggregate.ScheduleInFuture(DateTime.Now.AddSeconds(400), "test value E");
_futureEventA = _aggregate.GetEvents <FutureEventScheduledEvent>().First();
_futureEvent_out_of_criteria = _aggregate.GetEvents <FutureEventScheduledEvent>().Skip(1).First();
_aggregate.ClearEvents();
_aggregate.CancelFutureEvents(testValue);
}
public async Task When_raising_future_event()
{
_scheduledTime = DateTime.Now.AddSeconds(1);
_testCommand = new ScheduleEventInFutureCommand(_scheduledTime, Guid.NewGuid(), "test value");
var waitResults = await GridNode.PrepareCommand(_testCommand)
.Expect <FutureEventScheduledEvent>()
.And <TestDomainEvent>()
.Execute();
_futureEventEnvelop = waitResults.Message <FutureEventScheduledEvent>();
_producedEvent = waitResults.Message <TestDomainEvent>();
_aggregate = LoadAggregate <TestAggregate>(_testCommand.AggregateId);
}
public async Task When_raising_future_event()
{
_scheduledTime = DateTime.Now.AddSeconds(200);
_testCommand = new ScheduleEventInFutureCommand(_scheduledTime, Guid.NewGuid(), "test value");
_futureEventEnvelop = (await GridNode.PrepareCommand(_testCommand)
.Expect <FutureEventScheduledEvent>()
.Execute())
.Message <FutureEventScheduledEvent>();
_cancelFutureEventCommand = new CancelFutureEventCommand(_testCommand.AggregateId, _testCommand.Value);
_futureEventCancelation = (await GridNode.PrepareCommand(_cancelFutureEventCommand)
.Expect <FutureEventCanceledEvent>()
.Execute())
.Message <FutureEventCanceledEvent>();
}
private void Apply(FutureEventScheduledEvent e)
{
FutureEvents[e.Id] = e;
}
