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; }