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 "security_guard_database_manager_test.h"
17
18 #include "file_ex.h"
19 #include "gmock/gmock.h"
20 #include "security_event_info.h"
21 #define private public
22 #define protected public
23 #include "config_data_manager.h"
24 #include "database_manager.h"
25 #include "device_manager.h"
26 #include "i_db_listener.h"
27 #include "os_account_manager.h"
28 #include "rdb_helper.h"
29 #include "rdb_store.h"
30 #include "risk_event_rdb_helper.h"
31 #include "security_guard_define.h"
32 #include "security_guard_log.h"
33 #include "data_format.h"
34 #undef private
35 #undef protected
36
37 using namespace testing;
38 using namespace testing::ext;
39 using namespace OHOS::Security::SecurityGuard;
40 using namespace OHOS::Security::SecurityGuardTest;
41
42 namespace OHOS {
43 std::shared_ptr<NativeRdb::MockRdbHelperInterface> NativeRdb::RdbHelper::instance_ = nullptr;
44 std::shared_ptr<AccountSA::MockOsAccountManagerInterface> AccountSA::OsAccountManager::instance_ = nullptr;
45 std::mutex NativeRdb::RdbHelper::mutex_ {};
46 std::mutex AccountSA::OsAccountManager::mutex_ {};
47 constexpr uint32_t MAX_CONTENT_SIZE = 1500;
48 }
49
50 namespace OHOS::Security::SecurityGuardTest {
51 namespace {
52 constexpr int SUCCESS = 0;
53 }
54
55 class MockDbListener : public IDbListener {
56 public:
57 ~MockDbListener() override = default;
58 MOCK_METHOD3(OnChange, void(uint32_t optType, const SecEvent &events,
59 const std::set<std::string> &eventSubscribes));
60 };
61
SetUpTestCase()62 void SecurityGuardDatabaseManagerTest::SetUpTestCase()
63 {
64 }
65
TearDownTestCase()66 void SecurityGuardDatabaseManagerTest::TearDownTestCase()
67 {
68 }
69
SetUp()70 void SecurityGuardDatabaseManagerTest::SetUp()
71 {
72 }
73
TearDown()74 void SecurityGuardDatabaseManagerTest::TearDown()
75 {
76 }
77
78 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock006, TestSize.Level1)
79 {
80 uint32_t source = 0;
81 SecEvent event{};
82 event.eventId = 1011015001;
83 EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillOnce(
84 Return(false)).WillOnce(
__anon07b7bfe50202(int64_t eventId, EventCfg &config) 85 [] (int64_t eventId, EventCfg &config) {
86 config.source = 1;
87 return true;
88 }
89 ).WillRepeatedly(
__anon07b7bfe50302(int64_t eventId, EventCfg &config) 90 [] (int64_t eventId, EventCfg &config) {
91 config.source = 0;
92 return true;
93 });
94 int ret = DatabaseManager::GetInstance().InsertEvent(source, event);
95 EXPECT_EQ(ret, NOT_FOUND);
96 ret = DatabaseManager::GetInstance().InsertEvent(source, event);
97 EXPECT_EQ(ret, SUCCESS);
98 EXPECT_CALL(ConfigDataManager::GetInstance(), GetTableFromEventId).WillOnce(Return("audit_event"));
99 ret = DatabaseManager::GetInstance().InsertEvent(source, event);
100 EXPECT_EQ(ret, NOT_SUPPORT);
101 }
102
103 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock008, TestSize.Level1)
104 {
105 uint32_t source = 0;
106 SecEvent event{};
107 EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(
__anon07b7bfe50402(int64_t eventId, EventCfg &config) 108 [] (int64_t eventId, EventCfg &config) {
109 config.source = 0;
110 config.storageRomNums = 1;
111 return true;
112 });
113 EXPECT_CALL(ConfigDataManager::GetInstance(), GetTableFromEventId).WillRepeatedly(Return("risk_event"));
114 EXPECT_CALL(*(AccountSA::OsAccountManager::GetInterface()), QueryActiveOsAccountIds).WillRepeatedly(
115 Return(SUCCESS));
116 EXPECT_CALL(RiskEventRdbHelper::GetInstance(), CountEventByEventId).WillOnce(Return(0)).WillOnce(Return(1));
117 EXPECT_CALL(RiskEventRdbHelper::GetInstance(), InsertEvent).WillRepeatedly(Return(SUCCESS));
118 EXPECT_CALL(RiskEventRdbHelper::GetInstance(), DeleteOldEventByEventId).WillOnce(Return(SUCCESS));
119 int ret = DatabaseManager::GetInstance().InsertEvent(source, event);
120 EXPECT_EQ(ret, SUCCESS);
121 ret = DatabaseManager::GetInstance().InsertEvent(source, event);
122 EXPECT_EQ(ret, SUCCESS);
123 AccountSA::OsAccountManager::DelInterface();
124 }
125
126 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock009, TestSize.Level1)
127 {
128 EXPECT_CALL(RiskEventRdbHelper::GetInstance(), QueryAllEvent).WillOnce(Return(SUCCESS));
129 std::vector<SecEvent> events;
130 int ret = DatabaseManager::GetInstance().QueryAllEvent("risk_event", events);
131 EXPECT_EQ(ret, SUCCESS);
132 ret = DatabaseManager::GetInstance().QueryAllEvent("", events);
133 EXPECT_EQ(ret, NOT_SUPPORT);
134 }
135
136 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock011, TestSize.Level1)
137 {
138 EXPECT_CALL(RiskEventRdbHelper::GetInstance(), QueryRecentEventByEventId(
139 An<int64_t>(), An<SecEvent &>())).WillOnce(Return(SUCCESS));
140 EXPECT_CALL(ConfigDataManager::GetInstance(), GetTableFromEventId).WillOnce(Return("audit_event")).WillOnce(
141 Return("risk_event")).WillOnce(Return(""));
142 int64_t eventId = 0;
143 SecEvent event;
144 int ret = DatabaseManager::GetInstance().QueryRecentEventByEventId(eventId, event);
145 EXPECT_EQ(ret, SUCCESS);
146 ret = DatabaseManager::GetInstance().QueryRecentEventByEventId(eventId, event);
147 EXPECT_EQ(ret, SUCCESS);
148 ret = DatabaseManager::GetInstance().QueryRecentEventByEventId(eventId, event);
149 EXPECT_EQ(ret, NOT_SUPPORT);
150 }
151
152 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock012, TestSize.Level1)
153 {
154 EXPECT_CALL(RiskEventRdbHelper::GetInstance(), QueryRecentEventByEventId(
155 An<const std::vector<int64_t> &>(), An<std::vector<SecEvent> &>())).WillOnce(Return(SUCCESS));
156 std::vector<int64_t> eventIds{};
157 std::vector<SecEvent> events{};
158 int ret = DatabaseManager::GetInstance().QueryRecentEventByEventId("audit_event", eventIds, events);
159 EXPECT_EQ(ret, SUCCESS);
160 ret = DatabaseManager::GetInstance().QueryRecentEventByEventId("risk_event", eventIds, events);
161 EXPECT_EQ(ret, SUCCESS);
162 ret = DatabaseManager::GetInstance().QueryRecentEventByEventId("", eventIds, events);
163 EXPECT_EQ(ret, NOT_SUPPORT);
164 }
165
166 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock013, TestSize.Level1)
167 {
168 EXPECT_CALL(RiskEventRdbHelper::GetInstance(), QueryEventByEventIdAndDate).WillOnce(Return(SUCCESS));
169 std::vector<int64_t> eventIds{};
170 std::vector<SecEvent> events{};
171 std::string data;
172 int ret = DatabaseManager::GetInstance().QueryEventByEventIdAndDate("audit_event", eventIds, events, data, data);
173 EXPECT_EQ(ret, SUCCESS);
174 ret = DatabaseManager::GetInstance().QueryEventByEventIdAndDate("risk_event", eventIds, events, data, data);
175 EXPECT_EQ(ret, SUCCESS);
176 ret = DatabaseManager::GetInstance().QueryEventByEventIdAndDate("", eventIds, events, data, data);
177 EXPECT_EQ(ret, NOT_SUPPORT);
178 }
179
180 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock014, TestSize.Level1)
181 {
182 EXPECT_CALL(RiskEventRdbHelper::GetInstance(), QueryEventByEventId(
183 An<int64_t>(), An<std::vector<SecEvent> &>())).WillOnce(Return(SUCCESS));
184 EXPECT_CALL(ConfigDataManager::GetInstance(), GetTableFromEventId).WillOnce(Return("audit_event")).WillOnce(
185 Return("risk_event")).WillOnce(Return(""));
186 int64_t eventId = 0;
187 std::vector<SecEvent> events{};
188 int ret = DatabaseManager::GetInstance().QueryEventByEventId(eventId, events);
189 EXPECT_EQ(ret, SUCCESS);
190 ret = DatabaseManager::GetInstance().QueryEventByEventId(eventId, events);
191 EXPECT_EQ(ret, SUCCESS);
192 ret = DatabaseManager::GetInstance().QueryEventByEventId(eventId, events);
193 EXPECT_EQ(ret, NOT_SUPPORT);
194 }
195
196 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock015, TestSize.Level1)
197 {
198 EXPECT_CALL(RiskEventRdbHelper::GetInstance(), QueryEventByEventId(
199 An<std::vector<int64_t> &>(), An<std::vector<SecEvent> &>())).WillOnce(Return(SUCCESS));
200 std::vector<int64_t> eventIds{};
201 std::vector<SecEvent> events{};
202 int ret = DatabaseManager::GetInstance().QueryEventByEventId("audit_event", eventIds, events);
203 EXPECT_EQ(ret, SUCCESS);
204 ret = DatabaseManager::GetInstance().QueryEventByEventId("risk_event", eventIds, events);
205 EXPECT_EQ(ret, SUCCESS);
206 ret = DatabaseManager::GetInstance().QueryEventByEventId("", eventIds, events);
207 EXPECT_EQ(ret, NOT_SUPPORT);
208 }
209
210 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock016, TestSize.Level1)
211 {
212 EXPECT_CALL(RiskEventRdbHelper::GetInstance(), QueryEventByEventType).WillOnce(Return(SUCCESS));
213 int32_t eventType = 0;
214 std::vector<SecEvent> events{};
215 int ret = DatabaseManager::GetInstance().QueryEventByEventType("audit_event", eventType, events);
216 EXPECT_EQ(ret, SUCCESS);
217 ret = DatabaseManager::GetInstance().QueryEventByEventType("risk_event", eventType, events);
218 EXPECT_EQ(ret, SUCCESS);
219 ret = DatabaseManager::GetInstance().QueryEventByEventType("", eventType, events);
220 EXPECT_EQ(ret, NOT_SUPPORT);
221 }
222
223 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock017, TestSize.Level1)
224 {
225 EXPECT_CALL(RiskEventRdbHelper::GetInstance(), QueryEventByLevel).WillOnce(Return(SUCCESS));
226 int32_t level = 0;
227 std::vector<SecEvent> events{};
228 int ret = DatabaseManager::GetInstance().QueryEventByLevel("audit_event", level, events);
229 EXPECT_EQ(ret, SUCCESS);
230 ret = DatabaseManager::GetInstance().QueryEventByLevel("risk_event", level, events);
231 EXPECT_EQ(ret, SUCCESS);
232 ret = DatabaseManager::GetInstance().QueryEventByLevel("", level, events);
233 EXPECT_EQ(ret, NOT_SUPPORT);
234 }
235
236 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock018, TestSize.Level1)
237 {
238 EXPECT_CALL(RiskEventRdbHelper::GetInstance(), QueryEventByOwner).WillOnce(Return(SUCCESS));
239 std::string owner;
240 std::vector<SecEvent> events{};
241 int ret = DatabaseManager::GetInstance().QueryEventByOwner("audit_event", owner, events);
242 EXPECT_EQ(ret, SUCCESS);
243 ret = DatabaseManager::GetInstance().QueryEventByOwner("risk_event", owner, events);
244 EXPECT_EQ(ret, SUCCESS);
245 ret = DatabaseManager::GetInstance().QueryEventByOwner("", owner, events);
246 EXPECT_EQ(ret, NOT_SUPPORT);
247 }
248
249 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock019, TestSize.Level1)
250 {
251 EXPECT_CALL(RiskEventRdbHelper::GetInstance(), CountAllEvent).WillOnce(Return(1));
252 int ret = DatabaseManager::GetInstance().CountAllEvent("risk_event");
253 EXPECT_EQ(ret, 1);
254 ret = DatabaseManager::GetInstance().CountAllEvent("");
255 EXPECT_EQ(ret, 0);
256 }
257
258 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock020, TestSize.Level1)
259 {
260 EXPECT_CALL(RiskEventRdbHelper::GetInstance(), CountEventByEventId).WillOnce(Return(1));
261 EXPECT_CALL(ConfigDataManager::GetInstance(), GetTableFromEventId).WillOnce(
262 Return("risk_event")).WillOnce(Return(""));
263 int64_t eventId = 0;
264 int ret = DatabaseManager::GetInstance().CountEventByEventId(eventId);
265 EXPECT_EQ(ret, 1);
266 ret = DatabaseManager::GetInstance().CountEventByEventId(eventId);
267 EXPECT_EQ(ret, 0);
268 }
269
270 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock021, TestSize.Level1)
271 {
272 EXPECT_CALL(RiskEventRdbHelper::GetInstance(), DeleteOldEventByEventId).WillOnce(Return(SUCCESS));
273 EXPECT_CALL(ConfigDataManager::GetInstance(), GetTableFromEventId).WillOnce(Return("audit_event")).WillOnce(
274 Return("risk_event")).WillOnce(Return(""));
275 int64_t eventId = 0;
276 int64_t count = 0;
277 int ret = DatabaseManager::GetInstance().DeleteOldEventByEventId(eventId, count);
278 EXPECT_EQ(ret, SUCCESS);
279 ret = DatabaseManager::GetInstance().DeleteOldEventByEventId(eventId, count);
280 EXPECT_EQ(ret, SUCCESS);
281 ret = DatabaseManager::GetInstance().DeleteOldEventByEventId(eventId, count);
282 EXPECT_EQ(ret, NOT_SUPPORT);
283 }
284
285 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock022, TestSize.Level1)
286 {
287 EXPECT_CALL(RiskEventRdbHelper::GetInstance(), DeleteAllEventByEventId).WillOnce(Return(SUCCESS));
288 EXPECT_CALL(ConfigDataManager::GetInstance(), GetTableFromEventId).WillOnce(Return("audit_event")).WillOnce(
289 Return("risk_event")).WillOnce(Return(""));
290 int64_t eventId = 0;
291 int ret = DatabaseManager::GetInstance().DeleteAllEventByEventId(eventId);
292 EXPECT_EQ(ret, SUCCESS);
293 ret = DatabaseManager::GetInstance().DeleteAllEventByEventId(eventId);
294 EXPECT_EQ(ret, SUCCESS);
295 ret = DatabaseManager::GetInstance().DeleteAllEventByEventId(eventId);
296 EXPECT_EQ(ret, NOT_SUPPORT);
297 }
298
299 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock023, TestSize.Level1)
300 {
301 auto mockListener = std::make_shared<MockDbListener>();
302 EXPECT_CALL(*mockListener, OnChange).Times(Exactly(2));
303 std::vector<int64_t> eventIds{0, 1, 2, 3};
304 int ret = DatabaseManager::GetInstance().SubscribeDb(eventIds, nullptr);
305 EXPECT_EQ(ret, NULL_OBJECT);
306 ret = DatabaseManager::GetInstance().SubscribeDb(eventIds, mockListener);
307 EXPECT_EQ(ret, SUCCESS);
308 SecEvent event{};
309 event.eventId = 0;
310 DatabaseManager::GetInstance().DbChanged(1, event);
311 event.eventId = 1;
312 DatabaseManager::GetInstance().DbChanged(1, event);
313 event.eventId = 5;
314 DatabaseManager::GetInstance().DbChanged(1, event);
315 std::vector<int64_t> tmpEventIds{5, 6, 7, 8};
316 ret = DatabaseManager::GetInstance().UnSubscribeDb(eventIds, nullptr);
317 EXPECT_EQ(ret, NULL_OBJECT);
318 ret = DatabaseManager::GetInstance().UnSubscribeDb(tmpEventIds, mockListener);
319 EXPECT_EQ(ret, SUCCESS);
320 ret = DatabaseManager::GetInstance().UnSubscribeDb(eventIds, mockListener);
321 EXPECT_EQ(ret, SUCCESS);
322 }
323
324
325 HWTEST_F(SecurityGuardDatabaseManagerTest, CheckRiskContent001, TestSize.Level1)
326 {
327 std::string content(MAX_CONTENT_SIZE, 'c');
328 bool ret = DataFormat::CheckRiskContent(content);
329 EXPECT_FALSE(ret);
330 }
331
332 HWTEST_F(SecurityGuardDatabaseManagerTest, ParseConditions001, TestSize.Level1)
333 {
334 std::string conditions;
335 RequestCondition reqCondition;
336 DataFormat::ParseConditions(conditions, reqCondition);
337 EXPECT_TRUE(reqCondition.riskEvent.empty());
338 }
339
340 HWTEST_F(SecurityGuardDatabaseManagerTest, ParseConditions002, TestSize.Level1)
341 {
342 std::string conditions = "{\"eventId\":0}";
343 RequestCondition reqCondition;
344 DataFormat::ParseConditions(conditions, reqCondition);
345 EXPECT_TRUE(reqCondition.riskEvent.empty());
346 }
347
348 HWTEST_F(SecurityGuardDatabaseManagerTest, ParseConditions003, TestSize.Level1)
349 {
350 std::string conditions = "{\"eventId\":[\"t\", \"e\", \"s\", \"t\"]}";
351 RequestCondition reqCondition;
352 DataFormat::ParseConditions(conditions, reqCondition);
353 EXPECT_TRUE(reqCondition.riskEvent.empty());
354 }
355
356 HWTEST_F(SecurityGuardDatabaseManagerTest, ParseConditions004, TestSize.Level1)
357 {
358 std::string conditions = "{\"eventId\":[1, 2, 3, 4]}";
359 RequestCondition reqCondition;
360 EXPECT_CALL(ConfigDataManager::GetInstance(), GetTableFromEventId).WillOnce(Return("risk_event"))
361 .WillRepeatedly(Return("audit_event"));
362 DataFormat::ParseConditions(conditions, reqCondition);
363 EXPECT_FALSE(reqCondition.riskEvent.empty());
364 }
365
366 HWTEST_F(SecurityGuardDatabaseManagerTest, ParseConditions005, TestSize.Level1)
367 {
368 std::string conditions = "{\"beginTime\":1}";
369 RequestCondition reqCondition;
370 DataFormat::ParseConditions(conditions, reqCondition);
371 EXPECT_TRUE(reqCondition.beginTime.empty());
372 }
373
374 HWTEST_F(SecurityGuardDatabaseManagerTest, ParseConditions006, TestSize.Level1)
375 {
376 std::string conditions = "{\"beginTime\":\"0001\"}";
377 RequestCondition reqCondition;
378 DataFormat::ParseConditions(conditions, reqCondition);
379 EXPECT_TRUE(reqCondition.beginTime == "0001");
380 }
381
382 HWTEST_F(SecurityGuardDatabaseManagerTest, ParseConditions007, TestSize.Level1)
383 {
384 std::string conditions = "{\"endTime\":1}";
385 RequestCondition reqCondition;
386 DataFormat::ParseConditions(conditions, reqCondition);
387 EXPECT_TRUE(reqCondition.endTime.empty());
388 }
389
390 HWTEST_F(SecurityGuardDatabaseManagerTest, ParseConditions008, TestSize.Level1)
391 {
392 std::string conditions = "{\"endTime\":\"0001\"}";
393 RequestCondition reqCondition;
394 DataFormat::ParseConditions(conditions, reqCondition);
395 EXPECT_TRUE(reqCondition.endTime == "0001");
396 }
397
398 }