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