コード例 #1
0
        public void ResolveCommand_IsRequired_Test(CommandOptionSet commandOptionSet)
        {
            // Arrange
            var typeProvider    = new TypeProvider(typeof(TestCommand));
            var optionConverter = new CommandOptionConverter();

            var resolver = new CommandResolver(typeProvider, optionConverter);

            // Act & Assert
            Assert.Throws <CommandResolveException>(() => resolver.ResolveCommand(commandOptionSet));
        }
コード例 #2
0
        public void ConvertOption_Test(CommandOption option, Type targetType, object expectedConvertedValue)
        {
            // Arrange
            var converter = new CommandOptionConverter();

            // Act
            var convertedValue = converter.ConvertOption(option, targetType);

            // Assert
            Assert.Multiple(() =>
            {
                Assert.That(convertedValue, Is.EqualTo(expectedConvertedValue));

                if (convertedValue != null)
                {
                    Assert.That(convertedValue, Is.AssignableTo(targetType));
                }
            });
        }
コード例 #3
0
        public void ResolveCommand_Test(CommandOptionSet commandOptionSet, TestCommand expectedCommand)
        {
            // Arrange
            var typeProvider    = new TypeProvider(typeof(TestCommand));
            var optionConverter = new CommandOptionConverter();

            var resolver = new CommandResolver(typeProvider, optionConverter);

            // Act
            var command = resolver.ResolveCommand(commandOptionSet) as TestCommand;

            // Assert
            Assert.Multiple(() =>
            {
                Assert.That(command, Is.Not.Null);
                Assert.That(command.StringOption, Is.EqualTo(expectedCommand.StringOption), nameof(command.StringOption));
                Assert.That(command.IntOption, Is.EqualTo(expectedCommand.IntOption), nameof(command.IntOption));
            });
        }
コード例 #4
0
        public async Task RunAsync_Test()
        {
            // Arrange
            var command          = new TestCommand();
            var expectedExitCode = await command.ExecuteAsync();

            var commandOptionParser = new CommandOptionParser();

            var typeProvider           = new TypeProvider(typeof(TestCommand));
            var commandOptionConverter = new CommandOptionConverter();
            var commandResolver        = new CommandResolver(typeProvider, commandOptionConverter);

            var application = new CliApplication(commandOptionParser, commandResolver);

            // Act
            var exitCodeValue = await application.RunAsync();

            // Assert
            Assert.That(exitCodeValue, Is.EqualTo(expectedExitCode.Value), "Exit code");
        }