2022-06-10 01:03:28 +00:00
|
|
|
use clap::{arg, error::ErrorKind, Arg, ArgAction, Command};
|
2016-01-13 16:06:00 +00:00
|
|
|
|
2022-09-19 14:59:04 +00:00
|
|
|
use super::utils;
|
2020-10-07 12:17:26 +00:00
|
|
|
|
2016-01-13 16:06:00 +00:00
|
|
|
#[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(
|
2020-05-14 20:50:56 +00:00
|
|
|
Arg::new("test")
|
2018-07-23 19:09:42 +00:00
|
|
|
.short('t')
|
2018-01-25 04:05:05 +00:00
|
|
|
.long("test")
|
2022-07-26 00:17:01 +00:00
|
|
|
.action(ArgAction::Set)
|
2021-11-18 16:17:15 +00:00
|
|
|
.help("testing testing"),
|
2018-01-25 04:05:05 +00:00
|
|
|
),
|
2018-11-14 17:05:06 +00:00
|
|
|
)
|
2020-05-14 20:50:56 +00:00
|
|
|
.arg(Arg::new("other").long("other"))
|
2021-12-27 18:56:12 +00:00
|
|
|
.try_get_matches_from(vec!["myprog", "some", "--test", "testing"])
|
|
|
|
.unwrap();
|
2016-01-13 16:06:00 +00:00
|
|
|
|
|
|
|
assert_eq!(m.subcommand_name().unwrap(), "some");
|
|
|
|
let sub_m = m.subcommand_matches("some").unwrap();
|
2022-06-10 01:03:28 +00:00
|
|
|
assert!(sub_m.contains_id("test"));
|
2022-05-24 15:16:50 +00:00
|
|
|
assert_eq!(
|
|
|
|
sub_m.get_one::<String>("test").map(|v| v.as_str()).unwrap(),
|
|
|
|
"testing"
|
|
|
|
);
|
2016-01-13 16:06:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[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(
|
2020-05-14 20:50:56 +00:00
|
|
|
Arg::new("test")
|
2018-07-23 19:09:42 +00:00
|
|
|
.short('t')
|
2018-01-25 04:05:05 +00:00
|
|
|
.long("test")
|
2022-07-26 00:17:01 +00:00
|
|
|
.action(ArgAction::Set)
|
2021-11-18 16:17:15 +00:00
|
|
|
.help("testing testing"),
|
2018-01-25 04:05:05 +00:00
|
|
|
),
|
2018-11-14 17:05:06 +00:00
|
|
|
)
|
2020-05-14 20:50:56 +00:00
|
|
|
.arg(Arg::new("other").long("other"))
|
2021-12-27 18:56:12 +00:00
|
|
|
.try_get_matches_from(vec![""])
|
|
|
|
.unwrap();
|
2016-01-13 16:06:00 +00:00
|
|
|
|
|
|
|
assert!(m.subcommand_name().is_none());
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn subcommand_multiple() {
|
2022-02-12 03:48:29 +00:00
|
|
|
let m = Command::new("test")
|
2016-01-13 16:06:00 +00:00
|
|
|
.subcommands(vec![
|
2022-02-12 03:48:29 +00:00
|
|
|
Command::new("some").arg(
|
2020-05-14 20:50:56 +00:00
|
|
|
Arg::new("test")
|
2018-07-23 19:09:42 +00:00
|
|
|
.short('t')
|
2016-01-13 16:06:00 +00:00
|
|
|
.long("test")
|
2022-07-26 00:17:01 +00:00
|
|
|
.action(ArgAction::Set)
|
2021-11-18 16:17:15 +00:00
|
|
|
.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')),
|
2016-01-13 16:06:00 +00:00
|
|
|
])
|
2020-05-14 20:50:56 +00:00
|
|
|
.arg(Arg::new("other").long("other"))
|
2021-12-27 18:56:12 +00:00
|
|
|
.try_get_matches_from(vec!["myprog", "some", "--test", "testing"])
|
|
|
|
.unwrap();
|
2016-01-13 16:06:00 +00:00
|
|
|
|
|
|
|
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();
|
2022-06-10 01:03:28 +00:00
|
|
|
assert!(sub_m.contains_id("test"));
|
2022-05-24 15:16:50 +00:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2016-05-10 19:26:43 +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"))
|
2021-12-27 18:56:12 +00:00
|
|
|
.try_get_matches_from(vec!["myprog", "do-stuff"])
|
|
|
|
.unwrap();
|
2016-05-10 19:26:43 +00:00
|
|
|
assert_eq!(m.subcommand_name(), Some("test"));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn multiple_aliases() {
|
2022-02-12 03:48:29 +00:00
|
|
|
let m = Command::new("myprog")
|
2022-08-15 18:21:05 +00:00
|
|
|
.subcommand(Command::new("test").aliases(["do-stuff", "test-stuff"]))
|
2021-12-27 18:56:12 +00:00
|
|
|
.try_get_matches_from(vec!["myprog", "test-stuff"])
|
|
|
|
.unwrap();
|
2016-05-10 19:26:43 +00:00
|
|
|
assert_eq!(m.subcommand_name(), Some("test"));
|
|
|
|
}
|
|
|
|
|
2016-05-09 03:20:50 +00:00
|
|
|
#[test]
|
2018-01-25 04:05:05 +00:00
|
|
|
#[cfg(feature = "suggestions")]
|
2022-09-19 14:59:04 +00:00
|
|
|
#[cfg(feature = "error-context")]
|
2016-05-09 03:20:50 +00:00
|
|
|
fn subcmd_did_you_mean_output() {
|
2022-09-19 14:59:04 +00:00
|
|
|
#[cfg(feature = "suggestions")]
|
|
|
|
static DYM_SUBCMD: &str = "\
|
2023-01-06 23:01:34 +00:00
|
|
|
error: unrecognized subcommand 'subcm'
|
2022-09-19 14:59:04 +00:00
|
|
|
|
2022-10-13 18:55:27 +00:00
|
|
|
note: subcommand 'subcmd' exists
|
|
|
|
note: to pass 'subcm' as a value, use 'dym -- subcm'
|
2022-09-19 14:59:04 +00:00
|
|
|
|
|
|
|
Usage: dym [COMMAND]
|
|
|
|
|
2023-01-03 19:22:35 +00:00
|
|
|
For more information, try '--help'.
|
2022-09-19 14:59:04 +00:00
|
|
|
";
|
|
|
|
|
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);
|
2018-01-09 15:24:24 +00:00
|
|
|
}
|
|
|
|
|
2020-03-01 09:07:37 +00:00
|
|
|
#[test]
|
|
|
|
#[cfg(feature = "suggestions")]
|
2022-09-19 14:59:04 +00:00
|
|
|
#[cfg(feature = "error-context")]
|
2020-03-01 09:07:37 +00:00
|
|
|
fn subcmd_did_you_mean_output_ambiguous() {
|
2022-09-19 14:59:04 +00:00
|
|
|
#[cfg(feature = "suggestions")]
|
|
|
|
static DYM_SUBCMD_AMBIGUOUS: &str = "\
|
2023-01-06 23:01:34 +00:00
|
|
|
error: unrecognized subcommand 'te'
|
2022-09-19 14:59:04 +00:00
|
|
|
|
2023-01-23 21:01:57 +00:00
|
|
|
note: subcommands 'test', 'temp' exist
|
2022-10-13 18:55:27 +00:00
|
|
|
note: to pass 'te' as a value, use 'dym -- te'
|
2022-09-19 14:59:04 +00:00
|
|
|
|
|
|
|
Usage: dym [COMMAND]
|
|
|
|
|
2023-01-03 19:22:35 +00:00
|
|
|
For more information, try '--help'.
|
2022-09-19 14:59:04 +00:00
|
|
|
";
|
|
|
|
|
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);
|
2020-03-01 09:07:37 +00:00
|
|
|
}
|
|
|
|
|
2018-01-09 15:24:24 +00:00
|
|
|
#[test]
|
2018-01-25 04:05:05 +00:00
|
|
|
#[cfg(feature = "suggestions")]
|
2022-09-19 14:59:04 +00:00
|
|
|
#[cfg(feature = "error-context")]
|
2018-01-09 15:24:24 +00:00
|
|
|
fn subcmd_did_you_mean_output_arg() {
|
2022-09-07 20:29:15 +00:00
|
|
|
static EXPECTED: &str = "\
|
2023-01-14 03:29:49 +00:00
|
|
|
error: unexpected argument '--subcmarg' found
|
2020-10-09 16:31:00 +00:00
|
|
|
|
2022-10-13 18:55:27 +00:00
|
|
|
note: 'subcmd --subcmdarg' exists
|
2020-10-09 16:31:00 +00:00
|
|
|
|
2022-09-07 16:03:55 +00:00
|
|
|
Usage: dym [COMMAND]
|
2020-10-09 16:31:00 +00:00
|
|
|
|
2023-01-03 19:22:35 +00:00
|
|
|
For more information, try '--help'.
|
2021-09-24 15:58:39 +00:00
|
|
|
";
|
2020-10-09 16:31:00 +00:00
|
|
|
|
2022-09-12 21:59:57 +00:00
|
|
|
let cmd = Command::new("dym")
|
|
|
|
.subcommand(Command::new("subcmd").arg(arg!(-s --subcmdarg <subcmdarg> "tests")));
|
2020-10-09 16:31:00 +00:00
|
|
|
|
2022-04-29 20:32:25 +00:00
|
|
|
utils::assert_output(cmd, "dym --subcmarg subcmd", EXPECTED, true);
|
2020-10-09 16:31:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
#[cfg(feature = "suggestions")]
|
2022-09-19 14:59:04 +00:00
|
|
|
#[cfg(feature = "error-context")]
|
2020-10-09 16:31:00 +00:00
|
|
|
fn subcmd_did_you_mean_output_arg_false_positives() {
|
2022-09-07 20:29:15 +00:00
|
|
|
static EXPECTED: &str = "\
|
2023-01-14 03:29:49 +00:00
|
|
|
error: unexpected argument '--subcmarg' found
|
2020-10-09 16:31:00 +00:00
|
|
|
|
2022-09-07 16:03:55 +00:00
|
|
|
Usage: dym [COMMAND]
|
2020-10-09 16:31:00 +00:00
|
|
|
|
2023-01-03 19:22:35 +00:00
|
|
|
For more information, try '--help'.
|
2021-09-24 15:58:39 +00:00
|
|
|
";
|
2020-10-09 16:31:00 +00:00
|
|
|
|
2022-09-12 21:59:57 +00:00
|
|
|
let cmd = Command::new("dym")
|
|
|
|
.subcommand(Command::new("subcmd").arg(arg!(-s --subcmdarg <subcmdarg> "tests")));
|
2020-10-09 16:31:00 +00:00
|
|
|
|
2022-04-29 20:32:25 +00:00
|
|
|
utils::assert_output(cmd, "dym --subcmarg foo", EXPECTED, true);
|
2016-05-09 03:20:50 +00:00
|
|
|
}
|
2016-06-10 00:39:51 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn alias_help() {
|
2022-02-12 03:48:29 +00:00
|
|
|
let m = Command::new("myprog")
|
|
|
|
.subcommand(Command::new("test").alias("do-stuff"))
|
2018-10-19 20:42:13 +00:00
|
|
|
.try_get_matches_from(vec!["myprog", "help", "do-stuff"]);
|
2016-06-10 00:39:51 +00:00
|
|
|
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() {
|
2022-09-19 14:59:04 +00:00
|
|
|
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:
|
2023-01-03 16:49:43 +00:00
|
|
|
-h, --help Print help
|
|
|
|
-V, --version Print version
|
2022-09-19 14:59:04 +00:00
|
|
|
";
|
|
|
|
|
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")
|
2016-06-13 01:52:18 +00:00
|
|
|
.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
|
|
|
}
|
2016-06-13 01:52:18 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn invisible_aliases_help_output() {
|
2022-09-19 14:59:04 +00:00
|
|
|
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:
|
2023-01-03 16:49:43 +00:00
|
|
|
-h, --help Print help
|
|
|
|
-V, --version Print version
|
2022-09-19 14:59:04 +00:00
|
|
|
";
|
|
|
|
|
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);
|
2016-06-24 04:17:04 +00:00
|
|
|
}
|
2017-10-24 21:00:43 +00:00
|
|
|
|
2020-02-14 16:22:01 +00:00
|
|
|
#[test]
|
2021-10-09 15:44:31 +00:00
|
|
|
#[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")),
|
|
|
|
)
|
2022-11-24 13:54:25 +00:00
|
|
|
.replace("install", ["module", "install"])
|
2021-12-27 18:56:12 +00:00
|
|
|
.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")
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2017-10-24 21:00:43 +00:00
|
|
|
#[test]
|
|
|
|
fn issue_1031_args_with_same_name() {
|
2022-02-12 03:48:29 +00:00
|
|
|
let res = Command::new("prog")
|
2022-09-12 21:59:57 +00:00
|
|
|
.arg(arg!(--"ui-path" <PATH>).required(true))
|
2022-02-12 03:48:29 +00:00
|
|
|
.subcommand(Command::new("signer"))
|
2018-10-19 20:42:13 +00:00
|
|
|
.try_get_matches_from(vec!["prog", "--ui-path", "signer"]);
|
2017-10-24 21:00:43 +00:00
|
|
|
|
2022-01-25 22:19:28 +00:00
|
|
|
assert!(res.is_ok(), "{:?}", res.unwrap_err().kind());
|
2017-10-24 21:00:43 +00:00
|
|
|
let m = res.unwrap();
|
2022-05-24 15:16:50 +00:00
|
|
|
assert_eq!(
|
|
|
|
m.get_one::<String>("ui-path").map(|v| v.as_str()),
|
|
|
|
Some("signer")
|
|
|
|
);
|
2017-10-24 21:00:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn issue_1031_args_with_same_name_no_more_vals() {
|
2022-02-12 03:48:29 +00:00
|
|
|
let res = Command::new("prog")
|
2022-09-12 21:59:57 +00:00
|
|
|
.arg(arg!(--"ui-path" <PATH>).required(true))
|
2022-02-12 03:48:29 +00:00
|
|
|
.subcommand(Command::new("signer"))
|
2018-10-19 20:42:13 +00:00
|
|
|
.try_get_matches_from(vec!["prog", "--ui-path", "value", "signer"]);
|
2017-10-24 21:00:43 +00:00
|
|
|
|
2022-01-25 22:19:28 +00:00
|
|
|
assert!(res.is_ok(), "{:?}", res.unwrap_err().kind());
|
2017-10-24 21:00:43 +00:00
|
|
|
let m = res.unwrap();
|
2022-05-24 15:16:50 +00:00
|
|
|
assert_eq!(
|
|
|
|
m.get_one::<String>("ui-path").map(|v| v.as_str()),
|
|
|
|
Some("value")
|
|
|
|
);
|
2017-10-24 21:00:43 +00:00
|
|
|
assert_eq!(m.subcommand_name(), Some("signer"));
|
2018-01-25 04:05:05 +00:00
|
|
|
}
|
2018-03-01 11:52:30 +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")
|
2020-05-14 20:50:56 +00:00
|
|
|
.arg(Arg::new("eff").short('f'))
|
2022-07-26 00:17:01 +00:00
|
|
|
.arg(Arg::new("pea").short('p').action(ArgAction::Set))
|
2021-06-16 05:28:25 +00:00
|
|
|
.arg(
|
|
|
|
Arg::new("slop")
|
2022-07-26 00:17:01 +00:00
|
|
|
.action(ArgAction::Set)
|
2022-08-03 16:20:07 +00:00
|
|
|
.num_args(1..)
|
2021-06-16 05:28:25 +00:00
|
|
|
.last(true),
|
|
|
|
)
|
2018-10-19 20:42:13 +00:00
|
|
|
.try_get_matches_from(vec![
|
2018-08-02 03:13:51 +00:00
|
|
|
"-f",
|
|
|
|
"-p=bob",
|
|
|
|
"--",
|
|
|
|
"sloppy",
|
|
|
|
"slop",
|
|
|
|
"-a",
|
|
|
|
"--",
|
|
|
|
"subprogram",
|
|
|
|
"position",
|
|
|
|
"args",
|
|
|
|
]);
|
2018-03-01 11:52:30 +00:00
|
|
|
|
2022-01-25 22:19:28 +00:00
|
|
|
assert!(res.is_ok(), "{:?}", res.unwrap_err().kind());
|
2018-03-01 11:52:30 +00:00
|
|
|
let m = res.unwrap();
|
|
|
|
|
2018-08-02 03:13:51 +00:00
|
|
|
let expected = Some(vec![
|
|
|
|
"sloppy",
|
|
|
|
"slop",
|
|
|
|
"-a",
|
|
|
|
"--",
|
|
|
|
"subprogram",
|
|
|
|
"position",
|
|
|
|
"args",
|
|
|
|
]);
|
2022-05-24 15:16:50 +00:00
|
|
|
let actual = m
|
|
|
|
.get_many::<String>("slop")
|
|
|
|
.map(|vals| vals.map(|s| s.as_str()).collect::<Vec<_>>());
|
2018-03-01 11:52:30 +00:00
|
|
|
|
|
|
|
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"))
|
2020-05-14 20:50:56 +00:00
|
|
|
.arg(Arg::new("argument"))
|
2020-03-05 12:02:48 +00:00
|
|
|
.try_get_matches_from(vec!["myprog", "--", "subcommand"]);
|
2022-05-24 15:16:50 +00:00
|
|
|
assert_eq!(
|
|
|
|
m.unwrap().get_one::<String>("argument").map(|v| v.as_str()),
|
|
|
|
Some("subcommand")
|
|
|
|
);
|
2020-03-05 12:02:48 +00:00
|
|
|
}
|
2020-06-26 01:21:28 +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"))
|
2021-11-29 21:59:56 +00:00
|
|
|
.subcommand_value_name("TEST_PLACEHOLDER")
|
|
|
|
.subcommand_help_heading("TEST_HEADER");
|
2020-06-26 01:21:28 +00:00
|
|
|
|
2022-09-22 14:17:56 +00:00
|
|
|
assert_eq!(
|
|
|
|
&cmd.render_usage().to_string(),
|
|
|
|
"Usage: myprog [TEST_PLACEHOLDER]"
|
|
|
|
);
|
2020-06-28 03:19:57 +00:00
|
|
|
|
2022-09-22 14:39:24 +00:00
|
|
|
let help_text = cmd.render_help().to_string();
|
2020-06-28 03:19:57 +00:00
|
|
|
|
2022-09-22 14:39:24 +00:00
|
|
|
assert!(help_text.contains("TEST_HEADER:"));
|
2020-06-26 01:21:28 +00:00
|
|
|
}
|
2020-10-07 12:17:26 +00:00
|
|
|
|
|
|
|
#[test]
|
2022-09-19 14:59:04 +00:00
|
|
|
#[cfg(feature = "error-context")]
|
2020-10-07 12:17:26 +00:00
|
|
|
fn subcommand_used_after_double_dash() {
|
2022-09-19 14:59:04 +00:00
|
|
|
static SUBCMD_AFTER_DOUBLE_DASH: &str = "\
|
2023-01-14 03:29:49 +00:00
|
|
|
error: unexpected argument 'subcmd' found
|
2022-09-19 14:59:04 +00:00
|
|
|
|
2022-10-13 18:55:27 +00:00
|
|
|
note: subcommand 'subcmd' exists; to use it, remove the '--' before it
|
2022-09-19 14:59:04 +00:00
|
|
|
|
|
|
|
Usage: cmd [COMMAND]
|
|
|
|
|
2023-01-03 19:22:35 +00:00
|
|
|
For more information, try '--help'.
|
2022-09-19 14:59:04 +00:00
|
|
|
";
|
|
|
|
|
2022-02-14 21:47:20 +00:00
|
|
|
let cmd = Command::new("cmd").subcommand(Command::new("subcmd"));
|
2020-10-07 12:17:26 +00:00
|
|
|
|
2022-04-29 20:32:25 +00:00
|
|
|
utils::assert_output(cmd, "cmd -- subcmd", SUBCMD_AFTER_DOUBLE_DASH, true);
|
2020-10-07 12:17:26 +00:00
|
|
|
}
|
2020-11-07 12:32:28 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn subcommand_after_argument() {
|
2022-02-12 03:48:29 +00:00
|
|
|
let m = Command::new("myprog")
|
2020-11-07 12:32:28 +00:00
|
|
|
.arg(Arg::new("some_text"))
|
2022-02-12 03:48:29 +00:00
|
|
|
.subcommand(Command::new("test"))
|
2021-12-27 18:56:12 +00:00
|
|
|
.try_get_matches_from(vec!["myprog", "teat", "test"])
|
|
|
|
.unwrap();
|
2022-05-24 15:16:50 +00:00
|
|
|
assert_eq!(
|
|
|
|
m.get_one::<String>("some_text").map(|v| v.as_str()),
|
|
|
|
Some("teat")
|
|
|
|
);
|
2020-11-07 12:32:28 +00:00
|
|
|
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")
|
2020-11-07 12:32:28 +00:00
|
|
|
.arg(Arg::new("some_text"))
|
2022-02-12 03:48:29 +00:00
|
|
|
.subcommand(Command::new("test"))
|
2021-12-27 18:56:12 +00:00
|
|
|
.try_get_matches_from(vec!["myprog", "helt", "test"])
|
|
|
|
.unwrap();
|
2022-05-24 15:16:50 +00:00
|
|
|
assert_eq!(
|
|
|
|
m.get_one::<String>("some_text").map(|v| v.as_str()),
|
|
|
|
Some("helt")
|
|
|
|
);
|
2020-11-07 12:32:28 +00:00
|
|
|
assert_eq!(m.subcommand().unwrap().0, "test");
|
|
|
|
}
|
2021-05-25 23:40:38 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn issue_2494_subcommand_is_present() {
|
2022-02-14 21:47:20 +00:00
|
|
|
let cmd = Command::new("opt")
|
2022-06-10 01:03:28 +00:00
|
|
|
.arg(Arg::new("global").long("global").action(ArgAction::SetTrue))
|
2022-02-12 03:48:29 +00:00
|
|
|
.subcommand(Command::new("global"));
|
2021-05-25 23:40:38 +00:00
|
|
|
|
2022-02-14 21:47:20 +00:00
|
|
|
let m = cmd
|
2021-12-27 18:56:12 +00:00
|
|
|
.clone()
|
2022-11-24 13:54:25 +00:00
|
|
|
.try_get_matches_from(["opt", "--global", "global"])
|
2021-12-27 18:56:12 +00:00
|
|
|
.unwrap();
|
2021-05-25 23:40:38 +00:00
|
|
|
assert_eq!(m.subcommand_name().unwrap(), "global");
|
2022-06-10 01:03:28 +00:00
|
|
|
assert!(*m.get_one::<bool>("global").expect("defaulted by clap"));
|
2021-05-25 23:40:38 +00:00
|
|
|
|
2022-02-14 21:47:20 +00:00
|
|
|
let m = cmd
|
2021-12-27 18:56:12 +00:00
|
|
|
.clone()
|
2022-11-24 13:54:25 +00:00
|
|
|
.try_get_matches_from(["opt", "--global"])
|
2021-12-27 18:56:12 +00:00
|
|
|
.unwrap();
|
2021-05-25 23:40:38 +00:00
|
|
|
assert!(m.subcommand_name().is_none());
|
2022-06-10 01:03:28 +00:00
|
|
|
assert!(*m.get_one::<bool>("global").expect("defaulted by clap"));
|
2021-05-25 23:40:38 +00:00
|
|
|
|
2022-11-24 13:54:25 +00:00
|
|
|
let m = cmd.try_get_matches_from(["opt", "global"]).unwrap();
|
2021-05-25 23:40:38 +00:00
|
|
|
assert_eq!(m.subcommand_name().unwrap(), "global");
|
2022-06-10 01:03:28 +00:00
|
|
|
assert!(!*m.get_one::<bool>("global").expect("defaulted by clap"));
|
2021-05-25 23:40:38 +00:00
|
|
|
}
|
2021-09-04 20:10:24 +00:00
|
|
|
|
|
|
|
#[test]
|
2022-09-19 14:59:04 +00:00
|
|
|
#[cfg(feature = "error-context")]
|
2021-09-04 20:10:24 +00:00
|
|
|
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"))
|
2022-02-10 17:51:40 +00:00
|
|
|
.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,
|
2021-09-04 20:10:24 +00:00
|
|
|
"fake help",
|
2023-01-06 23:01:34 +00:00
|
|
|
"error: unrecognized subcommand 'help'
|
2021-09-04 20:10:24 +00:00
|
|
|
|
2022-09-07 16:03:55 +00:00
|
|
|
Usage: fake [COMMAND]
|
2021-09-04 20:10:24 +00:00
|
|
|
|
2023-01-03 19:22:35 +00:00
|
|
|
For more information, try '--help'.
|
2021-09-04 20:10:24 +00:00
|
|
|
",
|
2022-04-29 20:32:25 +00:00
|
|
|
true,
|
|
|
|
);
|
2021-09-04 20:10:24 +00:00
|
|
|
}
|
2021-09-14 20:38:41 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn busybox_like_multicall() {
|
2022-08-15 19:29:46 +00:00
|
|
|
fn applet_commands() -> [Command; 2] {
|
2022-02-12 03:48:29 +00:00
|
|
|
[Command::new("true"), Command::new("false")]
|
2021-11-17 20:20:52 +00:00
|
|
|
}
|
2022-02-14 21:47:20 +00:00
|
|
|
let cmd = Command::new("busybox")
|
2022-02-10 17:51:40 +00:00
|
|
|
.multicall(true)
|
2022-02-12 03:48:29 +00:00
|
|
|
.subcommand(Command::new("busybox").subcommands(applet_commands()))
|
2021-11-17 20:20:52 +00:00
|
|
|
.subcommands(applet_commands());
|
2021-09-14 20:38:41 +00:00
|
|
|
|
2022-02-14 21:47:20 +00:00
|
|
|
let m = cmd
|
2021-12-27 18:56:12 +00:00
|
|
|
.clone()
|
2022-11-24 13:54:25 +00:00
|
|
|
.try_get_matches_from(["busybox", "true"])
|
2021-12-27 18:56:12 +00:00
|
|
|
.unwrap();
|
2021-11-17 20:20:52 +00:00
|
|
|
assert_eq!(m.subcommand_name(), Some("busybox"));
|
|
|
|
assert_eq!(m.subcommand().unwrap().1.subcommand_name(), Some("true"));
|
2021-09-14 20:38:41 +00:00
|
|
|
|
2022-11-24 13:54:25 +00:00
|
|
|
let m = cmd.clone().try_get_matches_from(["true"]).unwrap();
|
2021-09-14 20:38:41 +00:00
|
|
|
assert_eq!(m.subcommand_name(), Some("true"));
|
|
|
|
|
2022-11-24 13:54:25 +00:00
|
|
|
let m = cmd.clone().try_get_matches_from(["a.out"]);
|
2021-09-14 20:38:41 +00:00
|
|
|
assert!(m.is_err());
|
2022-07-22 17:12:35 +00:00
|
|
|
assert_eq!(m.unwrap_err().kind(), ErrorKind::InvalidSubcommand);
|
2021-09-14 20:38:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn hostname_like_multicall() {
|
2022-02-14 21:47:20 +00:00
|
|
|
let mut cmd = Command::new("hostname")
|
2022-02-10 17:51:40 +00:00
|
|
|
.multicall(true)
|
2022-02-12 03:48:29 +00:00
|
|
|
.subcommand(Command::new("hostname"))
|
|
|
|
.subcommand(Command::new("dnsdomainname"));
|
2021-09-14 20:38:41 +00:00
|
|
|
|
2022-11-24 13:54:25 +00:00
|
|
|
let m = cmd.clone().try_get_matches_from(["hostname"]).unwrap();
|
2021-09-14 20:38:41 +00:00
|
|
|
assert_eq!(m.subcommand_name(), Some("hostname"));
|
|
|
|
|
2022-11-24 13:54:25 +00:00
|
|
|
let m = cmd.clone().try_get_matches_from(["dnsdomainname"]).unwrap();
|
2021-09-14 20:38:41 +00:00
|
|
|
assert_eq!(m.subcommand_name(), Some("dnsdomainname"));
|
|
|
|
|
2022-11-24 13:54:25 +00:00
|
|
|
let m = cmd.clone().try_get_matches_from(["a.out"]);
|
2021-09-14 20:38:41 +00:00
|
|
|
assert!(m.is_err());
|
2022-07-22 17:12:35 +00:00
|
|
|
assert_eq!(m.unwrap_err().kind(), ErrorKind::InvalidSubcommand);
|
2021-09-14 20:38:41 +00:00
|
|
|
|
2022-11-24 13:54:25 +00:00
|
|
|
let m = cmd.try_get_matches_from_mut(["hostname", "hostname"]);
|
2021-09-14 20:38:41 +00:00
|
|
|
assert!(m.is_err());
|
2022-01-25 22:19:28 +00:00
|
|
|
assert_eq!(m.unwrap_err().kind(), ErrorKind::UnknownArgument);
|
2021-09-14 20:38:41 +00:00
|
|
|
|
2022-11-24 13:54:25 +00:00
|
|
|
let m = cmd.try_get_matches_from(["hostname", "dnsdomainname"]);
|
2021-09-14 20:38:41 +00:00
|
|
|
assert!(m.is_err());
|
2022-01-25 22:19:28 +00:00
|
|
|
assert_eq!(m.unwrap_err().kind(), ErrorKind::UnknownArgument);
|
2021-09-14 20:38:41 +00:00
|
|
|
}
|
2022-05-02 12:00:35 +00:00
|
|
|
|
|
|
|
#[test]
|
2022-09-19 14:59:04 +00:00
|
|
|
#[cfg(feature = "error-context")]
|
2022-05-02 12:00:35 +00:00
|
|
|
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"));
|
|
|
|
|
2022-11-24 13:54:25 +00:00
|
|
|
let err = cmd.clone().try_get_matches_from(["world"]).unwrap_err();
|
2022-07-22 17:12:35 +00:00
|
|
|
assert_eq!(err.kind(), ErrorKind::InvalidSubcommand);
|
2022-05-02 12:00:35 +00:00
|
|
|
static HELLO_EXPECTED: &str = "\
|
2023-01-06 23:01:34 +00:00
|
|
|
error: unrecognized subcommand 'world'
|
2022-05-02 12:00:35 +00:00
|
|
|
|
2022-09-07 16:03:55 +00:00
|
|
|
Usage: <COMMAND>
|
2022-05-02 12:00:35 +00:00
|
|
|
|
2023-01-03 19:22:35 +00:00
|
|
|
For more information, try 'help'.
|
2022-05-02 12:00:35 +00:00
|
|
|
";
|
|
|
|
utils::assert_eq(HELLO_EXPECTED, err.to_string());
|
|
|
|
|
2022-05-04 13:11:51 +00:00
|
|
|
#[cfg(feature = "suggestions")]
|
|
|
|
{
|
2022-11-24 13:54:25 +00:00
|
|
|
let err = cmd.clone().try_get_matches_from(["baz"]).unwrap_err();
|
2022-05-04 13:11:51 +00:00
|
|
|
assert_eq!(err.kind(), ErrorKind::InvalidSubcommand);
|
|
|
|
static BAZ_EXPECTED: &str = "\
|
2023-01-06 23:01:34 +00:00
|
|
|
error: unrecognized subcommand 'baz'
|
2022-05-02 12:00:35 +00:00
|
|
|
|
2022-10-13 18:55:27 +00:00
|
|
|
note: subcommand 'bar' exists
|
|
|
|
note: to pass 'baz' as a value, use ' -- baz'
|
2022-05-02 12:00:35 +00:00
|
|
|
|
2022-09-07 16:03:55 +00:00
|
|
|
Usage: <COMMAND>
|
2022-05-02 12:00:35 +00:00
|
|
|
|
2023-01-03 19:22:35 +00:00
|
|
|
For more information, try 'help'.
|
2022-05-02 12:00:35 +00:00
|
|
|
";
|
2022-05-04 13:11:51 +00:00
|
|
|
utils::assert_eq(BAZ_EXPECTED, err.to_string());
|
|
|
|
}
|
2022-05-02 12:00:35 +00:00
|
|
|
|
|
|
|
// Verify whatever we did to get the above to work didn't disable `--help` and `--version`.
|
|
|
|
|
|
|
|
let err = cmd
|
|
|
|
.clone()
|
2022-11-24 13:54:25 +00:00
|
|
|
.try_get_matches_from(["foo", "--help"])
|
2022-05-02 12:00:35 +00:00
|
|
|
.unwrap_err();
|
|
|
|
assert_eq!(err.kind(), ErrorKind::DisplayHelp);
|
|
|
|
|
|
|
|
let err = cmd
|
|
|
|
.clone()
|
2022-11-24 13:54:25 +00:00
|
|
|
.try_get_matches_from(["foo", "--version"])
|
2022-05-02 12:00:35 +00:00
|
|
|
.unwrap_err();
|
|
|
|
assert_eq!(err.kind(), ErrorKind::DisplayVersion);
|
|
|
|
}
|
2022-05-02 14:33:06 +00:00
|
|
|
|
|
|
|
#[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();
|
|
|
|
}
|
2022-05-02 16:50:30 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn multicall_help_flag() {
|
|
|
|
static EXPECTED: &str = "\
|
2022-09-07 16:03:55 +00:00
|
|
|
Usage: foo bar [value]
|
2022-05-02 16:50:30 +00:00
|
|
|
|
2022-08-26 14:40:23 +00:00
|
|
|
Arguments:
|
2022-09-07 20:29:15 +00:00
|
|
|
[value]
|
2022-05-02 16:50:30 +00:00
|
|
|
|
2022-08-26 14:40:23 +00:00
|
|
|
Options:
|
2023-01-03 16:49:43 +00:00
|
|
|
-h, --help Print help
|
|
|
|
-V, --version Print version
|
2022-05-02 16:50:30 +00:00
|
|
|
";
|
|
|
|
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 = "\
|
2022-09-07 16:03:55 +00:00
|
|
|
Usage: foo bar [value]
|
2022-05-02 16:50:30 +00:00
|
|
|
|
2022-08-26 14:40:23 +00:00
|
|
|
Arguments:
|
2022-09-07 20:29:15 +00:00
|
|
|
[value]
|
2022-05-02 16:50:30 +00:00
|
|
|
|
2022-08-26 14:40:23 +00:00
|
|
|
Options:
|
2023-01-03 16:49:43 +00:00
|
|
|
-h, --help Print help
|
|
|
|
-V, --version Print version
|
2022-05-02 16:50:30 +00:00
|
|
|
";
|
|
|
|
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 = "\
|
2022-09-07 16:03:55 +00:00
|
|
|
Usage: foo bar [value]
|
2022-05-02 16:50:30 +00:00
|
|
|
|
2022-08-26 14:40:23 +00:00
|
|
|
Arguments:
|
2022-09-07 20:29:15 +00:00
|
|
|
[value]
|
2022-05-02 16:50:30 +00:00
|
|
|
|
2022-08-26 14:40:23 +00:00
|
|
|
Options:
|
2023-01-03 16:49:43 +00:00
|
|
|
-h, --help Print help
|
|
|
|
-V, --version Print version
|
2022-05-02 16:50:30 +00:00
|
|
|
";
|
|
|
|
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();
|
|
|
|
|
2022-09-22 14:39:24 +00:00
|
|
|
let help = subcmd.render_help().to_string();
|
|
|
|
utils::assert_eq(EXPECTED, help);
|
2022-05-02 16:50:30 +00:00
|
|
|
}
|
2022-07-25 18:45:33 +00:00
|
|
|
|
|
|
|
#[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()
|
|
|
|
}
|