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