Esempio n. 1
0
        public async Task ExecuteAsync_ArbitraryCommand_Always_Executes()
        {
            // arrange
            CommandsLibrary.Setup();

            var command = new ResultAsyncCommand {
                Number = 1
            };


            // act
            var result = await CommandsLibrary.CommandsProcessor.ExecuteAsync((IAsyncCommand)command);


            // assert
            result.Should().Be(2);
            command.Number.Should().Be(2);
        }
Esempio n. 2
0
        public async Task ExecuteAsync_CommandAndHandlerInDifferentLibraries_Executes()
        {
            // arrange
            CommandsLibrary.Setup(assemblies: new[] { typeof(ILibraryA).Assembly, typeof(ILibraryB).Assembly });

            var command = new CrossLibraryTestAsyncCommand {
                Number = 1
            };


            // act
            var result = await CommandsLibrary.CommandsProcessor.ExecuteAsync(command);


            // assert
            result.Should().Be(2);
            command.Number.Should().Be(2);
        }
Esempio n. 3
0
        public void Execute_ArbitraryCommand_Always_Executes()
        {
            // arrange
            CommandsLibrary.Setup();

            var command = new ResultCommand {
                Number = 1
            };


            // act
            var result = CommandsLibrary.CommandsProcessor.Execute((ICommand)command);


            // assert
            result.Should().Be(2);
            command.Number.Should().Be(2);
        }
Esempio n. 4
0
        public void ValidatableCommand_CallsValidateBeforeExecuting()
        {
            // arrange
            CommandsLibrary.Setup();

            var query = new ValidatableAsyncCommand {
                Number = 1
            };


            // act
            var action = new Action(() => CommandsLibrary.CommandsProcessor.ExecuteAsync(query).Wait());


            // assert
            action.Should().Throw <TestException> ();
            query.Number.Should().Be(1);
        }
Esempio n. 5
0
        public void GetAllDecorators_NoDecorators_ReturnsNothing()
        {
            // arrange
            var container = new Container {
                Options = { AllowOverridingRegistrations = true }
            };
            var lifestyle = Lifestyle.Transient;

            CommandsLibrary.Setup(container, lifestyle);


            // act
            var result = CommandsLibrary.CommandsProcessor.GetAllDecorators <TestDecoratableCommand> ();


            // assert
            result.Should().BeEmpty();
        }
Esempio n. 6
0
        public void GetAllDecoratorsGenericTypes_OneDecorator_ReturnsIt()
        {
            // arrange
            var container = new Container {
                Options = { AllowOverridingRegistrations = true }
            };
            var lifestyle = Lifestyle.Transient;

            CommandsLibrary.Setup(container, lifestyle);
            CommandsLibrary.RegisterCommandsDecorator(typeof(TestDecorator <,>), container, lifestyle);


            // act
            var result = CommandsLibrary.CommandsProcessor.GetAllDecoratorsGenericTypes <TestDecoratableCommand> ();


            // assert
            result.Should().Equal(typeof(TestDecorator <,>));
        }
Esempio n. 7
0
        public void Setup_CommandWithPartialHandler_Throws()
        {
            // arrange


            // act
            var action = new Action(() => CommandsLibrary.Setup(assemblies: new[] { typeof(ILibraryE).Assembly }));


            // assert
            action.Should().Throw <CommandHandlerNotFoundException> ()
            .Which
            .Should().BeEquivalentTo(new CommandHandlerNotFoundException
            {
                CommandType = typeof(TestAsyncCommandWithPartialHandler),
                ResultType  = typeof(int)
            },
                                     options => options.Including(x => x.CommandType)
                                     .Including(x => x.ResultType));
        }
Esempio n. 8
0
        public void RegisterCommandsDecorator_TwoRegistrations_Singleton_Verifies()
        {
            // arrange
            var container = new Container {
                Options = { AllowOverridingRegistrations = true }
            };
            var lifestyle = Lifestyle.Transient;

            CommandsLibrary.Setup(container, lifestyle);
            CommandsLibrary.RegisterCommandsDecorator(typeof(TestSingletonDecorator <,>), container, Lifestyle.Singleton);
            CommandsLibrary.RegisterCommandsDecorator(typeof(TestSingletonDecorator <,>), container, Lifestyle.Singleton);


            // act
            Action act = () => container.Verify();


            // assert
            act.Should().NotThrow();
        }
Esempio n. 9
0
        public void RegisterCommandsDecorator_DoesNotAppliesDecoratorToNotApplicableCommands()
        {
            // arrange
            var container = new Container {
                Options = { AllowOverridingRegistrations = true }
            };
            var lifestyle = Lifestyle.Transient;

            CommandsLibrary.Setup(container, lifestyle);
            CommandsLibrary.RegisterCommandsDecorator(typeof(TestDecorator <,>), container, lifestyle);

            var command = new TestNotDecoratableCommand {
                Number = 1
            };


            // act
            var result = CommandsLibrary.CommandsProcessor.Execute(command);


            // assert
            command.Number.Should().Be(2);
            result.Should().Be(2);
        }
Esempio n. 10
0
        public async Task RegisterCommandsDecorator_Always_RegistersAndUsesOpenGenericDecorators()
        {
            // arrange
            var container = new Container {
                Options = { AllowOverridingRegistrations = true }
            };
            var lifestyle = Lifestyle.Transient;

            CommandsLibrary.Setup(container, lifestyle);
            CommandsLibrary.RegisterAsyncCommandsDecorator(typeof(TestAsyncDecorator <,>), container, lifestyle);

            var command = new TestDecoratableAsyncCommand {
                Number = 1
            };


            // act
            var result = await CommandsLibrary.CommandsProcessor.ExecuteAsync(command);


            // assert
            command.Number.Should().Be(3);
            result.Should().Be(2);
        }