public AggregateRootTest(AggregateRootTestId id, string name, Guid correlationId)
: this()
{
var @event = new AggregateCreated(correlationId, id, name);
ApplyEvent(@event);
}
// public TAggregate Create<TAggregate>(Guid? id = null)
// where TAggregate : AggregateRoot<Guid>
// {
// id = id == null || id.Value == Guid.Empty ? Guid.NewGuid() : id;
//
// var existStream = _eventStore.Any(id.Value);
// if(existStream)
// throw new DuplicatedRootException(id.ToString());
//
// var createEvent = new AggregateCreated<Guid>(id.Value);
// var events = new List<IEvent>() { createEvent};
//
// var stream = new EventStream(){ Version = INITIAL_VERSION, Events = events};
//
// TAggregate aggregate = (TAggregate) Activator.CreateInstance(typeof(TAggregate), new object[] {stream});
//
// aggregate.Changes.Add(createEvent);
// return aggregate;
// }
public override TAggregate Create <TAggregate>(Guid?id = null)
{
id = id == null || id.Value == Guid.Empty ? Guid.NewGuid() : id;
var existStream = _eventStore.Any(id.Value);
if (existStream)
{
throw new DuplicatedRootException(id.ToString());
}
var createEvent = new AggregateCreated <Guid>(id.Value);
var events = new List <IEvent>()
{
createEvent
};
var stream = new EventStream()
{
Version = INITIAL_VERSION, Events = events
};
TAggregate aggregate = (TAggregate)Activator.CreateInstance(typeof(TAggregate), new object[] { stream });
aggregate.Changes.Add(createEvent);
return(aggregate);
}
public void SetUp()
{
_createSomething = new CreateSomething();
_somethingCreated = new SomethingCreated();
_somethingCreatedConcrete = new SomethingCreated();
_events = new List <IEvent> {
_somethingCreated
};
_createAggregate = new CreateAggregate();
_aggregateCreatedConcrete = new AggregateCreated();
_aggregate = new Aggregate();
_aggregateCreated = (AggregateCreated)_aggregate.Events[0];
_eventPublisher = new Mock <IEventPublisher>();
_eventPublisher
.Setup(x => x.Publish(_somethingCreatedConcrete));
_eventPublisher
.Setup(x => x.Publish(_aggregateCreatedConcrete));
_eventStore = new Mock <IEventStore>();
_eventStore
.Setup(x => x.SaveEvent <Aggregate>(_aggregateCreatedConcrete));
_eventFactory = new Mock <IEventFactory>();
_eventFactory
.Setup(x => x.CreateConcreteEvent(_somethingCreated))
.Returns(_somethingCreatedConcrete);
_eventFactory
.Setup(x => x.CreateConcreteEvent(_aggregateCreated))
.Returns(_aggregateCreatedConcrete);
_commandHandler = new Mock <ICommandHandler <CreateSomething> >();
_commandHandler
.Setup(x => x.Handle(_createSomething));
_commandHandlerWithEvents = new Mock <ICommandHandlerWithEvents <CreateSomething> >();
_commandHandlerWithEvents
.Setup(x => x.Handle(_createSomething))
.Returns(_events);
_domainCommandHandler = new Mock <ICommandHandlerWithAggregate <CreateAggregate> >();
_domainCommandHandler
.Setup(x => x.Handle(_createAggregate))
.Returns(_aggregate);
_resolver = new Mock <IResolver>();
_resolver
.Setup(x => x.Resolve <ICommandHandler <CreateSomething> >())
.Returns(_commandHandler.Object);
_resolver
.Setup(x => x.Resolve <ICommandHandlerWithEvents <CreateSomething> >())
.Returns(_commandHandlerWithEvents.Object);
_resolver
.Setup(x => x.Resolve <ICommandHandlerWithAggregate <CreateAggregate> >())
.Returns(_domainCommandHandler.Object);
_sut = new CommandSender(_resolver.Object, _eventPublisher.Object, _eventFactory.Object, _eventStore.Object);
}
public void SetUp()
{
_createSomething = new CreateSomething();
_somethingCreated = new SomethingCreated();
_somethingCreatedConcrete = new SomethingCreated();
_events = new List <IEvent> {
_somethingCreated
};
_createAggregate = new CreateAggregate();
_aggregateCreatedConcrete = new AggregateCreated();
_aggregate = new Aggregate();
_aggregateCreated = (AggregateCreated)_aggregate.Events[0];
_eventPublisher = new Mock <IEventPublisher>();
_eventPublisher
.Setup(x => x.PublishAsync(_somethingCreatedConcrete))
.Returns(Task.CompletedTask);
_eventPublisher
.Setup(x => x.PublishAsync(_aggregateCreatedConcrete))
.Returns(Task.CompletedTask);
_eventFactory = new Mock <IEventFactory>();
_eventFactory
.Setup(x => x.CreateConcreteEvent(_somethingCreated))
.Returns(_somethingCreatedConcrete);
_eventFactory
.Setup(x => x.CreateConcreteEvent(_aggregateCreated))
.Returns(_aggregateCreatedConcrete);
_commandHandlerAsync = new Mock <ICommandHandlerAsync <CreateSomething> >();
_commandHandlerAsync
.Setup(x => x.HandleAsync(_createSomething))
.ReturnsAsync(_events);
_domainCommandHandlerAsync = new Mock <IDomainCommandHandlerAsync <CreateAggregate> >();
_domainCommandHandlerAsync
.Setup(x => x.HandleAsync(_createAggregate))
.ReturnsAsync(_aggregate.Events);
_handlerResolver = new Mock <IHandlerResolver>();
_handlerResolver
.Setup(x => x.ResolveHandler <ICommandHandlerAsync <CreateSomething> >())
.Returns(_commandHandlerAsync.Object);
_handlerResolver
.Setup(x => x.ResolveHandler <IDomainCommandHandlerAsync <CreateAggregate> >())
.Returns(_domainCommandHandlerAsync.Object);
_optionsMock = new Mock <IOptions <Options> >();
_optionsMock
.Setup(x => x.Value)
.Returns(new Options());
_sut = new CommandSender(_handlerResolver.Object,
_eventPublisher.Object,
_eventFactory.Object,
_optionsMock.Object);
}
public void SetUp()
{
_createSomething = new CreateSomething();
_createSomethingConcrete = new CreateSomething();
_somethingCreated = new SomethingCreated();
_somethingCreatedConcrete = new SomethingCreated();
_events = new List <IEvent> {
_somethingCreated
};
_createAggregate = new CreateAggregate();
_createAggregateConcrete = new CreateAggregate();
_aggregateCreatedConcrete = new AggregateCreated();
_aggregate = new Aggregate();
_aggregateCreated = (AggregateCreated)_aggregate.Events[0];
_sampleCommandSequence = new SampleCommandSequence();
_commandInSequenceConcrete = new CommandInSequence();
_commandResponse = new CommandResponse {
Events = _events, Result = "Result"
};
_domainCommandResponse = new CommandResponse {
Events = _aggregate.Events, Result = "Result"
};
_eventPublisher = new Mock <IEventPublisher>();
_eventPublisher
.Setup(x => x.PublishAsync(_aggregateCreatedConcrete))
.Returns(Task.CompletedTask);
_storeProvider = new Mock <IStoreProvider>();
_storeProvider
.Setup(x => x.SaveAsync(It.IsAny <SaveStoreData>()))
.Callback <SaveStoreData>(x => _storeDataSaved = x)
.Returns(Task.CompletedTask);
_objectFactory = new Mock <IObjectFactory>();
_objectFactory
.Setup(x => x.CreateConcreteObject(_somethingCreated))
.Returns(_somethingCreatedConcrete);
_objectFactory
.Setup(x => x.CreateConcreteObject(_aggregateCreated))
.Returns(_aggregateCreatedConcrete);
_objectFactory
.Setup(x => x.CreateConcreteObject(_createSomething))
.Returns(_createSomethingConcrete);
_objectFactory
.Setup(x => x.CreateConcreteObject(_createAggregate))
.Returns(_createAggregateConcrete);
_objectFactory
.Setup(x => x.CreateConcreteObject(It.IsAny <CommandInSequence>()))
.Returns(_commandInSequenceConcrete);
_validationService = new Mock <IValidationService>();
_validationService
.Setup(x => x.ValidateAsync(It.IsAny <CreateSomething>()))
.Returns(Task.CompletedTask);
_commandHandlerAsync = new Mock <ICommandHandlerAsync <CreateSomething> >();
_commandHandlerAsync
.Setup(x => x.HandleAsync(_createSomethingConcrete))
.ReturnsAsync(_commandResponse);
_domainCommandHandlerAsync = new Mock <ICommandHandlerAsync <CreateAggregate> >();
_domainCommandHandlerAsync
.Setup(x => x.HandleAsync(_createAggregate))
.ReturnsAsync(_domainCommandResponse);
_domainCommandHandlerAsync
.Setup(x => x.HandleAsync(_createAggregateConcrete))
.ReturnsAsync(_domainCommandResponse);
_sequenceCommandHandlerAsync = new Mock <ISequenceCommandHandlerAsync <CommandInSequence> >();
_sequenceCommandHandlerAsync
.Setup(x => x.HandleAsync(It.IsAny <CommandInSequence>(), It.IsAny <CommandResponse>()))
.ReturnsAsync(_commandResponse);
_handlerResolver = new Mock <IHandlerResolver>();
_handlerResolver
.Setup(x => x.ResolveHandler <ICommandHandlerAsync <CreateSomething> >())
.Returns(_commandHandlerAsync.Object);
_handlerResolver
.Setup(x => x.ResolveHandler <ICommandHandlerAsync <CreateAggregate> >())
.Returns(_domainCommandHandlerAsync.Object);
_handlerResolver
.Setup(x => x.ResolveHandler <ISequenceCommandHandlerAsync <CommandInSequence> >())
.Returns(_sequenceCommandHandlerAsync.Object);
_mainOptionsMock = new Mock <IOptions <MainOptions> >();
_mainOptionsMock
.Setup(x => x.Value)
.Returns(new MainOptions());
_validationOptionsMock = new Mock <IOptions <ValidationOptions> >();
_validationOptionsMock
.Setup(x => x.Value)
.Returns(new ValidationOptions());
_sut = new CommandSender(_handlerResolver.Object,
_eventPublisher.Object,
_objectFactory.Object,
_storeProvider.Object,
_validationService.Object,
_mainOptionsMock.Object,
_validationOptionsMock.Object);
}
public void SetUp()
{
_createSomething = new CreateSomething();
_somethingCreated = new SomethingCreated();
_somethingCreatedConcrete = new SomethingCreated();
_events = new List <IEvent> {
_somethingCreated
};
_createAggregate = new CreateAggregate();
_aggregateCreatedConcrete = new AggregateCreated();
_aggregate = new Aggregate();
_aggregateCreated = (AggregateCreated)_aggregate.Events[0];
_eventPublisher = new Mock <IEventPublisher>();
_eventPublisher
.Setup(x => x.PublishAsync(_somethingCreatedConcrete))
.Returns(Task.CompletedTask);
_eventPublisher
.Setup(x => x.PublishAsync(_aggregateCreatedConcrete))
.Returns(Task.CompletedTask);
_eventStore = new Mock <IEventStore>();
_eventStore
.Setup(x => x.SaveEventAsync <Aggregate>(_aggregateCreatedConcrete, null))
.Returns(Task.CompletedTask);
_commandStore = new Mock <ICommandStore>();
_commandStore
.Setup(x => x.SaveCommandAsync <Aggregate>(_createAggregate))
.Returns(Task.CompletedTask);
_eventFactory = new Mock <IEventFactory>();
_eventFactory
.Setup(x => x.CreateConcreteEvent(_somethingCreated))
.Returns(_somethingCreatedConcrete);
_eventFactory
.Setup(x => x.CreateConcreteEvent(_aggregateCreated))
.Returns(_aggregateCreatedConcrete);
_commandHandlerAsync = new Mock <ICommandHandlerAsync <CreateSomething> >();
_commandHandlerAsync
.Setup(x => x.HandleAsync(_createSomething))
.Returns(Task.CompletedTask);
_commandHandlerWithEventsAsync = new Mock <ICommandHandlerWithEventsAsync <CreateSomething> >();
_commandHandlerWithEventsAsync
.Setup(x => x.HandleAsync(_createSomething))
.ReturnsAsync(_events);
_commandHandlerWithDomainEventsAsync = new Mock <ICommandHandlerWithDomainEventsAsync <CreateAggregate> >();
_commandHandlerWithDomainEventsAsync
.Setup(x => x.HandleAsync(_createAggregate))
.ReturnsAsync(_aggregate.Events);
_handlerResolver = new Mock <IHandlerResolver>();
_handlerResolver
.Setup(x => x.ResolveHandler <ICommandHandlerAsync <CreateSomething> >())
.Returns(_commandHandlerAsync.Object);
_handlerResolver
.Setup(x => x.ResolveHandler <ICommandHandlerWithEventsAsync <CreateSomething> >())
.Returns(_commandHandlerWithEventsAsync.Object);
_handlerResolver
.Setup(x => x.ResolveHandler <ICommandHandlerWithDomainEventsAsync <CreateAggregate> >())
.Returns(_commandHandlerWithDomainEventsAsync.Object);
_sut = new CommandSender(_handlerResolver.Object, _eventPublisher.Object, _eventFactory.Object, _eventStore.Object, _commandStore.Object);
}
public void SetUp()
{
_createSomething = new CreateSomething();
_somethingCreated = new SomethingCreated();
_somethingCreatedConcrete = new SomethingCreated();
_events = new List <IEvent> {
_somethingCreated
};
_createAggregate = new CreateAggregate();
_aggregateCreatedConcrete = new AggregateCreated();
_aggregate = new Aggregate();
_aggregateCreated = (AggregateCreated)_aggregate.Events[0];
_commandResponse = new CommandResponse {
Events = _events
};
_domainCommandResponse = new CommandResponse {
Events = _aggregate.Events
};
_eventPublisher = new Mock <IEventPublisher>();
_eventPublisher
.Setup(x => x.Publish(_aggregateCreatedConcrete));
_storeProvider = new Mock <IStoreProvider>();
_storeProvider
.Setup(x => x.Save(_aggregate.GetType(), _createAggregate.AggregateRootId, _createAggregate, new List <IDomainEvent>()
{
_aggregateCreated
}));
_eventFactory = new Mock <IEventFactory>();
_eventFactory
.Setup(x => x.CreateConcreteEvent(_somethingCreated))
.Returns(_somethingCreatedConcrete);
_eventFactory
.Setup(x => x.CreateConcreteEvent(_aggregateCreated))
.Returns(_aggregateCreatedConcrete);
_validationService = new Mock <IValidationService>();
_validationService
.Setup(x => x.Validate(_createAggregate));
_commandHandler = new Mock <ICommandHandler <CreateSomething> >();
_commandHandler
.Setup(x => x.Handle(_createSomething))
.Returns(_commandResponse);
_domainCommandHandler = new Mock <ICommandHandler <CreateAggregate> >();
_domainCommandHandler
.Setup(x => x.Handle(_createAggregate))
.Returns(_domainCommandResponse);
_handlerResolver = new Mock <IHandlerResolver>();
_handlerResolver
.Setup(x => x.ResolveHandler(_createSomething, typeof(ICommandHandler <>)))
.Returns(_commandHandler.Object);
_handlerResolver
.Setup(x => x.ResolveHandler(_createAggregate, typeof(ICommandHandler <>)))
.Returns(_domainCommandHandler.Object);
_optionsMock = new Mock <IOptions <Options> >();
_optionsMock
.Setup(x => x.Value)
.Returns(new Options());
_sut = new CommandSender(_handlerResolver.Object,
_eventPublisher.Object,
_eventFactory.Object,
_storeProvider.Object,
_validationService.Object,
_optionsMock.Object);
}
private void When(AggregateCreated <Guid> e)
{
Id = e.Id;
_products = new List <Product>();
}
public void SetUp()
{
_createSomething = new CreateSomething();
_somethingCreated = new SomethingCreated();
_somethingCreatedConcrete = new SomethingCreated();
_events = new List <IEvent> {
_somethingCreated
};
_createAggregate = new CreateAggregate();
_aggregateCreatedConcrete = new AggregateCreated();
_aggregate = new Aggregate();
_aggregateCreated = (AggregateCreated)_aggregate.Events[0];
_sampleCommandSequence = new sampleCommandSequence();
_commandResponse = new CommandResponse {
Events = _events, Result = "Result"
};
_domainCommandResponse = new CommandResponse {
Events = _aggregate.Events, Result = "Result"
};
_eventPublisher = new Mock <IEventPublisher>();
_eventPublisher
.Setup(x => x.Publish(_aggregateCreatedConcrete));
_storeProvider = new Mock <IStoreProvider>();
_storeProvider
.Setup(x => x.Save(It.IsAny <SaveStoreData>()))
.Callback <SaveStoreData>(x => _storeDataSaved = x);
_eventFactory = new Mock <IEventFactory>();
_eventFactory
.Setup(x => x.CreateConcreteEvent(_somethingCreated))
.Returns(_somethingCreatedConcrete);
_eventFactory
.Setup(x => x.CreateConcreteEvent(_aggregateCreated))
.Returns(_aggregateCreatedConcrete);
_validationService = new Mock <IValidationService>();
_validationService
.Setup(x => x.Validate(_createAggregate));
_commandHandler = new Mock <ICommandHandler <CreateSomething> >();
_commandHandler
.Setup(x => x.Handle(_createSomething))
.Returns(_commandResponse);
_domainCommandHandler = new Mock <ICommandHandler <CreateAggregate> >();
_domainCommandHandler
.Setup(x => x.Handle(_createAggregate))
.Returns(_domainCommandResponse);
_sequenceCommandHandler = new Mock <ISequenceCommandHandler <ICommand> >();
_sequenceCommandHandler
.Setup(x => x.Handle(It.IsAny <ICommand>(), It.IsAny <CommandResponse>()))
.Returns(It.IsAny <CommandResponse>());
_handlerResolver = new Mock <IHandlerResolver>();
_handlerResolver
.Setup(x => x.ResolveHandler(_createSomething, typeof(ICommandHandler <>)))
.Returns(_commandHandler.Object);
_handlerResolver
.Setup(x => x.ResolveHandler(_createAggregate, typeof(ICommandHandler <>)))
.Returns(_domainCommandHandler.Object);
_handlerResolver
.Setup(x => x.ResolveHandler(It.IsAny <ICommand>(), typeof(ISequenceCommandHandler <>)))
.Returns(_sequenceCommandHandler.Object);
_optionsMock = new Mock <IOptions <Options> >();
_optionsMock
.Setup(x => x.Value)
.Returns(new Options());
_sut = new CommandSender(_handlerResolver.Object,
_eventPublisher.Object,
_eventFactory.Object,
_storeProvider.Object,
_validationService.Object,
_optionsMock.Object);
}
public void SetUp()
{
_createSomething = new CreateSomething();
_somethingCreated = new SomethingCreated();
_somethingCreatedConcrete = new SomethingCreated();
_events = new List <IEvent> {
_somethingCreated
};
_createAggregate = new CreateAggregate();
_aggregateCreatedConcrete = new AggregateCreated();
_aggregate = new Aggregate();
_aggregateCreated = (AggregateCreated)_aggregate.Events[0];
_eventPublisher = new Mock <IEventPublisher>();
_eventPublisher
.Setup(x => x.Publish(_somethingCreatedConcrete));
_eventPublisher
.Setup(x => x.Publish(_aggregateCreatedConcrete));
_eventStore = new Mock <IEventStore>();
_eventStore
.Setup(x => x.SaveEvent <Aggregate>(_aggregateCreatedConcrete, null));
_commandStore = new Mock <ICommandStore>();
_commandStore
.Setup(x => x.SaveCommand <Aggregate>(_createAggregate));
_aggregateStore = new Mock <IAggregateStore>();
_aggregateStore
.Setup(x => x.SaveAggregate <Aggregate>(_createAggregate.AggregateRootId));
_eventFactory = new Mock <IEventFactory>();
_eventFactory
.Setup(x => x.CreateConcreteEvent(_somethingCreated))
.Returns(_somethingCreatedConcrete);
_eventFactory
.Setup(x => x.CreateConcreteEvent(_aggregateCreated))
.Returns(_aggregateCreatedConcrete);
_commandHandler = new Mock <ICommandHandler <CreateSomething> >();
_commandHandler
.Setup(x => x.Handle(_createSomething))
.Returns(_events);
_domainCommandHandler = new Mock <IDomainCommandHandler <CreateAggregate> >();
_domainCommandHandler
.Setup(x => x.Handle(_createAggregate))
.Returns(_aggregate.Events);
_handlerResolver = new Mock <IHandlerResolver>();
_handlerResolver
.Setup(x => x.ResolveHandler <ICommandHandler <CreateSomething> >())
.Returns(_commandHandler.Object);
_handlerResolver
.Setup(x => x.ResolveHandler <IDomainCommandHandler <CreateAggregate> >())
.Returns(_domainCommandHandler.Object);
_optionsMock = new Mock <IOptions <Options> >();
_optionsMock
.Setup(x => x.Value)
.Returns(new Options());
_sut = new DomainCommandSender(_handlerResolver.Object,
_eventPublisher.Object,
_eventFactory.Object,
_aggregateStore.Object,
_commandStore.Object,
_eventStore.Object,
_optionsMock.Object);
}
private void Apply(AggregateCreated @event)
{
}
void IPublish <AggregateCreated> .Apply(AggregateCreated @event)
{
Id = @event.AggregateSutId;
Name = @event.Name;
}
