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
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace DeviceUsageStats {
28 class BundleActiveUsageDatabaseTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
32 void SetUp();
33 void TearDown();
34 };
35
SetUpTestCase(void)36 void BundleActiveUsageDatabaseTest::SetUpTestCase(void)
37 {
38 }
39
TearDownTestCase(void)40 void BundleActiveUsageDatabaseTest::TearDownTestCase(void)
41 {
42 }
43
SetUp(void)44 void BundleActiveUsageDatabaseTest::SetUp(void)
45 {
46 }
47
TearDown(void)48 void BundleActiveUsageDatabaseTest::TearDown(void)
49 {
50 }
51
52 /*
53 * @tc.name: BundleActiveUsageDatabaseTest_OnPackageUninstalled_001
54 * @tc.desc: OnPackageUninstalled
55 * @tc.type: FUNC
56 * @tc.require: issuesI5SOZY
57 */
58 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_OnPackageUninstalled_001,
59 Function | MediumTest | Level0)
60 {
61 auto database = std::make_shared<BundleActiveUsageDatabase>();
62 int32_t userId = 0;
63 std::string bundleName = "defaultBundleName";
64 database->sortedTableArray_ = {{1}};
65 database->eventTableName_ = "defaultBundleName";
66 database->bundleHistoryTableName_ = "defaultBundleName";
67 database->moduleRecordsTableName_ = "defaultBundleName";
68 database->formRecordsTableName_ = "defaultBundleName";
69
70 database->OnPackageUninstalled(userId, bundleName, 0, 0);
71 EXPECT_NE(database, nullptr);
72 }
73
74 /*
75 * @tc.name: BundleActiveUsageDatabaseTest_GetOptimalIntervalType_001
76 * @tc.desc: GetOptimalIntervalType
77 * @tc.type: FUNC
78 * @tc.require: issuesI5SOZY
79 */
80 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_GetOptimalIntervalType_001,
81 Function | MediumTest | Level0)
82 {
83 auto database = std::make_shared<BundleActiveUsageDatabase>();
84 int64_t beginTime = 0;
85 int64_t endTime = 2000000000000000;
86 database->sortedTableArray_ = {{0}, {1}};
87 database->GetOptimalIntervalType(beginTime, endTime);
88 EXPECT_NE(database, nullptr);
89 }
90
91 /*
92 * @tc.name: BundleActiveUsageDatabaseTest_NearIndexOnOrBeforeCurrentTime_001
93 * @tc.desc: NearIndexOnOrBeforeCurrentTime
94 * @tc.type: FUNC
95 * @tc.require: issuesI5SOZY
96 */
97 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_NearIndexOnOrBeforeCurrentTime_001,
98 Function | MediumTest | Level0)
99 {
100 auto database = std::make_shared<BundleActiveUsageDatabase>();
101 int64_t currentTime = 0;
102 vector<int64_t> sortedTableArray = {0};
103 database->NearIndexOnOrBeforeCurrentTime(currentTime, sortedTableArray);
104 EXPECT_NE(database, nullptr);
105 }
106
107 /*
108 * @tc.name: BundleActiveUsageDatabaseTest_CheckDatabaseVersion_001
109 * @tc.desc: CheckDatabaseVersion
110 * @tc.type: FUNC
111 * @tc.require: issuesI9Q9ZJ
112 */
113 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_CheckDatabaseVersion_001,
114 Function | MediumTest | Level0)
115 {
116 auto database = std::make_shared<BundleActiveUsageDatabase>();
117 database->CheckDatabaseVersion();
118 EXPECT_NE(database, nullptr);
119 }
120
121 /*
122 * @tc.name: BundleActiveUsageDatabaseTest_GetOldDbVersion_001
123 * @tc.desc: GetOldDbVersion
124 * @tc.type: FUNC
125 * @tc.require: issuesI9Q9ZJ
126 */
127 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_GetOldDbVersion_001,
128 Function | MediumTest | Level0)
129 {
130 auto database = std::make_shared<BundleActiveUsageDatabase>();
131 database->GetOldDbVersion();
132 EXPECT_NE(database, nullptr);
133 }
134
135 /*
136 * @tc.name: BundleActiveUsageDatabaseTest_GetVersionByFileInput_001
137 * @tc.desc: GetVersionByFileInput
138 * @tc.type: FUNC
139 * @tc.require: issuesI9Q9ZJ
140 */
141 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_GetVersionByFileInput_001,
142 Function | MediumTest | Level0)
143 {
144 auto database = std::make_shared<BundleActiveUsageDatabase>();
145 std::string fileInput = "";
146 database->GetVersionByFileInput(fileInput);
147 fileInput = "aa123";
148 int32_t result = database->GetVersionByFileInput(fileInput);
149 EXPECT_EQ(result, 123);
150 }
151
152 /*
153 * @tc.name: BundleActiveUsageDatabaseTest_UpgradleDatabase_001
154 * @tc.desc: UpgradleDatabase
155 * @tc.type: FUNC
156 * @tc.require: issuesI9Q9ZJ
157 */
158 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_UpgradleDatabase_001,
159 Function | MediumTest | Level0)
160 {
161 auto database = std::make_shared<BundleActiveUsageDatabase>();
162 int32_t oldVersion = 1;
163 int32_t curVersion = 2;
164 database->UpgradleDatabase(oldVersion, curVersion);
165 oldVersion = 2;
166 curVersion = 2;
167 database->UpgradleDatabase(oldVersion, curVersion);
168 EXPECT_NE(database, nullptr);
169 }
170
171 /*
172 * @tc.name: BundleActiveUsageDatabaseTest_AddRdbColumn_001
173 * @tc.desc: AddRdbColumn
174 * @tc.type: FUNC
175 * @tc.require: issuesI9Q9ZJ
176 */
177 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_AddRdbColumn_001,
178 Function | MediumTest | Level0)
179 {
180 auto database = std::make_shared<BundleActiveUsageDatabase>();
181 std::shared_ptr<NativeRdb::RdbStore> store = database->GetBundleActiveRdbStore(0);
182 database->AddRdbColumn(store, "test", "testColumn", "INTERGER");
183 EXPECT_NE(database, nullptr);
184 }
185
186 /*
187 * @tc.name: BundleActiveUsageDatabaseTest_UpdateOldDataUid_001
188 * @tc.desc: UpdateOldDataUid
189 * @tc.type: FUNC
190 * @tc.require: issuesI9Q9ZJ
191 */
192 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_UpdateOldDataUid_001,
193 Function | MediumTest | Level0)
194 {
195 std::map<std::string, int32_t> bundleNameUidMap;
196 bundleNameUidMap["111"] = 111;
197 bundleNameUidMap["222"] = 222;
198 auto database = std::make_shared<BundleActiveUsageDatabase>();
199 std::shared_ptr<NativeRdb::RdbStore> store = database->GetBundleActiveRdbStore(0);
200 database->UpdateOldDataUid(store, "test", 100, bundleNameUidMap);
201 EXPECT_NE(database, nullptr);
202 }
203
204 /*
205 * @tc.name: BundleActiveUsageDatabaseTest_CreateRecordTable_001
206 * @tc.desc: CreateRecordTable
207 * @tc.type: FUNC
208 * @tc.require: issuesI9Q9ZJ
209 */
210 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_CreateRecordTable_001,
211 Function | MediumTest | Level0)
212 {
213 int64_t timeStamp = 10000;
214 auto database = std::make_shared<BundleActiveUsageDatabase>();
215 database->moduleRecordsTableName_ = "unknownTableName";
216 database->formRecordsTableName_ = "unknownTableName";
217 database->CreateRecordTable(timeStamp);;
218 EXPECT_NE(database, nullptr);
219 }
220
221 /*
222 * @tc.name: BundleActiveUsageDatabaseTest_GetQuerySqlCommand_001
223 * @tc.desc: GetQuerySqlCommand
224 * @tc.type: FUNC
225 * @tc.require: issuesI9Q9ZJ
226 */
227 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_GetQuerySqlCommand_001,
228 Function | MediumTest | Level0)
229 {
230 std::vector<std::string> queryCondition;
231 std::string queryPackageSql;
232 auto database = std::make_shared<BundleActiveUsageDatabase>();
233 database->sortedTableArray_ = {{0}, {1}, {2}};
234 database->GetQuerySqlCommand(0, 1, 2, 0, 0, 1, 10, queryCondition, queryPackageSql);
235 EXPECT_TRUE(!queryPackageSql.empty());
236 }
237
238 /*
239 * @tc.name: BundleActiveUtil_001
240 * @tc.desc: CreateRecordTable
241 * @tc.type: FUNC
242 * @tc.require: issuesI9Q9ZJ
243 */
244 HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUtil_001,
245 Function | MediumTest | Level0)
246 {
247 int32_t result = BundleActiveUtil::StringToInt32("11");
248 EXPECT_EQ(result, 11);
249 int64_t resultInt64 = BundleActiveUtil::StringToInt64("11");
250 EXPECT_EQ(resultInt64, 11);
251 }
252 } // namespace DeviceUsageStats
253 } // namespace OHOS