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_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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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     nlohmann::json 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.Level0)
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.Level0)
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.Level0)
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.Level0)
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     nlohmann::json jsonObject = nlohmann::json::parse(credentialInfo, nullptr, false);
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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     nlohmann::json jsonObject1 = nlohmann::json(credentialDataInfo);
712     nlohmann::json credentialJson = nlohmann::json::array();
713     credentialJson.push_back(jsonObject1);
714     nlohmann::json jsonObject;
715     jsonObject[FIELD_CREDENTIAL_DATA] = credentialJson;
716     jsonObject[FIELD_AUTH_TYPE] = CROSS_ACCOUNT_TYPE;
717     jsonObject[FIELD_USER_ID] = 0;
718     jsonObject[FIELD_PEER_USER_ID] = "peerUserId";
719 
720     std::string credentialInfo = jsonObject.dump();
721     dmCreMgr_->hiChainConnector_->deviceGroupManager_ = nullptr;
722     int32_t ret = dmCreMgr_->ImportRemoteCredential(credentialInfo);
723     EXPECT_EQ(ret, ERR_DM_FAILED);
724 
725     jsonObject[FIELD_CREDENTIAL_DATA] = 0;
726     credentialInfo = jsonObject.dump();
727     ret = dmCreMgr_->ImportRemoteCredential(credentialInfo);
728     EXPECT_EQ(ret, ERR_DM_FAILED);
729 }
730 
731 /**
732  * @tc.name: ImportRemoteCredential_002
733  * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
734  * @tc.type: FUNC
735  * @tc.require: AR000GHSJK
736  */
737 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_002, testing::ext::TestSize.Level0)
738 {
739     std::string credentialInfo = R"(
740     {
741         "processType", 2,
742     }
743     )";
744     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
745     int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
746     EXPECT_EQ(ret, ERR_DM_FAILED);
747 }
748 
749 /**
750  * @tc.name: ImportRemoteCredential_003
751  * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
752  * @tc.type: FUNC
753  * @tc.require: AR000GHSJK
754  */
755 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_003, testing::ext::TestSize.Level0)
756 {
757     std::string credentialInfo = R"(
758     {
759         "processType" : 2,
760         "authType" : 1,
761         "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
762     }
763     )";
764     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
765     int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
766     EXPECT_EQ(ret, ERR_DM_FAILED);
767 }
768 
769 /**
770  * @tc.name: ImportRemoteCredential_004
771  * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
772  * @tc.type: FUNC
773  * @tc.require: AR000GHSJK
774  */
775 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_004, testing::ext::TestSize.Level0)
776 {
777     std::string credentialInfo = R"(
778     {
779         "processType" : 2,
780         "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
781         "credentialData" :
782         [
783             {
784                 "credentialType" : 1,
785                 "credentialId" : "104",
786                 "authCode" : "456",
787                 "peerDeviceId" : "devD"
788             }
789         ]
790     }
791     )";
792     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
793     int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
794     EXPECT_EQ(ret, ERR_DM_FAILED);
795 }
796 
797 /**
798  * @tc.name: ImportRemoteCredential_005
799  * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
800  * @tc.type: FUNC
801  * @tc.require: AR000GHSJK
802  */
803 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_005, testing::ext::TestSize.Level0)
804 {
805     std::string credentialInfo = R"(
806     {
807         "processType" : 2,
808         "authType" : 1,
809         "credentialData" :
810         [
811             {
812                 "credentialType" : 1,
813                 "credentialId" : "104",
814                 "authCode" : "456",
815                 "peerDeviceId" : "devD"
816             }
817         ]
818     }
819     )";
820     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
821     int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
822     EXPECT_EQ(ret, ERR_DM_FAILED);
823 }
824 
825 /**
826  * @tc.name: ImportRemoteCredential_006
827  * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
828  * @tc.type: FUNC
829  * @tc.require: AR000GHSJK
830  */
831 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_006, testing::ext::TestSize.Level0)
832 {
833     std::string credentialInfo = R"(
834     {
835         "processType" : 2,
836         "authType" : 2,
837         "credentialData" :
838         [
839             {
840                 "credentialType" : 1,
841                 "credentialId" : "104",
842                 "authCode" : "456",
843                 "peerDeviceId" : "devD"
844             }
845         ]
846     }
847     )";
848     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
849     int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
850     EXPECT_EQ(ret, ERR_DM_FAILED);
851 }
852 
853 /**
854  * @tc.name: ImportRemoteCredential_007
855  * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
856  * @tc.type: FUNC
857  * @tc.require: AR000GHSJK
858  */
859 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_007, testing::ext::TestSize.Level0)
860 {
861     std::string credentialInfo = R"(
862     {
863         "processType" : 2,
864         "authType" : "x",
865         "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
866         "credentialData" :
867         [
868             {
869                 "credentialType" : 1,
870                 "credentialId" : "104",
871                 "authCode" : "456",
872                 "peerDeviceId" : "devD"
873             }
874         ]
875     }
876     )";
877     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
878     int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
879     EXPECT_EQ(ret, ERR_DM_FAILED);
880 }
881 
882 /**
883  * @tc.name: ImportRemoteCredential_008
884  * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
885  * @tc.type: FUNC
886  * @tc.require: AR000GHSJK
887  */
888 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_008, testing::ext::TestSize.Level0)
889 {
890     std::string credentialInfo = R"(
891     {
892         "processType" : 2,
893         "authType" : 1,
894         "userId" : "",
895         "credentialData" :
896         [
897             {
898                 "credentialType" : 1,
899                 "credentialId" : "104",
900                 "authCode" : "456",
901                 "peerDeviceId" : "devD"
902             }
903         ]
904     }
905     )";
906     int32_t ret = dmCreMgr_->ImportRemoteCredential(credentialInfo);
907     EXPECT_EQ(ret, ERR_DM_FAILED);
908 }
909 
910 /**
911  * @tc.name: DeleteRemoteCredential_001
912  * @tc.desc: delete remote credential and return ERR_DM_FAILED
913  * @tc.type: FUNC
914  * @tc.require: AR000GHSJK
915  */
916 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_001, testing::ext::TestSize.Level0)
917 {
918     std::string credentialInfo = R"(
919     {
920         "processType" : 2,
921         "authType" : 2,
922         "peerUserId": "123",
923         "peerCredentialInfo" : 0
924     }
925     )";
926     int32_t ret = dmCreMgr_->DeleteRemoteCredential(credentialInfo);
927     EXPECT_EQ(ret, ERR_DM_FAILED);
928 }
929 
930 /**
931  * @tc.name: DeleteRemoteCredential_002
932  * @tc.desc: delete remote credential and return ERR_DM_FAILED
933  * @tc.type: FUNC
934  * @tc.require: AR000GHSJK
935  */
936 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_002, testing::ext::TestSize.Level0)
937 {
938     std::string credentialInfo = R"(
939     {
940         "processType", 2,
941     }
942     )";
943     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
944     int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
945     EXPECT_EQ(ret, ERR_DM_FAILED);
946 }
947 
948 /**
949  * @tc.name: DeleteRemoteCredential_003
950  * @tc.desc: delete remote credential and return ERR_DM_FAILED
951  * @tc.type: FUNC
952  * @tc.require: AR000GHSJK
953  */
954 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_003, testing::ext::TestSize.Level0)
955 {
956     std::string credentialInfo = R"(
957     {
958         "processType" : 2,
959         "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
960         "peerCredentialInfo" :
961         [
962             {
963                 "peerDeviceId" : "devD"
964             }
965         ]
966     }
967     )";
968     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
969     int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
970     EXPECT_EQ(ret, ERR_DM_FAILED);
971 }
972 
973 /**
974  * @tc.name: DeleteRemoteCredential_004
975  * @tc.desc: delete remote credential and return ERR_DM_FAILED
976  * @tc.type: FUNC
977  * @tc.require: AR000GHSJK
978  */
979 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_004, testing::ext::TestSize.Level0)
980 {
981     std::string credentialInfo = R"(
982     {
983         "processType" : 2,
984         "authType" : 1,
985         "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
986     }
987     )";
988     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
989     int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
990     EXPECT_EQ(ret, ERR_DM_FAILED);
991 }
992 
993 /**
994  * @tc.name: DeleteRemoteCredential_005
995  * @tc.desc: delete remote credential and return ERR_DM_FAILED
996  * @tc.type: FUNC
997  * @tc.require: AR000GHSJK
998  */
999 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_005, testing::ext::TestSize.Level0)
1000 {
1001     std::string credentialInfo = R"(
1002     {
1003         "processType" : 2,
1004         "authType" : 1,
1005         "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
1006         "peerCredentialInfo" :
1007         [
1008             {
1009                 "peerDeviceId" : "devD"
1010             }
1011         ]
1012     }
1013     )";
1014     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1015     int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
1016     EXPECT_EQ(ret, ERR_DM_FAILED);
1017 }
1018 
1019 /**
1020  * @tc.name: DeleteRemoteCredential_006
1021  * @tc.desc: delete remote credential and return ERR_DM_FAILED
1022  * @tc.type: FUNC
1023  * @tc.require: AR000GHSJK
1024  */
1025 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_006, testing::ext::TestSize.Level0)
1026 {
1027     std::string credentialInfo = R"(
1028     {
1029         "processType" : 2,
1030         "authType" : 1,
1031         "peerCredentialInfo" :
1032         [
1033             {
1034                 "peerDeviceId" : "devD"
1035             }
1036         ]
1037     }
1038     )";
1039     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1040     int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
1041     EXPECT_EQ(ret, ERR_DM_FAILED);
1042 }
1043 
1044 /**
1045  * @tc.name: DeleteRemoteCredential_007
1046  * @tc.desc: delete remote credential and return ERR_DM_FAILED
1047  * @tc.type: FUNC
1048  * @tc.require: AR000GHSJK
1049  */
1050 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_007, testing::ext::TestSize.Level0)
1051 {
1052     std::string credentialInfo = R"(
1053     {
1054         "processType" : 2,
1055         "authType" : 2,
1056         "peerCredentialInfo" :
1057         [
1058             {
1059                 "peerDeviceId" : "devD"
1060             }
1061         ]
1062     }
1063     )";
1064     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1065     int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
1066     EXPECT_EQ(ret, ERR_DM_FAILED);
1067 }
1068 
1069 /**
1070  * @tc.name: DeleteRemoteCredential_008
1071  * @tc.desc: delete remote credential and return ERR_DM_FAILED
1072  * @tc.type: FUNC
1073  * @tc.require: AR000GHSJK
1074  */
1075 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_008, testing::ext::TestSize.Level0)
1076 {
1077     std::string credentialInfo = R"(
1078     {
1079         "processType" : 2,
1080         "authType" : 1,
1081     }
1082     )";
1083     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1084     int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
1085     EXPECT_EQ(ret, ERR_DM_FAILED);
1086 }
1087 
1088 /**
1089  * @tc.name: DeleteRemoteCredential_009
1090  * @tc.desc: delete remote credential and return ERR_DM_FAILED
1091  * @tc.type: FUNC
1092  * @tc.require: AR000GHSJK
1093  */
1094 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_009, testing::ext::TestSize.Level0)
1095 {
1096     std::string credentialInfo = R"(
1097     {
1098         "processType" : 2,
1099         "authType" : 2,
1100     }
1101     )";
1102     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1103     int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
1104     EXPECT_EQ(ret, ERR_DM_FAILED);
1105 }
1106 
1107 /**
1108  * @tc.name: DeleteRemoteCredential_0010
1109  * @tc.desc: delete remote credential and return ERR_DM_FAILED
1110  * @tc.type: FUNC
1111  * @tc.require: AR000GHSJK
1112  */
1113 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_0010, testing::ext::TestSize.Level0)
1114 {
1115     std::string credentialInfo = R"(
1116     {
1117         "processType" : 2,
1118         "authType" : 1,
1119         "userId": "123",
1120         "peerCredentialInfo" :
1121         [
1122             {
1123                 "peerDeviceId" : "devD"
1124             }
1125         ]
1126     }
1127     )";
1128     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1129     int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
1130     EXPECT_EQ(ret, ERR_DM_FAILED);
1131 }
1132 
1133 /**
1134  * @tc.name: DeleteRemoteCredential_0011
1135  * @tc.desc: delete remote credential and return ERR_DM_FAILED
1136  * @tc.type: FUNC
1137  * @tc.require: AR000GHSJK
1138  */
1139 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_0011, testing::ext::TestSize.Level0)
1140 {
1141     std::string credentialInfo = R"(
1142     {
1143         "processType" : 2,
1144         "authType" : 2,
1145         "peerUserId": "123",
1146         "peerCredentialInfo" :
1147         [
1148             {
1149                 "peerDeviceId" : "devD"
1150             }
1151         ]
1152     }
1153     )";
1154     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1155     int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
1156     EXPECT_EQ(ret, ERR_DM_FAILED);
1157 }
1158 
1159 /**
1160  * @tc.name: DeleteCredential_001
1161  * @tc.desc: test DeleteCredential
1162  * @tc.type: FUNC
1163  * @tc.require: AR000GHSJK
1164  */
1165 HWTEST_F(DmCredentialManagerTest, DeleteCredential_001, testing::ext::TestSize.Level0)
1166 {
1167     std::string pkgName = "com.ohos.helloworld";
1168     std::string resultInfo;
1169     std::string credentialInfo = R"(
1170     {
1171         "processType" : 2,
1172         "authType" : 2,
1173         "userId" : "123"
1174     }
1175     )";
1176     dmCreMgr_->requestId_ = 1;
1177     dmCreMgr_->OnGroupResult(0, 0, resultInfo);
1178     dmCreMgr_->requestId_ = 0;
1179     dmCreMgr_->OnGroupResult(0, 0, resultInfo);
1180     dmCreMgr_->credentialVec_.push_back(pkgName);
1181     int32_t ret = dmCreMgr_->DeleteCredential(pkgName, credentialInfo);
1182     EXPECT_EQ(ret, ERR_DM_FAILED);
1183 }
1184 
1185 /**
1186  * @tc.name: DeleteCredential_002
1187  * @tc.desc: delete local credential and return ERR_DM_FAILED
1188  * @tc.type: FUNC
1189  * @tc.require: AR000GHSJK
1190  */
1191 HWTEST_F(DmCredentialManagerTest, DeleteCredential_002, testing::ext::TestSize.Level0)
1192 {
1193     std::string pkgName = "";
1194     std::string credentialInfo = R"(
1195     {
1196         "processType" : 1,
1197         "authType" : 1,
1198         "userId" : "123"
1199     }
1200     )";
1201     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1202     dmCreMgr->credentialVec_.push_back(pkgName);
1203     int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
1204     EXPECT_EQ(ret, ERR_DM_FAILED);
1205 }
1206 
1207 /**
1208  * @tc.name: DeleteCredential_003
1209  * @tc.desc: delete remote credential and return ERR_DM_FAILED
1210  * @tc.type: FUNC
1211  * @tc.require: AR000GHSJK
1212  */
1213 HWTEST_F(DmCredentialManagerTest, DeleteCredential_003, testing::ext::TestSize.Level0)
1214 {
1215     std::string pkgName = "com.ohos.helloworld";
1216     std::string credentialInfo = R"(
1217     {
1218         "userId" , "123"
1219     }
1220     )";
1221     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1222     dmCreMgr->credentialVec_.push_back(pkgName);
1223     int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
1224     EXPECT_EQ(ret, ERR_DM_FAILED);
1225 }
1226 
1227 /**
1228  * @tc.name: DeleteCredential_004
1229  * @tc.desc: delete remote credential and return ERR_DM_FAILED
1230  * @tc.type: FUNC
1231  * @tc.require: AR000GHSJK
1232  */
1233 HWTEST_F(DmCredentialManagerTest, DeleteCredential_004, testing::ext::TestSize.Level0)
1234 {
1235     std::string pkgName = "com.ohos.helloworld";
1236     std::string credentialInfo = R"(
1237     {
1238         "authType" : 1,
1239         "userId" : "123"
1240     }
1241     )";
1242     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1243     dmCreMgr->credentialVec_.push_back(pkgName);
1244     int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
1245     EXPECT_EQ(ret, ERR_DM_FAILED);
1246 }
1247 
1248 /**
1249  * @tc.name: DeleteCredential_005
1250  * @tc.desc: delete remote credential and return ERR_DM_FAILED
1251  * @tc.type: FUNC
1252  * @tc.require: AR000GHSJK
1253  */
1254 HWTEST_F(DmCredentialManagerTest, DeleteCredential_005, testing::ext::TestSize.Level0)
1255 {
1256     std::string pkgName = "com.ohos.helloworld";
1257     std::string credentialInfo = R"(
1258     {
1259         "processType" : 1,
1260         "userId" : "123"
1261     }
1262     )";
1263     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1264     dmCreMgr->credentialVec_.push_back(pkgName);
1265     int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
1266     EXPECT_EQ(ret, ERR_DM_FAILED);
1267 }
1268 
1269 /**
1270  * @tc.name: DeleteCredential_006
1271  * @tc.desc: delete remote credential and return ERR_DM_FAILED
1272  * @tc.type: FUNC
1273  * @tc.require: AR000GHSJK
1274  */
1275 HWTEST_F(DmCredentialManagerTest, DeleteCredential_006, testing::ext::TestSize.Level0)
1276 {
1277     std::string pkgName = "com.ohos.helloworld";
1278     std::string credentialInfo = R"(
1279     {
1280         "processType" : 0,
1281         "authType" : 1,
1282         "userId" : "123"
1283     }
1284     )";
1285     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1286     dmCreMgr->credentialVec_.push_back(pkgName);
1287     int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
1288     EXPECT_EQ(ret, ERR_DM_FAILED);
1289 }
1290 
1291 /**
1292  * @tc.name: GetCredentialData_001
1293  * @tc.desc: get symmetry credential data and return DM_OK
1294  * @tc.type: FUNC
1295  * @tc.require: AR000GHSJK
1296  */
1297 HWTEST_F(DmCredentialManagerTest, GetCredentialData_001, testing::ext::TestSize.Level0)
1298 {
1299     std::string credentialInfo = R"(
1300     {
1301         "processType" : 1,
1302         "authType" : 1,
1303         "userId" : "123",
1304         "credentialData" :
1305         [
1306             {
1307                 "credentialType" : 1,
1308                 "credentialId" : "104",
1309                 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1310                 "serverPk" : "",
1311                 "pkInfoSignature" : "",
1312                 "pkInfo" : "",
1313                 "peerDeviceId" : ""
1314             }
1315         ]
1316     }
1317     )";
1318     CredentialData credentialData;
1319     credentialData.credentialType = 1;
1320     credentialData.credentialId = "104";
1321     credentialData.serverPk = "";
1322     credentialData.pkInfoSignature = "";
1323     credentialData.pkInfo = "";
1324     credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1325     credentialData.peerDeviceId = "";
1326     nlohmann::json jsonOutObj;
1327     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1328     int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1329     EXPECT_EQ(ret, DM_OK);
1330 }
1331 
1332 /**
1333  * @tc.name: GetCredentialData_002
1334  * @tc.desc: get symmetry credential data and return ERR_DM_FAILED
1335  * @tc.type: FUNC
1336  * @tc.require: AR000GHSJK
1337  */
1338 HWTEST_F(DmCredentialManagerTest, GetCredentialData_002, testing::ext::TestSize.Level0)
1339 {
1340     std::string credentialInfo = R"(
1341     {
1342         "processType" : 1,
1343         "authType" : 1,
1344         "userId" : "123",
1345         "credentialData" :
1346         [
1347             {
1348                 "credentialType" : 0,
1349                 "credentialId" : "104",
1350                 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1351                 "serverPk" : "",
1352                 "pkInfoSignature" : "",
1353                 "pkInfo" : "",
1354                 "peerDeviceId" : ""
1355             }
1356         ]
1357     }
1358     )";
1359     CredentialData credentialData;
1360     credentialData.credentialType = 0;
1361     credentialData.credentialId = "104";
1362     credentialData.serverPk = "";
1363     credentialData.pkInfoSignature = "";
1364     credentialData.pkInfo = "";
1365     credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1366     credentialData.peerDeviceId = "";
1367     nlohmann::json jsonOutObj;
1368     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1369     int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1370     EXPECT_EQ(ret, ERR_DM_FAILED);
1371 }
1372 
1373 /**
1374  * @tc.name: GetCredentialData_003
1375  * @tc.desc: get nonsymmetry credential data and return ERR_DM_FAILED
1376  * @tc.type: FUNC
1377  * @tc.require: AR000GHSJK
1378  */
1379 HWTEST_F(DmCredentialManagerTest, GetCredentialData_003, testing::ext::TestSize.Level0)
1380 {
1381     std::string credentialInfo = R"(
1382     {
1383         "processType", 1,
1384         "authType" : 1,
1385         "userId" : "123",
1386         "version" : "1.2.3",
1387         "deviceId" : "aaa",
1388         "devicePk" : "0000",
1389         "credentialData" :
1390         [
1391             {
1392                 "credentialType" : 2,
1393                 "credentialId" : "104",
1394                 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1395                 "serverPk" : "",
1396                 "pkInfoSignature" : "",
1397                 "pkInfo" : "",
1398                 "peerDeviceId" : ""
1399             }
1400         ]
1401     }
1402     )";
1403     CredentialData credentialData;
1404     credentialData.credentialType = 2;
1405     credentialData.credentialId = "104";
1406     credentialData.serverPk = "";
1407     credentialData.pkInfoSignature = "";
1408     credentialData.pkInfo = "";
1409     credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1410     credentialData.peerDeviceId = "";
1411     nlohmann::json jsonOutObj;
1412     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1413     int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1414     EXPECT_EQ(ret, ERR_DM_FAILED);
1415 }
1416 
1417 /**
1418  * @tc.name: GetCredentialData_004
1419  * @tc.desc: get nonsymmetry credential data and return ERR_DM_FAILED
1420  * @tc.type: FUNC
1421  * @tc.require: AR000GHSJK
1422  */
1423 HWTEST_F(DmCredentialManagerTest, GetCredentialData_004, testing::ext::TestSize.Level0)
1424 {
1425     std::string credentialInfo = R"(
1426     {
1427         "processType" : 1,
1428         "authType" : 1,
1429         "version" : "1.2.3",
1430         "deviceId" : "aaa",
1431         "devicePk" : "0000",
1432         "credentialData" :
1433         [
1434             {
1435                 "credentialType" : 2,
1436                 "credentialId" : "104",
1437                 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1438                 "serverPk" : "",
1439                 "pkInfoSignature" : "",
1440                 "pkInfo" : "",
1441                 "peerDeviceId" : ""
1442             }
1443         ]
1444     }
1445     )";
1446     CredentialData credentialData;
1447     credentialData.credentialType = 2;
1448     credentialData.credentialId = "104";
1449     credentialData.serverPk = "";
1450     credentialData.pkInfoSignature = "";
1451     credentialData.pkInfo = "";
1452     credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1453     credentialData.peerDeviceId = "";
1454     nlohmann::json jsonOutObj;
1455     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1456     int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1457     EXPECT_EQ(ret, ERR_DM_FAILED);
1458 }
1459 
1460 /**
1461  * @tc.name: GetCredentialData_005
1462  * @tc.desc: get nonsymmetry credential data and return ERR_DM_FAILED
1463  * @tc.type: FUNC
1464  * @tc.require: AR000GHSJK
1465  */
1466 HWTEST_F(DmCredentialManagerTest, GetCredentialData_005, testing::ext::TestSize.Level0)
1467 {
1468     std::string credentialInfo = R"(
1469     {
1470         "processType" : 1,
1471         "authType" : 1,
1472         "userId" : "123",
1473         "deviceId" : "aaa",
1474         "devicePk" : "0000",
1475         "credentialData" :
1476         [
1477             {
1478                 "credentialType" : 2,
1479                 "credentialId" : "104",
1480                 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1481                 "serverPk" : "",
1482                 "pkInfoSignature" : "",
1483                 "pkInfo" : "",
1484                 "peerDeviceId" : ""
1485             }
1486         ]
1487     }
1488     )";
1489     CredentialData credentialData;
1490     credentialData.credentialType = 2;
1491     credentialData.credentialId = "104";
1492     credentialData.serverPk = "";
1493     credentialData.pkInfoSignature = "";
1494     credentialData.pkInfo = "";
1495     credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1496     credentialData.peerDeviceId = "";
1497     nlohmann::json jsonOutObj;
1498     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1499     int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1500     EXPECT_EQ(ret, ERR_DM_FAILED);
1501 }
1502 
1503 /**
1504  * @tc.name: GetCredentialData_006
1505  * @tc.desc: get nonsymmetry credential data and return ERR_DM_FAILED
1506  * @tc.type: FUNC
1507  * @tc.require: AR000GHSJK
1508  */
1509 HWTEST_F(DmCredentialManagerTest, GetCredentialData_006, testing::ext::TestSize.Level0)
1510 {
1511     std::string credentialInfo = R"(
1512     {
1513         "processType" : 1,
1514         "authType" : 1,
1515         "userId" : "123",
1516         "version" : "1.2.3",
1517         "devicePk" : "0000",
1518         "credentialData" :
1519         [
1520             {
1521                 "credentialType" : 2,
1522                 "credentialId" : "104",
1523                 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1524                 "serverPk" : "",
1525                 "pkInfoSignature" : "",
1526                 "pkInfo" : "",
1527                 "peerDeviceId" : ""
1528             }
1529         ]
1530     }
1531     )";
1532     CredentialData credentialData;
1533     credentialData.credentialType = 2;
1534     credentialData.credentialId = "104";
1535     credentialData.serverPk = "";
1536     credentialData.pkInfoSignature = "";
1537     credentialData.pkInfo = "";
1538     credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1539     credentialData.peerDeviceId = "";
1540     nlohmann::json jsonOutObj;
1541     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1542     int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1543     EXPECT_EQ(ret, ERR_DM_FAILED);
1544 }
1545 
1546 /**
1547  * @tc.name: GetCredentialData_007
1548  * @tc.desc: get nonsymmetry credential data and return ERR_DM_FAILED
1549  * @tc.type: FUNC
1550  * @tc.require: AR000GHSJK
1551  */
1552 HWTEST_F(DmCredentialManagerTest, GetCredentialData_007, testing::ext::TestSize.Level0)
1553 {
1554     std::string credentialInfo = R"(
1555     {
1556         "processType" : 1,
1557         "authType" : 1,
1558         "userId" : "123",
1559         "version" : "1.2.3",
1560         "deviceId" : "aaa",
1561         "credentialData" :
1562         [
1563             {
1564                 "credentialType" : 2,
1565                 "credentialId" : "104",
1566                 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1567                 "serverPk" : "",
1568                 "pkInfoSignature" : "",
1569                 "pkInfo" : "",
1570                 "peerDeviceId" : ""
1571             }
1572         ]
1573     }
1574     )";
1575     CredentialData credentialData;
1576     credentialData.credentialType = 2;
1577     credentialData.credentialId = "104";
1578     credentialData.serverPk = "";
1579     credentialData.pkInfoSignature = "";
1580     credentialData.pkInfo = "";
1581     credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1582     credentialData.peerDeviceId = "";
1583     nlohmann::json jsonOutObj;
1584     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1585     int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1586     EXPECT_EQ(ret, ERR_DM_FAILED);
1587 }
1588 
1589 /**
1590  * @tc.name: GetCredentialData_008
1591  * @tc.desc: get nonsymmetry credential data and return ERR_DM_FAILED
1592  * @tc.type: FUNC
1593  * @tc.require: AR000GHSJK
1594  */
1595 HWTEST_F(DmCredentialManagerTest, GetCredentialData_008, testing::ext::TestSize.Level0)
1596 {
1597     std::string credentialInfo = R"(
1598     {
1599         "processType" : 1,
1600         "authType" : 1,
1601         "userId" : "123",
1602         "version" : "1.2.3",
1603         "deviceId" : "aaa",
1604         "devicePk" : "0000",
1605         "credentialData" :
1606         [
1607             {
1608                 "credentialType" : 2,
1609                 "credentialId" : "104",
1610                 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1611                 "serverPk" : "",
1612                 "pkInfoSignature" : "",
1613                 "pkInfo" : "",
1614                 "peerDeviceId" : ""
1615             }
1616         ]
1617     }
1618     )";
1619     CredentialData credentialData;
1620     credentialData.credentialType = 2;
1621     credentialData.credentialId = "104";
1622     credentialData.serverPk = "";
1623     credentialData.pkInfoSignature = "";
1624     credentialData.pkInfo = "";
1625     credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
1626     credentialData.peerDeviceId = "";
1627     nlohmann::json jsonOutObj;
1628     std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
1629     int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
1630     EXPECT_EQ(ret, DM_OK);
1631 }
1632 
1633 /**
1634  * @tc.name: from_json_001
1635  * @tc.desc: test from_json
1636  * @tc.type: FUNC
1637  * @tc.require: AR000GHSJK
1638  */
1639 HWTEST_F(DmCredentialManagerTest, from_json_001, testing::ext::TestSize.Level0)
1640 {
1641     nlohmann::json jsonOutObj;
1642     CredentialDataInfo credentialDataInfo;
1643     jsonOutObj[FIELD_CREDENTIAL_TYPE] = "test";
1644     from_json(jsonOutObj, credentialDataInfo);
1645 
1646     jsonOutObj[FIELD_CREDENTIAL_TYPE] = NONSYMMETRY_CREDENTIAL_TYPE;
1647     jsonOutObj[FIELD_SERVER_PK] = 0;
1648     jsonOutObj[FIELD_PKINFO_SIGNATURE] = 0;
1649     jsonOutObj[FIELD_PKINFO] = 0;
1650     jsonOutObj[FIELD_PEER_DEVICE_ID] = 0;
1651     credentialDataInfo.serverPk = "";
1652     from_json(jsonOutObj, credentialDataInfo);
1653     EXPECT_TRUE(credentialDataInfo.serverPk.empty());
1654 
1655     nlohmann::json jsonPkInfo;
1656     jsonOutObj[FIELD_SERVER_PK] = "serverPk";
1657     jsonOutObj[FIELD_PKINFO_SIGNATURE] = "pkInfoSignature";
1658     jsonOutObj[FIELD_PKINFO] = jsonPkInfo.dump();
1659     jsonOutObj[FIELD_PEER_DEVICE_ID] = "peerDeviceId";
1660     from_json(jsonOutObj, credentialDataInfo);
1661     EXPECT_FALSE(credentialDataInfo.serverPk.empty());
1662 
1663     jsonOutObj[FIELD_CREDENTIAL_TYPE] = SYMMETRY_CREDENTIAL_TYPE;
1664     jsonOutObj[FIELD_AUTH_CODE] = 0;
1665     credentialDataInfo.authCode = "";
1666     from_json(jsonOutObj, credentialDataInfo);
1667     EXPECT_TRUE(credentialDataInfo.authCode.empty());
1668 
1669     jsonOutObj[FIELD_AUTH_CODE] = "authCode";
1670     from_json(jsonOutObj, credentialDataInfo);
1671     EXPECT_FALSE(credentialDataInfo.authCode.empty());
1672 
1673     jsonOutObj[FIELD_CREDENTIAL_TYPE] = 0;
1674     from_json(jsonOutObj, credentialDataInfo);
1675     EXPECT_FALSE(credentialDataInfo.authCode.empty());
1676 }
1677 
1678 /**
1679  * @tc.name: from_json_002
1680  * @tc.desc: test from_json
1681  * @tc.type: FUNC
1682  * @tc.require: AR000GHSJK
1683  */
1684 HWTEST_F(DmCredentialManagerTest, from_json_002, testing::ext::TestSize.Level0)
1685 {
1686     nlohmann::json jsonObject;
1687     PeerCredentialInfo peerCredentialInfo;
1688     jsonObject[FIELD_PEER_USER_ID] = "peerDeviceId";
1689     from_json(jsonObject, peerCredentialInfo);
1690     EXPECT_EQ(peerCredentialInfo.peerDeviceId, "peerDeviceId");
1691 }
1692 
1693 /**
1694  * @tc.name: to_json_001
1695  * @tc.desc: test to_json
1696  * @tc.type: FUNC
1697  * @tc.require: AR000GHSJK
1698  */
1699 HWTEST_F(DmCredentialManagerTest, to_json_001, testing::ext::TestSize.Level0)
1700 {
1701     CredentialDataInfo credentialDataInfo;
1702     credentialDataInfo.peerDeviceId = "test";
1703     credentialDataInfo.userId = "test";
1704     credentialDataInfo.credentailId = "test";
1705     credentialDataInfo.credentialType = NONSYMMETRY_CREDENTIAL_TYPE;
1706     credentialDataInfo.serverPk = "test";
1707     credentialDataInfo.pkInfoSignature = "test";
1708     credentialDataInfo.pkInfo = "test";
1709     credentialDataInfo.authCode = "test";
1710     nlohmann::json jsonObject;
1711     to_json(jsonObject, credentialDataInfo);
1712     EXPECT_EQ(jsonObject[FIELD_SERVER_PK].get<std::string>(), "test");
1713 
1714     credentialDataInfo.credentialType = SYMMETRY_CREDENTIAL_TYPE;
1715     to_json(jsonObject, credentialDataInfo);
1716     EXPECT_EQ(jsonObject[FIELD_AUTH_CODE].get<std::string>(), "test");
1717 
1718     credentialDataInfo.credentialType = UNKNOWN_CREDENTIAL_TYPE;
1719     to_json(jsonObject, credentialDataInfo);
1720     EXPECT_EQ(jsonObject[FIELD_AUTH_CODE].get<std::string>(), "test");
1721 }
1722 } // namespace DistributedHardware
1723 } // namespace OHOS
1724