1 /*
2 * Copyright (c) 2022 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_random.h"
21 #include "parameter.h"
22 #include "nativetoken_kit.h"
23 #include "token_setproc.h"
24 #include "softbus_common.h"
25
26 using namespace OHOS::Security::AccessToken;
27 namespace OHOS {
28 namespace DistributedHardware {
SetUp()29 void DmCredentialManagerTest::SetUp()
30 {
31 uint64_t tokenId;
32 const char *perms[2];
33 perms[0] = OHOS_PERMISSION_DISTRIBUTED_SOFTBUS_CENTER;
34 perms[1] = OHOS_PERMISSION_DISTRIBUTED_DATASYNC;
35 NativeTokenInfoParams infoInstance = {
36 .dcapsNum = 0,
37 .permsNum = 2,
38 .aclsNum = 0,
39 .dcaps = NULL,
40 .perms = perms,
41 .acls = NULL,
42 .processName = "dsoftbus_service",
43 .aplStr = "system_core",
44 };
45 tokenId = GetAccessTokenId(&infoInstance);
46 SetSelfTokenID(tokenId);
47 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
48 }
49
TearDown()50 void DmCredentialManagerTest::TearDown()
51 {
52 }
53
SetUpTestCase()54 void DmCredentialManagerTest::SetUpTestCase()
55 {
56 }
57
TearDownTestCase()58 void DmCredentialManagerTest::TearDownTestCase()
59 {
60 }
61
62 namespace {
63 std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
64 std::shared_ptr<HiChainConnector> hiChainConnector_ = std::make_shared<HiChainConnector>();
65
66 /**
67 * @tc.name: DmCredentialManager_001
68 * @tc.desc: Test whether the DmCredentialManager function can generate a new pointer
69 * @tc.type: FUNC
70 * @tc.require: AR000GHSJK
71 */
72 HWTEST_F(DmCredentialManagerTest, DmCredentialManager_001, testing::ext::TestSize.Level0)
73 {
74 std::shared_ptr<DmCredentialManager> Test = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
75 ASSERT_NE(Test, nullptr);
76 }
77
78 /**
79 * @tc.name: DmCredentialManager_002
80 * @tc.desc: Test whether the DmCredentialManager function can delete a new pointer
81 * @tc.type: FUNC
82 * @tc.require: AR000GHSJK
83 */
84 HWTEST_F(DmCredentialManagerTest, DmCredentialManager_002, testing::ext::TestSize.Level0)
85 {
86 std::shared_ptr<DmCredentialManager> Test = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
87 Test.reset();
88 EXPECT_EQ(Test, nullptr);
89 }
90
91 /**
92 * @tc.name:RegisterCredentialCallback_001
93 * @tc.desc: return DM_OK
94 * @tc.type: FUNC
95 * @tc.require: AR000GHSJK
96 */
97 HWTEST_F(DmCredentialManagerTest, RegisterCredentialCallback_001, testing::ext::TestSize.Level0)
98 {
99 std::string pkgName = "com.ohos.helloworld";
100 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
101 int32_t ret = dmCreMgr->RegisterCredentialCallback(pkgName);
102 EXPECT_EQ(ret, DM_OK);
103 }
104
105 /**
106 * @tc.name:RegisterCredentialCallback_002
107 * @tc.desc: return ERR_DM_FAILED
108 * @tc.type: FUNC
109 * @tc.require: AR000GHSJK
110 */
111 HWTEST_F(DmCredentialManagerTest, RegisterCredentialCallback_002, testing::ext::TestSize.Level0)
112 {
113 std::string pkgName = "";
114 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
115 int32_t ret = dmCreMgr->RegisterCredentialCallback(pkgName);
116 EXPECT_EQ(ret, ERR_DM_FAILED);
117 }
118
119 /**
120 * @tc.name:UnRegisterCredentialCallback_001
121 * @tc.desc: return DM_OK
122 * @tc.type: FUNC
123 * @tc.require: AR000GHSJK
124 */
125 HWTEST_F(DmCredentialManagerTest, UnRegisterCredentialCallback_001, testing::ext::TestSize.Level0)
126 {
127 std::string pkgName = "com.ohos.helloworld";
128 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
129 int32_t ret = dmCreMgr->RegisterCredentialCallback(pkgName);
130 EXPECT_EQ(ret, DM_OK);
131 }
132
133 /**
134 * @tc.name:UnRegisterCredentialCallback_002
135 * @tc.desc: return ERR_DM_FAILED
136 * @tc.type: FUNC
137 * @tc.require: AR000GHSJK
138 */
139 HWTEST_F(DmCredentialManagerTest, UnRegisterCredentialCallback_002, testing::ext::TestSize.Level0)
140 {
141 std::string pkgName = "";
142 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
143 int32_t ret = dmCreMgr->UnRegisterCredentialCallback(pkgName);
144 EXPECT_EQ(ret, ERR_DM_FAILED);
145 }
146
147 /**
148 * @tc.name:RequestCredential_002
149 * @tc.desc: get credential info and return ERR_DM_FAILED
150 * @tc.type: FUNC
151 * @tc.require: AR000GHSJK
152 */
153 HWTEST_F(DmCredentialManagerTest, RequestCredential_002, testing::ext::TestSize.Level0)
154 {
155 std::string reqJsonStr = R"(
156 {
157 "userId" , "123"
158 }
159 )";
160 std::string returnJsonStr;
161 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
162 int32_t ret = dmCreMgr->RequestCredential(reqJsonStr, returnJsonStr);
163 ASSERT_EQ(ret, ERR_DM_FAILED);
164 }
165
166 /**
167 * @tc.name:RequestCredential_003
168 * @tc.desc: get credential info and return ERR_DM_FAILED
169 * @tc.type: FUNC
170 * @tc.require: AR000GHSJK
171 */
172 HWTEST_F(DmCredentialManagerTest, RequestCredential_003, testing::ext::TestSize.Level0)
173 {
174 std::string reqJsonStr = R"(
175 {
176 "userId" : "123"
177 }
178 )";
179 std::string returnJsonStr;
180 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
181 int32_t ret = dmCreMgr->RequestCredential(reqJsonStr, returnJsonStr);
182 ASSERT_EQ(ret, ERR_DM_FAILED);
183 }
184
185 /**
186 * @tc.name:RequestCredential_004
187 * @tc.desc: get credential info and return ERR_DM_FAILED
188 * @tc.type: FUNC
189 * @tc.require: AR000GHSJK
190 */
191 HWTEST_F(DmCredentialManagerTest, RequestCredential_004, testing::ext::TestSize.Level0)
192 {
193 std::string reqJsonStr = R"(
194 {
195 "version" : "1.2.3"
196 }
197 )";
198 std::string returnJsonStr;
199 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
200 int32_t ret = dmCreMgr->RequestCredential(reqJsonStr, returnJsonStr);
201 ASSERT_EQ(ret, ERR_DM_FAILED);
202 }
203
204 /**
205 * @tc.name: ImportCredential_002
206 * @tc.desc: import local credential and return ERR_DM_FAILED
207 * @tc.type: FUNC
208 * @tc.require: AR000GHSJK
209 */
210 HWTEST_F(DmCredentialManagerTest, ImportCredential_002, testing::ext::TestSize.Level0)
211 {
212 std::string pkgName = "";
213 std::string credentialInfo = R"(
214 {
215 "processType" : 1,
216 "authType" : 1,
217 "userId" : "123",
218 "credentialData" :
219 [
220 {
221 "credentialType" : 1,
222 "credentialId" : "104",
223 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
224 "serverPk" : "",
225 "pkInfoSignature" : "",
226 "pkInfo" : "",
227 "peerDeviceId" : ""
228 }
229 ]
230 }
231 )";
232 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
233 dmCreMgr->credentialVec_.push_back(pkgName);
234 int32_t ret = dmCreMgr->ImportCredential(pkgName, credentialInfo);
235 EXPECT_EQ(ret, ERR_DM_FAILED);
236 }
237
238 /**
239 * @tc.name: ImportCredential_003
240 * @tc.desc: import local credential and return ERR_DM_FAILED
241 * @tc.type: FUNC
242 * @tc.require: AR000GHSJK
243 */
244 HWTEST_F(DmCredentialManagerTest, ImportCredential_003, testing::ext::TestSize.Level0)
245 {
246 std::string pkgName = "com.ohos.helloworld";
247 std::string credentialInfo = R"(
248 {
249 "userId" , "123"
250 }
251 )";
252 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
253 dmCreMgr->credentialVec_.push_back(pkgName);
254 int32_t ret = dmCreMgr->ImportCredential(pkgName, credentialInfo);
255 EXPECT_EQ(ret, ERR_DM_FAILED);
256 }
257
258 /**
259 * @tc.name: ImportCredential_004
260 * @tc.desc: import local credential and return ERR_DM_FAILED
261 * @tc.type: FUNC
262 * @tc.require: AR000GHSJK
263 */
264 HWTEST_F(DmCredentialManagerTest, ImportCredential_004, testing::ext::TestSize.Level0)
265 {
266 std::string pkgName = "com.ohos.helloworld";
267 std::string credentialInfo = R"(
268 {
269 "userId" , "123"
270 }
271 )";
272 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
273 dmCreMgr->credentialVec_.push_back(pkgName);
274 int32_t ret = dmCreMgr->ImportCredential(pkgName, credentialInfo);
275 EXPECT_EQ(ret, ERR_DM_FAILED);
276 }
277
278 /**
279 * @tc.name: ImportCredential_005
280 * @tc.desc: import local credential and return ERR_DM_FAILED
281 * @tc.type: FUNC
282 * @tc.require: AR000GHSJK
283 */
284 HWTEST_F(DmCredentialManagerTest, ImportCredential_005, testing::ext::TestSize.Level0)
285 {
286 std::string pkgName = "com.ohos.helloworld";
287 std::string credentialInfo = R"(
288 {
289 "authType" : 1,
290 "userId" : "123",
291 "credentialData" :
292 [
293 {
294 "credentialType" : 1,
295 "credentialId" : "104",
296 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
297 "serverPk" : "",
298 "pkInfoSignature" : "",
299 "pkInfo" : "",
300 "peerDeviceId" : ""
301 }
302 ]
303 }
304 )";
305 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
306 dmCreMgr->credentialVec_.push_back(pkgName);
307 int32_t ret = dmCreMgr->ImportCredential(pkgName, credentialInfo);
308 EXPECT_EQ(ret, ERR_DM_FAILED);
309 }
310
311 /**
312 * @tc.name: ImportCredential_006
313 * @tc.desc: import local credential and return ERR_DM_FAILED
314 * @tc.type: FUNC
315 * @tc.require: AR000GHSJK
316 */
317 HWTEST_F(DmCredentialManagerTest, ImportCredential_006, testing::ext::TestSize.Level0)
318 {
319 std::string pkgName = "com.ohos.helloworld";
320 std::string credentialInfo = R"(
321 {
322 "processType" : 0,
323 "authType" : 1,
324 "userId" : "123",
325 "credentialData" :
326 [
327 {
328 "credentialType" : 1,
329 "credentialId" : "104",
330 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
331 "serverPk" : "",
332 "pkInfoSignature" : "",
333 "pkInfo" : "",
334 "peerDeviceId" : ""
335 }
336 ]
337 }
338 )";
339 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
340 dmCreMgr->credentialVec_.push_back(pkgName);
341 int32_t ret = dmCreMgr->ImportCredential(pkgName, credentialInfo);
342 EXPECT_EQ(ret, ERR_DM_FAILED);
343 }
344
345 /**
346 * @tc.name: ImportLocalCredential_002
347 * @tc.desc: import local credential and return ERR_DM_FAILED
348 * @tc.type: FUNC
349 * @tc.require: AR000GHSJK
350 */
351 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_002, testing::ext::TestSize.Level0)
352 {
353 std::string pkgName = "com.ohos.helloworld";
354 std::string credentialInfo = R"(
355 {
356 "processType" , 1,
357 }
358 )";
359 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
360 int32_t ret = dmCreMgr->ImportLocalCredential(credentialInfo);
361 EXPECT_EQ(ret, ERR_DM_FAILED);
362 }
363
364 /**
365 * @tc.name: ImportLocalCredential_003
366 * @tc.desc: import local credential and return ERR_DM_FAILED
367 * @tc.type: FUNC
368 * @tc.require: AR000GHSJK
369 */
370 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_003, testing::ext::TestSize.Level0)
371 {
372 std::string credentialInfo = R"(
373 {
374 "processType" : 1,
375 "userId" : "123",
376 "credentialData" :
377 [
378 {
379 "credentialType" : 1,
380 "credentialId" : "104",
381 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
382 "serverPk" : "",
383 "pkInfoSignature" : "",
384 "pkInfo" : "",
385 "peerDeviceId" : ""
386 }
387 ]
388 }
389 )";
390 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
391 int32_t ret = dmCreMgr->ImportLocalCredential(credentialInfo);
392 EXPECT_EQ(ret, ERR_DM_FAILED);
393 }
394
395 /**
396 * @tc.name: ImportLocalCredential_004
397 * @tc.desc: import local credential and return ERR_DM_FAILED
398 * @tc.type: FUNC
399 * @tc.require: AR000GHSJK
400 */
401 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_004, testing::ext::TestSize.Level0)
402 {
403 std::string credentialInfo = R"(
404 {
405 "processType" : 1,
406 "authType" : 1,
407 "credentialData" :
408 [
409 {
410 "credentialType" : 1,
411 "credentialId" : "104",
412 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
413 "serverPk" : "",
414 "pkInfoSignature" : "",
415 "pkInfo" : "",
416 "peerDeviceId" : ""
417 }
418 ]
419 }
420 )";
421 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
422 int32_t ret = dmCreMgr->ImportLocalCredential(credentialInfo);
423 EXPECT_EQ(ret, ERR_DM_FAILED);
424 }
425
426 /**
427 * @tc.name: ImportLocalCredential_005
428 * @tc.desc: import local credential and return ERR_DM_FAILED
429 * @tc.type: FUNC
430 * @tc.require: AR000GHSJK
431 */
432 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_005, testing::ext::TestSize.Level0)
433 {
434 std::string credentialInfo = R"(
435 {
436 "processType" : 1,
437 "authType" : 1,
438 "userId" : "123"
439 }
440 )";
441 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
442 int32_t ret = dmCreMgr->ImportLocalCredential(credentialInfo);
443 EXPECT_EQ(ret, ERR_DM_FAILED);
444 }
445
446 /**
447 * @tc.name: ImportLocalCredential_006
448 * @tc.desc: import local credential and return ERR_DM_FAILED
449 * @tc.type: FUNC
450 * @tc.require: AR000GHSJK
451 */
452 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_006, testing::ext::TestSize.Level0)
453 {
454 std::string credentialInfo = R"(
455 {
456 "processType" : 1,
457 "authType" : 1,
458 "userId" : "123",
459 "credentialData" :
460 [
461 {
462 "credentialType" : 1,
463 "credentialId" : "104",
464 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
465 "serverPk" : "",
466 "pkInfoSignature" : "",
467 "pkInfo" : "",
468 "peerDeviceId" : ""
469 }
470 {
471 "credentialType" : 1,
472 "credentialId" : "104",
473 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
474 "serverPk" : "",
475 "pkInfoSignature" : "",
476 "pkInfo" : "",
477 "peerDeviceId" : ""
478 }
479 ]
480 }
481 )";
482 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
483 int32_t ret = dmCreMgr->ImportLocalCredential(credentialInfo);
484 EXPECT_EQ(ret, ERR_DM_FAILED);
485 }
486
487 /**
488 * @tc.name: ImportRemoteCredential_002
489 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
490 * @tc.type: FUNC
491 * @tc.require: AR000GHSJK
492 */
493 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_002, testing::ext::TestSize.Level0)
494 {
495 std::string credentialInfo = R"(
496 {
497 "processType" , 2,
498 }
499 )";
500 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
501 int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
502 EXPECT_EQ(ret, ERR_DM_FAILED);
503 }
504
505 /**
506 * @tc.name: ImportRemoteCredential_003
507 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
508 * @tc.type: FUNC
509 * @tc.require: AR000GHSJK
510 */
511 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_003, testing::ext::TestSize.Level0)
512 {
513 std::string credentialInfo = R"(
514 {
515 "processType" : 2,
516 "authType" : 1,
517 "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
518 }
519 )";
520 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
521 int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
522 EXPECT_EQ(ret, ERR_DM_FAILED);
523 }
524
525 /**
526 * @tc.name: ImportRemoteCredential_004
527 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
528 * @tc.type: FUNC
529 * @tc.require: AR000GHSJK
530 */
531 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_004, testing::ext::TestSize.Level0)
532 {
533 std::string credentialInfo = R"(
534 {
535 "processType" : 2,
536 "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
537 "credentialData" :
538 [
539 {
540 "credentialType" : 1,
541 "credentialId" : "104",
542 "authCode" : "456",
543 "peerDeviceId" : "devD"
544 }
545 ]
546 }
547 )";
548 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
549 int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
550 EXPECT_EQ(ret, ERR_DM_FAILED);
551 }
552
553 /**
554 * @tc.name: ImportRemoteCredential_005
555 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
556 * @tc.type: FUNC
557 * @tc.require: AR000GHSJK
558 */
559 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_005, testing::ext::TestSize.Level0)
560 {
561 std::string credentialInfo = R"(
562 {
563 "processType" : 2,
564 "authType" : 1,
565 "credentialData" :
566 [
567 {
568 "credentialType" : 1,
569 "credentialId" : "104",
570 "authCode" : "456",
571 "peerDeviceId" : "devD"
572 }
573 ]
574 }
575 )";
576 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
577 int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
578 EXPECT_EQ(ret, ERR_DM_FAILED);
579 }
580
581 /**
582 * @tc.name: ImportRemoteCredential_006
583 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
584 * @tc.type: FUNC
585 * @tc.require: AR000GHSJK
586 */
587 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_006, testing::ext::TestSize.Level0)
588 {
589 std::string credentialInfo = R"(
590 {
591 "processType" : 2,
592 "authType" : 2,
593 "credentialData" :
594 [
595 {
596 "credentialType" : 1,
597 "credentialId" : "104",
598 "authCode" : "456",
599 "peerDeviceId" : "devD"
600 }
601 ]
602 }
603 )";
604 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
605 int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
606 EXPECT_EQ(ret, ERR_DM_FAILED);
607 }
608
609 /**
610 * @tc.name: ImportRemoteCredential_007
611 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
612 * @tc.type: FUNC
613 * @tc.require: AR000GHSJK
614 */
615 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_007, testing::ext::TestSize.Level0)
616 {
617 std::string credentialInfo = R"(
618 {
619 "processType" : 2,
620 "authType" : "x",
621 "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
622 "credentialData" :
623 [
624 {
625 "credentialType" : 1,
626 "credentialId" : "104",
627 "authCode" : "456",
628 "peerDeviceId" : "devD"
629 }
630 ]
631 }
632 )";
633 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
634 int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
635 EXPECT_EQ(ret, ERR_DM_FAILED);
636 }
637
638 /**
639 * @tc.name: ImportRemoteCredential_008
640 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
641 * @tc.type: FUNC
642 * @tc.require: AR000GHSJK
643 */
644 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_008, testing::ext::TestSize.Level0)
645 {
646 std::string credentialInfo = R"(
647 {
648 "processType" : 2,
649 "authType" : 1,
650 "userId" : "",
651 "credentialData" :
652 [
653 {
654 "credentialType" : 1,
655 "credentialId" : "104",
656 "authCode" : "456",
657 "peerDeviceId" : "devD"
658 }
659 ]
660 }
661 )";
662 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
663 int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
664 EXPECT_EQ(ret, ERR_DM_FAILED);
665 }
666
667 /**
668 * @tc.name: DeleteRemoteCredential_002
669 * @tc.desc: delete remote credential and return ERR_DM_FAILED
670 * @tc.type: FUNC
671 * @tc.require: AR000GHSJK
672 */
673 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_002, testing::ext::TestSize.Level0)
674 {
675 std::string credentialInfo = R"(
676 {
677 "processType" , 2,
678 }
679 )";
680 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
681 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
682 EXPECT_EQ(ret, ERR_DM_FAILED);
683 }
684
685 /**
686 * @tc.name: DeleteRemoteCredential_003
687 * @tc.desc: delete remote credential and return ERR_DM_FAILED
688 * @tc.type: FUNC
689 * @tc.require: AR000GHSJK
690 */
691 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_003, testing::ext::TestSize.Level0)
692 {
693 std::string credentialInfo = R"(
694 {
695 "processType" : 2,
696 "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
697 "peerCredentialInfo" :
698 [
699 {
700 "peerDeviceId" : "devD"
701 }
702 ]
703 }
704 )";
705 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
706 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
707 EXPECT_EQ(ret, ERR_DM_FAILED);
708 }
709
710 /**
711 * @tc.name: DeleteRemoteCredential_004
712 * @tc.desc: delete remote credential and return ERR_DM_FAILED
713 * @tc.type: FUNC
714 * @tc.require: AR000GHSJK
715 */
716 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_004, testing::ext::TestSize.Level0)
717 {
718 std::string credentialInfo = R"(
719 {
720 "processType" : 2,
721 "authType" : 1,
722 "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
723 }
724 )";
725 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
726 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
727 EXPECT_EQ(ret, ERR_DM_FAILED);
728 }
729
730 /**
731 * @tc.name: DeleteRemoteCredential_005
732 * @tc.desc: delete remote credential and return ERR_DM_FAILED
733 * @tc.type: FUNC
734 * @tc.require: AR000GHSJK
735 */
736 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_005, testing::ext::TestSize.Level0)
737 {
738 std::string credentialInfo = R"(
739 {
740 "processType" : 2,
741 "authType" : 1,
742 "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
743 "peerCredentialInfo" :
744 [
745 {
746 "peerDeviceId" : "devD"
747 }
748 ]
749 }
750 )";
751 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
752 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
753 EXPECT_EQ(ret, ERR_DM_FAILED);
754 }
755
756 /**
757 * @tc.name: DeleteRemoteCredential_006
758 * @tc.desc: delete remote credential and return ERR_DM_FAILED
759 * @tc.type: FUNC
760 * @tc.require: AR000GHSJK
761 */
762 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_006, testing::ext::TestSize.Level0)
763 {
764 std::string credentialInfo = R"(
765 {
766 "processType" : 2,
767 "authType" : 1,
768 "peerCredentialInfo" :
769 [
770 {
771 "peerDeviceId" : "devD"
772 }
773 ]
774 }
775 )";
776 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
777 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
778 EXPECT_EQ(ret, ERR_DM_FAILED);
779 }
780
781 /**
782 * @tc.name: DeleteRemoteCredential_007
783 * @tc.desc: delete remote credential and return ERR_DM_FAILED
784 * @tc.type: FUNC
785 * @tc.require: AR000GHSJK
786 */
787 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_007, testing::ext::TestSize.Level0)
788 {
789 std::string credentialInfo = R"(
790 {
791 "processType" : 2,
792 "authType" : 2,
793 "peerCredentialInfo" :
794 [
795 {
796 "peerDeviceId" : "devD"
797 }
798 ]
799 }
800 )";
801 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
802 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
803 EXPECT_EQ(ret, ERR_DM_FAILED);
804 }
805
806 /**
807 * @tc.name: DeleteRemoteCredential_008
808 * @tc.desc: delete remote credential and return ERR_DM_FAILED
809 * @tc.type: FUNC
810 * @tc.require: AR000GHSJK
811 */
812 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_008, testing::ext::TestSize.Level0)
813 {
814 std::string credentialInfo = R"(
815 {
816 "processType" : 2,
817 "authType" : 1,
818 }
819 )";
820 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
821 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
822 EXPECT_EQ(ret, ERR_DM_FAILED);
823 }
824
825 /**
826 * @tc.name: DeleteRemoteCredential_009
827 * @tc.desc: delete remote credential and return ERR_DM_FAILED
828 * @tc.type: FUNC
829 * @tc.require: AR000GHSJK
830 */
831 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_009, testing::ext::TestSize.Level0)
832 {
833 std::string credentialInfo = R"(
834 {
835 "processType" : 2,
836 "authType" : 2,
837 }
838 )";
839 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
840 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
841 EXPECT_EQ(ret, ERR_DM_FAILED);
842 }
843
844 /**
845 * @tc.name: DeleteRemoteCredential_0010
846 * @tc.desc: delete remote credential and return ERR_DM_FAILED
847 * @tc.type: FUNC
848 * @tc.require: AR000GHSJK
849 */
850 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_0010, testing::ext::TestSize.Level0)
851 {
852 std::string credentialInfo = R"(
853 {
854 "processType" : 2,
855 "authType" : 1,
856 "userId": "123",
857 "peerCredentialInfo" :
858 [
859 {
860 "peerDeviceId" : "devD"
861 }
862 ]
863 }
864 )";
865 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
866 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
867 EXPECT_EQ(ret, ERR_DM_FAILED);
868 }
869
870 /**
871 * @tc.name: DeleteRemoteCredential_0011
872 * @tc.desc: delete remote credential and return ERR_DM_FAILED
873 * @tc.type: FUNC
874 * @tc.require: AR000GHSJK
875 */
876 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_0011, testing::ext::TestSize.Level0)
877 {
878 std::string credentialInfo = R"(
879 {
880 "processType" : 2,
881 "authType" : 2,
882 "peerUserId": "123",
883 "peerCredentialInfo" :
884 [
885 {
886 "peerDeviceId" : "devD"
887 }
888 ]
889 }
890 )";
891 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
892 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
893 EXPECT_EQ(ret, ERR_DM_FAILED);
894 }
895
896 /**
897 * @tc.name: DeleteCredential_002
898 * @tc.desc: delete local credential and return ERR_DM_FAILED
899 * @tc.type: FUNC
900 * @tc.require: AR000GHSJK
901 */
902 HWTEST_F(DmCredentialManagerTest, DeleteCredential_002, testing::ext::TestSize.Level0)
903 {
904 std::string pkgName = "";
905 std::string credentialInfo = R"(
906 {
907 "processType" : 1,
908 "authType" : 1,
909 "userId" : "123"
910 }
911 )";
912 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
913 dmCreMgr->credentialVec_.push_back(pkgName);
914 int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
915 EXPECT_EQ(ret, ERR_DM_FAILED);
916 }
917
918 /**
919 * @tc.name: DeleteCredential_003
920 * @tc.desc: delete remote credential and return ERR_DM_FAILED
921 * @tc.type: FUNC
922 * @tc.require: AR000GHSJK
923 */
924 HWTEST_F(DmCredentialManagerTest, DeleteCredential_003, testing::ext::TestSize.Level0)
925 {
926 std::string pkgName = "com.ohos.helloworld";
927 std::string credentialInfo = R"(
928 {
929 "userId" , "123"
930 }
931 )";
932 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
933 dmCreMgr->credentialVec_.push_back(pkgName);
934 int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
935 EXPECT_EQ(ret, ERR_DM_FAILED);
936 }
937
938 /**
939 * @tc.name: DeleteCredential_004
940 * @tc.desc: delete remote credential and return ERR_DM_FAILED
941 * @tc.type: FUNC
942 * @tc.require: AR000GHSJK
943 */
944 HWTEST_F(DmCredentialManagerTest, DeleteCredential_004, testing::ext::TestSize.Level0)
945 {
946 std::string pkgName = "com.ohos.helloworld";
947 std::string credentialInfo = R"(
948 {
949 "authType" : 1,
950 "userId" : "123"
951 }
952 )";
953 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
954 dmCreMgr->credentialVec_.push_back(pkgName);
955 int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
956 EXPECT_EQ(ret, ERR_DM_FAILED);
957 }
958
959 /**
960 * @tc.name: DeleteCredential_005
961 * @tc.desc: delete remote credential and return ERR_DM_FAILED
962 * @tc.type: FUNC
963 * @tc.require: AR000GHSJK
964 */
965 HWTEST_F(DmCredentialManagerTest, DeleteCredential_005, testing::ext::TestSize.Level0)
966 {
967 std::string pkgName = "com.ohos.helloworld";
968 std::string credentialInfo = R"(
969 {
970 "processType" : 1,
971 "userId" : "123"
972 }
973 )";
974 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
975 dmCreMgr->credentialVec_.push_back(pkgName);
976 int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
977 EXPECT_EQ(ret, ERR_DM_FAILED);
978 }
979
980 /**
981 * @tc.name: DeleteCredential_006
982 * @tc.desc: delete remote credential and return ERR_DM_FAILED
983 * @tc.type: FUNC
984 * @tc.require: AR000GHSJK
985 */
986 HWTEST_F(DmCredentialManagerTest, DeleteCredential_006, testing::ext::TestSize.Level0)
987 {
988 std::string pkgName = "com.ohos.helloworld";
989 std::string credentialInfo = R"(
990 {
991 "processType" : 0,
992 "authType" : 1,
993 "userId" : "123"
994 }
995 )";
996 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
997 dmCreMgr->credentialVec_.push_back(pkgName);
998 int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
999 EXPECT_EQ(ret, ERR_DM_FAILED);
1000 }
1001
1002 /**
1003 * @tc.name: GetCredentialData_001
1004 * @tc.desc: get symmetry credential data and return DM_OK
1005 * @tc.type: FUNC
1006 * @tc.require: AR000GHSJK
1007 */
1008 HWTEST_F(DmCredentialManagerTest, GetCredentialData_001, testing::ext::TestSize.Level0)
1009 {
1010 std::string credentialInfo = R"(
1011 {
1012 "processType" : 1,
1013 "authType" : 1,
1014 "userId" : "123",
1015 "credentialData" :
1016 [
1017 {
1018 "credentialType" : 1,
1019 "credentialId" : "104",
1020 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1021 "serverPk" : "",
1022 "pkInfoSignature" : "",
1023 "pkInfo" : "",
1024 "peerDeviceId" : ""
1025 }
1026 ]
1027 }
1028 )";
1029 CredentialData credentialData;
1030 credentialData.credentialType = 1;
1031 credentialData.credentialId = "104";
1032 credentialData.serverPk = "";
1033 credentialData.pkInfoSignature = "";
1034 credentialData.pkInfo = "";
1035 credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1036 credentialData.peerDeviceId = "";
1037 nlohmann::json jsonOutObj;
1038 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1039 int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1040 EXPECT_EQ(ret, DM_OK);
1041 }
1042
1043 /**
1044 * @tc.name: GetCredentialData_002
1045 * @tc.desc: get symmetry credential data and return ERR_DM_FAILED
1046 * @tc.type: FUNC
1047 * @tc.require: AR000GHSJK
1048 */
1049 HWTEST_F(DmCredentialManagerTest, GetCredentialData_002, testing::ext::TestSize.Level0)
1050 {
1051 std::string credentialInfo = R"(
1052 {
1053 "processType" : 1,
1054 "authType" : 1,
1055 "userId" : "123",
1056 "credentialData" :
1057 [
1058 {
1059 "credentialType" : 0,
1060 "credentialId" : "104",
1061 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1062 "serverPk" : "",
1063 "pkInfoSignature" : "",
1064 "pkInfo" : "",
1065 "peerDeviceId" : ""
1066 }
1067 ]
1068 }
1069 )";
1070 CredentialData credentialData;
1071 credentialData.credentialType = 0;
1072 credentialData.credentialId = "104";
1073 credentialData.serverPk = "";
1074 credentialData.pkInfoSignature = "";
1075 credentialData.pkInfo = "";
1076 credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1077 credentialData.peerDeviceId = "";
1078 nlohmann::json jsonOutObj;
1079 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1080 int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1081 EXPECT_EQ(ret, ERR_DM_FAILED);
1082 }
1083
1084 /**
1085 * @tc.name: GetCredentialData_003
1086 * @tc.desc: get nonsymmetry credential data and return ERR_DM_FAILED
1087 * @tc.type: FUNC
1088 * @tc.require: AR000GHSJK
1089 */
1090 HWTEST_F(DmCredentialManagerTest, GetCredentialData_003, testing::ext::TestSize.Level0)
1091 {
1092 std::string credentialInfo = R"(
1093 {
1094 "processType" , 1,
1095 "authType" : 1,
1096 "userId" : "123",
1097 "version" : "1.2.3",
1098 "deviceId" : "aaa",
1099 "devicePk" : "0000",
1100 "credentialData" :
1101 [
1102 {
1103 "credentialType" : 2,
1104 "credentialId" : "104",
1105 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1106 "serverPk" : "",
1107 "pkInfoSignature" : "",
1108 "pkInfo" : "",
1109 "peerDeviceId" : ""
1110 }
1111 ]
1112 }
1113 )";
1114 CredentialData credentialData;
1115 credentialData.credentialType = 2;
1116 credentialData.credentialId = "104";
1117 credentialData.serverPk = "";
1118 credentialData.pkInfoSignature = "";
1119 credentialData.pkInfo = "";
1120 credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1121 credentialData.peerDeviceId = "";
1122 nlohmann::json jsonOutObj;
1123 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1124 int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1125 EXPECT_EQ(ret, ERR_DM_FAILED);
1126 }
1127
1128 /**
1129 * @tc.name: GetCredentialData_004
1130 * @tc.desc: get nonsymmetry credential data and return ERR_DM_FAILED
1131 * @tc.type: FUNC
1132 * @tc.require: AR000GHSJK
1133 */
1134 HWTEST_F(DmCredentialManagerTest, GetCredentialData_004, testing::ext::TestSize.Level0)
1135 {
1136 std::string credentialInfo = R"(
1137 {
1138 "processType" : 1,
1139 "authType" : 1,
1140 "version" : "1.2.3",
1141 "deviceId" : "aaa",
1142 "devicePk" : "0000",
1143 "credentialData" :
1144 [
1145 {
1146 "credentialType" : 2,
1147 "credentialId" : "104",
1148 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1149 "serverPk" : "",
1150 "pkInfoSignature" : "",
1151 "pkInfo" : "",
1152 "peerDeviceId" : ""
1153 }
1154 ]
1155 }
1156 )";
1157 CredentialData credentialData;
1158 credentialData.credentialType = 2;
1159 credentialData.credentialId = "104";
1160 credentialData.serverPk = "";
1161 credentialData.pkInfoSignature = "";
1162 credentialData.pkInfo = "";
1163 credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1164 credentialData.peerDeviceId = "";
1165 nlohmann::json jsonOutObj;
1166 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1167 int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1168 EXPECT_EQ(ret, ERR_DM_FAILED);
1169 }
1170
1171 /**
1172 * @tc.name: GetCredentialData_005
1173 * @tc.desc: get nonsymmetry credential data and return ERR_DM_FAILED
1174 * @tc.type: FUNC
1175 * @tc.require: AR000GHSJK
1176 */
1177 HWTEST_F(DmCredentialManagerTest, GetCredentialData_005, testing::ext::TestSize.Level0)
1178 {
1179 std::string credentialInfo = R"(
1180 {
1181 "processType" : 1,
1182 "authType" : 1,
1183 "userId" : "123",
1184 "deviceId" : "aaa",
1185 "devicePk" : "0000",
1186 "credentialData" :
1187 [
1188 {
1189 "credentialType" : 2,
1190 "credentialId" : "104",
1191 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1192 "serverPk" : "",
1193 "pkInfoSignature" : "",
1194 "pkInfo" : "",
1195 "peerDeviceId" : ""
1196 }
1197 ]
1198 }
1199 )";
1200 CredentialData credentialData;
1201 credentialData.credentialType = 2;
1202 credentialData.credentialId = "104";
1203 credentialData.serverPk = "";
1204 credentialData.pkInfoSignature = "";
1205 credentialData.pkInfo = "";
1206 credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1207 credentialData.peerDeviceId = "";
1208 nlohmann::json jsonOutObj;
1209 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1210 int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1211 EXPECT_EQ(ret, ERR_DM_FAILED);
1212 }
1213
1214 /**
1215 * @tc.name: GetCredentialData_006
1216 * @tc.desc: get nonsymmetry credential data and return ERR_DM_FAILED
1217 * @tc.type: FUNC
1218 * @tc.require: AR000GHSJK
1219 */
1220 HWTEST_F(DmCredentialManagerTest, GetCredentialData_006, testing::ext::TestSize.Level0)
1221 {
1222 std::string credentialInfo = R"(
1223 {
1224 "processType" : 1,
1225 "authType" : 1,
1226 "userId" : "123",
1227 "version" : "1.2.3",
1228 "devicePk" : "0000",
1229 "credentialData" :
1230 [
1231 {
1232 "credentialType" : 2,
1233 "credentialId" : "104",
1234 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1235 "serverPk" : "",
1236 "pkInfoSignature" : "",
1237 "pkInfo" : "",
1238 "peerDeviceId" : ""
1239 }
1240 ]
1241 }
1242 )";
1243 CredentialData credentialData;
1244 credentialData.credentialType = 2;
1245 credentialData.credentialId = "104";
1246 credentialData.serverPk = "";
1247 credentialData.pkInfoSignature = "";
1248 credentialData.pkInfo = "";
1249 credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1250 credentialData.peerDeviceId = "";
1251 nlohmann::json jsonOutObj;
1252 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1253 int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1254 EXPECT_EQ(ret, ERR_DM_FAILED);
1255 }
1256
1257 /**
1258 * @tc.name: GetCredentialData_007
1259 * @tc.desc: get nonsymmetry credential data and return ERR_DM_FAILED
1260 * @tc.type: FUNC
1261 * @tc.require: AR000GHSJK
1262 */
1263 HWTEST_F(DmCredentialManagerTest, GetCredentialData_007, testing::ext::TestSize.Level0)
1264 {
1265 std::string credentialInfo = R"(
1266 {
1267 "processType" : 1,
1268 "authType" : 1,
1269 "userId" : "123",
1270 "version" : "1.2.3",
1271 "deviceId" : "aaa",
1272 "credentialData" :
1273 [
1274 {
1275 "credentialType" : 2,
1276 "credentialId" : "104",
1277 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1278 "serverPk" : "",
1279 "pkInfoSignature" : "",
1280 "pkInfo" : "",
1281 "peerDeviceId" : ""
1282 }
1283 ]
1284 }
1285 )";
1286 CredentialData credentialData;
1287 credentialData.credentialType = 2;
1288 credentialData.credentialId = "104";
1289 credentialData.serverPk = "";
1290 credentialData.pkInfoSignature = "";
1291 credentialData.pkInfo = "";
1292 credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1293 credentialData.peerDeviceId = "";
1294 nlohmann::json jsonOutObj;
1295 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1296 int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1297 EXPECT_EQ(ret, ERR_DM_FAILED);
1298 }
1299
1300 /**
1301 * @tc.name: GetCredentialData_008
1302 * @tc.desc: get nonsymmetry credential data and return ERR_DM_FAILED
1303 * @tc.type: FUNC
1304 * @tc.require: AR000GHSJK
1305 */
1306 HWTEST_F(DmCredentialManagerTest, GetCredentialData_008, testing::ext::TestSize.Level0)
1307 {
1308 std::string credentialInfo = R"(
1309 {
1310 "processType" : 1,
1311 "authType" : 1,
1312 "userId" : "123",
1313 "version" : "1.2.3",
1314 "deviceId" : "aaa",
1315 "devicePk" : "0000",
1316 "credentialData" :
1317 [
1318 {
1319 "credentialType" : 2,
1320 "credentialId" : "104",
1321 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1322 "serverPk" : "",
1323 "pkInfoSignature" : "",
1324 "pkInfo" : "",
1325 "peerDeviceId" : ""
1326 }
1327 ]
1328 }
1329 )";
1330 CredentialData credentialData;
1331 credentialData.credentialType = 2;
1332 credentialData.credentialId = "104";
1333 credentialData.serverPk = "";
1334 credentialData.pkInfoSignature = "";
1335 credentialData.pkInfo = "";
1336 credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1337 credentialData.peerDeviceId = "";
1338 nlohmann::json jsonOutObj;
1339 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1340 int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1341 EXPECT_EQ(ret, DM_OK);
1342 }
1343 } // namespace
1344 } // namespace DistributedHardware
1345 } // namespace OHOS
1346