1 /*
2 * Copyright (c) 2022 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 "system_ability_definition.h"
18
19 #include "bundle_active_client.h"
20 #include "bundle_active_event.h"
21 #include "bundle_active_service.h"
22 #include "bundle_active_group_map.h"
23 #include "app_group_callback_stub.h"
24 #include "app_group_callback_info.h"
25 #include "iapp_group_callback.h"
26 #include "bundle_active_constant.h"
27 #include "bundle_active_usage_database.h"
28
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace DeviceUsageStats {
33 static std::string g_defaultBundleName = "com.ohos.camera";
34 static std::string g_defaultMoudleName = "defaultmodulename";
35 static std::string g_defaultFormName = "defaultformname";
36 static int32_t g_defaultDimension = 4;
37 static int64_t g_defaultFormId = 1;
38 static int32_t g_defaultUserId = 0;
39 static int32_t g_commonUserid = 100;
40 static int64_t g_largeNum = 20000000000000;
41 static int32_t g_defaultGroup = 10;
42 static int32_t g_intervalType = 4;
43 static sptr<IAppGroupCallback> observer = nullptr;
44
45 class DeviceUsageStatisticsMockTest : public testing::Test {
46 public:
47 static void SetUpTestCase(void);
48 static void TearDownTestCase(void);
49 void SetUp();
50 void TearDown();
51 };
52
SetUpTestCase(void)53 void DeviceUsageStatisticsMockTest::SetUpTestCase(void)
54 {
55 }
56
TearDownTestCase(void)57 void DeviceUsageStatisticsMockTest::TearDownTestCase(void)
58 {
59 }
60
SetUp(void)61 void DeviceUsageStatisticsMockTest::SetUp(void)
62 {
63 }
64
TearDown(void)65 void DeviceUsageStatisticsMockTest::TearDown(void)
66 {
67 }
68
69 /*
70 * @tc.name: DeviceUsageStatisticsMockTest_GetBundleActiveProxy_001
71 * @tc.desc: test client getBundleActiveProxy boundary condition
72 * @tc.type: FUNC
73 * @tc.require: issuesI5SOZY
74 */
75 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_GetBundleActiveProxy_001,
76 Function | MediumTest | Level0)
77 {
78 BundleActiveEvent eventA(g_defaultBundleName, g_defaultMoudleName, g_defaultFormName,
79 g_defaultDimension, g_defaultFormId, BundleActiveEvent::FORM_IS_CLICKED);
80 EXPECT_NE(BundleActiveClient::GetInstance().ReportEvent(eventA, g_defaultUserId), ERR_OK);
81
82 bool isIdle = false;
83 EXPECT_NE(BundleActiveClient::GetInstance().IsBundleIdle(isIdle, g_defaultBundleName, g_defaultUserId), ERR_OK);
84
85 std::vector<BundleActivePackageStats> packageStats;
86 EXPECT_NE(BundleActiveClient::GetInstance().QueryBundleStatsInfoByInterval(packageStats,
87 g_intervalType, 0, g_largeNum), ERR_OK);
88 EXPECT_NE(BundleActiveClient::GetInstance().QueryBundleStatsInfos(packageStats,
89 g_intervalType, 0, g_largeNum), ERR_OK);
90
91 std::vector<BundleActiveEvent> event;
92 EXPECT_NE(BundleActiveClient::GetInstance().QueryBundleEvents(event, 0, g_largeNum, 100), ERR_OK);
93 EXPECT_NE(BundleActiveClient::GetInstance().QueryCurrentBundleEvents(event, 0, g_largeNum), ERR_OK);
94
95 int32_t result = 0;
96 EXPECT_NE(BundleActiveClient::GetInstance().QueryAppGroup(result, g_defaultBundleName, g_commonUserid), ERR_OK);
97
98 EXPECT_NE(BundleActiveClient::GetInstance().SetAppGroup(
99 g_defaultBundleName, g_defaultGroup, g_commonUserid), ERR_OK);
100
101 EXPECT_NE(BundleActiveClient::GetInstance().RegisterAppGroupCallBack(observer), ERR_OK);
102 EXPECT_NE(BundleActiveClient::GetInstance().UnRegisterAppGroupCallBack(observer), ERR_OK);
103
104 std::vector<BundleActiveEventStats> eventStats;
105 EXPECT_NE(BundleActiveClient::GetInstance().QueryDeviceEventStats(0, g_largeNum, eventStats), ERR_OK);
106 EXPECT_NE(BundleActiveClient::GetInstance().QueryNotificationEventStats(0, g_largeNum, eventStats), ERR_OK);
107
108 std::vector<BundleActiveModuleRecord> moduleRecord;
109 int32_t maxNum = 1000;
110 EXPECT_NE(BundleActiveClient::GetInstance().QueryModuleUsageRecords(maxNum, moduleRecord, g_defaultUserId), ERR_OK);
111 }
112
113 /*
114 * @tc.name: DeviceUsageStatisticsMockTest_GetBundleMgrProxy_001
115 * @tc.desc: test service getBundleMgrProxy boundary condition
116 * @tc.type: FUNC
117 * @tc.require: issuesI5SOZY
118 */
119 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_GetBundleMgrProxy_001,
120 Function | MediumTest | Level0)
121 {
122 std::string bundleName;
123 bool isBundleIdle = false;
124 ErrCode code = DelayedSingleton<BundleActiveService>::GetInstance()->IsBundleIdle(isBundleIdle, bundleName, -1);
125 EXPECT_NE(code, ERR_OK);
126
127 code = DelayedSingleton<BundleActiveService>::GetInstance()->CheckBundleIsSystemAppAndHasPermission(100, 100000);
128 EXPECT_NE(code, ERR_OK);
129 }
130
131 /*
132 * @tc.name: DeviceUsageStatisticsMockTest_QueryDeviceEventStats_001
133 * @tc.desc: test service queryDeviceEventStats boundary condition
134 * @tc.type: FUNC
135 * @tc.require: issuesI5SOZY
136 */
137 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_QueryDeviceEventStats_001,
138 Function | MediumTest | Level0)
139 {
140 std::vector<BundleActiveEventStats> eventStats;
141 ErrCode code =
142 DelayedSingleton<BundleActiveService>::GetInstance()->QueryDeviceEventStats(0, g_largeNum, eventStats, -1);
143 EXPECT_NE(code, ERR_OK);
144 }
145
146 /*
147 * @tc.name: DeviceUsageStatisticsMockTest_QueryNotificationEventStats_001
148 * @tc.desc: test service queryNotificationEventStats boundary condition
149 * @tc.type: FUNC
150 * @tc.require: issuesI5SOZY
151 */
152 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_QueryNotificationEventStats_001,
153 Function | MediumTest | Level0)
154 {
155 std::vector<BundleActiveEventStats> eventStats;
156 ErrCode code = DelayedSingleton<BundleActiveService>::GetInstance()->QueryNotificationEventStats(
157 0, g_largeNum, eventStats, -1);
158 EXPECT_NE(code, ERR_OK);
159 }
160
161 /*
162 * @tc.name: DeviceUsageStatisticsMockTest_QueryModuleUsageRecords_001
163 * @tc.desc: test service queryModuleUsageRecords boundary condition
164 * @tc.type: FUNC
165 * @tc.require: issuesI5SOZY
166 */
167 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_QueryModuleUsageRecords_001,
168 Function | MediumTest | Level0)
169 {
170 std::vector<BundleActiveModuleRecord> records;
171 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->QueryModuleUsageRecords(1000, records, -1), ERR_OK);
172
173 BundleActiveModuleRecord bundleActiveModuleRecord;
174 DelayedSingleton<BundleActiveService>::GetInstance()->QueryModuleRecordInfos(bundleActiveModuleRecord);
175 }
176
177 /*
178 * @tc.name: DeviceUsageStatisticsMockTest_QueryAppGroup_001
179 * @tc.desc: test service queryAppGroup boundary condition
180 * @tc.type: FUNC
181 * @tc.require: issuesI5SOZY
182 */
183 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_QueryAppGroup_001,
184 Function | MediumTest | Level0)
185 {
186 int32_t appGroup;
187 std::string bundleName;
188 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->QueryAppGroup(appGroup, bundleName, -1), ERR_OK);
189 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->QueryAppGroup(appGroup, bundleName, 100), ERR_OK);
190 }
191
192 /*
193 * @tc.name: DeviceUsageStatisticsMockTest_SetAppGroup_001
194 * @tc.desc: test service SetAppGroup boundary condition
195 * @tc.type: FUNC
196 * @tc.require: issuesI5SOZY
197 */
198 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_SetAppGroup_001,
199 Function | MediumTest | Level0)
200 {
201 int32_t appGroup = 100;
202 std::string bundleName;
203 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->SetAppGroup(bundleName, appGroup, -1), ERR_OK);
204 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->SetAppGroup(bundleName, appGroup, 100), ERR_OK);
205 }
206
207 /*
208 * @tc.name: DeviceUsageStatisticsMockTest_AppGroupCallback_001
209 * @tc.desc: test service appGroupCallback boundary condition
210 * @tc.type: FUNC
211 * @tc.require: issuesI5SOZY
212 */
213 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_AppGroupCallback_001,
214 Function | MediumTest | Level0)
215 {
216 sptr<IAppGroupCallback> observer = nullptr;
217 DelayedSingleton<BundleActiveService>::GetInstance()->bundleActiveCore_ = nullptr;
218 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->RegisterAppGroupCallBack(observer), ERR_OK);
219 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->UnRegisterAppGroupCallBack(observer), ERR_OK);
220 }
221
222 /*
223 * @tc.name: DeviceUsageStatisticsMockTest_QueryBundleEvents_001
224 * @tc.desc: test service queryBundleEvents boundary condition
225 * @tc.type: FUNC
226 * @tc.require: issuesI5SOZY
227 */
228 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_QueryBundleEvents_001,
229 Function | MediumTest | Level0)
230 {
231 std::vector<BundleActiveEvent> bundleActiveEvents;
232 ErrCode code = DelayedSingleton<BundleActiveService>::GetInstance()
233 ->QueryBundleEvents(bundleActiveEvents, 0, g_largeNum, -1);
234 EXPECT_NE(code, ERR_OK);
235 code = DelayedSingleton<BundleActiveService>::GetInstance()
236 ->QueryCurrentBundleEvents(bundleActiveEvents, 0, g_largeNum);
237 EXPECT_NE(code, ERR_OK);
238 }
239
240 /*
241 * @tc.name: DeviceUsageStatisticsMockTest_QueryBundleStatsInfoByInterval_001
242 * @tc.desc: test service queryBundleStatsInfoByInterval boundary condition
243 * @tc.type: FUNC
244 * @tc.require: issuesI5SOZY
245 */
246 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_QueryBundleStatsInfoByInterval_001,
247 Function | MediumTest | Level0)
248 {
249 std::vector<BundleActivePackageStats> packageStats;
250 ErrCode code = DelayedSingleton<BundleActiveService>::GetInstance()
251 ->QueryBundleStatsInfoByInterval(packageStats, 0, 0, g_largeNum, -1);
252 EXPECT_NE(code, ERR_OK);
253 }
254
255 /*
256 * @tc.name: DeviceUsageStatisticsMockTest_QueryBundleStatsInfos_001
257 * @tc.desc: test service queryBundleStatsInfos boundary condition
258 * @tc.type: FUNC
259 * @tc.require: issuesI5SOZY
260 */
261 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_QueryBundleStatsInfos_001,
262 Function | MediumTest | Level0)
263 {
264 std::vector<BundleActivePackageStats> packageStats;
265 ErrCode code = DelayedSingleton<BundleActiveService>::GetInstance()
266 ->QueryBundleStatsInfos(packageStats, 0, 0, g_largeNum);
267 EXPECT_NE(code, ERR_OK);
268 }
269
270 /*
271 * @tc.name: DeviceUsageStatisticsMockTest_QueryBundleStatsInfos_001
272 * @tc.desc: test service queryBundleStatsInfos boundary condition
273 * @tc.type: FUNC
274 * @tc.require: issuesI5SOZY
275 */
276 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_CheckTimeChangeAndGetWallTime_001,
277 Function | MediumTest | Level0)
278 {
279 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
280
281 BundleActiveEvent event;
282 event.bundleName_ = "com.ohos.settings";
283 int32_t userId = 101;
284 EXPECT_NE(bundleActiveCore->ReportEvent(event, userId), ERR_OK);
285
286 EXPECT_NE(bundleActiveCore->ReportEventToAllUserId(event), ERR_OK);
287
288 std::vector<BundleActiveEventStats> eventStats;
289 EXPECT_NE(bundleActiveCore->QueryNotificationEventStats(0, g_largeNum, eventStats, g_defaultUserId), ERR_OK);
290 EXPECT_NE(bundleActiveCore->QueryDeviceEventStats(0, g_largeNum, eventStats, g_defaultUserId), ERR_OK);
291
292 std::vector<BundleActiveModuleRecord> moduleRecords;
293 EXPECT_NE(bundleActiveCore->QueryModuleUsageRecords(1000, moduleRecords, g_defaultUserId), ERR_OK);
294
295 std::vector<BundleActiveEvent> activeEvent;
296 ErrCode code = bundleActiveCore->QueryBundleEvents(
297 activeEvent, g_defaultUserId, 0, g_largeNum, g_defaultBundleName);
298 EXPECT_NE(code, ERR_OK);
299
300 std::vector<BundleActivePackageStats> packageStats;
301 code = bundleActiveCore->QueryBundleStatsInfos(
302 packageStats, g_defaultUserId, g_intervalType, 0, g_largeNum, g_defaultBundleName);
303 EXPECT_NE(code, ERR_OK);
304
305 BundleActiveEvent eventTemp;
306 EXPECT_NE(bundleActiveCore->ReportEventToAllUserId(eventTemp), ERR_OK);
307 int32_t uid = 0;
308 int32_t appIndex = 0;
309 bundleActiveCore->OnBundleUninstalled(g_defaultUserId, g_defaultBundleName, uid, appIndex);
310
311 EXPECT_NE(bundleActiveCore->QueryNotificationEventStats(0, g_largeNum, eventStats, g_commonUserid), ERR_OK);
312 EXPECT_NE(bundleActiveCore->QueryDeviceEventStats(0, g_largeNum, eventStats, g_commonUserid), ERR_OK);
313 EXPECT_NE(bundleActiveCore->QueryModuleUsageRecords(1000, moduleRecords, g_commonUserid), ERR_OK);
314
315 code = bundleActiveCore->QueryBundleEvents(activeEvent, g_commonUserid, 0, g_largeNum, g_defaultBundleName);
316 EXPECT_NE(code, ERR_OK);
317
318 code = bundleActiveCore->QueryBundleStatsInfos(packageStats, g_commonUserid,
319 g_intervalType, 0, g_largeNum, g_defaultBundleName);
320 EXPECT_NE(code, ERR_OK);
321
322 bundleActiveCore->OnBundleUninstalled(g_commonUserid, g_defaultBundleName, uid, appIndex);
323 }
324
325 /*
326 * @tc.name: DeviceUsageStatisticsMockTest_getUserHistory_001
327 * @tc.desc: test service getUserHistory boundary condition
328 * @tc.type: FUNC
329 * @tc.require: issuesI5SOZY
330 */
331 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_getUserHistory_001,
332 Function | MediumTest | Level0)
333 {
334 auto groupController = std::make_shared<BundleActiveGroupController>(false);
335 const int64_t timeStamp = g_largeNum;
336 int32_t uid = 0;
337 int32_t appIndex = 0;
338 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
339 groupController->bundleUserHistory_ = std::make_shared<BundleActiveUserHistory>(timeStamp, bundleActiveCore);
340
341 groupController->OnBundleUninstalled(0, g_defaultBundleName, uid, appIndex);
342 EXPECT_NE(groupController, nullptr);
343 }
344
345 /*
346 * @tc.name: DeviceUsageStatisticsMockTest_calculationTimeOut_001
347 * @tc.desc: test service calculationTimeOut boundary condition
348 * @tc.type: FUNC
349 * @tc.require: issuesI5SOZY
350 */
351 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_calculationTimeOut_001,
352 Function | MediumTest | Level0)
353 {
354 auto groupController = std::make_shared<BundleActiveGroupController>(false);
355
356 std::shared_ptr<BundleActivePackageHistory> history = nullptr;
357 groupController->calculationTimeOut(history, g_largeNum);
358 history = std::make_shared<BundleActivePackageHistory>();
359 groupController->calculationTimeOut(history, g_largeNum);
360 EXPECT_NE(groupController, nullptr);
361 }
362
363 /*
364 * @tc.name: DeviceUsageStatisticsMockTest_QueryStatsInfoByStep_001
365 * @tc.desc: test QueryStatsInfoByStep
366 * @tc.type: FUNC
367 * @tc.require: issuesI5SOZY
368 */
369 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_QueryStatsInfoByStep_001,
370 Function | MediumTest | Level0)
371 {
372 auto database = std::make_shared<BundleActiveUsageDatabase>();
373
374 int32_t databaseType = DAILY_DATABASE_INDEX;
375 bool forModuleRecords = true;
376 database->InitUsageGroupDatabase(databaseType, forModuleRecords);
377
378 database->HandleTableInfo(databaseType);
379 int64_t currentTimeMillis = 20000000000000;
380 database->GetOverdueTableCreateTime(databaseType, currentTimeMillis);
381
382 int32_t userId = 100;
383 database->GetBundleHistoryData(userId);
384
385 database->GetDurationData();
386
387 database->GetCurrentUsageData(databaseType, userId);
388
389 int64_t beginTime = 0;
390 int64_t endTime = 20000000000000;
391 database->QueryDatabaseUsageStats(databaseType, beginTime, endTime, userId);
392
393 std::string bundleName = "defaultBundleName";
394 database->QueryDatabaseEvents(beginTime, endTime, userId, bundleName);
395
396 std::map<std::string, std::shared_ptr<BundleActiveModuleRecord>> moduleRecords;
397 database->LoadModuleData(userId, moduleRecords);
398
399 database->LoadFormData(userId, moduleRecords);
400
401 std::map<std::string, BundleActiveEventStats> eventStats;
402 int32_t eventId = 2;
403 database->QueryDeviceEventStats(eventId, beginTime, endTime, eventStats, userId);
404
405 database->QueryNotificationEventStats(eventId, beginTime, endTime, eventStats, userId);
406 }
407
408 /*
409 * @tc.name: DeviceUsageStatisticsMockTest_GetBundleActiveRdbStore_001
410 * @tc.desc: test GetBundleActiveRdbStore
411 * @tc.type: FUNC
412 * @tc.require: issuesI5SOZY
413 */
414 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_GetBundleActiveRdbStore_001,
415 Function | MediumTest | Level0)
416 {
417 auto database = std::make_shared<BundleActiveUsageDatabase>();
418 int32_t databaseType = EVENT_DATABASE_INDEX;
419 database->DeleteExcessiveTableData(databaseType);
420 database->DeleteInvalidTable(databaseType, 0);
421 database->CreateEventLogTable(databaseType, 0);
422 database->CreatePackageLogTable(databaseType, 0);
423 database->CreateModuleRecordTable(databaseType, 0);
424 database->CreateFormRecordTable(databaseType, 0);
425 database->CreateDurationTable(databaseType);
426 database->CreateBundleHistoryTable(databaseType);
427
428 int32_t userId = 100;
429 auto userHistory = std::make_shared<std::map<std::string, std::shared_ptr<BundleActivePackageHistory>>>();
430 database->PutBundleHistoryData(userId, userHistory);
431
432 int64_t bootBasedDuration = 0;
433 int64_t screenOnDuration = 20000000000;
434 database->PutDurationData(bootBasedDuration, screenOnDuration);
435
436 BundleActivePeriodStats stats;
437 database->FlushPackageInfo(databaseType, stats);
438 database->FlushEventInfo(databaseType, stats);
439 database->RenameTableName(databaseType, 0, 0);
440 std::string bundleName = "defaultBundleName";
441 std::string tableName = "defaultTableName";
442 int32_t uid = 0;
443 int32_t appIndex = 0;
444 database->DeleteUninstalledInfo(userId, bundleName, uid, tableName, databaseType, appIndex);
445
446 auto moduleRecords = std::map<std::string, std::shared_ptr<BundleActiveModuleRecord>>();
447 int64_t timeStamp = 20000000000;
448 database->UpdateModuleData(userId, moduleRecords, timeStamp);
449
450 std::string moduleName = "defaultMoudleName";
451 std::string formName = "defaultFormName";
452 database->RemoveFormData(userId, bundleName, moduleName, formName, 0, 0, uid);
453 }
454 } // namespace DeviceUsageStats
455 } // namespace OHOS
456
457