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 <gtest/gtest.h>
17 #include <memory>
18 #include <string>
19 #include "accesstoken_log.h"
20 #include "access_token.h"
21 #define private public
22 #include "access_token_db.h"
23 #undef private
24 #include "data_translator.h"
25 #include "permission_def.h"
26 #include "generic_values.h"
27 #include "variant_value.h"
28
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace Security {
33 namespace AccessToken {
34 namespace {
35 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "DatabaseTest"};
36 static constexpr int32_t GET_INT64_TRUE_VALUE = -1;
37 static constexpr int32_t ROLLBACK_TRANSACTION_RESULT_ABNORMAL = -1;
38 static constexpr int32_t EXECUTESQL_RESULT_ABNORMAL = -1;
39 static const int32_t DEFAULT_VALUE = -1;
40 static const int32_t TEST_TOKEN_ID = 100;
41 } // namespace
42 class DatabaseTest : public testing::Test {
43 public:
44 static void SetUpTestCase(void);
45 static void TearDownTestCase(void);
46 void SetUp();
47 void TearDown();
48 };
49
SetUpTestCase()50 void DatabaseTest::SetUpTestCase() {}
TearDownTestCase()51 void DatabaseTest::TearDownTestCase() {}
SetUp()52 void DatabaseTest::SetUp() {}
TearDown()53 void DatabaseTest::TearDown() {}
54
55 /**
56 * @tc.name: PutInt64001
57 * @tc.desc: Verify the GenericValues put and get int64 value function.
58 * @tc.type: FUNC
59 * @tc.require: Issue Number
60 */
61 HWTEST_F(DatabaseTest, PutInt64001, TestSize.Level1)
62 {
63 GenericValues genericValues;
64 std::string key = "databasetest";
65 int64_t data = 1;
66 genericValues.Put(key, data);
67 int64_t outdata = genericValues.GetInt64(key);
68 EXPECT_EQ(outdata, data);
69 genericValues.Remove(key);
70 outdata = genericValues.GetInt64(key);
71 EXPECT_EQ(GET_INT64_TRUE_VALUE, outdata);
72 }
73
74 /**
75 * @tc.name: RollbackTransaction001
76 * @tc.desc: RollbackTransaction001 Abnormal branch res != SQLITE_OK
77 * @tc.type: FUNC
78 * @tc.require: Issue Number
79 */
80 HWTEST_F(DatabaseTest, RollbackTransaction001, TestSize.Level1)
81 {
82 AccessTokenDb::GetInstance().SetVersion();
83 int32_t result = AccessTokenDb::GetInstance().RollbackTransaction();
84 EXPECT_EQ(result, ROLLBACK_TRANSACTION_RESULT_ABNORMAL);
85 }
86
87 /**
88 * @tc.name: RollbackTransaction002
89 * @tc.desc: RollbackTransaction002 Abnormal branch db_ = nullptr
90 * @tc.type: FUNC
91 * @tc.require: Issue Number
92 */
93 HWTEST_F(DatabaseTest, RollbackTransaction002, TestSize.Level1)
94 {
95 AccessTokenDb::GetInstance().Close();
96 EXPECT_EQ(AccessTokenDb::GetInstance().RollbackTransaction(), ROLLBACK_TRANSACTION_RESULT_ABNORMAL);
97 }
98
99 /**
100 * @tc.name: ExecuteSql001
101 * @tc.desc: ExecuteSql001 Abnormal branch res != SQLITE_OK
102 * @tc.type: FUNC
103 * @tc.require: Issue Number
104 */
105 HWTEST_F(DatabaseTest, ExecuteSql001, TestSize.Level1)
106 {
107 std::string testSql = "test";
108 EXPECT_EQ(AccessTokenDb::GetInstance().ExecuteSql(testSql), EXECUTESQL_RESULT_ABNORMAL);
109 }
110
111 /**
112 * @tc.name: ExecuteSql002
113 * @tc.desc: ExecuteSql002 Abnormal branch db_ = nullptr
114 * @tc.type: FUNC
115 * @tc.require: Issue Number
116 */
117 HWTEST_F(DatabaseTest, ExecuteSql002, TestSize.Level1)
118 {
119 std::string testSql = "test";
120 AccessTokenDb::GetInstance().Close();
121 EXPECT_EQ(AccessTokenDb::GetInstance().ExecuteSql(testSql), EXECUTESQL_RESULT_ABNORMAL);
122 }
123
124 /**
125 * @tc.name: SpitError001
126 * @tc.desc: SpitError001 Abnormal branch db_ = nullptr
127 * @tc.type: FUNC
128 * @tc.require: Issue Number
129 */
130 HWTEST_F(DatabaseTest, SpitError001, TestSize.Level1)
131 {
132 AccessTokenDb::GetInstance().Close();
133 std::string result = AccessTokenDb::GetInstance().SpitError().c_str();
134 EXPECT_EQ(result.empty(), true);
135 }
136
137 /**
138 * @tc.name: SpitError002
139 * @tc.desc: SpitError002 use SpitError
140 * @tc.type: FUNC
141 * @tc.require: Issue Number
142 */
143 HWTEST_F(DatabaseTest, SpitError002, TestSize.Level1)
144 {
145 AccessTokenDb::GetInstance().Open();
146 std::string result = AccessTokenDb::GetInstance().SpitError().c_str();
147 EXPECT_EQ(result.length() > 0, true);
148 }
149
150 /**
151 * @tc.name: VariantValue64001
152 * @tc.desc: VariantValue64001 use VariantValue
153 * @tc.type: FUNC
154 * @tc.require: Issue Number
155 */
156 HWTEST_F(DatabaseTest, VariantValue64001, TestSize.Level1)
157 {
158 int64_t testValue = 1;
159 VariantValue Test(testValue);
160 EXPECT_EQ(Test.GetInt64(), testValue);
161 }
162
163 /**
164 * @tc.name: VariantValue64002
165 * @tc.desc: VariantValue64002 getint and getint64 Abnormal branch
166 * @tc.type: FUNC
167 * @tc.require: Issue Number
168 */
169 HWTEST_F(DatabaseTest, VariantValue64002, TestSize.Level1)
170 {
171 int32_t ntestValue = 1;
172 VariantValue Ntest(ntestValue);
173 EXPECT_EQ(DEFAULT_VALUE, Ntest.GetInt64());
174 int64_t testValue = 1;
175 VariantValue Test(testValue);
176 EXPECT_EQ(DEFAULT_VALUE, Test.GetInt());
177 }
178
179 /**
180 * @tc.name: VariantValue001
181 * @tc.desc: VariantValue001 getstring
182 * @tc.type: FUNC
183 * @tc.require:
184 */
185 HWTEST_F(DatabaseTest, VariantValue001, TestSize.Level1)
186 {
187 VariantValue Test;
188 Test.GetString();
189 EXPECT_EQ(ValueType::TYPE_NULL, Test.GetType());
190 }
191
RemoveTestTokenHapInfo()192 static void RemoveTestTokenHapInfo()
193 {
194 std::vector<GenericValues> hapInfoResults;
195 AccessTokenDb::GetInstance().Find(AccessTokenDb::ACCESSTOKEN_HAP_INFO, hapInfoResults);
196 for (GenericValues hapInfoValue : hapInfoResults) {
197 AccessTokenID tokenId = (AccessTokenID)hapInfoValue.GetInt(TokenFiledConst::FIELD_TOKEN_ID);
198 if (tokenId == TEST_TOKEN_ID) {
199 ASSERT_EQ(AccessTokenDb::SUCCESS,
200 AccessTokenDb::GetInstance().Remove(AccessTokenDb::ACCESSTOKEN_HAP_INFO, hapInfoValue));
201 break;
202 }
203 }
204 }
205
206 /*
207 * @tc.name: SqliteStorageAddTest001
208 * @tc.desc: Add function test
209 * @tc.type: FUNC
210 * @tc.require:
211 */
212 HWTEST_F(DatabaseTest, SqliteStorageAddTest001, TestSize.Level1)
213 {
214 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageAddTest001 begin");
215
216 RemoveTestTokenHapInfo();
217
218 GenericValues genericValues;
219 genericValues.Put(TokenFiledConst::FIELD_TOKEN_ID, TEST_TOKEN_ID);
220 genericValues.Put(TokenFiledConst::FIELD_USER_ID, 100);
221 genericValues.Put(TokenFiledConst::FIELD_BUNDLE_NAME, "test_bundle_name");
222 genericValues.Put(TokenFiledConst::FIELD_API_VERSION, 9);
223 genericValues.Put(TokenFiledConst::FIELD_INST_INDEX, 0);
224 genericValues.Put(TokenFiledConst::FIELD_DLP_TYPE, 0);
225 genericValues.Put(TokenFiledConst::FIELD_APP_ID, "test_app_id");
226 genericValues.Put(TokenFiledConst::FIELD_DEVICE_ID, "test_device_id");
227 genericValues.Put(TokenFiledConst::FIELD_APL, ATokenAplEnum::APL_NORMAL);
228 genericValues.Put(TokenFiledConst::FIELD_TOKEN_VERSION, 0);
229 genericValues.Put(TokenFiledConst::FIELD_TOKEN_ATTR, 0);
230 genericValues.Put(TokenFiledConst::FIELD_FORBID_PERM_DIALOG, "test_perm_dialog_cap_state");
231
232 std::vector<GenericValues> values;
233 values.emplace_back(genericValues);
234 EXPECT_EQ(AccessTokenDb::SUCCESS, AccessTokenDb::GetInstance().Add(AccessTokenDb::ACCESSTOKEN_HAP_INFO, values));
235 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageAddTest001 end");
236 }
237
238 /*
239 * @tc.name: SqliteStorageAddTest002
240 * @tc.desc: Add function test failed
241 * @tc.type: FUNC
242 * @tc.require:
243 */
244 HWTEST_F(DatabaseTest, SqliteStorageAddTest002, TestSize.Level1)
245 {
246 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageAddTest002 begin");
247
248 RemoveTestTokenHapInfo();
249
250 GenericValues genericValues;
251 genericValues.Put(TokenFiledConst::FIELD_TOKEN_ID, TEST_TOKEN_ID);
252
253 std::vector<GenericValues> values;
254 values.emplace_back(genericValues);
255 EXPECT_EQ(AccessTokenDb::FAILURE, AccessTokenDb::GetInstance().Add(AccessTokenDb::ACCESSTOKEN_HAP_INFO, values));
256 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageAddTest002 end");
257 }
258
259 /*
260 * @tc.name: SqliteStorageModifyTest001
261 * @tc.desc: Modify function test
262 * @tc.type: FUNC
263 * @tc.require:
264 */
265 HWTEST_F(DatabaseTest, SqliteStorageModifyTest001, TestSize.Level1)
266 {
267 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageModifyTest001 begin");
268
269 RemoveTestTokenHapInfo();
270
271 GenericValues genericValues;
272 genericValues.Put(TokenFiledConst::FIELD_TOKEN_ID, TEST_TOKEN_ID);
273 genericValues.Put(TokenFiledConst::FIELD_USER_ID, 100);
274 genericValues.Put(TokenFiledConst::FIELD_BUNDLE_NAME, "test_bundle_name");
275 genericValues.Put(TokenFiledConst::FIELD_API_VERSION, 9);
276 genericValues.Put(TokenFiledConst::FIELD_INST_INDEX, 0);
277 genericValues.Put(TokenFiledConst::FIELD_DLP_TYPE, 0);
278 genericValues.Put(TokenFiledConst::FIELD_APP_ID, "test_app_id");
279 genericValues.Put(TokenFiledConst::FIELD_DEVICE_ID, "test_device_id");
280 genericValues.Put(TokenFiledConst::FIELD_APL, ATokenAplEnum::APL_NORMAL);
281 genericValues.Put(TokenFiledConst::FIELD_TOKEN_VERSION, 0);
282 genericValues.Put(TokenFiledConst::FIELD_TOKEN_ATTR, 0);
283 genericValues.Put(TokenFiledConst::FIELD_FORBID_PERM_DIALOG, "test_perm_dialog_cap_state");
284
285 std::vector<GenericValues> values;
286 values.emplace_back(genericValues);
287 EXPECT_EQ(AccessTokenDb::SUCCESS, AccessTokenDb::GetInstance().Add(AccessTokenDb::ACCESSTOKEN_HAP_INFO, values));
288
289 GenericValues modifyValues;
290 modifyValues.Put(TokenFiledConst::FIELD_BUNDLE_NAME, "test_bundle_name_modified");
291
292 GenericValues conditions;
293 conditions.Put(TokenFiledConst::FIELD_TOKEN_ID, TEST_TOKEN_ID);
294 conditions.Put(TokenFiledConst::FIELD_USER_ID, 100);
295
296 ASSERT_EQ(AccessTokenDb::SUCCESS, AccessTokenDb::GetInstance().Modify(AccessTokenDb::ACCESSTOKEN_HAP_INFO,
297 modifyValues, conditions));
298
299 bool modifySuccess = false;
300 std::vector<GenericValues> hapInfoResults;
301 AccessTokenDb::GetInstance().Find(AccessTokenDb::ACCESSTOKEN_HAP_INFO, hapInfoResults);
302 for (GenericValues hapInfoValue : hapInfoResults) {
303 AccessTokenID tokenId = (AccessTokenID)hapInfoValue.GetInt(TokenFiledConst::FIELD_TOKEN_ID);
304 if (tokenId == TEST_TOKEN_ID) {
305 ASSERT_EQ("test_bundle_name_modified", hapInfoValue.GetString(TokenFiledConst::FIELD_BUNDLE_NAME));
306 modifySuccess = true;
307 break;
308 }
309 }
310 EXPECT_TRUE(modifySuccess);
311 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageModifyTest001 end");
312 }
313
314 /*
315 * @tc.name: SqliteStorageRefreshAllTest001
316 * @tc.desc: RefreshAll function test failed
317 * @tc.type: FUNC
318 * @tc.require:
319 */
320 HWTEST_F(DatabaseTest, SqliteStorageRefreshAllTest001, TestSize.Level1)
321 {
322 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageRefreshAllTest001 begin");
323
324 RemoveTestTokenHapInfo();
325
326 GenericValues genericValues;
327 genericValues.Put(TokenFiledConst::FIELD_TOKEN_ID, TEST_TOKEN_ID);
328
329 std::vector<GenericValues> values;
330 values.emplace_back(genericValues);
331 EXPECT_EQ(AccessTokenDb::FAILURE,
332 AccessTokenDb::GetInstance().RefreshAll(AccessTokenDb::ACCESSTOKEN_HAP_INFO, values));
333 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageRefreshAllTest001 end");
334 }
335
336 /*
337 * @tc.name: SqliteStorageCreateInsertPrepareSqlCmd001
338 * @tc.desc: CreateInsertPrepareSqlCmd function test type not found
339 * @tc.type: FUNC
340 * @tc.require:
341 */
342 HWTEST_F(DatabaseTest, SqliteStorageCreateInsertPrepareSqlCmd001, TestSize.Level1)
343 {
344 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageCreateInsertPrepareSqlCmdTest001 begin");
345 AccessTokenDb::DataType type = static_cast<AccessTokenDb::DataType>(100);
346 ASSERT_EQ("", AccessTokenDb::GetInstance().CreateInsertPrepareSqlCmd(type));
347 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageCreateInsertPrepareSqlCmdTest001 end");
348 }
349
350 /*
351 * @tc.name: SqliteStorageCreateDeletePrepareSqlCmd001
352 * @tc.desc: CreateDeletePrepareSqlCmd function test type not found
353 * @tc.type: FUNC
354 * @tc.require:
355 */
356 HWTEST_F(DatabaseTest, SqliteStorageCreateDeletePrepareSqlCmd001, TestSize.Level1)
357 {
358 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageCreateDeletePrepareSqlCmdTest001 begin");
359 AccessTokenDb::DataType type = static_cast<AccessTokenDb::DataType>(100);
360 ASSERT_EQ("", AccessTokenDb::GetInstance().CreateDeletePrepareSqlCmd(type));
361 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageCreateDeletePrepareSqlCmdTest001 end");
362 }
363
364 /*
365 * @tc.name: SqliteStorageCreateUpdatePrepareSqlCmd001
366 * @tc.desc: CreateUpdatePrepareSqlCmd function test type not found
367 * @tc.type: FUNC
368 * @tc.require:
369 */
370 HWTEST_F(DatabaseTest, SqliteStorageCreateUpdatePrepareSqlCmd001, TestSize.Level1)
371 {
372 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageCreateUpdatePrepareSqlCmdTest001 begin");
373
374 AccessTokenDb::DataType type = static_cast<AccessTokenDb::DataType>(100);
375
376 GenericValues conditions;
377 conditions.Put(TokenFiledConst::FIELD_TOKEN_ID, TEST_TOKEN_ID);
378 conditions.Put(TokenFiledConst::FIELD_USER_ID, 100);
379
380 GenericValues modifyValues;
381 modifyValues.Put(TokenFiledConst::FIELD_BUNDLE_NAME, "test_bundle_name_modified");
382
383 std::vector<std::string> modifyColumns = modifyValues.GetAllKeys();
384 std::vector<std::string> conditionColumns = conditions.GetAllKeys();
385
386 ASSERT_EQ("", AccessTokenDb::GetInstance().CreateUpdatePrepareSqlCmd(type, modifyColumns, conditionColumns));
387 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageCreateUpdatePrepareSqlCmdTest001 end");
388 }
389
390 /**
391 * @tc.name: SqliteStorageCreateUpdatePrepareSqlCmd002
392 * @tc.desc: AccessTokenDb::CreateUpdatePrepareSqlCmd function test
393 * @tc.type: FUNC
394 * @tc.require:
395 */
396 HWTEST_F(DatabaseTest, SqliteStorageCreateUpdatePrepareSqlCmd002, TestSize.Level1)
397 {
398 AccessTokenDb::DataType type = AccessTokenDb::DataType::ACCESSTOKEN_HAP_INFO;
399 std::vector<std::string> modifyColumns;
400 std::vector<std::string> conditionColumns;
401
402 // modifyColumns is empty
403 ASSERT_EQ("", AccessTokenDb::GetInstance().CreateUpdatePrepareSqlCmd(type, modifyColumns, conditionColumns));
404
405 type = AccessTokenDb::DataType::ACCESSTOKEN_HAP_INFO;
406 modifyColumns.emplace_back(TokenFiledConst::FIELD_TOKEN_ID);
407 modifyColumns.emplace_back(TokenFiledConst::FIELD_USER_ID);
408 // modifyColumns is not empty + modifyColumns.size > 1 + conditionColumns is empty
409 ASSERT_NE("", AccessTokenDb::GetInstance().CreateUpdatePrepareSqlCmd(type, modifyColumns, conditionColumns));
410 }
411
412 /*
413 * @tc.name: SqliteStorageCreateSelectPrepareSqlCmd001
414 * @tc.desc: CreateSelectPrepareSqlCmd function test type not found
415 * @tc.type: FUNC
416 * @tc.require:
417 */
418 HWTEST_F(DatabaseTest, SqliteStorageCreateSelectPrepareSqlCmd001, TestSize.Level1)
419 {
420 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageCreateSelectPrepareSqlCmdTest001 begin");
421 AccessTokenDb::DataType type = static_cast<AccessTokenDb::DataType>(100);
422 ASSERT_EQ("", AccessTokenDb::GetInstance().CreateSelectPrepareSqlCmd(type));
423 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageCreateSelectPrepareSqlCmdTest001 end");
424 }
425
426 /*
427 * @tc.name: SqliteStorageCreateHapTokenInfoTable001
428 * @tc.desc: CreateHapTokenInfoTable function test
429 * @tc.type: FUNC
430 * @tc.require:
431 */
432 HWTEST_F(DatabaseTest, SqliteStorageCreateHapTokenInfoTable001, TestSize.Level1)
433 {
434 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageCreateHapTokenInfoTableTest001 begin");
435 ASSERT_EQ(AccessTokenDb::SUCCESS, AccessTokenDb::GetInstance().CreateHapTokenInfoTable());
436 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageCreateHapTokenInfoTableTest001 end");
437 }
438
439 /**
440 * @tc.name: SqliteStorageCreateHapTokenInfoTable002
441 * @tc.desc: AccessTokenDb::CreateHapTokenInfoTable function test
442 * @tc.type: FUNC
443 * @tc.require:
444 */
445 HWTEST_F(DatabaseTest, SqliteStorageCreateHapTokenInfoTable002, TestSize.Level1)
446 {
447 std::map<AccessTokenDb::DataType, AccessTokenDb::SqliteTable> dataTypeToSqlTable;
448 dataTypeToSqlTable = AccessTokenDb::GetInstance().dataTypeToSqlTable_; // backup
449 AccessTokenDb::GetInstance().dataTypeToSqlTable_.clear();
450
451 ASSERT_EQ(AccessTokenDb::FAILURE, AccessTokenDb::GetInstance().CreateHapTokenInfoTable());
452 ASSERT_EQ(AccessTokenDb::FAILURE, AccessTokenDb::GetInstance().CreateNativeTokenInfoTable());
453 ASSERT_EQ(AccessTokenDb::FAILURE, AccessTokenDb::GetInstance().CreatePermissionDefinitionTable());
454 ASSERT_EQ(AccessTokenDb::FAILURE, AccessTokenDb::GetInstance().CreatePermissionStateTable());
455
456 AccessTokenDb::GetInstance().dataTypeToSqlTable_ = dataTypeToSqlTable; // recovery
457 }
458
459 /*
460 * @tc.name: SqliteStorageCreateNativeTokenInfoTable001
461 * @tc.desc: CreateNativeTokenInfoTable function test
462 * @tc.type: FUNC
463 * @tc.require:
464 */
465 HWTEST_F(DatabaseTest, SqliteStorageCreateNativeTokenInfoTable001, TestSize.Level1)
466 {
467 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageCreateNativeTokenInfoTableTest001 begin");
468 ASSERT_EQ(AccessTokenDb::SUCCESS, AccessTokenDb::GetInstance().CreateNativeTokenInfoTable());
469 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageCreateNativeTokenInfoTableTest001 end");
470 }
471
472 /*
473 * @tc.name: SqliteStorageCreatePermissionDefinitionTable001
474 * @tc.desc: CreatePermissionDefinitionTable function test
475 * @tc.type: FUNC
476 * @tc.require:
477 */
478 HWTEST_F(DatabaseTest, SqliteStorageCreatePermissionDefinitionTable001, TestSize.Level1)
479 {
480 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageCreatePermissionDefinitionTableTest001 begin");
481 ASSERT_EQ(AccessTokenDb::SUCCESS, AccessTokenDb::GetInstance().CreatePermissionDefinitionTable());
482 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageCreatePermissionDefinitionTableTest001 end");
483 }
484
485 /*
486 * @tc.name: SqliteStorageCreatePermissionStateTable001
487 * @tc.desc: CreatePermissionStateTable function test
488 * @tc.type: FUNC
489 * @tc.require:
490 */
491 HWTEST_F(DatabaseTest, SqliteStorageCreatePermissionStateTable001, TestSize.Level1)
492 {
493 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageCreatePermissionStateTableTest001 begin");
494 ASSERT_EQ(AccessTokenDb::SUCCESS, AccessTokenDb::GetInstance().CreatePermissionStateTable());
495 ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageCreatePermissionStateTableTest001 end");
496 }
497
498 /*
499 * @tc.name: DataTranslatorTranslationIntoPermissionDef001
500 * @tc.desc: TranslationIntoPermissionDef function test
501 * @tc.type: FUNC
502 * @tc.require:
503 */
504 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionDef001, TestSize.Level1)
505 {
506 ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionDefTest001 begin");
507
508 RemoveTestTokenHapInfo();
509
510 GenericValues genericValues;
511 genericValues.Put(TokenFiledConst::FIELD_TOKEN_ID, TEST_TOKEN_ID);
512 genericValues.Put(TokenFiledConst::FIELD_AVAILABLE_LEVEL, ATokenAplEnum::APL_INVALID);
513
514 PermissionDef outPermissionDef;
515 ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionDef(genericValues, outPermissionDef));
516 ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionDefTest001 end");
517 }
518
519 /*
520 * @tc.name: DataTranslatorTranslationIntoGenericValues001
521 * @tc.desc: DataTranslatorTranslationIntoGenericValues function test
522 * @tc.type: FUNC
523 * @tc.require:
524 */
525 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoGenericValues001, TestSize.Level1)
526 {
527 ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoGenericValues001 begin");
528 PermissionStateFull grantPermissionReq = {
529 .permissionName = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS",
530 .isGeneral = true,
531 .resDeviceID = {"device1"},
532 .grantStatus = {PermissionState::PERMISSION_GRANTED},
533 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}
534 };
535 int grantIndex = 1;
536 GenericValues genericValues;
537 ASSERT_NE(RET_SUCCESS,
538 DataTranslator::TranslationIntoGenericValues(grantPermissionReq, grantIndex, genericValues));
539 ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoGenericValues001 end");
540 }
541
542 /*
543 * @tc.name: DataTranslatorTranslationIntoGenericValues002
544 * @tc.desc: DataTranslatorTranslationIntoGenericValues function test
545 * @tc.type: FUNC
546 * @tc.require:
547 */
548 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoGenericValues002, TestSize.Level1)
549 {
550 ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoGenericValues002 begin");
551 PermissionStateFull grantPermissionReq = {
552 .permissionName = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS",
553 .isGeneral = true,
554 .resDeviceID = {"device1", "device2"},
555 .grantStatus = {PermissionState::PERMISSION_GRANTED},
556 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}
557 };
558 int grantIndex = 1;
559 GenericValues genericValues;
560 ASSERT_NE(RET_SUCCESS,
561 DataTranslator::TranslationIntoGenericValues(grantPermissionReq, grantIndex, genericValues));
562 ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoGenericValues002 end");
563 }
564
565 /*
566 * @tc.name: DataTranslatorTranslationIntoGenericValues003
567 * @tc.desc: DataTranslatorTranslationIntoGenericValues function test
568 * @tc.type: FUNC
569 * @tc.require:
570 */
571 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoGenericValues003, TestSize.Level1)
572 {
573 ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoGenericValues003 begin");
574 PermissionStateFull grantPermissionReq = {
575 .permissionName = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS",
576 .isGeneral = true,
577 .resDeviceID = {"device1", "device2"},
578 .grantStatus = {PermissionState::PERMISSION_GRANTED, PermissionState::PERMISSION_GRANTED},
579 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}
580 };
581 int grantIndex = 1;
582 GenericValues genericValues;
583 ASSERT_NE(RET_SUCCESS,
584 DataTranslator::TranslationIntoGenericValues(grantPermissionReq, grantIndex, genericValues));
585 ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoGenericValues003 end");
586 }
587
588 /*
589 * @tc.name: DataTranslatorTranslationIntoPermissionStateFull001
590 * @tc.desc: TranslationIntoPermissionStateFull function test
591 * @tc.type: FUNC
592 * @tc.require:
593 */
594 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionStateFull001, TestSize.Level1)
595 {
596 ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionStateFullTest001 begin");
597
598 PermissionStateFull outPermissionState;
599
600 GenericValues inGenericValues;
601 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, 1);
602 inGenericValues.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "");
603
604 PermissionDef outPermissionDef;
605 ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionStateFull(inGenericValues, outPermissionState));
606 ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionStateFullTest001 end");
607 }
608
609 /*
610 * @tc.name: DataTranslatorTranslationIntoPermissionStateFull002
611 * @tc.desc: TranslationIntoPermissionStateFull function test
612 * @tc.type: FUNC
613 * @tc.require:
614 */
615 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionStateFull002, TestSize.Level1)
616 {
617 ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionStateFullTest002 begin");
618
619 PermissionStateFull outPermissionState;
620
621 GenericValues inGenericValues;
622 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, 1);
623 inGenericValues.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "test_permission_name");
624 inGenericValues.Put(TokenFiledConst::FIELD_DEVICE_ID, "");
625
626 PermissionDef outPermissionDef;
627 ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionStateFull(inGenericValues, outPermissionState));
628 ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionStateFullTest002 end");
629 }
630
631 /*
632 * @tc.name: DataTranslatorTranslationIntoPermissionStateFull003
633 * @tc.desc: TranslationIntoPermissionStateFull function test
634 * @tc.type: FUNC
635 * @tc.require:
636 */
637 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionStateFull003, TestSize.Level1)
638 {
639 ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionStateFullTest003 begin");
640
641 PermissionStateFull outPermissionState;
642
643 GenericValues inGenericValues;
644 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, 1);
645 inGenericValues.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "test_permission_name");
646 inGenericValues.Put(TokenFiledConst::FIELD_DEVICE_ID, "test_device_id");
647 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_STATE, 100);
648
649 PermissionDef outPermissionDef;
650 ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionStateFull(inGenericValues, outPermissionState));
651 ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionStateFullTest003 end");
652 }
653
654 /*
655 * @tc.name: DataTranslatorTranslationIntoPermissionStateFull004
656 * @tc.desc: TranslationIntoPermissionStateFull function test
657 * @tc.type: FUNC
658 * @tc.require:
659 */
660 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionStateFull004, TestSize.Level1)
661 {
662 ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionStateFullTest004 begin");
663
664 PermissionStateFull outPermissionState;
665
666 GenericValues inGenericValues;
667 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, 1);
668 inGenericValues.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "test_permission_name");
669 inGenericValues.Put(TokenFiledConst::FIELD_DEVICE_ID, "test_device_id");
670 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_STATE, PermissionState::PERMISSION_GRANTED);
671 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_FLAG, 100);
672
673 PermissionDef outPermissionDef;
674 ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionStateFull(inGenericValues, outPermissionState));
675 ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionStateFullTest004 end");
676 }
677 } // namespace AccessToken
678 } // namespace Security
679 } // namespace OHOS