public void Async_execute_dont_wait_for_command_finish()
{
var syncCommand = new AsyncMethodCommand(42, Guid.NewGuid());
GridNode.Execute(syncCommand);
var aggregate = LoadAggregate <SampleAggregate>(syncCommand.AggregateId);
Assert.AreNotEqual(syncCommand.Parameter, aggregate.Value);
}
public async Task When_async_method_finished_produced_events_has_sagaId_from_command()
{
var externalCallCommand = new AsyncMethodCommand(43, Guid.NewGuid(), Guid.NewGuid());
var domainEvent = await GridNode.Execute(CommandPlan.New(externalCallCommand,
TimeSpan.FromDays(1),
Expect.Message <SampleAggregateChangedEvent>(e => e.SourceId,
externalCallCommand.AggregateId)));
Assert.AreEqual(externalCallCommand.SagaId, domainEvent.SagaId);
}
public async Task After_wait_end_aggregate_event_is_applied()
{
var syncCommand = new AsyncMethodCommand(42, Guid.NewGuid());
await GridNode.Execute(CommandPlan.New(syncCommand,
Timeout,
Expect.Message <SampleAggregateChangedEvent>(e => e.SourceId, syncCommand.AggregateId)));
var aggregate = LoadAggregate <SampleAggregate>(syncCommand.AggregateId);
Assert.AreEqual(syncCommand.Parameter.ToString(), aggregate.Value);
}
public async Task After_wait_of_async_command_aggregate_should_be_changed()
{
var cmd = new AsyncMethodCommand(42, Guid.NewGuid(), Guid.NewGuid(), TimeSpan.FromMilliseconds(50));
var res = await GridNode.NewCommandWaiter(Timeout)
.Expect <SampleAggregateChangedEvent>(e => e.SourceId == cmd.AggregateId)
.Create()
.Execute(cmd);
Assert.AreEqual(cmd.Parameter.ToString(), res.Message <SampleAggregateChangedEvent>().Value);
}
public async Task When_async_method_is_called_domainEvents_are_persisted()
{
var cmd = new AsyncMethodCommand(43, Guid.NewGuid(), Guid.Empty, TimeSpan.FromMilliseconds(50));
await GridNode.PrepareCommand(cmd)
.Expect <SampleAggregateChangedEvent>()
.Execute();
var aggregate = LoadAggregate <SampleAggregate>(cmd.AggregateId);
Assert.AreEqual(cmd.Parameter.ToString(), aggregate.Value);
}
public async Task After_wait_aggregate_should_be_changed()
{
var syncCommand = new AsyncMethodCommand(42, Guid.NewGuid());
var expectedMessage = Expect.Message <AggregateChangedEventNotification>(e => e.AggregateId,
syncCommand.AggregateId);
await GridNode.Execute(CommandPlan.New(syncCommand, Timeout, expectedMessage));
var aggregate = LoadAggregate <SampleAggregate>(syncCommand.AggregateId);
Assert.AreEqual(syncCommand.Parameter.ToString(), aggregate.Value);
}
public void When_execute_aggregate_command_with_metadata()
{
_command = new AsyncMethodCommand(1, Guid.NewGuid());
_commandMetadata = new MessageMetadata(_command.Id, BusinessDateTime.Now, Guid.NewGuid());
var res = GridNode.NewCommandWaiter()
.Expect <IMessageMetadataEnvelop <SampleAggregateChangedEvent> >()
.Create()
.Execute(_command, _commandMetadata)
.Result;
_answer = res.Message <IMessageMetadataEnvelop <SampleAggregateChangedEvent> >();
}
public void Then_events_are_applied_to_aggregate_after_wait_finish()
{
var cmd = new AsyncMethodCommand(42, Guid.NewGuid());
var expectedMessage = Expect.Message <AggregateChangedEventNotification>(e => e.AggregateId, cmd.AggregateId);
var task = GridNode.Execute(cmd, expectedMessage);
if (!task.Wait(Timeout))
{
throw new TimeoutException();
}
var aggregate = LoadAggregate <SampleAggregate>(cmd.AggregateId);
Assert.AreEqual(cmd.Parameter.ToString(), aggregate.Value);
}
public void Then_events_are_applied_to_aggregate_after_wait_finish()
{
var syncCommand = new AsyncMethodCommand(42, Guid.NewGuid());
var expectedMessage = Expect.Message <SampleAggregateChangedEvent>(e => e.SourceId,
syncCommand.AggregateId);
var task = GridNode.Execute(CommandPlan.New(syncCommand, expectedMessage));
if (!task.Wait(Timeout))
{
throw new TimeoutException();
}
//to finish persistence
var aggregate = LoadAggregate <SampleAggregate>(syncCommand.AggregateId);
Assert.AreEqual(syncCommand.Parameter.ToString(), aggregate.Value);
}
public async Task When_async_method_is_called_other_commands_can_be_executed_before_async_results()
{
var aggregateId = Guid.NewGuid();
var asyncCommand = new AsyncMethodCommand(43, Guid.NewGuid(), Guid.NewGuid(), TimeSpan.FromSeconds(3));
var syncCommand = new ChangeSampleAggregateCommand(42, aggregateId);
var asyncCommandTask = GridNode.PrepareCommand(asyncCommand)
.Expect <SampleAggregateChangedEvent>()
.Execute();
await GridNode.Execute(CommandPlan.New(syncCommand,
TimeSpan.FromSeconds(1),
Expect.Message <SampleAggregateChangedEvent>(e => e.SourceId,
syncCommand.AggregateId)));
var sampleAggregate = LoadAggregate <SampleAggregate>(syncCommand.AggregateId);
Assert.AreEqual(syncCommand.Parameter.ToString(), sampleAggregate.Value);
var waitResults = await asyncCommandTask;
Assert.AreEqual(asyncCommand.Parameter.ToString(), waitResults.Message <SampleAggregateChangedEvent>().Value);
}
