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: TestEnableAdmin
182 * @tc.desc: Test EdmCommand: edm enable-admin -n <bundle-name> -a <ability-name>.
183 * @tc.type: FUNC
184 */
185 HWTEST_F(EdmCommandTest, TestEnableAdmin, TestSize.Level1)
186 {
187 char* argv[] = {
188 const_cast<char*>("edm"),
189 const_cast<char*>("enable-admin"),
190 const_cast<char*>("-n"),
191 const_cast<char*>("xxx"),
192 const_cast<char*>("-a"),
193 const_cast<char*>("xxx"),
194 const_cast<char*>(""),
195 };
196 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
197 EdmCommand cmd(argc, argv);
198 EXPECT_EQ(cmd.ExecCommand(), cmd.GetMessageFromCode(EdmReturnErrCode::COMPONENT_INVALID));
199 }
200
201 /**
202 * @tc.name: TestEnableAdminHelpOfLong
203 * @tc.desc: Test EdmCommand: edm enable-admin --help.
204 * @tc.type: FUNC
205 */
206 HWTEST_F(EdmCommandTest, TestEnableAdminHelpOfLong, TestSize.Level1)
207 {
208 char* argv[] = {
209 const_cast<char*>("edm"),
210 const_cast<char*>("enable-admin"),
211 const_cast<char*>("--help"),
212 const_cast<char*>("")
213 };
214 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
215 EdmCommand cmd(argc, argv);
216 EXPECT_EQ(cmd.ExecCommand(), HELP_MSG_ENABLE_ADMIN);
217 }
218
219 /**
220 * @tc.name: TestEnableAdminWithoutAOptionOfLong
221 * @tc.desc: Test EdmCommand: edm enable-admin --bundle-name <bundle-name>.
222 * @tc.type: FUNC
223 */
224 HWTEST_F(EdmCommandTest, TestEnableAdminWithoutAOptionOfLong, TestSize.Level1)
225 {
226 char* argv[] = {
227 const_cast<char*>("edm"),
228 const_cast<char*>("enable-admin"),
229 const_cast<char*>("--bundle-name"),
230 const_cast<char*>("xxx"),
231 const_cast<char*>(""),
232 };
233 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
234 EdmCommand cmd(argc, argv);
235 EXPECT_EQ(cmd.ExecCommand(),
236 cmd.GetMessageFromCode(ERR_EDM_TOOLS_COMMAND_NO_ABILITY_NAME_OPTION) + HELP_MSG_ENABLE_ADMIN);
237 }
238
239 /**
240 * @tc.name: TestEnableAdminWithoutNOptionOfLong
241 * @tc.desc: Test EdmCommand: edm enable-admin --ability-name <ability-name>.
242 * @tc.type: FUNC
243 */
244 HWTEST_F(EdmCommandTest, TestEnableAdminWithoutNOptionOfLong, TestSize.Level1)
245 {
246 char* argv[] = {
247 const_cast<char*>("edm"),
248 const_cast<char*>("enable-admin"),
249 const_cast<char*>("--ability-name"),
250 const_cast<char*>("xxx"),
251 const_cast<char*>(""),
252 };
253 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
254 EdmCommand cmd(argc, argv);
255 EXPECT_EQ(cmd.ExecCommand(),
256 cmd.GetMessageFromCode(ERR_EDM_TOOLS_COMMAND_NO_BUNDLE_NAME_OPTION) + HELP_MSG_ENABLE_ADMIN);
257 }
258
259 /**
260 * @tc.name: TestEnableAdminOfLong
261 * @tc.desc: Test EdmCommand: edm enable-admin --bundle-name <bundle-name> --ability-name <ability-name>.
262 * @tc.type: FUNC
263 */
264 HWTEST_F(EdmCommandTest, TestEnableAdminOfLong, TestSize.Level1)
265 {
266 char* argv[] = {
267 const_cast<char*>("edm"),
268 const_cast<char*>("enable-admin"),
269 const_cast<char*>("--bundle-name"),
270 const_cast<char*>("xxx"),
271 const_cast<char*>("--ability-name"),
272 const_cast<char*>("xxx"),
273 const_cast<char*>(""),
274 };
275 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
276 EdmCommand cmd(argc, argv);
277 EXPECT_EQ(cmd.ExecCommand(), cmd.GetMessageFromCode(EdmReturnErrCode::COMPONENT_INVALID));
278 }
279 /**
280 * @tc.name: TestDisableAdminWithoutOption
281 * @tc.desc: Test EdmCommand disable admin without option.
282 * @tc.type: FUNC
283 */
284 HWTEST_F(EdmCommandTest, TestDisableAdminWithoutOption, TestSize.Level1)
285 {
286 char* argv[] = {
287 const_cast<char*>("edm"),
288 const_cast<char*>("disable-admin"),
289 const_cast<char*>(""),
290 };
291 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
292 EdmCommand cmd(argc, argv);
293 EXPECT_EQ(cmd.ExecCommand(), cmd.GetMessageFromCode(ERR_EDM_TOOLS_COMMAND_NO_OPTION) + HELP_MSG_DISABLE_ADMIN);
294 }
295
296 /**
297 * @tc.name: TestDisableAdminHelp
298 * @tc.desc: Test EdmCommand: edm disable-admin -h.
299 * @tc.type: FUNC
300 */
301 HWTEST_F(EdmCommandTest, TestDisableAdminHelp, TestSize.Level1)
302 {
303 char* argv[] = {
304 const_cast<char*>("edm"),
305 const_cast<char*>("disable-admin"),
306 const_cast<char*>("-h"),
307 const_cast<char*>(""),
308 };
309 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
310 EdmCommand cmd(argc, argv);
311 EXPECT_EQ(cmd.ExecCommand(), HELP_MSG_DISABLE_ADMIN);
312 }
313
314 /**
315 * @tc.name: TestDisableAdminWithInvalidOption
316 * @tc.desc: Test EdmCommand: edm disable-admin -f.
317 * @tc.type: FUNC
318 */
319 HWTEST_F(EdmCommandTest, TestDisableAdminWithInvalidOption, TestSize.Level1)
320 {
321 char* argv[] = {
322 const_cast<char*>("edm"),
323 const_cast<char*>("disable-admin"),
324 const_cast<char*>("-f"),
325 const_cast<char*>(""),
326 };
327 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
328 EdmCommand cmd(argc, argv);
329 EXPECT_EQ(cmd.ExecCommand(), cmd.GetMessageFromCode(ERR_EDM_TOOLS_COMMAND_UNKNOWN_OPTION) + HELP_MSG_DISABLE_ADMIN);
330 }
331
332 /**
333 * @tc.name: TestDisableAdminWithoutNArgument
334 * @tc.desc: Test EdmCommand: edm disable-admin -n.
335 * @tc.type: FUNC
336 */
337 HWTEST_F(EdmCommandTest, TestDisableAdminWithoutNArgument, TestSize.Level1)
338 {
339 char* argv[] = {
340 const_cast<char*>("edm"),
341 const_cast<char*>("disable-admin"),
342 const_cast<char*>("-n"),
343 const_cast<char*>(""),
344 };
345 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
346 EdmCommand cmd(argc, argv);
347 EXPECT_EQ(cmd.ExecCommand(),
348 cmd.GetMessageFromCode(ERR_EDM_TOOLS_COMMAND_N_OPTION_REQUIRES_AN_ARGUMENT) + HELP_MSG_DISABLE_ADMIN);
349 }
350
351 /**
352 * @tc.name: TestDisableAdmin
353 * @tc.desc: Test EdmCommand: edm disable-admin -n <bundle-name>.
354 * @tc.type: FUNC
355 */
356 HWTEST_F(EdmCommandTest, TestDisableAdmin, TestSize.Level1)
357 {
358 char* argv[] = {
359 const_cast<char*>("edm"),
360 const_cast<char*>("disable-admin"),
361 const_cast<char*>("-n"),
362 const_cast<char*>("xxx"),
363 const_cast<char*>(""),
364 };
365 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
366 EdmCommand cmd(argc, argv);
367 EXPECT_EQ(cmd.ExecCommand(), cmd.GetMessageFromCode(EdmReturnErrCode::DISABLE_ADMIN_FAILED));
368 }
369
370 /**
371 * @tc.name: TestDisableAdminHelpOfLong
372 * @tc.desc: Test EdmCommand: edm disable-admin --help.
373 * @tc.type: FUNC
374 */
375 HWTEST_F(EdmCommandTest, TestDisableAdminHelpOfLong, TestSize.Level1)
376 {
377 char* argv[] = {
378 const_cast<char*>("edm"),
379 const_cast<char*>("disable-admin"),
380 const_cast<char*>("--help"),
381 const_cast<char*>(""),
382 };
383 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
384 EdmCommand cmd(argc, argv);
385 EXPECT_EQ(cmd.ExecCommand(), HELP_MSG_DISABLE_ADMIN);
386 }
387
388 /**
389 * @tc.name: TestDisableAdminOfLong
390 * @tc.desc: Test EdmCommand: edm disable-admin --bundle-name <bundle-name>.
391 * @tc.type: FUNC
392 */
393 HWTEST_F(EdmCommandTest, TestDisableAdminOfLong, TestSize.Level1)
394 {
395 char* argv[] = {
396 const_cast<char*>("edm"),
397 const_cast<char*>("disable-admin"),
398 const_cast<char*>("--bundle-name"),
399 const_cast<char*>("xxx"),
400 const_cast<char*>(""),
401 };
402 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
403 EdmCommand cmd(argc, argv);
404 EXPECT_EQ(cmd.ExecCommand(), cmd.GetMessageFromCode(EdmReturnErrCode::DISABLE_ADMIN_FAILED));
405 }
406 } // TEST
407 } // EDM
408 } // OHOS
409