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 <gtest/gtest.h>
17 #include <memory>
18
19 #define private public
20 #define protected public
21 #include "ability_connect_manager.h"
22 #undef private
23 #undef protected
24
25 #include "ability_config.h"
26 #include "ability_manager_errors.h"
27 #include "ability_scheduler.h"
28 #include "ability_util.h"
29 #include "bundlemgr/mock_bundle_manager.h"
30 #include "hilog_tag_wrapper.h"
31 #include "mock_ability_connect_callback.h"
32 #include "mock_sa_call.h"
33 #include "mock_task_handler_wrap.h"
34 #include "sa_mgr_client.h"
35 #include "system_ability_definition.h"
36 #include "session/host/include/session.h"
37 #include <thread>
38 #include <chrono>
39
40 using namespace testing::ext;
41 using namespace OHOS::AppExecFwk;
42 using testing::_;
43 using testing::Invoke;
44 using testing::Return;
45 using testing::SetArgReferee;
46 using ::testing::DoAll;
47
48 namespace {
49 const std::string PARAM_RESV_CALLER_APP_ID("ohos.aafwk.param.callerAppId");
50 }
51
52 namespace OHOS {
53 namespace AAFwk {
54 class AbilityConnectManagerTest : public testing::Test {
55 public:
56 static void SetUpTestCase(void);
57 static void TearDownTestCase(void);
58 void SetUp();
59 void TearDown();
60
61 AbilityConnectManager* ConnectManager() const;
62 std::shared_ptr<MockTaskHandlerWrap> TaskHandler() const;
63 std::shared_ptr<EventHandlerWrap> EventHandler() const;
64
65 AbilityRequest GenerateAbilityRequest(const std::string& deviceName, const std::string& abilityName,
66 const std::string& appName, const std::string& bundleName, const std::string& moduleName);
67
68 sptr<SessionInfo> MockSessionInfo(int32_t persistentId);
69 std::shared_ptr<AbilityRecord> InitAbilityRecord();
70 std::shared_ptr<MockTaskHandlerWrap> taskHandler_;
71 protected:
72 AbilityRequest abilityRequest_{};
73 AbilityRequest abilityRequest1_{};
74 AbilityRequest abilityRequest2_{};
75 std::shared_ptr<AbilityRecord> serviceRecord_{ nullptr };
76 std::shared_ptr<AbilityRecord> serviceRecord1_{ nullptr };
77 std::shared_ptr<AbilityRecord> serviceRecord2_{ nullptr };
78 OHOS::sptr<Token> serviceToken_{ nullptr };
79 OHOS::sptr<Token> serviceToken1_{ nullptr };
80 OHOS::sptr<Token> serviceToken2_{ nullptr };
81 OHOS::sptr<IAbilityConnection> callbackA_{ nullptr };
82 OHOS::sptr<IAbilityConnection> callbackB_{ nullptr };
83
84 private:
85 std::shared_ptr<AbilityConnectManager> connectManager_;
86 std::shared_ptr<EventHandlerWrap> eventHandler_;
87 };
88
GenerateAbilityRequest(const std::string & deviceName,const std::string & abilityName,const std::string & appName,const std::string & bundleName,const std::string & moduleName)89 AbilityRequest AbilityConnectManagerTest::GenerateAbilityRequest(const std::string& deviceName,
90 const std::string& abilityName, const std::string& appName, const std::string& bundleName,
91 const std::string& moduleName)
92 {
93 ElementName element(deviceName, bundleName, abilityName, moduleName);
94 Want want;
95 want.SetElement(element);
96
97 AbilityInfo abilityInfo;
98 abilityInfo.visible = true;
99 abilityInfo.applicationName = appName;
100 abilityInfo.type = AbilityType::SERVICE;
101 abilityInfo.name = abilityName;
102 abilityInfo.bundleName = bundleName;
103 abilityInfo.moduleName = moduleName;
104 abilityInfo.deviceId = deviceName;
105 ApplicationInfo appinfo;
106 appinfo.name = appName;
107 abilityInfo.applicationInfo = appinfo;
108 AbilityRequest abilityRequest;
109 abilityRequest.want = want;
110 abilityRequest.abilityInfo = abilityInfo;
111 abilityRequest.appInfo = appinfo;
112 abilityInfo.process = bundleName;
113
114 return abilityRequest;
115 }
116
MockSessionInfo(int32_t persistentId)117 sptr<SessionInfo> AbilityConnectManagerTest::MockSessionInfo(int32_t persistentId)
118 {
119 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
120 if (!sessionInfo) {
121 TAG_LOGE(AAFwkTag::TEST, "sessionInfo is nullptr");
122 return nullptr;
123 }
124 sessionInfo->persistentId = persistentId;
125 return sessionInfo;
126 }
127
InitAbilityRecord()128 std::shared_ptr<AbilityRecord> AbilityConnectManagerTest::InitAbilityRecord()
129 {
130 AbilityRequest abilityRequest;
131 abilityRequest.appInfo.bundleName = "com.example.unittest";
132 abilityRequest.abilityInfo.name = "MainAbility";
133 abilityRequest.abilityInfo.type = AbilityType::PAGE;
134 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
135 return abilityRecord;
136 }
137
SetUpTestCase(void)138 void AbilityConnectManagerTest::SetUpTestCase(void)
139 {}
140
TearDownTestCase(void)141 void AbilityConnectManagerTest::TearDownTestCase(void)
142 {}
143
SetUp(void)144 void AbilityConnectManagerTest::SetUp(void)
145 {
146 connectManager_ = std::make_unique<AbilityConnectManager>(0);
147 taskHandler_ = MockTaskHandlerWrap::CreateQueueHandler("AbilityConnectManagerTest");
148 eventHandler_ = std::make_shared<EventHandlerWrap>(taskHandler_);
149 // generate ability request
150 std::string deviceName = "device";
151 std::string abilityName = "ServiceAbility";
152 std::string appName = "hiservcie";
153 std::string bundleName = "com.ix.hiservcie";
154 std::string moduleName = "entry";
155 abilityRequest_ = GenerateAbilityRequest(deviceName, abilityName, appName, bundleName, moduleName);
156 serviceRecord_ = AbilityRecord::CreateAbilityRecord(abilityRequest_);
157 serviceToken_ = serviceRecord_->GetToken();
158 std::string deviceName1 = "device";
159 std::string abilityName1 = "musicServiceAbility";
160 std::string appName1 = "musicservcie";
161 std::string bundleName1 = "com.ix.musicservcie";
162 std::string moduleName1 = "entry";
163 abilityRequest1_ = GenerateAbilityRequest(deviceName1, abilityName1, appName1, bundleName1, moduleName1);
164 serviceRecord1_ = AbilityRecord::CreateAbilityRecord(abilityRequest1_);
165 std::string deviceName2 = "device";
166 std::string abilityName2 = "residentServiceAbility";
167 std::string appName2 = "residentservcie";
168 std::string bundleName2 = "com.ix.residentservcie";
169 std::string moduleName2 = "entry";
170 abilityRequest2_ = GenerateAbilityRequest(deviceName2, abilityName2, appName2, bundleName2, moduleName2);
171 serviceRecord2_ = AbilityRecord::CreateAbilityRecord(abilityRequest2_);
172 serviceToken2_ = serviceRecord_->GetToken();
173 serviceToken1_ = serviceRecord_->GetToken();
174 callbackA_ = new AbilityConnectCallback();
175 callbackB_ = new AbilityConnectCallback();
176 }
177
TearDown(void)178 void AbilityConnectManagerTest::TearDown(void)
179 {
180 // reset the callback count
181 AbilityConnectCallback::onAbilityConnectDoneCount = 0;
182 AbilityConnectCallback::onAbilityDisconnectDoneCount = 0;
183 serviceRecord_ = nullptr;
184 }
185
ConnectManager() const186 AbilityConnectManager* AbilityConnectManagerTest::ConnectManager() const
187 {
188 return connectManager_.get();
189 }
190
TaskHandler() const191 std::shared_ptr<MockTaskHandlerWrap> AbilityConnectManagerTest::TaskHandler() const
192 {
193 return taskHandler_;
194 }
195
EventHandler() const196 std::shared_ptr<EventHandlerWrap> AbilityConnectManagerTest::EventHandler() const
197 {
198 return eventHandler_;
199 }
200
201 /*
202 * Feature: AbilityConnectManager
203 * Function: GetUIExtensionBySessionInfo
204 */
205 HWTEST_F(AbilityConnectManagerTest, GetUIExtensionBySessionInfo_001, TestSize.Level1)
206 {
207 TAG_LOGI(AAFwkTag::TEST, "GetUIExtensionBySessionInfo_001 start");
208 std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
209 EXPECT_NE(connectManager, nullptr);
210 connectManager->uiExtensionMap_.clear();
211 Rosen::SessionInfo info;
212 sptr<SessionInfo> sessionInfo(new SessionInfo());
213 sessionInfo->sessionToken = new Rosen::Session(info);
214 auto service = connectManager->GetUIExtensionBySessionInfo(sessionInfo);
215 std::string device = "device";
216 std::string abilityName1 = "uiExtensionAbility1";
217 std::string appName1 = "uiExtensionProvider1";
218 std::string bundleName1 = "com.ix.uiExtensionProvider1";
219 std::string moduleName1 = "entry";
220 auto request1 = GenerateAbilityRequest(device, abilityName1, appName1, bundleName1, moduleName1);
221 auto uiExtension1 = AbilityRecord::CreateAbilityRecord(request1);
222 EXPECT_NE(uiExtension1, nullptr);
223 uiExtension1->abilityInfo_.extensionAbilityType = ExtensionAbilityType::SYS_COMMON_UI;
224 uiExtension1 = nullptr;
225 connectManager->uiExtensionMap_.emplace(
226 sessionInfo->sessionToken, AbilityConnectManager::UIExtWindowMapValType(uiExtension1, sessionInfo));
227 service = connectManager->GetUIExtensionBySessionInfo(sessionInfo);
228 EXPECT_EQ(service, nullptr);
229 TAG_LOGI(AAFwkTag::TEST, "GetUIExtensionBySessionInfo_001 end");
230 }
231
232 /*
233 * Feature: AbilityConnectManager
234 * Function: GetUIExtensionBySessionInfo
235 */
236 HWTEST_F(AbilityConnectManagerTest, GetUIExtensionBySessionInfo_002, TestSize.Level1)
237 {
238 TAG_LOGI(AAFwkTag::TEST, "GetUIExtensionBySessionInfo_002 start");
239 std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
240 EXPECT_NE(connectManager, nullptr);
241 connectManager->uiExtensionMap_.clear();
242 Rosen::SessionInfo info;
243 sptr<SessionInfo> sessionInfo(new SessionInfo());
244 sessionInfo->sessionToken = new Rosen::Session(info);
245 sessionInfo->callerToken = new Rosen::Session(info);
246 std::string device = "device";
247 std::string abilityName1 = "uiExtensionAbility1";
248 std::string appName1 = "uiExtensionProvider1";
249 std::string bundleName1 = "com.ix.uiExtensionProvider1";
250 std::string moduleName1 = "entry";
251 auto request1 = GenerateAbilityRequest(device, abilityName1, appName1, bundleName1, moduleName1);
252 auto uiExtension1 = AbilityRecord::CreateAbilityRecord(request1);
253 EXPECT_NE(uiExtension1, nullptr);
254 uiExtension1->abilityInfo_.extensionAbilityType = ExtensionAbilityType::SYS_COMMON_UI;
255 Rosen::SessionInfo infos;
256 sptr<SessionInfo> sessionInfo1(new SessionInfo());
257 sessionInfo1 = nullptr;
258 connectManager->uiExtensionMap_.emplace(
259 sessionInfo->sessionToken, AbilityConnectManager::UIExtWindowMapValType(uiExtension1, sessionInfo1));
260 auto service = connectManager->GetUIExtensionBySessionInfo(sessionInfo);
261 EXPECT_EQ(service, nullptr);
262 TAG_LOGI(AAFwkTag::TEST, "GetUIExtensionBySessionInfo_002 end");
263 }
264
265 /*
266 * Feature: AbilityConnectManager
267 * Function: GetUIExtensionBySessionInfo
268 */
269 HWTEST_F(AbilityConnectManagerTest, GetUIExtensionBySessionInfo_003, TestSize.Level1)
270 {
271 TAG_LOGI(AAFwkTag::TEST, "GetUIExtensionBySessionInfo_003 start");
272 std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
273 EXPECT_NE(connectManager, nullptr);
274 connectManager->uiExtensionMap_.clear();
275 Rosen::SessionInfo info;
276 sptr<SessionInfo> sessionInfo(new SessionInfo());
277 sessionInfo->sessionToken = new Rosen::Session(info);
278 sessionInfo->callerToken = new Rosen::Session(info);
279 std::string device = "device";
280 std::string abilityName1 = "uiExtensionAbility1";
281 std::string appName1 = "uiExtensionProvider1";
282 std::string bundleName1 = "com.ix.uiExtensionProvider1";
283 std::string moduleName1 = "entry";
284 auto request1 = GenerateAbilityRequest(device, abilityName1, appName1, bundleName1, moduleName1);
285 auto uiExtension1 = AbilityRecord::CreateAbilityRecord(request1);
286 EXPECT_NE(uiExtension1, nullptr);
287 uiExtension1->abilityInfo_.extensionAbilityType = ExtensionAbilityType::SYS_COMMON_UI;
288
289 Rosen::SessionInfo infos;
290 sptr<SessionInfo> sessionInfo1(new SessionInfo());
291 sessionInfo1->sessionToken = new Rosen::Session(info);
292 sessionInfo1->callerToken = uiExtension1->GetToken();
293 connectManager->uiExtensionMap_.emplace(
294 sessionInfo->sessionToken, AbilityConnectManager::UIExtWindowMapValType(uiExtension1, sessionInfo1));
295 auto service = connectManager->GetUIExtensionBySessionInfo(sessionInfo);
296 EXPECT_EQ(service, nullptr);
297 TAG_LOGI(AAFwkTag::TEST, "GetUIExtensionBySessionInfo_003 end");
298 }
299
300 /*
301 * Feature: AbilityConnectManager
302 * Function: GetUIExtensionBySessionInfo
303 */
304 HWTEST_F(AbilityConnectManagerTest, GetUIExtensionBySessionInfo_004, TestSize.Level1)
305 {
306 TAG_LOGI(AAFwkTag::TEST, "GetUIExtensionBySessionInfo_004 start");
307 std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
308 EXPECT_NE(connectManager, nullptr);
309 connectManager->uiExtensionMap_.clear();
310 Rosen::SessionInfo info;
311 sptr<SessionInfo> sessionInfo(new SessionInfo());
312 sessionInfo->sessionToken = new Rosen::Session(info);
313 std::string device = "device";
314 std::string abilityName1 = "uiExtensionAbility1";
315 std::string appName1 = "uiExtensionProvider1";
316 std::string bundleName1 = "com.ix.uiExtensionProvider1";
317 std::string moduleName1 = "entry";
318 auto request1 = GenerateAbilityRequest(device, abilityName1, appName1, bundleName1, moduleName1);
319 auto uiExtension1 = AbilityRecord::CreateAbilityRecord(request1);
320 EXPECT_NE(uiExtension1, nullptr);
321 uiExtension1->abilityInfo_.extensionAbilityType = ExtensionAbilityType::SYS_COMMON_UI;
322 Rosen::SessionInfo infos;
323 sptr<SessionInfo> sessionInfo1(new SessionInfo());
324 sessionInfo1->sessionToken = uiExtension1->GetToken();
325 sessionInfo1->callerToken = new Rosen::Session(info);
326 connectManager->uiExtensionMap_.emplace(
327 sessionInfo->sessionToken, AbilityConnectManager::UIExtWindowMapValType(uiExtension1, sessionInfo1));
328 auto service = connectManager->GetUIExtensionBySessionInfo(sessionInfo);
329 EXPECT_EQ(service, nullptr);
330 TAG_LOGI(AAFwkTag::TEST, "GetUIExtensionBySessionInfo_004 end");
331 }
332
333 /*
334 * Feature: AbilityConnectManager
335 * Function: HandleActiveAbility
336 */
337 HWTEST_F(AbilityConnectManagerTest, HandleActiveAbility_001, TestSize.Level1)
338 {
339 TAG_LOGI(AAFwkTag::TEST, "HandleActiveAbility_001 start");
340 std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
341 std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
342 AbilityRequest abilityRequest;
343 sptr<IRemoteObject> callerToken = abilityRecord->GetToken();
344 OHOS::sptr<IAbilityConnection> callback1 = new AbilityConnectCallback();
345 std::shared_ptr<ConnectionRecord> connectRecord =
346 std::make_shared<ConnectionRecord>(callerToken, abilityRecord, callback1, nullptr);
347 std::shared_ptr<AbilityRecord> targetService = nullptr;
348 connectManager->HandleActiveAbility(targetService, connectRecord);
349 abilityRecord->abilityInfo_.extensionAbilityType = AppExecFwk::ExtensionAbilityType::UI_SERVICE;
350 Want want;
351 want.SetParam(PARAM_RESV_CALLER_APP_ID, std::string("app"));
352 abilityRecord->SetWant(want);
353 EXPECT_EQ(abilityRecord->GetWant().GetStringParam(PARAM_RESV_CALLER_APP_ID), "app");
354 TAG_LOGI(AAFwkTag::TEST, "HandleActiveAbility_001 end");
355 }
356
357 /*
358 * Feature: AbilityConnectManager
359 * Function: HandleActiveAbility
360 */
361 HWTEST_F(AbilityConnectManagerTest, HandleActiveAbility_002, TestSize.Level1)
362 {
363 TAG_LOGI(AAFwkTag::TEST, "HandleActiveAbility_002 start");
364 std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
365 EXPECT_NE(connectManager, nullptr);
366 auto result = connectManager->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
367 EXPECT_EQ(0, result);
368 auto connectMap = connectManager->connectMap_;
369 auto connectRecordList = connectMap.at(callbackA_->AsObject());
370 EXPECT_EQ(1, static_cast<int>(connectRecordList.size()));
371 auto elementName = abilityRequest_.want.GetElement();
372 auto elementNameUri = elementName.GetURI();
373 auto serviceMap = connectManager->GetServiceMap();
374 std::shared_ptr<AbilityRecord> abilityRecord = serviceMap.at(elementNameUri);
375 //AbilityRequest abilityRequest;
376 sptr<IRemoteObject> callerToken = abilityRecord->GetToken();
377 Want want;
378 want.SetParam(PARAM_RESV_CALLER_APP_ID, std::string("app"));
379 abilityRecord->SetWant(want);
380 OHOS::sptr<IAbilityConnection> callback1 = new AbilityConnectCallback();
381 auto connectRecord = std::make_shared<ConnectionRecord>(callerToken, abilityRecord, callback1, nullptr);
382 abilityRecord->abilityInfo_.extensionAbilityType = AppExecFwk::ExtensionAbilityType::UI;
383 connectManager->HandleActiveAbility(abilityRecord, connectRecord);
384 EXPECT_EQ(abilityRecord->GetWant().GetStringParam(PARAM_RESV_CALLER_APP_ID), "app"); // no remove signatureInfo
385 TAG_LOGI(AAFwkTag::TEST, "HandleActiveAbility_002 end");
386 }
387
388 /*
389 * Feature: AbilityConnectManager
390 * Function: HandleActiveAbility
391 */
392 HWTEST_F(AbilityConnectManagerTest, HandleActiveAbility_003, TestSize.Level1)
393 {
394 TAG_LOGI(AAFwkTag::TEST, "HandleActiveAbility_003 start");
395 std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
396 EXPECT_NE(connectManager, nullptr);
397
398 auto result = connectManager->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
399 EXPECT_EQ(0, result);
400
401 result = connectManager->ConnectAbilityLocked(abilityRequest_, callbackB_, nullptr);
402 EXPECT_EQ(0, result);
403
404 auto connectMap = connectManager->connectMap_;
405 auto connectRecordList = connectMap.at(callbackA_->AsObject());
406 EXPECT_EQ(1, static_cast<int>(connectRecordList.size()));
407
408 connectRecordList = connectMap.at(callbackB_->AsObject());
409 EXPECT_EQ(1, static_cast<int>(connectRecordList.size()));
410
411 auto elementName = abilityRequest_.want.GetElement();
412 std::string elementNameUri = elementName.GetURI();
413 auto serviceMap = connectManager->GetServiceMap();
414 auto abilityRecord = serviceMap.at(elementNameUri);
415 connectRecordList = abilityRecord->GetConnectRecordList();
416 EXPECT_EQ(2, static_cast<int>(connectRecordList.size()));
417 //AbilityRequest abilityRequest;
418 sptr<IRemoteObject> callerToken = abilityRecord->GetToken();
419 OHOS::sptr<IAbilityConnection> callback1 = new AbilityConnectCallback();
420 auto connectRecord = std::make_shared<ConnectionRecord>(callerToken, abilityRecord, callback1, nullptr);
421 auto mockTaskHandler = MockTaskHandlerWrap::CreateQueueHandler("HandleActiveAbility003");
422 EXPECT_CALL(*mockTaskHandler, SubmitTaskInner(_, _)).Times(0);
423 connectManager->taskHandler_ = mockTaskHandler;
424 abilityRecord->connRemoteObject_ = abilityRecord->GetToken();
425 connectManager->HandleActiveAbility(abilityRecord, connectRecord);
426 TAG_LOGI(AAFwkTag::TEST, "HandleActiveAbility_003 end");
427 }
428 } // namespace AAFwk
429 } // namespace OHOS
430