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()
{
_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.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);
_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.ValidateAsync(_createAggregate))
.Returns(Task.CompletedTask);
_commandHandlerAsync = new Mock <ICommandHandlerAsync <CreateSomething> >();
_commandHandlerAsync
.Setup(x => x.HandleAsync(_createSomething))
.ReturnsAsync(_commandResponse);
_domainCommandHandlerAsync = new Mock <ICommandHandlerAsync <CreateAggregate> >();
_domainCommandHandlerAsync
.Setup(x => x.HandleAsync(_createAggregate))
.ReturnsAsync(_domainCommandResponse);
_sequenceCommandHandlerAsync = new Mock <ISequenceCommandHandlerAsync <ICommand> >();
_sequenceCommandHandlerAsync
.Setup(x => x.HandleAsync(It.IsAny <ICommand>(), It.IsAny <CommandResponse>()))
.ReturnsAsync(It.IsAny <CommandResponse>());
_handlerResolver = new Mock <IHandlerResolver>();
_handlerResolver
.Setup(x => x.ResolveHandler(_createSomething, typeof(ICommandHandlerAsync <>)))
.Returns(_commandHandlerAsync.Object);
_handlerResolver
.Setup(x => x.ResolveHandler(_createAggregate, typeof(ICommandHandlerAsync <>)))
.Returns(_domainCommandHandlerAsync.Object);
_handlerResolver
.Setup(x => x.ResolveHandler(It.IsAny <ICommand>(), typeof(ISequenceCommandHandlerAsync <>)))
.Returns(_sequenceCommandHandlerAsync.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);
}
