public async Task When_raising_future_event()
{
var scheduledTime = DateTime.Now.AddSeconds(200);
var testCommand = new ScheduleEventInFutureCommand(scheduledTime, Guid.NewGuid().ToString(), "test value");
var futureEventEnvelop =
(await Node.Prepare(testCommand).Expect <FutureEventScheduledEvent>().Execute())
.Message <FutureEventScheduledEvent>();
var cancelFutureEventCommand = new CancelFutureEventCommand(testCommand.AggregateId, testCommand.Value);
var futureEventCancelation =
(await Node.Prepare(cancelFutureEventCommand).Expect <FutureEventCanceledEvent>().Execute())
.Message <FutureEventCanceledEvent>();
//Cancelation_event_has_same_id_as_future_event()
Assert.Equal(futureEventEnvelop.Id, futureEventCancelation.FutureEventId);
//Scheduler_does_not_contain_job_for_future_event()
var scheduler = Node.System.GetExtension <SchedulingExtension>().Scheduler;
//scheduler needs time to cancel the event
//TODO: remove sleep to explicit wait
await Task.Delay(2000);
var scheduleKey = FutureEventsSchedulingMessageHandler.CreateScheduleKey(futureEventEnvelop.Id,
testCommand.AggregateId,
nameof(TestFutureEventsAggregate));
var jobKey = new JobKey(scheduleKey.Name, scheduleKey.Group);
Assert.False(await scheduler.CheckExists(jobKey));
}
public async Task It_fires_after_node_restart()
{
var cmd = new ScheduleEventInFutureCommand(DateTime.Now.AddSeconds(10),
Guid.NewGuid(),
"test value");
GridNode.NewCommandWaiter()
.Expect <FutureEventScheduledEvent>(e => e.Event.SourceId == cmd.AggregateId)
.Create()
.Execute(cmd)
.Wait(Timeout);
await GridNode.Stop();
await GridNode.Start();
var waiter = GridNode.NewWaiter()
.Expect <FutureEventOccuredEvent>(e => e.SourceId == cmd.AggregateId)
.Create();
waiter.Wait(Timeout);
var repo = new AggregateRepository(new ActorSystemEventRepository(GridNode.System), GridNode.EventsAdaptersCatalog);
var aggregate = repo.LoadAggregate <TestAggregate>(cmd.AggregateId);
Assert.LessOrEqual(aggregate.ProcessedTime - cmd.RaiseTime, TimeSpan.FromSeconds(2));
}
public async Task When_execute_aggregate_command()
{
var command = new ScheduleEventInFutureCommand(DateTime.Now.AddMilliseconds(100), Guid.NewGuid().ToString(), "12");
var commandMetadata = MessageMetadata.New(command.Id, Guid.NewGuid().ToString(), null);
var res = await Node.Prepare(command, commandMetadata)
.Expect <ValueChangedSuccessfullyEvent>()
.And <JobSucceeded>()
.Execute();
var answer = res.MessageWithMetadata <ValueChangedSuccessfullyEvent>();
var jobSucced = res.MessageWithMetadata <JobSucceeded>();
//Result_contains_metadata()
Assert.NotNull(answer.Metadata);
//Result_contains_message()
Assert.NotNull(answer.Message);
//Result_message_has_expected_type()
Assert.IsAssignableFrom <ValueChangedSuccessfullyEvent>(answer.Message);
//Result_message_has_expected_id()
Assert.Equal(command.AggregateId, answer.Message.SourceId);
//Result_metadata_has_command_id_as_casuation_id()
Assert.Equal((jobSucced.Message.Message as ICommand)?.Id, answer.Metadata.CasuationId);
//Result_metadata_has_correlation_id_same_as_command_metadata()
Assert.Equal(commandMetadata.CorrelationId, answer.Metadata.CorrelationId);
//Result_metadata_has_processed_history_filled_from_aggregate()
//Assert.Equal(1, answer.Metadata.History?.Steps.Count);
////Result_metadata_has_processed_correct_filled_history_step()
//var step = answer.Metadata.History.Steps.First();
//
//Assert.Equal(AggregateActorName.New<TestFutureEventsAggregate>(command.AggregateId).Name, step.Who);
//Assert.Equal(AggregateActorConstants.CommandExecutionCreatedAnEvent, step.Why);
//Assert.Equal(AggregateActorConstants.PublishingEvent, step.What);
}
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 async Task When_raising_future_event()
{
var scheduledTime = DateTime.Now.AddSeconds(1);
var testCommand = new ScheduleEventInFutureCommand(scheduledTime, Guid.NewGuid().ToString(), "test value");
var waitResults = await Node.Prepare(testCommand)
.Expect <FutureEventScheduledEvent>()
.And <ValueChangedSuccessfullyEvent>()
.Execute();
var futureEventEnvelop = waitResults.Message <FutureEventScheduledEvent>();
var producedEvent = waitResults.Message <ValueChangedSuccessfullyEvent>();
var aggregate = await this.LoadAggregateByActor <TestFutureEventsAggregate>(testCommand.AggregateId);
//Future_event_fires_in_time()
Assert.True(scheduledTime.Second - aggregate.ProcessedTime.Second <= 1);
//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);
}
protected async Task <TestAggregate> RaiseFutureEventInTime(DateTime scheduledTime)
{
var testCommand = new ScheduleEventInFutureCommand(scheduledTime, Guid.NewGuid(), "test value");
await GridNode.PrepareCommand(testCommand).Expect <TestDomainEvent>().Execute();
return(LoadAggregate <TestAggregate>(testCommand.AggregateId));
}
public async Task FutureDomainEvent_envelops_has_unique_id()
{
_aggregateId = Guid.NewGuid();
var testCommandA = new ScheduleEventInFutureCommand(DateTime.Now.AddSeconds(1), _aggregateId, "test value A");
var testCommandB = new ScheduleEventInFutureCommand(DateTime.Now.AddSeconds(2), _aggregateId, "test value B");
_eventA = await GridNode.Execute(CommandPlan.New(testCommandA, Timeout, Expect.Message <FutureEventOccuredEvent>(e => e.SourceId, testCommandA.AggregateId)));
_eventB = await GridNode.Execute(CommandPlan.New(testCommandB, Timeout, Expect.Message <FutureEventOccuredEvent>(e => e.SourceId, testCommandB.AggregateId)));
}
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 async Task Given_aggregate_When_raising_future_event_in_past_Then_it_fires_immediatly()
{
var scheduledTime = DateTime.Now.AddSeconds(-5);
var now = DateTime.Now;
var testCommand = new ScheduleEventInFutureCommand(scheduledTime, Guid.NewGuid().ToString(), "test value");
await Node.Prepare(testCommand)
.Expect <JobSucceeded>()
.Execute();
var aggregate = await Node.LoadAggregate <TestFutureEventsAggregate>(testCommand.AggregateId);
Assert.True(now.Second - aggregate.ProcessedTime.Second <= 1);
}
public async Task When_execute_aggregate_command_with_fault_and_metadata()
{
_command = new ScheduleEventInFutureCommand(DateTime.Now.AddMilliseconds(20), Guid.NewGuid(), "12");
_commandMetadata = new MessageMetadata(_command.Id, BusinessDateTime.Now, Guid.NewGuid());
var res = await GridNode.NewCommandWaiter(null, false)
.Expect <IMessageMetadataEnvelop <TestDomainEvent> >()
.And <IMessageMetadataEnvelop <JobSucceeded> >()
.Create()
.Execute(_command, _commandMetadata);
_answer = res.Message <IMessageMetadataEnvelop <TestDomainEvent> >();
_jobSucced = res.Message <IMessageMetadataEnvelop <JobSucceeded> >();
}
public void When_raising_future_event()
{
var testCommand = new ScheduleEventInFutureCommand(DateTime.Now, Guid.NewGuid().ToString(), "test value");
var aggregate = new TestFutureEventsAggregate(testCommand.AggregateId);
aggregate.ScheduleInFuture(testCommand.RaiseTime, testCommand.Value);
var futureEventEnvelop = aggregate.GetEvent <FutureEventScheduledEvent>();
aggregate.ApplyEvent(futureEventEnvelop);
//quite ugly, but it only safe way to run some logic after scheduled event persistence
aggregate.RaiseScheduledEvent(futureEventEnvelop.Id, Guid.NewGuid().ToString());
}
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 void Raising_several_future_events_for_different_aggregates()
{
_commandA = new ScheduleEventInFutureCommand(DateTime.Now.AddSeconds(0.5), Guid.NewGuid(), "test value A");
var expectedMessageA = Expect.Message <FutureEventOccuredEvent>(e => e.SourceId, _commandA.AggregateId);
var planA = CommandPlan.New(_commandA, expectedMessageA);
_commandB = new ScheduleEventInFutureCommand(DateTime.Now.AddSeconds(0.5), Guid.NewGuid(), "test value B");
var expectedMessageB = Expect.Message <FutureEventOccuredEvent>(e => e.SourceId, _commandB.AggregateId);
var planB = CommandPlan.New(_commandB, expectedMessageB);
var taskA = GridNode.Execute <FutureEventOccuredEvent>(planA).ContinueWith(r => _eventA = r.Result);
var taskB = GridNode.Execute <FutureEventOccuredEvent>(planB).ContinueWith(r => _eventB = r.Result);
Task.WaitAll(taskA, taskB);
}
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>();
}
public async Task Given_aggregate_When_reraising_future_event_Then_it_fires_in_time()
{
var aggregateId = Guid.NewGuid();
var testCommand = new ScheduleEventInFutureCommand(DateTime.Now.AddSeconds(1), aggregateId, "test value");
await GridNode.PrepareCommand(testCommand).Expect <TestDomainEvent>().Execute();
var reraiseTime = DateTime.Now.AddSeconds(1);
testCommand = new ScheduleEventInFutureCommand(reraiseTime, aggregateId, "test value");
await GridNode.PrepareCommand(testCommand).Expect <TestDomainEvent>().Execute();
var aggregate = LoadAggregate <TestAggregate>(aggregateId);
Assert.LessOrEqual(reraiseTime.Second - aggregate.ProcessedTime.Second, 1);
}
public async Task Raising_several_future_events_for_different_aggregates()
{
var commandA = new ScheduleEventInFutureCommand(DateTime.Now.AddSeconds(0.5), Guid.NewGuid().ToString(), "test value A");
var commandB = new ScheduleEventInFutureCommand(DateTime.Now.AddSeconds(0.5), Guid.NewGuid().ToString(), "test value B");
var eventA =
await Node.Prepare(commandA).Expect <FutureEventOccuredEvent>().Execute().Received();
var eventB =
await Node.Prepare(commandB).Expect <FutureEventOccuredEvent>().Execute().Received();
//Future_event_ids_are_different()
Assert.NotEqual(eventA.FutureEventId, eventB.FutureEventId);
//EventA_is_result_of_commandA()
Assert.Equal(eventA.SourceId, commandA.AggregateId);
//EventB_is_result_of_commandB()
Assert.Equal(eventB.SourceId, commandB.AggregateId);
}
public async Task FutureDomainEvent_envelops_has_unique_id()
{
var aggregateId = Guid.NewGuid().ToString();
var testCommandA = new ScheduleEventInFutureCommand(DateTime.Now.AddSeconds(0.1), aggregateId, "test value A");
var testCommandB = new ScheduleEventInFutureCommand(DateTime.Now.AddSeconds(0.1), aggregateId, "test value B");
var eventA =
(await Node.Prepare(testCommandA).Expect <FutureEventOccuredEvent>().Execute())
.Message <FutureEventOccuredEvent>();
var eventB =
(await Node.Prepare(testCommandB).Expect <FutureEventOccuredEvent>().Execute())
.Message <FutureEventOccuredEvent>();
//Envelop_ids_are_different()
Assert.NotEqual(eventA.FutureEventId, eventB.FutureEventId);
//Envelop_id_not_equal_to_aggregate_id()
Assert.True(eventA.Id != aggregateId && aggregateId != eventB.Id);
}
public async Task It_fires_after_node_restart()
{
var logger = new XUnitAutoTestLoggerConfiguration(_testOutputHelper, LogEventLevel.Warning).CreateLogger();
var node = await new FutureEventsFixture(_testOutputHelper, new PersistedQuartzConfig())
.UseSqlPersistence()
.CreateNode(logger);
var cmd = new ScheduleEventInFutureCommand(BusinessDateTime.UtcNow.AddSeconds(5), Guid.NewGuid().ToString(), "test value");
await node.Execute(cmd);
await node.Stop();
node = await new FutureEventsFixture(_testOutputHelper, new PersistedQuartzConfig(), false).UseSqlPersistence(false).CreateNode();
_testOutputHelper.WriteLine("starting waiter creation");
var res = await node.NewWaiter(TimeSpan.FromSeconds(30))
.Expect <FutureEventOccuredEvent>(e => e.SourceId == cmd.AggregateId)
.Create();
var evt = res.Message <FutureEventOccuredEvent>();
Assert.True(evt.CreatedTime - cmd.RaiseTime <= TimeSpan.FromSeconds(2));
}
