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