public void ShouldUseRegisteredCommandHandlerToExecuteCommand()
            {
                List <IQueryHandler> queryHandlers =
                    Enumerable.Repeat <IQueryHandler>(new TestQueryHandler1 <TestQuery1, string>(string.Empty), 1)
                    .ToList();
                var mockHandler = new TestCommandHandler1 <TestCommand1>();
                ICollection <ICommandHandler> commandHandlers = new List <ICommandHandler>
                {
                    mockHandler
                };
                var command = new TestCommand1();

                var dispatcher = new CommandAndQueryDispatcher(commandHandlers, queryHandlers);

                dispatcher.ExecuteCommand(command);
                mockHandler.CommandExecuted.Should().Be(command);
            }
            public void ShouldThrowInvalidOperationExceptionWhenNoCommandHandlerIsRegistered()
            {
                List <IQueryHandler> queryHandlers =
                    Enumerable.Repeat <IQueryHandler>(new TestQueryHandler1 <TestQuery1, string>(string.Empty), 1)
                    .ToList();
                var mockHandler = new TestCommandHandler1 <TestCommand1>();
                ICollection <ICommandHandler> commandHandlers = new List <ICommandHandler>
                {
                    mockHandler,
                };
                var command = new TestCommand2();

                var    dispatcher = new CommandAndQueryDispatcher(commandHandlers, queryHandlers);
                Action action     = () => dispatcher.ExecuteCommand(command);

                action.ShouldThrow <InvalidOperationException>();
            }
            public void ShouldUseRegisteredQueryHandlerToExecuteQuery()
            {
                const string expectedResult = "expectedResult";
                var          mockHandler    = new TestQueryHandler1 <TestQuery1, string>(expectedResult);
                ICollection <ICommandHandler> commandHandlers =
                    Enumerable.Repeat <ICommandHandler>(new TestCommandHandler1 <TestCommand1>(), 1).ToList();
                ICollection <IQueryHandler> queryHandlers = new List <IQueryHandler>
                {
                    mockHandler
                };
                var query = new TestQuery1();

                var    dispatcher  = new CommandAndQueryDispatcher(commandHandlers, queryHandlers);
                string queryResult = dispatcher.ExecuteQuery(query);

                mockHandler.QueryExecuted.Should().Be(query);
                queryResult.Should().Be(expectedResult);
            }
            public void ShouldThrowInvalidOperationExceptionWhenQueryHandlerIsNotRegistered()
            {
                const string expectedResult  = "expectedResult";
                const string expectedResult2 = "expectedResult2";
                var          mockHandler     = new TestQueryHandler1 <TestQuery1, string>(expectedResult);
                ICollection <ICommandHandler> commandHandlers =
                    Enumerable.Repeat <ICommandHandler>(new TestCommandHandler1 <TestCommand1>(), 1).ToList();
                ICollection <IQueryHandler> queryHandlers = new List <IQueryHandler>
                {
                    mockHandler,
                };
                var query = new TestQuery2();

                var    dispatcher = new CommandAndQueryDispatcher(commandHandlers, queryHandlers);
                string queryResult;
                Action action = () => queryResult = dispatcher.ExecuteQuery(query);

                action.ShouldThrow <InvalidOperationException>();
            }