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