1 /*
2  * Copyright (c) 2022-2024 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 #include "access_token_open_callback.h"
24 #undef private
25 #include "access_token_error.h"
26 #include "data_translator.h"
27 #include "permission_def.h"
28 #include "generic_values.h"
29 #include "token_field_const.h"
30 #include "variant_value.h"
31 
32 using namespace testing::ext;
33 
34 namespace OHOS {
35 namespace Security {
36 namespace AccessToken {
37 namespace {
38 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "DatabaseTest"};
39 static constexpr int32_t GET_INT64_TRUE_VALUE = -1;
40 static const int32_t DEFAULT_VALUE = -1;
41 static const int32_t TEST_TOKEN_ID = 100;
42 } // namespace
43 class DatabaseTest : public testing::Test {
44 public:
45     static void SetUpTestCase(void);
46     static void TearDownTestCase(void);
47     void SetUp();
48     void TearDown();
49 };
50 
SetUpTestCase()51 void DatabaseTest::SetUpTestCase() {}
TearDownTestCase()52 void DatabaseTest::TearDownTestCase() {}
SetUp()53 void DatabaseTest::SetUp() {}
TearDown()54 void DatabaseTest::TearDown() {}
55 
56 /**
57  * @tc.name: PutInt64001
58  * @tc.desc: Verify the GenericValues put and get int64 value function.
59  * @tc.type: FUNC
60  * @tc.require: Issue Number
61  */
62 HWTEST_F(DatabaseTest, PutInt64001, TestSize.Level1)
63 {
64     GenericValues genericValues;
65     std::string key = "databasetest";
66     int64_t data = 1;
67     genericValues.Put(key, data);
68     int64_t outdata = genericValues.GetInt64(key);
69     EXPECT_EQ(outdata, data);
70     genericValues.Remove(key);
71     outdata = genericValues.GetInt64(key);
72     EXPECT_EQ(GET_INT64_TRUE_VALUE, outdata);
73 }
74 
75 /**
76  * @tc.name: PutVariant001
77  * @tc.desc: Verify the GenericValues put and get variant value function.
78  * @tc.type: FUNC
79  * @tc.require: Issue Number
80  */
81 HWTEST_F(DatabaseTest, PutVariant001, TestSize.Level1)
82 {
83     GenericValues genericValues;
84     std::string key = "databasetest";
85     int64_t testValue = 1;
86     VariantValue Test(testValue);
87     genericValues.Put(key, Test);
88     VariantValue outdata = genericValues.Get(key);
89     EXPECT_EQ(outdata.GetInt64(), testValue);
90     outdata = genericValues.Get("key");
91     EXPECT_EQ(DEFAULT_VALUE, outdata.GetInt64());
92     genericValues.Remove(key);
93     genericValues.Remove("key");
94 }
95 
96 /**
97  * @tc.name: VariantValue64001
98  * @tc.desc: VariantValue64001 use VariantValue
99  * @tc.type: FUNC
100  * @tc.require: Issue Number
101  */
102 HWTEST_F(DatabaseTest, VariantValue64001, TestSize.Level1)
103 {
104     int64_t testValue = 1;
105     VariantValue Test(testValue);
106     EXPECT_EQ(Test.GetInt64(), testValue);
107 }
108 
109 /**
110  * @tc.name: VariantValue64002
111  * @tc.desc: VariantValue64002 getint and getint64 Abnormal branch
112  * @tc.type: FUNC
113  * @tc.require: Issue Number
114  */
115 HWTEST_F(DatabaseTest, VariantValue64002, TestSize.Level1)
116 {
117     int32_t ntestValue = 1;
118     VariantValue Ntest(ntestValue);
119     EXPECT_EQ(DEFAULT_VALUE, Ntest.GetInt64());
120     int64_t testValue = 1;
121     VariantValue Test(testValue);
122     EXPECT_EQ(DEFAULT_VALUE, Test.GetInt());
123 }
124 
125 /**
126  * @tc.name: VariantValue001
127  * @tc.desc: VariantValue001 getstring
128  * @tc.type: FUNC
129  * @tc.require:
130  */
131 HWTEST_F(DatabaseTest, VariantValue001, TestSize.Level1)
132 {
133     VariantValue Test;
134     Test.GetString();
135     EXPECT_EQ(ValueType::TYPE_NULL, Test.GetType());
136 }
137 
RemoveTestTokenHapInfo()138 static void RemoveTestTokenHapInfo()
139 {
140     GenericValues conditionValue;
141     std::vector<GenericValues> hapInfoResults;
142     AccessTokenDb::GetInstance().Find(AtmDataType::ACCESSTOKEN_HAP_INFO, conditionValue, hapInfoResults);
143     for (GenericValues hapInfoValue : hapInfoResults) {
144         AccessTokenID tokenId = (AccessTokenID)hapInfoValue.GetInt(TokenFiledConst::FIELD_TOKEN_ID);
145         if (tokenId == TEST_TOKEN_ID) {
146             ASSERT_EQ(0, AccessTokenDb::GetInstance().Remove(AtmDataType::ACCESSTOKEN_HAP_INFO, hapInfoValue));
147             break;
148         }
149     }
150 }
151 
152 /*
153  * @tc.name: SqliteStorageAddTest001
154  * @tc.desc: Add function test
155  * @tc.type: FUNC
156  * @tc.require:
157  */
158 HWTEST_F(DatabaseTest, SqliteStorageAddTest001, TestSize.Level1)
159 {
160     ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageAddTest001 begin");
161 
162     RemoveTestTokenHapInfo();
163 
164     GenericValues genericValues;
165     genericValues.Put(TokenFiledConst::FIELD_TOKEN_ID, TEST_TOKEN_ID);
166     genericValues.Put(TokenFiledConst::FIELD_USER_ID, 100);
167     genericValues.Put(TokenFiledConst::FIELD_BUNDLE_NAME, "test_bundle_name");
168     genericValues.Put(TokenFiledConst::FIELD_API_VERSION, 9);
169     genericValues.Put(TokenFiledConst::FIELD_INST_INDEX, 0);
170     genericValues.Put(TokenFiledConst::FIELD_DLP_TYPE, 0);
171     genericValues.Put(TokenFiledConst::FIELD_APP_ID, "test_app_id");
172     genericValues.Put(TokenFiledConst::FIELD_DEVICE_ID, "test_device_id");
173     genericValues.Put(TokenFiledConst::FIELD_APL, ATokenAplEnum::APL_NORMAL);
174     genericValues.Put(TokenFiledConst::FIELD_TOKEN_VERSION, 0);
175     genericValues.Put(TokenFiledConst::FIELD_TOKEN_ATTR, 0);
176     genericValues.Put(TokenFiledConst::FIELD_FORBID_PERM_DIALOG, "test_perm_dialog_cap_state");
177 
178     std::vector<GenericValues> values;
179     values.emplace_back(genericValues);
180     EXPECT_EQ(0, AccessTokenDb::GetInstance().Add(AtmDataType::ACCESSTOKEN_HAP_INFO, values));
181     ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageAddTest001 end");
182 }
183 
184 /*
185  * @tc.name: SqliteStorageAddTest002
186  * @tc.desc: Add function test failed
187  * @tc.type: FUNC
188  * @tc.require:
189  */
190 HWTEST_F(DatabaseTest, SqliteStorageAddTest002, TestSize.Level1)
191 {
192     ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageAddTest002 begin");
193 
194     RemoveTestTokenHapInfo();
195 
196     GenericValues genericValues;
197     genericValues.Put(TokenFiledConst::FIELD_TOKEN_ID, TEST_TOKEN_ID);
198 
199     std::vector<GenericValues> values;
200     values.emplace_back(genericValues);
201     EXPECT_EQ(AccessTokenError::ERR_DATABASE_OPERATE_FAILED,
202         AccessTokenDb::GetInstance().Add(AtmDataType::ACCESSTOKEN_HAP_INFO, values));
203     ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageAddTest002 end");
204 }
205 
206 /*
207  * @tc.name: SqliteStorageModifyTest001
208  * @tc.desc: Modify function test
209  * @tc.type: FUNC
210  * @tc.require:
211  */
212 HWTEST_F(DatabaseTest, SqliteStorageModifyTest001, TestSize.Level1)
213 {
214     ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageModifyTest001 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(0, AccessTokenDb::GetInstance().Add(AtmDataType::ACCESSTOKEN_HAP_INFO, values));
235 
236     GenericValues modifyValues;
237     modifyValues.Put(TokenFiledConst::FIELD_BUNDLE_NAME, "test_bundle_name_modified");
238 
239     GenericValues conditions;
240     conditions.Put(TokenFiledConst::FIELD_TOKEN_ID, TEST_TOKEN_ID);
241     conditions.Put(TokenFiledConst::FIELD_USER_ID, 100);
242 
243     ASSERT_EQ(0, AccessTokenDb::GetInstance().Modify(AtmDataType::ACCESSTOKEN_HAP_INFO, modifyValues, conditions));
244 
245     bool modifySuccess = false;
246     GenericValues conditionValue;
247     std::vector<GenericValues> hapInfoResults;
248     AccessTokenDb::GetInstance().Find(AtmDataType::ACCESSTOKEN_HAP_INFO, conditionValue, hapInfoResults);
249     for (GenericValues hapInfoValue : hapInfoResults) {
250         AccessTokenID tokenId = (AccessTokenID)hapInfoValue.GetInt(TokenFiledConst::FIELD_TOKEN_ID);
251         if (tokenId == TEST_TOKEN_ID) {
252             ASSERT_EQ("test_bundle_name_modified", hapInfoValue.GetString(TokenFiledConst::FIELD_BUNDLE_NAME));
253             modifySuccess = true;
254             break;
255         }
256     }
257     EXPECT_TRUE(modifySuccess);
258     ACCESSTOKEN_LOG_INFO(LABEL, "SqliteStorageModifyTest001 end");
259 }
260 
261 /*
262  * @tc.name: DataTranslatorTranslationIntoPermissionDef001
263  * @tc.desc: TranslationIntoPermissionDef function test
264  * @tc.type: FUNC
265  * @tc.require:
266  */
267 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionDef001, TestSize.Level1)
268 {
269     ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionDefTest001 begin");
270 
271     RemoveTestTokenHapInfo();
272 
273     GenericValues genericValues;
274     genericValues.Put(TokenFiledConst::FIELD_TOKEN_ID, TEST_TOKEN_ID);
275     genericValues.Put(TokenFiledConst::FIELD_AVAILABLE_LEVEL, ATokenAplEnum::APL_INVALID);
276 
277     PermissionDef outPermissionDef;
278     ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionDef(genericValues, outPermissionDef));
279     ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionDefTest001 end");
280 }
281 
282 /*
283  * @tc.name: DataTranslatorTranslationIntoGenericValues001
284  * @tc.desc: DataTranslatorTranslationIntoGenericValues function test
285  * @tc.type: FUNC
286  * @tc.require:
287  */
288 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoGenericValues001, TestSize.Level1)
289 {
290     ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoGenericValues001 begin");
291     PermissionStateFull grantPermissionReq = {
292         .permissionName = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS",
293         .isGeneral = true,
294         .resDeviceID = {"device1"},
295         .grantStatus = {PermissionState::PERMISSION_GRANTED},
296         .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}
297     };
298     int grantIndex = 1;
299     GenericValues genericValues;
300     ASSERT_NE(RET_SUCCESS,
301         DataTranslator::TranslationIntoGenericValues(grantPermissionReq, grantIndex, genericValues));
302     ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoGenericValues001 end");
303 }
304 
305 /*
306  * @tc.name: DataTranslatorTranslationIntoGenericValues002
307  * @tc.desc: DataTranslatorTranslationIntoGenericValues function test
308  * @tc.type: FUNC
309  * @tc.require:
310  */
311 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoGenericValues002, TestSize.Level1)
312 {
313     ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoGenericValues002 begin");
314     PermissionStateFull grantPermissionReq = {
315         .permissionName = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS",
316         .isGeneral = true,
317         .resDeviceID = {"device1", "device2"},
318         .grantStatus = {PermissionState::PERMISSION_GRANTED},
319         .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}
320     };
321     int grantIndex = 1;
322     GenericValues genericValues;
323     ASSERT_NE(RET_SUCCESS,
324         DataTranslator::TranslationIntoGenericValues(grantPermissionReq, grantIndex, genericValues));
325     ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoGenericValues002 end");
326 }
327 
328 /*
329  * @tc.name: DataTranslatorTranslationIntoGenericValues003
330  * @tc.desc: DataTranslatorTranslationIntoGenericValues function test
331  * @tc.type: FUNC
332  * @tc.require:
333  */
334 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoGenericValues003, TestSize.Level1)
335 {
336     ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoGenericValues003 begin");
337     PermissionStateFull grantPermissionReq = {
338         .permissionName = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS",
339         .isGeneral = true,
340         .resDeviceID = {"device1", "device2"},
341         .grantStatus = {PermissionState::PERMISSION_GRANTED, PermissionState::PERMISSION_GRANTED},
342         .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}
343     };
344     int grantIndex = 1;
345     GenericValues genericValues;
346     ASSERT_NE(RET_SUCCESS,
347         DataTranslator::TranslationIntoGenericValues(grantPermissionReq, grantIndex, genericValues));
348     ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoGenericValues003 end");
349 }
350 
351 /*
352  * @tc.name: DataTranslatorTranslationIntoPermissionStateFull001
353  * @tc.desc: TranslationIntoPermissionStateFull function test
354  * @tc.type: FUNC
355  * @tc.require:
356  */
357 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionStateFull001, TestSize.Level1)
358 {
359     ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionStateFullTest001 begin");
360 
361     PermissionStateFull outPermissionState;
362 
363     GenericValues inGenericValues;
364     inGenericValues.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, 1);
365     inGenericValues.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "");
366 
367     PermissionDef outPermissionDef;
368     ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionStateFull(inGenericValues, outPermissionState));
369     ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionStateFullTest001 end");
370 }
371 
372 /*
373  * @tc.name: DataTranslatorTranslationIntoPermissionStateFull002
374  * @tc.desc: TranslationIntoPermissionStateFull function test
375  * @tc.type: FUNC
376  * @tc.require:
377  */
378 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionStateFull002, TestSize.Level1)
379 {
380     ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionStateFullTest002 begin");
381 
382     PermissionStateFull outPermissionState;
383 
384     GenericValues inGenericValues;
385     inGenericValues.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, 1);
386     inGenericValues.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "test_permission_name");
387     inGenericValues.Put(TokenFiledConst::FIELD_DEVICE_ID, "");
388 
389     PermissionDef outPermissionDef;
390     ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionStateFull(inGenericValues, outPermissionState));
391     ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionStateFullTest002 end");
392 }
393 
394 /*
395  * @tc.name: DataTranslatorTranslationIntoPermissionStateFull003
396  * @tc.desc: TranslationIntoPermissionStateFull function test
397  * @tc.type: FUNC
398  * @tc.require:
399  */
400 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionStateFull003, TestSize.Level1)
401 {
402     ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionStateFullTest003 begin");
403 
404     PermissionStateFull outPermissionState;
405 
406     GenericValues inGenericValues;
407     inGenericValues.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, 1);
408     inGenericValues.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "test_permission_name");
409     inGenericValues.Put(TokenFiledConst::FIELD_DEVICE_ID, "test_device_id");
410     inGenericValues.Put(TokenFiledConst::FIELD_GRANT_STATE, 100);
411 
412     PermissionDef outPermissionDef;
413     ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionStateFull(inGenericValues, outPermissionState));
414     ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionStateFullTest003 end");
415 }
416 
417 /*
418  * @tc.name: DataTranslatorTranslationIntoPermissionStateFull004
419  * @tc.desc: TranslationIntoPermissionStateFull function test
420  * @tc.type: FUNC
421  * @tc.require:
422  */
423 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionStateFull004, TestSize.Level1)
424 {
425     ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionStateFullTest004 begin");
426 
427     PermissionStateFull outPermissionState;
428 
429     GenericValues inGenericValues;
430     inGenericValues.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, 1);
431     inGenericValues.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "test_permission_name");
432     inGenericValues.Put(TokenFiledConst::FIELD_DEVICE_ID, "test_device_id");
433     inGenericValues.Put(TokenFiledConst::FIELD_GRANT_STATE, PermissionState::PERMISSION_GRANTED);
434     inGenericValues.Put(TokenFiledConst::FIELD_GRANT_FLAG, 100);
435 
436     PermissionDef outPermissionDef;
437     ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionStateFull(inGenericValues, outPermissionState));
438     ACCESSTOKEN_LOG_INFO(LABEL, "DataTranslatorTranslationIntoPermissionStateFullTest004 end");
439 }
440 } // namespace AccessToken
441 } // namespace Security
442 } // namespace OHOS
443