1 use super::utils;
2
3 use clap::{arg, Arg, ArgAction, Command};
4
5 #[test]
single_short_alias_of_option()6 fn single_short_alias_of_option() {
7 let a = Command::new("single_alias")
8 .arg(
9 Arg::new("alias")
10 .long("alias")
11 .action(ArgAction::Set)
12 .help("single short alias")
13 .short_alias('a'),
14 )
15 .try_get_matches_from(vec!["", "-a", "cool"]);
16 assert!(a.is_ok(), "{}", a.unwrap_err());
17 let a = a.unwrap();
18 assert!(a.contains_id("alias"));
19 assert_eq!(
20 a.get_one::<String>("alias").map(|v| v.as_str()).unwrap(),
21 "cool"
22 );
23 }
24
25 #[test]
multiple_short_aliases_of_option()26 fn multiple_short_aliases_of_option() {
27 let a = Command::new("multiple_aliases").arg(
28 Arg::new("aliases")
29 .long("aliases")
30 .action(ArgAction::Set)
31 .help("multiple aliases")
32 .short_aliases(['1', '2', '3']),
33 );
34 let long = a
35 .clone()
36 .try_get_matches_from(vec!["", "--aliases", "value"]);
37 assert!(long.is_ok(), "{}", long.unwrap_err());
38 let long = long.unwrap();
39
40 let als1 = a.clone().try_get_matches_from(vec!["", "-1", "value"]);
41 assert!(als1.is_ok(), "{}", als1.unwrap_err());
42 let als1 = als1.unwrap();
43
44 let als2 = a.clone().try_get_matches_from(vec!["", "-2", "value"]);
45 assert!(als2.is_ok(), "{}", als2.unwrap_err());
46 let als2 = als2.unwrap();
47
48 let als3 = a.clone().try_get_matches_from(vec!["", "-3", "value"]);
49 assert!(als3.is_ok(), "{}", als3.unwrap_err());
50 let als3 = als3.unwrap();
51
52 assert!(long.contains_id("aliases"));
53 assert!(als1.contains_id("aliases"));
54 assert!(als2.contains_id("aliases"));
55 assert!(als3.contains_id("aliases"));
56 assert_eq!(
57 long.get_one::<String>("aliases")
58 .map(|v| v.as_str())
59 .unwrap(),
60 "value"
61 );
62 assert_eq!(
63 als1.get_one::<String>("aliases")
64 .map(|v| v.as_str())
65 .unwrap(),
66 "value"
67 );
68 assert_eq!(
69 als2.get_one::<String>("aliases")
70 .map(|v| v.as_str())
71 .unwrap(),
72 "value"
73 );
74 assert_eq!(
75 als3.get_one::<String>("aliases")
76 .map(|v| v.as_str())
77 .unwrap(),
78 "value"
79 );
80 }
81
82 #[test]
single_short_alias_of_flag()83 fn single_short_alias_of_flag() {
84 let a = Command::new("test")
85 .arg(
86 Arg::new("flag")
87 .long("flag")
88 .short_alias('f')
89 .action(ArgAction::SetTrue),
90 )
91 .try_get_matches_from(vec!["", "-f"]);
92 assert!(a.is_ok(), "{}", a.unwrap_err());
93 let a = a.unwrap();
94 assert!(*a.get_one::<bool>("flag").expect("defaulted by clap"));
95 }
96
97 #[test]
multiple_short_aliases_of_flag()98 fn multiple_short_aliases_of_flag() {
99 let a = Command::new("test").arg(
100 Arg::new("flag")
101 .long("flag")
102 .short_aliases(['a', 'b', 'c', 'd', 'e'])
103 .action(ArgAction::SetTrue),
104 );
105
106 let flag = a.clone().try_get_matches_from(vec!["", "--flag"]);
107 assert!(flag.is_ok(), "{}", flag.unwrap_err());
108 let flag = flag.unwrap();
109
110 let als1 = a.clone().try_get_matches_from(vec!["", "-a"]);
111 assert!(als1.is_ok(), "{}", als1.unwrap_err());
112 let als1 = als1.unwrap();
113
114 let als2 = a.clone().try_get_matches_from(vec!["", "-b"]);
115 assert!(als2.is_ok(), "{}", als2.unwrap_err());
116 let als2 = als2.unwrap();
117
118 let als3 = a.clone().try_get_matches_from(vec!["", "-c"]);
119 assert!(als3.is_ok(), "{}", als3.unwrap_err());
120 let als3 = als3.unwrap();
121
122 assert!(*flag.get_one::<bool>("flag").expect("defaulted by clap"));
123 assert!(*als1.get_one::<bool>("flag").expect("defaulted by clap"));
124 assert!(*als2.get_one::<bool>("flag").expect("defaulted by clap"));
125 assert!(*als3.get_one::<bool>("flag").expect("defaulted by clap"));
126 }
127
128 #[test]
short_alias_on_a_subcommand_option()129 fn short_alias_on_a_subcommand_option() {
130 let m = Command::new("test")
131 .subcommand(
132 Command::new("some").arg(
133 Arg::new("test")
134 .short('t')
135 .long("test")
136 .action(ArgAction::Set)
137 .short_alias('o')
138 .help("testing testing"),
139 ),
140 )
141 .arg(
142 Arg::new("other")
143 .long("other")
144 .short_aliases(['1', '2', '3']),
145 )
146 .try_get_matches_from(vec!["test", "some", "-o", "awesome"])
147 .unwrap();
148
149 assert!(m.subcommand_matches("some").is_some());
150 let sub_m = m.subcommand_matches("some").unwrap();
151 assert!(sub_m.contains_id("test"));
152 assert_eq!(
153 sub_m.get_one::<String>("test").map(|v| v.as_str()).unwrap(),
154 "awesome"
155 );
156 }
157
158 #[test]
invisible_short_arg_aliases_help_output()159 fn invisible_short_arg_aliases_help_output() {
160 static SC_INVISIBLE_ALIAS_HELP: &str = "\
161 Some help
162
163 Usage: ct test [OPTIONS]
164
165 Options:
166 -o, --opt <opt>
167 -f, --flag
168 -h, --help Print help
169 -V, --version Print version
170 ";
171
172 let cmd = Command::new("ct").author("Salim Afiune").subcommand(
173 Command::new("test")
174 .about("Some help")
175 .version("1.2")
176 .arg(
177 Arg::new("opt")
178 .long("opt")
179 .short('o')
180 .action(ArgAction::Set)
181 .short_aliases(['a', 'b', 'c']),
182 )
183 .arg(arg!(-f - -flag).short_aliases(['x', 'y', 'z'])),
184 );
185 utils::assert_output(cmd, "ct test --help", SC_INVISIBLE_ALIAS_HELP, false);
186 }
187
188 #[test]
visible_short_arg_aliases_help_output()189 fn visible_short_arg_aliases_help_output() {
190 static SC_VISIBLE_ALIAS_HELP: &str = "\
191 Some help
192
193 Usage: ct test [OPTIONS]
194
195 Options:
196 -o, --opt <opt> [short aliases: v]
197 -f, --flag [aliases: flag1] [short aliases: a, b, ��]
198 -h, --help Print help
199 -V, --version Print version
200 ";
201
202 let cmd = Command::new("ct").author("Salim Afiune").subcommand(
203 Command::new("test")
204 .about("Some help")
205 .version("1.2")
206 .arg(
207 Arg::new("opt")
208 .long("opt")
209 .short('o')
210 .action(ArgAction::Set)
211 .short_alias('i')
212 .visible_short_alias('v'),
213 )
214 .arg(
215 Arg::new("flg")
216 .long("flag")
217 .short('f')
218 .action(ArgAction::SetTrue)
219 .visible_alias("flag1")
220 .visible_short_aliases(['a', 'b', '��']),
221 ),
222 );
223 utils::assert_output(cmd, "ct test --help", SC_VISIBLE_ALIAS_HELP, false);
224 }
225