public AggregateScenarioRun(IAggregateScenario scenario, TAggregate aggregate, IReadOnlyCollection <IDomainEvent> producedEvents, ILogger log)
{
Aggregate = aggregate;
ProducedEvents = producedEvents ?? new IDomainEvent[] {};
Log = log;
Scenario = scenario;
}
public async Task <IAggregateScenarioRun <TAggregate> > Run(IAggregateScenario <TAggregate> scenario)
{
var aggregate = scenario.Dependencies.AggregateFactory.Build(scenario.AggregateId);
foreach (var evt in scenario.GivenEvents)
{
aggregate.Apply(evt);
}
IReadOnlyCollection <IDomainEvent> producedEvents = null;
//When
foreach (var cmd in scenario.GivenCommands)
{
try
{
producedEvents = await aggregate.Execute(cmd);
foreach (var e in producedEvents)
{
if (e.Version == aggregate.Version)
{
aggregate.Apply(e);
}
else if (e.Version > aggregate.Version)
{
throw new AggregateVersionMismatchException();
}
}
}
catch (Exception ex)
{
Log.Error(ex, "failed to execute an aggregate command");
throw;
}
}
//Then
return(new AggregateScenarioRun <TAggregate>(scenario, aggregate, producedEvents, Log));
}
protected override Task <IAggregateScenarioRun <T> > Run <T>(IAggregateScenario <T> scenario)
{
return(scenario.Run().Local());
}
protected abstract Task <IAggregateScenarioRun <T> > Run <T>(
IAggregateScenario <T> scenario) where T : class, IAggregate;
public static IAggregateScenarioRunBuilder <T> Run <T>(this IAggregateScenario <T> scenario) where T : IAggregate
{
return(new AggregateScenarioRunBuilder <T>(scenario));
}
public AggregateScenarioRunBuilder(IAggregateScenario <T> builder)
{
Scenario = builder;
}
