1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "UTTest_dm_credential_manager.h"
17 #include "accesstoken_kit.h"
18 #include "dm_anonymous.h"
19 #include "dm_constants.h"
20 #include "dm_random.h"
21 #include "parameter.h"
22 #include "nativetoken_kit.h"
23 #include "token_setproc.h"
24 #include "softbus_common.h"
25
26 using namespace OHOS::Security::AccessToken;
27 namespace OHOS {
28 namespace DistributedHardware {
SetUp()29 void DmCredentialManagerTest::SetUp()
30 {
31 uint64_t tokenId;
32 const char *perms[2];
33 perms[0] = OHOS_PERMISSION_DISTRIBUTED_SOFTBUS_CENTER;
34 perms[1] = OHOS_PERMISSION_DISTRIBUTED_DATASYNC;
35 NativeTokenInfoParams infoInstance = {
36 .dcapsNum = 0,
37 .permsNum = 2,
38 .aclsNum = 0,
39 .dcaps = NULL,
40 .perms = perms,
41 .acls = NULL,
42 .processName = "dsoftbus_service",
43 .aplStr = "system_core",
44 };
45 tokenId = GetAccessTokenId(&infoInstance);
46 SetSelfTokenID(tokenId);
47 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
48 }
49
TearDown()50 void DmCredentialManagerTest::TearDown()
51 {
52 }
53
SetUpTestCase()54 void DmCredentialManagerTest::SetUpTestCase()
55 {
56 }
57
TearDownTestCase()58 void DmCredentialManagerTest::TearDownTestCase()
59 {
60 }
61
62 namespace {
63 std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
64 std::shared_ptr<HiChainConnector> hiChainConnector_ = std::make_shared<HiChainConnector>();
65
66 /**
67 * @tc.name: DmCredentialManager_001
68 * @tc.desc: Test whether the DmCredentialManager function can generate a new pointer
69 * @tc.type: FUNC
70 * @tc.require: AR000GHSJK
71 */
72 HWTEST_F(DmCredentialManagerTest, DmCredentialManager_001, testing::ext::TestSize.Level0)
73 {
74 std::shared_ptr<DmCredentialManager> Test = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
75 ASSERT_NE(Test, nullptr);
76 }
77
78 /**
79 * @tc.name: DmCredentialManager_002
80 * @tc.desc: Test whether the DmCredentialManager function can delete a new pointer
81 * @tc.type: FUNC
82 * @tc.require: AR000GHSJK
83 */
84 HWTEST_F(DmCredentialManagerTest, DmCredentialManager_002, testing::ext::TestSize.Level0)
85 {
86 std::shared_ptr<DmCredentialManager> Test = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
87 Test.reset();
88 EXPECT_EQ(Test, nullptr);
89 }
90
91 /**
92 * @tc.name:RegisterCredentialCallback_001
93 * @tc.desc: return DM_OK
94 * @tc.type: FUNC
95 * @tc.require: AR000GHSJK
96 */
97 HWTEST_F(DmCredentialManagerTest, RegisterCredentialCallback_001, testing::ext::TestSize.Level0)
98 {
99 std::string pkgName = "com.ohos.helloworld";
100 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
101 int32_t ret = dmCreMgr->RegisterCredentialCallback(pkgName);
102 EXPECT_EQ(ret, DM_OK);
103 }
104
105 /**
106 * @tc.name:RegisterCredentialCallback_002
107 * @tc.desc: return ERR_DM_FAILED
108 * @tc.type: FUNC
109 * @tc.require: AR000GHSJK
110 */
111 HWTEST_F(DmCredentialManagerTest, RegisterCredentialCallback_002, testing::ext::TestSize.Level0)
112 {
113 std::string pkgName = "";
114 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
115 int32_t ret = dmCreMgr->RegisterCredentialCallback(pkgName);
116 EXPECT_EQ(ret, ERR_DM_FAILED);
117 }
118
119 /**
120 * @tc.name:UnRegisterCredentialCallback_001
121 * @tc.desc: return DM_OK
122 * @tc.type: FUNC
123 * @tc.require: AR000GHSJK
124 */
125 HWTEST_F(DmCredentialManagerTest, UnRegisterCredentialCallback_001, testing::ext::TestSize.Level0)
126 {
127 std::string pkgName = "com.ohos.helloworld";
128 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
129 int32_t ret = dmCreMgr->RegisterCredentialCallback(pkgName);
130 EXPECT_EQ(ret, DM_OK);
131 }
132
133 /**
134 * @tc.name:UnRegisterCredentialCallback_002
135 * @tc.desc: return ERR_DM_FAILED
136 * @tc.type: FUNC
137 * @tc.require: AR000GHSJK
138 */
139 HWTEST_F(DmCredentialManagerTest, UnRegisterCredentialCallback_002, testing::ext::TestSize.Level0)
140 {
141 std::string pkgName = "";
142 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
143 int32_t ret = dmCreMgr->UnRegisterCredentialCallback(pkgName);
144 EXPECT_EQ(ret, ERR_DM_FAILED);
145 }
146
147 /**
148 * @tc.name:RequestCredential_001
149 * @tc.desc: get credential info and return DM_OK
150 * @tc.type: FUNC
151 * @tc.require: AR000GHSJK
152 */
153 HWTEST_F(DmCredentialManagerTest, RequestCredential_001, testing::ext::TestSize.Level0)
154 {
155 std::string reqJsonStr = R"(
156 {
157 "version" : "1.2.3",
158 "userId" : "123"
159 }
160 )";
161 std::string returnJsonStr;
162 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
163 int32_t ret = dmCreMgr->RequestCredential(reqJsonStr, returnJsonStr);
164 ASSERT_EQ(ret, DM_OK);
165 }
166
167 /**
168 * @tc.name:RequestCredential_002
169 * @tc.desc: get credential info and return ERR_DM_FAILED
170 * @tc.type: FUNC
171 * @tc.require: AR000GHSJK
172 */
173 HWTEST_F(DmCredentialManagerTest, RequestCredential_002, testing::ext::TestSize.Level0)
174 {
175 std::string reqJsonStr = R"(
176 {
177 "userId" , "123"
178 }
179 )";
180 std::string returnJsonStr;
181 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
182 int32_t ret = dmCreMgr->RequestCredential(reqJsonStr, returnJsonStr);
183 ASSERT_EQ(ret, ERR_DM_FAILED);
184 }
185
186 /**
187 * @tc.name:RequestCredential_003
188 * @tc.desc: get credential info and return ERR_DM_FAILED
189 * @tc.type: FUNC
190 * @tc.require: AR000GHSJK
191 */
192 HWTEST_F(DmCredentialManagerTest, RequestCredential_003, testing::ext::TestSize.Level0)
193 {
194 std::string reqJsonStr = R"(
195 {
196 "userId" : "123"
197 }
198 )";
199 std::string returnJsonStr;
200 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
201 int32_t ret = dmCreMgr->RequestCredential(reqJsonStr, returnJsonStr);
202 ASSERT_EQ(ret, ERR_DM_FAILED);
203 }
204
205 /**
206 * @tc.name:RequestCredential_004
207 * @tc.desc: get credential info and return ERR_DM_FAILED
208 * @tc.type: FUNC
209 * @tc.require: AR000GHSJK
210 */
211 HWTEST_F(DmCredentialManagerTest, RequestCredential_004, testing::ext::TestSize.Level0)
212 {
213 std::string reqJsonStr = R"(
214 {
215 "version" : "1.2.3"
216 }
217 )";
218 std::string returnJsonStr;
219 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
220 int32_t ret = dmCreMgr->RequestCredential(reqJsonStr, returnJsonStr);
221 ASSERT_EQ(ret, ERR_DM_FAILED);
222 }
223
224 /**
225 * @tc.name: ImportCredential_002
226 * @tc.desc: import local credential and return ERR_DM_FAILED
227 * @tc.type: FUNC
228 * @tc.require: AR000GHSJK
229 */
230 HWTEST_F(DmCredentialManagerTest, ImportCredential_002, testing::ext::TestSize.Level0)
231 {
232 std::string pkgName = "";
233 std::string credentialInfo = R"(
234 {
235 "processType" : 1,
236 "authType" : 1,
237 "userId" : "123",
238 "credentialData" :
239 [
240 {
241 "credentialType" : 1,
242 "credentialId" : "104",
243 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
244 "serverPk" : "",
245 "pkInfoSignature" : "",
246 "pkInfo" : "",
247 "peerDeviceId" : ""
248 }
249 ]
250 }
251 )";
252 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
253 dmCreMgr->credentialVec_.push_back(pkgName);
254 int32_t ret = dmCreMgr->ImportCredential(pkgName, credentialInfo);
255 EXPECT_EQ(ret, ERR_DM_FAILED);
256 }
257
258 /**
259 * @tc.name: ImportCredential_003
260 * @tc.desc: import local credential and return ERR_DM_FAILED
261 * @tc.type: FUNC
262 * @tc.require: AR000GHSJK
263 */
264 HWTEST_F(DmCredentialManagerTest, ImportCredential_003, testing::ext::TestSize.Level0)
265 {
266 std::string pkgName = "com.ohos.helloworld";
267 std::string credentialInfo = R"(
268 {
269 "userId" , "123"
270 }
271 )";
272 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
273 dmCreMgr->credentialVec_.push_back(pkgName);
274 int32_t ret = dmCreMgr->ImportCredential(pkgName, credentialInfo);
275 EXPECT_EQ(ret, ERR_DM_FAILED);
276 }
277
278 /**
279 * @tc.name: ImportCredential_004
280 * @tc.desc: import local credential and return ERR_DM_FAILED
281 * @tc.type: FUNC
282 * @tc.require: AR000GHSJK
283 */
284 HWTEST_F(DmCredentialManagerTest, ImportCredential_004, testing::ext::TestSize.Level0)
285 {
286 std::string pkgName = "com.ohos.helloworld";
287 std::string credentialInfo = R"(
288 {
289 "userId" , "123"
290 }
291 )";
292 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
293 dmCreMgr->credentialVec_.push_back(pkgName);
294 int32_t ret = dmCreMgr->ImportCredential(pkgName, credentialInfo);
295 EXPECT_EQ(ret, ERR_DM_FAILED);
296 }
297
298 /**
299 * @tc.name: ImportCredential_005
300 * @tc.desc: import local credential and return ERR_DM_FAILED
301 * @tc.type: FUNC
302 * @tc.require: AR000GHSJK
303 */
304 HWTEST_F(DmCredentialManagerTest, ImportCredential_005, testing::ext::TestSize.Level0)
305 {
306 std::string pkgName = "com.ohos.helloworld";
307 std::string credentialInfo = R"(
308 {
309 "authType" : 1,
310 "userId" : "123",
311 "credentialData" :
312 [
313 {
314 "credentialType" : 1,
315 "credentialId" : "104",
316 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
317 "serverPk" : "",
318 "pkInfoSignature" : "",
319 "pkInfo" : "",
320 "peerDeviceId" : ""
321 }
322 ]
323 }
324 )";
325 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
326 dmCreMgr->credentialVec_.push_back(pkgName);
327 int32_t ret = dmCreMgr->ImportCredential(pkgName, credentialInfo);
328 EXPECT_EQ(ret, ERR_DM_FAILED);
329 }
330
331 /**
332 * @tc.name: ImportCredential_006
333 * @tc.desc: import local credential and return ERR_DM_FAILED
334 * @tc.type: FUNC
335 * @tc.require: AR000GHSJK
336 */
337 HWTEST_F(DmCredentialManagerTest, ImportCredential_006, testing::ext::TestSize.Level0)
338 {
339 std::string pkgName = "com.ohos.helloworld";
340 std::string credentialInfo = R"(
341 {
342 "processType" : 0,
343 "authType" : 1,
344 "userId" : "123",
345 "credentialData" :
346 [
347 {
348 "credentialType" : 1,
349 "credentialId" : "104",
350 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
351 "serverPk" : "",
352 "pkInfoSignature" : "",
353 "pkInfo" : "",
354 "peerDeviceId" : ""
355 }
356 ]
357 }
358 )";
359 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
360 dmCreMgr->credentialVec_.push_back(pkgName);
361 int32_t ret = dmCreMgr->ImportCredential(pkgName, credentialInfo);
362 EXPECT_EQ(ret, ERR_DM_FAILED);
363 }
364
365 /**
366 * @tc.name: ImportLocalCredential_002
367 * @tc.desc: import local credential and return ERR_DM_FAILED
368 * @tc.type: FUNC
369 * @tc.require: AR000GHSJK
370 */
371 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_002, testing::ext::TestSize.Level0)
372 {
373 std::string pkgName = "com.ohos.helloworld";
374 std::string credentialInfo = R"(
375 {
376 "processType" , 1,
377 }
378 )";
379 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
380 int32_t ret = dmCreMgr->ImportLocalCredential(credentialInfo);
381 EXPECT_EQ(ret, ERR_DM_FAILED);
382 }
383
384 /**
385 * @tc.name: ImportLocalCredential_003
386 * @tc.desc: import local credential and return ERR_DM_FAILED
387 * @tc.type: FUNC
388 * @tc.require: AR000GHSJK
389 */
390 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_003, testing::ext::TestSize.Level0)
391 {
392 std::string credentialInfo = R"(
393 {
394 "processType" : 1,
395 "userId" : "123",
396 "credentialData" :
397 [
398 {
399 "credentialType" : 1,
400 "credentialId" : "104",
401 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
402 "serverPk" : "",
403 "pkInfoSignature" : "",
404 "pkInfo" : "",
405 "peerDeviceId" : ""
406 }
407 ]
408 }
409 )";
410 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
411 int32_t ret = dmCreMgr->ImportLocalCredential(credentialInfo);
412 EXPECT_EQ(ret, ERR_DM_FAILED);
413 }
414
415 /**
416 * @tc.name: ImportLocalCredential_004
417 * @tc.desc: import local credential and return ERR_DM_FAILED
418 * @tc.type: FUNC
419 * @tc.require: AR000GHSJK
420 */
421 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_004, testing::ext::TestSize.Level0)
422 {
423 std::string credentialInfo = R"(
424 {
425 "processType" : 1,
426 "authType" : 1,
427 "credentialData" :
428 [
429 {
430 "credentialType" : 1,
431 "credentialId" : "104",
432 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
433 "serverPk" : "",
434 "pkInfoSignature" : "",
435 "pkInfo" : "",
436 "peerDeviceId" : ""
437 }
438 ]
439 }
440 )";
441 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
442 int32_t ret = dmCreMgr->ImportLocalCredential(credentialInfo);
443 EXPECT_EQ(ret, ERR_DM_FAILED);
444 }
445
446 /**
447 * @tc.name: ImportLocalCredential_005
448 * @tc.desc: import local credential and return ERR_DM_FAILED
449 * @tc.type: FUNC
450 * @tc.require: AR000GHSJK
451 */
452 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_005, testing::ext::TestSize.Level0)
453 {
454 std::string credentialInfo = R"(
455 {
456 "processType" : 1,
457 "authType" : 1,
458 "userId" : "123"
459 }
460 )";
461 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
462 int32_t ret = dmCreMgr->ImportLocalCredential(credentialInfo);
463 EXPECT_EQ(ret, ERR_DM_FAILED);
464 }
465
466 /**
467 * @tc.name: ImportLocalCredential_006
468 * @tc.desc: import local credential and return ERR_DM_FAILED
469 * @tc.type: FUNC
470 * @tc.require: AR000GHSJK
471 */
472 HWTEST_F(DmCredentialManagerTest, ImportLocalCredential_006, testing::ext::TestSize.Level0)
473 {
474 std::string credentialInfo = R"(
475 {
476 "processType" : 1,
477 "authType" : 1,
478 "userId" : "123",
479 "credentialData" :
480 [
481 {
482 "credentialType" : 1,
483 "credentialId" : "104",
484 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
485 "serverPk" : "",
486 "pkInfoSignature" : "",
487 "pkInfo" : "",
488 "peerDeviceId" : ""
489 }
490 {
491 "credentialType" : 1,
492 "credentialId" : "104",
493 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
494 "serverPk" : "",
495 "pkInfoSignature" : "",
496 "pkInfo" : "",
497 "peerDeviceId" : ""
498 }
499 ]
500 }
501 )";
502 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
503 int32_t ret = dmCreMgr->ImportLocalCredential(credentialInfo);
504 EXPECT_EQ(ret, ERR_DM_FAILED);
505 }
506
507 /**
508 * @tc.name: ImportRemoteCredential_002
509 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
510 * @tc.type: FUNC
511 * @tc.require: AR000GHSJK
512 */
513 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_002, testing::ext::TestSize.Level0)
514 {
515 std::string credentialInfo = R"(
516 {
517 "processType" , 2,
518 }
519 )";
520 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
521 int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
522 EXPECT_EQ(ret, ERR_DM_FAILED);
523 }
524
525 /**
526 * @tc.name: ImportRemoteCredential_003
527 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
528 * @tc.type: FUNC
529 * @tc.require: AR000GHSJK
530 */
531 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_003, testing::ext::TestSize.Level0)
532 {
533 std::string credentialInfo = R"(
534 {
535 "processType" : 2,
536 "authType" : 1,
537 "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
538 }
539 )";
540 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
541 int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
542 EXPECT_EQ(ret, ERR_DM_FAILED);
543 }
544
545 /**
546 * @tc.name: ImportRemoteCredential_004
547 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
548 * @tc.type: FUNC
549 * @tc.require: AR000GHSJK
550 */
551 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_004, testing::ext::TestSize.Level0)
552 {
553 std::string credentialInfo = R"(
554 {
555 "processType" : 2,
556 "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
557 "credentialData" :
558 [
559 {
560 "credentialType" : 1,
561 "credentialId" : "104",
562 "authCode" : "456",
563 "peerDeviceId" : "devD"
564 }
565 ]
566 }
567 )";
568 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
569 int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
570 EXPECT_EQ(ret, ERR_DM_FAILED);
571 }
572
573 /**
574 * @tc.name: ImportRemoteCredential_005
575 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
576 * @tc.type: FUNC
577 * @tc.require: AR000GHSJK
578 */
579 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_005, testing::ext::TestSize.Level0)
580 {
581 std::string credentialInfo = R"(
582 {
583 "processType" : 2,
584 "authType" : 1,
585 "credentialData" :
586 [
587 {
588 "credentialType" : 1,
589 "credentialId" : "104",
590 "authCode" : "456",
591 "peerDeviceId" : "devD"
592 }
593 ]
594 }
595 )";
596 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
597 int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
598 EXPECT_EQ(ret, ERR_DM_FAILED);
599 }
600
601 /**
602 * @tc.name: ImportRemoteCredential_006
603 * @tc.desc: import remote symmetry credential and return ERR_DM_FAILED
604 * @tc.type: FUNC
605 * @tc.require: AR000GHSJK
606 */
607 HWTEST_F(DmCredentialManagerTest, ImportRemoteCredential_006, testing::ext::TestSize.Level0)
608 {
609 std::string credentialInfo = R"(
610 {
611 "processType" : 2,
612 "authType" : 2,
613 "credentialData" :
614 [
615 {
616 "credentialType" : 1,
617 "credentialId" : "104",
618 "authCode" : "456",
619 "peerDeviceId" : "devD"
620 }
621 ]
622 }
623 )";
624 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
625 int32_t ret = dmCreMgr->ImportRemoteCredential(credentialInfo);
626 EXPECT_EQ(ret, ERR_DM_FAILED);
627 }
628
629 /**
630 * @tc.name: DeleteRemoteCredential_002
631 * @tc.desc: delete remote credential and return ERR_DM_FAILED
632 * @tc.type: FUNC
633 * @tc.require: AR000GHSJK
634 */
635 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_002, testing::ext::TestSize.Level0)
636 {
637 std::string credentialInfo = R"(
638 {
639 "processType" , 2,
640 }
641 )";
642 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
643 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
644 EXPECT_EQ(ret, ERR_DM_FAILED);
645 }
646
647 /**
648 * @tc.name: DeleteRemoteCredential_003
649 * @tc.desc: delete remote credential and return ERR_DM_FAILED
650 * @tc.type: FUNC
651 * @tc.require: AR000GHSJK
652 */
653 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_003, testing::ext::TestSize.Level0)
654 {
655 std::string credentialInfo = R"(
656 {
657 "processType" : 2,
658 "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
659 "peerCredentialInfo" :
660 [
661 {
662 "peerDeviceId" : "devD"
663 }
664 ]
665 }
666 )";
667 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
668 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
669 EXPECT_EQ(ret, ERR_DM_FAILED);
670 }
671
672 /**
673 * @tc.name: DeleteRemoteCredential_004
674 * @tc.desc: delete remote credential and return ERR_DM_FAILED
675 * @tc.type: FUNC
676 * @tc.require: AR000GHSJK
677 */
678 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_004, testing::ext::TestSize.Level0)
679 {
680 std::string credentialInfo = R"(
681 {
682 "processType" : 2,
683 "authType" : 1,
684 "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
685 }
686 )";
687 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
688 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
689 EXPECT_EQ(ret, ERR_DM_FAILED);
690 }
691
692 /**
693 * @tc.name: DeleteRemoteCredential_005
694 * @tc.desc: delete remote credential and return ERR_DM_FAILED
695 * @tc.type: FUNC
696 * @tc.require: AR000GHSJK
697 */
698 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_005, testing::ext::TestSize.Level0)
699 {
700 std::string credentialInfo = R"(
701 {
702 "processType" : 2,
703 "authType" : 1,
704 "userId" : "123456785442435DlDFADFAsDFDsAFDjFsAjFDsFDAFDAFDAFDFAsDDFho",
705 "peerCredentialInfo" :
706 [
707 {
708 "peerDeviceId" : "devD"
709 }
710 ]
711 }
712 )";
713 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
714 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
715 EXPECT_EQ(ret, ERR_DM_FAILED);
716 }
717
718 /**
719 * @tc.name: DeleteRemoteCredential_006
720 * @tc.desc: delete remote credential and return ERR_DM_FAILED
721 * @tc.type: FUNC
722 * @tc.require: AR000GHSJK
723 */
724 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_006, testing::ext::TestSize.Level0)
725 {
726 std::string credentialInfo = R"(
727 {
728 "processType" : 2,
729 "authType" : 1,
730 "peerCredentialInfo" :
731 [
732 {
733 "peerDeviceId" : "devD"
734 }
735 ]
736 }
737 )";
738 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
739 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
740 EXPECT_EQ(ret, ERR_DM_FAILED);
741 }
742
743 /**
744 * @tc.name: DeleteRemoteCredential_007
745 * @tc.desc: delete remote credential and return ERR_DM_FAILED
746 * @tc.type: FUNC
747 * @tc.require: AR000GHSJK
748 */
749 HWTEST_F(DmCredentialManagerTest, DeleteRemoteCredential_007, testing::ext::TestSize.Level0)
750 {
751 std::string credentialInfo = R"(
752 {
753 "processType" : 2,
754 "authType" : 2,
755 "peerCredentialInfo" :
756 [
757 {
758 "peerDeviceId" : "devD"
759 }
760 ]
761 }
762 )";
763 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
764 int32_t ret = dmCreMgr->DeleteRemoteCredential(credentialInfo);
765 EXPECT_EQ(ret, ERR_DM_FAILED);
766 }
767
768 /**
769 * @tc.name: DeleteCredential_002
770 * @tc.desc: delete local credential and return ERR_DM_FAILED
771 * @tc.type: FUNC
772 * @tc.require: AR000GHSJK
773 */
774 HWTEST_F(DmCredentialManagerTest, DeleteCredential_002, testing::ext::TestSize.Level0)
775 {
776 std::string pkgName = "";
777 std::string credentialInfo = R"(
778 {
779 "processType" : 1,
780 "authType" : 1,
781 "userId" : "123"
782 }
783 )";
784 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
785 dmCreMgr->credentialVec_.push_back(pkgName);
786 int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
787 EXPECT_EQ(ret, ERR_DM_FAILED);
788 }
789
790 /**
791 * @tc.name: DeleteCredential_003
792 * @tc.desc: delete remote credential and return ERR_DM_FAILED
793 * @tc.type: FUNC
794 * @tc.require: AR000GHSJK
795 */
796 HWTEST_F(DmCredentialManagerTest, DeleteCredential_003, testing::ext::TestSize.Level0)
797 {
798 std::string pkgName = "com.ohos.helloworld";
799 std::string credentialInfo = R"(
800 {
801 "userId" , "123"
802 }
803 )";
804 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
805 dmCreMgr->credentialVec_.push_back(pkgName);
806 int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
807 EXPECT_EQ(ret, ERR_DM_FAILED);
808 }
809
810 /**
811 * @tc.name: DeleteCredential_004
812 * @tc.desc: delete remote credential and return ERR_DM_FAILED
813 * @tc.type: FUNC
814 * @tc.require: AR000GHSJK
815 */
816 HWTEST_F(DmCredentialManagerTest, DeleteCredential_004, testing::ext::TestSize.Level0)
817 {
818 std::string pkgName = "com.ohos.helloworld";
819 std::string credentialInfo = R"(
820 {
821 "authType" : 1,
822 "userId" : "123"
823 }
824 )";
825 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
826 dmCreMgr->credentialVec_.push_back(pkgName);
827 int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
828 EXPECT_EQ(ret, ERR_DM_FAILED);
829 }
830
831 /**
832 * @tc.name: DeleteCredential_005
833 * @tc.desc: delete remote credential and return ERR_DM_FAILED
834 * @tc.type: FUNC
835 * @tc.require: AR000GHSJK
836 */
837 HWTEST_F(DmCredentialManagerTest, DeleteCredential_005, testing::ext::TestSize.Level0)
838 {
839 std::string pkgName = "com.ohos.helloworld";
840 std::string credentialInfo = R"(
841 {
842 "processType" : 1,
843 "userId" : "123"
844 }
845 )";
846 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
847 dmCreMgr->credentialVec_.push_back(pkgName);
848 int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
849 EXPECT_EQ(ret, ERR_DM_FAILED);
850 }
851
852 /**
853 * @tc.name: DeleteCredential_006
854 * @tc.desc: delete remote credential and return ERR_DM_FAILED
855 * @tc.type: FUNC
856 * @tc.require: AR000GHSJK
857 */
858 HWTEST_F(DmCredentialManagerTest, DeleteCredential_006, testing::ext::TestSize.Level0)
859 {
860 std::string pkgName = "com.ohos.helloworld";
861 std::string credentialInfo = R"(
862 {
863 "processType" : 0,
864 "authType" : 1,
865 "userId" : "123"
866 }
867 )";
868 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
869 dmCreMgr->credentialVec_.push_back(pkgName);
870 int32_t ret = dmCreMgr->DeleteCredential(pkgName, credentialInfo);
871 EXPECT_EQ(ret, ERR_DM_FAILED);
872 }
873
874 /**
875 * @tc.name: GetCredentialData_001
876 * @tc.desc: get symmetry credential data and return DM_OK
877 * @tc.type: FUNC
878 * @tc.require: AR000GHSJK
879 */
880 HWTEST_F(DmCredentialManagerTest, GetCredentialData_001, testing::ext::TestSize.Level0)
881 {
882 std::string credentialInfo = R"(
883 {
884 "processType" : 1,
885 "authType" : 1,
886 "userId" : "123",
887 "credentialData" :
888 [
889 {
890 "credentialType" : 1,
891 "credentialId" : "104",
892 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
893 "serverPk" : "",
894 "pkInfoSignature" : "",
895 "pkInfo" : "",
896 "peerDeviceId" : ""
897 }
898 ]
899 }
900 )";
901 CredentialData credentialData;
902 credentialData.credentialType = 1;
903 credentialData.credentialId = "104";
904 credentialData.serverPk = "";
905 credentialData.pkInfoSignature = "";
906 credentialData.pkInfo = "";
907 credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
908 credentialData.peerDeviceId = "";
909 nlohmann::json jsonOutObj;
910 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
911 int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
912 EXPECT_EQ(ret, DM_OK);
913 }
914
915 /**
916 * @tc.name: GetCredentialData_002
917 * @tc.desc: get symmetry credential data and return ERR_DM_FAILED
918 * @tc.type: FUNC
919 * @tc.require: AR000GHSJK
920 */
921 HWTEST_F(DmCredentialManagerTest, GetCredentialData_002, testing::ext::TestSize.Level0)
922 {
923 std::string credentialInfo = R"(
924 {
925 "processType" : 1,
926 "authType" : 1,
927 "userId" : "123",
928 "credentialData" :
929 [
930 {
931 "credentialType" : 0,
932 "credentialId" : "104",
933 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
934 "serverPk" : "",
935 "pkInfoSignature" : "",
936 "pkInfo" : "",
937 "peerDeviceId" : ""
938 }
939 ]
940 }
941 )";
942 CredentialData credentialData;
943 credentialData.credentialType = 0;
944 credentialData.credentialId = "104";
945 credentialData.serverPk = "";
946 credentialData.pkInfoSignature = "";
947 credentialData.pkInfo = "";
948 credentialData.authCode = "1234567812345678123456781234567812345678123456781234567812345678";
949 credentialData.peerDeviceId = "";
950 nlohmann::json jsonOutObj;
951 std::shared_ptr<DmCredentialManager> dmCreMgr = std::make_shared<DmCredentialManager>(hiChainConnector_, listener_);
952 int32_t ret = dmCreMgr->GetCredentialData(credentialInfo, credentialData, jsonOutObj);
953 EXPECT_EQ(ret, ERR_DM_FAILED);
954 }
955 } // namespace
956 } // namespace DistributedHardware
957 } // namespace OHOS
958