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