public async Task Then_separate_process_startes_on_each_message()
{
var startMessageA = new GotTiredEvent(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
var resA = await Node.NewDebugWaiter()
.Expect <ProcessReceivedMessage <SoftwareProgrammingState> >()
.Create()
.SendToProcessManagers(startMessageA);
var stateA = resA.Message <ProcessReceivedMessage <SoftwareProgrammingState> >().State;
var secondStartMessageB = new SleptWellEvent(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
var resB = await Node.NewDebugWaiter()
.Expect <ProcessReceivedMessage <SoftwareProgrammingState> >()
.Create()
.SendToProcessManagers(secondStartMessageB);
var stateB = resB.Message <ProcessReceivedMessage <SoftwareProgrammingState> >().State;
Assert.Equal(secondStartMessageB.SofaId, stateB.SofaId);
//Process_has_correct_state()
Assert.Equal(nameof(SoftwareProgrammingProcess.Coding), stateB.CurrentStateName);
Assert.NotEqual(stateA.Id, stateB.Id);
}
public void Given_default_policy()
{
_sagaId = Guid.NewGuid();
var sagaStartEvent = new GotTiredEvent(_sagaId, Guid.NewGuid(), Guid.NewGuid(), _sagaId);
var waiter = GridNode.NewWaiter()
.Expect <SagaCreatedEvent <SoftwareProgrammingSaga.States> >()
.Create();
Publisher.Publish(sagaStartEvent);
waiter.Wait();
var sagaContinueEvent = new CoffeMakeFailedEvent(_sagaId,
sagaStartEvent.PersonId,
BusinessDateTime.UtcNow,
_sagaId);
var waiterB = GridNode.NewWaiter()
.Expect <SagaTransitionEvent <SoftwareProgrammingSaga.States, SoftwareProgrammingSaga.Triggers> >()
.Create();
Publisher.Publish(sagaContinueEvent);
waiterB.Wait();
//saving snapshot
Thread.Sleep(200);
_snapshots = new AggregateSnapshotRepository(AkkaConf.Persistence.JournalConnectionString, GridNode.AggregateFromSnapshotsFactory)
.Load <SoftwareProgrammingSagaState>(sagaStartEvent.SagaId);
}
public Given_created_and_message_received_and_transitioned_event_when_hydrating()
{
_sagaId = Guid.NewGuid();
_machine = new SoftwareProgrammingSaga();
_softwareProgrammingSagaData = new SoftwareProgrammingSagaData(_machine.Sleeping.Name);
_message = new GotTiredEvent(Guid.NewGuid());
}
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 Given_default_policy()
{
var startEvent = new GotTiredEvent(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
var res = await
Node.NewDebugWaiter()
.Expect <ProcessManagerCreated <SoftwareProgrammingState> >()
.Create()
.SendToProcessManagers(startEvent);
var processId = res.Message <ProcessManagerCreated <SoftwareProgrammingState> >().SourceId;
var continueEvent = new CoffeMakeFailedEvent(Guid.NewGuid().ToString(), startEvent.PersonId, BusinessDateTime.UtcNow, processId);
await Node.NewDebugWaiter()
.Expect <ProcessReceivedMessage <SoftwareProgrammingState> >()
.Create()
.SendToProcessManagers(continueEvent);
//saving snapshot
await Task.Delay(200);
var snapshots =
await
new AggregateSnapshotRepository(AutoTestNodeDbConfiguration.Default.JournalConnectionString,
new AggregateFactory(),
new AggregateFactory()
).Load <ProcessStateAggregate <SoftwareProgrammingState> >(
startEvent.ProcessId);
//Snapshot_should_be_saved_one_time()
Assert.Empty(snapshots);
}
public async Task Process_state_is_changed_after_transition_by_event_data()
{
var given = new Given_Automatonymous_Process(m => m.Coding);
var subscriptionExpiredEvent = new GotTiredEvent(Guid.NewGuid().ToString());
await given.Process.Transit(given.State, subscriptionExpiredEvent);
Assert.Equal(subscriptionExpiredEvent.SourceId, given.State.PersonId);
}
public async Task Commands_are_produced()
{
var given = new Given_Automatonymous_Process(m => m.Coding);
var subscriptionExpiredEvent = new GotTiredEvent(Guid.NewGuid().ToString());
var commands = await given.Process.Transit(given.State, subscriptionExpiredEvent);
Assert.NotEmpty(commands);
}
public void Commands_are_produced()
{
var given = new Given_State_SoftareProgramming_Saga(SoftwareProgrammingSaga.States.Coding);
var subscriptionExpiredEvent = new GotTiredEvent(Guid.NewGuid());
When_execute_valid_transaction(given.SagaInstance, subscriptionExpiredEvent);
CollectionAssert.IsNotEmpty(given.SagaInstance.CommandsToDispatch);
}
public void Commands_are_produced()
{
var given = new Given_AutomatonymousSaga(m => m.Coding);
var subscriptionExpiredEvent = new GotTiredEvent(Guid.NewGuid());
When_execute_valid_transaction(given.SagaInstance, subscriptionExpiredEvent);
CollectionAssert.IsNotEmpty(given.SagaInstance.CommandsToDispatch);
}
public async Task When_publishing_start_message_B()
{
var startMessage = new GotTiredEvent(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
var state = await Node.GetTransitedState <SoftwareProgrammingState>(startMessage);
//process_has_correct_data()
Assert.Equal(startMessage.PersonId, state.PersonId);
//process_has_correct_state()
Assert.Equal(nameof(SoftwareProgrammingProcess.MakingCoffee), state.CurrentStateName);
}
public async Task When_dispatch_command_than_command_should_have_right_sagaId()
{
var gotTiredEvent = new GotTiredEvent(Guid.NewGuid());
var expectedCommand =
(await GridNode.NewDebugWaiter()
.Expect <MakeCoffeCommand>()
.Create()
.Publish(gotTiredEvent)).Message <MakeCoffeCommand>();
Assert.AreEqual(gotTiredEvent.PersonId, expectedCommand.SagaId);
}
public async Task Given_save_on_each_message_policy_and_keep_2_snapshots()
{
var startEvent = new GotTiredEvent(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
var res = await Node.NewDebugWaiter()
.Expect <ProcessManagerCreated <SoftwareProgrammingState> >()
.Create()
.SendToProcessManagers(startEvent);
var processId = res.Message <ProcessManagerCreated <SoftwareProgrammingState> >()
.SourceId;
var continueEventA = new CoffeMakeFailedEvent(Guid.NewGuid().ToString(),
startEvent.PersonId,
BusinessDateTime.UtcNow,
processId);
await Node.SendToProcessManagers(continueEventA);
await Node.KillProcessManager <SoftwareProgrammingProcess, SoftwareProgrammingState>(processId);
Version <ProcessStateAggregate <SoftwareProgrammingState> >[] snapshots = null;
//Only_two_Snapshots_should_left()
AwaitAssert(() =>
{
snapshots = AggregateSnapshotRepository.New(AutoTestNodeDbConfiguration.Default.JournalConnectionString)
.Load <ProcessStateAggregate <SoftwareProgrammingState> >(processId)
.Result;
Assert.Equal(2, snapshots.Length);
// Restored_aggregates_should_have_same_ids()
Assert.True(snapshots.All(s => s.Payload.Id == processId));
// First_Snapshots_should_have_coding_state_from_first_event()
Assert.Equal(nameof(SoftwareProgrammingProcess.MakingCoffee),
snapshots.First()
.Payload.State.CurrentStateName);
//Last_Snapshots_should_have_coding_state_from_last_event()
Assert.Equal(nameof(SoftwareProgrammingProcess.Sleeping),
snapshots.Last()
.Payload.State.CurrentStateName);
//All_snapshots_should_not_have_uncommited_events()
Assert.Empty(snapshots.SelectMany(s => s.Payload.GetEvents()));
},
TimeSpan.FromSeconds(10),
TimeSpan.FromSeconds(1));
}
public async Task When_raise_saga_than_saga_transitioned_event_should_have_right_sagaId()
{
var gotTiredEvent = new GotTiredEvent(Guid.NewGuid());
var expectedTransitionedEvent =
(await GridNode.NewDebugWaiter()
.Expect <SagaTransitionEvent <SoftwareProgrammingSagaData> >()
.Create()
.Publish(gotTiredEvent)).Message <SagaTransitionEvent <SoftwareProgrammingSagaData> >();
Assert.AreEqual(gotTiredEvent.PersonId, expectedTransitionedEvent.SagaId);
}
public async Task When_raise_saga_than_saga_event_should_have_right_sagaId()
{
var sagaStartEvent = new GotTiredEvent(Guid.NewGuid()).CloneWithSaga(Guid.NewGuid());
var expectedEvent = (await GridNode.NewDebugWaiter()
.Expect <SagaCreatedEvent <SoftwareProgrammingSaga.States> >()
.Create()
.Publish(sagaStartEvent))
.Message <SagaCreatedEvent <SoftwareProgrammingSaga.States> >();
Assert.AreEqual(sagaStartEvent.SagaId, expectedEvent.SagaId);
}
public async Task When_publishing_start_message()
{
SagaId = Guid.NewGuid();
_gotTiredEvent = new GotTiredEvent(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), SagaId);
_gotTiredEventMetadata = new MessageMetadata(_gotTiredEvent.SourceId, BusinessDateTime.UtcNow, Guid.NewGuid(), Guid.NewGuid());
var res = await GridNode.NewDebugWaiter(TimeSpan.FromHours(5))
.Expect <IMessageMetadataEnvelop <MakeCoffeCommand> >()
.Create()
.Publish(_gotTiredEvent, _gotTiredEventMetadata);
_answer = res.Message <IMessageMetadataEnvelop <MakeCoffeCommand> >();
}
public async Task When_process_created_from_event_with_processId_new_Id_is_generated()
{
var domainEvent = new GotTiredEvent(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
var waitResults = await Node.NewDebugWaiter()
.Expect <ProcessManagerCreated <SoftwareProgrammingState> >()
.Create()
.SendToProcessManagers(domainEvent);
Assert.NotEqual(domainEvent.ProcessId,
waitResults.Message <ProcessManagerCreated <SoftwareProgrammingState> >()
.State.Id);
}
public async Task When_dispatch_command_than_command_should_have_right_sagaId()
{
var sagaId = Guid.NewGuid();
var sourceId = Guid.NewGuid();
var domainEvent = new GotTiredEvent(sourceId).CloneWithSaga(sagaId);
var expectedCommand =
(await GridNode.NewDebugWaiter()
.Expect <MakeCoffeCommand>()
.Create()
.Publish(domainEvent)).Message <MakeCoffeCommand>();
Assert.AreEqual(sagaId, expectedCommand.SagaId);
}
public void SagaData_is_changed_after_transition_by_event_data()
{
var given = new Given_AutomatonymousSaga(m => m.Coding);
ClearEvents(given.SagaDataAggregate);
var subscriptionExpiredEvent = new GotTiredEvent(Guid.NewGuid());
When_execute_valid_transaction(given.SagaInstance, subscriptionExpiredEvent);
var newSubscriptionId = given.SagaDataAggregate.Data.PersonId;
Assert.AreEqual(subscriptionExpiredEvent.SourceId, newSubscriptionId);
}
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_raise_saga_than_saga_created_event_should_have_right_sagaId()
{
var sagaId = Guid.NewGuid();
var sourceId = Guid.NewGuid();
var domainEvent = new GotTiredEvent(sourceId, Guid.NewGuid(), Guid.NewGuid(), sagaId);
var expectedCreatedEvent =
(await GridNode.NewDebugWaiter()
.Expect <SagaCreatedEvent <SoftwareProgrammingSagaData> >()
.Create()
.Publish(domainEvent)).Message <SagaCreatedEvent <SoftwareProgrammingSagaData> >();
Assert.AreEqual(sagaId, expectedCreatedEvent.SagaId);
}
public void SagaData_is_changed_after_transition_by_event_data()
{
var given = new Given_State_SoftareProgramming_Saga(SoftwareProgrammingSaga.States.Coding);
given.SagaDataAggregate.ClearEvents();
var gotTiredEvent = new GotTiredEvent(Guid.NewGuid());
When_execute_valid_transaction(given.SagaInstance, gotTiredEvent);
var personId = given.SagaDataAggregate.PersonId;
Assert.AreEqual(gotTiredEvent.SourceId, personId);
}
public async Task When_start_message_has_saga_id()
{
_sagaId = Guid.NewGuid();
_personId = Guid.NewGuid();
var sagaStartEvent = new GotTiredEvent(_personId).CloneWithSaga(_sagaId);
await GridNode.NewDebugWaiter()
.Expect <MakeCoffeCommand>()
.Create()
.Publish(sagaStartEvent);
_sagaState = LoadSagaState <SoftwareProgrammingSaga, SoftwareProgrammingSagaState>(_sagaId);
}
public async Task Instance_saga_actor_has_correct_path_when_saga_is_raised_by_domain_message()
{
var msg = new GotTiredEvent(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid());
await GridNode.NewDebugWaiter()
.Expect <MakeCoffeCommand>()
.Create()
.Publish(msg);
var sagaActorName = AggregateActorName.New <SagaDataAggregate <SoftwareProgrammingSagaData> >(msg.SagaId).ToString();
var sagaActor = LookupInstanceSagaActor <SoftwareProgrammingSaga, SoftwareProgrammingSagaData>(msg.SagaId);
Assert.NotNull(sagaActor);
}
public StateSagaPersistedHub_Infrastructure(ActorSystem system)
{
var sagaId = Guid.NewGuid();
ChildId = sagaId;
var gotTired = new GotTiredEvent(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), sagaId);
var coffeMadeEvent = new CoffeMadeEvent(gotTired.FavoriteCoffeMachineId, gotTired.PersonId, null, sagaId);
ChildCreateMessage = new MessageMetadataEnvelop <DomainEvent>(gotTired,
new MessageMetadata(gotTired.SourceId));
ChildActivateMessage = new MessageMetadataEnvelop <DomainEvent>(coffeMadeEvent,
new MessageMetadata(coffeMadeEvent.SourceId));
HubProps = system.DI().Props <SagaHubActor <SoftwareProgrammingSaga, SoftwareProgrammingSagaState> >();
}
public void Given_save_on_each_message_policy_and_keep_2_snapshots()
{
_sagaId = Guid.NewGuid();
var sagaStartEvent = new GotTiredEvent(_sagaId, Guid.NewGuid(), Guid.NewGuid(), _sagaId);
var wait = GridNode.NewWaiter()
.Expect <SagaCreatedEvent <SoftwareProgrammingSagaData> >()
.Create();
Publisher.Publish(sagaStartEvent);
wait.Wait();
var sagaActorRef = LookupInstanceSagaActor <SoftwareProgrammingSaga, SoftwareProgrammingSagaData>(_sagaId);
sagaActorRef.Tell(new NotifyOnPersistenceEvents(TestActor), TestActor);
var sagaContinueEventA = new CoffeMakeFailedEvent(_sagaId,
sagaStartEvent.PersonId,
BusinessDateTime.UtcNow,
_sagaId);
var sagaContinueEventB = new SleptWellEvent(_sagaId,
sagaStartEvent.LovelySofaId,
_sagaId);
var waiter = GridNode.NewWaiter()
.Expect <SagaMessageReceivedEvent <SoftwareProgrammingSagaData> >(e => (e.Message as CoffeMakeFailedEvent)?.SourceId == _sagaId)
.And <SagaMessageReceivedEvent <SoftwareProgrammingSagaData> >(e => (e.Message as SleptWellEvent)?.SourceId == _sagaId)
.Create();
Publisher.Publish(sagaContinueEventA);
Publisher.Publish(sagaContinueEventB);
waiter.Wait();
Watch(sagaActorRef);
sagaActorRef.Tell(GracefullShutdownRequest.Instance, TestActor);
FishForMessage <Terminated>(m => true, TimeSpan.FromDays(1));
Thread.Sleep(1000);
_snapshots = new AggregateSnapshotRepository(AkkaConf.Persistence.JournalConnectionString,
GridNode.AggregateFromSnapshotsFactory)
.Load <SagaDataAggregate <SoftwareProgrammingSagaData> >(_sagaId);
Console.WriteLine(_snapshotsPersistencePolicy.ToPropsString());
}
public void Given_save_on_each_message_policy_and_keep_2_snapshots()
{
_sagaId = Guid.NewGuid();
var sagaStartEvent = new GotTiredEvent(_sagaId, Guid.NewGuid(), Guid.NewGuid(), _sagaId);
var w = GridNode.NewWaiter()
.Expect <SagaCreatedEvent <SoftwareProgrammingSaga.States> >()
.Create();
Publisher.Publish(sagaStartEvent);
w.Wait();
var sagaActorRef = LookupStateSagaActor <SoftwareProgrammingSaga, SoftwareProgrammingSagaState>(_sagaId);
Watch(sagaActorRef);
sagaActorRef.Tell(new NotifyOnPersistenceEvents(TestActor), TestActor);
var sagaContinueEventA = new CoffeMakeFailedEvent(_sagaId,
sagaStartEvent.PersonId,
BusinessDateTime.UtcNow,
_sagaId);
var sagaContinueEventB = new SleptWellEvent(_sagaId,
sagaStartEvent.LovelySofaId,
_sagaId);
var waiter = GridNode.NewWaiter()
.Expect <SagaTransitionEvent <SoftwareProgrammingSaga.States, SoftwareProgrammingSaga.Triggers> >(e => e.State == SoftwareProgrammingSaga.States.Coding)
.And <SagaTransitionEvent <SoftwareProgrammingSaga.States, SoftwareProgrammingSaga.Triggers> >(e => e.State == SoftwareProgrammingSaga.States.Sleeping)
.Create();
Publisher.Publish(sagaContinueEventA);
Publisher.Publish(sagaContinueEventB);
waiter.Wait();
sagaActorRef.Tell(GracefullShutdownRequest.Instance, TestActor);
FishForMessage <Terminated>(m => true);
_snapshots = new AggregateSnapshotRepository(AkkaConf.Persistence.JournalConnectionString,
GridNode.AggregateFromSnapshotsFactory)
.Load <SoftwareProgrammingSagaState>(_sagaId);
}
public void When_publishing_start_message()
{
_startMessage = (GotTiredEvent)
new GotTiredEvent(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid())
.CloneWithSaga(Guid.NewGuid());
_coffeMadeEvent = (CoffeMadeEvent)
new CoffeMadeEvent(_startMessage.FavoriteCoffeMachineId, _startMessage.PersonId)
.CloneWithSaga(_startMessage.SagaId);
_reStartEvent = (GotTiredEvent)
new GotTiredEvent(Guid.NewGuid(), _startMessage.LovelySofaId, Guid.NewGuid())
.CloneWithSaga(_startMessage.SagaId);
GridNode.Transport.Publish(_startMessage);
GridNode.Transport.Publish(_coffeMadeEvent);
GridNode.Transport.Publish(_reStartEvent);
Thread.Sleep(3000);
_sagaDataAggregate = LoadAggregate <SagaDataAggregate <SoftwareProgrammingSagaData> >(_startMessage.SagaId);
}
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()));
}
private static void When_apply_known_but_not_mapped_event_in_state(ISagaInstance sagaInstance)
{
_gotTiredDomainEvent = new GotTiredEvent(Guid.NewGuid());
sagaInstance.Transit(_gotTiredDomainEvent);
}
public ISagaInstance <SoftwareProgrammingSaga, SoftwareProgrammingSagaData> Create(GotTiredEvent message)
{
var data = new SagaDataAggregate <SoftwareProgrammingSagaData>(message.SagaId,
new SoftwareProgrammingSagaData(
nameof(SoftwareProgrammingSaga.Coding)));
return(Create(data));
}
