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