v

1
import cli
2

3
fn test_if_command_parses_empty_args() {
4
	mut cmd := cli.Command{
5
		name:    'command'
6
		execute: empty_func
7
	}
8
	cmd.parse(['command'])
9
	assert cmd.name == 'command' && cmd.args == []
10
}
11

12
fn test_if_command_parses_args() {
13
	mut cmd := cli.Command{
14
		name:    'command'
15
		execute: empty_func
16
	}
17
	cmd.parse(['command', 'arg0', 'arg1'])
18
	assert cmd.name == 'command' && cmd.args == ['arg0', 'arg1']
19
}
20

21
fn test_if_subcommands_parse_args() {
22
	mut cmd := cli.Command{
23
		name: 'command'
24
	}
25
	subcmd := cli.Command{
26
		name:    'subcommand'
27
		execute: if_subcommands_parse_args_func
28
	}
29
	cmd.add_command(subcmd)
30
	cmd.parse(['command', 'subcommand', 'arg0', 'arg1'])
31
}
32

33
fn if_subcommands_parse_args_func(cmd cli.Command) ! {
34
	assert cmd.name == 'subcommand' && cmd.args == ['arg0', 'arg1']
35
}
36

37
fn test_default_subcommands() {
38
	mut cmd := cli.Command{
39
		name: 'command'
40
	}
41
	cmd.parse(['command'])
42
	assert cmd.commands.any(it.name == 'help')
43
	assert cmd.commands.any(it.name == 'man')
44

45
	cmd = cli.Command{
46
		name:    'command'
47
		version: '1.0.0'
48
	}
49
	cmd.parse(['command'])
50
	assert cmd.commands.any(it.name == 'version')
51
}
52

53
fn flag_should_be_set(cmd cli.Command) ! {
54
	flag := cmd.flags.get_string('flag')!
55
	assert flag == 'value'
56
}
57

58
fn test_if_flag_gets_set() {
59
	mut cmd := cli.Command{
60
		name:    'command'
61
		execute: flag_should_be_set
62
	}
63
	cmd.add_flag(cli.Flag{
64
		flag: .string
65
		name: 'flag'
66
	})
67
	cmd.parse(['command', '-flag', 'value'])
68
}
69

70
fn test_if_flag_gets_set_with_abbrev() {
71
	mut cmd := cli.Command{
72
		name:    'command'
73
		execute: flag_should_be_set
74
	}
75
	cmd.add_flag(cli.Flag{
76
		flag:   .string
77
		name:   'flag'
78
		abbrev: 'f'
79
	})
80
	cmd.parse(['command', '-f', 'value'])
81
}
82

83
fn test_if_flag_gets_set_with_long_arg() {
84
	mut cmd := cli.Command{
85
		name:       'command'
86
		execute:    flag_should_be_set
87
		posix_mode: true
88
	}
89
	cmd.add_flag(cli.Flag{
90
		flag:   .string
91
		name:   'flag'
92
		abbrev: 'f'
93
	})
94
	cmd.parse(['command', '--flag', 'value'])
95
}
96

97
fn assert_flags(cmd cli.Command) ! {
98
	flag := cmd.flags.get_string('flag')!
99
	assert flag == 'value'
100
	value := cmd.flags.get_int('value')!
101
	assert value == 42
102
	flag2 := cmd.flags.get_string('flag-2')!
103
	assert flag2 == 'value-2'
104
}
105

106
fn test_if_multiple_flags_get_set() {
107
	mut cmd := cli.Command{
108
		name:    'command'
109
		execute: assert_flags
110
	}
111
	cmd.add_flag(cli.Flag{
112
		flag: .string
113
		name: 'flag'
114
	})
115
	cmd.add_flag(cli.Flag{
116
		flag: .string
117
		name: 'flag-2'
118
	})
119
	cmd.add_flag(cli.Flag{
120
		flag: .int
121
		name: 'value'
122
	})
123
	cmd.parse(['command', '-flag=value', '-value', '42', '-flag-2', 'value-2'])
124
}
125

126
fn test_if_required_flags_get_set() {
127
	mut cmd := cli.Command{
128
		name:    'command'
129
		execute: assert_flags
130
	}
131
	cmd.add_flag(cli.Flag{
132
		flag: .string
133
		name: 'flag'
134
	})
135
	cmd.add_flag(cli.Flag{
136
		flag: .string
137
		name: 'flag-2'
138
	})
139
	cmd.add_flag(cli.Flag{
140
		flag:     .int
141
		name:     'value'
142
		required: true
143
	})
144
	cmd.parse(['command', '-flag', 'value', '-value', '42', '-flag-2', 'value-2'])
145
}
146

147
fn flag_is_set_in_subcommand(cmd cli.Command) ! {
148
	flag := cmd.flags.get_string('flag') or { panic(err) }
149
	assert flag == 'value'
150
}
151

152
fn test_if_flag_gets_set_in_subcommand() {
153
	mut cmd := cli.Command{
154
		name:    'command'
155
		execute: empty_func
156
	}
157
	mut subcmd := cli.Command{
158
		name:    'subcommand'
159
		execute: flag_is_set_in_subcommand
160
	}
161
	subcmd.add_flag(cli.Flag{
162
		flag: .string
163
		name: 'flag'
164
	})
165
	cmd.add_command(subcmd)
166
	cmd.parse(['command', 'subcommand', '-flag', 'value'])
167
}
168

169
fn test_if_global_flag_gets_set_in_subcommand() {
170
	mut cmd := cli.Command{
171
		name:    'command'
172
		execute: empty_func
173
	}
174
	cmd.add_flag(cli.Flag{
175
		flag:   .string
176
		name:   'flag'
177
		global: true
178
	})
179
	subcmd := cli.Command{
180
		name:    'subcommand'
181
		execute: flag_is_set_in_subcommand
182
	}
183
	cmd.add_command(subcmd)
184
	cmd.parse(['command', '-flag', 'value', 'subcommand'])
185
}
186

187
fn test_command_setup() {
188
	mut cmd := cli.Command{
189
		name:     'root'
190
		commands: [
191
			cli.Command{
192
				name:     'child'
193
				commands: [
194
					cli.Command{
195
						name: 'child-child'
196
					},
197
				]
198
			},
199
		]
200
	}
201
	assert isnil(cmd.commands[0].parent)
202
	assert isnil(cmd.commands[0].commands[0].parent)
203
	cmd.setup()
204
	assert cmd.commands[0].parent.name == 'root'
205
	assert cmd.commands[0].commands[0].parent.name == 'child'
206
}
207

208
// helper functions
209
fn empty_func(cmd cli.Command) ! {
210
}
211