1 /*
2 * Copyright (c) 2022-2023 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 #include "ability_manager_errors.h"
19 #include "mock_ability_debug_response_stub.h"
20 #include "mock_ability_token.h"
21 #include "mock_ams_mgr_scheduler.h"
22 #include "mock_app_debug_listener_stub.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace AppExecFwk {
29 namespace {
30 const std::string STRING_BUNDLE_NAME = "bundleName";
31 const std::string EMPTY_BUNDLE_NAME = "";
32 } // namespace
33
34 class AmsMgrStubTest : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 void SetUp() override;
39 void TearDown() override;
40
41 sptr<MockAppDebugListenerStub> listener_;
42 sptr<MockAbilityDebugResponseStub> response_;
43 sptr<MockAmsMgrScheduler> mockAmsMgrScheduler_;
44
45 void WriteInterfaceToken(MessageParcel& data);
46 };
47
SetUpTestCase(void)48 void AmsMgrStubTest::SetUpTestCase(void)
49 {}
50
TearDownTestCase(void)51 void AmsMgrStubTest::TearDownTestCase(void)
52 {}
53
SetUp()54 void AmsMgrStubTest::SetUp()
55 {
56 GTEST_LOG_(INFO) << "AmsMgrStubTest::SetUp()";
57
58 listener_ = new MockAppDebugListenerStub();
59 response_ = new MockAbilityDebugResponseStub();
60 mockAmsMgrScheduler_ = new MockAmsMgrScheduler();
61 }
62
TearDown()63 void AmsMgrStubTest::TearDown()
64 {}
65
WriteInterfaceToken(MessageParcel & data)66 void AmsMgrStubTest::WriteInterfaceToken(MessageParcel& data)
67 {
68 GTEST_LOG_(INFO) << "AmsMgrStubTest::WriteInterfaceToken()";
69
70 data.WriteInterfaceToken(AmsMgrStub::GetDescriptor());
71 }
72
73 /**
74 * @tc.name: HandleRegisterAppDebugListener_0100
75 * @tc.desc: Handle register app debug listener.
76 * @tc.type: FUNC
77 */
78 HWTEST_F(AmsMgrStubTest, HandleRegisterAppDebugListener_0100, TestSize.Level1)
79 {
80 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
81 EXPECT_CALL(*mockAmsMgrScheduler_, RegisterAppDebugListener(_)).Times(1);
82 MessageParcel data;
83 MessageParcel reply;
84 MessageOption option(MessageOption::TF_ASYNC);
85 WriteInterfaceToken(data);
86 EXPECT_NE(listener_, nullptr);
87 data.WriteRemoteObject(listener_);
88
89 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
90 static_cast<uint32_t>(IAmsMgr::Message::REGISTER_APP_DEBUG_LISTENER), data, reply, option);
91 EXPECT_EQ(result, NO_ERROR);
92 }
93
94 /**
95 * @tc.name: HandleRegisterAppDebugListener_0200
96 * @tc.desc: Handle register app debug listener, check nullptr listener.
97 * @tc.type: FUNC
98 */
99 HWTEST_F(AmsMgrStubTest, HandleRegisterAppDebugListener_0200, TestSize.Level1)
100 {
101 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
102 EXPECT_CALL(*mockAmsMgrScheduler_, RegisterAppDebugListener(_)).Times(0);
103 MessageParcel data;
104 MessageParcel reply;
105 MessageOption option(MessageOption::TF_ASYNC);
106 listener_ = nullptr;
107 WriteInterfaceToken(data);
108 data.WriteRemoteObject(listener_);
109
110 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
111 static_cast<uint32_t>(IAmsMgr::Message::REGISTER_APP_DEBUG_LISTENER), data, reply, option);
112 EXPECT_EQ(result, ERR_INVALID_VALUE);
113 }
114 /**
115 * @tc.name: HandleUnregisterAppDebugListener_0100
116 * @tc.desc: Handle unregister app debug listener.
117 * @tc.type: FUNC
118 */
119 HWTEST_F(AmsMgrStubTest, HandleUnregisterAppDebugListener_0100, TestSize.Level1)
120 {
121 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
122 EXPECT_CALL(*mockAmsMgrScheduler_, UnregisterAppDebugListener(_)).Times(1);
123 MessageParcel data;
124 MessageParcel reply;
125 MessageOption option(MessageOption::TF_ASYNC);
126 WriteInterfaceToken(data);
127 EXPECT_NE(listener_, nullptr);
128 data.WriteRemoteObject(listener_);
129
130 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
131 static_cast<uint32_t>(IAmsMgr::Message::UNREGISTER_APP_DEBUG_LISTENER), data, reply, option);
132 EXPECT_EQ(result, NO_ERROR);
133 }
134
135 /**
136 * @tc.name: HandleUnregisterAppDebugListener_0200
137 * @tc.desc: Handle unregister app debug listener, check nullptr listener.
138 * @tc.type: FUNC
139 */
140 HWTEST_F(AmsMgrStubTest, HandleUnregisterAppDebugListener_0200, TestSize.Level1)
141 {
142 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
143 EXPECT_CALL(*mockAmsMgrScheduler_, UnregisterAppDebugListener(_)).Times(0);
144 MessageParcel data;
145 MessageParcel reply;
146 MessageOption option(MessageOption::TF_ASYNC);
147 listener_ = nullptr;
148 WriteInterfaceToken(data);
149 data.WriteRemoteObject(listener_);
150
151 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
152 static_cast<uint32_t>(IAmsMgr::Message::UNREGISTER_APP_DEBUG_LISTENER), data, reply, option);
153 EXPECT_EQ(result, ERR_INVALID_VALUE);
154 }
155
156 /**
157 * @tc.name: HandleAttachAppDebug_0100
158 * @tc.desc: Handle attach app, begin debug mode.
159 * @tc.type: FUNC
160 */
161 HWTEST_F(AmsMgrStubTest, HandleAttachAppDebug_0100, TestSize.Level1)
162 {
163 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
164 EXPECT_CALL(*mockAmsMgrScheduler_, AttachAppDebug(_, _)).Times(1);
165 MessageParcel data;
166 MessageParcel reply;
167 MessageOption option(MessageOption::TF_ASYNC);
168 WriteInterfaceToken(data);
169 data.WriteString(STRING_BUNDLE_NAME);
170
171 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
172 static_cast<uint32_t>(IAmsMgr::Message::ATTACH_APP_DEBUG), data, reply, option);
173 EXPECT_EQ(result, NO_ERROR);
174 }
175
176 /**
177 * @tc.name: HandleAttachAppDebug_0200
178 * @tc.desc: Handle attach app, begin debug mode, check empty bunle name.
179 * @tc.type: FUNC
180 */
181 HWTEST_F(AmsMgrStubTest, HandleAttachAppDebug_0200, TestSize.Level1)
182 {
183 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
184 EXPECT_CALL(*mockAmsMgrScheduler_, AttachAppDebug(_, _)).Times(0);
185 MessageParcel data;
186 MessageParcel reply;
187 MessageOption option(MessageOption::TF_ASYNC);
188 WriteInterfaceToken(data);
189 data.WriteString(EMPTY_BUNDLE_NAME);
190
191 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
192 static_cast<uint32_t>(IAmsMgr::Message::ATTACH_APP_DEBUG), data, reply, option);
193 EXPECT_EQ(result, ERR_INVALID_VALUE);
194 }
195
196 /**
197 * @tc.name: HandleDetachAppDebug_0100
198 * @tc.desc: Handle detach app, end debug mode.
199 * @tc.type: FUNC
200 */
201 HWTEST_F(AmsMgrStubTest, HandleDetachAppDebug_0100, TestSize.Level1)
202 {
203 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
204 EXPECT_CALL(*mockAmsMgrScheduler_, DetachAppDebug(_)).Times(1);
205 MessageParcel data;
206 MessageParcel reply;
207 MessageOption option(MessageOption::TF_ASYNC);
208 WriteInterfaceToken(data);
209 data.WriteString(STRING_BUNDLE_NAME);
210
211 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
212 static_cast<uint32_t>(IAmsMgr::Message::DETACH_APP_DEBUG), data, reply, option);
213 EXPECT_EQ(result, NO_ERROR);
214 }
215
216 /**
217 * @tc.name: HandleDetachAppDebug_0200
218 * @tc.desc: Handle detach app, check empty bundle name.
219 * @tc.type: FUNC
220 */
221 HWTEST_F(AmsMgrStubTest, HandleDetachAppDebug_0200, TestSize.Level1)
222 {
223 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
224 EXPECT_CALL(*mockAmsMgrScheduler_, DetachAppDebug(_)).Times(0);
225 MessageParcel data;
226 MessageParcel reply;
227 MessageOption option(MessageOption::TF_ASYNC);
228 WriteInterfaceToken(data);
229 data.WriteString(EMPTY_BUNDLE_NAME);
230
231 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
232 static_cast<uint32_t>(IAmsMgr::Message::DETACH_APP_DEBUG), data, reply, option);
233 EXPECT_EQ(result, ERR_INVALID_VALUE);
234 }
235
236 /**
237 * @tc.name: HandleRegisterAbilityDebugResponse_0100
238 * @tc.desc: Handle register ability debug response.
239 * @tc.type: FUNC
240 */
241 HWTEST_F(AmsMgrStubTest, HandleRegisterAbilityDebugResponse_0100, TestSize.Level1)
242 {
243 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
244 MessageParcel data;
245 MessageParcel reply;
246 MessageOption option(MessageOption::TF_ASYNC);
247 WriteInterfaceToken(data);
248 EXPECT_NE(response_, nullptr);
249 data.WriteRemoteObject(response_);
250
251 EXPECT_CALL(*mockAmsMgrScheduler_, RegisterAbilityDebugResponse(_)).Times(1);
252 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
253 static_cast<uint32_t>(IAmsMgr::Message::REGISTER_ABILITY_DEBUG_RESPONSE), data, reply, option);
254 EXPECT_EQ(result, NO_ERROR);
255 }
256
257 /**
258 * @tc.name: HandleRegisterAbilityDebugResponse_0200
259 * @tc.desc: Handle register ability debug response, check nullptr response.
260 * @tc.type: FUNC
261 */
262 HWTEST_F(AmsMgrStubTest, HandleRegisterAbilityDebugResponse_0200, TestSize.Level1)
263 {
264 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
265 MessageParcel data;
266 MessageParcel reply;
267 MessageOption option(MessageOption::TF_ASYNC);
268 response_ = nullptr;
269 WriteInterfaceToken(data);
270 data.WriteRemoteObject(response_);
271
272 EXPECT_CALL(*mockAmsMgrScheduler_, RegisterAbilityDebugResponse(_)).Times(0);
273 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
274 static_cast<uint32_t>(IAmsMgr::Message::REGISTER_ABILITY_DEBUG_RESPONSE), data, reply, option);
275 EXPECT_EQ(result, ERR_INVALID_VALUE);
276 }
277
278 /**
279 * @tc.name: NotifyAppMgrRecordExitReason_0100
280 * @tc.desc: NotifyAppMgrRecordExitReason.
281 * @tc.type: FUNC
282 */
283 HWTEST_F(AmsMgrStubTest, NotifyAppMgrRecordExitReason_0100, TestSize.Level1)
284 {
285 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
286 MessageParcel data;
287 MessageParcel reply;
288 MessageOption option(MessageOption::TF_SYNC);
289 WriteInterfaceToken(data);
290
291 int32_t reason = 0;
292 int32_t pid = 1;
293 std::string exitMsg = "JsError";
294 data.WriteInt32(reason);
295 data.WriteInt32(pid);
296 data.WriteString16(Str8ToStr16(exitMsg));
297
298 EXPECT_CALL(*mockAmsMgrScheduler_, NotifyAppMgrRecordExitReason(_, _, _))
299 .Times(1)
300 .WillOnce(Return(NO_ERROR));
301 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
302 static_cast<uint32_t>(IAmsMgr::Message::NOTIFY_APP_MGR_RECORD_EXIT_REASON), data, reply, option);
303 EXPECT_EQ(result, NO_ERROR);
304 }
305
306 /**
307 * @tc.name: HandlePreloadApplicationByPhase_0100
308 * @tc.desc: Handle preload application with valid parameters.
309 * @tc.type: FUNC
310 */
311 HWTEST_F(AmsMgrStubTest, HandlePreloadApplicationByPhase_0100, TestSize.Level1)
312 {
313 TAG_LOGI(AAFwkTag::TEST, "HandlePreloadApplicationByPhase_0100 start.");
314 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
315 MessageParcel data;
316 MessageParcel reply;
317 MessageOption option;
318 WriteInterfaceToken(data);
319
320 std::string bundleName = "com.example.bundle";
321 int32_t userId = 100;
322 int32_t appIndex = 1;
323 int32_t preloadPhase = static_cast<int32_t>(PreloadPhase::PROCESS_CREATED);
324 data.WriteString(bundleName);
325 data.WriteInt32(userId);
326 data.WriteInt32(appIndex);
327 data.WriteInt32(preloadPhase);
328
329 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
330 static_cast<uint32_t>(IAmsMgr::Message::PRELOAD_APPLICATION_BY_PHASE), data, reply, option);
331 EXPECT_EQ(result, NO_ERROR);
332 TAG_LOGI(AAFwkTag::TEST, "HandlePreloadApplicationByPhase_0100 end.");
333 }
334
335 /**
336 * @tc.name: HandleNotifyPreloadAbilityStateChanged_0100
337 * @tc.desc: HandleNotifyPreloadAbilityStateChanged.
338 * @tc.type: FUNC
339 */
340 HWTEST_F(AmsMgrStubTest, HandleNotifyPreloadAbilityStateChanged_0100, TestSize.Level1)
341 {
342 TAG_LOGI(AAFwkTag::TEST, "HandleNotifyPreloadAbilityStateChanged_0100 start.");
343 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
344 MessageParcel data;
345 MessageParcel reply;
346 MessageOption option;
347 WriteInterfaceToken(data);
348
349 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
350 static_cast<uint32_t>(IAmsMgr::Message::NOTIFY_PRELOAD_ABILITY_STATE_CHANGED), data, reply, option);
351 EXPECT_EQ(result, AAFwk::INVALID_CALLER_TOKEN);
352 TAG_LOGI(AAFwkTag::TEST, "HandleNotifyPreloadAbilityStateChanged_0100 end.");
353 }
354
355 /**
356 * @tc.name: HandleNotifyPreloadAbilityStateChanged_0200
357 * @tc.desc: HandleNotifyPreloadAbilityStateChanged.
358 * @tc.type: FUNC
359 */
360 HWTEST_F(AmsMgrStubTest, HandleNotifyPreloadAbilityStateChanged_0200, TestSize.Level1)
361 {
362 TAG_LOGI(AAFwkTag::TEST, "HandleNotifyPreloadAbilityStateChanged_0100 start.");
363 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
364 MessageParcel data;
365 MessageParcel reply;
366 MessageOption option;
367 WriteInterfaceToken(data);
368
369 sptr<MockAbilityToken> token = new (std::nothrow) MockAbilityToken();
370 data.WriteRemoteObject(token);
371
372 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
373 static_cast<uint32_t>(IAmsMgr::Message::NOTIFY_PRELOAD_ABILITY_STATE_CHANGED), data, reply, option);
374 EXPECT_EQ(result, NO_ERROR);
375 TAG_LOGI(AAFwkTag::TEST, "HandleNotifyPreloadAbilityStateChanged_0200 end.");
376 }
377
378 /**
379 * @tc.name: HandleCheckPreloadAppRecordExist_0100
380 * @tc.desc: HandleCheckPreloadAppRecordExist.
381 * @tc.type: FUNC
382 */
383 HWTEST_F(AmsMgrStubTest, HandleCheckPreloadAppRecordExist_0100, TestSize.Level1)
384 {
385 TAG_LOGI(AAFwkTag::TEST, "HandleCheckPreloadAppRecordExist_0100 start.");
386 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
387 MessageParcel data;
388 MessageParcel reply;
389 MessageOption option;
390 WriteInterfaceToken(data);
391
392 std::string bundleName = "testBundle";
393 int32_t userId = 100;
394 int32_t appIndex = 0;
395 data.WriteString(bundleName);
396 data.WriteInt32(userId);
397 data.WriteInt32(appIndex);
398
399 EXPECT_CALL(*mockAmsMgrScheduler_, CheckPreloadAppRecordExist(_, _, _, _))
400 .Times(1)
401 .WillOnce(Return(ERR_INVALID_VALUE));
402 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
403 static_cast<uint32_t>(IAmsMgr::Message::CHECK_PRELOAD_APP_RECORD_EXIST), data, reply, option);
404 EXPECT_EQ(result, NO_ERROR);
405 TAG_LOGI(AAFwkTag::TEST, "HandleCheckPreloadAppRecordExist_0100 end.");
406 }
407
408 /**
409 * @tc.name: HandleCheckPreloadAppRecordExist_0200
410 * @tc.desc: HandleCheckPreloadAppRecordExist.
411 * @tc.type: FUNC
412 */
413 HWTEST_F(AmsMgrStubTest, HandleCheckPreloadAppRecordExist_0200, TestSize.Level1)
414 {
415 TAG_LOGI(AAFwkTag::TEST, "HandleCheckPreloadAppRecordExist_0200 start.");
416 EXPECT_NE(mockAmsMgrScheduler_, nullptr);
417 MessageParcel data;
418 MessageParcel reply;
419 MessageOption option;
420 WriteInterfaceToken(data);
421
422 std::string bundleName = "testBundle";
423 int32_t userId = 100;
424 int32_t appIndex = 0;
425 data.WriteString(bundleName);
426 data.WriteInt32(userId);
427 data.WriteInt32(appIndex);
428
429 EXPECT_CALL(*mockAmsMgrScheduler_, CheckPreloadAppRecordExist(_, _, _, _))
430 .Times(1)
431 .WillOnce(Return(NO_ERROR));
432 auto result = mockAmsMgrScheduler_->OnRemoteRequest(
433 static_cast<uint32_t>(IAmsMgr::Message::CHECK_PRELOAD_APP_RECORD_EXIST), data, reply, option);
434 EXPECT_EQ(result, NO_ERROR);
435 TAG_LOGI(AAFwkTag::TEST, "HandleCheckPreloadAppRecordExist_0200 end.");
436 }
437 } // namespace AppExecFwk
438 } // namespace OHOS
439