1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "edm_command_test.h"
17
18 #include "edm_command.h"
19 #include "edm_log.h"
20
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace EDM {
25 namespace TEST {
SetUp()26 void EdmCommandTest::SetUp()
27 {
28 // reset optind to 0
29 optind = 0;
30 }
31
32 /**
33 * @tc.name: TestEdmCommandHelp
34 * @tc.desc: Test EdmCommand: edm help.
35 * @tc.type: FUNC
36 */
37 HWTEST_F(EdmCommandTest, TestEdmCommandHelp, TestSize.Level1)
38 {
39 char* argv[] = {
40 const_cast<char*>("edm"),
41 const_cast<char*>("help"),
42 const_cast<char*>("")
43 };
44 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
45 EdmCommand cmd(argc, argv);
46 EXPECT_EQ(cmd.ExecCommand(), HELP_MSG);
47 }
48
49 /**
50 * @tc.name: TestEnableAdminWithoutOption
51 * @tc.desc: Test EdmCommand: edm enable-admin.
52 * @tc.type: FUNC
53 */
54 HWTEST_F(EdmCommandTest, TestEnableAdminWithoutOption, TestSize.Level1)
55 {
56 char* argv[] = {
57 const_cast<char*>("edm"),
58 const_cast<char*>("enable-admin"),
59 const_cast<char*>("")
60 };
61 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
62 EdmCommand cmd(argc, argv);
63 EXPECT_EQ(cmd.ExecCommand(), cmd.GetMessageFromCode(ERR_EDM_TOOLS_COMMAND_NO_OPTION) + HELP_MSG_ENABLE_ADMIN);
64 }
65
66 /**
67 * @tc.name: TestEnableAdminHelp
68 * @tc.desc: Test EdmCommand: edm enable-admin -h.
69 * @tc.type: FUNC
70 */
71 HWTEST_F(EdmCommandTest, TestEnableAdminHelp, TestSize.Level1)
72 {
73 char* argv[] = {
74 const_cast<char*>("edm"),
75 const_cast<char*>("enable-admin"),
76 const_cast<char*>("-h"),
77 const_cast<char*>("")
78 };
79 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
80 EdmCommand cmd(argc, argv);
81 EXPECT_EQ(cmd.ExecCommand(), HELP_MSG_ENABLE_ADMIN);
82 }
83
84 /**
85 * @tc.name: TestEnableAdminWithInvalidOption
86 * @tc.desc: Test EdmCommand: edm enable-admin -f.
87 * @tc.type: FUNC
88 */
89 HWTEST_F(EdmCommandTest, TestEnableAdminWithInvalidOption, TestSize.Level1)
90 {
91 char* argv[] = {
92 const_cast<char*>("edm"),
93 const_cast<char*>("enable-admin"),
94 const_cast<char*>("-f"),
95 const_cast<char*>("")
96 };
97 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
98 EdmCommand cmd(argc, argv);
99 EXPECT_EQ(cmd.ExecCommand(), cmd.GetMessageFromCode(ERR_EDM_TOOLS_COMMAND_UNKNOWN_OPTION) + HELP_MSG_ENABLE_ADMIN);
100 }
101
102 /**
103 * @tc.name: TestEnableAdminWithoutNArgument
104 * @tc.desc: Test EdmCommand: edm enable-admin -n.
105 * @tc.type: FUNC
106 */
107 HWTEST_F(EdmCommandTest, TestEnableAdminWithoutNArgument, TestSize.Level1)
108 {
109 char* argv[] = {
110 const_cast<char*>("edm"),
111 const_cast<char*>("enable-admin"),
112 const_cast<char*>("-n"),
113 const_cast<char*>(""),
114 };
115 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
116 EdmCommand cmd(argc, argv);
117 EXPECT_EQ(cmd.ExecCommand(),
118 cmd.GetMessageFromCode(ERR_EDM_TOOLS_COMMAND_N_OPTION_REQUIRES_AN_ARGUMENT) + HELP_MSG_ENABLE_ADMIN);
119 }
120
121 /**
122 * @tc.name: TestEnableAdminWithoutAOption
123 * @tc.desc: Test EdmCommand: edm enable-admin -n <bundle-name>.
124 * @tc.type: FUNC
125 */
126 HWTEST_F(EdmCommandTest, TestEnableAdminWithoutAOption, TestSize.Level1)
127 {
128 char* argv[] = {
129 const_cast<char*>("edm"),
130 const_cast<char*>("enable-admin"),
131 const_cast<char*>("-n"),
132 const_cast<char*>("xxx"),
133 const_cast<char*>(""),
134 };
135 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
136 EdmCommand cmd(argc, argv);
137 EXPECT_EQ(cmd.ExecCommand(),
138 cmd.GetMessageFromCode(ERR_EDM_TOOLS_COMMAND_NO_ABILITY_NAME_OPTION) + HELP_MSG_ENABLE_ADMIN);
139 }
140
141 /**
142 * @tc.name: TestEnableAdminWithoutAArgument
143 * @tc.desc: Test EdmCommand: edm enable-admin -a.
144 * @tc.type: FUNC
145 */
146 HWTEST_F(EdmCommandTest, TestEnableAdminWithoutAArgument, TestSize.Level1)
147 {
148 char* argv[] = {
149 const_cast<char*>("edm"),
150 const_cast<char*>("enable-admin"),
151 const_cast<char*>("-a"),
152 const_cast<char*>(""),
153 };
154 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
155 EdmCommand cmd(argc, argv);
156 EXPECT_EQ(cmd.ExecCommand(),
157 cmd.GetMessageFromCode(ERR_EDM_TOOLS_COMMAND_A_OPTION_REQUIRES_AN_ARGUMENT) + HELP_MSG_ENABLE_ADMIN);
158 }
159
160 /**
161 * @tc.name: TestEnableAdminWithoutNOption
162 * @tc.desc: Test EdmCommand: edm enable-admin -a <ability-name>.
163 * @tc.type: FUNC
164 */
165 HWTEST_F(EdmCommandTest, TestEnableAdminWithoutNOption, TestSize.Level1)
166 {
167 char* argv[] = {
168 const_cast<char*>("edm"),
169 const_cast<char*>("enable-admin"),
170 const_cast<char*>("-a"),
171 const_cast<char*>("xxx"),
172 const_cast<char*>(""),
173 };
174 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
175 EdmCommand cmd(argc, argv);
176 EXPECT_EQ(cmd.ExecCommand(),
177 cmd.GetMessageFromCode(ERR_EDM_TOOLS_COMMAND_NO_BUNDLE_NAME_OPTION) + HELP_MSG_ENABLE_ADMIN);
178 }
179
180 /**
181 * @tc.name: TestEnableAdminWithoutTArgument
182 * @tc.desc: Test EdmCommand: edm enable-admin -t.
183 * @tc.type: FUNC
184 */
185 HWTEST_F(EdmCommandTest, TestEnableAdminWithoutTArgument, TestSize.Level1)
186 {
187 char* argv[] = {
188 const_cast<char*>("edm"),
189 const_cast<char*>("enable-admin"),
190 const_cast<char*>("-t"),
191 const_cast<char*>(""),
192 };
193 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
194 EdmCommand cmd(argc, argv);
195 EXPECT_EQ(cmd.ExecCommand(),
196 cmd.GetMessageFromCode(ERR_EDM_TOOLS_COMMAND_T_OPTION_REQUIRES_AN_ARGUMENT) + HELP_MSG_ENABLE_ADMIN);
197 }
198
199 /**
200 * @tc.name: TestEnableAdminWithTInvalidOption
201 * @tc.desc: Test EdmCommand: edm enable-admin -t.
202 * @tc.type: FUNC
203 */
204 HWTEST_F(EdmCommandTest, TestEnableAdminWithTInvalidOption, TestSize.Level1)
205 {
206 char* argv[] = {
207 const_cast<char*>("edm"),
208 const_cast<char*>("enable-admin"),
209 const_cast<char*>("-t"),
210 const_cast<char*>("XXX"),
211 const_cast<char*>(""),
212 };
213 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
214 EdmCommand cmd(argc, argv);
215 EXPECT_EQ(cmd.ExecCommand(),
216 cmd.GetMessageFromCode(ERR_EDM_TOOLS_COMMAND_UNKNOWN_ADMIN_TYPE) + HELP_MSG_ENABLE_ADMIN);
217 }
218
219 /**
220 * @tc.name: TestEnableAdmin
221 * @tc.desc: Test EdmCommand: edm enable-admin -n <bundle-name> -a <ability-name>.
222 * @tc.type: FUNC
223 */
224 HWTEST_F(EdmCommandTest, TestEnableAdmin, TestSize.Level1)
225 {
226 char* argv[] = {
227 const_cast<char*>("edm"),
228 const_cast<char*>("enable-admin"),
229 const_cast<char*>("-n"),
230 const_cast<char*>("xxx"),
231 const_cast<char*>("-a"),
232 const_cast<char*>("xxx"),
233 const_cast<char*>(""),
234 };
235 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
236 EdmCommand cmd(argc, argv);
237 EXPECT_EQ(cmd.ExecCommand(), cmd.GetMessageFromCode(EdmReturnErrCode::COMPONENT_INVALID) + "errorCode: 9200003");
238 }
239
240 /**
241 * @tc.name: TestEnableAdminHelpOfLong
242 * @tc.desc: Test EdmCommand: edm enable-admin --help.
243 * @tc.type: FUNC
244 */
245 HWTEST_F(EdmCommandTest, TestEnableAdminHelpOfLong, TestSize.Level1)
246 {
247 char* argv[] = {
248 const_cast<char*>("edm"),
249 const_cast<char*>("enable-admin"),
250 const_cast<char*>("--help"),
251 const_cast<char*>("")
252 };
253 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
254 EdmCommand cmd(argc, argv);
255 EXPECT_EQ(cmd.ExecCommand(), HELP_MSG_ENABLE_ADMIN);
256 }
257
258 /**
259 * @tc.name: TestEnableAdminWithoutAOptionOfLong
260 * @tc.desc: Test EdmCommand: edm enable-admin --bundle-name <bundle-name>.
261 * @tc.type: FUNC
262 */
263 HWTEST_F(EdmCommandTest, TestEnableAdminWithoutAOptionOfLong, TestSize.Level1)
264 {
265 char* argv[] = {
266 const_cast<char*>("edm"),
267 const_cast<char*>("enable-admin"),
268 const_cast<char*>("--bundle-name"),
269 const_cast<char*>("xxx"),
270 const_cast<char*>(""),
271 };
272 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
273 EdmCommand cmd(argc, argv);
274 EXPECT_EQ(cmd.ExecCommand(),
275 cmd.GetMessageFromCode(ERR_EDM_TOOLS_COMMAND_NO_ABILITY_NAME_OPTION) + HELP_MSG_ENABLE_ADMIN);
276 }
277
278 /**
279 * @tc.name: TestEnableAdminWithoutNOptionOfLong
280 * @tc.desc: Test EdmCommand: edm enable-admin --ability-name <ability-name>.
281 * @tc.type: FUNC
282 */
283 HWTEST_F(EdmCommandTest, TestEnableAdminWithoutNOptionOfLong, TestSize.Level1)
284 {
285 char* argv[] = {
286 const_cast<char*>("edm"),
287 const_cast<char*>("enable-admin"),
288 const_cast<char*>("--ability-name"),
289 const_cast<char*>("xxx"),
290 const_cast<char*>(""),
291 };
292 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
293 EdmCommand cmd(argc, argv);
294 EXPECT_EQ(cmd.ExecCommand(),
295 cmd.GetMessageFromCode(ERR_EDM_TOOLS_COMMAND_NO_BUNDLE_NAME_OPTION) + HELP_MSG_ENABLE_ADMIN);
296 }
297
298 /**
299 * @tc.name: TestEnableAdminOfLong
300 * @tc.desc: Test EdmCommand: edm enable-admin --bundle-name <bundle-name> --ability-name <ability-name>.
301 * @tc.type: FUNC
302 */
303 HWTEST_F(EdmCommandTest, TestEnableAdminOfLong, TestSize.Level1)
304 {
305 char* argv[] = {
306 const_cast<char*>("edm"),
307 const_cast<char*>("enable-admin"),
308 const_cast<char*>("--bundle-name"),
309 const_cast<char*>("xxx"),
310 const_cast<char*>("--ability-name"),
311 const_cast<char*>("xxx"),
312 const_cast<char*>(""),
313 };
314 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
315 EdmCommand cmd(argc, argv);
316 EXPECT_EQ(cmd.ExecCommand(), cmd.GetMessageFromCode(EdmReturnErrCode::COMPONENT_INVALID) + "errorCode: 9200003");
317 }
318 /**
319 * @tc.name: TestDisableAdminWithoutOption
320 * @tc.desc: Test EdmCommand disable admin without option.
321 * @tc.type: FUNC
322 */
323 HWTEST_F(EdmCommandTest, TestDisableAdminWithoutOption, TestSize.Level1)
324 {
325 char* argv[] = {
326 const_cast<char*>("edm"),
327 const_cast<char*>("disable-admin"),
328 const_cast<char*>(""),
329 };
330 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
331 EdmCommand cmd(argc, argv);
332 EXPECT_EQ(cmd.ExecCommand(), cmd.GetMessageFromCode(ERR_EDM_TOOLS_COMMAND_NO_OPTION) + HELP_MSG_DISABLE_ADMIN);
333 }
334
335 /**
336 * @tc.name: TestDisableAdminHelp
337 * @tc.desc: Test EdmCommand: edm disable-admin -h.
338 * @tc.type: FUNC
339 */
340 HWTEST_F(EdmCommandTest, TestDisableAdminHelp, TestSize.Level1)
341 {
342 char* argv[] = {
343 const_cast<char*>("edm"),
344 const_cast<char*>("disable-admin"),
345 const_cast<char*>("-h"),
346 const_cast<char*>(""),
347 };
348 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
349 EdmCommand cmd(argc, argv);
350 EXPECT_EQ(cmd.ExecCommand(), HELP_MSG_DISABLE_ADMIN);
351 }
352
353 /**
354 * @tc.name: TestDisableAdminWithInvalidOption
355 * @tc.desc: Test EdmCommand: edm disable-admin -f.
356 * @tc.type: FUNC
357 */
358 HWTEST_F(EdmCommandTest, TestDisableAdminWithInvalidOption, TestSize.Level1)
359 {
360 char* argv[] = {
361 const_cast<char*>("edm"),
362 const_cast<char*>("disable-admin"),
363 const_cast<char*>("-f"),
364 const_cast<char*>(""),
365 };
366 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
367 EdmCommand cmd(argc, argv);
368 EXPECT_EQ(cmd.ExecCommand(), cmd.GetMessageFromCode(ERR_EDM_TOOLS_COMMAND_UNKNOWN_OPTION) + HELP_MSG_DISABLE_ADMIN);
369 }
370
371 /**
372 * @tc.name: TestDisableAdminWithoutNArgument
373 * @tc.desc: Test EdmCommand: edm disable-admin -n.
374 * @tc.type: FUNC
375 */
376 HWTEST_F(EdmCommandTest, TestDisableAdminWithoutNArgument, TestSize.Level1)
377 {
378 char* argv[] = {
379 const_cast<char*>("edm"),
380 const_cast<char*>("disable-admin"),
381 const_cast<char*>("-n"),
382 const_cast<char*>(""),
383 };
384 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
385 EdmCommand cmd(argc, argv);
386 EXPECT_EQ(cmd.ExecCommand(),
387 cmd.GetMessageFromCode(ERR_EDM_TOOLS_COMMAND_N_OPTION_REQUIRES_AN_ARGUMENT) + HELP_MSG_DISABLE_ADMIN);
388 }
389
390 /**
391 * @tc.name: TestDisableAdmin
392 * @tc.desc: Test EdmCommand: edm disable-admin -n <bundle-name>.
393 * @tc.type: FUNC
394 */
395 HWTEST_F(EdmCommandTest, TestDisableAdmin, TestSize.Level1)
396 {
397 char* argv[] = {
398 const_cast<char*>("edm"),
399 const_cast<char*>("disable-admin"),
400 const_cast<char*>("-n"),
401 const_cast<char*>("xxx"),
402 const_cast<char*>(""),
403 };
404 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
405 EdmCommand cmd(argc, argv);
406 EXPECT_EQ(cmd.ExecCommand(), cmd.GetMessageFromCode(EdmReturnErrCode::DISABLE_ADMIN_FAILED) + "errorCode: 9200005");
407 }
408
409 /**
410 * @tc.name: TestDisableAdminHelpOfLong
411 * @tc.desc: Test EdmCommand: edm disable-admin --help.
412 * @tc.type: FUNC
413 */
414 HWTEST_F(EdmCommandTest, TestDisableAdminHelpOfLong, TestSize.Level1)
415 {
416 char* argv[] = {
417 const_cast<char*>("edm"),
418 const_cast<char*>("disable-admin"),
419 const_cast<char*>("--help"),
420 const_cast<char*>(""),
421 };
422 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
423 EdmCommand cmd(argc, argv);
424 EXPECT_EQ(cmd.ExecCommand(), HELP_MSG_DISABLE_ADMIN);
425 }
426
427 /**
428 * @tc.name: TestDisableAdminOfLong
429 * @tc.desc: Test EdmCommand: edm disable-admin --bundle-name <bundle-name>.
430 * @tc.type: FUNC
431 */
432 HWTEST_F(EdmCommandTest, TestDisableAdminOfLong, TestSize.Level1)
433 {
434 char* argv[] = {
435 const_cast<char*>("edm"),
436 const_cast<char*>("disable-admin"),
437 const_cast<char*>("--bundle-name"),
438 const_cast<char*>("xxx"),
439 const_cast<char*>(""),
440 };
441 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
442 EdmCommand cmd(argc, argv);
443 EXPECT_EQ(cmd.ExecCommand(), cmd.GetMessageFromCode(EdmReturnErrCode::DISABLE_ADMIN_FAILED) + "errorCode: 9200005");
444 }
445 } // TEST
446 } // EDM
447 } // OHOS
448