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_dm_credential_manager.h"
17 #include "accesstoken_kit.h"
18 #include "dm_anonymous.h"
19 #include "dm_constants.h"
20 #include "dm_credential_manager.cpp"
21 #include "dm_random.h"
22 #include "nativetoken_kit.h"
23 #include "parameter.h"
24 #include "softbus_common.h"
25 #include "token_setproc.h"
26
27 using namespace OHOS::Security::AccessToken;
28 namespace OHOS {
29 namespace DistributedHardware {
SetUp()30 void DmCredentialManagerTest::SetUp()
31 {
32 const int32_t permsNum = 2;
33 const int32_t indexZero = 0;
34 const int32_t indexOne = 1;
35 uint64_t tokenId;
36 const char *perms[permsNum];
37 perms[indexZero] = "ohos.permission.DISTRIBUTED_SOFTBUS_CENTER";
38 perms[indexOne] = "ohos.permission.DISTRIBUTED_DATASYNC";
39 NativeTokenInfoParams infoInstance = {
40 .dcapsNum = 0,
41 .permsNum = permsNum,
42 .aclsNum = 0,
43 .dcaps = NULL,
44 .perms = perms,
45 .acls = NULL,
46 .processName = "dsoftbus_service",
47 .aplStr = "system_core",
48 };
49 tokenId = GetAccessTokenId(&infoInstance);
50 SetSelfTokenID(tokenId);
51 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
52 hiChainConnector_ = std::make_shared<HiChainConnector>();
53 listener_ = std::make_shared<MockDeviceManagerServiceListener>();
54 dmCreMgr_ = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
55 }
56
TearDown()57 void DmCredentialManagerTest::TearDown()
58 {
59 dmCreMgr_ = nullptr;
60 hiChainConnector_ = nullptr;
61 listener_ = nullptr;
62 }
63
SetUpTestCase()64 void DmCredentialManagerTest::SetUpTestCase()
65 {
66 }
67
TearDownTestCase()68 void DmCredentialManagerTest::TearDownTestCase()
69 {
70 }
71
72 /**
73 * @tc.name: DmCredentialManager_001
74 * @tc.desc: Test whether the DmCredentialManager function can generate a new pointer
75 * @tc.type: FUNC
76 * @tc.require: AR000GHSJK
77 */
78 HWTEST_F(DmCredentialManagerTest, DmCredentialManager_001, testing::ext::TestSize.Level1)
79 {
80 std::shared_ptr<DmCredentialManager> Test = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
81 ASSERT_NE(Test, nullptr);
82 }
83
84 /**
85 * @tc.name: DmCredentialManager_002
86 * @tc.desc: Test whether the DmCredentialManager function can delete a new pointer
87 * @tc.type: FUNC
88 * @tc.require: AR000GHSJK
89 */
90 HWTEST_F(DmCredentialManagerTest, DmCredentialManager_002, testing::ext::TestSize.Level1)
91 {
92 std::shared_ptr<DmCredentialManager> Test = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
93 Test.reset();
94 EXPECT_EQ(Test, nullptr);
95 }
96
97 /**
98 * @tc.name:RegisterCredentialCallback_001
99 * @tc.desc: return DM_OK
100 * @tc.type: FUNC
101 * @tc.require: AR000GHSJK
102 */
103 HWTEST_F(DmCredentialManagerTest, RegisterCredentialCallback_001, testing::ext::TestSize.Level1)
104 {
105 std::string pkgName = "com.ohos.helloworld";
106 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
107 int32_t ret = dmCreMgr->RegisterCredentialCallback(pkgName);
108 EXPECT_EQ(ret, DM_OK);
109 }
110
111 /**
112 * @tc.name:RegisterCredentialCallback_002
113 * @tc.desc: return ERR_DM_FAILED
114 * @tc.type: FUNC
115 * @tc.require: AR000GHSJK
116 */
117 HWTEST_F(DmCredentialManagerTest, RegisterCredentialCallback_002, testing::ext::TestSize.Level1)
118 {
119 std::string pkgName = "";
120 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
121 int32_t ret = dmCreMgr->RegisterCredentialCallback(pkgName);
122 EXPECT_EQ(ret, ERR_DM_FAILED);
123 }
124
125 /**
126 * @tc.name:UnRegisterCredentialCallback_001
127 * @tc.desc: return DM_OK
128 * @tc.type: FUNC
129 * @tc.require: AR000GHSJK
130 */
131 HWTEST_F(DmCredentialManagerTest, UnRegisterCredentialCallback_001, testing::ext::TestSize.Level1)
132 {
133 std::string pkgName = "com.ohos.helloworld";
134 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
135 int32_t ret = dmCreMgr->RegisterCredentialCallback(pkgName);
136 EXPECT_EQ(ret, DM_OK);
137 }
138
139 /**
140 * @tc.name:UnRegisterCredentialCallback_002
141 * @tc.desc: return ERR_DM_FAILED
142 * @tc.type: FUNC
143 * @tc.require: AR000GHSJK
144 */
145 HWTEST_F(DmCredentialManagerTest, UnRegisterCredentialCallback_002, testing::ext::TestSize.Level1)
146 {
147 std::string pkgName = "";
148 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
149 int32_t ret = dmCreMgr->UnRegisterCredentialCallback(pkgName);
150 EXPECT_EQ(ret, ERR_DM_FAILED);
151 }
152
153 /**
154 * @tc.name:UnRegisterCredentialCallback_003
155 * @tc.desc: return ERR_DM_FAILED
156 * @tc.type: FUNC
157 * @tc.require: AR000GHSJK
158 */
159 HWTEST_F(DmCredentialManagerTest, UnRegisterCredentialCallback_003, testing::ext::TestSize.Level1)
160 {
161 std::string pkgName = "com.ohos.helloworld";
162 int32_t ret = dmCreMgr_->RegisterCredentialCallback(pkgName);
163 EXPECT_EQ(ret, DM_OK);
164 ret = dmCreMgr_->UnRegisterCredentialCallback(pkgName);
165 EXPECT_EQ(ret, DM_OK);
166 }
167
168 /**
169 * @tc.name:RequestCredential_001
170 * @tc.desc: get credential info and return ERR_DM_FAILED
171 * @tc.type: FUNC
172 * @tc.require: AR000GHSJK
173 */
174 HWTEST_F(DmCredentialManagerTest, RequestCredential_001, testing::ext::TestSize.Level1)
175 {
176 std::string reqJsonStr = "invalid json string";
177 std::string returnJsonStr;
178 int32_t ret = dmCreMgr_->RequestCredential(reqJsonStr, returnJsonStr);
179 ASSERT_EQ(ret, ERR_DM_FAILED);
180
181 JsonObject jsonObject;
182 jsonObject["userId"] = "test";
183 jsonObject["version"] = "test";
184 reqJsonStr = jsonObject.Dump();
185 ret = dmCreMgr_->RequestCredential(reqJsonStr, returnJsonStr);
186 ASSERT_EQ(ret, ERR_DM_FAILED);
187 }
188
189 /**
190 * @tc.name:RequestCredential_002
191 * @tc.desc: get credential info and return ERR_DM_FAILED
192 * @tc.type: FUNC
193 * @tc.require: AR000GHSJK
194 */
195 HWTEST_F(DmCredentialManagerTest, RequestCredential_002, testing::ext::TestSize.Level1)
196 {
197 std::string reqJsonStr = R"(
198 {
199 "userId":"4269DC28B639681698809A67EDAD08E39F207900038F91EFF95DD042FE2874E4"
200 }
201 )";
202 std::string returnJsonStr;
203 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
204 int32_t ret = dmCreMgr->RequestCredential(reqJsonStr, returnJsonStr);
205 ASSERT_EQ(ret, ERR_DM_FAILED);
206 }
207
208 /**
209 * @tc.name:RequestCredential_003
210 * @tc.desc: get credential info and return ERR_DM_FAILED
211 * @tc.type: FUNC
212 * @tc.require: AR000GHSJK
213 */
214 HWTEST_F(DmCredentialManagerTest, RequestCredential_003, testing::ext::TestSize.Level1)
215 {
216 std::string reqJsonStr = R"(
217 {
218 "userId":"4269DC28B639681698809A67EDAD08E39F207900038F91EFF95DD042FE2874E4"
219 }
220 )";
221 std::string returnJsonStr;
222 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
223 int32_t ret = dmCreMgr->RequestCredential(reqJsonStr, returnJsonStr);
224 ASSERT_EQ(ret, ERR_DM_FAILED);
225 }
226
227 /**
228 * @tc.name:RequestCredential_004
229 * @tc.desc: get credential info and return ERR_DM_FAILED
230 * @tc.type: FUNC
231 * @tc.require: AR000GHSJK
232 */
233 HWTEST_F(DmCredentialManagerTest, RequestCredential_004, testing::ext::TestSize.Level1)
234 {
235 std::string reqJsonStr = R"(
236 {
237 "version" : "1.2.3"
238 }
239 )";
240 std::string returnJsonStr;
241 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
242 int32_t ret = dmCreMgr->RequestCredential(reqJsonStr, returnJsonStr);
243 ASSERT_EQ(ret, ERR_DM_FAILED);
244 }
245
246 /**
247 * @tc.name: ImportCredential_001
248 * @tc.desc: import local credential and return ERR_DM_FAILED
249 * @tc.type: FUNC
250 * @tc.require: AR000GHSJK
251 */
252 HWTEST_F(DmCredentialManagerTest, ImportCredential_001, testing::ext::TestSize.Level1)
253 {
254 std::string pkgName = "com.ohos.helloworld";
255 std::string credentialInfo = R"(
256 {
257 "processType" : 1,
258 "authType" : "test",
259 "userId" : "123",
260 "credentialData" :
261 [
262 {
263 "credentialType" : 1,
264 "credentialId" : "104",
265 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
266 "serverPk" : "",
267 "pkInfoSignature" : "",
268 "pkInfo" : "",
269 "peerDeviceId" : ""
270 }
271 ]
272 }
273 )";
274 dmCreMgr_->hiChainConnector_->deviceGroupManager_ = nullptr;
275 dmCreMgr_->credentialVec_.push_back(pkgName);
276 int32_t ret = dmCreMgr_->ImportCredential(pkgName, credentialInfo);
277 EXPECT_EQ(ret, ERR_DM_FAILED);
278
279 JsonObject jsonObject(credentialInfo);
280 jsonObject["TType"] = 1;
281 jsonObject["processType"] = 1;
282 credentialInfo = jsonObject.Dump();
283 ret = dmCreMgr_->ImportCredential(pkgName, credentialInfo);
284 EXPECT_EQ(ret, ERR_DM_FAILED);
285
286 jsonObject["processType"] = -1;
287 credentialInfo = jsonObject.Dump();
288 ret = dmCreMgr_->ImportCredential(pkgName, credentialInfo);
289 EXPECT_EQ(ret, ERR_DM_FAILED);
290
291 jsonObject["processType"] = 2;
292 credentialInfo = jsonObject.Dump();
293 ret = dmCreMgr_->ImportCredential(pkgName, credentialInfo);
294 EXPECT_EQ(ret, ERR_DM_FAILED);
295
296 jsonObject["TType"] = "test";
297 credentialInfo = jsonObject.Dump();
298 ret = dmCreMgr_->ImportCredential(pkgName, credentialInfo);
299 EXPECT_EQ(ret, ERR_DM_FAILED);
300 }
301
302 /**
303 * @tc.name: ImportCredential_002
304 * @tc.desc: import local credential and return ERR_DM_FAILED
305 * @tc.type: FUNC
306 * @tc.require: AR000GHSJK
307 */
308 HWTEST_F(DmCredentialManagerTest, ImportCredential_002, testing::ext::TestSize.Level1)
309 {
310 std::string pkgName = "com.ohos.helloworld";
311 std::string credentialInfo;
312 int32_t ret = dmCreMgr_->ImportCredential(pkgName, credentialInfo);
313 EXPECT_EQ(ret, ERR_DM_FAILED);
314 }
315
316 /**
317 * @tc.name: ImportCredential_003
318 * @tc.desc: import local credential and return ERR_DM_FAILED
319 * @tc.type: FUNC
320 * @tc.require: AR000GHSJK
321 */
322 HWTEST_F(DmCredentialManagerTest, ImportCredential_003, testing::ext::TestSize.Level1)
323 {
324 std::string pkgName = "com.ohos.helloworld";
325 std::string credentialInfo = R"(
326 {
327 "userId" , "123"
328 }
329 )";
330 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
331 dmCreMgr->credentialVec_.push_back(pkgName);
332 int32_t ret = dmCreMgr->ImportCredential(pkgName, credentialInfo);
333 EXPECT_EQ(ret, ERR_DM_FAILED);
334 }
335
336 /**
337 * @tc.name: ImportCredential_004
338 * @tc.desc: import local credential and return ERR_DM_FAILED
339 * @tc.type: FUNC
340 * @tc.require: AR000GHSJK
341 */
342 HWTEST_F(DmCredentialManagerTest, ImportCredential_004, testing::ext::TestSize.Level1)
343 {
344 std::string pkgName = "com.ohos.helloworld";
345 std::string credentialInfo = R"(
346 {
347 "authType" : 1,
348 "userId" : "123",
349 "credentialData" :
350 [
351 {
352 "credentialType" : 1,
353 "credentialId" : "104",
354 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
355 "serverPk" : "",
356 "pkInfoSignature" : "",
357 "pkInfo" : "",
358 "peerDeviceId" : ""
359 }
360 ]
361 }
362 )";
363 dmCreMgr_->credentialVec_.push_back(pkgName);
364 int32_t ret = dmCreMgr_->ImportCredential(pkgName, credentialInfo);
365 EXPECT_EQ(ret, ERR_DM_FAILED);
366 }
367
368 /**
369 * @tc.name: ImportCredential_005
370 * @tc.desc: import local credential and return ERR_DM_FAILED
371 * @tc.type: FUNC
372 * @tc.require: AR000GHSJK
373 */
374 HWTEST_F(DmCredentialManagerTest, ImportCredential_005, testing::ext::TestSize.Level1)
375 {
376 std::string pkgName = "com.ohos.helloworld";
377 std::string credentialInfo = R"(
378 {
379 "processType" : 0,
380 "authType" : 1,
381 "userId" : "123",
382 "credentialData" :
383 [
384 {
385 "credentialType" : 1,
386 "credentialId" : "104",
387 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
388 "serverPk" : "",
389 "pkInfoSignature" : "",
390 "pkInfo" : "",
391 "peerDeviceId" : ""
392 }
393 ]
394 }
395 )";
396 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
397 dmCreMgr->credentialVec_.push_back(pkgName);
398 int32_t ret = dmCreMgr->ImportCredential(pkgName, credentialInfo);
399 EXPECT_EQ(ret, ERR_DM_FAILED);
400 }
401
402 /**
403 * @tc.name: ImportRemoteCredentialExt_001
404 * @tc.desc: test ImportRemoteCredentialExt
405 * @tc.type: FUNC
406 * @tc.require: AR000GHSJK
407 */
408 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredentialExt_001, testing::ext::TestSize.Level1)
409 {
410 std::string credentialInfo = "";
411 dmCreMgr_->hiChainConnector_->deviceGroupManager_ = nullptr;
412 int32_t ret = dmCreMgr_->ImportRemoteCredentialExt(credentialInfo);
413 EXPECT_EQ(ret, ERR_DM_FAILED);
414 }
415
416 /**
417 * @tc.name: ImportLocalCredential_001
418 * @tc.desc: test ImportLocalCredential
419 * @tc.type: FUNC
420 * @tc.require: AR000GHSJK
421 */
422 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_001, testing::ext::TestSize.Level1)
423 {
424 std::string credentialInfo = R"(
425 {
426 "processType" : 1,
427 "authType" : 2,
428 "userId" : "123",
429 "credentialData" :
430 [
431 {
432 "credentialType" : 0,
433 "credentialId" : "104",
434 "authCode" : "12345",
435 "serverPk" : "",
436 "pkInfoSignature" : "",
437 "pkInfo" : "",
438 "peerDeviceId" : ""
439 },
440 {
441 "credentialType" : 0,
442 "credentialId" : "105",
443 "authCode" : "12345",
444 "serverPk" : "",
445 "pkInfoSignature" : "",
446 "pkInfo" : "",
447 "peerDeviceId" : ""
448 }
449 ]
450 }
451 )";
452 int32_t ret = dmCreMgr_->ImportLocalCredential(credentialInfo);
453 EXPECT_EQ(ret, ERR_DM_FAILED);
454 }
455
456 /**
457 * @tc.name: ImportLocalCredential_002
458 * @tc.desc: import local credential and return ERR_DM_FAILED
459 * @tc.type: FUNC
460 * @tc.require: AR000GHSJK
461 */
462 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_002, testing::ext::TestSize.Level1)
463 {
464 std::string pkgName = "com.ohos.helloworld";
465 std::string credentialInfo = R"(
466 {
467 "processType", 1,
468 }
469 )";
470 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
471 int32_t ret = dmCreMgr->ImportLocalCredential(credentialInfo);
472 EXPECT_EQ(ret, ERR_DM_FAILED);
473 }
474
475 /**
476 * @tc.name: ImportLocalCredential_003
477 * @tc.desc: import local credential and return ERR_DM_FAILED
478 * @tc.type: FUNC
479 * @tc.require: AR000GHSJK
480 */
481 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_003, testing::ext::TestSize.Level1)
482 {
483 std::string credentialInfo = R"(
484 {
485 "processType" : 1,
486 "userId" : "123",
487 "credentialData" :
488 [
489 {
490 "credentialType" : 1,
491 "credentialId" : "104",
492 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
493 "serverPk" : "",
494 "pkInfoSignature" : "",
495 "pkInfo" : "",
496 "peerDeviceId" : ""
497 }
498 ]
499 }
500 )";
501 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
502 int32_t ret = dmCreMgr->ImportLocalCredential(credentialInfo);
503 EXPECT_EQ(ret, ERR_DM_FAILED);
504 }
505
506 /**
507 * @tc.name: ImportLocalCredential_004
508 * @tc.desc: import local credential and return ERR_DM_FAILED
509 * @tc.type: FUNC
510 * @tc.require: AR000GHSJK
511 */
512 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_004, testing::ext::TestSize.Level1)
513 {
514 std::string credentialInfo = R"(
515 {
516 "processType" : 1,
517 "authType" : 1,
518 "credentialData" :
519 [
520 {
521 "credentialType" : 1,
522 "credentialId" : "104",
523 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
524 "serverPk" : "",
525 "pkInfoSignature" : "",
526 "pkInfo" : "",
527 "peerDeviceId" : ""
528 }
529 ]
530 }
531 )";
532 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
533 int32_t ret = dmCreMgr->ImportLocalCredential(credentialInfo);
534 EXPECT_EQ(ret, ERR_DM_FAILED);
535 }
536
537 /**
538 * @tc.name: ImportLocalCredential_005
539 * @tc.desc: import local credential and return ERR_DM_FAILED
540 * @tc.type: FUNC
541 * @tc.require: AR000GHSJK
542 */
543 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_005, testing::ext::TestSize.Level1)
544 {
545 std::string credentialInfo = R"(
546 {
547 "processType" : 1,
548 "authType" : 1,
549 "userId" : "123"
550 }
551 )";
552 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
553 int32_t ret = dmCreMgr->ImportLocalCredential(credentialInfo);
554 EXPECT_EQ(ret, ERR_DM_FAILED);
555 }
556
557 /**
558 * @tc.name: ImportLocalCredential_006
559 * @tc.desc: import local credential and return ERR_DM_FAILED
560 * @tc.type: FUNC
561 * @tc.require: AR000GHSJK
562 */
563 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_006, testing::ext::TestSize.Level1)
564 {
565 std::string credentialInfo = R"(
566 {
567 "processType" : 1,
568 "authType" : 1,
569 "userId" : "123",
570 "credentialData" :
571 [
572 {
573 "credentialType" : 1,
574 "credentialId" : "104",
575 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
576 "serverPk" : "",
577 "pkInfoSignature" : "",
578 "pkInfo" : "",
579 "peerDeviceId" : ""
580 }
581 {
582 "credentialType" : 1,
583 "credentialId" : "104",
584 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
585 "serverPk" : "",
586 "pkInfoSignature" : "",
587 "pkInfo" : "",
588 "peerDeviceId" : ""
589 }
590 ]
591 }
592 )";
593 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
594 int32_t ret = dmCreMgr->ImportLocalCredential(credentialInfo);
595 EXPECT_EQ(ret, ERR_DM_FAILED);
596 }
597
598 /**
599 * @tc.name: ImportLocalCredential_007
600 * @tc.desc: test ImportLocalCredential
601 * @tc.type: FUNC
602 * @tc.require: AR000GHSJK
603 */
604 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_007, testing::ext::TestSize.Level1)
605 {
606 std::string credentialInfo = R"(
607 {
608 "processType" : 1,
609 "authType" : 1,
610 "userId" : "123",
611 "credentialData" :
612 [
613 {
614 "credentialType" : 0,
615 "credentialId" : "104",
616 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
617 "serverPk" : "",
618 "pkInfoSignature" : "",
619 "pkInfo" : "",
620 "peerDeviceId" : ""
621 }
622 ]
623 }
624 )";
625 int32_t ret = dmCreMgr_->ImportLocalCredential(credentialInfo);
626 EXPECT_EQ(ret, ERR_DM_FAILED);
627 }
628
629 /**
630 * @tc.name: ImportLocalCredential_008
631 * @tc.desc: test ImportLocalCredential
632 * @tc.type: FUNC
633 * @tc.require: AR000GHSJK
634 */
635 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_008, testing::ext::TestSize.Level1)
636 {
637 std::string credentialInfo = R"(
638 {
639 "processType" : 1,
640 "authType" : 1,
641 "userId" : "123",
642 "credentialData" :
643 [
644 {
645 "credentialType" : 2,
646 "credentialId" : "104",
647 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
648 "serverPk" : "",
649 "pkInfoSignature" : "",
650 "pkInfo" : "",
651 "peerDeviceId" : ""
652 }
653 ]
654 }
655 )";
656 dmCreMgr_->hiChainConnector_->deviceGroupManager_ = nullptr;
657 int32_t ret = dmCreMgr_->ImportLocalCredential(credentialInfo);
658 EXPECT_EQ(ret, ERR_DM_FAILED);
659 }
660
661 /**
662 * @tc.name: ImportLocalCredential_009
663 * @tc.desc: test ImportLocalCredential
664 * @tc.type: FUNC
665 * @tc.require: AR000GHSJK
666 */
667 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_009, testing::ext::TestSize.Level1)
668 {
669 std::string credentialInfo = R"(
670 {
671 "processType" : 1,
672 "authType" : 1,
673 "userId" : "123",
674 "credentialData" :
675 [
676 {
677 "credentialType" : 2,
678 "credentialId" : "104",
679 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
680 "serverPk" : "",
681 "pkInfoSignature" : "",
682 "pkInfo" : "",
683 "peerDeviceId" : ""
684 }
685 ]
686 }
687 )";
688 dmCreMgr_->hiChainConnector_->deviceGroupManager_ = nullptr;
689 int32_t ret = dmCreMgr_->ImportLocalCredential(credentialInfo);
690 EXPECT_EQ(ret, ERR_DM_FAILED);
691 }
692
693 /**
694 * @tc.name: ImportRemoteCredential_001
695 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
696 * @tc.type: FUNC
697 * @tc.require: AR000GHSJK
698 */
699 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_001, testing::ext::TestSize.Level1)
700 {
701 CredentialDataInfo credentialDataInfo;
702 credentialDataInfo.credentialType = SAME_ACCOUNT_TYPE;
703 credentialDataInfo.credentailId = "credential_id";
704 credentialDataInfo.serverPk = "server_pk";
705 credentialDataInfo.pkInfoSignature = "pk_info_signature";
706 credentialDataInfo.pkInfo = "pk_info";
707 credentialDataInfo.authCode = "auth_code";
708 credentialDataInfo.peerDeviceId = "peer_device_id";
709 credentialDataInfo.userId = "user_id";
710 credentialDataInfo.credentialType = SAME_ACCOUNT_TYPE;
711 JsonObject jsonObject1;
712 jsonObject1 = credentialDataInfo;
713 JsonObject credentialJson(JsonCreateType::JSON_CREATE_TYPE_ARRAY);
714 credentialJson.PushBack(jsonObject1);
715 JsonObject jsonObject;
716 jsonObject.Insert(FIELD_CREDENTIAL_DATA, credentialJson);
717 jsonObject[FIELD_AUTH_TYPE] = CROSS_ACCOUNT_TYPE;
718 jsonObject[FIELD_USER_ID] = 0;
719 jsonObject[FIELD_PEER_USER_ID] = "peerUserId";
720
721 std::string credentialInfo = jsonObject.Dump();
722 dmCreMgr_->hiChainConnector_->deviceGroupManager_ = nullptr;
723 int32_t ret = dmCreMgr_->ImportRemoteCredential(credentialInfo);
724 EXPECT_EQ(ret, ERR_DM_FAILED);
725
726 jsonObject[FIELD_CREDENTIAL_DATA] = 0;
727 credentialInfo = jsonObject.Dump();
728 ret = dmCreMgr_->ImportRemoteCredential(credentialInfo);
729 EXPECT_EQ(ret, ERR_DM_FAILED);
730 }
731
732 /**
733 * @tc.name: ImportRemoteCredential_002
734 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
735 * @tc.type: FUNC
736 * @tc.require: AR000GHSJK
737 */
738 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_002, testing::ext::TestSize.Level1)
739 {
740 std::string credentialInfo = R"(
741 {
742 "processType", 2,
743 }
744 )";
745 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
746 int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
747 EXPECT_EQ(ret, ERR_DM_FAILED);
748 }
749
750 /**
751 * @tc.name: ImportRemoteCredential_003
752 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
753 * @tc.type: FUNC
754 * @tc.require: AR000GHSJK
755 */
756 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_003, testing::ext::TestSize.Level1)
757 {
758 std::string credentialInfo = R"(
759 {
760 "processType" : 2,
761 "authType" : 1,
762 "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
763 }
764 )";
765 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
766 int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
767 EXPECT_EQ(ret, ERR_DM_FAILED);
768 }
769
770 /**
771 * @tc.name: ImportRemoteCredential_004
772 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
773 * @tc.type: FUNC
774 * @tc.require: AR000GHSJK
775 */
776 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_004, testing::ext::TestSize.Level1)
777 {
778 std::string credentialInfo = R"(
779 {
780 "processType" : 2,
781 "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
782 "credentialData" :
783 [
784 {
785 "credentialType" : 1,
786 "credentialId" : "104",
787 "authCode" : "456",
788 "peerDeviceId" : "devD"
789 }
790 ]
791 }
792 )";
793 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
794 int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
795 EXPECT_EQ(ret, ERR_DM_FAILED);
796 }
797
798 /**
799 * @tc.name: ImportRemoteCredential_005
800 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
801 * @tc.type: FUNC
802 * @tc.require: AR000GHSJK
803 */
804 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_005, testing::ext::TestSize.Level1)
805 {
806 std::string credentialInfo = R"(
807 {
808 "processType" : 2,
809 "authType" : 1,
810 "credentialData" :
811 [
812 {
813 "credentialType" : 1,
814 "credentialId" : "104",
815 "authCode" : "456",
816 "peerDeviceId" : "devD"
817 }
818 ]
819 }
820 )";
821 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
822 int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
823 EXPECT_EQ(ret, ERR_DM_FAILED);
824 }
825
826 /**
827 * @tc.name: ImportRemoteCredential_006
828 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
829 * @tc.type: FUNC
830 * @tc.require: AR000GHSJK
831 */
832 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_006, testing::ext::TestSize.Level1)
833 {
834 std::string credentialInfo = R"(
835 {
836 "processType" : 2,
837 "authType" : 2,
838 "credentialData" :
839 [
840 {
841 "credentialType" : 1,
842 "credentialId" : "104",
843 "authCode" : "456",
844 "peerDeviceId" : "devD"
845 }
846 ]
847 }
848 )";
849 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
850 int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
851 EXPECT_EQ(ret, ERR_DM_FAILED);
852 }
853
854 /**
855 * @tc.name: ImportRemoteCredential_007
856 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
857 * @tc.type: FUNC
858 * @tc.require: AR000GHSJK
859 */
860 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_007, testing::ext::TestSize.Level1)
861 {
862 std::string credentialInfo = R"(
863 {
864 "processType" : 2,
865 "authType" : "x",
866 "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
867 "credentialData" :
868 [
869 {
870 "credentialType" : 1,
871 "credentialId" : "104",
872 "authCode" : "456",
873 "peerDeviceId" : "devD"
874 }
875 ]
876 }
877 )";
878 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
879 int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
880 EXPECT_EQ(ret, ERR_DM_FAILED);
881 }
882
883 /**
884 * @tc.name: ImportRemoteCredential_008
885 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
886 * @tc.type: FUNC
887 * @tc.require: AR000GHSJK
888 */
889 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_008, testing::ext::TestSize.Level1)
890 {
891 std::string credentialInfo = R"(
892 {
893 "processType" : 2,
894 "authType" : 1,
895 "userId" : "",
896 "credentialData" :
897 [
898 {
899 "credentialType" : 1,
900 "credentialId" : "104",
901 "authCode" : "456",
902 "peerDeviceId" : "devD"
903 }
904 ]
905 }
906 )";
907 int32_t ret = dmCreMgr_->ImportRemoteCredential(credentialInfo);
908 EXPECT_EQ(ret, ERR_DM_FAILED);
909 }
910
911 /**
912 * @tc.name: DeleteRemoteCredential_001
913 * @tc.desc: delete remote credential and return ERR_DM_FAILED
914 * @tc.type: FUNC
915 * @tc.require: AR000GHSJK
916 */
917 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_001, testing::ext::TestSize.Level1)
918 {
919 std::string credentialInfo = R"(
920 {
921 "processType" : 2,
922 "authType" : 2,
923 "peerUserId": "123",
924 "peerCredentialInfo" : 0
925 }
926 )";
927 int32_t ret = dmCreMgr_->DeleteRemoteCredential(credentialInfo);
928 EXPECT_EQ(ret, ERR_DM_FAILED);
929 }
930
931 /**
932 * @tc.name: DeleteRemoteCredential_002
933 * @tc.desc: delete remote credential and return ERR_DM_FAILED
934 * @tc.type: FUNC
935 * @tc.require: AR000GHSJK
936 */
937 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_002, testing::ext::TestSize.Level1)
938 {
939 std::string credentialInfo = R"(
940 {
941 "processType", 2,
942 }
943 )";
944 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
945 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
946 EXPECT_EQ(ret, ERR_DM_FAILED);
947 }
948
949 /**
950 * @tc.name: DeleteRemoteCredential_003
951 * @tc.desc: delete remote credential and return ERR_DM_FAILED
952 * @tc.type: FUNC
953 * @tc.require: AR000GHSJK
954 */
955 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_003, testing::ext::TestSize.Level1)
956 {
957 std::string credentialInfo = R"(
958 {
959 "processType" : 2,
960 "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
961 "peerCredentialInfo" :
962 [
963 {
964 "peerDeviceId" : "devD"
965 }
966 ]
967 }
968 )";
969 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
970 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
971 EXPECT_EQ(ret, ERR_DM_FAILED);
972 }
973
974 /**
975 * @tc.name: DeleteRemoteCredential_004
976 * @tc.desc: delete remote credential and return ERR_DM_FAILED
977 * @tc.type: FUNC
978 * @tc.require: AR000GHSJK
979 */
980 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_004, testing::ext::TestSize.Level1)
981 {
982 std::string credentialInfo = R"(
983 {
984 "processType" : 2,
985 "authType" : 1,
986 "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
987 }
988 )";
989 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
990 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
991 EXPECT_EQ(ret, ERR_DM_FAILED);
992 }
993
994 /**
995 * @tc.name: DeleteRemoteCredential_005
996 * @tc.desc: delete remote credential and return ERR_DM_FAILED
997 * @tc.type: FUNC
998 * @tc.require: AR000GHSJK
999 */
1000 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_005, testing::ext::TestSize.Level1)
1001 {
1002 std::string credentialInfo = R"(
1003 {
1004 "processType" : 2,
1005 "authType" : 1,
1006 "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
1007 "peerCredentialInfo" :
1008 [
1009 {
1010 "peerDeviceId" : "devD"
1011 }
1012 ]
1013 }
1014 )";
1015 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1016 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
1017 EXPECT_EQ(ret, ERR_DM_FAILED);
1018 }
1019
1020 /**
1021 * @tc.name: DeleteRemoteCredential_006
1022 * @tc.desc: delete remote credential and return ERR_DM_FAILED
1023 * @tc.type: FUNC
1024 * @tc.require: AR000GHSJK
1025 */
1026 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_006, testing::ext::TestSize.Level1)
1027 {
1028 std::string credentialInfo = R"(
1029 {
1030 "processType" : 2,
1031 "authType" : 1,
1032 "peerCredentialInfo" :
1033 [
1034 {
1035 "peerDeviceId" : "devD"
1036 }
1037 ]
1038 }
1039 )";
1040 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1041 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
1042 EXPECT_EQ(ret, ERR_DM_FAILED);
1043 }
1044
1045 /**
1046 * @tc.name: DeleteRemoteCredential_007
1047 * @tc.desc: delete remote credential and return ERR_DM_FAILED
1048 * @tc.type: FUNC
1049 * @tc.require: AR000GHSJK
1050 */
1051 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_007, testing::ext::TestSize.Level1)
1052 {
1053 std::string credentialInfo = R"(
1054 {
1055 "processType" : 2,
1056 "authType" : 2,
1057 "peerCredentialInfo" :
1058 [
1059 {
1060 "peerDeviceId" : "devD"
1061 }
1062 ]
1063 }
1064 )";
1065 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1066 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
1067 EXPECT_EQ(ret, ERR_DM_FAILED);
1068 }
1069
1070 /**
1071 * @tc.name: DeleteRemoteCredential_008
1072 * @tc.desc: delete remote credential and return ERR_DM_FAILED
1073 * @tc.type: FUNC
1074 * @tc.require: AR000GHSJK
1075 */
1076 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_008, testing::ext::TestSize.Level1)
1077 {
1078 std::string credentialInfo = R"(
1079 {
1080 "processType" : 2,
1081 "authType" : 1,
1082 }
1083 )";
1084 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1085 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
1086 EXPECT_EQ(ret, ERR_DM_FAILED);
1087 }
1088
1089 /**
1090 * @tc.name: DeleteRemoteCredential_009
1091 * @tc.desc: delete remote credential and return ERR_DM_FAILED
1092 * @tc.type: FUNC
1093 * @tc.require: AR000GHSJK
1094 */
1095 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_009, testing::ext::TestSize.Level1)
1096 {
1097 std::string credentialInfo = R"(
1098 {
1099 "processType" : 2,
1100 "authType" : 2,
1101 }
1102 )";
1103 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1104 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
1105 EXPECT_EQ(ret, ERR_DM_FAILED);
1106 }
1107
1108 /**
1109 * @tc.name: DeleteRemoteCredential_0010
1110 * @tc.desc: delete remote credential and return ERR_DM_FAILED
1111 * @tc.type: FUNC
1112 * @tc.require: AR000GHSJK
1113 */
1114 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_0010, testing::ext::TestSize.Level1)
1115 {
1116 std::string credentialInfo = R"(
1117 {
1118 "processType" : 2,
1119 "authType" : 1,
1120 "userId": "123",
1121 "peerCredentialInfo" :
1122 [
1123 {
1124 "peerDeviceId" : "devD"
1125 }
1126 ]
1127 }
1128 )";
1129 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1130 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
1131 EXPECT_EQ(ret, ERR_DM_FAILED);
1132 }
1133
1134 /**
1135 * @tc.name: DeleteRemoteCredential_0011
1136 * @tc.desc: delete remote credential and return ERR_DM_FAILED
1137 * @tc.type: FUNC
1138 * @tc.require: AR000GHSJK
1139 */
1140 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_0011, testing::ext::TestSize.Level1)
1141 {
1142 std::string credentialInfo = R"(
1143 {
1144 "processType" : 2,
1145 "authType" : 2,
1146 "peerUserId": "123",
1147 "peerCredentialInfo" :
1148 [
1149 {
1150 "peerDeviceId" : "devD"
1151 }
1152 ]
1153 }
1154 )";
1155 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1156 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
1157 EXPECT_EQ(ret, ERR_DM_FAILED);
1158 }
1159
1160 /**
1161 * @tc.name: DeleteCredential_001
1162 * @tc.desc: test DeleteCredential
1163 * @tc.type: FUNC
1164 * @tc.require: AR000GHSJK
1165 */
1166 HWTEST_F(DmCredentialManagerTest, DeleteCredential_001, testing::ext::TestSize.Level1)
1167 {
1168 std::string pkgName = "com.ohos.helloworld";
1169 std::string resultInfo;
1170 std::string credentialInfo = R"(
1171 {
1172 "processType" : 2,
1173 "authType" : 2,
1174 "userId" : "123"
1175 }
1176 )";
1177 dmCreMgr_->requestId_ = 1;
1178 dmCreMgr_->OnGroupResult(0, 0, resultInfo);
1179 dmCreMgr_->requestId_ = 0;
1180 dmCreMgr_->OnGroupResult(0, 0, resultInfo);
1181 dmCreMgr_->credentialVec_.push_back(pkgName);
1182 int32_t ret = dmCreMgr_->DeleteCredential(pkgName, credentialInfo);
1183 EXPECT_EQ(ret, ERR_DM_FAILED);
1184 }
1185
1186 /**
1187 * @tc.name: DeleteCredential_002
1188 * @tc.desc: delete local credential and return ERR_DM_FAILED
1189 * @tc.type: FUNC
1190 * @tc.require: AR000GHSJK
1191 */
1192 HWTEST_F(DmCredentialManagerTest, DeleteCredential_002, testing::ext::TestSize.Level1)
1193 {
1194 std::string pkgName = "";
1195 std::string credentialInfo = R"(
1196 {
1197 "processType" : 1,
1198 "authType" : 1,
1199 "userId" : "123"
1200 }
1201 )";
1202 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1203 dmCreMgr->credentialVec_.push_back(pkgName);
1204 int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
1205 EXPECT_EQ(ret, ERR_DM_FAILED);
1206 }
1207
1208 /**
1209 * @tc.name: DeleteCredential_003
1210 * @tc.desc: delete remote credential and return ERR_DM_FAILED
1211 * @tc.type: FUNC
1212 * @tc.require: AR000GHSJK
1213 */
1214 HWTEST_F(DmCredentialManagerTest, DeleteCredential_003, testing::ext::TestSize.Level1)
1215 {
1216 std::string pkgName = "com.ohos.helloworld";
1217 std::string credentialInfo = R"(
1218 {
1219 "userId" , "123"
1220 }
1221 )";
1222 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1223 dmCreMgr->credentialVec_.push_back(pkgName);
1224 int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
1225 EXPECT_EQ(ret, ERR_DM_FAILED);
1226 }
1227
1228 /**
1229 * @tc.name: DeleteCredential_004
1230 * @tc.desc: delete remote credential and return ERR_DM_FAILED
1231 * @tc.type: FUNC
1232 * @tc.require: AR000GHSJK
1233 */
1234 HWTEST_F(DmCredentialManagerTest, DeleteCredential_004, testing::ext::TestSize.Level1)
1235 {
1236 std::string pkgName = "com.ohos.helloworld";
1237 std::string credentialInfo = R"(
1238 {
1239 "authType" : 1,
1240 "userId" : "123"
1241 }
1242 )";
1243 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1244 dmCreMgr->credentialVec_.push_back(pkgName);
1245 int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
1246 EXPECT_EQ(ret, ERR_DM_FAILED);
1247 }
1248
1249 /**
1250 * @tc.name: DeleteCredential_005
1251 * @tc.desc: delete remote credential and return ERR_DM_FAILED
1252 * @tc.type: FUNC
1253 * @tc.require: AR000GHSJK
1254 */
1255 HWTEST_F(DmCredentialManagerTest, DeleteCredential_005, testing::ext::TestSize.Level1)
1256 {
1257 std::string pkgName = "com.ohos.helloworld";
1258 std::string credentialInfo = R"(
1259 {
1260 "processType" : 1,
1261 "userId" : "123"
1262 }
1263 )";
1264 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1265 dmCreMgr->credentialVec_.push_back(pkgName);
1266 int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
1267 EXPECT_EQ(ret, ERR_DM_FAILED);
1268 }
1269
1270 /**
1271 * @tc.name: DeleteCredential_006
1272 * @tc.desc: delete remote credential and return ERR_DM_FAILED
1273 * @tc.type: FUNC
1274 * @tc.require: AR000GHSJK
1275 */
1276 HWTEST_F(DmCredentialManagerTest, DeleteCredential_006, testing::ext::TestSize.Level1)
1277 {
1278 std::string pkgName = "com.ohos.helloworld";
1279 std::string credentialInfo = R"(
1280 {
1281 "processType" : 0,
1282 "authType" : 1,
1283 "userId" : "123"
1284 }
1285 )";
1286 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1287 dmCreMgr->credentialVec_.push_back(pkgName);
1288 int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
1289 EXPECT_EQ(ret, ERR_DM_FAILED);
1290 }
1291
1292 /**
1293 * @tc.name: GetCredentialData_001
1294 * @tc.desc: get symmetry credential data and return DM_OK
1295 * @tc.type: FUNC
1296 * @tc.require: AR000GHSJK
1297 */
1298 HWTEST_F(DmCredentialManagerTest, GetCredentialData_001, testing::ext::TestSize.Level1)
1299 {
1300 std::string credentialInfo = R"(
1301 {
1302 "processType" : 1,
1303 "authType" : 1,
1304 "userId" : "123",
1305 "credentialData" :
1306 [
1307 {
1308 "credentialType" : 1,
1309 "credentialId" : "104",
1310 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1311 "serverPk" : "",
1312 "pkInfoSignature" : "",
1313 "pkInfo" : "",
1314 "peerDeviceId" : ""
1315 }
1316 ]
1317 }
1318 )";
1319 CredentialData credentialData;
1320 credentialData.credentialType = 1;
1321 credentialData.credentialId = "104";
1322 credentialData.serverPk = "";
1323 credentialData.pkInfoSignature = "";
1324 credentialData.pkInfo = "";
1325 credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1326 credentialData.peerDeviceId = "";
1327 JsonObject jsonOutObj;
1328 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1329 int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1330 EXPECT_EQ(ret, DM_OK);
1331 }
1332
1333 /**
1334 * @tc.name: GetCredentialData_002
1335 * @tc.desc: get symmetry credential data and return ERR_DM_FAILED
1336 * @tc.type: FUNC
1337 * @tc.require: AR000GHSJK
1338 */
1339 HWTEST_F(DmCredentialManagerTest, GetCredentialData_002, testing::ext::TestSize.Level1)
1340 {
1341 std::string credentialInfo = R"(
1342 {
1343 "processType" : 1,
1344 "authType" : 1,
1345 "userId" : "123",
1346 "credentialData" :
1347 [
1348 {
1349 "credentialType" : 0,
1350 "credentialId" : "104",
1351 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1352 "serverPk" : "",
1353 "pkInfoSignature" : "",
1354 "pkInfo" : "",
1355 "peerDeviceId" : ""
1356 }
1357 ]
1358 }
1359 )";
1360 CredentialData credentialData;
1361 credentialData.credentialType = 0;
1362 credentialData.credentialId = "104";
1363 credentialData.serverPk = "";
1364 credentialData.pkInfoSignature = "";
1365 credentialData.pkInfo = "";
1366 credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1367 credentialData.peerDeviceId = "";
1368 JsonObject jsonOutObj;
1369 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1370 int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1371 EXPECT_EQ(ret, ERR_DM_FAILED);
1372 }
1373
1374 /**
1375 * @tc.name: GetCredentialData_003
1376 * @tc.desc: get nonsymmetry credential data and return ERR_DM_FAILED
1377 * @tc.type: FUNC
1378 * @tc.require: AR000GHSJK
1379 */
1380 HWTEST_F(DmCredentialManagerTest, GetCredentialData_003, testing::ext::TestSize.Level1)
1381 {
1382 std::string credentialInfo = R"(
1383 {
1384 "processType", 1,
1385 "authType" : 1,
1386 "userId" : "123",
1387 "version" : "1.2.3",
1388 "deviceId" : "aaa",
1389 "devicePk" : "0000",
1390 "credentialData" :
1391 [
1392 {
1393 "credentialType" : 2,
1394 "credentialId" : "104",
1395 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1396 "serverPk" : "",
1397 "pkInfoSignature" : "",
1398 "pkInfo" : "",
1399 "peerDeviceId" : ""
1400 }
1401 ]
1402 }
1403 )";
1404 CredentialData credentialData;
1405 credentialData.credentialType = 2;
1406 credentialData.credentialId = "104";
1407 credentialData.serverPk = "";
1408 credentialData.pkInfoSignature = "";
1409 credentialData.pkInfo = "";
1410 credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1411 credentialData.peerDeviceId = "";
1412 JsonObject jsonOutObj;
1413 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1414 int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1415 EXPECT_EQ(ret, ERR_DM_FAILED);
1416 }
1417
1418 /**
1419 * @tc.name: GetCredentialData_004
1420 * @tc.desc: get nonsymmetry credential data and return ERR_DM_FAILED
1421 * @tc.type: FUNC
1422 * @tc.require: AR000GHSJK
1423 */
1424 HWTEST_F(DmCredentialManagerTest, GetCredentialData_004, testing::ext::TestSize.Level1)
1425 {
1426 std::string credentialInfo = R"(
1427 {
1428 "processType" : 1,
1429 "authType" : 1,
1430 "version" : "1.2.3",
1431 "deviceId" : "aaa",
1432 "devicePk" : "0000",
1433 "credentialData" :
1434 [
1435 {
1436 "credentialType" : 2,
1437 "credentialId" : "104",
1438 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1439 "serverPk" : "",
1440 "pkInfoSignature" : "",
1441 "pkInfo" : "",
1442 "peerDeviceId" : ""
1443 }
1444 ]
1445 }
1446 )";
1447 CredentialData credentialData;
1448 credentialData.credentialType = 2;
1449 credentialData.credentialId = "104";
1450 credentialData.serverPk = "";
1451 credentialData.pkInfoSignature = "";
1452 credentialData.pkInfo = "";
1453 credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1454 credentialData.peerDeviceId = "";
1455 JsonObject jsonOutObj;
1456 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1457 int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1458 EXPECT_EQ(ret, ERR_DM_FAILED);
1459 }
1460
1461 /**
1462 * @tc.name: GetCredentialData_005
1463 * @tc.desc: get nonsymmetry credential data and return ERR_DM_FAILED
1464 * @tc.type: FUNC
1465 * @tc.require: AR000GHSJK
1466 */
1467 HWTEST_F(DmCredentialManagerTest, GetCredentialData_005, testing::ext::TestSize.Level1)
1468 {
1469 std::string credentialInfo = R"(
1470 {
1471 "processType" : 1,
1472 "authType" : 1,
1473 "userId" : "123",
1474 "deviceId" : "aaa",
1475 "devicePk" : "0000",
1476 "credentialData" :
1477 [
1478 {
1479 "credentialType" : 2,
1480 "credentialId" : "104",
1481 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1482 "serverPk" : "",
1483 "pkInfoSignature" : "",
1484 "pkInfo" : "",
1485 "peerDeviceId" : ""
1486 }
1487 ]
1488 }
1489 )";
1490 CredentialData credentialData;
1491 credentialData.credentialType = 2;
1492 credentialData.credentialId = "104";
1493 credentialData.serverPk = "";
1494 credentialData.pkInfoSignature = "";
1495 credentialData.pkInfo = "";
1496 credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1497 credentialData.peerDeviceId = "";
1498 JsonObject jsonOutObj;
1499 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1500 int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1501 EXPECT_EQ(ret, ERR_DM_FAILED);
1502 }
1503
1504 /**
1505 * @tc.name: GetCredentialData_006
1506 * @tc.desc: get nonsymmetry credential data and return ERR_DM_FAILED
1507 * @tc.type: FUNC
1508 * @tc.require: AR000GHSJK
1509 */
1510 HWTEST_F(DmCredentialManagerTest, GetCredentialData_006, testing::ext::TestSize.Level1)
1511 {
1512 std::string credentialInfo = R"(
1513 {
1514 "processType" : 1,
1515 "authType" : 1,
1516 "userId" : "123",
1517 "version" : "1.2.3",
1518 "devicePk" : "0000",
1519 "credentialData" :
1520 [
1521 {
1522 "credentialType" : 2,
1523 "credentialId" : "104",
1524 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1525 "serverPk" : "",
1526 "pkInfoSignature" : "",
1527 "pkInfo" : "",
1528 "peerDeviceId" : ""
1529 }
1530 ]
1531 }
1532 )";
1533 CredentialData credentialData;
1534 credentialData.credentialType = 2;
1535 credentialData.credentialId = "104";
1536 credentialData.serverPk = "";
1537 credentialData.pkInfoSignature = "";
1538 credentialData.pkInfo = "";
1539 credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1540 credentialData.peerDeviceId = "";
1541 JsonObject jsonOutObj;
1542 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1543 int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1544 EXPECT_EQ(ret, ERR_DM_FAILED);
1545 }
1546
1547 /**
1548 * @tc.name: GetCredentialData_007
1549 * @tc.desc: get nonsymmetry credential data and return ERR_DM_FAILED
1550 * @tc.type: FUNC
1551 * @tc.require: AR000GHSJK
1552 */
1553 HWTEST_F(DmCredentialManagerTest, GetCredentialData_007, testing::ext::TestSize.Level1)
1554 {
1555 std::string credentialInfo = R"(
1556 {
1557 "processType" : 1,
1558 "authType" : 1,
1559 "userId" : "123",
1560 "version" : "1.2.3",
1561 "deviceId" : "aaa",
1562 "credentialData" :
1563 [
1564 {
1565 "credentialType" : 2,
1566 "credentialId" : "104",
1567 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1568 "serverPk" : "",
1569 "pkInfoSignature" : "",
1570 "pkInfo" : "",
1571 "peerDeviceId" : ""
1572 }
1573 ]
1574 }
1575 )";
1576 CredentialData credentialData;
1577 credentialData.credentialType = 2;
1578 credentialData.credentialId = "104";
1579 credentialData.serverPk = "";
1580 credentialData.pkInfoSignature = "";
1581 credentialData.pkInfo = "";
1582 credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1583 credentialData.peerDeviceId = "";
1584 JsonObject jsonOutObj;
1585 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1586 int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1587 EXPECT_EQ(ret, ERR_DM_FAILED);
1588 }
1589
1590 /**
1591 * @tc.name: GetCredentialData_008
1592 * @tc.desc: get nonsymmetry credential data and return ERR_DM_FAILED
1593 * @tc.type: FUNC
1594 * @tc.require: AR000GHSJK
1595 */
1596 HWTEST_F(DmCredentialManagerTest, GetCredentialData_008, testing::ext::TestSize.Level1)
1597 {
1598 std::string credentialInfo = R"(
1599 {
1600 "processType" : 1,
1601 "authType" : 1,
1602 "userId" : "123",
1603 "version" : "1.2.3",
1604 "deviceId" : "aaa",
1605 "devicePk" : "0000",
1606 "credentialData" :
1607 [
1608 {
1609 "credentialType" : 2,
1610 "credentialId" : "104",
1611 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1612 "serverPk" : "",
1613 "pkInfoSignature" : "",
1614 "pkInfo" : "",
1615 "peerDeviceId" : ""
1616 }
1617 ]
1618 }
1619 )";
1620 CredentialData credentialData;
1621 credentialData.credentialType = 2;
1622 credentialData.credentialId = "104";
1623 credentialData.serverPk = "";
1624 credentialData.pkInfoSignature = "";
1625 credentialData.pkInfo = "";
1626 credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1627 credentialData.peerDeviceId = "";
1628 JsonObject jsonOutObj;
1629 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1630 int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1631 EXPECT_EQ(ret, DM_OK);
1632 }
1633
1634 /**
1635 * @tc.name: from_json_001
1636 * @tc.desc: test from_json
1637 * @tc.type: FUNC
1638 * @tc.require: AR000GHSJK
1639 */
1640 HWTEST_F(DmCredentialManagerTest, from_json_001, testing::ext::TestSize.Level1)
1641 {
1642 JsonObject jsonOutObj;
1643 CredentialDataInfo credentialDataInfo;
1644 jsonOutObj[FIELD_CREDENTIAL_TYPE] = "test";
1645 FromJson(jsonOutObj, credentialDataInfo);
1646
1647 jsonOutObj[FIELD_CREDENTIAL_TYPE] = NONSYMMETRY_CREDENTIAL_TYPE;
1648 jsonOutObj[FIELD_SERVER_PK] = 0;
1649 jsonOutObj[FIELD_PKINFO_SIGNATURE] = 0;
1650 jsonOutObj[FIELD_PKINFO] = 0;
1651 jsonOutObj[FIELD_PEER_DEVICE_ID] = 0;
1652 credentialDataInfo.serverPk = "";
1653 FromJson(jsonOutObj, credentialDataInfo);
1654 EXPECT_TRUE(credentialDataInfo.serverPk.empty());
1655
1656 JsonObject jsonPkInfo;
1657 jsonOutObj[FIELD_SERVER_PK] = "serverPk";
1658 jsonOutObj[FIELD_PKINFO_SIGNATURE] = "pkInfoSignature";
1659 jsonOutObj[FIELD_PKINFO] = jsonPkInfo.Dump();
1660 jsonOutObj[FIELD_PEER_DEVICE_ID] = "peerDeviceId";
1661 FromJson(jsonOutObj, credentialDataInfo);
1662 EXPECT_FALSE(credentialDataInfo.serverPk.empty());
1663
1664 jsonOutObj[FIELD_CREDENTIAL_TYPE] = SYMMETRY_CREDENTIAL_TYPE;
1665 jsonOutObj[FIELD_AUTH_CODE] = 0;
1666 credentialDataInfo.authCode = "";
1667 FromJson(jsonOutObj, credentialDataInfo);
1668 EXPECT_TRUE(credentialDataInfo.authCode.empty());
1669
1670 jsonOutObj[FIELD_AUTH_CODE] = "authCode";
1671 FromJson(jsonOutObj, credentialDataInfo);
1672 EXPECT_FALSE(credentialDataInfo.authCode.empty());
1673
1674 jsonOutObj[FIELD_CREDENTIAL_TYPE] = 0;
1675 FromJson(jsonOutObj, credentialDataInfo);
1676 EXPECT_FALSE(credentialDataInfo.authCode.empty());
1677 }
1678
1679 /**
1680 * @tc.name: from_json_002
1681 * @tc.desc: test from_json
1682 * @tc.type: FUNC
1683 * @tc.require: AR000GHSJK
1684 */
1685 HWTEST_F(DmCredentialManagerTest, from_json_002, testing::ext::TestSize.Level1)
1686 {
1687 JsonObject jsonObject;
1688 PeerCredentialInfo peerCredentialInfo;
1689 jsonObject[FIELD_PEER_USER_ID] = "peerDeviceId";
1690 FromJson(jsonObject, peerCredentialInfo);
1691 EXPECT_EQ(peerCredentialInfo.peerDeviceId, "peerDeviceId");
1692
1693 std::string deviceList = "deviceList";
1694 uint16_t deviceTypeId = 0;
1695 int32_t errcode = 0;
1696 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1697 dmCreMgr->HandleCredentialAuthStatus(deviceList, deviceTypeId, errcode);
1698 }
1699
1700 /**
1701 * @tc.name: to_json_001
1702 * @tc.desc: test to_json
1703 * @tc.type: FUNC
1704 * @tc.require: AR000GHSJK
1705 */
1706 HWTEST_F(DmCredentialManagerTest, to_json_001, testing::ext::TestSize.Level1)
1707 {
1708 CredentialDataInfo credentialDataInfo;
1709 credentialDataInfo.peerDeviceId = "test";
1710 credentialDataInfo.userId = "test";
1711 credentialDataInfo.credentailId = "test";
1712 credentialDataInfo.credentialType = NONSYMMETRY_CREDENTIAL_TYPE;
1713 credentialDataInfo.serverPk = "test";
1714 credentialDataInfo.pkInfoSignature = "test";
1715 credentialDataInfo.pkInfo = "test";
1716 credentialDataInfo.authCode = "test";
1717 JsonObject jsonObject;
1718 ToJson(jsonObject, credentialDataInfo);
1719 EXPECT_EQ(jsonObject[FIELD_SERVER_PK].Get<std::string>(), "test");
1720
1721 credentialDataInfo.credentialType = SYMMETRY_CREDENTIAL_TYPE;
1722 ToJson(jsonObject, credentialDataInfo);
1723 EXPECT_EQ(jsonObject[FIELD_AUTH_CODE].Get<std::string>(), "test");
1724
1725 credentialDataInfo.credentialType = UNKNOWN_CREDENTIAL_TYPE;
1726 ToJson(jsonObject, credentialDataInfo);
1727 EXPECT_EQ(jsonObject[FIELD_AUTH_CODE].Get<std::string>(), "test");
1728 }
1729 } // namespace DistributedHardware
1730 } // namespace OHOS
1731