public void NFlags_ShouldRunSubCommand() { var subCmdCalled = false; Cli.Configure(c => { }) .Root(c => c. RegisterCommand("sub", "desc", sc => sc. SetExecute((args, output) => { subCmdCalled = true; return(0); }) ) ) .Run(new[] { "sub" }); Assert.True(subCmdCalled); }
public void TestRun_ShouldRunDefaultCommandWithParams() { CommandArgs a = null; Cli .Configure(c => { }) .Root(c => c .RegisterDefaultCommand("defaultCommand", "defaultCommandDescription", dc => dc .RegisterParameter("param1", "paramDesc", "xx") .SetExecute((args, output) => { a = args; }) )) .Run(new [] { "ff" }); Assert.Equal("ff", a.GetParameter <string>("param1")); }
public void RegisterCommandGeneric_ReadMultipleParamsIntoArray_WhenAllowMultiple() { ArrayArgumentType a = null; Cli .Configure(c => c .SetDialect(Dialect.Gnu) .DisableExceptionHandling()) .Root <ArrayArgumentType>(c => c.SetExecute((args, output) => a = args) ).Run(new[] { "--int-array", "1", "--int-array", "2", "--int-array", "3" }); Assert.Equal(new[] { 1, 2, 3 }, a.Option); }
public void TestParams_ShouldSetParamSeries_IfContainedInArgs() { CommandArgs a = null; Cli.Configure(configurator => configurator .SetDialect(Dialect.Gnu) ) .Root(configurator => configurator .RegisterParameterSeries <string>("paramSeries1", "") .SetExecute((args, output) => { a = args; return(0); }) ) .Run(new[] { "paramValue1" }); Assert.Equal("paramValue1", a.GetParameterFromSeries <string>(0)); }
public void TestParams_ShouldNotSetFlagValue_IfNotContainedInArgs() { CommandArgs a = null; Cli.Configure(configurator => configurator .SetDialect(Dialect.Gnu) ) .Root(configurator => configurator .RegisterFlag("yFlag", "y", "", false) .SetExecute((args, output) => { a = args; return(0); }) ) .Run(new string[] { }); Assert.False(a.GetFlag("yFlag")); }
public void RegisterCommand_ShouldPassArgumentsToValuesToExecute_EvenIfConfigurationValuesAreSet() { var testEnvironment = new TestConfig() .SetConfigValue("NFLAG_TEST_OPTION1", "3") .SetConfigValue("NFLAG_TEST_OPTION2", "xyz") .SetConfigValue("NFLAG_TEST_PARAMETER1", 2.53.ToString(CultureInfo.CurrentCulture)) .SetConfigValue("NFLAG_TEST_PARAMETER2", "5"); CommandArgs a = null; Cli .Configure(c => c .SetDialect(Dialect.Gnu) .SetConfiguration(testEnvironment) ) .Root(c => c .RegisterCommand("sub", "sub command ", rc => rc .RegisterOption <int>(b => b.Name("option1").Description("option desc").DefaultValue(1).ConfigPath("NFLAG_TEST_OPTION1")) .RegisterOption <string>(b => b.Name("option2").Abr("o2").Description("option2 desc").DefaultValue("asd").ConfigPath("NFLAG_TEST_OPTION2")) .RegisterParameter <double>(b => b.Name("parameter1").Description("parameter desc").DefaultValue(1.1).ConfigPath("NFLAG_TEST_PARAMETER1")) .RegisterParameter <int>(b => b.Name("parameter2").Description("parameter2 desc").DefaultValue(1).ConfigPath("NFLAG_TEST_PARAMETER2")) .SetExecute((args, output) => { a = args; })) .SetExecute((type, output) => { }) ) .Run(new[] { "sub", "--option1", "30", "-o2", "cxyz", 20.53.ToString(CultureInfo.CurrentCulture), "50" }); Assert.Equal(30, a.GetOption <int>("option1")); Assert.Equal("cxyz", a.GetOption <string>("option2")); Assert.Equal(20.53, a.GetParameter <double>("parameter1")); Assert.Equal(50, a.GetParameter <int>("parameter2")); }
public void TestParams_ShouldSetOptionValue_IfWordAbrContainedInArgs() { CommandArgs a = null; Cli.Configure(configurator => configurator .SetDialect(Dialect.Gnu) ) .Root(configurator => configurator .RegisterOption("option", "op", "", "") .SetExecute((args, output) => { a = args; return(0); }) ) .Run(new[] { "-op", "optionValue" }); Assert.Equal("optionValue", a.GetOption <string>("option")); }
public void Run_ShouldPrintHelp_WhenCustomizedHelpFlagPassed() { var printer = Substitute.For <IHelpPrinter>(); Cli.Configure(c => c .SetDialect(Dialect.Gnu) .ConfigureHelp(configurator => configurator .SetPrinter(printer) .SetOptionFlag("xhelp") ) ) .Root(c => c .RegisterParameterSeries <string>("fk", "fake parameters to allow wrong flag without exception") .SetExecute((args, output) => output.WriteLine(args.GetParameterSeries <string>())) ) .Run(new[] { "--xhelp" }); printer.Received().PrintHelp(Arg.Any <CliConfig>(), Arg.Any <CommandConfig>()); }
public void TestParams_ShouldSetOptionValueForTypeWhereStringIsConvertibleTo_IfContainedInArgs() { CommandArgs a = null; Cli.Configure(configurator => configurator .SetDialect(Dialect.Win) ) .Root(configurator => configurator .RegisterOption("option", "o", "", 1) .SetExecute((args, output) => { a = args; return(0); }) ) .Run(new[] { "/option=2" }); Assert.Equal(2, a.GetOption <int>("option")); }
public void TestParams_ShouldSetDefaultOptionValue_IfNotContainedInArgs() { CommandArgs a = null; Cli.Configure(configurator => configurator .SetDialect(Dialect.Win) ) .Root(configurator => configurator .RegisterOption("option", "o", "", "defaultValue") .SetExecute((args, output) => { a = args; return(0); }) ) .Run(new string[] { }); Assert.Equal("defaultValue", a.GetOption <string>("option")); }
public void TestParams_ShouldSetOptionValueForTypeWithImplicitOperatorFromString_IfContainedInArgs() { CommandArgs a = null; Cli.Configure(configurator => configurator .SetDialect(Dialect.Win) ) .Root(configurator => configurator .RegisterOption("option", "o", "", new TypeWithImplicitOperator()) .SetExecute((args, output) => { a = args; return(0); }) ) .Run(new[] { "/option=b" }); Assert.Equal("b", a.GetOption <TypeWithImplicitOperator>("option").S); }
public void TestOption_ShouldUseCustomConverterConfiguredForOption_IfSet() { CommandArgs args = null; Cli .Configure(c => { }) .Root(c => c .RegisterOption <CustomType>(b => b .Name("custom") .Description("CustomType") .DefaultValue(null) .Converter(new CustomTypeConverter()) ) .SetExecute((commandArgs, output) => { args = commandArgs; }) ) .Run(new [] { "/custom=x" }); Assert.Equal("x", args.GetOption <CustomType>("custom").SomeString); }
public void TestParams_ShouldSetFlag_IfWordAbrContainedInArgs() { CommandArgs a = null; Cli.Configure(configurator => configurator .SetDialect(Dialect.Gnu) ) .Root(configurator => configurator .RegisterFlag("xFlag", "xf", "", false) .SetExecute((args, output) => { a = args; return(0); }) ) .Run(new[] { "-xf" }); Assert.True(a.GetFlag("xFlag")); }
public void PrintHelp_ShouldPrintVersion_WhenCustomFlagAbrPassed() { var outputAggregator = new OutputAggregator(); Cli.Configure(configurator => { configurator .SetDialect(Dialect.Gnu) .ConfigureVersion(vc => vc.Enable().SetOptionAbr("x")) .SetOutput(outputAggregator); }) .Root(c => { }) .Run(new[] { "-x" }); NFAssert.HelpEquals( outputAggregator, "testhost Version: " + Assembly.GetEntryAssembly()?.GetName().Version ); }
public void RegisterCommand_ShouldPrintParametersOptionsFlagsAndParameterSeriesInHelp() { var outputAggregator = new OutputAggregator(); Cli .Configure(c => c .SetDialect(Dialect.Gnu) .SetOutput(outputAggregator) ) .Root(c => c .RegisterCommand("sub", "sub command ", rc => rc .RegisterOption <int>(b => b.Name("option1").Description("option desc").DefaultValue(1)) .RegisterOption <string>(b => b.Name("option2").Abr("o2").Description("option2 desc").DefaultValue("asd")) .RegisterFlag(b => b.Name("flag1").Description("flag desc").DefaultValue(true)) .RegisterFlag(b => b.Name("flag2").Abr("f2").Description("flag2 desc")) .RegisterParameter <double>(b => b.Name("parameter1").Description("parameter desc").DefaultValue(1.1)) .RegisterParameter <int>(b => b.Name("parameter2").Description("parameter2 desc").DefaultValue(1)) .RegisterParameterSeries <int>(b => b.Name("parameterSeries").Description("parameter series desc")) .SetExecute((args, output) => { })) .SetExecute((type, output) => { }) ) .Run(new[] { "sub", "--help" }); NFAssert.HelpEquals( outputAggregator, "Usage:", "\ttesthost sub [OPTIONS]... [PARAMETERS]...", "", "\tParameters:", "\t<parameter1>\tparameter desc (Default: " + 1.1 + ")", "\t<parameter2>\tparameter2 desc (Default: " + 1 + ")", "\t<parameterSeries...>\tparameter series desc", "", "\tOptions:", "\t--option1 <option1>\toption desc (Default: " + 1 + ")", "\t--option2 <option2>, -o2 <option2>\toption2 desc (Default: 'asd')", "\t--flag1\tflag desc", "\t--flag2, -f2\tflag2 desc", "\t--help, -h\tPrints this help", "" ); }
public void PrintHelp_ShouldPrintDefaultValueAfterOptionAndParametersDescriptions() { var outputAggregator = new OutputAggregator(); Cli.Configure(configurator => configurator .SetDialect(_dialect) .SetOutput(outputAggregator) .SetName("custName") .SetDescription("some description") ) .Root(configurator => configurator .RegisterFlag("flag1", "Flag 1 Description", false) .RegisterFlag("flag2", "f2", "Flag 2 Description", false) .RegisterOption("option1", "Option 1 Description", 1) .RegisterOption("option2", "o2", "Option 2 Description", 2.1) .RegisterParameter("param1", "Param 1 Description", 8.5m) .RegisterParameter("param2", "Param 2 Description", "default") .RegisterParameter("param3", "", "default") ) .Run(new[] { "" + _longPrefix + "help" }); NFAssert.HelpEquals( outputAggregator, "Usage:", "\tcustName [OPTIONS]... [PARAMETERS]...", "", "some description", "", "\tParameters:", "\t<param1>\tParam 1 Description (Default: " + 8.5 + ")", "\t<param2>\tParam 2 Description (Default: 'default')", "\t<param3>\t(Default: 'default')", "", "\tOptions:", "\t" + _longPrefix + "flag1\tFlag 1 Description", "\t" + _longPrefix + "flag2, " + _shortPrefix + "f2\tFlag 2 Description", "\t" + _longPrefix + "option1" + _optionValueSeparator + "<option1>\tOption 1 Description (Default: 1)", "\t" + _longPrefix + "option2" + _optionValueSeparator + "<option2>, " + _shortPrefix + "o2" + _optionValueSeparator + "<option2>\tOption 2 Description (Default: " + 2.1 + ")", "\t" + _longPrefix + "help, " + _shortPrefix + "h\tPrints this help", "" ); }
public static NFlags.Bootstrap Init(ApplicationConfig applicationConfig, Action <CommandConfigurator, IGenericConfig> additionalConfiguration = null) { var configuration = new Configuration(GetContentRoot()); return(Cli.Configure(c => c .SetName(applicationConfig.Name) .SetDescription(applicationConfig.Description) .SetDialect(Dialect.Gnu) .SetEnvironment(Environment.Prefixed(applicationConfig.EnvPrefix)) .SetConfiguration(configuration) .RegisterConverter(new StringToStringArrayConverter()) ) .Root(c => { c.PrintHelpOnExecute(); additionalConfiguration?.Invoke(c, configuration); })); }
public void RegisterCommandT_ShouldNotReadOptionEnvironmentVariable_IfSetAfterInitialization() { var testEnvironment = new TestEnvironment(); ArgumentsType commandArgs = null; Cli .Configure(c => c .SetDialect(Dialect.Gnu) .SetEnvironment(testEnvironment) ) .Root <ArgumentsType>(c => c .SetExecute((args, output) => { commandArgs = args; }) ) .Run(new string[0]); testEnvironment .SetEnvironmentVariable("NFLAG_TEST_OPTION1", "2"); Assert.Equal(1, commandArgs.Option1); }
public void PrintHelp_ShouldPrintSubCommandBasicInfoWithDefaultName() { var outputAggregator = new OutputAggregator(); Cli.Configure(configurator => configurator .SetDialect(_dialect) .SetOutput(outputAggregator) ) .Root(c => { }) .Run(new[] { "" + _longPrefix + "help" }); NFAssert.HelpEquals( outputAggregator, "Usage:", "\ttesthost [OPTIONS]...", "", "\tOptions:", "\t" + _longPrefix + "help, " + _shortPrefix + "h\tPrints this help", "" ); }
public void RegisterCommandT_ShouldReadFlagLazyEnvironmentVariable_IfSetAfterInitialization() { var testConfig = new TestConfig(); LazyConfigPathArgumentsType commandArgs = null; Cli .Configure(c => c .SetDialect(Dialect.Gnu) .SetConfiguration(testConfig) ) .Root <LazyConfigPathArgumentsType>(c => c .SetExecute((args, output) => { commandArgs = args; }) ) .Run(new string[0]); testConfig .SetConfigValue("config.flag", "false"); Assert.False(commandArgs.Flag.Value); }
public void PrintingHelp_ShouldPrintTextReturnedByPrinterToOutput() { const string helpText = "some help text"; var printer = Substitute.For <IHelpPrinter>(); printer.PrintHelp(Arg.Any <CliConfig>(), Arg.Any <CommandConfig>()).Returns(helpText); var output = Substitute.For <IOutput>(); Cli.Configure(c => c .ConfigureHelp(configurator => configurator.SetPrinter(printer)) .SetOutput(output) ) .Root(c => c .PrintHelpOnExecute() ) .Run(new string[0]); output.Received().Write(Arg.Is(helpText)); }
public void TestParams_ShouldSetSecondParam_IfContainedInArgs() { CommandArgs a = null; Cli.Configure(configurator => configurator .SetDialect(Dialect.Win) ) .Root(configurator => configurator .RegisterParameter("param1", "", "") .RegisterParameter("param2", "", "") .SetExecute((args, output) => { a = args; return(0); }) ) .Run(new[] { "paramValue1", "paramValue2" }); Assert.Equal("paramValue1", a.GetParameter <string>("param1")); Assert.Equal("paramValue2", a.GetParameter <string>("param2")); }
public void RegisterCommandT_ShouldReadLazyParameterEnvironmentVariable_IfSetAfterInitialization() { var testEnvironment = new TestEnvironment(); LazyEnvironmentArgumentsType commandArgs = null; Cli .Configure(c => c .SetDialect(Dialect.Gnu) .SetEnvironment(testEnvironment) ) .Root <LazyEnvironmentArgumentsType>(c => c .SetExecute((args, output) => { commandArgs = args; }) ) .Run(new string[0]); testEnvironment .SetEnvironmentVariable("NFLAG_TEST_PARAM_ENV", "env_p"); Assert.Equal("env_p", commandArgs.Parameter.Value); }
public void RegisterCommandT_ShouldReadLazyParameterEnvironmentVariable_IfSetAfterInitialization() { var testConfig = new TestConfig(); LazyConfigPathArgumentsType commandArgs = null; Cli .Configure(c => c .SetDialect(Dialect.Gnu) .SetConfiguration(testConfig) ) .Root <LazyConfigPathArgumentsType>(c => c .SetExecute((args, output) => { commandArgs = args; }) ) .Run(new string[0]); testConfig .SetConfigValue("config.parameter", "env_p"); Assert.Equal("env_p", commandArgs.Parameter.Value); }
public void TestParams_ShouldSetMultipleFlags_IfAbrContainedInArgs() { CommandArgs a = null; Cli.Configure(configurator => configurator .SetDialect(Dialect.Gnu) ) .Root(configurator => configurator .RegisterFlag("flag1", "f1", "", false) .RegisterFlag("flag2", "f2", "", false) .SetExecute((args, output) => { a = args; return(0); }) ) .Run(new[] { "-f1", "-f2" }); Assert.True(a.GetFlag("flag1")); Assert.True(a.GetFlag("flag2")); }
public void RegisterCommandT_ShouldReadFlagLazyEnvironmentVariable_IfSetAfterInitialization() { var testEnvironment = new TestEnvironment(); LazyEnvironmentArgumentsType commandArgs = null; Cli .Configure(c => c .SetDialect(Dialect.Gnu) .SetEnvironment(testEnvironment) ) .Root <LazyEnvironmentArgumentsType>(c => c .SetExecute((args, output) => { commandArgs = args; }) ) .Run(new string[0]); testEnvironment .SetEnvironmentVariable("NFLAG_TEST_FLAG_ENV", "false"); Assert.False(commandArgs.Flag.Value); }
public void TestParams_ShouldSetMultipleOptionValues_IfOptionHasNoAbrAndContainedInArgs() { CommandArgs a = null; Cli.Configure(configurator => configurator .SetDialect(Dialect.Gnu) ) .Root(configurator => configurator .RegisterOption("option1", "", "") .RegisterOption("option2", "", "") .SetExecute((args, output) => { a = args; return(0); }) ) .Run(new[] { "--option1", "optValue1", "--option2", "optValue2" }); Assert.Equal("optValue1", a.GetOption <string>("option1")); Assert.Equal("optValue2", a.GetOption <string>("option2")); }
public void TestParams_ShouldReverseFlags_IfContainedInArgs() { CommandArgs a = null; Cli.Configure(configurator => configurator .SetDialect(Dialect.Gnu) ) .Root(configurator => configurator .RegisterFlag("xFlag1", "x1", "", true) .RegisterFlag("xFlag2", "x2", "", true) .SetExecute((args, output) => { a = args; return(0); }) ) .Run(new[] { "--xFlag1", "--xFlag2" }); Assert.False(a.GetFlag("xFlag1")); Assert.False(a.GetFlag("xFlag2")); }
public void RegisterCommandT_ShouldNotReadOptionEnvironmentVariable_IfSetAfterInitialization() { var testConfig = new TestConfig(); NonLazyConfigPathArgumentsType commandArgs = null; Cli .Configure(c => c .SetDialect(Dialect.Gnu) .SetConfiguration(testConfig) ) .Root <NonLazyConfigPathArgumentsType>(c => c .SetExecute((args, output) => { commandArgs = args; }) ) .Run(new string[0]); testConfig .SetConfigValue("config.option", "2"); Assert.Equal("def_o", commandArgs.Option); }
public void RegisterCommand_ShouldPassConfigurationValuesToValuesToExecute() { var testConfig = new TestConfig() .SetConfigValue("NFLAG_TEST_FLAG1", "false") .SetConfigValue("NFLAG_TEST_FLAG2", "true") .SetConfigValue("NFLAG_TEST_OPTION1", "3") .SetConfigValue("NFLAG_TEST_OPTION2", "xyz") .SetConfigValue("NFLAG_TEST_PARAMETER1", 2.53.ToString(CultureInfo.CurrentCulture)) .SetConfigValue("NFLAG_TEST_PARAMETER2", "5"); CommandArgs a = null; Cli .Configure(c => c .SetDialect(Dialect.Gnu) .SetConfiguration(testConfig) ) .Root(c => c .RegisterCommand("sub", "sub command ", rc => rc .RegisterOption <int>(b => b.Name("option1").Description("option desc").DefaultValue(1).ConfigPath("NFLAG_TEST_OPTION1")) .RegisterOption <string>(b => b.Name("option2").Abr("o2").Description("option2 desc").DefaultValue("asd").ConfigPath("NFLAG_TEST_OPTION2")) .RegisterFlag(b => b.Name("flag1").Description("flag desc").DefaultValue(true).ConfigPath("NFLAG_TEST_FLAG1")) .RegisterFlag(b => b.Name("flag2").Abr("f2").Description("flag2 desc").ConfigPath("NFLAG_TEST_FLAG2")) .RegisterParameter <double>(b => b.Name("parameter1").Description("parameter desc").DefaultValue(1.1).ConfigPath("NFLAG_TEST_PARAMETER1")) .RegisterParameter <int>(b => b.Name("parameter2").Description("parameter2 desc").DefaultValue(1).ConfigPath("NFLAG_TEST_PARAMETER2")) .SetExecute((args, output) => { a = args; })) .SetExecute((type, output) => { }) ) .Run(new[] { "sub" }); Assert.Equal(3, a.GetOption <int>("option1")); Assert.Equal("xyz", a.GetOption <string>("option2")); Assert.False(a.GetFlag("flag1")); Assert.True(a.GetFlag("flag2")); Assert.Equal(2.53, a.GetParameter <double>("parameter1")); Assert.Equal(5, a.GetParameter <int>("parameter2")); }