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"));
}
