1 /*
2 * Copyright (c) 2021 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 <gtest/gtest.h>
17
18 #define protected public
19 #include "ability_command.h"
20 #undef protected
21 #include "mock_ability_manager_stub.h"
22 #define private public
23 #include "ability_manager_client.h"
24 #undef private
25 #include "ability_manager_interface.h"
26
27 using namespace testing::ext;
28 using namespace OHOS;
29 using namespace OHOS::AAFwk;
30
31 namespace {
32 const std::string STRING_DEVICE = "device";
33 const std::string STRING_ABILITY_NAME = "ability";
34 const std::string STRING_ABILITY_NAME_INVALID = "invalid_ability";
35 const std::string STRING_BUNDLE_NAME = "bundle";
36 const std::string STRING_BUNDLE_NAME_INVALID = "invalid_bundle";
37 const std::string STRING_RECORD_ID = "1024";
38 const std::string STRING_RECORD_ID_INVALID = "2048";
39 const std::string STRING_STATE_ON = "on";
40 const std::string STRING_STATE_ON_INVALID = "invalid_on";
41 const std::string STRING_STATE_OFF = "off";
42 const std::string STRING_STATE_OFF_INVALID = "invalid_off";
43 }
44
45 class AaCommandStopServiceTest : public ::testing::Test {
46 public:
47 static void SetUpTestCase();
48 static void TearDownTestCase();
49 void SetUp() override;
50 void TearDown() override;
51
52 void MakeMockObjects() const;
53
54 std::string cmd_ = "stop-service";
55 };
56
SetUpTestCase()57 void AaCommandStopServiceTest::SetUpTestCase()
58 {}
59
TearDownTestCase()60 void AaCommandStopServiceTest::TearDownTestCase()
61 {}
62
SetUp()63 void AaCommandStopServiceTest::SetUp()
64 {
65 // reset optind to 0
66 optind = 0;
67
68 // make mock objects
69 MakeMockObjects();
70 }
71
TearDown()72 void AaCommandStopServiceTest::TearDown()
73 {}
74
MakeMockObjects() const75 void AaCommandStopServiceTest::MakeMockObjects() const
76 {
77 // mock a stub
78 auto managerStubPtr = sptr<IAbilityManager>(new MockAbilityManagerStub());
79
80 // set the mock stub
81 auto managerClientPtr = AbilityManagerClient::GetInstance();
82 managerClientPtr->proxy_ = managerStubPtr;
83 }
84
85 /**
86 * @tc.number: Aa_Command_StopService_0100
87 * @tc.name: ExecCommand
88 * @tc.desc: Verify the "aa stop-service" command.
89 */
90 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_0100, Function | MediumTest | Level1)
91 {
92 char *argv[] = {
93 (char *)TOOL_NAME.c_str(),
94 (char *)cmd_.c_str(),
95 (char *)"",
96 };
97 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
98
99 AbilityManagerShellCommand cmd(argc, argv);
100 EXPECT_EQ(cmd.ExecCommand(), HELP_MSG_NO_OPTION + "\n" + HELP_MSG_STOP_SERVICE);
101 }
102
103 /**
104 * @tc.number: Aa_Command_StopService_0200
105 * @tc.name: ExecCommand
106 * @tc.desc: Verify the "aa stop-service xxx" command.
107 */
108 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_0200, Function | MediumTest | Level1)
109 {
110 char *argv[] = {
111 (char *)TOOL_NAME.c_str(),
112 (char *)cmd_.c_str(),
113 (char *)"xxx",
114 (char *)"",
115 };
116 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
117
118 AbilityManagerShellCommand cmd(argc, argv);
119 EXPECT_EQ(cmd.ExecCommand(), HELP_MSG_NO_OPTION + "\n" + HELP_MSG_STOP_SERVICE);
120 }
121
122 /**
123 * @tc.number: Aa_Command_StopService_0300
124 * @tc.name: ExecCommand
125 * @tc.desc: Verify the "aa stop-service -x" command.
126 */
127 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_0300, Function | MediumTest | Level1)
128 {
129 char *argv[] = {
130 (char *)TOOL_NAME.c_str(),
131 (char *)cmd_.c_str(),
132 (char *)"-x",
133 (char *)"",
134 };
135 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
136
137 AbilityManagerShellCommand cmd(argc, argv);
138 EXPECT_EQ(cmd.ExecCommand(), "error: unknown option.\n" + HELP_MSG_STOP_SERVICE);
139 }
140
141 /**
142 * @tc.number: Aa_Command_StopService_0400
143 * @tc.name: ExecCommand
144 * @tc.desc: Verify the "aa stop-service -xxx" command.
145 */
146 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_0400, Function | MediumTest | Level1)
147 {
148 char *argv[] = {
149 (char *)TOOL_NAME.c_str(),
150 (char *)cmd_.c_str(),
151 (char *)"-xxx",
152 (char *)"",
153 };
154 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
155
156 AbilityManagerShellCommand cmd(argc, argv);
157 EXPECT_EQ(cmd.ExecCommand(), "error: unknown option.\n" + HELP_MSG_STOP_SERVICE);
158 }
159
160 /**
161 * @tc.number: Aa_Command_StopService_0500
162 * @tc.name: ExecCommand
163 * @tc.desc: Verify the "aa stop-service --x" command.
164 */
165 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_0500, Function | MediumTest | Level1)
166 {
167 char *argv[] = {
168 (char *)TOOL_NAME.c_str(),
169 (char *)cmd_.c_str(),
170 (char *)"--x",
171 (char *)"",
172 };
173 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
174
175 AbilityManagerShellCommand cmd(argc, argv);
176 EXPECT_EQ(cmd.ExecCommand(), "error: unknown option.\n" + HELP_MSG_STOP_SERVICE);
177 }
178
179 /**
180 * @tc.number: Aa_Command_StopService_0600
181 * @tc.name: ExecCommand
182 * @tc.desc: Verify the "aa stop-service --xxx" command.
183 */
184 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_0600, Function | MediumTest | Level1)
185 {
186 char *argv[] = {
187 (char *)TOOL_NAME.c_str(),
188 (char *)cmd_.c_str(),
189 (char *)"--xxx",
190 (char *)"",
191 };
192 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
193
194 AbilityManagerShellCommand cmd(argc, argv);
195 EXPECT_EQ(cmd.ExecCommand(), "error: unknown option.\n" + HELP_MSG_STOP_SERVICE);
196 }
197
198 /**
199 * @tc.number: Aa_Command_StopService_0700
200 * @tc.name: ExecCommand
201 * @tc.desc: Verify the "aa stop-service -h" command.
202 */
203 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_0700, Function | MediumTest | Level1)
204 {
205 char *argv[] = {
206 (char *)TOOL_NAME.c_str(),
207 (char *)cmd_.c_str(),
208 (char *)"-h",
209 (char *)"",
210 };
211 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
212
213 AbilityManagerShellCommand cmd(argc, argv);
214 EXPECT_EQ(cmd.ExecCommand(), HELP_MSG_STOP_SERVICE);
215 }
216
217 /**
218 * @tc.number: Aa_Command_StopService_0800
219 * @tc.name: ExecCommand
220 * @tc.desc: Verify the "aa stop-service --help" command.
221 */
222 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_0800, Function | MediumTest | Level1)
223 {
224 char *argv[] = {
225 (char *)TOOL_NAME.c_str(),
226 (char *)cmd_.c_str(),
227 (char *)"--help",
228 (char *)"",
229 };
230 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
231
232 AbilityManagerShellCommand cmd(argc, argv);
233 EXPECT_EQ(cmd.ExecCommand(), HELP_MSG_STOP_SERVICE);
234 }
235
236 /**
237 * @tc.number: Aa_Command_StopService_0900
238 * @tc.name: ExecCommand
239 * @tc.desc: Verify the "aa stop-service -d" command.
240 */
241 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_0900, Function | MediumTest | Level1)
242 {
243 char *argv[] = {
244 (char *)TOOL_NAME.c_str(),
245 (char *)cmd_.c_str(),
246 (char *)"-d",
247 (char *)"",
248 };
249 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
250
251 AbilityManagerShellCommand cmd(argc, argv);
252 EXPECT_EQ(cmd.ExecCommand(), "error: option requires a value.\n" + HELP_MSG_STOP_SERVICE);
253 }
254
255 /**
256 * @tc.number: Aa_Command_StopService_1000
257 * @tc.name: ExecCommand
258 * @tc.desc: Verify the "aa stop-service -d <device-id>" command.
259 */
260 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_1000, Function | MediumTest | Level1)
261 {
262 char *argv[] = {
263 (char *)TOOL_NAME.c_str(),
264 (char *)cmd_.c_str(),
265 (char *)"-d",
266 (char *)STRING_DEVICE.c_str(),
267 (char *)"",
268 };
269 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
270
271 AbilityManagerShellCommand cmd(argc, argv);
272 EXPECT_EQ(cmd.ExecCommand(),
273 HELP_MSG_NO_ABILITY_NAME_OPTION + "\n" + HELP_MSG_NO_BUNDLE_NAME_OPTION + "\n" + HELP_MSG_STOP_SERVICE);
274 }
275
276 /**
277 * @tc.number: Aa_Command_StopService_1100
278 * @tc.name: ExecCommand
279 * @tc.desc: Verify the "aa stop-service -d <device-id> -a" command.
280 */
281 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_1100, Function | MediumTest | Level1)
282 {
283 char *argv[] = {
284 (char *)TOOL_NAME.c_str(),
285 (char *)cmd_.c_str(),
286 (char *)"-d",
287 (char *)STRING_DEVICE.c_str(),
288 (char *)"-a",
289 (char *)"",
290 };
291 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
292
293 AbilityManagerShellCommand cmd(argc, argv);
294 EXPECT_EQ(cmd.ExecCommand(), "error: option requires a value.\n" + HELP_MSG_STOP_SERVICE);
295 }
296
297 /**
298 * @tc.number: Aa_Command_StopService_1200
299 * @tc.name: ExecCommand
300 * @tc.desc: Verify the "aa stop-service -d <device-id> -a <ability-name>" command.
301 */
302 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_1200, Function | MediumTest | Level1)
303 {
304 char *argv[] = {
305 (char *)TOOL_NAME.c_str(),
306 (char *)cmd_.c_str(),
307 (char *)"-d",
308 (char *)STRING_DEVICE.c_str(),
309 (char *)"-a",
310 (char *)STRING_ABILITY_NAME.c_str(),
311 (char *)"",
312 };
313 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
314
315 AbilityManagerShellCommand cmd(argc, argv);
316 EXPECT_EQ(cmd.ExecCommand(), HELP_MSG_NO_BUNDLE_NAME_OPTION + "\n" + HELP_MSG_STOP_SERVICE);
317 }
318
319 /**
320 * @tc.number: Aa_Command_StopService_1300
321 * @tc.name: ExecCommand
322 * @tc.desc: Verify the "aa stop-service -d <device-id> -b" command.
323 */
324 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_1300, Function | MediumTest | Level1)
325 {
326 char *argv[] = {
327 (char *)TOOL_NAME.c_str(),
328 (char *)cmd_.c_str(),
329 (char *)"-d",
330 (char *)STRING_DEVICE.c_str(),
331 (char *)"-b",
332 (char *)"",
333 };
334 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
335
336 AbilityManagerShellCommand cmd(argc, argv);
337 EXPECT_EQ(cmd.ExecCommand(), "error: option requires a value.\n" + HELP_MSG_STOP_SERVICE);
338 }
339
340 /**
341 * @tc.number: Aa_Command_StopService_1400
342 * @tc.name: ExecCommand
343 * @tc.desc: Verify the "aa stop-service -d <device-id> -b <bundle-name>" command.
344 */
345 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_1400, Function | MediumTest | Level1)
346 {
347 char *argv[] = {
348 (char *)TOOL_NAME.c_str(),
349 (char *)cmd_.c_str(),
350 (char *)"-d",
351 (char *)STRING_DEVICE.c_str(),
352 (char *)"-b",
353 (char *)STRING_BUNDLE_NAME.c_str(),
354 (char *)"",
355 };
356 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
357
358 AbilityManagerShellCommand cmd(argc, argv);
359 EXPECT_EQ(cmd.ExecCommand(), HELP_MSG_NO_ABILITY_NAME_OPTION + "\n" + HELP_MSG_STOP_SERVICE);
360 }
361
362 /**
363 * @tc.number: Aa_Command_StopService_1500
364 * @tc.name: ExecCommand
365 * @tc.desc: Verify the "aa stop-service -d <device-id> -a <ability-name> -b" command.
366 */
367 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_1500, Function | MediumTest | Level1)
368 {
369 char *argv[] = {
370 (char *)TOOL_NAME.c_str(),
371 (char *)cmd_.c_str(),
372 (char *)"-d",
373 (char *)STRING_DEVICE.c_str(),
374 (char *)"-a",
375 (char *)STRING_ABILITY_NAME.c_str(),
376 (char *)"-b",
377 (char *)"",
378 };
379 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
380
381 AbilityManagerShellCommand cmd(argc, argv);
382 EXPECT_EQ(cmd.ExecCommand(), "error: option requires a value.\n" + HELP_MSG_STOP_SERVICE);
383 }
384
385 /**
386 * @tc.number: Aa_Command_StopService_1600
387 * @tc.name: ExecCommand
388 * @tc.desc: Verify the "aa stop-service -d <device-id> -a <ability-name> -b <bundle-name>" command.
389 */
390 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_1600, Function | MediumTest | Level1)
391 {
392 char *argv[] = {
393 (char *)TOOL_NAME.c_str(),
394 (char *)cmd_.c_str(),
395 (char *)"-d",
396 (char *)STRING_DEVICE.c_str(),
397 (char *)"-a",
398 (char *)STRING_ABILITY_NAME.c_str(),
399 (char *)"-b",
400 (char *)STRING_BUNDLE_NAME.c_str(),
401 (char *)"",
402 };
403 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
404
405 AbilityManagerShellCommand cmd(argc, argv);
406 EXPECT_EQ(cmd.ExecCommand(), STRING_STOP_SERVICE_ABILITY_OK + "\n");
407 }
408
409 /**
410 * @tc.number: Aa_Command_StopService_1700
411 * @tc.name: ExecCommand
412 * @tc.desc: Verify the "aa stop-service -a" command.
413 */
414 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_1700, Function | MediumTest | Level1)
415 {
416 char *argv[] = {
417 (char *)TOOL_NAME.c_str(),
418 (char *)cmd_.c_str(),
419 (char *)"-a",
420 (char *)"",
421 };
422 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
423
424 AbilityManagerShellCommand cmd(argc, argv);
425 EXPECT_EQ(cmd.ExecCommand(), "error: option requires a value.\n" + HELP_MSG_STOP_SERVICE);
426 }
427
428 /**
429 * @tc.number: Aa_Command_StopService_1800
430 * @tc.name: ExecCommand
431 * @tc.desc: Verify the "aa stop-service -a <ability-name> -b" command.
432 */
433 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_1800, Function | MediumTest | Level1)
434 {
435 char *argv[] = {
436 (char *)TOOL_NAME.c_str(),
437 (char *)cmd_.c_str(),
438 (char *)"-a",
439 (char *)STRING_ABILITY_NAME.c_str(),
440 (char *)"-b",
441 (char *)"",
442 };
443 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
444
445 AbilityManagerShellCommand cmd(argc, argv);
446 EXPECT_EQ(cmd.ExecCommand(), "error: option requires a value.\n" + HELP_MSG_STOP_SERVICE);
447 }
448
449 /**
450 * @tc.number: Aa_Command_StopService_1900
451 * @tc.name: ExecCommand
452 * @tc.desc: Verify the "aa stop-service -a <ability-name> -b <bundle-name>" command.
453 */
454 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_1900, Function | MediumTest | Level1)
455 {
456 char *argv[] = {
457 (char *)TOOL_NAME.c_str(),
458 (char *)cmd_.c_str(),
459 (char *)"-a",
460 (char *)STRING_ABILITY_NAME.c_str(),
461 (char *)"-b",
462 (char *)STRING_BUNDLE_NAME.c_str(),
463 (char *)"",
464 };
465 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
466
467 AbilityManagerShellCommand cmd(argc, argv);
468 EXPECT_EQ(cmd.ExecCommand(), STRING_STOP_SERVICE_ABILITY_OK + "\n");
469 }
470
471 /**
472 * @tc.number: Aa_Command_StopService_2000
473 * @tc.name: ExecCommand
474 * @tc.desc: Verify the "aa stop-service -d <device-id> -a <ability-name> -b <bundle-name>" command.
475 */
476 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_2000, Function | MediumTest | Level1)
477 {
478 char *argv[] = {
479 (char *)TOOL_NAME.c_str(),
480 (char *)cmd_.c_str(),
481 (char *)"-d",
482 (char *)STRING_DEVICE.c_str(),
483 (char *)"-a",
484 (char *)STRING_ABILITY_NAME_INVALID.c_str(),
485 (char *)"-b",
486 (char *)STRING_BUNDLE_NAME.c_str(),
487 (char *)"",
488 };
489 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
490
491 AbilityManagerShellCommand cmd(argc, argv);
492 EXPECT_EQ(
493 cmd.ExecCommand(), STRING_STOP_SERVICE_ABILITY_NG + "\n" + cmd.messageMap_.at(RESOLVE_ABILITY_ERR) + "\n");
494 }
495
496 /**
497 * @tc.number: Aa_Command_StopService_2100
498 * @tc.name: ExecCommand
499 * @tc.desc: Verify the "aa stop-service -d <device-id> -a <ability-name> -b <bundle-name>" command.
500 */
501 HWTEST_F(AaCommandStopServiceTest, Aa_Command_StopService_2100, Function | MediumTest | Level1)
502 {
503 char *argv[] = {
504 (char *)TOOL_NAME.c_str(),
505 (char *)cmd_.c_str(),
506 (char *)"-d",
507 (char *)STRING_DEVICE.c_str(),
508 (char *)"-a",
509 (char *)STRING_ABILITY_NAME.c_str(),
510 (char *)"-b",
511 (char *)STRING_BUNDLE_NAME_INVALID.c_str(),
512 (char *)"",
513 };
514 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
515
516 AbilityManagerShellCommand cmd(argc, argv);
517 EXPECT_EQ(cmd.ExecCommand(), STRING_STOP_SERVICE_ABILITY_NG + "\n" + cmd.messageMap_.at(RESOLVE_APP_ERR) + "\n");
518 }
519