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