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 <string>
17
18 #include <gtest/gtest.h>
19 #include "system_ability_definition.h"
20
21 #include "bundle_active_usage_database.h"
22 #include "bundle_active_util.h"
23 #include "bundle_active_constant.h"
24
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace DeviceUsageStats {
29 class BundleActiveUsageDatabaseTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
33 void SetUp();
34 void TearDown();
35 };
36
SetUpTestCase(void)37 void BundleActiveUsageDatabaseTest::SetUpTestCase(void)
38 {
39 }
40
TearDownTestCase(void)41 void BundleActiveUsageDatabaseTest::TearDownTestCase(void)
42 {
43 }
44
SetUp(void)45 void BundleActiveUsageDatabaseTest::SetUp(void)
46 {
47 }
48
TearDown(void)49 void BundleActiveUsageDatabaseTest::TearDown(void)
50 {
51 }
52
53 /*
54 * @tc.name: BundleActiveUsageDatabaseTest_OnPackageUninstalled_001
55 * @tc.desc: OnPackageUninstalled
56 * @tc.type: FUNC
57 * @tc.require: issuesI5SOZY
58 */
59 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_OnPackageUninstalled_001,
60 Function | MediumTest | TestSize.Level0)
61 {
62 auto database = std::make_shared<BundleActiveUsageDatabase>();
63 int32_t userId = 0;
64 std::string bundleName = "defaultBundleName";
65 database->sortedTableArray_ = {{1}};
66 database->eventTableName_ = "defaultBundleName";
67 database->bundleHistoryTableName_ = "defaultBundleName";
68 database->moduleRecordsTableName_ = "defaultBundleName";
69 database->formRecordsTableName_ = "defaultBundleName";
70
71 database->OnPackageUninstalled(userId, bundleName, 0, 0);
72 EXPECT_NE(database, nullptr);
73 }
74
75 /*
76 * @tc.name: BundleActiveUsageDatabaseTest_GetOptimalIntervalType_001
77 * @tc.desc: GetOptimalIntervalType
78 * @tc.type: FUNC
79 * @tc.require: issuesI5SOZY
80 */
81 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_GetOptimalIntervalType_001,
82 Function | MediumTest | TestSize.Level0)
83 {
84 auto database = std::make_shared<BundleActiveUsageDatabase>();
85 int64_t beginTime = 0;
86 int64_t endTime = 2000000000000000;
87 database->sortedTableArray_ = {{0}, {1}};
88 database->GetOptimalIntervalType(beginTime, endTime);
89 EXPECT_NE(database, nullptr);
90 }
91
92 /*
93 * @tc.name: BundleActiveUsageDatabaseTest_NearIndexOnOrBeforeCurrentTime_001
94 * @tc.desc: NearIndexOnOrBeforeCurrentTime
95 * @tc.type: FUNC
96 * @tc.require: issuesI5SOZY
97 */
98 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_NearIndexOnOrBeforeCurrentTime_001,
99 Function | MediumTest | TestSize.Level0)
100 {
101 auto database = std::make_shared<BundleActiveUsageDatabase>();
102 int64_t currentTime = 0;
103 vector<int64_t> sortedTableArray = {0};
104 database->NearIndexOnOrBeforeCurrentTime(currentTime, sortedTableArray);
105 EXPECT_NE(database, nullptr);
106 }
107
108 /*
109 * @tc.name: BundleActiveUsageDatabaseTest_CheckDatabaseVersion_001
110 * @tc.desc: CheckDatabaseVersion
111 * @tc.type: FUNC
112 * @tc.require: issuesI9Q9ZJ
113 */
114 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_CheckDatabaseVersion_001,
115 Function | MediumTest | TestSize.Level0)
116 {
117 auto database = std::make_shared<BundleActiveUsageDatabase>();
118 database->CheckDatabaseVersion();
119 EXPECT_NE(database, nullptr);
120 }
121
122 /*
123 * @tc.name: BundleActiveUsageDatabaseTest_GetOldDbVersion_001
124 * @tc.desc: GetOldDbVersion
125 * @tc.type: FUNC
126 * @tc.require: issuesI9Q9ZJ
127 */
128 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_GetOldDbVersion_001,
129 Function | MediumTest | TestSize.Level0)
130 {
131 auto database = std::make_shared<BundleActiveUsageDatabase>();
132 database->GetOldDbVersion();
133 EXPECT_NE(database, nullptr);
134 }
135
136 /*
137 * @tc.name: BundleActiveUsageDatabaseTest_GetVersionByFileInput_001
138 * @tc.desc: GetVersionByFileInput
139 * @tc.type: FUNC
140 * @tc.require: issuesI9Q9ZJ
141 */
142 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_GetVersionByFileInput_001,
143 Function | MediumTest | TestSize.Level0)
144 {
145 auto database = std::make_shared<BundleActiveUsageDatabase>();
146 std::string fileInput = "";
147 database->GetVersionByFileInput(fileInput);
148 fileInput = "aa123";
149 int32_t result = database->GetVersionByFileInput(fileInput);
150 EXPECT_EQ(result, 123);
151 }
152
153 /*
154 * @tc.name: BundleActiveUsageDatabaseTest_UpgradeDatabase_001
155 * @tc.desc: UpgradeDatabase
156 * @tc.type: FUNC
157 * @tc.require: issuesI9Q9ZJ
158 */
159 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_UpgradeDatabase_001,
160 Function | MediumTest | TestSize.Level0)
161 {
162 auto database = std::make_shared<BundleActiveUsageDatabase>();
163 database->currentVersion_ = 0;
164 int32_t oldVersion = 1;
165 int32_t curVersion = 2;
166 database->UpgradeDatabase(oldVersion, curVersion);
167
168 oldVersion = 2;
169 curVersion = 3;
170 database->UpgradeDatabase(oldVersion, curVersion);
171 EXPECT_EQ(database->currentVersion_, curVersion);
172 }
173
174 /*
175 * @tc.name: BundleActiveUsageDatabaseTest_UpgradeDatabase_001
176 * @tc.desc: UpgradeDatabase
177 * @tc.type: FUNC
178 * @tc.require: issuesI9Q9ZJ
179 */
180 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_UpgradeDatabase_002,
181 Function | MediumTest | TestSize.Level0)
182 {
183 auto database = std::make_shared<BundleActiveUsageDatabase>();
184 database->currentVersion_ = 0;
185 int32_t oldVersion = 1;
186 int32_t curVersion = 3;
187 database->UpgradeDatabase(oldVersion, curVersion);
188 EXPECT_EQ(database->currentVersion_, curVersion);
189 database->currentVersion_ = 0;
190 oldVersion = 2;
191 curVersion = 3;
192 database->UpgradeDatabase(oldVersion, curVersion);
193 EXPECT_EQ(database->currentVersion_, curVersion);
194 oldVersion = 3;
195 database->UpgradeDatabase(oldVersion, curVersion);
196 EXPECT_EQ(database->currentVersion_, curVersion);
197 }
198
199 /*
200 * @tc.name: BundleActiveUsageDatabaseTest_AddRdbColumn_001
201 * @tc.desc: AddRdbColumn
202 * @tc.type: FUNC
203 * @tc.require: issuesI9Q9ZJ
204 */
205 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_AddRdbColumn_001,
206 Function | MediumTest | TestSize.Level0)
207 {
208 auto database = std::make_shared<BundleActiveUsageDatabase>();
209 std::shared_ptr<NativeRdb::RdbStore> store = database->GetBundleActiveRdbStore(0);
210 database->AddRdbColumn(store, "test", "testColumn", "INTERGER");
211 EXPECT_NE(database, nullptr);
212 }
213
214 /*
215 * @tc.name: BundleActiveUsageDatabaseTest_UpdateOldDataUid_001
216 * @tc.desc: UpdateOldDataUid
217 * @tc.type: FUNC
218 * @tc.require: issuesI9Q9ZJ
219 */
220 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_UpdateOldDataUid_001,
221 Function | MediumTest | TestSize.Level0)
222 {
223 std::map<std::string, int32_t> bundleNameUidMap;
224 bundleNameUidMap["111"] = 111;
225 bundleNameUidMap["222"] = 222;
226 auto database = std::make_shared<BundleActiveUsageDatabase>();
227 std::shared_ptr<NativeRdb::RdbStore> store = database->GetBundleActiveRdbStore(0);
228 database->UpdateOldDataUid(store, "test", 100, bundleNameUidMap);
229 EXPECT_NE(database, nullptr);
230 }
231
232 /*
233 * @tc.name: BundleActiveUsageDatabaseTest_CreateRecordTable_001
234 * @tc.desc: CreateRecordTable
235 * @tc.type: FUNC
236 * @tc.require: issuesI9Q9ZJ
237 */
238 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_CreateRecordTable_001,
239 Function | MediumTest | TestSize.Level0)
240 {
241 int64_t timeStamp = 10000;
242 auto database = std::make_shared<BundleActiveUsageDatabase>();
243 database->moduleRecordsTableName_ = "unknownTableName";
244 database->formRecordsTableName_ = "unknownTableName";
245 database->CreateRecordTable(timeStamp);;
246 EXPECT_NE(database, nullptr);
247 }
248
249 /*
250 * @tc.name: BundleActiveUsageDatabaseTest_GetQuerySqlCommand_001
251 * @tc.desc: GetQuerySqlCommand
252 * @tc.type: FUNC
253 * @tc.require: issuesI9Q9ZJ
254 */
255 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_GetQuerySqlCommand_001,
256 Function | MediumTest | TestSize.Level0)
257 {
258 std::vector<std::string> queryCondition;
259 std::string queryPackageSql;
260 auto database = std::make_shared<BundleActiveUsageDatabase>();
261 database->sortedTableArray_ = {{0}, {1}, {2}};
262 database->GetQuerySqlCommand(0, 1, 2, 0, 0, 1, 10, queryCondition, queryPackageSql);
263 EXPECT_TRUE(!queryPackageSql.empty());
264 }
265
266 /*
267 * @tc.name: BundleActiveUtil_001
268 * @tc.desc: CreateRecordTable
269 * @tc.type: FUNC
270 * @tc.require: issuesI9Q9ZJ
271 */
272 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUtil_001,
273 Function | MediumTest | TestSize.Level0)
274 {
275 int32_t result = BundleActiveUtil::StringToInt32("11");
276 EXPECT_EQ(result, 11);
277 int64_t resultInt64 = BundleActiveUtil::StringToInt64("11");
278 EXPECT_EQ(resultInt64, 11);
279 }
280
281 /*
282 * @tc.name: BundleActiveUsageDatabaseTest_SupportFirstUseTime_001
283 * @tc.desc: SupportFirstUseTime
284 * @tc.type: FUNC
285 * @tc.require: issuesICCZ27
286 */
287 HWTEST_F(BundleActiveUsageDatabaseTest, SupportFirstUseTime_001,
288 Function | MediumTest | TestSize.Level0)
289 {
290 auto database = std::make_shared<BundleActiveUsageDatabase>();
291
292 database->SupportFirstUseTime();
293 EXPECT_NE(database, nullptr);
294 }
295
296 /*
297 * @tc.name: BundleActiveUsageDatabaseTest_UpdateFirstUseTime_002
298 * @tc.desc: UpdateFirstUseTime
299 * @tc.type: FUNC
300 * @tc.require: issuesICCZ27
301 */
302 HWTEST_F(BundleActiveUsageDatabaseTest, UpdateFirstUseTime_002,
303 Function | MediumTest | TestSize.Level0)
304 {
305 auto database = std::make_shared<BundleActiveUsageDatabase>();
306 auto rdb = database->GetBundleActiveRdbStore(APP_GROUP_DATABASE_INDEX);
307 database->UpdateFirstUseTime(rdb, BUNDLE_HISTORY_LOG_TABLE, 100);
308 EXPECT_NE(database, nullptr);
309 }
310
311 /*
312 * @tc.name: BundleActiveUsageDatabaseTest_DeleteExcessiveEventTableData_001
313 * @tc.desc: DeleteExcessiveEventTableData
314 * @tc.type: FUNC
315 * @tc.require: issuesIC2FBU
316 */
317 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_DeleteExcessiveEventTableData_001,
318 Function | MediumTest | TestSize.Level0)
319 {
320 auto database = std::make_shared<BundleActiveUsageDatabase>();
321 database->DeleteExcessiveEventTableData(0);
322 database->eventTableName_ = "a123";
323 database->DeleteExcessiveEventTableData(0);
324 database->eventBeginTime_ = 0;
325 database->DeleteExcessiveEventTableData(0);
326 database->eventBeginTime_ = MAX_END_TIME;
327 database->DeleteExcessiveEventTableData(0);
328 database->InitDatabaseTableInfo(100);
329 database->DeleteExcessiveEventTableData(0);
330 EXPECT_EQ(database->eventTableName_, "a123");
331 }
332
333 /*
334 * @tc.name: GetSteadyTime_001
335 * @tc.desc: BundleActiveUtil Test
336 * @tc.type: FUNC
337 * @tc.require: issuesIC2FBU
338 */
339 HWTEST_F(BundleActiveUsageDatabaseTest, GetSteadyTime_001,
340 Function | MediumTest | TestSize.Level0)
341 {
342 EXPECT_TRUE(BundleActiveUtil::GetSteadyTime() > 0);
343 }
344
345 /*
346 * @tc.name: GetFolderOrFileSize_001
347 * @tc.desc: BundleActiveUtil Test
348 * @tc.type: FUNC
349 * @tc.require: issuesIC2FBU
350 */
351 HWTEST_F(BundleActiveUsageDatabaseTest, GetFolderOrFileSize_001,
352 Function | MediumTest | TestSize.Level0)
353 {
354 EXPECT_EQ(BundleActiveUtil::GetFolderOrFileSize(""), 0);
355 EXPECT_TRUE(BundleActiveUtil::GetFolderOrFileSize(BUNDLE_ACTIVE_DATABASE_DIR) > 0);
356 }
357
358 /*
359 * @tc.name: GetPartitionName_001
360 * @tc.desc: BundleActiveUtil Test
361 * @tc.type: FUNC
362 * @tc.require: issuesIC2FBU
363 */
364 HWTEST_F(BundleActiveUsageDatabaseTest, GetPartitionName_001,
365 Function | MediumTest | TestSize.Level0)
366 {
367 EXPECT_EQ(BundleActiveUtil::GetPartitionName(""), "/");
368 EXPECT_EQ(BundleActiveUtil::GetPartitionName(BUNDLE_ACTIVE_DATABASE_DIR), "/data");
369 EXPECT_EQ(BundleActiveUtil::GetPartitionName("/data"), "/data");
370 }
371
372 /*
373 * @tc.name: GetDeviceValidSize_001
374 * @tc.desc: BundleActiveUtil Test
375 * @tc.type: FUNC
376 * @tc.require: issuesIC2FBU
377 */
378 HWTEST_F(BundleActiveUsageDatabaseTest, GetDeviceValidSize_001,
379 Function | MediumTest | TestSize.Level0)
380 {
381 EXPECT_TRUE(BundleActiveUtil::GetDeviceValidSize("") >= 0);
382 EXPECT_TRUE(BundleActiveUtil::GetDeviceValidSize(BUNDLE_ACTIVE_DATABASE_DIR) >= 0);
383 }
384
385 /*
386 * @tc.name: GetPercentOfAvailableUserSpace_001
387 * @tc.desc: BundleActiveUtil Test
388 * @tc.type: FUNC
389 * @tc.require: issuesIC2FBU
390 */
391 HWTEST_F(BundleActiveUsageDatabaseTest, GetPercentOfAvailableUserSpace_001,
392 Function | MediumTest | TestSize.Level0)
393 {
394 EXPECT_TRUE(BundleActiveUtil::GetPercentOfAvailableUserSpace("") >= 0);
395 EXPECT_TRUE(BundleActiveUtil::GetPercentOfAvailableUserSpace(BUNDLE_ACTIVE_DATABASE_DIR) >= 0);
396 }
397 } // namespace DeviceUsageStats
398 } // namespace OHOS