clap/tests/builder/subcommands.rs

652 lines
18 KiB
Rust
Raw Normal View History

use clap::{arg, error::ErrorKind, Arg, ArgAction, Command};
use super::utils;
#[test]
fn subcommand() {
2022-02-12 03:48:29 +00:00
let m = Command::new("test")
2018-01-25 04:05:05 +00:00
.subcommand(
2022-02-12 03:48:29 +00:00
Command::new("some").arg(
Arg::new("test")
.short('t')
2018-01-25 04:05:05 +00:00
.long("test")
.action(ArgAction::Set)
.help("testing testing"),
2018-01-25 04:05:05 +00:00
),
2018-11-14 17:05:06 +00:00
)
.arg(Arg::new("other").long("other"))
.try_get_matches_from(vec!["myprog", "some", "--test", "testing"])
.unwrap();
assert_eq!(m.subcommand_name().unwrap(), "some");
let sub_m = m.subcommand_matches("some").unwrap();
assert!(sub_m.contains_id("test"));
assert_eq!(
sub_m.get_one::<String>("test").map(|v| v.as_str()).unwrap(),
"testing"
);
}
#[test]
fn subcommand_none_given() {
2022-02-12 03:48:29 +00:00
let m = Command::new("test")
2018-01-25 04:05:05 +00:00
.subcommand(
2022-02-12 03:48:29 +00:00
Command::new("some").arg(
Arg::new("test")
.short('t')
2018-01-25 04:05:05 +00:00
.long("test")
.action(ArgAction::Set)
.help("testing testing"),
2018-01-25 04:05:05 +00:00
),
2018-11-14 17:05:06 +00:00
)
.arg(Arg::new("other").long("other"))
.try_get_matches_from(vec![""])
.unwrap();
assert!(m.subcommand_name().is_none());
}
#[test]
fn subcommand_multiple() {
2022-02-12 03:48:29 +00:00
let m = Command::new("test")
.subcommands(vec![
2022-02-12 03:48:29 +00:00
Command::new("some").arg(
Arg::new("test")
.short('t')
.long("test")
.action(ArgAction::Set)
.help("testing testing"),
2018-01-25 04:05:05 +00:00
),
2022-02-12 03:48:29 +00:00
Command::new("add").arg(Arg::new("roster").short('r')),
])
.arg(Arg::new("other").long("other"))
.try_get_matches_from(vec!["myprog", "some", "--test", "testing"])
.unwrap();
assert!(m.subcommand_matches("some").is_some());
assert!(m.subcommand_matches("add").is_none());
assert_eq!(m.subcommand_name().unwrap(), "some");
let sub_m = m.subcommand_matches("some").unwrap();
assert!(sub_m.contains_id("test"));
assert_eq!(
sub_m.get_one::<String>("test").map(|v| v.as_str()).unwrap(),
"testing"
2022-04-29 20:32:25 +00:00
);
2020-04-02 04:35:48 +00:00
}
#[test]
fn single_alias() {
2022-02-12 03:48:29 +00:00
let m = Command::new("myprog")
.subcommand(Command::new("test").alias("do-stuff"))
.try_get_matches_from(vec!["myprog", "do-stuff"])
.unwrap();
assert_eq!(m.subcommand_name(), Some("test"));
}
#[test]
fn multiple_aliases() {
2022-02-12 03:48:29 +00:00
let m = Command::new("myprog")
.subcommand(Command::new("test").aliases(["do-stuff", "test-stuff"]))
.try_get_matches_from(vec!["myprog", "test-stuff"])
.unwrap();
assert_eq!(m.subcommand_name(), Some("test"));
}
#[test]
2018-01-25 04:05:05 +00:00
#[cfg(feature = "suggestions")]
#[cfg(feature = "error-context")]
fn subcmd_did_you_mean_output() {
#[cfg(feature = "suggestions")]
static DYM_SUBCMD: &str = "\
error: The subcommand 'subcm' wasn't recognized
Did you mean 'subcmd'?
If you believe you received this message in error, try re-running with 'dym -- subcm'
Usage: dym [COMMAND]
For more information try '--help'
";
2022-02-14 21:47:20 +00:00
let cmd = Command::new("dym").subcommand(Command::new("subcmd"));
2022-04-29 20:32:25 +00:00
utils::assert_output(cmd, "dym subcm", DYM_SUBCMD, true);
}
#[test]
#[cfg(feature = "suggestions")]
#[cfg(feature = "error-context")]
fn subcmd_did_you_mean_output_ambiguous() {
#[cfg(feature = "suggestions")]
static DYM_SUBCMD_AMBIGUOUS: &str = "\
error: The subcommand 'te' wasn't recognized
Did you mean 'test' or 'temp'?
If you believe you received this message in error, try re-running with 'dym -- te'
Usage: dym [COMMAND]
For more information try '--help'
";
2022-02-14 21:47:20 +00:00
let cmd = Command::new("dym")
2022-02-12 03:48:29 +00:00
.subcommand(Command::new("test"))
.subcommand(Command::new("temp"));
2022-04-29 20:32:25 +00:00
utils::assert_output(cmd, "dym te", DYM_SUBCMD_AMBIGUOUS, true);
}
#[test]
2018-01-25 04:05:05 +00:00
#[cfg(feature = "suggestions")]
#[cfg(feature = "error-context")]
fn subcmd_did_you_mean_output_arg() {
static EXPECTED: &str = "\
error: Found argument '--subcmarg' which wasn't expected, or isn't valid in this context
Did you mean to put '--subcmdarg' after the subcommand 'subcmd'?
If you tried to supply `--subcmarg` as a value rather than a flag, use `-- --subcmarg`
Usage: dym [COMMAND]
For more information try '--help'
";
let cmd = Command::new("dym")
.subcommand(Command::new("subcmd").arg(arg!(-s --subcmdarg <subcmdarg> "tests")));
2022-04-29 20:32:25 +00:00
utils::assert_output(cmd, "dym --subcmarg subcmd", EXPECTED, true);
}
#[test]
#[cfg(feature = "suggestions")]
#[cfg(feature = "error-context")]
fn subcmd_did_you_mean_output_arg_false_positives() {
static EXPECTED: &str = "\
error: Found argument '--subcmarg' which wasn't expected, or isn't valid in this context
If you tried to supply `--subcmarg` as a value rather than a flag, use `-- --subcmarg`
Usage: dym [COMMAND]
For more information try '--help'
";
let cmd = Command::new("dym")
.subcommand(Command::new("subcmd").arg(arg!(-s --subcmdarg <subcmdarg> "tests")));
2022-04-29 20:32:25 +00:00
utils::assert_output(cmd, "dym --subcmarg foo", EXPECTED, true);
}
#[test]
fn alias_help() {
2022-02-12 03:48:29 +00:00
let m = Command::new("myprog")
.subcommand(Command::new("test").alias("do-stuff"))
.try_get_matches_from(vec!["myprog", "help", "do-stuff"]);
assert!(m.is_err());
2022-01-25 22:19:28 +00:00
assert_eq!(m.unwrap_err().kind(), ErrorKind::DisplayHelp);
2016-06-10 01:55:53 +00:00
}
#[test]
fn visible_aliases_help_output() {
static VISIBLE_ALIAS_HELP: &str = "\
Usage: clap-test [COMMAND]
Commands:
test Some help [aliases: dongle, done]
help Print this message or the help of the given subcommand(s)
Options:
-h, --help Print help information
-V, --version Print version information
";
2022-02-14 21:47:20 +00:00
let cmd = Command::new("clap-test").version("2.6").subcommand(
2022-02-12 03:48:29 +00:00
Command::new("test")
2016-06-10 01:55:53 +00:00
.about("Some help")
.alias("invisible")
.visible_alias("dongle")
2018-01-25 04:05:05 +00:00
.visible_alias("done"),
);
2022-04-29 20:32:25 +00:00
utils::assert_output(cmd, "clap-test --help", VISIBLE_ALIAS_HELP, false);
2016-06-10 01:55:53 +00:00
}
#[test]
fn invisible_aliases_help_output() {
static INVISIBLE_ALIAS_HELP: &str = "\
Usage: clap-test [COMMAND]
Commands:
test Some help
help Print this message or the help of the given subcommand(s)
Options:
-h, --help Print help information
-V, --version Print version information
";
2022-02-14 21:47:20 +00:00
let cmd = Command::new("clap-test")
2018-11-14 17:05:06 +00:00
.version("2.6")
2022-02-12 03:48:29 +00:00
.subcommand(Command::new("test").about("Some help").alias("invisible"));
2022-04-29 20:32:25 +00:00
utils::assert_output(cmd, "clap-test --help", INVISIBLE_ALIAS_HELP, false);
}
2020-02-14 16:22:01 +00:00
#[test]
#[cfg(feature = "unstable-replace")]
2020-02-14 16:22:01 +00:00
fn replace() {
2022-02-12 03:48:29 +00:00
let m = Command::new("prog")
.subcommand(
Command::new("module").subcommand(Command::new("install").about("Install module")),
)
2020-02-14 16:22:01 +00:00
.replace("install", &["module", "install"])
.try_get_matches_from(vec!["prog", "install"])
.unwrap();
2020-02-14 16:22:01 +00:00
assert_eq!(m.subcommand_name(), Some("module"));
assert_eq!(
m.subcommand_matches("module").unwrap().subcommand_name(),
Some("install")
);
}
#[test]
fn issue_1031_args_with_same_name() {
2022-02-12 03:48:29 +00:00
let res = Command::new("prog")
.arg(arg!(--"ui-path" <PATH>).required(true))
2022-02-12 03:48:29 +00:00
.subcommand(Command::new("signer"))
.try_get_matches_from(vec!["prog", "--ui-path", "signer"]);
2022-01-25 22:19:28 +00:00
assert!(res.is_ok(), "{:?}", res.unwrap_err().kind());
let m = res.unwrap();
assert_eq!(
m.get_one::<String>("ui-path").map(|v| v.as_str()),
Some("signer")
);
}
#[test]
fn issue_1031_args_with_same_name_no_more_vals() {
2022-02-12 03:48:29 +00:00
let res = Command::new("prog")
.arg(arg!(--"ui-path" <PATH>).required(true))
2022-02-12 03:48:29 +00:00
.subcommand(Command::new("signer"))
.try_get_matches_from(vec!["prog", "--ui-path", "value", "signer"]);
2022-01-25 22:19:28 +00:00
assert!(res.is_ok(), "{:?}", res.unwrap_err().kind());
let m = res.unwrap();
assert_eq!(
m.get_one::<String>("ui-path").map(|v| v.as_str()),
Some("value")
);
assert_eq!(m.subcommand_name(), Some("signer"));
2018-01-25 04:05:05 +00:00
}
#[test]
fn issue_1161_multiple_hyphen_hyphen() {
// from example 22
2022-02-12 03:48:29 +00:00
let res = Command::new("myprog")
.arg(Arg::new("eff").short('f'))
.arg(Arg::new("pea").short('p').action(ArgAction::Set))
2021-06-16 05:28:25 +00:00
.arg(
Arg::new("slop")
.action(ArgAction::Set)
.num_args(1..)
2021-06-16 05:28:25 +00:00
.last(true),
)
.try_get_matches_from(vec![
2018-08-02 03:13:51 +00:00
"-f",
"-p=bob",
"--",
"sloppy",
"slop",
"-a",
"--",
"subprogram",
"position",
"args",
]);
2022-01-25 22:19:28 +00:00
assert!(res.is_ok(), "{:?}", res.unwrap_err().kind());
let m = res.unwrap();
2018-08-02 03:13:51 +00:00
let expected = Some(vec![
"sloppy",
"slop",
"-a",
"--",
"subprogram",
"position",
"args",
]);
let actual = m
.get_many::<String>("slop")
.map(|vals| vals.map(|s| s.as_str()).collect::<Vec<_>>());
assert_eq!(expected, actual);
2018-08-02 03:13:51 +00:00
}
2020-03-05 12:02:48 +00:00
#[test]
fn issue_1722_not_emit_error_when_arg_follows_similar_to_a_subcommand() {
2022-02-12 03:48:29 +00:00
let m = Command::new("myprog")
.subcommand(Command::new("subcommand"))
.arg(Arg::new("argument"))
2020-03-05 12:02:48 +00:00
.try_get_matches_from(vec!["myprog", "--", "subcommand"]);
assert_eq!(
m.unwrap().get_one::<String>("argument").map(|v| v.as_str()),
Some("subcommand")
);
2020-03-05 12:02:48 +00:00
}
#[test]
fn subcommand_placeholder_test() {
2022-02-14 21:47:20 +00:00
let mut cmd = Command::new("myprog")
2022-02-12 03:48:29 +00:00
.subcommand(Command::new("subcommand"))
.subcommand_value_name("TEST_PLACEHOLDER")
.subcommand_help_heading("TEST_HEADER");
assert_eq!(&cmd.render_usage(), "Usage: myprog [TEST_PLACEHOLDER]");
let mut help_text = Vec::new();
2022-02-14 21:47:20 +00:00
cmd.write_help(&mut help_text)
2020-07-07 07:23:00 +00:00
.expect("Failed to write to internal buffer");
2020-07-07 07:23:00 +00:00
assert!(String::from_utf8(help_text)
.unwrap()
.contains("TEST_HEADER:"));
}
#[test]
#[cfg(feature = "error-context")]
fn subcommand_used_after_double_dash() {
static SUBCMD_AFTER_DOUBLE_DASH: &str = "\
error: Found argument 'subcmd' which wasn't expected, or isn't valid in this context
If you tried to supply `subcmd` as a subcommand, remove the '--' before it.
Usage: cmd [COMMAND]
For more information try '--help'
";
2022-02-14 21:47:20 +00:00
let cmd = Command::new("cmd").subcommand(Command::new("subcmd"));
2022-04-29 20:32:25 +00:00
utils::assert_output(cmd, "cmd -- subcmd", SUBCMD_AFTER_DOUBLE_DASH, true);
}
#[test]
fn subcommand_after_argument() {
2022-02-12 03:48:29 +00:00
let m = Command::new("myprog")
.arg(Arg::new("some_text"))
2022-02-12 03:48:29 +00:00
.subcommand(Command::new("test"))
.try_get_matches_from(vec!["myprog", "teat", "test"])
.unwrap();
assert_eq!(
m.get_one::<String>("some_text").map(|v| v.as_str()),
Some("teat")
);
assert_eq!(m.subcommand().unwrap().0, "test");
}
#[test]
fn subcommand_after_argument_looks_like_help() {
2022-02-12 03:48:29 +00:00
let m = Command::new("myprog")
.arg(Arg::new("some_text"))
2022-02-12 03:48:29 +00:00
.subcommand(Command::new("test"))
.try_get_matches_from(vec!["myprog", "helt", "test"])
.unwrap();
assert_eq!(
m.get_one::<String>("some_text").map(|v| v.as_str()),
Some("helt")
);
assert_eq!(m.subcommand().unwrap().0, "test");
}
#[test]
fn issue_2494_subcommand_is_present() {
2022-02-14 21:47:20 +00:00
let cmd = Command::new("opt")
.arg(Arg::new("global").long("global").action(ArgAction::SetTrue))
2022-02-12 03:48:29 +00:00
.subcommand(Command::new("global"));
2022-02-14 21:47:20 +00:00
let m = cmd
.clone()
.try_get_matches_from(&["opt", "--global", "global"])
.unwrap();
assert_eq!(m.subcommand_name().unwrap(), "global");
assert!(*m.get_one::<bool>("global").expect("defaulted by clap"));
2022-02-14 21:47:20 +00:00
let m = cmd
.clone()
.try_get_matches_from(&["opt", "--global"])
.unwrap();
assert!(m.subcommand_name().is_none());
assert!(*m.get_one::<bool>("global").expect("defaulted by clap"));
2022-02-14 21:47:20 +00:00
let m = cmd.try_get_matches_from(&["opt", "global"]).unwrap();
assert_eq!(m.subcommand_name().unwrap(), "global");
assert!(!*m.get_one::<bool>("global").expect("defaulted by clap"));
}
#[test]
#[cfg(feature = "error-context")]
fn subcommand_not_recognized() {
2022-02-14 21:47:20 +00:00
let cmd = Command::new("fake")
2022-02-12 03:48:29 +00:00
.subcommand(Command::new("sub"))
.disable_help_subcommand(true)
.infer_subcommands(true);
2022-04-29 20:32:25 +00:00
utils::assert_output(
2022-02-14 21:47:20 +00:00
cmd,
"fake help",
"error: The subcommand 'help' wasn't recognized
Usage: fake [COMMAND]
For more information try '--help'
",
2022-04-29 20:32:25 +00:00
true,
);
}
#[test]
fn busybox_like_multicall() {
fn applet_commands() -> [Command; 2] {
2022-02-12 03:48:29 +00:00
[Command::new("true"), Command::new("false")]
}
2022-02-14 21:47:20 +00:00
let cmd = Command::new("busybox")
.multicall(true)
2022-02-12 03:48:29 +00:00
.subcommand(Command::new("busybox").subcommands(applet_commands()))
.subcommands(applet_commands());
2022-02-14 21:47:20 +00:00
let m = cmd
.clone()
.try_get_matches_from(&["busybox", "true"])
.unwrap();
assert_eq!(m.subcommand_name(), Some("busybox"));
assert_eq!(m.subcommand().unwrap().1.subcommand_name(), Some("true"));
2022-02-14 21:47:20 +00:00
let m = cmd.clone().try_get_matches_from(&["true"]).unwrap();
assert_eq!(m.subcommand_name(), Some("true"));
2022-02-14 21:47:20 +00:00
let m = cmd.clone().try_get_matches_from(&["a.out"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind(), ErrorKind::InvalidSubcommand);
}
#[test]
fn hostname_like_multicall() {
2022-02-14 21:47:20 +00:00
let mut cmd = Command::new("hostname")
.multicall(true)
2022-02-12 03:48:29 +00:00
.subcommand(Command::new("hostname"))
.subcommand(Command::new("dnsdomainname"));
2022-02-14 21:47:20 +00:00
let m = cmd.clone().try_get_matches_from(&["hostname"]).unwrap();
assert_eq!(m.subcommand_name(), Some("hostname"));
2022-02-14 21:47:20 +00:00
let m = cmd
.clone()
.try_get_matches_from(&["dnsdomainname"])
.unwrap();
assert_eq!(m.subcommand_name(), Some("dnsdomainname"));
2022-02-14 21:47:20 +00:00
let m = cmd.clone().try_get_matches_from(&["a.out"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind(), ErrorKind::InvalidSubcommand);
2022-02-14 21:47:20 +00:00
let m = cmd.try_get_matches_from_mut(&["hostname", "hostname"]);
assert!(m.is_err());
2022-01-25 22:19:28 +00:00
assert_eq!(m.unwrap_err().kind(), ErrorKind::UnknownArgument);
2022-02-14 21:47:20 +00:00
let m = cmd.try_get_matches_from(&["hostname", "dnsdomainname"]);
assert!(m.is_err());
2022-01-25 22:19:28 +00:00
assert_eq!(m.unwrap_err().kind(), ErrorKind::UnknownArgument);
}
#[test]
#[cfg(feature = "error-context")]
fn bad_multicall_command_error() {
let cmd = Command::new("repl")
.version("1.0.0")
.propagate_version(true)
.multicall(true)
.subcommand(Command::new("foo"))
.subcommand(Command::new("bar"));
let err = cmd.clone().try_get_matches_from(&["world"]).unwrap_err();
assert_eq!(err.kind(), ErrorKind::InvalidSubcommand);
static HELLO_EXPECTED: &str = "\
error: The subcommand 'world' wasn't recognized
Usage: <COMMAND>
For more information try 'help'
";
utils::assert_eq(HELLO_EXPECTED, err.to_string());
#[cfg(feature = "suggestions")]
{
let err = cmd.clone().try_get_matches_from(&["baz"]).unwrap_err();
assert_eq!(err.kind(), ErrorKind::InvalidSubcommand);
static BAZ_EXPECTED: &str = "\
error: The subcommand 'baz' wasn't recognized
Did you mean 'bar'?
If you believe you received this message in error, try re-running with ' -- baz'
Usage: <COMMAND>
For more information try 'help'
";
utils::assert_eq(BAZ_EXPECTED, err.to_string());
}
// Verify whatever we did to get the above to work didn't disable `--help` and `--version`.
let err = cmd
.clone()
.try_get_matches_from(&["foo", "--help"])
.unwrap_err();
assert_eq!(err.kind(), ErrorKind::DisplayHelp);
let err = cmd
.clone()
.try_get_matches_from(&["foo", "--version"])
.unwrap_err();
assert_eq!(err.kind(), ErrorKind::DisplayVersion);
}
#[test]
#[should_panic = "Command repl: Arguments like oh-no cannot be set on a multicall command"]
fn cant_have_args_with_multicall() {
let mut cmd = Command::new("repl")
.version("1.0.0")
.propagate_version(true)
.multicall(true)
.subcommand(Command::new("foo"))
.subcommand(Command::new("bar"))
.arg(Arg::new("oh-no"));
cmd.build();
}
#[test]
fn multicall_help_flag() {
static EXPECTED: &str = "\
Usage: foo bar [value]
Arguments:
[value]
Options:
-h, --help Print help information
-V, --version Print version information
";
let cmd = Command::new("repl")
.version("1.0.0")
.propagate_version(true)
.multicall(true)
.subcommand(Command::new("foo").subcommand(Command::new("bar").arg(Arg::new("value"))));
utils::assert_output(cmd, "foo bar --help", EXPECTED, false);
}
#[test]
fn multicall_help_subcommand() {
static EXPECTED: &str = "\
Usage: foo bar [value]
Arguments:
[value]
Options:
-h, --help Print help information
-V, --version Print version information
";
let cmd = Command::new("repl")
.version("1.0.0")
.propagate_version(true)
.multicall(true)
.subcommand(Command::new("foo").subcommand(Command::new("bar").arg(Arg::new("value"))));
utils::assert_output(cmd, "help foo bar", EXPECTED, false);
}
#[test]
fn multicall_render_help() {
static EXPECTED: &str = "\
Usage: foo bar [value]
Arguments:
[value]
Options:
-h, --help Print help information
-V, --version Print version information
";
let mut cmd = Command::new("repl")
.version("1.0.0")
.propagate_version(true)
.multicall(true)
.subcommand(Command::new("foo").subcommand(Command::new("bar").arg(Arg::new("value"))));
cmd.build();
let subcmd = cmd.find_subcommand_mut("foo").unwrap();
let subcmd = subcmd.find_subcommand_mut("bar").unwrap();
let mut buf = Vec::new();
subcmd.write_help(&mut buf).unwrap();
utils::assert_eq(EXPECTED, String::from_utf8(buf).unwrap());
}
#[test]
#[should_panic = "Command test: command name `repeat` is duplicated"]
fn duplicate_subcommand() {
Command::new("test")
.subcommand(Command::new("repeat"))
.subcommand(Command::new("repeat"))
.build()
}
#[test]
#[should_panic = "Command test: command `unique` alias `repeat` is duplicated"]
fn duplicate_subcommand_alias() {
Command::new("test")
.subcommand(Command::new("repeat"))
.subcommand(Command::new("unique").alias("repeat"))
.build()
}