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.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: 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.Level1)
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.Level1)
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.Level1)
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.Level1)
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 std::vector<AtmDataType> deleteDataTypes;
142 std::vector<GenericValues> deleteValues;
143 deleteDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_INFO);
144 deleteValues.emplace_back(condition);
145
146 std::vector<AtmDataType> addDataTypes;
147 std::vector<std::vector<GenericValues>> addValues;
148 AccessTokenDb::GetInstance().DeleteAndInsertValues(deleteDataTypes, deleteValues, addDataTypes, addValues);
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.Level1)
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
177 std::vector<AtmDataType> deleteDataTypes;
178 std::vector<GenericValues> deleteValues;
179
180 std::vector<AtmDataType> addDataTypes;
181 std::vector<std::vector<GenericValues>> addValues;
182 std::vector<GenericValues> value;
183 addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_INFO);
184 value.emplace_back(genericValues);
185 addValues.emplace_back(value);
186 EXPECT_EQ(0,
187 AccessTokenDb::GetInstance().DeleteAndInsertValues(deleteDataTypes, deleteValues, addDataTypes, addValues));
188
189 GenericValues modifyValues;
190 modifyValues.Put(TokenFiledConst::FIELD_BUNDLE_NAME, "test_bundle_name_modified");
191
192 GenericValues conditions;
193 conditions.Put(TokenFiledConst::FIELD_TOKEN_ID, TEST_TOKEN_ID);
194 conditions.Put(TokenFiledConst::FIELD_USER_ID, 100);
195
196 ASSERT_EQ(0, AccessTokenDb::GetInstance().Modify(AtmDataType::ACCESSTOKEN_HAP_INFO, modifyValues, conditions));
197
198 bool modifySuccess = false;
199 GenericValues conditionValue;
200 std::vector<GenericValues> hapInfoResults;
201 AccessTokenDb::GetInstance().Find(AtmDataType::ACCESSTOKEN_HAP_INFO, conditionValue, hapInfoResults);
202 for (GenericValues hapInfoValue : hapInfoResults) {
203 AccessTokenID tokenId = (AccessTokenID)hapInfoValue.GetInt(TokenFiledConst::FIELD_TOKEN_ID);
204 if (tokenId == TEST_TOKEN_ID) {
205 ASSERT_EQ("test_bundle_name_modified", hapInfoValue.GetString(TokenFiledConst::FIELD_BUNDLE_NAME));
206 modifySuccess = true;
207 break;
208 }
209 }
210 EXPECT_TRUE(modifySuccess);
211 LOGI(ATM_DOMAIN, ATM_TAG, "SqliteStorageModifyTest001 end");
212 }
213
214 /*
215 * @tc.name: DataTranslatorTranslationIntoPermissionDef001
216 * @tc.desc: TranslationIntoPermissionDef function test
217 * @tc.type: FUNC
218 * @tc.require:
219 */
220 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionDef001, TestSize.Level1)
221 {
222 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionDefTest001 begin");
223
224 RemoveTestTokenHapInfo();
225
226 GenericValues genericValues;
227 genericValues.Put(TokenFiledConst::FIELD_TOKEN_ID, TEST_TOKEN_ID);
228 genericValues.Put(TokenFiledConst::FIELD_AVAILABLE_LEVEL, ATokenAplEnum::APL_INVALID);
229
230 PermissionDef outPermissionDef;
231 ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionDef(genericValues, outPermissionDef));
232 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionDefTest001 end");
233 }
234
235 /*
236 * @tc.name: DataTranslatorTranslationIntoPermissionStatus001
237 * @tc.desc: TranslationIntoPermissionStatus function test
238 * @tc.type: FUNC
239 * @tc.require:
240 */
241 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionStatus001, TestSize.Level1)
242 {
243 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionStatus001 begin");
244
245 PermissionStatus outPermissionState;
246
247 GenericValues inGenericValues;
248 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, 1);
249 inGenericValues.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "");
250
251 PermissionDef outPermissionDef;
252 ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionStatus(inGenericValues, outPermissionState));
253 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionStatus001 end");
254 }
255
256 /*
257 * @tc.name: DataTranslatorTranslationIntoPermissionStatus002
258 * @tc.desc: TranslationIntoPermissionStatus function test
259 * @tc.type: FUNC
260 * @tc.require:
261 */
262 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionStatus002, TestSize.Level1)
263 {
264 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionStatus002 begin");
265
266 PermissionStatus outPermissionState;
267
268 GenericValues inGenericValues;
269 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, 1);
270 inGenericValues.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "test_permission_name");
271 inGenericValues.Put(TokenFiledConst::FIELD_DEVICE_ID, "");
272
273 PermissionDef outPermissionDef;
274 ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionStatus(inGenericValues, outPermissionState));
275 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionStatus002 end");
276 }
277
278 /*
279 * @tc.name: DataTranslatorTranslationIntoPermissionStatus003
280 * @tc.desc: TranslationIntoPermissionStatus function test
281 * @tc.type: FUNC
282 * @tc.require:
283 */
284 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionStatus003, TestSize.Level1)
285 {
286 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionStatus003 begin");
287
288 PermissionStatus outPermissionState;
289
290 GenericValues inGenericValues;
291 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, 1);
292 inGenericValues.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "test_permission_name");
293 inGenericValues.Put(TokenFiledConst::FIELD_DEVICE_ID, "test_device_id");
294 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_STATE, 100);
295
296 PermissionDef outPermissionDef;
297 ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionStatus(inGenericValues, outPermissionState));
298 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionStatus003 end");
299 }
300
301 /*
302 * @tc.name: DataTranslatorTranslationIntoPermissionStatus004
303 * @tc.desc: TranslationIntoPermissionStatus function test
304 * @tc.type: FUNC
305 * @tc.require:
306 */
307 HWTEST_F(DatabaseTest, DataTranslatorTranslationIntoPermissionStatus004, TestSize.Level1)
308 {
309 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionStatus004 begin");
310
311 PermissionStatus outPermissionState;
312
313 GenericValues inGenericValues;
314 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, 1);
315 inGenericValues.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "test_permission_name");
316 inGenericValues.Put(TokenFiledConst::FIELD_DEVICE_ID, "test_device_id");
317 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_STATE, PermissionState::PERMISSION_GRANTED);
318 inGenericValues.Put(TokenFiledConst::FIELD_GRANT_FLAG, 100);
319
320 PermissionDef outPermissionDef;
321 ASSERT_NE(RET_SUCCESS, DataTranslator::TranslationIntoPermissionStatus(inGenericValues, outPermissionState));
322 LOGI(ATM_DOMAIN, ATM_TAG, "DataTranslatorTranslationIntoPermissionStatus004 end");
323 }
324 } // namespace AccessToken
325 } // namespace Security
326 } // namespace OHOS
327