public void When_publishing_start_message()
{
var gotTiredEvent = new GotTiredEvent(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
var gotTiredEventMetadata = MessageMetadata.New(gotTiredEvent.SourceId, Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
Node.Pipe.ProcessesPipeActor.Tell(new Initialize(TestActor));
Node.Pipe.ProcessesPipeActor.Tell(new MessageMetadataEnvelop <DomainEvent>(gotTiredEvent,
gotTiredEventMetadata));
var answer = FishForMessage <MessageMetadataEnvelop>(m => true, TimeSpan.FromSeconds(5));
var command = answer.Message as MakeCoffeCommand;
//Result_contains_metadata()
Assert.NotNull(answer.Metadata);
//Result_contains_message()
Assert.NotNull(answer.Message);
//Result_message_has_expected_type()
Assert.IsAssignableFrom <MakeCoffeCommand>(answer.Message);
//Result_message_has_expected_value()
Assert.Equal(gotTiredEvent.PersonId, command.PersonId);
//Result_metadata_has_command_id_as_casuation_id()
Assert.Equal(gotTiredEvent.SourceId, answer.Metadata.CasuationId);
//Result_metadata_has_correlation_id_same_as_command_metadata()
Assert.Equal(gotTiredEventMetadata.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();
//var name = AggregateActorName.New<SoftwareProgrammingState>(command.ProcessId);
//
//Assert.Equal(name.Name, step.Who);
//Assert.Equal(ProcessManagerActorConstants.ProcessProducedACommand, step.Why);
//Assert.Equal(ProcessManagerActorConstants.PublishingCommand, step.What);
}
public async Task When_process_produce_command_and_waiting_for_it_fault()
{
var givenProcessStateAggregate = new ProcessStateAggregate <SoftwareProgrammingState>(new SoftwareProgrammingState(Guid.NewGuid().ToString(),
nameof(SoftwareProgrammingProcess.MakingCoffee))
{
PersonId = Guid.NewGuid().ToString()
});
await Node.SaveToJournal(givenProcessStateAggregate);
var coffeMakeFailedEvent = new CoffeMakeFailedEvent(Guid.NewGuid().ToString(),
givenProcessStateAggregate.State.PersonId,
BusinessDateTime.UtcNow,
givenProcessStateAggregate.Id);
await Node.NewDebugWaiter()
.Expect <ProcessReceivedMessage <SoftwareProgrammingState> >(m => m.State.CurrentStateName == nameof(SoftwareProgrammingProcess.Coding))
.Create()
.SendToProcessManagers(coffeMakeFailedEvent, MessageMetadata.New(coffeMakeFailedEvent.SourceId, null, null));
var processStateAggregate = await this.LoadProcessByActor <SoftwareProgrammingState>(givenProcessStateAggregate.Id);
//Process_should_be_in_correct_state_after_fault_handling()
Assert.Equal(nameof(SoftwareProgrammingProcess.Coding), processStateAggregate.CurrentStateName);
//Process_state_should_contain_data_from_fault_message()
Assert.Equal(coffeMakeFailedEvent.ForPersonId, processStateAggregate.BadSleepPersonId);
}
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);
}
public async Task When_execute_aggregate_command_with_metadata()
{
_command = new InflateNewBallonCommand(1, Guid.NewGuid().ToString());
_commandMetadata = MessageMetadata.New(_command.Id, Guid.NewGuid().ToString(), null);
var res = await Node.Prepare(_command, _commandMetadata)
.Expect <BalloonCreated>()
.And <BalloonCreatedNotification>()
.Execute();
_answer = res.MessageWithMetadata <BalloonCreatedNotification>();
_aggregateEvent = res.MessageWithMetadata <BalloonCreated>();
//Result_contains_metadata()
Assert.NotNull(_answer.Metadata);
//Result_message_has_expected_type()
Assert.IsAssignableFrom <BalloonCreatedNotification>(_answer.Message);
//Result_message_has_expected_id()
Assert.Equal(_command.AggregateId, _answer.Message.BallonId);
//Result_metadata_has_command_id_as_casuation_id()
Assert.Equal(_aggregateEvent.Metadata.MessageId, _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(nameof(BalloonCreatedNotificator), step.Who);
//Assert.Equal(BalloonCreatedNotificator.Why, step.Why);
//Assert.Equal(BalloonCreatedNotificator.MessageProcessed, step.What);
}
public async Task When_execute_aggregate_command_with_metadata()
{
_command = new PlanTitleChangeCommand(1, Guid.NewGuid().ToString());
_commandMetadata = MessageMetadata.New(_command.Id, Guid.NewGuid().ToString(), null);
var res = await Node.Prepare(_command, _commandMetadata)
.Expect <BalloonTitleChanged>()
.Execute();
_answer = res.MessageWithMetadata <BalloonTitleChanged>();
//Result_contains_metadata()
Assert.NotNull(_answer.Metadata);
//Result_contains_message()
Assert.NotNull(_answer.Message);
//Result_message_has_expected_type()
Assert.IsAssignableFrom <BalloonTitleChanged>(_answer.Message);
//Result_message_has_expected_id()
Assert.Equal(_command.AggregateId, _answer.Message.SourceId);
//Result_message_has_expected_value()
Assert.Equal(_command.Parameter.ToString(), _answer.Message.Value);
//Result_metadata_has_command_id_as_casuation_id()
Assert.Equal(_command.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<Balloon>(_command.AggregateId)
// .Name,
// step.Who);
//Assert.Equal(AggregateActorConstants.CommandExecutionCreatedAnEvent, step.Why);
//Assert.Equal(AggregateActorConstants.PublishingEvent, step.What);
}
public async Task When_execute_aggregate_command_with_metadata()
{
_command = new InflateNewBallonCommand(1, Guid.NewGuid().ToString());
_commandMetadata = MessageMetadata.New(_command.Id, Guid.NewGuid().ToString(), null);
var res = await Node.Prepare(_command, _commandMetadata)
.Expect <BalloonCreated>()
.Execute();
var messageMetadata = res.ReceivedMetadata;
var balloonCreated = res.Received;
Assert.NotNull(messageMetadata);
//Result_contains_message()
Assert.NotNull(balloonCreated);
//Result_message_has_expected_type()
Assert.IsAssignableFrom <BalloonCreated>(balloonCreated);
//Result_message_has_expected_id()
Assert.Equal(_command.AggregateId, balloonCreated.SourceId);
//Result_message_has_expected_value()
Assert.Equal(_command.Title.ToString(), balloonCreated.Value);
//Result_metadata_has_command_id_as_casuation_id()
Assert.Equal(_command.Id, messageMetadata.CasuationId);
//Result_metadata_has_correlation_id_same_as_command_metadata()
Assert.Equal(_commandMetadata.CorrelationId, messageMetadata.CorrelationId);
//Result_metadata_has_processed_history_filled_from_aggregate()
//Assert.Equal(1, messageMetadata.History?.Steps.Count);
////Result_metadata_has_processed_correct_filled_history_step()
//var step = messageMetadata.History.Steps.First();
//
//Assert.Equal(AggregateActorName.New<Balloon>(_command.AggregateId).Name, step.Who);
//Assert.Equal(AggregateActorConstants.CommandExecutionCreatedAnEvent, step.Why);
//Assert.Equal(AggregateActorConstants.PublishingEvent, step.What);
}
public async Task When_execute_aggregate_command_with_metadata()
{
var command = new InflateNewBallonCommand(1, Guid.NewGuid().ToString());
var commandMetadata = MessageMetadata.New(command.Id, Guid.NewGuid().ToString(), null);
var res = await Node.Prepare(command, commandMetadata)
.Expect <BalloonCreated>()
.And <Fault <BalloonCreated> >()
.Execute(null, false);
var answer = res.MessageWithMetadata <IFault <BalloonCreated> >();
var aggregateEvent = res.MessageWithMetadata <BalloonCreated>();
//Result_contains_metadata()
Assert.NotNull(answer.Metadata);
//Result_message_has_expected_type()
Assert.IsAssignableFrom <IFault <BalloonCreated> >(answer.Message);
//Produced_fault_produced_by_projection_builder()
Assert.Equal(typeof(BalloonCreatedFaultyProjection), answer.Message.Processor);
//Result_message_has_expected_id()
Assert.Equal(command.AggregateId, answer.Message.Message.SourceId);
//Result_metadata_has_aggregate_event_id_as_casuation_id()
Assert.Equal(aggregateEvent.Metadata.MessageId, 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(nameof(BalloonCreatedFaultyProjection), step.Who);
//Assert.Equal(MessageHandlingConstants.MessageProcessCasuedAnError, step.Why);
//Assert.Equal(MessageHandlingConstants.PublishingFault, step.What);
}
public async Task When_execute_aggregate_command_with_fault_and_metadata()
{
var commandMetadata = MessageMetadata.New(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), null);
var command = new PlanBoomCommand(Guid.NewGuid(), DateTime.Now.AddMilliseconds(100));
var res = await Node.Prepare(command, commandMetadata)
.Expect <JobFailed>()
.And <Fault <RaiseScheduledDomainEventCommand> >()
.Execute(null, false);
var schedulingCommandFault = res.MessageWithMetadata <Fault <RaiseScheduledDomainEventCommand> >();
var jobFailedEnvelop = res.MessageWithMetadata <JobFailed>();
//Result_contains_metadata()
Assert.NotNull(schedulingCommandFault.Metadata);
//Result_contains_message()
Assert.NotNull(schedulingCommandFault.Message);
//Result_message_has_expected_type()
Assert.IsAssignableFrom <IFault <RaiseScheduledDomainEventCommand> >(schedulingCommandFault.Message);
//Result_message_has_expected_id()
Assert.Equal((jobFailedEnvelop.Message.ProcessingMessage as ICommand)?.Id,
schedulingCommandFault.Message.Message.Id);
//Result_metadata_has_command_id_as_casuation_id()
Assert.Equal((jobFailedEnvelop.Message.ProcessingMessage as ICommand)?.Id,
schedulingCommandFault.Metadata.CasuationId);
//Result_metadata_has_correlation_id_same_as_command_metadata()
Assert.Equal(commandMetadata.CorrelationId, schedulingCommandFault.Metadata.CorrelationId);
}
public AggregatePersistedHubInfrastructure()
{
ChildId = Guid.NewGuid().ToString();
ChildCreateMessage = new MessageMetadataEnvelop <ICommand>(new InflateNewBallonCommand(42, ChildId),
MessageMetadata.New(ChildId, null, null));
ChildActivateMessage = new MessageMetadataEnvelop <ICommand>(new WriteTitleCommand(100, ChildId),
MessageMetadata.New(ChildId, null, null));
}
public ProcessHubInfrastructure()
{
var processId = Guid.NewGuid().ToString();
ChildId = processId;
var gotTired = new GotTiredEvent(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), processId);
var coffeMadeEvent = new CoffeMadeEvent(gotTired.FavoriteCoffeMachineId, gotTired.PersonId, null, processId);
ChildCreateMessage = new MessageMetadataEnvelop <DomainEvent>(gotTired, MessageMetadata.New(gotTired.SourceId, null, null));
//TODO: second message will not hit same process as created by previos,
//think how to change it.
ChildActivateMessage = new MessageMetadataEnvelop <DomainEvent>(coffeMadeEvent,
MessageMetadata.New(coffeMadeEvent.SourceId, null, null));
}
public async Task When_publishing_start_message()
{
var evt = new SleptWellEvent(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
var metadata = MessageMetadata.New(evt.Id, Guid.NewGuid().ToString(), null);
var res = await
Node.NewDebugWaiter()
.Expect <ProcessManagerCreated <SoftwareProgrammingState> >()
.Create()
.SendToProcessManagers(evt, metadata);
var processCreatedEvent = res.Message <ProcessManagerCreated <SoftwareProgrammingState> >();
var state = await this.LoadProcessByActor <SoftwareProgrammingState>(processCreatedEvent.State.Id);
//Process_data_is_not_null()
Assert.NotNull(state);
//Process_has_correct_id()
Assert.Equal(processCreatedEvent.SourceId, state.Id);
}
public void Aggregate_actor_produce_fault_with_processId_from_command()
{
var command = new GoSleepCommand(null, null).CloneForProcess(Guid.NewGuid().ToString());
var transport = Sys.InitLocalTransportExtension().Transport;
transport.Subscribe <MessageMetadataEnvelop <Fault <GoSleepCommand> > >(TestActor);
var handlersActor = Sys.ActorOf(Props.Create(() => new HandlersPipeActor(new HandlersDefaultProcessor(), TestActor)));
var actor = Sys.ActorOf(Props.Create(() => new AggregateActor <ProgrammerAggregate>(CommandAggregateHandler.New <ProgrammerAggregate>(null),
new SnapshotsPersistencePolicy(1, null, 5, null),
AggregateFactory.Default,
AggregateFactory.Default,
handlersActor)),
EntityActorName.New <ProgrammerAggregate>(command.Id).Name);
actor.Tell(new MessageMetadataEnvelop <ICommand>(command, MessageMetadata.New(command.Id, null, null)));
var fault = FishForMessage <MessageMetadataEnvelop>(m => m.Message is Fault <GoSleepCommand>).Message as IFault;
Assert.Equal(command.ProcessId, fault.ProcessId);
}
public async Task When_execute_aggregate_command_with_fault_and_metadata()
{
var command = new BlowBalloonCommand(Guid.NewGuid().ToString());
var commandMetadata = MessageMetadata.New(command.Id, Guid.NewGuid().ToString(), null);
var res = await Node.Prepare(command, commandMetadata)
.Expect <Fault <BlowBalloonCommand> >()
.Execute(false);
// Result_contains_metadata()
var metadata = res.ReceivedMetadata;
Assert.NotNull(metadata);
// Result_contains_message()
var fault = res.Fault;
Assert.NotNull(fault);
//Result_message_has_expected_type()
Assert.IsAssignableFrom <IFault <BlowBalloonCommand> >(fault);
//Result_message_has_expected_id()
Assert.Equal(command.Id, ((IFault <BlowBalloonCommand>)fault).Message.Id);
//Result_message_has_expected_value()
Assert.Equal(command.GetType(), fault.Message.GetType());
//Result_metadata_has_command_id_as_casuation_id()
Assert.Equal(command.Id, metadata.CasuationId);
//Result_metadata_has_correlation_id_same_as_command_metadata()
Assert.Equal(commandMetadata.CorrelationId, metadata.CorrelationId);
//Result_metadata_has_processed_history_filled_from_aggregate()
//Assert.Equal(1, metadata.History?.Steps.Count);
////Result_metadata_has_processed_correct_filled_history_step()
//var step = metadata.History.Steps.First();
//
//Assert.Equal(AggregateActorName.New<Balloon>(command.AggregateId).Name, step.Who);
//Assert.Equal(AggregateActorConstants.CommandRaisedAnError, step.Why);
//Assert.Equal(AggregateActorConstants.CommandExecutionFinished, step.What);
}
public async Task Given_default_policy()
{
var startEvent = new GotTiredEvent(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
var resTask = Node.NewDebugWaiter()
.Expect <ProcessReceivedMessage <SoftwareProgrammingState> >()
.Create()
.SendToProcessManagers(startEvent, MessageMetadata.New(startEvent.Id, null, null));
var processId = (await resTask).Message <ProcessReceivedMessage <SoftwareProgrammingState> >().SourceId;
var continueEvent = new CoffeMakeFailedEvent(processId, startEvent.PersonId, BusinessDateTime.UtcNow, processId);
//to avoid racy state receiving expected message from processing GotTiredEvent
await Node.NewDebugWaiter()
.Expect <ProcessReceivedMessage <SoftwareProgrammingState> >(e => e.MessageId == continueEvent.Id)
.Create()
.SendToProcessManagers(continueEvent, processId);
Log.Info("Testcase enforce additional snapshot save & delete, will kill process manager");
await Node.KillProcessManager <SoftwareProgrammingProcess, SoftwareProgrammingState>(processId);
var snapshots = await AggregateSnapshotRepository.New(AutoTestNodeDbConfiguration.Default.JournalConnectionString,
AggregateFactory.Default)
.Load <ProcessStateAggregate <SoftwareProgrammingState> >(processId);
//Snapshot_should_be_saved_one_time
Assert.Single(snapshots);
//Restored_process_state_should_have_correct_ids
Assert.True(snapshots.All(s => s.Payload.Id == processId));
//Snapshot_should_have_parameters_from_first_event = created event
Assert.Equal(nameof(SoftwareProgrammingProcess.Coding),
snapshots.First().Payload.State.CurrentStateName);
//All_snapshots_should_not_have_uncommited_events
Assert.Empty(snapshots.SelectMany(s => s.Payload.GetEvents()));
}
public void When_child_revives_monitor_should_be_created_even_on_collision()
{
var ChildId = "testChild";
var create = new MessageMetadataEnvelop <ICommand>(new InflateNewBallonCommand(42, ChildId),
MessageMetadata.New(ChildId, null, null));
_hubRef.Tell(create);
Task.Run(async() =>
{
while (true)
{
var activate = new MessageMetadataEnvelop <ICommand>(new WriteTitleCommand(100, ChildId),
MessageMetadata.New(ChildId, null, null));
_hubRef.Tell(activate);
await Task.Delay(150);
}
});
EventFilter.Exception <InvalidActorNameException>()
.Expect(0, TimeSpan.FromSeconds(10), () => { });
}
