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_common_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 int32_t GET_INT64_TRUE_VALUE = -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.Level0)
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: PutVariant001
76 * @tc.desc: Verify the GenericValues put and get variant value function.
77 * @tc.type: FUNC
78 * @tc.require: Issue Number
79 */
80 HWTEST_F(DatabaseTest, PutVariant001, TestSize.Level0)
81 {
82 GenericValues genericValues;
83 std::string key = "databasetest";
84 int64_t testValue = 1;
85 VariantValue Test(testValue);
86 genericValues.Put(key, Test);
87 VariantValue outdata = genericValues.Get(key);
88 EXPECT_EQ(outdata.GetInt64(), testValue);
89 outdata = genericValues.Get("key");
90 EXPECT_EQ(DEFAULT_VALUE, outdata.GetInt64());
91 genericValues.Remove(key);
92 genericValues.Remove("key");
93 }
94
95 /**
96 * @tc.name: VariantValue64001
97 * @tc.desc: VariantValue64001 use VariantValue
98 * @tc.type: FUNC
99 * @tc.require: Issue Number
100 */
101 HWTEST_F(DatabaseTest, VariantValue64001, TestSize.Level0)
102 {
103 int64_t testValue = 1;
104 VariantValue Test(testValue);
105 EXPECT_EQ(Test.GetInt64(), testValue);
106 }
107
108 /**
109 * @tc.name: VariantValue64002
110 * @tc.desc: VariantValue64002 getint and getint64 Abnormal branch
111 * @tc.type: FUNC
112 * @tc.require: Issue Number
113 */
114 HWTEST_F(DatabaseTest, VariantValue64002, TestSize.Level0)
115 {
116 int32_t ntestValue = 1;
117 VariantValue Ntest(ntestValue);
118 EXPECT_EQ(DEFAULT_VALUE, Ntest.GetInt64());
119 int64_t testValue = 1;
120 VariantValue Test(testValue);
121 EXPECT_EQ(DEFAULT_VALUE, Test.GetInt());
122 }
123
124 /**
125 * @tc.name: VariantValue001
126 * @tc.desc: VariantValue001 getstring
127 * @tc.type: FUNC
128 * @tc.require:
129 */
130 HWTEST_F(DatabaseTest, VariantValue001, TestSize.Level0)
131 {
132 VariantValue Test;
133 Test.GetString();
134 EXPECT_EQ(ValueType::TYPE_NULL, Test.GetType());
135 }
136
RemoveTestTokenHapInfo()137 static void RemoveTestTokenHapInfo()
138 {
139 GenericValues condition;
140 condition.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(TEST_TOKEN_ID));
141 DelInfo delInfo;
142 delInfo.delType = AtmDataType::ACCESSTOKEN_HAP_INFO;
143 delInfo.delValue = condition;
144
145 std::vector<DelInfo> delInfoVec;
146 delInfoVec.emplace_back(delInfo);
147 std::vector<AddInfo> addInfoVec;
148 AccessTokenDb::GetInstance()->DeleteAndInsertValues(delInfoVec, addInfoVec);
149 }
150
151 /*
152 * @tc.name: SqliteStorageModifyTest001
153 * @tc.desc: Modify function test
154 * @tc.type: FUNC
155 * @tc.require:
156 */
157 HWTEST_F(DatabaseTest, SqliteStorageModifyTest001, TestSize.Level0)
158 {
159 LOGI(ATM_DOMAIN, ATM_TAG, "SqliteStorageModifyTest001 begin");
160
161 RemoveTestTokenHapInfo();
162
163 GenericValues genericValues;
164 genericValues.Put(TokenFiledConst::FIELD_TOKEN_ID, TEST_TOKEN_ID);
165 genericValues.Put(TokenFiledConst::FIELD_USER_ID, 100);
166 genericValues.Put(TokenFiledConst::FIELD_BUNDLE_NAME, "test_bundle_name");
167 genericValues.Put(TokenFiledConst::FIELD_API_VERSION, 9);
168 genericValues.Put(TokenFiledConst::FIELD_INST_INDEX, 0);
169 genericValues.Put(TokenFiledConst::FIELD_DLP_TYPE, 0);
170 genericValues.Put(TokenFiledConst::FIELD_APP_ID, "test_app_id");
171 genericValues.Put(TokenFiledConst::FIELD_DEVICE_ID, "test_device_id");
172 genericValues.Put(TokenFiledConst::FIELD_APL, ATokenAplEnum::APL_NORMAL);
173 genericValues.Put(TokenFiledConst::FIELD_TOKEN_VERSION, 0);
174 genericValues.Put(TokenFiledConst::FIELD_TOKEN_ATTR, 0);
175 genericValues.Put(TokenFiledConst::FIELD_FORBID_PERM_DIALOG, "test_perm_dialog_cap_state");
176 AddInfo addInfo;
177 addInfo.addType = AtmDataType::ACCESSTOKEN_HAP_INFO;
178 addInfo.addValues.emplace_back(genericValues);
179
180 std::vector<DelInfo> delInfoVec;
181 std::vector<AddInfo> addInfoVec;
182 addInfoVec.emplace_back(addInfo);
183 EXPECT_EQ(0, AccessTokenDb::GetInstance()->DeleteAndInsertValues(delInfoVec, addInfoVec));
184
185 GenericValues modifyValues;
186 modifyValues.Put(TokenFiledConst::FIELD_BUNDLE_NAME, "test_bundle_name_modified");
187
188 GenericValues conditions;
189 conditions.Put(TokenFiledConst::FIELD_TOKEN_ID, TEST_TOKEN_ID);
190 conditions.Put(TokenFiledConst::FIELD_USER_ID, 100);
191
192 ASSERT_EQ(0, AccessTokenDb::GetInstance()->Modify(AtmDataType::ACCESSTOKEN_HAP_INFO, modifyValues, conditions));
193
194 bool modifySuccess = false;
195 GenericValues conditionValue;
196 std::vector<GenericValues> hapInfoResults;
197 AccessTokenDb::GetInstance()->Find(AtmDataType::ACCESSTOKEN_HAP_INFO, conditionValue, hapInfoResults);
198 for (GenericValues hapInfoValue : hapInfoResults) {
199 AccessTokenID tokenId = (AccessTokenID)hapInfoValue.GetInt(TokenFiledConst::FIELD_TOKEN_ID);
200 if (tokenId == TEST_TOKEN_ID) {
201 ASSERT_EQ("test_bundle_name_modified", hapInfoValue.GetString(TokenFiledConst::FIELD_BUNDLE_NAME));
202 modifySuccess = true;
203 break;
204 }
205 }
206 EXPECT_TRUE(modifySuccess);
207 LOGI(ATM_DOMAIN, ATM_TAG, "SqliteStorageModifyTest001 end");
208 }
209
210 /*
211 * @tc.name: DataTranslatorTranslationIntoPermissionDef001
212 * @tc.desc: TranslationIntoPermissionDef function test
213 * @tc.type: FUNC
214 * @tc.require:
215 */
216 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionDef001, TestSize.Level0)
217 {
218 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionDefTest001 begin");
219
220 RemoveTestTokenHapInfo();
221
222 GenericValues genericValues;
223 genericValues.Put(TokenFiledConst::FIELD_TOKEN_ID, TEST_TOKEN_ID);
224 genericValues.Put(TokenFiledConst::FIELD_AVAILABLE_LEVEL, ATokenAplEnum::APL_INVALID);
225
226 PermissionDef outPermissionDef;
227 ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionDef(genericValues, outPermissionDef));
228 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionDefTest001 end");
229 }
230
231 /*
232 * @tc.name: DataTranslatorTranslationIntoPermissionStatus001
233 * @tc.desc: TranslationIntoPermissionStatus function test
234 * @tc.type: FUNC
235 * @tc.require:
236 */
237 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionStatus001, TestSize.Level0)
238 {
239 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionStatus001 begin");
240
241 PermissionStatus outPermissionState;
242
243 GenericValues inGenericValues;
244 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, 1);
245 inGenericValues.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "");
246
247 PermissionDef outPermissionDef;
248 ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionStatus(inGenericValues, outPermissionState));
249 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionStatus001 end");
250 }
251
252 /*
253 * @tc.name: DataTranslatorTranslationIntoPermissionStatus002
254 * @tc.desc: TranslationIntoPermissionStatus function test
255 * @tc.type: FUNC
256 * @tc.require:
257 */
258 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionStatus002, TestSize.Level0)
259 {
260 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionStatus002 begin");
261
262 PermissionStatus outPermissionState;
263
264 GenericValues inGenericValues;
265 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, 1);
266 inGenericValues.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "test_permission_name");
267 inGenericValues.Put(TokenFiledConst::FIELD_DEVICE_ID, "");
268
269 PermissionDef outPermissionDef;
270 ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionStatus(inGenericValues, outPermissionState));
271 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionStatus002 end");
272 }
273
274 /*
275 * @tc.name: DataTranslatorTranslationIntoPermissionStatus003
276 * @tc.desc: TranslationIntoPermissionStatus function test
277 * @tc.type: FUNC
278 * @tc.require:
279 */
280 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionStatus003, TestSize.Level0)
281 {
282 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionStatus003 begin");
283
284 PermissionStatus outPermissionState;
285
286 GenericValues inGenericValues;
287 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, 1);
288 inGenericValues.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "test_permission_name");
289 inGenericValues.Put(TokenFiledConst::FIELD_DEVICE_ID, "test_device_id");
290 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_STATE, 100);
291
292 PermissionDef outPermissionDef;
293 ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionStatus(inGenericValues, outPermissionState));
294 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionStatus003 end");
295 }
296
297 /*
298 * @tc.name: DataTranslatorTranslationIntoPermissionStatus004
299 * @tc.desc: TranslationIntoPermissionStatus function test
300 * @tc.type: FUNC
301 * @tc.require:
302 */
303 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionStatus004, TestSize.Level0)
304 {
305 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionStatus004 begin");
306
307 PermissionStatus outPermissionState;
308
309 GenericValues inGenericValues;
310 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, 1);
311 inGenericValues.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "test_permission_name");
312 inGenericValues.Put(TokenFiledConst::FIELD_DEVICE_ID, "test_device_id");
313 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_STATE, PermissionState::PERMISSION_GRANTED);
314 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_FLAG, 100);
315
316 PermissionDef outPermissionDef;
317 ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionStatus(inGenericValues, outPermissionState));
318 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionStatus004 end");
319 }
320 } // namespace AccessToken
321 } // namespace Security
322 } // namespace OHOS
323