public void SetUp()
{
_getSomething = new GetSomething();
_getSomethingCacheable = new GetSomethingCacheable();
_something = new Something();
_queryHandler = new Mock <IQueryHandlerAsync <GetSomething, Something> >();
_queryHandler
.Setup(x => x.HandleAsync(_getSomething))
.ReturnsAsync(_something);
_handlerResolver = new Mock <IHandlerResolver>();
_handlerResolver
.Setup(x => x.ResolveHandler <IQueryHandlerAsync <GetSomething, Something> >())
.Returns(_queryHandler.Object);
_cacheManager = new Mock <ICacheManager>();
_cacheManager
.Setup(x => x.GetOrSetAsync(_getSomethingCacheable.CacheKey, It.IsAny <int>(), It.IsAny <Func <Task <Something> > >()))
.ReturnsAsync(_something);
_cacheOptions = new Mock <IOptions <CacheOptions> >();
_cacheOptions
.Setup(x => x.Value)
.Returns(new CacheOptions());
_sut = new QueryProcessor(_handlerResolver.Object, _cacheManager.Object, _cacheOptions.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()
{
_getSomething = new GetSomething();
_something = new Something();
_queryHandler = new Mock <IQueryHandlerAsync <GetSomething, Something> >();
_queryHandler
.Setup(x => x.HandleAsync(_getSomething))
.ReturnsAsync(_something);
_queryHandlerResolver = new Mock <IQueryHandlerResolver>();
_queryHandlerResolver
.Setup(x => x.ResolveHandler(_getSomething, typeof(IQueryHandlerAsync <,>)))
.Returns(_queryHandler.Object);
_sut = new QueryProcessor(_queryHandlerResolver.Object);
}
public void SetUp()
{
_getSomething = new GetSomething();
_something = new Something();
_queryHendler = new Mock <IQueryHandler <GetSomething, Something> >();
_queryHendler
.Setup(x => x.Retrieve(_getSomething))
.Returns(_something);
_handlerResolver = new Mock <IHandlerResolver>();
_handlerResolver
.Setup(x => x.ResolveHandler <IQueryHandler <GetSomething, Something> >())
.Returns(_queryHendler.Object);
_sut = new QueryProcessor(_handlerResolver.Object);
}
public void SetUp()
{
_getSomething = new GetSomething();
_something = new Something();
_queryHendler = new Mock <IQueryHandlerAsync <GetSomething, Something> >();
_queryHendler
.Setup(x => x.RetrieveAsync(_getSomething))
.ReturnsAsync(_something);
_resolver = new Mock <IResolver>();
_resolver
.Setup(x => x.Resolve <IQueryHandlerAsync <GetSomething, Something> >())
.Returns(_queryHendler.Object);
_sut = new QueryProcessorAsync(_resolver.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()
{
_getSomething = new GetSomething();
_something = new Something();
_queryHendler = new Mock <IQueryHandler <GetSomething, Something> >();
_queryHendler
.Setup(x => x.Retrieve(_getSomething))
.Returns(_something);
_resolver = new Mock <IResolver>();
_resolver
.Setup(x => x.Resolve <IQueryHandler <GetSomething, Something> >())
.Returns(_queryHendler.Object);
_sut = new QueryDispatcher(_resolver.Object);
}
public GetSomething Employee(string role)
{
GetSomething returnValue = null;
if (role == "admin" || role == "admins")
{
returnValue = new Admin();
return(returnValue);
}
else if (role == "manager")
{
returnValue = new Manager();
return(returnValue);
}
returnValue = new all();
return(returnValue);
}
public void ProcessAsync_ThrowsException_WhenQueryIsNull()
{
_getSomething = null;
Assert.ThrowsAsync <ArgumentNullException>(async() => await _sut.ProcessAsync <Something>(_getSomething));
}
public void Process_ThrowsException_WhenQueryIsNull()
{
_getSomething = null;
Assert.Throws <ArgumentNullException>(() => _sut.Process <GetSomething, Something>(_getSomething));
}
public void DispatchThrowsExceptionWhenQueryIsNull()
{
_getSomething = null;
Assert.Throws <ArgumentNullException>(() => _sut.Dispatch <GetSomething, Something>(_getSomething));
}
public void DispatchThrowsExceptionWhenQueryIsNull()
{
_getSomething = null;
Assert.ThrowsAsync <ArgumentNullException>(async() => await _sut.DispatchAsync <GetSomething, Something>(_getSomething));
}
