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
27using namespace OHOS::Security::AccessToken;
28namespace OHOS {
29namespace DistributedHardware {
30void 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
57void DmCredentialManagerTest::TearDown()
58{
59    dmCreMgr_ = nullptr;
60    hiChainConnector_ = nullptr;
61    listener_ = nullptr;
62}
63
64void DmCredentialManagerTest::SetUpTestCase()
65{
66}
67
68void 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 */
78HWTEST_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 */
90HWTEST_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 */
103HWTEST_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 */
117HWTEST_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 */
131HWTEST_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 */
145HWTEST_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 */
159HWTEST_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 */
174HWTEST_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 */
195HWTEST_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 */
214HWTEST_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 */
233HWTEST_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 */
252HWTEST_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 */
308HWTEST_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 */
322HWTEST_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 */
342HWTEST_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 */
374HWTEST_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 */
408HWTEST_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 */
422HWTEST_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 */
462HWTEST_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 */
481HWTEST_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 */
512HWTEST_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 */
543HWTEST_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 */
563HWTEST_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 */
604HWTEST_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 */
635HWTEST_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 */
667HWTEST_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 */
699HWTEST_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 */
737HWTEST_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 */
755HWTEST_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 */
775HWTEST_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 */
803HWTEST_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 */
831HWTEST_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 */
859HWTEST_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 */
888HWTEST_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 */
916HWTEST_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 */
936HWTEST_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 */
954HWTEST_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 */
979HWTEST_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 */
999HWTEST_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 */
1025HWTEST_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 */
1050HWTEST_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 */
1075HWTEST_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 */
1094HWTEST_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 */
1113HWTEST_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 */
1139HWTEST_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 */
1165HWTEST_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 */
1191HWTEST_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 */
1213HWTEST_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 */
1233HWTEST_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 */
1254HWTEST_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 */
1275HWTEST_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 */
1297HWTEST_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 */
1338HWTEST_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 */
1379HWTEST_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 */
1423HWTEST_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 */
1466HWTEST_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 */
1509HWTEST_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 */
1552HWTEST_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 */
1595HWTEST_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 */
1639HWTEST_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 */
1684HWTEST_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 */
1699HWTEST_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