1 /*
2 * Copyright (c) 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
18 #include "access_token_error.h"
19 #include "access_token.h"
20 #define private public
21 #include "access_token_db.h"
22 #include "access_token_open_callback.h"
23 #undef private
24 #include "data_translator.h"
25 #include "token_field_const.h"
26
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace Security {
31 namespace AccessToken {
32 namespace {
33 static constexpr uint32_t NOT_EXSIT_ATM_TYPE = 9;
34 static constexpr uint32_t UPDATE_FLAG_1 = 1;
35 static constexpr uint32_t UPDATE_FLAG_2 = 2;
36 static constexpr uint32_t UPDATE_FLAG_3 = 3;
37 static constexpr uint32_t UPDATE_FLAG_4 = 4;
38 static constexpr uint32_t UPDATE_FLAG_6 = 6;
39 static constexpr uint32_t UPDATE_FLAG_7 = 7;
40 static constexpr uint32_t UPDATE_FLAG_8 = 8;
41 static constexpr uint32_t UPDATE_FLAG_12 = 12;
42 static constexpr uint32_t UPDATE_FLAG_14 = 14;
43 static constexpr uint32_t UPDATE_FLAG_15 = 15;
44 }
45 class AccessTokenDatabaseCoverageTest : public testing::Test {
46 public:
47 static void SetUpTestCase();
48
49 static void TearDownTestCase();
50
51 void SetUp();
52
53 void TearDown();
54 };
55
SetUpTestCase()56 void AccessTokenDatabaseCoverageTest::SetUpTestCase() {}
57
TearDownTestCase()58 void AccessTokenDatabaseCoverageTest::TearDownTestCase() {}
59
SetUp()60 void AccessTokenDatabaseCoverageTest::SetUp() {}
61
TearDown()62 void AccessTokenDatabaseCoverageTest::TearDown() {}
63
64 /*
65 * @tc.name: ToRdbValueBuckets001
66 * @tc.desc: AccessTokenDbUtil::ToRdbValueBuckets
67 * @tc.type: FUNC
68 * @tc.require:
69 */
70 HWTEST_F(AccessTokenDatabaseCoverageTest, ToRdbValueBuckets001, TestSize.Level1)
71 {
72 std::vector<GenericValues> values;
73 GenericValues value;
74 values.emplace_back(value);
75 std::vector<NativeRdb::ValuesBucket> buckets;
76 AccessTokenDbUtil::ToRdbValueBuckets(values, buckets);
77 ASSERT_EQ(true, buckets.empty());
78 }
79
80 /*
81 * @tc.name: TranslationIntoPermissionStatus001
82 * @tc.desc: DataTranslator::TranslationIntoPermissionStatus
83 * @tc.type: FUNC
84 * @tc.require:
85 */
86 HWTEST_F(AccessTokenDatabaseCoverageTest, TranslationIntoPermissionStatus001, TestSize.Level1)
87 {
88 GenericValues value;
89 value.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, 1);
90 value.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "ohos.permission.READ_MEDIA");
91 value.Put(TokenFiledConst::FIELD_DEVICE_ID, "local");
92 value.Put(TokenFiledConst::FIELD_GRANT_FLAG, static_cast<int32_t>(PermissionFlag::PERMISSION_ALLOW_THIS_TIME));
93 value.Put(TokenFiledConst::FIELD_GRANT_STATE, static_cast<int32_t>(PermissionState::PERMISSION_GRANTED));
94 ASSERT_EQ(static_cast<int32_t>(PermissionState::PERMISSION_GRANTED),
95 value.GetInt(TokenFiledConst::FIELD_GRANT_STATE));
96
97 PermissionStatus permissionState;
98 DataTranslator::TranslationIntoPermissionStatus(value, permissionState);
99 ASSERT_EQ(static_cast<int32_t>(PermissionState::PERMISSION_DENIED), permissionState.grantStatus);
100 }
101
102 /*
103 * @tc.name: OnUpgrade001
104 * @tc.desc: AccessTokenOpenCallback::OnUpgrade
105 * @tc.type: FUNC
106 * @tc.require:
107 */
108 HWTEST_F(AccessTokenDatabaseCoverageTest, OnUpgrade001, TestSize.Level1)
109 {
110 AccessTokenOpenCallback callback;
111 uint32_t flag = 0;
112 callback.GetUpgradeFlag(DATABASE_VERSION_1, DATABASE_VERSION_2, flag);
113 ASSERT_EQ(UPDATE_FLAG_1, flag);
114
115 flag = 0;
116 callback.GetUpgradeFlag(DATABASE_VERSION_1, DATABASE_VERSION_3, flag);
117 ASSERT_EQ(UPDATE_FLAG_3, flag);
118
119 flag = 0;
120 callback.GetUpgradeFlag(DATABASE_VERSION_1, DATABASE_VERSION_4, flag);
121 ASSERT_EQ(UPDATE_FLAG_7, flag);
122
123 flag = 0;
124 callback.GetUpgradeFlag(DATABASE_VERSION_1, DATABASE_VERSION_5, flag);
125 ASSERT_EQ(UPDATE_FLAG_15, flag);
126
127 flag = 0;
128 callback.GetUpgradeFlag(DATABASE_VERSION_2, DATABASE_VERSION_3, flag);
129 ASSERT_EQ(UPDATE_FLAG_2, flag);
130
131 flag = 0;
132 callback.GetUpgradeFlag(DATABASE_VERSION_2, DATABASE_VERSION_4, flag);
133 ASSERT_EQ(UPDATE_FLAG_6, flag);
134
135 flag = 0;
136 callback.GetUpgradeFlag(DATABASE_VERSION_2, DATABASE_VERSION_5, flag);
137 ASSERT_EQ(UPDATE_FLAG_14, flag);
138
139 flag = 0;
140 callback.GetUpgradeFlag(DATABASE_VERSION_3, DATABASE_VERSION_4, flag);
141 ASSERT_EQ(UPDATE_FLAG_4, flag);
142
143 flag = 0;
144 callback.GetUpgradeFlag(DATABASE_VERSION_3, DATABASE_VERSION_5, flag);
145 ASSERT_EQ(UPDATE_FLAG_12, flag);
146
147 flag = 0;
148 callback.GetUpgradeFlag(DATABASE_VERSION_4, DATABASE_VERSION_5, flag);
149 ASSERT_EQ(UPDATE_FLAG_8, flag);
150 }
151
152 /*
153 * @tc.name: Modify001
154 * @tc.desc: AccessTokenDb::Modify
155 * @tc.type: FUNC
156 * @tc.require:
157 */
158 HWTEST_F(AccessTokenDatabaseCoverageTest, Modify001, TestSize.Level1)
159 {
160 AtmDataType type = static_cast<AtmDataType>(NOT_EXSIT_ATM_TYPE);
161 GenericValues modifyValue;
162 GenericValues conditionValue;
163 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID,
164 AccessTokenDb::GetInstance().Modify(type, modifyValue, conditionValue));
165
166 type = AtmDataType::ACCESSTOKEN_HAP_INFO;
167 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID,
168 AccessTokenDb::GetInstance().Modify(type, modifyValue, conditionValue));
169
170 modifyValue.Put(TokenFiledConst::FIELD_PROCESS_NAME, "hdcd");
171 ASSERT_EQ(NativeRdb::E_SQLITE_ERROR, AccessTokenDb::GetInstance().Modify(type, modifyValue, conditionValue));
172
173 conditionValue.Put(TokenFiledConst::FIELD_PROCESS_NAME, "hdcd");
174 ASSERT_NE(NativeRdb::E_OK, AccessTokenDb::GetInstance().Modify(type, modifyValue, conditionValue));
175
176 int32_t resultCode = NativeRdb::E_SQLITE_ERROR;
177 int32_t changedRows = 0;
178 NativeRdb::ValuesBucket bucket;
179 AccessTokenDbUtil::ToRdbValueBucket(modifyValue, bucket);
180 NativeRdb::RdbPredicates predicates("hap_token_info_table");
181 AccessTokenDbUtil::ToRdbPredicates(conditionValue, predicates);
182 std::shared_ptr<NativeRdb::RdbStore> db = AccessTokenDb::GetInstance().GetRdb();
183 ASSERT_EQ(NativeRdb::E_SQLITE_ERROR,
184 AccessTokenDb::GetInstance().RestoreAndUpdateIfCorrupt(resultCode, changedRows, bucket, predicates, db));
185
186 resultCode = NativeRdb::E_SQLITE_CORRUPT;
187 ASSERT_NE(NativeRdb::E_OK,
188 AccessTokenDb::GetInstance().RestoreAndUpdateIfCorrupt(resultCode, changedRows, bucket, predicates, db));
189 }
190
191 /*
192 * @tc.name: Find001
193 * @tc.desc: AccessTokenDb::Find
194 * @tc.type: FUNC
195 * @tc.require:
196 */
197 HWTEST_F(AccessTokenDatabaseCoverageTest, Find001, TestSize.Level1)
198 {
199 AtmDataType type = static_cast<AtmDataType>(NOT_EXSIT_ATM_TYPE);
200 GenericValues conditionValue;
201 std::vector<GenericValues> results;
202 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID,
203 AccessTokenDb::GetInstance().Find(type, conditionValue, results));
204
205 type = AtmDataType::ACCESSTOKEN_HAP_INFO;
206 ASSERT_EQ(NativeRdb::E_OK, AccessTokenDb::GetInstance().Find(type, conditionValue, results));
207
208 conditionValue.Put(TokenFiledConst::FIELD_PROCESS_NAME, "hdcd");
209 ASSERT_EQ(AccessTokenError::ERR_DATABASE_OPERATE_FAILED,
210 AccessTokenDb::GetInstance().Find(type, conditionValue, results));
211 }
212 } // namespace AccessToken
213 } // namespace Security
214 } // namespace OHOS
215