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 "constant.h"
18 #include "data_translator.h"
19 #include "active_change_response_info.h"
20 #include "privacy_field_const.h"
21 #define private public
22 #include "permission_used_record_db.h"
23 #undef private
24 #include "permission_used_type.h"
25 
26 using namespace testing::ext;
27 
28 namespace OHOS {
29 namespace Security {
30 namespace AccessToken {
31 namespace {
32 static const int32_t NOT_EXSIT_TYPE = 9;
33 static const int32_t PERMISSION_USED_TYPE_VALUE = 1;
34 static const int32_t PICKER_TYPE_VALUE = 2;
35 static const int32_t RANDOM_TOKENID = 123;
36 }
37 
38 class PermissionRecordDBTest : public testing::Test {
39 public:
40     static void SetUpTestCase();
41     static void TearDownTestCase();
42     void SetUp();
43     void TearDown();
44 };
45 
SetUpTestCase()46 void PermissionRecordDBTest::SetUpTestCase()
47 {
48 }
49 
TearDownTestCase()50 void PermissionRecordDBTest::TearDownTestCase()
51 {
52 }
53 
SetUp()54 void PermissionRecordDBTest::SetUp()
55 {
56 }
57 
TearDown()58 void PermissionRecordDBTest::TearDown()
59 {
60 }
61 
62 /*
63  * @tc.name: CreateInsertPrepareSqlCmd001
64  * @tc.desc: PermissionUsedRecordDb::CreateInsertPrepareSqlCmd function test type not found
65  * @tc.type: FUNC
66  * @tc.require: issueI5YL6H
67  */
68 HWTEST_F(PermissionRecordDBTest, CreateInsertPrepareSqlCmd001, TestSize.Level1)
69 {
70     PermissionUsedRecordDb::DataType type = static_cast<PermissionUsedRecordDb::DataType>(100);
71     ASSERT_EQ("", PermissionUsedRecordDb::GetInstance().CreateInsertPrepareSqlCmd(type));
72 }
73 
74 /*
75  * @tc.name: CreateInsertPrepareSqlCmd002
76  * @tc.desc: PermissionUsedRecordDb::CreateInsertPrepareSqlCmd function test
77  * @tc.type: FUNC
78  * @tc.require: issueI5YL6H
79  */
80 HWTEST_F(PermissionRecordDBTest, CreateInsertPrepareSqlCmd002, TestSize.Level1)
81 {
82     PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
83     ASSERT_NE("", PermissionUsedRecordDb::GetInstance().CreateInsertPrepareSqlCmd(type));
84 }
85 
86 /*
87  * @tc.name: CreateDeletePrepareSqlCmd001
88  * @tc.desc: PermissionUsedRecordDb::CreateDeletePrepareSqlCmd function test type not found
89  * @tc.type: FUNC
90  * @tc.require: issueI5YL6H
91  */
92 HWTEST_F(PermissionRecordDBTest, CreateDeletePrepareSqlCmd001, TestSize.Level1)
93 {
94     PermissionUsedRecordDb::DataType type = static_cast<PermissionUsedRecordDb::DataType>(100);
95     std::vector<std::string> columnNames;
96     ASSERT_EQ("", PermissionUsedRecordDb::GetInstance().CreateDeletePrepareSqlCmd(type, columnNames));
97 }
98 
99 /*
100  * @tc.name: CreateUpdatePrepareSqlCmd001
101  * @tc.desc: PermissionUsedRecordDb::CreateUpdatePrepareSqlCmd function test modifyColumns empty
102  * @tc.type: FUNC
103  * @tc.require: issueI5YL6H
104  */
105 HWTEST_F(PermissionRecordDBTest, CreateUpdatePrepareSqlCmd001, TestSize.Level1)
106 {
107     PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
108     std::vector<std::string> modifyColumns;
109     std::vector<std::string> conditionColumns;
110     ASSERT_EQ("", PermissionUsedRecordDb::GetInstance().CreateUpdatePrepareSqlCmd(type, modifyColumns,
111         conditionColumns));
112 }
113 
114 /*
115  * @tc.name: CreateUpdatePrepareSqlCmd002
116  * @tc.desc: PermissionUsedRecordDb::CreateUpdatePrepareSqlCmd function test type not found
117  * @tc.type: FUNC
118  * @tc.require: issueI5YL6H
119  */
120 HWTEST_F(PermissionRecordDBTest, CreateUpdatePrepareSqlCmd002, TestSize.Level1)
121 {
122     PermissionUsedRecordDb::DataType type = static_cast<PermissionUsedRecordDb::DataType>(100);
123     std::vector<std::string> modifyColumns;
124     modifyColumns.emplace_back(PrivacyFiledConst::FIELD_TOKEN_ID);
125     std::vector<std::string> conditionColumns;
126     ASSERT_EQ("", PermissionUsedRecordDb::GetInstance().CreateUpdatePrepareSqlCmd(type, modifyColumns,
127         conditionColumns));
128 }
129 
130 /*
131  * @tc.name: CreateUpdatePrepareSqlCmd003
132  * @tc.desc: PermissionUsedRecordDb::CreateUpdatePrepareSqlCmd function test conditionColumns empty
133  * @tc.type: FUNC
134  * @tc.require: issueI5YL6H
135  */
136 HWTEST_F(PermissionRecordDBTest, CreateUpdatePrepareSqlCmd003, TestSize.Level1)
137 {
138     PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
139     std::vector<std::string> modifyColumns;
140     modifyColumns.emplace_back(PrivacyFiledConst::FIELD_TOKEN_ID);
141     modifyColumns.emplace_back(PrivacyFiledConst::FIELD_TIMESTAMP);
142     std::vector<std::string> conditionColumns;
143     ASSERT_NE("", PermissionUsedRecordDb::GetInstance().CreateUpdatePrepareSqlCmd(type, modifyColumns,
144         conditionColumns));
145 }
146 
147 /*
148  * @tc.name: CreateUpdatePrepareSqlCmd004
149  * @tc.desc: PermissionUsedRecordDb::CreateUpdatePrepareSqlCmd function test conditionColumns empty
150  * @tc.type: FUNC
151  * @tc.require: issueI5YL6H
152  */
153 HWTEST_F(PermissionRecordDBTest, CreateUpdatePrepareSqlCmd004, TestSize.Level1)
154 {
155     PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
156     std::vector<std::string> modifyColumns;
157     modifyColumns.emplace_back(PrivacyFiledConst::FIELD_TOKEN_ID);
158     modifyColumns.emplace_back(PrivacyFiledConst::FIELD_TIMESTAMP);
159     std::vector<std::string> conditionColumns;
160     ASSERT_NE("", PermissionUsedRecordDb::GetInstance().CreateUpdatePrepareSqlCmd(type, modifyColumns,
161         conditionColumns));
162 }
163 
164 /*
165  * @tc.name: CreateUpdatePrepareSqlCmd005
166  * @tc.desc: PermissionUsedRecordDb::CreateUpdatePrepareSqlCmd function test
167  * @tc.type: FUNC
168  * @tc.require: issueI5YL6H
169  */
170 HWTEST_F(PermissionRecordDBTest, CreateUpdatePrepareSqlCmd005, TestSize.Level1)
171 {
172     PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
173     std::vector<std::string> modifyColumns;
174     modifyColumns.emplace_back(PrivacyFiledConst::FIELD_TOKEN_ID);
175     modifyColumns.emplace_back(PrivacyFiledConst::FIELD_TIMESTAMP);
176     std::vector<std::string> conditionColumns;
177     conditionColumns.emplace_back(PrivacyFiledConst::FIELD_STATUS);
178     ASSERT_NE("", PermissionUsedRecordDb::GetInstance().CreateUpdatePrepareSqlCmd(type, modifyColumns,
179         conditionColumns));
180 }
181 
182 /*
183  * @tc.name: CreateSelectByConditionPrepareSqlCmd001
184  * @tc.desc: PermissionUsedRecordDb::CreateSelectByConditionPrepareSqlCmd function test type not found
185  * @tc.type: FUNC
186  * @tc.require: issueI5YL6H
187  */
188 HWTEST_F(PermissionRecordDBTest, CreateSelectByConditionPrepareSqlCmd001, TestSize.Level1)
189 {
190     PermissionUsedRecordDb::DataType type = static_cast<PermissionUsedRecordDb::DataType>(100);
191     std::set<int32_t> opCodeList;
192     std::vector<std::string> andColumns;
193     ASSERT_EQ("", PermissionUsedRecordDb::GetInstance().CreateSelectByConditionPrepareSqlCmd(0, type, opCodeList,
194         andColumns, 10));
195 }
196 
197 /*
198  * @tc.name: CreateSelectByConditionPrepareSqlCmd002
199  * @tc.desc: PermissionUsedRecordDb::CreateSelectByConditionPrepareSqlCmd function test
200  * @tc.type: FUNC
201  * @tc.require: issueI5YL6H
202  */
203 HWTEST_F(PermissionRecordDBTest, CreateSelectByConditionPrepareSqlCmd002, TestSize.Level1)
204 {
205     PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
206     std::set<int32_t> opCodeList;
207     opCodeList.insert(static_cast<int32_t>(Constant::OP_LOCATION));
208     std::vector<std::string> andColumns;
209     andColumns.emplace_back(PrivacyFiledConst::FIELD_TIMESTAMP_BEGIN);
210     std::vector<std::string> orColumns;
211     orColumns.emplace_back(PrivacyFiledConst::FIELD_TIMESTAMP);
212     ASSERT_NE("", PermissionUsedRecordDb::GetInstance().CreateSelectByConditionPrepareSqlCmd(0, type, opCodeList,
213         andColumns, 10));
214 }
215 
216 /*
217  * @tc.name: CreateCountPrepareSqlCmd001
218  * @tc.desc: PermissionUsedRecordDb::CreateCountPrepareSqlCmd function test type not found
219  * @tc.type: FUNC
220  * @tc.require: issueI5YL6H
221  */
222 HWTEST_F(PermissionRecordDBTest, CreateCountPrepareSqlCmd001, TestSize.Level1)
223 {
224     PermissionUsedRecordDb::DataType type = static_cast<PermissionUsedRecordDb::DataType>(100);
225     ASSERT_EQ("", PermissionUsedRecordDb::GetInstance().CreateCountPrepareSqlCmd(type));
226 }
227 
228 /*
229  * @tc.name: CreateDeleteExpireRecordsPrepareSqlCmd001
230  * @tc.desc: PermissionUsedRecordDb::CreateDeleteExpireRecordsPrepareSqlCmd function test
231  * @tc.type: FUNC
232  * @tc.require: issueI5YL6H
233  */
234 HWTEST_F(PermissionRecordDBTest, CreateDeleteExpireRecordsPrepareSqlCmd001, TestSize.Level1)
235 {
236     PermissionUsedRecordDb::DataType type = static_cast<PermissionUsedRecordDb::DataType>(100); // type not found
237     std::vector<std::string> andColumns;
238     ASSERT_EQ("", PermissionUsedRecordDb::GetInstance().CreateDeleteExpireRecordsPrepareSqlCmd(type, andColumns));
239 
240     type = PermissionUsedRecordDb::PERMISSION_RECORD; // field timestamp_begin and timestamp_end
241     andColumns.emplace_back(PrivacyFiledConst::FIELD_TIMESTAMP_BEGIN);
242     andColumns.emplace_back(PrivacyFiledConst::FIELD_TIMESTAMP_END);
243     ASSERT_NE("", PermissionUsedRecordDb::GetInstance().CreateDeleteExpireRecordsPrepareSqlCmd(type, andColumns));
244 }
245 
246 /*
247  * @tc.name: CreateDeleteExcessiveRecordsPrepareSqlCmd001
248  * @tc.desc: PermissionUsedRecordDb::CreateDeleteExcessiveRecordsPrepareSqlCmd function test type not found
249  * @tc.type: FUNC
250  * @tc.require: issueI5YL6H
251  */
252 HWTEST_F(PermissionRecordDBTest, CreateDeleteExcessiveRecordsPrepareSqlCmd001, TestSize.Level1)
253 {
254     PermissionUsedRecordDb::DataType type = static_cast<PermissionUsedRecordDb::DataType>(100);
255     uint32_t excessiveSize = 10;
256     ASSERT_EQ("", PermissionUsedRecordDb::GetInstance().CreateDeleteExcessiveRecordsPrepareSqlCmd(type, excessiveSize));
257 }
258 
259 /*
260  * @tc.name: CreateDeleteExcessiveRecordsPrepareSqlCmd002
261  * @tc.desc: PermissionUsedRecordDb::CreateDeleteExcessiveRecordsPrepareSqlCmd function test
262  * @tc.type: FUNC
263  * @tc.require: issueI5YL6H
264  */
265 HWTEST_F(PermissionRecordDBTest, CreateDeleteExcessiveRecordsPrepareSqlCmd002, TestSize.Level1)
266 {
267     PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
268     uint32_t excessiveSize = 10;
269     ASSERT_NE("", PermissionUsedRecordDb::GetInstance().CreateDeleteExcessiveRecordsPrepareSqlCmd(type, excessiveSize));
270 }
271 
272 /*
273  * @tc.name: CreatePermissionRecordTable001
274  * @tc.desc: PermissionUsedRecordDb::CreatePermissionRecordTable function test
275  * @tc.type: FUNC
276  * @tc.require: issueI5YL6H
277  */
278 HWTEST_F(PermissionRecordDBTest, CreatePermissionRecordTable001, TestSize.Level1)
279 {
280     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().CreatePermissionRecordTable());
281 
282     std::map<PermissionUsedRecordDb::DataType, SqliteTable> dataTypeToSqlTable;
283     dataTypeToSqlTable = PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_; // backup
284     PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_.clear();
285 
286     ASSERT_EQ(Constant::FAILURE, PermissionUsedRecordDb::GetInstance().CreatePermissionRecordTable());
287     PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_ = dataTypeToSqlTable; // recovery
288 }
289 
290 /*
291  * @tc.name: InsertLockScreenStatusColumn001
292  * @tc.desc: PermissionUsedRecordDb::InsertLockScreenStatusColumn function test
293  * @tc.type: FUNC
294  * @tc.require: issueI5YL6H
295  */
296 HWTEST_F(PermissionRecordDBTest, InsertLockScreenStatusColumn001, TestSize.Level1)
297 {
298     ASSERT_EQ(Constant::SUCCESS, PermissionUsedRecordDb::GetInstance().InsertLockScreenStatusColumn());
299 
300     std::map<PermissionUsedRecordDb::DataType, SqliteTable> dataTypeToSqlTable;
301     dataTypeToSqlTable = PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_; // backup
302     PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_.clear();
303 
304     ASSERT_EQ(Constant::FAILURE, PermissionUsedRecordDb::GetInstance().InsertLockScreenStatusColumn());
305     PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_ = dataTypeToSqlTable; // recovery
306 }
307 
308 /*
309  * @tc.name: TranslationIntoGenericValues001
310  * @tc.desc: DataTranslator::TranslationIntoGenericValues function test
311  * @tc.type: FUNC
312  * @tc.require:
313  */
314 HWTEST_F(PermissionRecordDBTest, TranslationIntoGenericValues001, TestSize.Level1)
315 {
316     PermissionUsedRequest request;
317     GenericValues andGenericValues;
318 
319     request.beginTimeMillis = -1;
320     // begin < 0
321     ASSERT_EQ(Constant::FAILURE,
322         DataTranslator::TranslationIntoGenericValues(request, andGenericValues));
323 
324     request.beginTimeMillis = 10;
325     request.endTimeMillis = -1;
326     // begin > 0 + end < 0
327     ASSERT_EQ(Constant::FAILURE,
328         DataTranslator::TranslationIntoGenericValues(request, andGenericValues));
329 
330     request.endTimeMillis = 1;
331     // begin > 0 + end > 0 + begin > end
332     ASSERT_EQ(Constant::FAILURE,
333         DataTranslator::TranslationIntoGenericValues(request, andGenericValues));
334 
335     request.beginTimeMillis = 10; // begin != 0
336     request.endTimeMillis = 20; // end != 0
337     request.flag = static_cast<PermissionUsageFlag>(9);
338     // begin > 0 + end > 0 + begin < end + flag = 9
339     ASSERT_EQ(Constant::FAILURE,
340         DataTranslator::TranslationIntoGenericValues(request, andGenericValues));
341 
342     request.flag = PermissionUsageFlag::FLAG_PERMISSION_USAGE_DETAIL;
343     request.permissionList.emplace_back("ohos.com.CAMERA");
344     // begin > 0 + end > 0 + begin < end + flag = 1 + TransferPermissionToOpcode true
345     ASSERT_EQ(Constant::SUCCESS,
346         DataTranslator::TranslationIntoGenericValues(request, andGenericValues));
347 }
348 
349 /*
350  * @tc.name: TranslationGenericValuesIntoPermissionUsedRecord001
351  * @tc.desc: DataTranslator::TranslationGenericValuesIntoPermissionUsedRecord function test
352  * @tc.type: FUNC
353  * @tc.require:
354  */
355 HWTEST_F(PermissionRecordDBTest, TranslationGenericValuesIntoPermissionUsedRecord001, TestSize.Level1)
356 {
357     GenericValues inGenericValues;
358     PermissionUsedRecord permissionRecord;
359 
360     int32_t opCode = static_cast<int32_t>(Constant::OpCode::OP_INVALID);
361     inGenericValues.Put(PrivacyFiledConst::FIELD_OP_CODE, opCode);
362     // TransferOpcodeToPermission fail
363     ASSERT_EQ(Constant::FAILURE, DataTranslator::TranslationGenericValuesIntoPermissionUsedRecord(
364         FLAG_PERMISSION_USAGE_SUMMARY, inGenericValues, permissionRecord));
365     inGenericValues.Remove(PrivacyFiledConst::FIELD_OP_CODE);
366 
367     opCode = static_cast<int32_t>(Constant::OpCode::OP_CAMERA);
368     inGenericValues.Put(PrivacyFiledConst::FIELD_OP_CODE, opCode);
369     inGenericValues.Put(PrivacyFiledConst::FIELD_TIMESTAMP, 10);
370     inGenericValues.Put(PrivacyFiledConst::FIELD_REJECT_COUNT, 1);
371     inGenericValues.Put(PrivacyFiledConst::FIELD_FLAG, 1);
372     // lastRejectTime > 0
373     ASSERT_EQ(Constant::SUCCESS, DataTranslator::TranslationGenericValuesIntoPermissionUsedRecord(
374         FLAG_PERMISSION_USAGE_DETAIL, inGenericValues, permissionRecord));
375 }
376 
377 /*
378  * @tc.name: Add001
379  * @tc.desc: PermissionUsedRecordDb::Add function test miss not null field
380  * @tc.type: FUNC
381  * @tc.require: issueI5YL6H
382  */
383 HWTEST_F(PermissionRecordDBTest, Add001, TestSize.Level1)
384 {
385     GenericValues value1;
386     value1.Put(PrivacyFiledConst::FIELD_TOKEN_ID, 0);
387     value1.Put(PrivacyFiledConst::FIELD_OP_CODE, Constant::OP_MICROPHONE);
388     value1.Put(PrivacyFiledConst::FIELD_STATUS, ActiveChangeType::PERM_ACTIVE_IN_FOREGROUND);
389     value1.Put(PrivacyFiledConst::FIELD_TIMESTAMP, 123); // 123 is random input
390     value1.Put(PrivacyFiledConst::FIELD_REJECT_COUNT, 0);
391     value1.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_UNLOCKED);
392     value1.Put(PrivacyFiledConst::FIELD_USED_TYPE, static_cast<int>(PermissionUsedType::NORMAL_TYPE));
393 
394     GenericValues value2;
395     value2.Put(PrivacyFiledConst::FIELD_TOKEN_ID, 0);
396     value2.Put(PrivacyFiledConst::FIELD_OP_CODE, Constant::OP_MICROPHONE);
397     value2.Put(PrivacyFiledConst::FIELD_STATUS, ActiveChangeType::PERM_ACTIVE_IN_FOREGROUND);
398     value2.Put(PrivacyFiledConst::FIELD_TIMESTAMP, 123); // 123 is random input
399     value2.Put(PrivacyFiledConst::FIELD_ACCESS_COUNT, 1);
400     value2.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_UNLOCKED);
401     value2.Put(PrivacyFiledConst::FIELD_USED_TYPE, static_cast<int>(PermissionUsedType::NORMAL_TYPE));
402 
403     PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
404     std::vector<GenericValues> values;
405     values.emplace_back(value1);
406     values.emplace_back(value2);
407     ASSERT_NE(0, PermissionUsedRecordDb::GetInstance().Add(type, values));
408 }
409 
410 /*
411  * @tc.name: Add002
412  * @tc.desc: PermissionUsedRecordDb::Add function test
413  * @tc.type: FUNC
414  * @tc.require: issueI5YL6H
415  */
416 HWTEST_F(PermissionRecordDBTest, Add002, TestSize.Level1)
417 {
418     GenericValues value1;
419     value1.Put(PrivacyFiledConst::FIELD_TOKEN_ID, 0);
420     value1.Put(PrivacyFiledConst::FIELD_OP_CODE, Constant::OP_MICROPHONE);
421     value1.Put(PrivacyFiledConst::FIELD_STATUS, ActiveChangeType::PERM_ACTIVE_IN_FOREGROUND);
422     value1.Put(PrivacyFiledConst::FIELD_TIMESTAMP, 123); // 123 is random input
423     value1.Put(PrivacyFiledConst::FIELD_ACCESS_DURATION, 123); // 123 is random input
424     value1.Put(PrivacyFiledConst::FIELD_ACCESS_COUNT, 1);
425     value1.Put(PrivacyFiledConst::FIELD_REJECT_COUNT, 0);
426     value1.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_UNLOCKED);
427     value1.Put(PrivacyFiledConst::FIELD_USED_TYPE, static_cast<int>(PermissionUsedType::NORMAL_TYPE));
428 
429     GenericValues value2;
430     value2.Put(PrivacyFiledConst::FIELD_TOKEN_ID, 1);
431     value2.Put(PrivacyFiledConst::FIELD_OP_CODE, Constant::OP_MICROPHONE);
432     value2.Put(PrivacyFiledConst::FIELD_STATUS, ActiveChangeType::PERM_ACTIVE_IN_FOREGROUND);
433     value2.Put(PrivacyFiledConst::FIELD_TIMESTAMP, 123); // 123 is random input
434     value2.Put(PrivacyFiledConst::FIELD_ACCESS_DURATION, 123); // 123 is random input
435     value2.Put(PrivacyFiledConst::FIELD_ACCESS_COUNT, 1);
436     value2.Put(PrivacyFiledConst::FIELD_REJECT_COUNT, 0);
437     value2.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_UNLOCKED);
438     value2.Put(PrivacyFiledConst::FIELD_USED_TYPE, static_cast<int>(PermissionUsedType::NORMAL_TYPE));
439 
440     PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
441     std::vector<GenericValues> values;
442     values.emplace_back(value1);
443     values.emplace_back(value2);
444     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Add(type, values));
445     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Remove(type, value1));
446     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Remove(type, value2));
447 }
448 
449 /*
450  * @tc.name: Add003
451  * @tc.desc: PermissionUsedRecordDb::Add function test
452  * @tc.type: FUNC
453  * @tc.require: issueI5RWXF
454  */
455 HWTEST_F(PermissionRecordDBTest, Add003, TestSize.Level1)
456 {
457     std::vector<GenericValues> values;
458     PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
459     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Add(type, values));
460 }
461 
462 /*
463  * @tc.name: Add004
464  * @tc.desc: PermissionUsedRecordDb::Add function test
465  * @tc.type: FUNC
466  * @tc.require: issueI5RWXF
467  */
468 HWTEST_F(PermissionRecordDBTest, Add004, TestSize.Level1)
469 {
470     GenericValues value1;
471     value1.Put(PrivacyFiledConst::FIELD_TOKEN_ID, 0);
472     value1.Put(PrivacyFiledConst::FIELD_OP_CODE, Constant::OP_MICROPHONE);
473     value1.Put(PrivacyFiledConst::FIELD_STATUS, ActiveChangeType::PERM_ACTIVE_IN_FOREGROUND);
474     value1.Put(PrivacyFiledConst::FIELD_TIMESTAMP, 123); // 123 is random input
475     value1.Put(PrivacyFiledConst::FIELD_ACCESS_DURATION, 123); // 123 is random input
476     value1.Put(PrivacyFiledConst::FIELD_ACCESS_COUNT, 1);
477     value1.Put(PrivacyFiledConst::FIELD_REJECT_COUNT, 0);
478     value1.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_UNLOCKED);
479     value1.Put(PrivacyFiledConst::FIELD_USED_TYPE, static_cast<int>(PermissionUsedType::NORMAL_TYPE));
480 
481     GenericValues value2; // only used_type diff from value1
482     value2.Put(PrivacyFiledConst::FIELD_TOKEN_ID, 0);
483     value2.Put(PrivacyFiledConst::FIELD_OP_CODE, Constant::OP_MICROPHONE);
484     value2.Put(PrivacyFiledConst::FIELD_STATUS, ActiveChangeType::PERM_ACTIVE_IN_FOREGROUND);
485     value2.Put(PrivacyFiledConst::FIELD_TIMESTAMP, 123); // 123 is random input
486     value2.Put(PrivacyFiledConst::FIELD_ACCESS_DURATION, 123); // 123 is random input
487     value2.Put(PrivacyFiledConst::FIELD_ACCESS_COUNT, 1);
488     value2.Put(PrivacyFiledConst::FIELD_REJECT_COUNT, 0);
489     value2.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_UNLOCKED);
490     value2.Put(PrivacyFiledConst::FIELD_USED_TYPE, static_cast<int>(PermissionUsedType::PICKER_TYPE));
491 
492     PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
493     std::vector<GenericValues> values;
494     values.emplace_back(value1);
495     values.emplace_back(value2);
496 
497     // if primary key do not add used_type, this place should be wrong
498     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Add(type, values));
499     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Remove(type, value1));
500     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Remove(type, value2));
501 }
502 
503 /*
504  * @tc.name: FindByConditions001
505  * @tc.desc: PermissionUsedRecordDb::FindByConditions function test
506  * @tc.type: FUNC
507  * @tc.require: issueI5YL6H
508  */
509 HWTEST_F(PermissionRecordDBTest, FindByConditions001, TestSize.Level1)
510 {
511     GenericValues value;
512     std::set<int32_t> opCodeList;
513     value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, 0);
514     value.Put(PrivacyFiledConst::FIELD_OP_CODE, Constant::OP_MICROPHONE);
515     value.Put(PrivacyFiledConst::FIELD_STATUS, ActiveChangeType::PERM_ACTIVE_IN_FOREGROUND);
516     value.Put(PrivacyFiledConst::FIELD_TIMESTAMP, 123); // 123 is random input
517     value.Put(PrivacyFiledConst::FIELD_ACCESS_DURATION, 123); // 123 is random input
518     value.Put(PrivacyFiledConst::FIELD_ACCESS_COUNT, 1);
519     value.Put(PrivacyFiledConst::FIELD_REJECT_COUNT, 0);
520     value.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_LOCKED);
521     value.Put(PrivacyFiledConst::FIELD_USED_TYPE, static_cast<int>(PermissionUsedType::NORMAL_TYPE));
522 
523     PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
524     std::vector<GenericValues> values;
525     values.emplace_back(value);
526     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Add(type, values));
527 
528     GenericValues orConditions;
529     std::vector<GenericValues> results;
530 
531     GenericValues andConditions; // no column
532     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().FindByConditions(type, opCodeList, andConditions, results, 10));
533 
534     GenericValues andConditions1; // field timestamp
535     andConditions1.Put(PrivacyFiledConst::FIELD_TIMESTAMP, 0);
536 
537     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().FindByConditions(type, opCodeList, andConditions1, results, 10));
538 
539     GenericValues andConditions2; // field access_duration
540     andConditions2.Put(PrivacyFiledConst::FIELD_ACCESS_DURATION, 0);
541     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().FindByConditions(type, opCodeList, andConditions2, results, 10));
542 
543     GenericValues andConditions3; // field not timestamp or access_duration
544     andConditions3.Put(PrivacyFiledConst::FIELD_STATUS, ActiveChangeType::PERM_ACTIVE_IN_FOREGROUND);
545     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().FindByConditions(type, opCodeList, andConditions3, results, 10));
546 
547     GenericValues andConditions4;
548     andConditions4.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_LOCKED);
549     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().FindByConditions(type, opCodeList, andConditions4, results, 10));
550 
551     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Remove(type, value));
552 }
553 
554 /*
555  * @tc.name: FindByConditions002
556  * @tc.desc: PermissionUsedRecordDb::FindByConditions function test
557  * @tc.type: FUNC
558  * @tc.require: issueI5YL6H
559  */
560 HWTEST_F(PermissionRecordDBTest, FindByConditions002, TestSize.Level1)
561 {
562     GenericValues value1;
563     value1.Put(PrivacyFiledConst::FIELD_TOKEN_ID, 1);
564     value1.Put(PrivacyFiledConst::FIELD_OP_CODE, Constant::OP_MICROPHONE);
565     value1.Put(PrivacyFiledConst::FIELD_STATUS, ActiveChangeType::PERM_ACTIVE_IN_FOREGROUND);
566     value1.Put(PrivacyFiledConst::FIELD_TIMESTAMP, 123); // 123 is random input
567     value1.Put(PrivacyFiledConst::FIELD_ACCESS_DURATION, 123); // 123 is random input
568     value1.Put(PrivacyFiledConst::FIELD_ACCESS_COUNT, 1);
569     value1.Put(PrivacyFiledConst::FIELD_REJECT_COUNT, 0);
570     value1.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_LOCKED);
571     value1.Put(PrivacyFiledConst::FIELD_USED_TYPE, static_cast<int>(PermissionUsedType::NORMAL_TYPE));
572 
573     GenericValues value2;
574     value2.Put(PrivacyFiledConst::FIELD_TOKEN_ID, 2); // random input
575     value2.Put(PrivacyFiledConst::FIELD_OP_CODE, Constant::OP_MICROPHONE);
576     value2.Put(PrivacyFiledConst::FIELD_STATUS, ActiveChangeType::PERM_ACTIVE_IN_FOREGROUND);
577     value2.Put(PrivacyFiledConst::FIELD_TIMESTAMP, 123); // 123 is random input
578     value2.Put(PrivacyFiledConst::FIELD_ACCESS_DURATION, 123); // 123 is random input
579     value2.Put(PrivacyFiledConst::FIELD_ACCESS_COUNT, 1);
580     value2.Put(PrivacyFiledConst::FIELD_REJECT_COUNT, 0);
581     value2.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_LOCKED);
582     value2.Put(PrivacyFiledConst::FIELD_USED_TYPE, static_cast<int>(PermissionUsedType::NORMAL_TYPE));
583 
584     GenericValues value3;
585     value3.Put(PrivacyFiledConst::FIELD_TOKEN_ID, 3); // random input
586     value3.Put(PrivacyFiledConst::FIELD_OP_CODE, Constant::OP_MICROPHONE);
587     value3.Put(PrivacyFiledConst::FIELD_STATUS, ActiveChangeType::PERM_ACTIVE_IN_FOREGROUND);
588     value3.Put(PrivacyFiledConst::FIELD_TIMESTAMP, 123); // 123 is random input
589     value3.Put(PrivacyFiledConst::FIELD_ACCESS_DURATION, 123); // 123 is random input
590     value3.Put(PrivacyFiledConst::FIELD_ACCESS_COUNT, 1);
591     value3.Put(PrivacyFiledConst::FIELD_REJECT_COUNT, 0);
592     value3.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_LOCKED);
593     value3.Put(PrivacyFiledConst::FIELD_USED_TYPE, static_cast<int>(PermissionUsedType::NORMAL_TYPE));
594 
595     PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
596     std::vector<GenericValues> values;
597     values.emplace_back(value1);
598     values.emplace_back(value2);
599     values.emplace_back(value3);
600     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Add(type, values));
601 
602     std::set<int32_t> opCodeList;
603     GenericValues andConditions;
604     std::vector<GenericValues> results;
605     andConditions.Put(PrivacyFiledConst::FIELD_OP_CODE, Constant::OP_MICROPHONE);
606     andConditions.Put(PrivacyFiledConst::FIELD_STATUS, ActiveChangeType::PERM_ACTIVE_IN_FOREGROUND);
607     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().FindByConditions(type, opCodeList, andConditions, results, 2));
608     ASSERT_EQ(static_cast<size_t>(2), results.size());
609 
610     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Remove(type, value1));
611     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Remove(type, value2));
612     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Remove(type, value3));
613 }
614 
615 /*
616  * @tc.name: DeleteExpireRecords001
617  * @tc.desc: PermissionUsedRecordDb::DeleteExpireRecords function test andColumns empty
618  * @tc.type: FUNC
619  * @tc.require: issueI5YL6H
620  */
621 HWTEST_F(PermissionRecordDBTest, DeleteExpireRecords001, TestSize.Level1)
622 {
623     PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
624     GenericValues andConditions;
625     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().DeleteExpireRecords(type, andConditions));
626 }
627 
628 /*
629  * @tc.name: DeleteExcessiveRecords001
630  * @tc.desc: PermissionUsedRecordDb::DeleteExcessiveRecords function test
631  * @tc.type: FUNC
632  * @tc.require: issueI5YL6H
633  */
634 HWTEST_F(PermissionRecordDBTest, DeleteExcessiveRecords001, TestSize.Level1)
635 {
636     PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
637     uint32_t excessiveSize = 10;
638     ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().DeleteExcessiveRecords(type, excessiveSize));
639 }
640 
641 /*
642  * @tc.name: CreateQueryPrepareSqlCmd001
643  * @tc.desc: PermissionUsedRecordDb::CreateQueryPrepareSqlCmd function test
644  * @tc.type: FUNC
645  * @tc.require:
646  */
647 HWTEST_F(PermissionRecordDBTest, CreateQueryPrepareSqlCmd001, TestSize.Level1)
648 {
649     PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_USED_TYPE;
650     std::vector<std::string> conditionColumns;
651     ASSERT_NE("", PermissionUsedRecordDb::GetInstance().CreateQueryPrepareSqlCmd(
652         type, conditionColumns));
653 
654     type = static_cast<PermissionUsedRecordDb::DataType>(NOT_EXSIT_TYPE);
655     ASSERT_EQ("", PermissionUsedRecordDb::GetInstance().CreateQueryPrepareSqlCmd(
656         type, conditionColumns));
657 }
658 
659 /*
660  * @tc.name: Query001
661  * @tc.desc: PermissionUsedRecordDb::Query function test
662  * @tc.type: FUNC
663  * @tc.require:
664  */
665 HWTEST_F(PermissionRecordDBTest, Query001, TestSize.Level1)
666 {
667     PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_USED_TYPE;
668     GenericValues conditionValue;
669     conditionValue.Put(PrivacyFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID);
670     conditionValue.Put(PrivacyFiledConst::FIELD_PERMISSION_CODE,
671         static_cast<int32_t>(Constant::OpCode::OP_ANSWER_CALL));
672     std::vector<GenericValues> results;
673     ASSERT_EQ(PermissionUsedRecordDb::ExecuteResult::SUCCESS,
674         PermissionUsedRecordDb::GetInstance().Query(type, conditionValue, results));
675     for (const auto& result : results) {
676         // no record with token 123 before add
677         ASSERT_NE(RANDOM_TOKENID, result.GetInt(PrivacyFiledConst::FIELD_TOKEN_ID));
678     }
679     results.clear();
680 
681     GenericValues value;
682     value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID);
683     value.Put(PrivacyFiledConst::FIELD_PERMISSION_CODE, static_cast<int32_t>(Constant::OpCode::OP_ANSWER_CALL));
684     value.Put(PrivacyFiledConst::FIELD_USED_TYPE, PERMISSION_USED_TYPE_VALUE);
685     std::vector<GenericValues> values;
686     values.emplace_back(value);
687     // add a record: 123-0-1
688     ASSERT_EQ(PermissionUsedRecordDb::ExecuteResult::SUCCESS, PermissionUsedRecordDb::GetInstance().Add(type, values));
689 
690     ASSERT_EQ(PermissionUsedRecordDb::ExecuteResult::SUCCESS,
691         PermissionUsedRecordDb::GetInstance().Query(type, conditionValue, results));
692     ASSERT_EQ(false, results.empty());
693     for (const auto& result : results) {
694         // query result success, when tokenId is 123, permission_code is 0 and used_type is 1
695         if (RANDOM_TOKENID == result.GetInt(PrivacyFiledConst::FIELD_TOKEN_ID)) {
696             ASSERT_EQ(static_cast<int32_t>(Constant::OpCode::OP_ANSWER_CALL),
697                 result.GetInt(PrivacyFiledConst::FIELD_PERMISSION_CODE));
698             ASSERT_EQ(PERMISSION_USED_TYPE_VALUE, result.GetInt(PrivacyFiledConst::FIELD_USED_TYPE));
699             break;
700         }
701     }
702 
703     ASSERT_EQ(PermissionUsedRecordDb::ExecuteResult::SUCCESS, PermissionUsedRecordDb::GetInstance().Remove(
704         type, conditionValue));
705 }
706 
707 /*
708  * @tc.name: Update001
709  * @tc.desc: PermissionUsedRecordDb::Update function test
710  * @tc.type: FUNC
711  * @tc.require:
712  */
713 HWTEST_F(PermissionRecordDBTest, Update001, TestSize.Level1)
714 {
715     PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_USED_TYPE;
716     GenericValues conditionValue;
717     conditionValue.Put(PrivacyFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID);
718     conditionValue.Put(PrivacyFiledConst::FIELD_PERMISSION_CODE,
719         static_cast<int32_t>(Constant::OpCode::OP_ANSWER_CALL));
720 
721     GenericValues value;
722     value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID);
723     value.Put(PrivacyFiledConst::FIELD_PERMISSION_CODE, static_cast<int32_t>(Constant::OpCode::OP_ANSWER_CALL));
724     value.Put(PrivacyFiledConst::FIELD_USED_TYPE, PERMISSION_USED_TYPE_VALUE);
725     std::vector<GenericValues> values;
726     values.emplace_back(value);
727     // add a record: 123-0-1
728     ASSERT_EQ(PermissionUsedRecordDb::ExecuteResult::SUCCESS, PermissionUsedRecordDb::GetInstance().Add(type, values));
729 
730     std::vector<GenericValues> results;
731     ASSERT_EQ(PermissionUsedRecordDb::ExecuteResult::SUCCESS,
732         PermissionUsedRecordDb::GetInstance().Query(type, conditionValue, results));
733     ASSERT_EQ(false, results.empty());
734     for (const auto& result : results) {
735         // query result success, when tokenId is 123, permission_code is 0 and used_type is 1
736         if (RANDOM_TOKENID == result.GetInt(PrivacyFiledConst::FIELD_TOKEN_ID)) {
737             ASSERT_EQ(static_cast<int32_t>(Constant::OpCode::OP_ANSWER_CALL),
738                 result.GetInt(PrivacyFiledConst::FIELD_PERMISSION_CODE));
739             ASSERT_EQ(PERMISSION_USED_TYPE_VALUE, result.GetInt(PrivacyFiledConst::FIELD_USED_TYPE));
740             break;
741         }
742     }
743     results.clear();
744 
745     GenericValues modifyValue;
746     modifyValue.Put(PrivacyFiledConst::FIELD_USED_TYPE, PICKER_TYPE_VALUE);
747     // update record 123-0-1 to 123-0-2
748     ASSERT_EQ(PermissionUsedRecordDb::ExecuteResult::SUCCESS, PermissionUsedRecordDb::GetInstance().Update(
749         type, modifyValue, conditionValue));
750     ASSERT_EQ(PermissionUsedRecordDb::ExecuteResult::SUCCESS,
751         PermissionUsedRecordDb::GetInstance().Query(type, conditionValue, results));
752     ASSERT_EQ(false, results.empty());
753     for (const auto& result : results) {
754         // query result success, when tokenId is 123, permission_code is 0 and used_type is 2
755         if (RANDOM_TOKENID == result.GetInt(PrivacyFiledConst::FIELD_TOKEN_ID)) {
756             ASSERT_EQ(static_cast<int32_t>(Constant::OpCode::OP_ANSWER_CALL),
757                 result.GetInt(PrivacyFiledConst::FIELD_PERMISSION_CODE));
758             ASSERT_EQ(PICKER_TYPE_VALUE, result.GetInt(PrivacyFiledConst::FIELD_USED_TYPE));
759             break;
760         }
761     }
762 
763     ASSERT_EQ(PermissionUsedRecordDb::ExecuteResult::SUCCESS, PermissionUsedRecordDb::GetInstance().Remove(
764         type, conditionValue));
765 }
766 } // namespace AccessToken
767 } // namespace Security
768 } // namespace OHOS
769