1 /*
2 * Copyright (c) 2022-2025 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 "UTTest_device_manager_service_impl_first.h"
17 #include "softbus_error_code.h"
18 #include "common_event_support.h"
19 #include "deviceprofile_connector.h"
20 #include "distributed_device_profile_client.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24 using namespace OHOS::DistributedDeviceProfile;
25 namespace OHOS {
26 namespace DistributedHardware {
SetUp()27 void DeviceManagerServiceImplFirstTest::SetUp()
28 {
29 if (deviceManagerServiceImpl_ == nullptr) {
30 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
31 }
32 deviceManagerServiceImpl_->Initialize(listener_);
33 }
34
TearDown()35 void DeviceManagerServiceImplFirstTest::TearDown()
36 {
37 }
38
SetUpTestCase()39 void DeviceManagerServiceImplFirstTest::SetUpTestCase()
40 {
41 DmDeviceProfileConnector::dmDeviceProfileConnector = deviceProfileConnectorMock_;
42 DmMultipleUserConnector::dmMultipleUserConnector = multipleUserConnectorMock_;
43 DmSoftbusConnector::dmSoftbusConnector = softbusConnectorMock_;
44 DmDmDeviceStateManager::dmDeviceStateManager = dmDeviceStateManagerMock_;
45 DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl = deviceManagerServiceImplMock_;
46 DmHiChainConnector::dmHiChainConnector = hiChainConnectorMock_;
47 }
48
TearDownTestCase()49 void DeviceManagerServiceImplFirstTest::TearDownTestCase()
50 {
51 DmDeviceProfileConnector::dmDeviceProfileConnector = nullptr;
52 deviceProfileConnectorMock_ = nullptr;
53 DmMultipleUserConnector::dmMultipleUserConnector = nullptr;
54 multipleUserConnectorMock_ = nullptr;
55 DmSoftbusConnector::dmSoftbusConnector = nullptr;
56 softbusConnectorMock_ = nullptr;
57 DmDmDeviceStateManager::dmDeviceStateManager = nullptr;
58 dmDeviceStateManagerMock_ = nullptr;
59 DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl = nullptr;
60 deviceManagerServiceImplMock_ = nullptr;
61 DmHiChainConnector::dmHiChainConnector = nullptr;
62 hiChainConnectorMock_ = nullptr;
63 }
64
65 namespace {
66 HWTEST_F(DeviceManagerServiceImplFirstTest, GetDeviceIdAndUserId_101, testing::ext::TestSize.Level1)
67 {
68 int32_t userId = 1;
69 std::string accountId = "accountId";
70 auto ret = deviceManagerServiceImpl_->GetDeviceIdAndUserId(userId, accountId);
71 EXPECT_TRUE(ret.empty());
72
73 ret = deviceManagerServiceImpl_->GetDeviceIdAndUserId(userId);
74 EXPECT_TRUE(ret.empty());
75
76 std::string localUdid = "deviceId";
77 int32_t localUserId = 123456;
78 std::string peerUdid = "remoteUdid";
79 int32_t peerUserId = 1;
80 EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAclForAccountLogOut(_, _, _)).WillOnce(Return(true));
81 if (deviceManagerServiceImpl_->softbusConnector_ == nullptr) {
82 deviceManagerServiceImpl_->Initialize(listener_);
83 }
84
85 if (deviceManagerServiceImpl_->deviceStateMgr_ == nullptr) {
86 deviceManagerServiceImpl_->Initialize(listener_);
87 }
88 DMAclQuadInfo info = {localUdid, localUserId, peerUdid, peerUserId};
89 std::string accoutId = "accountId";
90 deviceManagerServiceImpl_->HandleIdentAccountLogout(info, accoutId);
91
92 std::vector<uint32_t> foregroundUserIds;
93 std::vector<uint32_t> backgroundUserIds;
94 std::string remoteUdid = "deviceId";
95 EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(_)).WillOnce(Return(ERR_DM_FAILED));
96 deviceManagerServiceImpl_->HandleSyncUserIdEvent(foregroundUserIds, backgroundUserIds, remoteUdid, false);
97
98 std::vector<int32_t> localUserIds;
99 localUserIds.push_back(101);
100 localUserIds.push_back(102);
101 EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(_))
102 .WillOnce(DoAll(SetArgReferee<0>(localUserIds), Return(DM_OK)));
103 deviceManagerServiceImpl_->HandleSyncUserIdEvent(foregroundUserIds, backgroundUserIds, remoteUdid, false);
104 }
105
106 HWTEST_F(DeviceManagerServiceImplFirstTest, CheckSharePeerSrc_001, testing::ext::TestSize.Level1)
107 {
108 std::string peerUdid = "peerUdid";
109 std::string localUdid = "localUdid";
110 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
111
112 EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile())
113 .WillOnce(Return(profiles));
114
115 bool result = deviceManagerServiceImpl_->CheckSharePeerSrc(peerUdid, localUdid);
116 EXPECT_FALSE(result);
117 }
118
119 HWTEST_F(DeviceManagerServiceImplFirstTest, CheckSharePeerSrc_002, testing::ext::TestSize.Level1)
120 {
121 std::string peerUdid = "peerUdid";
122 std::string localUdid = "localUdid";
123
124 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
125 AccessControlProfile profile;
126 profile.SetBindType(DM_SHARE);
127 profile.SetTrustDeviceId(peerUdid);
128 Accesser accesser;
129 accesser.SetAccesserDeviceId(peerUdid);
130 profile.SetAccesser(accesser);
131
132 Accessee accessee;
133 accessee.SetAccesseeDeviceId(localUdid);
134 profile.SetAccessee(accessee);
135 profiles.push_back(profile);
136
137 EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile())
138 .WillOnce(Return(profiles));
139
140 bool result = deviceManagerServiceImpl_->CheckSharePeerSrc(peerUdid, localUdid);
141 EXPECT_TRUE(result);
142 }
143
144 HWTEST_F(DeviceManagerServiceImplFirstTest, CheckSharePeerSrc_003, testing::ext::TestSize.Level1)
145 {
146 std::string peerUdid = "peerUdid";
147 std::string localUdid = "localUdid";
148
149 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
150 AccessControlProfile profile;
151 profile.SetBindType(DM_SHARE);
152 profile.SetTrustDeviceId(peerUdid);
153 Accesser accesser;
154 accesser.SetAccesserDeviceId(localUdid);
155 profile.SetAccesser(accesser);
156 profile.GetAccessee().SetAccesseeDeviceId(peerUdid);
157 profiles.push_back(profile);
158
159 EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile())
160 .WillOnce(Return(profiles));
161
162 bool result = deviceManagerServiceImpl_->CheckSharePeerSrc(peerUdid, localUdid);
163 EXPECT_FALSE(result);
164 }
165
166 HWTEST_F(DeviceManagerServiceImplFirstTest, CheckSharePeerSrc_004, testing::ext::TestSize.Level1)
167 {
168 std::string peerUdid = "peerUdid";
169 std::string localUdid = "localUdid";
170
171 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
172 AccessControlProfile profile;
173 profile.SetBindType(DM_IDENTICAL_ACCOUNT);
174 profile.SetTrustDeviceId(peerUdid);
175 Accesser accesser;
176 accesser.SetAccesserDeviceId(peerUdid);
177 profile.SetAccesser(accesser);
178 Accessee accessee;
179 accessee.SetAccesseeDeviceId(localUdid);
180 profile.SetAccessee(accessee);
181 profiles.push_back(profile);
182
183 EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile())
184 .WillOnce(Return(profiles));
185
186 bool result = deviceManagerServiceImpl_->CheckSharePeerSrc(peerUdid, localUdid);
187 EXPECT_FALSE(result);
188 }
189
190 HWTEST_F(DeviceManagerServiceImplFirstTest, CheckSharePeerSrc_005, testing::ext::TestSize.Level1)
191 {
192 std::string peerUdid = "peerUdid";
193 std::string localUdid = "localUdid";
194 std::string trustDevideId = "trustDevideId";
195
196 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
197 AccessControlProfile profile;
198 profile.SetBindType(DM_SHARE);
199 profile.SetTrustDeviceId(trustDevideId);
200 profiles.push_back(profile);
201
202 EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile())
203 .WillOnce(Return(profiles));
204
205 bool result = deviceManagerServiceImpl_->CheckSharePeerSrc(peerUdid, localUdid);
206 EXPECT_FALSE(result);
207 }
208
209 HWTEST_F(DeviceManagerServiceImplFirstTest, HandleCredentialDeleted_001, testing::ext::TestSize.Level1)
210 {
211 const char *credId = "123456";
212 const char *credInfo = "invalid_json";
213 std::string localUdid = "localUdid";
214 std::string remoteUdid;
215 bool isSendBroadCast = false;
216
217 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
218
219 EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile())
220 .WillOnce(Return(profiles));
221 EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_))
222 .Times(0);
223
224 deviceManagerServiceImpl_->HandleCredentialDeleted(credId, credInfo, localUdid, remoteUdid, isSendBroadCast);
225 }
226
227 HWTEST_F(DeviceManagerServiceImplFirstTest, HandleCredentialDeleted_002, testing::ext::TestSize.Level1)
228 {
229 const char *credId = "123456";
230 const char *credInfo = R"({"deviceId": "remoteUdid", "userId": 1})";
231 std::string localUdid = "localUdid";
232 std::string remoteUdid;
233 bool isSendBroadCast = false;
234
235 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
236 AccessControlProfile profile;
237 profile.SetBindType(DM_POINT_TO_POINT);
238 profiles.push_back(profile);
239
240 EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile())
241 .WillOnce(Return(profiles));
242 EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_)).Times(0);
243
244 deviceManagerServiceImpl_->HandleCredentialDeleted(credId, credInfo, localUdid, remoteUdid, isSendBroadCast);
245 }
246
247 HWTEST_F(DeviceManagerServiceImplFirstTest, HandleCredentialDeleted_003, testing::ext::TestSize.Level1)
248 {
249 const char *credId = "123456";
250 const char *credInfo = R"({"deviceId": "remoteUdid", "userId": 1})";
251 std::string localUdid = "localUdid";
252 std::string remoteUdid;
253 bool isSendBroadCast = false;
254
255 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
256 AccessControlProfile profile;
257 profile.SetBindType(DM_SHARE);
258
259 profile.GetAccesser().SetAccesserCredentialId(atoi(credId));
260 profile.GetAccesser().SetAccesserDeviceId(localUdid);
261 profile.GetAccessee().SetAccesseeDeviceId("remoteUdid");
262 profile.GetAccessee().SetAccesseeUserId(1);
263
264 profiles.push_back(profile);
265
266 EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile())
267 .WillOnce(Return(profiles));
268 EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_))
269 .Times(1);
270
271 deviceManagerServiceImpl_->HandleCredentialDeleted(credId, credInfo, localUdid, remoteUdid, isSendBroadCast);
272 }
273
274 HWTEST_F(DeviceManagerServiceImplFirstTest, HandleCredentialDeleted_004, testing::ext::TestSize.Level1)
275 {
276 const char *credId = "123456";
277 const char *credInfo = R"({"deviceId": "remoteUdid", "userId": 1})";
278 std::string localUdid = "localUdid";
279 std::string remoteUdid;
280 bool isSendBroadCast = false;
281
282 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
283 AccessControlProfile profile;
284 profile.SetBindType(DM_SHARE);
285
286 profile.GetAccessee().SetAccesseeCredentialId(atoi(credId));
287 profile.GetAccessee().SetAccesseeDeviceId(localUdid);
288 profile.GetAccesser().SetAccesserDeviceId("remoteUdid");
289 profile.GetAccesser().SetAccesserUserId(1);
290
291 profiles.push_back(profile);
292
293 EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile())
294 .WillOnce(Return(profiles));
295 EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_))
296 .Times(1);
297
298 deviceManagerServiceImpl_->HandleCredentialDeleted(credId, credInfo, localUdid, remoteUdid, isSendBroadCast);
299 }
300
301 HWTEST_F(DeviceManagerServiceImplFirstTest, HandleCredentialDeleted_005, testing::ext::TestSize.Level1)
302 {
303 const char *credId = "testCredId";
304 const char *credInfo = R"({"deviceId": "remoteUdid", "osAccountId": 1})";
305 std::string localUdid = "localUdid";
306 std::string remoteUdid = "remoteUdid";
307 bool isSendBroadCast = false;
308
309 EXPECT_CALL(*multipleUserConnectorMock_, GetCurrentAccountUserID()).Times(::testing::AtLeast(1))
310 .WillOnce(Return(1));
311
312 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
313 AccessControlProfile profile;
314 profile.SetBindType(DM_SHARE);
315 Accesser accesser;
316 accesser.SetAccesserCredentialIdStr(credId);
317 accesser.SetAccesserDeviceId(localUdid);
318 accesser.SetAccesserUserId(1);
319 Accessee accessee;
320 accessee.SetAccesseeUserId(1);
321 accessee.SetAccesseeDeviceId(remoteUdid);
322 profile.SetAccesser(accesser);
323 profile.SetAccessee(accessee);
324 profiles.push_back(profile);
325
326 EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile()).WillOnce(Return(profiles));
327 EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_)).Times(1);
328
329 deviceManagerServiceImpl_->HandleCredentialDeleted(credId, credInfo, localUdid, remoteUdid, isSendBroadCast);
330 EXPECT_TRUE(isSendBroadCast);
331 }
332
333 HWTEST_F(DeviceManagerServiceImplFirstTest, HandleShareUnbindBroadCast_001, testing::ext::TestSize.Level1)
334 {
335 std::string credId = "12345";
336 std::string localUdid = "localId";
337 int32_t userId = 123456;
338
339 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
340
341 EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile())
342 .WillOnce(Return(profiles));
343 EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_))
344 .Times(0);
345
346 deviceManagerServiceImpl_->HandleShareUnbindBroadCast(credId, userId, localUdid);
347 }
348
349 HWTEST_F(DeviceManagerServiceImplFirstTest, HandleShareUnbindBroadCast_002, testing::ext::TestSize.Level1)
350 {
351 std::string credId = "12345";
352 std::string localUdid = "localId";
353 int32_t userId = 123456;
354
355 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
356 AccessControlProfile profile;
357 profile.SetBindType(DM_IDENTICAL_ACCOUNT);
358 profiles.push_back(profile);
359
360 EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile())
361 .WillOnce(Return(profiles));
362 EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_))
363 .Times(0);
364
365 deviceManagerServiceImpl_->HandleShareUnbindBroadCast(credId, userId, localUdid);
366 }
367
368 HWTEST_F(DeviceManagerServiceImplFirstTest, HandleShareUnbindBroadCast_003, testing::ext::TestSize.Level1)
369 {
370 std::string credId = "12345";
371 std::string localUdid = "localId";
372 int32_t userId = 123456;
373
374 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
375 AccessControlProfile profile;
376 profile.SetBindType(DM_SHARE);
377
378 Accesser accesser;
379 accesser.SetAccesserCredentialId(atoi(credId.c_str()));
380 accesser.SetAccesserUserId(userId);
381 profile.SetAccesser(accesser);
382 Accessee accessee;
383 accessee.SetAccesseeDeviceId(localUdid);
384 profile.SetAccessee(accessee);
385
386 profiles.push_back(profile);
387
388 EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile())
389 .WillOnce(Return(profiles));
390 EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_))
391 .Times(1);
392
393 deviceManagerServiceImpl_->HandleShareUnbindBroadCast(credId, userId, localUdid);
394 }
395
396 HWTEST_F(DeviceManagerServiceImplFirstTest, HandleShareUnbindBroadCast_004, testing::ext::TestSize.Level1)
397 {
398 std::string credId = "12345";
399 std::string localUdid = "localUdid";
400 int32_t userId = 123456;
401
402 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
403 AccessControlProfile profile;
404 profile.SetBindType(DM_SHARE);
405
406 Accesser accesser;
407 accesser.SetAccesserDeviceId(localUdid);
408 profile.SetAccesser(accesser);
409 Accessee accessee;
410 accessee.SetAccesseeCredentialId(atoi(credId.c_str()));
411 accessee.SetAccesseeUserId(userId);
412 profile.SetAccessee(accessee);
413
414 profiles.push_back(profile);
415
416 EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile())
417 .WillOnce(Return(profiles));
418 EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_))
419 .Times(1);
420
421 deviceManagerServiceImpl_->HandleShareUnbindBroadCast(credId, userId, localUdid);
422 }
423
424 HWTEST_F(DeviceManagerServiceImplFirstTest, HandleShareUnbindBroadCast_005, testing::ext::TestSize.Level1)
425 {
426 std::string credId = "12345";
427 std::string localUdid = "localUdid";
428 int32_t userId = 123456;
429
430 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
431 AccessControlProfile profile;
432 profile.SetBindType(DM_SHARE);
433
434 Accesser accesser;
435 accesser.SetAccesserCredentialId(9999);
436 accesser.SetAccesserDeviceId("peer123");
437 accesser.SetAccesserUserId(1002);
438 profile.SetAccesser(accesser);
439
440 Accessee accessee;
441 accessee.SetAccesseeDeviceId("peer456");
442 accessee.SetAccesseeUserId(1003);
443 profile.SetAccessee(accessee);
444
445 profiles.push_back(profile);
446
447 EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile())
448 .WillOnce(Return(profiles));
449 EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAccessControlById(_))
450 .Times(0);
451
452 deviceManagerServiceImpl_->HandleShareUnbindBroadCast(credId, userId, localUdid);
453 }
454
455 HWTEST_F(DeviceManagerServiceImplFirstTest, SetOnlineProcessInfo_001, testing::ext::TestSize.Level1)
456 {
457 uint32_t bindType = IDENTICAL_ACCOUNT_TYPE;
458 ProcessInfo processInfo;
459 DmDeviceInfo devInfo;
460 std::string requestDeviceId = "requestDeviceId";
461 std::string trustDeviceId = "trustDeviceId";
462 DmDeviceState devState = DEVICE_STATE_ONLINE;
463
464 EXPECT_CALL(*softbusConnectorMock_, SetProcessInfo(_)).Times(1);
465 EXPECT_CALL(*dmDeviceStateManagerMock_, HandleDeviceStatusChange(_, _, _)).Times(1);
466
467 deviceManagerServiceImpl_->SetOnlineProcessInfo(
468 bindType, processInfo, devInfo, requestDeviceId, trustDeviceId, devState);
469
470 EXPECT_EQ(devInfo.authForm, DmAuthForm::IDENTICAL_ACCOUNT);
471 }
472
473 HWTEST_F(DeviceManagerServiceImplFirstTest, SetOnlineProcessInfo_002, testing::ext::TestSize.Level1)
474 {
475 uint32_t bindType = DEVICE_PEER_TO_PEER_TYPE;
476 ProcessInfo processInfo;
477 DmDeviceInfo devInfo;
478 std::string requestDeviceId = "requestDeviceId";
479 std::string trustDeviceId = "trustDeviceId";
480 DmDeviceState devState = DEVICE_STATE_ONLINE;
481
482 EXPECT_CALL(*softbusConnectorMock_, SetProcessInfo(_)).Times(1);
483 EXPECT_CALL(*dmDeviceStateManagerMock_, HandleDeviceStatusChange(_, _, _)).Times(1);
484
485 deviceManagerServiceImpl_->SetOnlineProcessInfo(
486 bindType, processInfo, devInfo, requestDeviceId, trustDeviceId, devState);
487
488 EXPECT_EQ(devInfo.authForm, DmAuthForm::PEER_TO_PEER);
489 }
490
491 HWTEST_F(DeviceManagerServiceImplFirstTest, SetOnlineProcessInfo_003, testing::ext::TestSize.Level1)
492 {
493 uint32_t bindType = DEVICE_ACROSS_ACCOUNT_TYPE;
494 ProcessInfo processInfo;
495 DmDeviceInfo devInfo;
496 std::string requestDeviceId = "requestDeviceId";
497 std::string trustDeviceId = "trustDeviceId";
498 DmDeviceState devState = DEVICE_STATE_ONLINE;
499
500 EXPECT_CALL(*softbusConnectorMock_, SetProcessInfo(_)).Times(1);
501 EXPECT_CALL(*dmDeviceStateManagerMock_, HandleDeviceStatusChange(_, _, _)).Times(1);
502
503 deviceManagerServiceImpl_->SetOnlineProcessInfo(
504 bindType, processInfo, devInfo, requestDeviceId, trustDeviceId, devState);
505
506 EXPECT_EQ(devInfo.authForm, DmAuthForm::ACROSS_ACCOUNT);
507 }
508
509 HWTEST_F(DeviceManagerServiceImplFirstTest, SetOnlineProcessInfo_004, testing::ext::TestSize.Level1)
510 {
511 uint32_t bindType = APP_PEER_TO_PEER_TYPE;
512 ProcessInfo processInfo;
513 DmDeviceInfo devInfo;
514 std::string requestDeviceId = "requestDeviceId";
515 std::string trustDeviceId = "trustDeviceId";
516 DmDeviceState devState = DEVICE_STATE_ONLINE;
517
518 std::vector<ProcessInfo> processInfoVec = {processInfo};
519 EXPECT_CALL(*deviceProfileConnectorMock_, GetProcessInfoFromAclByUserId(_, _, _))
520 .WillOnce(Return(processInfoVec));
521 EXPECT_CALL(*softbusConnectorMock_, SetProcessInfoVec(_)).Times(1);
522 EXPECT_CALL(*dmDeviceStateManagerMock_, HandleDeviceStatusChange(_, _, _)).Times(1);
523
524 deviceManagerServiceImpl_->SetOnlineProcessInfo(
525 bindType, processInfo, devInfo, requestDeviceId, trustDeviceId, devState);
526
527 EXPECT_EQ(devInfo.authForm, DmAuthForm::PEER_TO_PEER);
528 }
529
530 HWTEST_F(DeviceManagerServiceImplFirstTest, SetOnlineProcessInfo_005, testing::ext::TestSize.Level1)
531 {
532 uint32_t bindType = APP_ACROSS_ACCOUNT_TYPE;
533 ProcessInfo processInfo;
534 DmDeviceInfo devInfo;
535 std::string requestDeviceId = "requestDeviceId";
536 std::string trustDeviceId = "trustDeviceId";
537 DmDeviceState devState = DEVICE_STATE_ONLINE;
538
539 std::vector<ProcessInfo> processInfoVec = {processInfo};
540 EXPECT_CALL(*deviceProfileConnectorMock_, GetProcessInfoFromAclByUserId(_, _, _))
541 .WillOnce(Return(processInfoVec));
542 EXPECT_CALL(*softbusConnectorMock_, SetProcessInfoVec(_)).Times(1);
543 EXPECT_CALL(*dmDeviceStateManagerMock_, HandleDeviceStatusChange(_, _, _)).Times(1);
544
545 deviceManagerServiceImpl_->SetOnlineProcessInfo(
546 bindType, processInfo, devInfo, requestDeviceId, trustDeviceId, devState);
547
548 EXPECT_EQ(devInfo.authForm, DmAuthForm::ACROSS_ACCOUNT);
549 }
550
551 HWTEST_F(DeviceManagerServiceImplFirstTest, SetOnlineProcessInfo_006, testing::ext::TestSize.Level1)
552 {
553 uint32_t bindType = SHARE_TYPE;
554 ProcessInfo processInfo;
555 DmDeviceInfo devInfo;
556 std::string requestDeviceId = "requestDeviceId";
557 std::string trustDeviceId = "trustDeviceId";
558 DmDeviceState devState = DEVICE_STATE_ONLINE;
559
560 EXPECT_CALL(*deviceProfileConnectorMock_, GetAccessControlProfile())
561 .Times(1).WillOnce(Return(std::vector<DistributedDeviceProfile::AccessControlProfile>()));
562
563 EXPECT_CALL(*deviceManagerServiceImplMock_, CheckSharePeerSrc(_, _)).WillOnce(Return(false));
564 EXPECT_CALL(*softbusConnectorMock_, SetProcessInfo(_)).Times(1);
565 EXPECT_CALL(*dmDeviceStateManagerMock_, HandleDeviceStatusChange(_, _, _)).Times(1);
566
567 deviceManagerServiceImpl_->SetOnlineProcessInfo(
568 bindType, processInfo, devInfo, requestDeviceId, trustDeviceId, devState);
569
570 EXPECT_EQ(devInfo.authForm, DmAuthForm::SHARE);
571 }
572
573 HWTEST_F(DeviceManagerServiceImplFirstTest, GetDeviceIdByUserIdAndTokenId_001, testing::ext::TestSize.Level1)
574 {
575 int32_t userId = 1;
576 int32_t tokenId = 1234;
577
578 EXPECT_CALL(*deviceProfileConnectorMock_, GetDeviceIdAndUdidListByTokenId(_, _, _))
579 .WillOnce(Return(std::vector<std::string>()));
580
581 auto result = deviceManagerServiceImpl_->GetDeviceIdByUserIdAndTokenId(userId, tokenId);
582 EXPECT_TRUE(result.empty());
583 }
584
585 HWTEST_F(DeviceManagerServiceImplFirstTest, GetDeviceIdByUserIdAndTokenId_002, testing::ext::TestSize.Level1)
586 {
587 int32_t userId = 1;
588 int32_t tokenId = 1234;
589
590 std::vector<std::string> expectedDeviceIds = {"deviceId1"};
591 EXPECT_CALL(*deviceProfileConnectorMock_, GetDeviceIdAndUdidListByTokenId(_, _, _))
592 .WillOnce(Return(expectedDeviceIds));
593
594 auto result = deviceManagerServiceImpl_->GetDeviceIdByUserIdAndTokenId(userId, tokenId);
595 EXPECT_EQ(result.size(), 1);
596 EXPECT_EQ(result[0], "deviceId1");
597 }
598
599 HWTEST_F(DeviceManagerServiceImplFirstTest, GetDeviceIdByUserIdAndTokenId_003, testing::ext::TestSize.Level1)
600 {
601 int32_t userId = 1;
602 int32_t tokenId = 1234;
603
604 std::vector<std::string> expectedDeviceIds = {"deviceId1", "deviceId2"};
605 EXPECT_CALL(*deviceProfileConnectorMock_, GetDeviceIdAndUdidListByTokenId(_, _, _))
606 .WillOnce(Return(expectedDeviceIds));
607
608 auto result = deviceManagerServiceImpl_->GetDeviceIdByUserIdAndTokenId(userId, tokenId);
609 EXPECT_EQ(result.size(), 2);
610 EXPECT_NE(std::find(result.begin(), result.end(), "deviceId1"), result.end());
611 EXPECT_NE(std::find(result.begin(), result.end(), "deviceId2"), result.end());
612 }
613
614 HWTEST_F(DeviceManagerServiceImplFirstTest, ProcessAppUninstall_001, testing::ext::TestSize.Level1)
615 {
616 int32_t userId = 1001;
617 int32_t accessTokenId = 2001;
618
619 deviceManagerServiceImpl_->listener_ = nullptr;
620
621 auto result = deviceManagerServiceImpl_->ProcessAppUninstall(userId, accessTokenId);
622 EXPECT_EQ(result, ERR_DM_POINT_NULL);
623 }
624
625 HWTEST_F(DeviceManagerServiceImplFirstTest, ProcessAppUninstall_002, testing::ext::TestSize.Level1)
626 {
627 int32_t userId = 1;
628 int32_t accessTokenId = 1234;
629
630 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAclIncludeLnnAcl())
631 .WillOnce(Return(std::vector<DistributedDeviceProfile::AccessControlProfile>()));
632
633 int32_t result = deviceManagerServiceImpl_->ProcessAppUninstall(userId, accessTokenId);
634 EXPECT_EQ(result, DM_OK);
635 }
636
637 HWTEST_F(DeviceManagerServiceImplFirstTest, ProcessAppUninstall_003, testing::ext::TestSize.Level1)
638 {
639 int32_t userId = 1;
640 int32_t accessTokenId = 1234;
641
642 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
643 DistributedDeviceProfile::AccessControlProfile profile;
644 profile.GetAccesser().SetAccesserTokenId(5678);
645 profiles.push_back(profile);
646
647 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAclIncludeLnnAcl())
648 .WillOnce(Return(profiles));
649
650 int32_t result = deviceManagerServiceImpl_->ProcessAppUninstall(userId, accessTokenId);
651 EXPECT_EQ(result, DM_OK);
652 }
653
654 HWTEST_F(DeviceManagerServiceImplFirstTest, ProcessAppUninstall_004, testing::ext::TestSize.Level1)
655 {
656 int32_t userId = 1;
657 int32_t accessTokenId = 1234;
658
659 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
660 DistributedDeviceProfile::AccessControlProfile profile;
661 profile.GetAccesser().SetAccesserTokenId(accessTokenId);
662 profiles.push_back(profile);
663
664 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAclIncludeLnnAcl())
665 .WillOnce(Return(profiles));
666 EXPECT_CALL(*hiChainConnectorMock_, DeleteGroupByACL(_, _)).Times(1);
667
668 int32_t result = deviceManagerServiceImpl_->ProcessAppUninstall(userId, accessTokenId);
669 EXPECT_EQ(result, DM_OK);
670 }
671
672 HWTEST_F(DeviceManagerServiceImplFirstTest, ProcessAppUninstall_005, testing::ext::TestSize.Level1)
673 {
674 int32_t userId = 1;
675 int32_t accessTokenId = 1234;
676
677 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
678 DistributedDeviceProfile::AccessControlProfile profile;
679 profile.GetAccesser().SetAccesserTokenId(accessTokenId);
680 profiles.push_back(profile);
681
682 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAclIncludeLnnAcl())
683 .WillOnce(Return(profiles));
684 EXPECT_CALL(*deviceProfileConnectorMock_, IsLnnAcl(_)).WillRepeatedly(Return(true));
685 EXPECT_CALL(*deviceProfileConnectorMock_, CacheAcerAclId(_, _)).Times(1);
686 EXPECT_CALL(*hiChainConnectorMock_, DeleteGroupByACL(_, _)).Times(1);
687
688 int32_t result = deviceManagerServiceImpl_->ProcessAppUninstall(userId, accessTokenId);
689 EXPECT_EQ(result, DM_OK);
690 }
691
692 HWTEST_F(DeviceManagerServiceImplFirstTest, ProcessAppUninstall_006, testing::ext::TestSize.Level1)
693 {
694 int32_t userId = 1;
695 int32_t accessTokenId = 1234;
696
697 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
698 DistributedDeviceProfile::AccessControlProfile profile;
699 profile.GetAccesser().SetAccesserTokenId(accessTokenId);
700 profiles.push_back(profile);
701
702 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAclIncludeLnnAcl())
703 .WillOnce(Return(profiles));
704 EXPECT_CALL(*hiChainConnectorMock_, DeleteGroupByACL(_, _)).Times(0);
705
706 int32_t result = deviceManagerServiceImpl_->ProcessAppUninstall(userId, accessTokenId);
707 EXPECT_EQ(result, DM_OK);
708 }
709
710 HWTEST_F(DeviceManagerServiceImplFirstTest, ProcessAppUninstall_007, testing::ext::TestSize.Level1)
711 {
712 int32_t userId = 1;
713 int32_t accessTokenId = 1234;
714
715 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
716 DistributedDeviceProfile::AccessControlProfile profile;
717 profile.GetAccesser().SetAccesserTokenId(accessTokenId);
718 profiles.push_back(profile);
719
720 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAclIncludeLnnAcl())
721 .WillOnce(Return(profiles));
722 EXPECT_CALL(*deviceProfileConnectorMock_, IsLnnAcl(_)).WillRepeatedly(Return(false));
723 EXPECT_CALL(*hiChainConnectorMock_, DeleteGroupByACL(_, _)).Times(1);
724
725 int32_t result = deviceManagerServiceImpl_->ProcessAppUninstall(userId, accessTokenId);
726 EXPECT_EQ(result, DM_OK);
727 }
728
729 HWTEST_F(DeviceManagerServiceImplFirstTest, ProcessUnBindApp_001, testing::ext::TestSize.Level1)
730 {
731 int32_t userId = 1;
732 int32_t accessTokenId = 1234;
733 std::string extra = "invalid_json";
734 std::string udid = "remoteUdid";
735
736 EXPECT_CALL(*deviceManagerServiceImplMock_, HandleAppUnBindEvent(userId, udid, accessTokenId)).Times(1);
737
738 deviceManagerServiceImpl_->ProcessUnBindApp(userId, accessTokenId, extra, udid);
739 }
740
741 HWTEST_F(DeviceManagerServiceImplFirstTest, ProcessUnBindApp_002, testing::ext::TestSize.Level1)
742 {
743 int32_t userId = 1;
744 int32_t accessTokenId = 1234;
745 std::string extra = R"({"key": "value"})";
746 std::string udid = "remoteUdid";
747
748 EXPECT_CALL(*deviceManagerServiceImplMock_, HandleAppUnBindEvent(userId, udid, accessTokenId)).Times(1);
749
750 deviceManagerServiceImpl_->ProcessUnBindApp(userId, accessTokenId, extra, udid);
751 }
752
753 HWTEST_F(DeviceManagerServiceImplFirstTest, ProcessUnBindApp_003, testing::ext::TestSize.Level1)
754 {
755 int32_t userId = 1;
756 int32_t accessTokenId = 1234;
757 int32_t peerTokenId = 5678;
758 std::string extra = R"({"peerTokenId": 5678})";
759 std::string udid = "remoteUdid";
760
761 EXPECT_CALL(*deviceManagerServiceImplMock_, HandleAppUnBindEvent(userId, udid, accessTokenId, peerTokenId)).Times(1);
762
763 deviceManagerServiceImpl_->ProcessUnBindApp(userId, accessTokenId, extra, udid);
764 }
765
766 HWTEST_F(DeviceManagerServiceImplFirstTest, ProcessUnBindApp_004, testing::ext::TestSize.Level1)
767 {
768 int32_t userId = 1;
769 int32_t accessTokenId = 1234;
770 std::string extra = R"({"peerTokenId": "invalid"})";
771 std::string udid = "remoteUdid";
772
773 EXPECT_CALL(*deviceManagerServiceImplMock_, HandleAppUnBindEvent(userId, udid, accessTokenId)).Times(1);
774
775 deviceManagerServiceImpl_->ProcessUnBindApp(userId, accessTokenId, extra, udid);
776 }
777
778 HWTEST_F(DeviceManagerServiceImplFirstTest, ProcessUnBindApp_005, testing::ext::TestSize.Level1)
779 {
780 int32_t userId = 1;
781 int32_t accessTokenId = 1234;
782 std::string extra = "";
783 std::string udid = "remoteUdid";
784
785 EXPECT_CALL(*deviceManagerServiceImplMock_, HandleAppUnBindEvent(userId, udid, accessTokenId)).Times(1);
786
787 deviceManagerServiceImpl_->ProcessUnBindApp(userId, accessTokenId, extra, udid);
788 }
789
790 HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAclByTokenId_001, testing::ext::TestSize.Level1)
791 {
792 int32_t accessTokenId = 1234;
793 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
794 DistributedDeviceProfile::AccessControlProfile profile;
795 profile.GetAccesser().SetAccesserTokenId(5678);
796 profiles.push_back(profile);
797
798 std::map<int64_t, DistributedDeviceProfile::AccessControlProfile> delProfileMap;
799 std::vector<std::pair<int32_t, std::string>> delACLInfoVec;
800 std::vector<int32_t> userIdVec;
801
802 deviceManagerServiceImpl_->DeleteAclByTokenId(accessTokenId, profiles, delProfileMap, delACLInfoVec, userIdVec);
803
804 EXPECT_TRUE(delProfileMap.empty());
805 EXPECT_TRUE(delACLInfoVec.empty());
806 EXPECT_TRUE(userIdVec.empty());
807 }
808
809 HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAclByTokenId_002, testing::ext::TestSize.Level1)
810 {
811 int32_t accessTokenId = 1234;
812 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
813
814 std::map<int64_t, DistributedDeviceProfile::AccessControlProfile> delProfileMap;
815 std::vector<std::pair<int32_t, std::string>> delACLInfoVec;
816 std::vector<int32_t> userIdVec;
817
818 deviceManagerServiceImpl_->DeleteAclByTokenId(accessTokenId, profiles, delProfileMap, delACLInfoVec, userIdVec);
819
820 EXPECT_TRUE(profiles.empty());
821 EXPECT_TRUE(delProfileMap.empty());
822 EXPECT_TRUE(delACLInfoVec.empty());
823 EXPECT_TRUE(userIdVec.empty());
824 }
825 } // namespace
826 } // namespace DistributedHardware
827 } // namespace OHOS
828