public void SetUp()
{
_somethingCreated = new SomethingCreated();
_eventHandler1 = new Mock <IEventHandlerAsync <SomethingCreated> >();
_eventHandler1
.Setup(x => x.HandleAsync(_somethingCreated))
.Returns(Task.CompletedTask);
_eventHandler2 = new Mock <IEventHandlerAsync <SomethingCreated> >();
_eventHandler2
.Setup(x => x.HandleAsync(_somethingCreated))
.Returns(Task.CompletedTask);
_resolver = new Mock <IResolver>();
_resolver
.Setup(x => x.ResolveAll <IEventHandlerAsync <SomethingCreated> >())
.Returns(new List <IEventHandlerAsync <SomethingCreated> > {
_eventHandler1.Object, _eventHandler2.Object
});
_busMessageDispatcher = new Mock <IBusMessageDispatcher>();
_busMessageDispatcher
.Setup(x => x.DispatchAsync(_somethingCreated))
.Returns(Task.CompletedTask);
_sut = new EventPublisherAsync(_resolver.Object, _busMessageDispatcher.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));
_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();
_getSomething = new GetSomething();
_something = new Something();
_createAggregate = new CreateAggregate();
_commandSenderAsync = new Mock <ICommandSenderAsync>();
_commandSenderAsync
.Setup(x => x.SendAsync(_createSomething))
.Returns(Task.CompletedTask);
_commandSenderAsync
.Setup(x => x.SendAsync <IDomainCommand, IAggregateRoot>(_createAggregate))
.Returns(Task.CompletedTask);
_commandSenderAsync
.Setup(x => x.SendAndPublishAsync(_createSomething))
.Returns(Task.CompletedTask);
_commandSenderAsync
.Setup(x => x.SendAndPublishAsync <IDomainCommand, IAggregateRoot>(_createAggregate))
.Returns(Task.CompletedTask);
_commandSender = new Mock <ICommandSender>();
_commandSender
.Setup(x => x.Send(_createSomething));
_commandSender
.Setup(x => x.Send <IDomainCommand, IAggregateRoot>(_createAggregate));
_commandSender
.Setup(x => x.SendAndPublish(_createSomething));
_commandSender
.Setup(x => x.SendAndPublish <IDomainCommand, IAggregateRoot>(_createAggregate));
_eventPublisherAsync = new Mock <IEventPublisherAsync>();
_eventPublisherAsync
.Setup(x => x.PublishAsync(_somethingCreated))
.Returns(Task.CompletedTask);
_eventPublisher = new Mock <IEventPublisher>();
_eventPublisher
.Setup(x => x.Publish(_somethingCreated));
_queryDispatcherAsync = new Mock <IQueryProcessorAsync>();
_queryDispatcherAsync
.Setup(x => x.ProcessAsync <IQuery, Something>(_getSomething))
.ReturnsAsync(_something);
_queryDispatcher = new Mock <IQueryProcessor>();
_queryDispatcher
.Setup(x => x.Process <IQuery, Something>(_getSomething))
.Returns(_something);
_sut = new Dispatcher(_commandSenderAsync.Object,
_commandSender.Object,
_eventPublisherAsync.Object,
_eventPublisher.Object,
_queryDispatcherAsync.Object,
_queryDispatcher.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()
{
_somethingCreated = new SomethingCreated();
_getSomething = new GetSomething();
_something = new Something();
_createAggregate = new CreateAggregate();
_createAggregateBusMessage = new CreateAggregateBusMessage();
_sampleCommandSequence = new SampleCommandSequence();
_commandSender = new Mock <ICommandSender>();
_commandSender
.Setup(x => x.SendAsync(_createAggregate))
.Returns(Task.CompletedTask);
_commandSender
.Setup(x => x.Send(_createAggregate));
_commandSender
.Setup(x => x.SendAsync(_sampleCommandSequence))
.Returns(Task.CompletedTask);
_commandSender
.Setup(x => x.Send(_sampleCommandSequence));
_eventPublisher = new Mock <IEventPublisher>();
_eventPublisher
.Setup(x => x.PublishAsync(_somethingCreated))
.Returns(Task.CompletedTask);
_eventPublisher
.Setup(x => x.Publish(_somethingCreated));
_queryDispatcher = new Mock <IQueryProcessor>();
_queryDispatcher
.Setup(x => x.ProcessAsync(_getSomething))
.ReturnsAsync(_something);
_queryDispatcher
.Setup(x => x.Process(_getSomething))
.Returns(_something);
_busMessageDispatcher = new Mock <IBusMessageDispatcher>();
_busMessageDispatcher
.Setup(x => x.DispatchAsync(_createAggregateBusMessage))
.Returns(Task.CompletedTask);
_sut = new Dispatcher(_commandSender.Object,
_eventPublisher.Object,
_queryDispatcher.Object,
_busMessageDispatcher.Object);
}
public void SetUp()
{
_somethingCreated = new SomethingCreated();
_eventHandler1 = new Mock <IEventHandler <SomethingCreated> >();
_eventHandler1
.Setup(x => x.Handle(_somethingCreated));
_eventHandler2 = new Mock <IEventHandler <SomethingCreated> >();
_eventHandler2
.Setup(x => x.Handle(_somethingCreated));
_resolver = new Mock <IResolver>();
_resolver
.Setup(x => x.ResolveAll <IEventHandler <SomethingCreated> >())
.Returns(new List <IEventHandler <SomethingCreated> > {
_eventHandler1.Object, _eventHandler2.Object
});
_sut = new EventPublisher(_resolver.Object);
}
public void PublishAsync_ThrowsException_WhenEventIsNull()
{
_somethingCreated = null;
Assert.ThrowsAsync <ArgumentNullException>(async() => await _sut.PublishAsync(_somethingCreated));
}
public void PublishThrowsExceptionWhenEventIsNull()
{
_somethingCreated = null;
Assert.Throws <ArgumentNullException>(() => _sut.Publish(_somethingCreated));
}
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);
}
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);
}
