1 /*
2 * Copyright (C) 2025 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 <cinttypes>
17 #include <cstring>
18 #include <unistd.h>
19 #include <gtest/gtest.h>
20 #include "device_auth.h"
21 #include "device_auth_defines.h"
22 #include "json_utils.h"
23 #include "hc_types.h"
24 #include "securec.h"
25 #include "nativetoken_kit.h"
26 #include "token_setproc.h"
27
28 using namespace std;
29 using namespace testing::ext;
30
31 namespace {
32 #define PROC_NAME_DEVICE_MANAGER "device_manager"
33 #define PROC_NAME_SOFT_BUS "softbus_server"
34 #define PROC_NAME_DEVICE_SECURITY_LEVEL "dslm_service"
35 #define TEST_DEVICE_ID "TestDeviceId"
36 #define TEST_RESULT_SUCCESS 0
37 #define TEST_OS_ACCOUNT_ID 100
38 #define TEST_APP_ID "TestAppId"
39 #define TEST_APP_ID2 "TestAppId2"
40 #define TEST_USER_ID "4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4"
41 #define TEST_USER_ID2 "DCBA4321"
42 #define TEST_CRED_ID "52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD2E6492C"
43 #define QUERY_RESULT_NUM 0
44 static const char *ADD_PARAMS =
45 "{\"credType\":2,\"keyFormat\":3,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
46 "\"proofType\":1,\"method\":1,\"authorizedScope\":1,\"userId\":\"TestUserId\","
47 "\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId\","
48 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
49 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
50 static const char *ADD_PARAMS1 =
51 "{\"credType\":0,\"keyFormat\":4,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
52 "\"proofType\":1,\"method\":1,\"authorizedScope\":1,\"userId\":\"TestUserId\","
53 "\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId\","
54 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
55 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
56 static const char *ADD_PARAMS14 =
57 "{\"credType\":2,\"keyFormat\":3,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
58 "\"proofType\":1,\"method\":1,\"authorizedScope\":1,\"userId\":\"TestUserId\","
59 "\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId1\","
60 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
61 "\"peerUserSpaceId\":\"100\",\"extendInfo\":\"\"}";
62 static const char *ADD_PARAMS17 =
63 "{\"credType\":2,\"keyFormat\":3,\"algorithmType\":3,\"subject\":1,"
64 "\"proofType\":1,\"method\":1,\"authorizedScope\":1,"
65 "\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId\"}";
66 static const char *ADD_PARAMS18 =
67 "{\"credType\":3,\"keyFormat\":4,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
68 "\"proofType\":1,\"method\":1,\"authorizedScope\":1,\"userId\":\"TestUserId0\","
69 "\"deviceId\":\"TestDeviceId0\",\"credOwner\":\"TestAppId\"}";
70 static const char *REQUEST_PARAMS =
71 "{\"authorizedScope\":1, \"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\","
72 "\"TestName4\"],\"extendInfo\":\"\"}";
73 static const char *AGREE_PARAMS =
74 "{\"credType\":2, \"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId\",\"subject\":1,"
75 "\"keyFormat\":2,\"proofType\":1,\"authorizedScope\":1,\"algorithmType\":3,\"peerUserSpaceId\":\"100\","
76 "\"keyValue\":\"3059301306072a8648ce3d020106082a8648ce3d030107034200043bb1f8107c6306bddcdb70cd9fee0e581"
77 "5bbd305184871cd2880657eb2cc88aeece1a7f076d9fff7e1114e3bc9dfa45b061b2755b46fc282ef59763b4c0288bd\"}";
78 static const char *BATCH_UPDATE_PARAMS =
79 "{\"baseInfo\":{\"credType\":3,\"keyFormat\":2,\"algorithmType\":3,\"subject\":2,\"authorizedScope\":2,"
80 "\"issuer\":1,\"proofType\":2,\"credOwner\":\"TestAppId\"},"
81 "\"updateLists\":[{\"userId\":\"TestUserId\",\"deviceId\":\"TestDeviceId\"}]}";
82 static const char *BATCH_UPDATE_PARAMS1 =
83 "{\"baseInfo\":{\"credType\":1,\"keyFormat\":2,\"algorithmType\":3,\"subject\":2,\"authorizedScope\":2,"
84 "\"issuer\":1,\"proofType\":2,\"credOwner\":\"TestAppId\"},"
85 "\"updateLists\":[{\"userId\":\"TestUserId\",\"deviceId\":\"TestDeviceId\"}]}";
86
87 static const char *QUERY_PARAMS = "{\"deviceId\":\"TestDeviceId\"}";
88 static const char *DEL_PARAMS = "{\"credOwner\":\"TestAppId\"}";
89 static const char *DEL_PARAMS1 = "{\"credOwner\":\"TestAppId\",\"userIdHash\":\"12D2\",\"deviceIdHash\":\"12D2\"}";
NativeTokenSet(const char * procName)90 static void NativeTokenSet(const char *procName)
91 {
92 const char *acls[] = {"ACCESS_IDS"};
93 const char *perms[] = {
94 "ohos.permission.PLACE_CALL",
95 "ohos.permission.ACCESS_IDS"
96 };
97 uint64_t tokenId;
98 NativeTokenInfoParams infoInstance = {
99 .dcapsNum = 0,
100 .permsNum = 2,
101 .aclsNum = 1,
102 .dcaps = NULL,
103 .perms = perms,
104 .acls = acls,
105 .processName = procName,
106 .aplStr = "system_core",
107 };
108 tokenId = GetAccessTokenId(&infoInstance);
109 SetSelfTokenID(tokenId);
110 }
111
112 class GetCredMgrInstanceTest : public testing::Test {
113 public:
114 static void SetUpTestCase();
115 static void TearDownTestCase();
116 void SetUp();
117 void TearDown();
118 };
119
SetUpTestCase()120 void GetCredMgrInstanceTest::SetUpTestCase() {}
TearDownTestCase()121 void GetCredMgrInstanceTest::TearDownTestCase() {}
122
SetUp()123 void GetCredMgrInstanceTest::SetUp()
124 {
125 int ret = InitDeviceAuthService();
126 EXPECT_EQ(ret, HC_SUCCESS);
127 }
128
TearDown()129 void GetCredMgrInstanceTest::TearDown()
130 {
131 DestroyDeviceAuthService();
132 }
133
134 HWTEST_F(GetCredMgrInstanceTest, GetCredMgrInstanceTest001, TestSize.Level0)
135 {
136 const CredManager *cm = GetCredMgrInstance();
137 EXPECT_NE(cm, nullptr);
138 }
139
140 class GetCredAuthInstanceTest : public testing::Test {
141 public:
142 static void SetUpTestCase();
143 static void TearDownTestCase();
144 void SetUp();
145 void TearDown();
146 };
147
SetUpTestCase()148 void GetCredAuthInstanceTest::SetUpTestCase() {}
TearDownTestCase()149 void GetCredAuthInstanceTest::TearDownTestCase() {}
150
SetUp()151 void GetCredAuthInstanceTest::SetUp()
152 {
153 int ret = InitDeviceAuthService();
154 EXPECT_EQ(ret, HC_SUCCESS);
155 }
156
TearDown()157 void GetCredAuthInstanceTest::TearDown()
158 {
159 DestroyDeviceAuthService();
160 }
161
162 HWTEST_F(GetCredAuthInstanceTest, GetCredAuthInstanceTest001, TestSize.Level0)
163 {
164 const CredAuthManager *ca = GetCredAuthInstance();
165 EXPECT_NE(ca, nullptr);
166 }
167
168 class CredMgrAddCredentialTest : public testing::Test {
169 public:
170 static void SetUpTestCase();
171 static void TearDownTestCase();
172 void SetUp();
173 void TearDown();
174 };
175
SetUpTestCase()176 void CredMgrAddCredentialTest::SetUpTestCase() {}
TearDownTestCase()177 void CredMgrAddCredentialTest::TearDownTestCase() {}
178
SetUp()179 void CredMgrAddCredentialTest::SetUp()
180 {
181 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
182 int ret = InitDeviceAuthService();
183 ASSERT_EQ(ret, HC_SUCCESS);
184 const CredManager *cm = GetCredMgrInstance();
185 EXPECT_NE(cm, nullptr);
186 }
187
TearDown()188 void CredMgrAddCredentialTest::TearDown()
189 {
190 DestroyDeviceAuthService();
191 }
192
193 HWTEST_F(CredMgrAddCredentialTest, CredMgrAddCredentialTest001, TestSize.Level0)
194 {
195 const CredManager *cm = GetCredMgrInstance();
196 ASSERT_NE(cm, nullptr);
197 char *returnData = nullptr;
198 int32_t ret = cm->addCredential(TEST_OS_ACCOUNT_ID, nullptr, &returnData);
199 EXPECT_NE(ret, IS_SUCCESS);
200 cm->destroyInfo(&returnData);
201 }
202
203
204 HWTEST_F(CredMgrAddCredentialTest, CredMgrAddCredentialTest002, TestSize.Level0)
205 {
206 const CredManager *cm = GetCredMgrInstance();
207 ASSERT_NE(cm, nullptr);
208 char *returnData = nullptr;
209 int32_t ret = cm->addCredential(TEST_OS_ACCOUNT_ID, ADD_PARAMS, nullptr);
210 EXPECT_NE(ret, IS_SUCCESS);
211 cm->destroyInfo(&returnData);
212 }
213
214 HWTEST_F(CredMgrAddCredentialTest, CredMgrAddCredentialTest003, TestSize.Level0)
215 {
216 const CredManager *cm = GetCredMgrInstance();
217 ASSERT_NE(cm, nullptr);
218 char *returnData = nullptr;
219 int32_t ret = cm->addCredential(TEST_OS_ACCOUNT_ID, ADD_PARAMS1, &returnData);
220 EXPECT_NE(ret, IS_SUCCESS);
221 cm->destroyInfo(&returnData);
222 }
223
224 HWTEST_F(CredMgrAddCredentialTest, CredMgrAddCredentialTest004, TestSize.Level0)
225 {
226 const CredManager *cm = GetCredMgrInstance();
227 ASSERT_NE(cm, nullptr);
228 char *returnData = nullptr;
229 int32_t ret = cm->addCredential(TEST_OS_ACCOUNT_ID, ADD_PARAMS, &returnData);
230 EXPECT_EQ(ret, IS_SUCCESS);
231 cm->destroyInfo(&returnData);
232 }
233
234 class CredMgrExportCredentialTest : public testing::Test {
235 public:
236 static void SetUpTestCase();
237 static void TearDownTestCase();
238 void SetUp();
239 void TearDown();
240 };
241
SetUpTestCase()242 void CredMgrExportCredentialTest::SetUpTestCase() {}
TearDownTestCase()243 void CredMgrExportCredentialTest::TearDownTestCase() {}
244
SetUp()245 void CredMgrExportCredentialTest::SetUp()
246 {
247 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
248 int ret = InitDeviceAuthService();
249 ASSERT_EQ(ret, HC_SUCCESS);
250 }
251
TearDown()252 void CredMgrExportCredentialTest::TearDown()
253 {
254 DestroyDeviceAuthService();
255 }
256
257 HWTEST_F(CredMgrExportCredentialTest, CredMgrExportCredentialTest001, TestSize.Level0)
258 {
259 const CredManager *cm = GetCredMgrInstance();
260 ASSERT_NE(cm, nullptr);
261 char *returnData = nullptr;
262 int32_t ret = cm->exportCredential(TEST_OS_ACCOUNT_ID, nullptr, &returnData);
263 EXPECT_NE(ret, IS_SUCCESS);
264 cm->destroyInfo(&returnData);
265 }
266
267 HWTEST_F(CredMgrExportCredentialTest, CredMgrExportCredentialTest002, TestSize.Level0)
268 {
269 const CredManager *cm = GetCredMgrInstance();
270 ASSERT_NE(cm, nullptr);
271 char *credId = nullptr;
272 int32_t ret = cm->addCredential(TEST_OS_ACCOUNT_ID, ADD_PARAMS, &credId);
273 EXPECT_EQ(ret, IS_SUCCESS);
274 ret = cm->exportCredential(TEST_OS_ACCOUNT_ID, credId, nullptr);
275 HcFree(credId);
276 EXPECT_NE(ret, IS_SUCCESS);
277 }
278
279 HWTEST_F(CredMgrExportCredentialTest, CredMgrExportCredentialTest003, TestSize.Level0)
280 {
281 const CredManager *cm = GetCredMgrInstance();
282 ASSERT_NE(cm, nullptr);
283 char *credId = nullptr;
284 int32_t ret = cm->addCredential(TEST_OS_ACCOUNT_ID, ADD_PARAMS, &credId);
285 EXPECT_EQ(ret, IS_SUCCESS);
286 char *returnData = nullptr;
287 ret = cm->exportCredential(TEST_OS_ACCOUNT_ID, credId, &returnData);
288 HcFree(credId);
289 cm->destroyInfo(&returnData);
290 EXPECT_EQ(ret, IS_SUCCESS);
291 }
292
293 HWTEST_F(CredMgrExportCredentialTest, CredMgrExportCredentialTest004, TestSize.Level0)
294 {
295 const CredManager *cm = GetCredMgrInstance();
296 ASSERT_NE(cm, nullptr);
297 char *returnData = nullptr;
298 int32_t ret = cm->exportCredential(TEST_OS_ACCOUNT_ID, static_cast<const char *>(TEST_CRED_ID), &returnData);
299 EXPECT_NE(ret, IS_SUCCESS);
300 }
301
302 class CredMgrQueryCredentialByParamsTest : public testing::Test {
303 public:
304 static void SetUpTestCase();
305 static void TearDownTestCase();
306 void SetUp();
307 void TearDown();
308 };
309
SetUpTestCase()310 void CredMgrQueryCredentialByParamsTest::SetUpTestCase() {}
TearDownTestCase()311 void CredMgrQueryCredentialByParamsTest::TearDownTestCase() {}
312
SetUp()313 void CredMgrQueryCredentialByParamsTest::SetUp()
314 {
315 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
316 int ret = InitDeviceAuthService();
317 EXPECT_EQ(ret, IS_SUCCESS);
318 }
319
TearDown()320 void CredMgrQueryCredentialByParamsTest::TearDown()
321 {
322 DestroyDeviceAuthService();
323 }
324
325 HWTEST_F(CredMgrQueryCredentialByParamsTest, CredMgrQueryCredentialByParamsTest001, TestSize.Level0)
326 {
327 const CredManager *cm = GetCredMgrInstance();
328 ASSERT_NE(cm, nullptr);
329 char *returnData = nullptr;
330 int32_t ret = cm->addCredential(TEST_OS_ACCOUNT_ID, ADD_PARAMS, &returnData);
331 HcFree(returnData);
332 returnData = nullptr;
333 EXPECT_EQ(ret, IS_SUCCESS);
334 ret = cm->addCredential(TEST_OS_ACCOUNT_ID, ADD_PARAMS14, &returnData);
335 HcFree(returnData);
336 EXPECT_EQ(ret, IS_SUCCESS);
337 char *credIdList = nullptr;
338 ret = cm->queryCredentialByParams(TEST_OS_ACCOUNT_ID, QUERY_PARAMS, &credIdList);
339 EXPECT_EQ(ret, IS_SUCCESS);
340 CJson *jsonArr = CreateJsonFromString(credIdList);
341 int32_t size = GetItemNum(jsonArr);
342 HcFree(credIdList);
343 FreeJson(jsonArr);
344 EXPECT_NE(size, QUERY_RESULT_NUM);
345 }
346
347 HWTEST_F(CredMgrQueryCredentialByParamsTest, CredMgrQueryCredentialByParamsTest002, TestSize.Level0)
348 {
349 const CredManager *cm = GetCredMgrInstance();
350 ASSERT_NE(cm, nullptr);
351 char *credIdList = nullptr;
352 int32_t ret = cm->queryCredentialByParams(TEST_OS_ACCOUNT_ID, nullptr, &credIdList);
353 EXPECT_NE(ret, IS_SUCCESS);
354 }
355
356 HWTEST_F(CredMgrQueryCredentialByParamsTest, CredMgrQueryCredentialByParamsTest003, TestSize.Level0)
357 {
358 const CredManager *cm = GetCredMgrInstance();
359 ASSERT_NE(cm, nullptr);
360 int32_t ret = cm->queryCredentialByParams(TEST_OS_ACCOUNT_ID, QUERY_PARAMS, nullptr);
361 EXPECT_NE(ret, IS_SUCCESS);
362 }
363
364 class CredMgrQueryCredInfoByCredIdTest : public testing::Test {
365 public:
366 static void SetUpTestCase();
367 static void TearDownTestCase();
368 void SetUp();
369 void TearDown();
370 };
371
SetUpTestCase()372 void CredMgrQueryCredInfoByCredIdTest::SetUpTestCase() {}
TearDownTestCase()373 void CredMgrQueryCredInfoByCredIdTest::TearDownTestCase() {}
374
SetUp()375 void CredMgrQueryCredInfoByCredIdTest::SetUp()
376 {
377 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
378 int ret = InitDeviceAuthService();
379 EXPECT_EQ(ret, IS_SUCCESS);
380 }
381
TearDown()382 void CredMgrQueryCredInfoByCredIdTest::TearDown()
383 {
384 DestroyDeviceAuthService();
385 }
386
387 HWTEST_F(CredMgrQueryCredInfoByCredIdTest, CredMgrQueryCredInfoByCredIdTest001, TestSize.Level0)
388 {
389 const CredManager *cm = GetCredMgrInstance();
390 ASSERT_NE(cm, nullptr);
391 char *credId = nullptr;
392 int32_t ret = cm->addCredential(TEST_OS_ACCOUNT_ID, ADD_PARAMS, &credId);
393 EXPECT_EQ(ret, IS_SUCCESS);
394 char *returnCredInfo = nullptr;
395 ret = cm->queryCredInfoByCredId(TEST_OS_ACCOUNT_ID, credId, &returnCredInfo);
396 HcFree(credId);
397 EXPECT_EQ(ret, IS_SUCCESS);
398 CJson *credInfoJson = CreateJsonFromString(returnCredInfo);
399 HcFree(returnCredInfo);
400 const char *deviceId = GetStringFromJson(credInfoJson, FIELD_DEVICE_ID);
401 if (deviceId != nullptr) {
402 EXPECT_EQ(strcmp(deviceId, TEST_DEVICE_ID), TEST_RESULT_SUCCESS);
403 }
404 FreeJson(credInfoJson);
405 }
406
407 HWTEST_F(CredMgrQueryCredInfoByCredIdTest, CredMgrQueryCredInfoByCredIdTest002, TestSize.Level0)
408 {
409 const CredManager *cm = GetCredMgrInstance();
410 ASSERT_NE(cm, nullptr);
411 char *returnCredInfo = nullptr;
412 int32_t ret = cm->queryCredInfoByCredId(TEST_OS_ACCOUNT_ID, nullptr, &returnCredInfo);
413 EXPECT_NE(ret, IS_SUCCESS);
414 }
415
416 HWTEST_F(CredMgrQueryCredInfoByCredIdTest, CredMgrQueryCredInfoByCredIdTest003, TestSize.Level0)
417 {
418 const CredManager *cm = GetCredMgrInstance();
419 ASSERT_NE(cm, nullptr);
420 int32_t ret = cm->queryCredInfoByCredId(TEST_OS_ACCOUNT_ID, static_cast<const char *>(TEST_CRED_ID), nullptr);
421 EXPECT_NE(ret, IS_SUCCESS);
422 }
423
424 HWTEST_F(CredMgrQueryCredInfoByCredIdTest, CredMgrQueryCredInfoByCredIdTest004, TestSize.Level0)
425 {
426 const CredManager *cm = GetCredMgrInstance();
427 ASSERT_NE(cm, nullptr);
428 char *returnCredInfo = nullptr;
429 int32_t ret = cm->queryCredInfoByCredId(TEST_OS_ACCOUNT_ID, static_cast<const char *>(TEST_CRED_ID),
430 &returnCredInfo);
431 EXPECT_NE(ret, IS_SUCCESS);
432 HcFree(returnCredInfo);
433 }
434
435 class CredMgrDeleteCredentialTest : public testing::Test {
436 public:
437 static void SetUpTestCase();
438 static void TearDownTestCase();
439 void SetUp();
440 void TearDown();
441 };
442
SetUpTestCase()443 void CredMgrDeleteCredentialTest::SetUpTestCase() {}
TearDownTestCase()444 void CredMgrDeleteCredentialTest::TearDownTestCase() {}
445
SetUp()446 void CredMgrDeleteCredentialTest::SetUp()
447 {
448 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
449 int ret = InitDeviceAuthService();
450 EXPECT_EQ(ret, IS_SUCCESS);
451 }
452
TearDown()453 void CredMgrDeleteCredentialTest::TearDown()
454 {
455 DestroyDeviceAuthService();
456 }
457
458 HWTEST_F(CredMgrDeleteCredentialTest, CredMgrDeleteCredentialTest001, TestSize.Level0)
459 {
460 const CredManager *cm = GetCredMgrInstance();
461 ASSERT_NE(cm, nullptr);
462 char *credId = nullptr;
463 int32_t ret = cm->addCredential(TEST_OS_ACCOUNT_ID, ADD_PARAMS, &credId);
464 EXPECT_EQ(ret, IS_SUCCESS);
465 ret = cm->deleteCredential(TEST_OS_ACCOUNT_ID, credId);
466 HcFree(credId);
467 EXPECT_EQ(ret, IS_SUCCESS);
468 }
469
470 HWTEST_F(CredMgrDeleteCredentialTest, CredMgrDeleteCredentialTest002, TestSize.Level0)
471 {
472 const CredManager *cm = GetCredMgrInstance();
473 ASSERT_NE(cm, nullptr);
474 int32_t ret = cm->deleteCredential(TEST_OS_ACCOUNT_ID, nullptr);
475 EXPECT_NE(ret, IS_SUCCESS);
476 }
477
478 HWTEST_F(CredMgrDeleteCredentialTest, CredMgrDeleteCredentialTest003, TestSize.Level0)
479 {
480 const CredManager *cm = GetCredMgrInstance();
481 ASSERT_NE(cm, nullptr);
482 int32_t ret = cm->deleteCredential(TEST_OS_ACCOUNT_ID, static_cast<const char *>(TEST_CRED_ID));
483 EXPECT_NE(ret, IS_SUCCESS);
484 }
485
486 class CredMgrUpdateCredInfoTest : public testing::Test {
487 public:
488 static void SetUpTestCase();
489 static void TearDownTestCase();
490 void SetUp();
491 void TearDown();
492 };
493
SetUpTestCase()494 void CredMgrUpdateCredInfoTest::SetUpTestCase() {}
TearDownTestCase()495 void CredMgrUpdateCredInfoTest::TearDownTestCase() {}
496
SetUp()497 void CredMgrUpdateCredInfoTest::SetUp()
498 {
499 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
500 int ret = InitDeviceAuthService();
501 EXPECT_EQ(ret, IS_SUCCESS);
502 }
503
TearDown()504 void CredMgrUpdateCredInfoTest::TearDown()
505 {
506 DestroyDeviceAuthService();
507 }
508
509 HWTEST_F(CredMgrUpdateCredInfoTest, CredMgrUpdateCredInfoTest001, TestSize.Level0)
510 {
511 const CredManager *cm = GetCredMgrInstance();
512 ASSERT_NE(cm, nullptr);
513 char *credId = nullptr;
514 int32_t ret = cm->addCredential(TEST_OS_ACCOUNT_ID, ADD_PARAMS, &credId);
515 EXPECT_EQ(ret, IS_SUCCESS);
516 ret = cm->updateCredInfo(TEST_OS_ACCOUNT_ID, credId, REQUEST_PARAMS);
517 HcFree(credId);
518 EXPECT_EQ(ret, IS_SUCCESS);
519 }
520
521 HWTEST_F(CredMgrUpdateCredInfoTest, CredMgrUpdateCredInfoTest002, TestSize.Level0)
522 {
523 const CredManager *cm = GetCredMgrInstance();
524 ASSERT_NE(cm, nullptr);
525 char *credId = nullptr;
526 int32_t ret = cm->addCredential(TEST_OS_ACCOUNT_ID, ADD_PARAMS, &credId);
527 EXPECT_EQ(ret, IS_SUCCESS);
528 ret = cm->updateCredInfo(TEST_OS_ACCOUNT_ID, credId, "");
529 HcFree(credId);
530 EXPECT_NE(ret, IS_SUCCESS);
531 }
532
533 HWTEST_F(CredMgrUpdateCredInfoTest, CredMgrUpdateCredInfoTest003, TestSize.Level0)
534 {
535 const CredManager *cm = GetCredMgrInstance();
536 ASSERT_NE(cm, nullptr);
537 char *credId = nullptr;
538 int32_t ret = cm->addCredential(TEST_OS_ACCOUNT_ID, ADD_PARAMS, &credId);
539 EXPECT_EQ(ret, IS_SUCCESS);
540 ret = cm->updateCredInfo(TEST_OS_ACCOUNT_ID, credId, nullptr);
541 HcFree(credId);
542 EXPECT_NE(ret, IS_SUCCESS);
543 }
544
545 HWTEST_F(CredMgrUpdateCredInfoTest, CredMgrUpdateCredInfoTest004, TestSize.Level0)
546 {
547 const CredManager *cm = GetCredMgrInstance();
548 ASSERT_NE(cm, nullptr);
549 char *credId = nullptr;
550 int32_t ret = cm->addCredential(TEST_OS_ACCOUNT_ID, ADD_PARAMS, &credId);
551 EXPECT_EQ(ret, IS_SUCCESS);
552 ret = cm->updateCredInfo(TEST_OS_ACCOUNT_ID, nullptr, REQUEST_PARAMS);
553 HcFree(credId);
554 EXPECT_NE(ret, IS_SUCCESS);
555 }
556
557
558 class CredMgrRegCredListenerTest : public testing::Test {
559 public:
560 static void SetUpTestCase();
561 static void TearDownTestCase();
562 void SetUp();
563 void TearDown();
564 };
565
SetUpTestCase()566 void CredMgrRegCredListenerTest::SetUpTestCase() {}
TearDownTestCase()567 void CredMgrRegCredListenerTest::TearDownTestCase() {}
568
SetUp()569 void CredMgrRegCredListenerTest::SetUp()
570 {
571 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
572 int ret = InitDeviceAuthService();
573 EXPECT_EQ(ret, IS_SUCCESS);
574 }
575
TearDown()576 void CredMgrRegCredListenerTest::TearDown()
577 {
578 DestroyDeviceAuthService();
579 }
580
581 HWTEST_F(CredMgrRegCredListenerTest, CredMgrRegCredListenerTest001, TestSize.Level0)
582 {
583 const CredManager *cm = GetCredMgrInstance();
584 ASSERT_NE(cm, nullptr);
585 CredChangeListener listener;
586 int32_t ret = cm->registerChangeListener(TEST_APP_ID, &listener);
587 EXPECT_EQ(ret, IS_SUCCESS);
588 }
589
590 HWTEST_F(CredMgrRegCredListenerTest, CredMgrRegCredListenerTest002, TestSize.Level0)
591 {
592 const CredManager *cm = GetCredMgrInstance();
593 ASSERT_NE(cm, nullptr);
594 CredChangeListener listener;
595 int32_t ret = cm->registerChangeListener(TEST_APP_ID, &listener);
596 EXPECT_EQ(ret, IS_SUCCESS);
597 ret = cm->registerChangeListener(TEST_APP_ID, &listener);
598 EXPECT_EQ(ret, IS_SUCCESS);
599 }
600
601 HWTEST_F(CredMgrRegCredListenerTest, CredMgrRegCredListenerTest003, TestSize.Level0)
602 {
603 const CredManager *cm = GetCredMgrInstance();
604 ASSERT_NE(cm, nullptr);
605 CredChangeListener listener;
606 int32_t ret = cm->registerChangeListener(nullptr, &listener);
607 EXPECT_NE(ret, IS_SUCCESS);
608 }
609
610 HWTEST_F(CredMgrRegCredListenerTest, CredMgrRegCredListenerTest004, TestSize.Level0)
611 {
612 const CredManager *cm = GetCredMgrInstance();
613 ASSERT_NE(cm, nullptr);
614 int32_t ret = cm->registerChangeListener(TEST_APP_ID, nullptr);
615 EXPECT_NE(ret, IS_SUCCESS);
616 }
617
618 class CredMgrUnRegCredListenerTest : public testing::Test {
619 public:
620 static void SetUpTestCase();
621 static void TearDownTestCase();
622 void SetUp();
623 void TearDown();
624 };
625
SetUpTestCase()626 void CredMgrUnRegCredListenerTest::SetUpTestCase() {}
TearDownTestCase()627 void CredMgrUnRegCredListenerTest::TearDownTestCase() {}
628
SetUp()629 void CredMgrUnRegCredListenerTest::SetUp()
630 {
631 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
632 int ret = InitDeviceAuthService();
633 EXPECT_EQ(ret, IS_SUCCESS);
634 }
635
TearDown()636 void CredMgrUnRegCredListenerTest::TearDown()
637 {
638 DestroyDeviceAuthService();
639 }
640
641 HWTEST_F(CredMgrUnRegCredListenerTest, CredMgrUnRegCredListenerTest001, TestSize.Level0)
642 {
643 const CredManager *cm = GetCredMgrInstance();
644 ASSERT_NE(cm, nullptr);
645 CredChangeListener listener;
646 int32_t ret = cm->registerChangeListener(TEST_APP_ID, &listener);
647 EXPECT_EQ(ret, IS_SUCCESS);
648 ret = cm->unregisterChangeListener(TEST_APP_ID);
649 EXPECT_EQ(ret, IS_SUCCESS);
650 }
651
652 HWTEST_F(CredMgrUnRegCredListenerTest, CredMgrUnRegCredListenerTest002, TestSize.Level0)
653 {
654 const CredManager *cm = GetCredMgrInstance();
655 ASSERT_NE(cm, nullptr);
656 int32_t ret = cm->unregisterChangeListener(TEST_APP_ID);
657 EXPECT_EQ(ret, IS_SUCCESS);
658 }
659
660 HWTEST_F(CredMgrUnRegCredListenerTest, CredMgrUnRegCredListenerTest003, TestSize.Level0)
661 {
662 const CredManager *cm = GetCredMgrInstance();
663 ASSERT_NE(cm, nullptr);
664 int32_t ret = cm->unregisterChangeListener(nullptr);
665 EXPECT_NE(ret, IS_SUCCESS);
666 }
667
668 class CredMgrAgreeCredentialTest : public testing::Test {
669 public:
670 static void SetUpTestCase();
671 static void TearDownTestCase();
672 void SetUp();
673 void TearDown();
674 };
675
SetUpTestCase()676 void CredMgrAgreeCredentialTest::SetUpTestCase() {}
TearDownTestCase()677 void CredMgrAgreeCredentialTest::TearDownTestCase() {}
678
SetUp()679 void CredMgrAgreeCredentialTest::SetUp()
680 {
681 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
682 int ret = InitDeviceAuthService();
683 EXPECT_EQ(ret, IS_SUCCESS);
684 }
685
TearDown()686 void CredMgrAgreeCredentialTest::TearDown()
687 {
688 DestroyDeviceAuthService();
689 }
690
691 HWTEST_F(CredMgrAgreeCredentialTest, CredMgrAgreeCredentialTest001, TestSize.Level0)
692 {
693 const CredManager *cm = GetCredMgrInstance();
694 ASSERT_NE(cm, nullptr);
695 char *selfCredId = nullptr;
696 int32_t ret = cm->addCredential(TEST_OS_ACCOUNT_ID, ADD_PARAMS17, &selfCredId);
697 EXPECT_EQ(ret, IS_SUCCESS);
698 char *returnData = nullptr;
699 ret = cm->agreeCredential(TEST_OS_ACCOUNT_ID, selfCredId, AGREE_PARAMS, &returnData);
700 HcFree(selfCredId);
701 HcFree(returnData);
702 EXPECT_EQ(ret, IS_SUCCESS);
703 }
704
705 HWTEST_F(CredMgrAgreeCredentialTest, CredMgrAgreeCredentialTest002, TestSize.Level0)
706 {
707 const CredManager *cm = GetCredMgrInstance();
708 ASSERT_NE(cm, nullptr);
709 char *returnData = nullptr;
710 int32_t ret = cm->agreeCredential(TEST_OS_ACCOUNT_ID, nullptr, AGREE_PARAMS, &returnData);
711 EXPECT_NE(ret, IS_SUCCESS);
712 }
713
714 HWTEST_F(CredMgrAgreeCredentialTest, CredMgrAgreeCredentialTest003, TestSize.Level0)
715 {
716 const CredManager *cm = GetCredMgrInstance();
717 ASSERT_NE(cm, nullptr);
718 char *returnData = nullptr;
719 int32_t ret = cm->agreeCredential(TEST_OS_ACCOUNT_ID, TEST_CRED_ID, nullptr, &returnData);
720 EXPECT_NE(ret, IS_SUCCESS);
721 }
722
723 HWTEST_F(CredMgrAgreeCredentialTest, CredMgrAgreeCredentialTest004, TestSize.Level0)
724 {
725 const CredManager *cm = GetCredMgrInstance();
726 ASSERT_NE(cm, nullptr);
727 int32_t ret = cm->agreeCredential(TEST_OS_ACCOUNT_ID, TEST_CRED_ID, AGREE_PARAMS, nullptr);
728 EXPECT_NE(ret, IS_SUCCESS);
729 }
730
731
732 class CredMgrBatchUpdateCredsTest : public testing::Test {
733 public:
734 static void SetUpTestCase();
735 static void TearDownTestCase();
736 void SetUp();
737 void TearDown();
738 };
739
SetUpTestCase()740 void CredMgrBatchUpdateCredsTest::SetUpTestCase() {}
TearDownTestCase()741 void CredMgrBatchUpdateCredsTest::TearDownTestCase() {}
742
SetUp()743 void CredMgrBatchUpdateCredsTest::SetUp()
744 {
745 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
746 int ret = InitDeviceAuthService();
747 EXPECT_EQ(ret, IS_SUCCESS);
748 }
749
TearDown()750 void CredMgrBatchUpdateCredsTest::TearDown()
751 {
752 DestroyDeviceAuthService();
753 }
754
755 HWTEST_F(CredMgrBatchUpdateCredsTest, CredMgrBatchUpdateCredsTest001, TestSize.Level0)
756 {
757 const CredManager *cm = GetCredMgrInstance();
758 ASSERT_NE(cm, nullptr);
759 char *returnData = nullptr;
760 int32_t ret = cm->batchUpdateCredentials(TEST_OS_ACCOUNT_ID, BATCH_UPDATE_PARAMS, &returnData);
761 HcFree(returnData);
762 EXPECT_EQ(ret, IS_SUCCESS);
763 }
764
765 HWTEST_F(CredMgrBatchUpdateCredsTest, CredMgrBatchUpdateCredsTest002, TestSize.Level0)
766 {
767 const CredManager *cm = GetCredMgrInstance();
768 ASSERT_NE(cm, nullptr);
769 char *returnData = nullptr;
770 int32_t ret = cm->batchUpdateCredentials(TEST_OS_ACCOUNT_ID, nullptr, &returnData);
771 EXPECT_NE(ret, IS_SUCCESS);
772 }
773
774 HWTEST_F(CredMgrBatchUpdateCredsTest, CredMgrBatchUpdateCredsTest003, TestSize.Level0)
775 {
776 const CredManager *cm = GetCredMgrInstance();
777 ASSERT_NE(cm, nullptr);
778 char *returnData = nullptr;
779 int32_t ret = cm->batchUpdateCredentials(TEST_OS_ACCOUNT_ID, BATCH_UPDATE_PARAMS1, &returnData);
780 EXPECT_NE(ret, IS_SUCCESS);
781 }
782
783 HWTEST_F(CredMgrBatchUpdateCredsTest, CredMgrBatchUpdateCredsTest004, TestSize.Level0)
784 {
785 const CredManager *cm = GetCredMgrInstance();
786 ASSERT_NE(cm, nullptr);
787 int32_t ret = cm->batchUpdateCredentials(TEST_OS_ACCOUNT_ID, BATCH_UPDATE_PARAMS, nullptr);
788 EXPECT_NE(ret, IS_SUCCESS);
789 }
790
791 HWTEST_F(CredMgrBatchUpdateCredsTest, CredMgrBatchUpdateCredsTest005, TestSize.Level0)
792 {
793 const CredManager *cm = GetCredMgrInstance();
794 ASSERT_NE(cm, nullptr);
795 char *credId = nullptr;
796 int32_t ret = cm->addCredential(TEST_OS_ACCOUNT_ID, ADD_PARAMS18, &credId);
797 HcFree(credId);
798 EXPECT_EQ(ret, IS_SUCCESS);
799 char *returnData = nullptr;
800 ret = cm->batchUpdateCredentials(TEST_OS_ACCOUNT_ID, BATCH_UPDATE_PARAMS, &returnData);
801 HcFree(returnData);
802 EXPECT_EQ(ret, IS_SUCCESS);
803 }
804
805 class CredMgrDelCredByParamsTest : public testing::Test {
806 public:
807 static void SetUpTestCase();
808 static void TearDownTestCase();
809 void SetUp();
810 void TearDown();
811 };
812
SetUpTestCase()813 void CredMgrDelCredByParamsTest::SetUpTestCase() {}
TearDownTestCase()814 void CredMgrDelCredByParamsTest::TearDownTestCase() {}
815
SetUp()816 void CredMgrDelCredByParamsTest::SetUp()
817 {
818 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
819 int ret = InitDeviceAuthService();
820 EXPECT_EQ(ret, IS_SUCCESS);
821 }
822
TearDown()823 void CredMgrDelCredByParamsTest::TearDown()
824 {
825 DestroyDeviceAuthService();
826 }
827
828 HWTEST_F(CredMgrDelCredByParamsTest, CredMgrDelCredByParamsTest001, TestSize.Level0)
829 {
830 const CredManager *cm = GetCredMgrInstance();
831 ASSERT_NE(cm, nullptr);
832 char *credId = nullptr;
833 int32_t ret = cm->addCredential(TEST_OS_ACCOUNT_ID, ADD_PARAMS, &credId);
834 HcFree(credId);
835 EXPECT_EQ(ret, IS_SUCCESS);
836 char *returnData = nullptr;
837 ret = cm->deleteCredByParams(TEST_OS_ACCOUNT_ID, DEL_PARAMS, &returnData);
838 HcFree(returnData);
839 EXPECT_EQ(ret, IS_SUCCESS);
840 }
841
842 HWTEST_F(CredMgrDelCredByParamsTest, CredMgrDelCredByParamsTest002, TestSize.Level0)
843 {
844 const CredManager *cm = GetCredMgrInstance();
845 ASSERT_NE(cm, nullptr);
846 char *returnData = nullptr;
847 int32_t ret = cm->deleteCredByParams(TEST_OS_ACCOUNT_ID, nullptr, &returnData);
848 EXPECT_NE(ret, IS_SUCCESS);
849 }
850
851 HWTEST_F(CredMgrDelCredByParamsTest, CredMgrDelCredByParamsTest003, TestSize.Level0)
852 {
853 const CredManager *cm = GetCredMgrInstance();
854 ASSERT_NE(cm, nullptr);
855 int32_t ret = cm->deleteCredByParams(TEST_OS_ACCOUNT_ID, DEL_PARAMS, nullptr);
856 EXPECT_NE(ret, IS_SUCCESS);
857 }
858
859 HWTEST_F(CredMgrDelCredByParamsTest, CredMgrDelCredByParamsTest004, TestSize.Level0)
860 {
861 const CredManager *cm = GetCredMgrInstance();
862 ASSERT_NE(cm, nullptr);
863 char *credId = nullptr;
864 int32_t ret = cm->addCredential(TEST_OS_ACCOUNT_ID, ADD_PARAMS, &credId);
865 HcFree(credId);
866 EXPECT_EQ(ret, IS_SUCCESS);
867 char *returnData = nullptr;
868 ret = cm->deleteCredByParams(TEST_OS_ACCOUNT_ID, DEL_PARAMS1, &returnData);
869 HcFree(returnData);
870 EXPECT_EQ(ret, IS_SUCCESS);
871 }
872 }
873