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 
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 #undef private
34 #undef protected
35 
36 using namespace testing;
37 using namespace testing::ext;
38 using namespace OHOS::Security::SecurityGuard;
39 using namespace OHOS::Security::SecurityGuardTest;
40 
41 namespace OHOS {
42     std::shared_ptr<NativeRdb::MockRdbHelperInterface> NativeRdb::RdbHelper::instance_ = nullptr;
43     std::shared_ptr<AccountSA::MockOsAccountManagerInterface> AccountSA::OsAccountManager::instance_ = nullptr;
44     std::mutex NativeRdb::RdbHelper::mutex_ {};
45     std::mutex AccountSA::OsAccountManager::mutex_ {};
46 }
47 
48 namespace OHOS::Security::SecurityGuardTest {
49 namespace {
50     constexpr int SUCCESS = 0;
51 }
52 
53 class MockDbListener : public IDbListener {
54 public:
55     ~MockDbListener() override = default;
56     MOCK_METHOD2(OnChange, void(uint32_t optType, const SecEvent &events));
57 };
58 
SetUpTestCase()59 void SecurityGuardDatabaseManagerTest::SetUpTestCase()
60 {
61 }
62 
TearDownTestCase()63 void SecurityGuardDatabaseManagerTest::TearDownTestCase()
64 {
65 }
66 
SetUp()67 void SecurityGuardDatabaseManagerTest::SetUp()
68 {
69 }
70 
TearDown()71 void SecurityGuardDatabaseManagerTest::TearDown()
72 {
73 }
74 
75 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock006, TestSize.Level1)
76 {
77     uint32_t source = 0;
78     SecEvent event{};
79     event.eventId = 1011015001;
80     EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillOnce(
81         Return(false)).WillOnce(
__anoneb9782dd0202(int64_t eventId, EventCfg &config) 82             [] (int64_t eventId, EventCfg &config) {
83                 config.source = 1;
84                 return true;
85             }
86         ).WillRepeatedly(
__anoneb9782dd0302(int64_t eventId, EventCfg &config) 87             [] (int64_t eventId, EventCfg &config) {
88                 config.source = 0;
89                 return true;
90             });
91     int ret = DatabaseManager::GetInstance().InsertEvent(source, event);
92     EXPECT_EQ(ret, NOT_FOUND);
93     ret = DatabaseManager::GetInstance().InsertEvent(source, event);
94     EXPECT_EQ(ret, SUCCESS);
95     EXPECT_CALL(ConfigDataManager::GetInstance(), GetTableFromEventId).WillOnce(Return("audit_event"));
96     ret = DatabaseManager::GetInstance().InsertEvent(source, event);
97     EXPECT_EQ(ret, NOT_SUPPORT);
98 }
99 
100 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock008, TestSize.Level1)
101 {
102     uint32_t source = 0;
103     SecEvent event{};
104     EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(
__anoneb9782dd0402(int64_t eventId, EventCfg &config) 105         [] (int64_t eventId, EventCfg &config) {
106             config.source = 0;
107             config.storageRomNums = 1;
108             return true;
109         });
110     EXPECT_CALL(ConfigDataManager::GetInstance(), GetTableFromEventId).WillRepeatedly(Return("risk_event"));
111     EXPECT_CALL(*(AccountSA::OsAccountManager::GetInterface()), QueryActiveOsAccountIds).WillRepeatedly(
112         Return(SUCCESS));
113     EXPECT_CALL(RiskEventRdbHelper::GetInstance(), CountEventByEventId).WillOnce(Return(0)).WillOnce(Return(1));
114     EXPECT_CALL(RiskEventRdbHelper::GetInstance(), InsertEvent).WillRepeatedly(Return(SUCCESS));
115     EXPECT_CALL(RiskEventRdbHelper::GetInstance(), DeleteOldEventByEventId).WillOnce(Return(SUCCESS));
116     int ret = DatabaseManager::GetInstance().InsertEvent(source, event);
117     EXPECT_EQ(ret, SUCCESS);
118     ret = DatabaseManager::GetInstance().InsertEvent(source, event);
119     EXPECT_EQ(ret, SUCCESS);
120     AccountSA::OsAccountManager::DelInterface();
121 }
122 
123 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock009, TestSize.Level1)
124 {
125     EXPECT_CALL(RiskEventRdbHelper::GetInstance(), QueryAllEvent).WillOnce(Return(SUCCESS));
126     std::vector<SecEvent> events;
127     int ret = DatabaseManager::GetInstance().QueryAllEvent("risk_event", events);
128     EXPECT_EQ(ret, SUCCESS);
129     ret = DatabaseManager::GetInstance().QueryAllEvent("", events);
130     EXPECT_EQ(ret, NOT_SUPPORT);
131 }
132 
133 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock011, TestSize.Level1)
134 {
135     EXPECT_CALL(RiskEventRdbHelper::GetInstance(), QueryRecentEventByEventId(
136         An<int64_t>(), An<SecEvent &>())).WillOnce(Return(SUCCESS));
137     EXPECT_CALL(ConfigDataManager::GetInstance(), GetTableFromEventId).WillOnce(Return("audit_event")).WillOnce(
138         Return("risk_event")).WillOnce(Return(""));
139     int64_t eventId = 0;
140     SecEvent event;
141     int ret = DatabaseManager::GetInstance().QueryRecentEventByEventId(eventId, event);
142     EXPECT_EQ(ret, SUCCESS);
143     ret = DatabaseManager::GetInstance().QueryRecentEventByEventId(eventId, event);
144     EXPECT_EQ(ret, SUCCESS);
145     ret = DatabaseManager::GetInstance().QueryRecentEventByEventId(eventId, event);
146     EXPECT_EQ(ret, NOT_SUPPORT);
147 }
148 
149 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock012, TestSize.Level1)
150 {
151     EXPECT_CALL(RiskEventRdbHelper::GetInstance(), QueryRecentEventByEventId(
152         An<const std::vector<int64_t> &>(), An<std::vector<SecEvent> &>())).WillOnce(Return(SUCCESS));
153     std::vector<int64_t> eventIds{};
154     std::vector<SecEvent> events{};
155     int ret = DatabaseManager::GetInstance().QueryRecentEventByEventId("audit_event", eventIds, events);
156     EXPECT_EQ(ret, SUCCESS);
157     ret = DatabaseManager::GetInstance().QueryRecentEventByEventId("risk_event", eventIds, events);
158     EXPECT_EQ(ret, SUCCESS);
159     ret = DatabaseManager::GetInstance().QueryRecentEventByEventId("", eventIds, events);
160     EXPECT_EQ(ret, NOT_SUPPORT);
161 }
162 
163 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock013, TestSize.Level1)
164 {
165     EXPECT_CALL(RiskEventRdbHelper::GetInstance(), QueryEventByEventIdAndDate).WillOnce(Return(SUCCESS));
166     std::vector<int64_t> eventIds{};
167     std::vector<SecEvent> events{};
168     std::string data;
169     int ret = DatabaseManager::GetInstance().QueryEventByEventIdAndDate("audit_event", eventIds, events, data, data);
170     EXPECT_EQ(ret, SUCCESS);
171     ret = DatabaseManager::GetInstance().QueryEventByEventIdAndDate("risk_event", eventIds, events, data, data);
172     EXPECT_EQ(ret, SUCCESS);
173     ret = DatabaseManager::GetInstance().QueryEventByEventIdAndDate("", eventIds, events, data, data);
174     EXPECT_EQ(ret, NOT_SUPPORT);
175 }
176 
177 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock014, TestSize.Level1)
178 {
179     EXPECT_CALL(RiskEventRdbHelper::GetInstance(), QueryEventByEventId(
180         An<int64_t>(), An<std::vector<SecEvent> &>())).WillOnce(Return(SUCCESS));
181     EXPECT_CALL(ConfigDataManager::GetInstance(), GetTableFromEventId).WillOnce(Return("audit_event")).WillOnce(
182         Return("risk_event")).WillOnce(Return(""));
183     int64_t eventId = 0;
184     std::vector<SecEvent> events{};
185     int ret = DatabaseManager::GetInstance().QueryEventByEventId(eventId, events);
186     EXPECT_EQ(ret, SUCCESS);
187     ret = DatabaseManager::GetInstance().QueryEventByEventId(eventId, events);
188     EXPECT_EQ(ret, SUCCESS);
189     ret = DatabaseManager::GetInstance().QueryEventByEventId(eventId, events);
190     EXPECT_EQ(ret, NOT_SUPPORT);
191 }
192 
193 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock015, TestSize.Level1)
194 {
195     EXPECT_CALL(RiskEventRdbHelper::GetInstance(), QueryEventByEventId(
196         An<std::vector<int64_t> &>(), An<std::vector<SecEvent> &>())).WillOnce(Return(SUCCESS));
197     std::vector<int64_t> eventIds{};
198     std::vector<SecEvent> events{};
199     int ret = DatabaseManager::GetInstance().QueryEventByEventId("audit_event", eventIds, events);
200     EXPECT_EQ(ret, SUCCESS);
201     ret = DatabaseManager::GetInstance().QueryEventByEventId("risk_event", eventIds, events);
202     EXPECT_EQ(ret, SUCCESS);
203     ret = DatabaseManager::GetInstance().QueryEventByEventId("", eventIds, events);
204     EXPECT_EQ(ret, NOT_SUPPORT);
205 }
206 
207 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock016, TestSize.Level1)
208 {
209     EXPECT_CALL(RiskEventRdbHelper::GetInstance(), QueryEventByEventType).WillOnce(Return(SUCCESS));
210     int32_t eventType = 0;
211     std::vector<SecEvent> events{};
212     int ret = DatabaseManager::GetInstance().QueryEventByEventType("audit_event", eventType, events);
213     EXPECT_EQ(ret, SUCCESS);
214     ret = DatabaseManager::GetInstance().QueryEventByEventType("risk_event", eventType, events);
215     EXPECT_EQ(ret, SUCCESS);
216     ret = DatabaseManager::GetInstance().QueryEventByEventType("", eventType, events);
217     EXPECT_EQ(ret, NOT_SUPPORT);
218 }
219 
220 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock017, TestSize.Level1)
221 {
222     EXPECT_CALL(RiskEventRdbHelper::GetInstance(), QueryEventByLevel).WillOnce(Return(SUCCESS));
223     int32_t level = 0;
224     std::vector<SecEvent> events{};
225     int ret = DatabaseManager::GetInstance().QueryEventByLevel("audit_event", level, events);
226     EXPECT_EQ(ret, SUCCESS);
227     ret = DatabaseManager::GetInstance().QueryEventByLevel("risk_event", level, events);
228     EXPECT_EQ(ret, SUCCESS);
229     ret = DatabaseManager::GetInstance().QueryEventByLevel("", level, events);
230     EXPECT_EQ(ret, NOT_SUPPORT);
231 }
232 
233 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock018, TestSize.Level1)
234 {
235     EXPECT_CALL(RiskEventRdbHelper::GetInstance(), QueryEventByOwner).WillOnce(Return(SUCCESS));
236     std::string owner;
237     std::vector<SecEvent> events{};
238     int ret = DatabaseManager::GetInstance().QueryEventByOwner("audit_event", owner, events);
239     EXPECT_EQ(ret, SUCCESS);
240     ret = DatabaseManager::GetInstance().QueryEventByOwner("risk_event", owner, events);
241     EXPECT_EQ(ret, SUCCESS);
242     ret = DatabaseManager::GetInstance().QueryEventByOwner("", owner, events);
243     EXPECT_EQ(ret, NOT_SUPPORT);
244 }
245 
246 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock019, TestSize.Level1)
247 {
248     EXPECT_CALL(RiskEventRdbHelper::GetInstance(), CountAllEvent).WillOnce(Return(1));
249     int ret = DatabaseManager::GetInstance().CountAllEvent("risk_event");
250     EXPECT_EQ(ret, 1);
251     ret = DatabaseManager::GetInstance().CountAllEvent("");
252     EXPECT_EQ(ret, 0);
253 }
254 
255 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock020, TestSize.Level1)
256 {
257     EXPECT_CALL(RiskEventRdbHelper::GetInstance(), CountEventByEventId).WillOnce(Return(1));
258     EXPECT_CALL(ConfigDataManager::GetInstance(), GetTableFromEventId).WillOnce(
259         Return("risk_event")).WillOnce(Return(""));
260     int64_t eventId = 0;
261     int ret = DatabaseManager::GetInstance().CountEventByEventId(eventId);
262     EXPECT_EQ(ret, 1);
263     ret = DatabaseManager::GetInstance().CountEventByEventId(eventId);
264     EXPECT_EQ(ret, 0);
265 }
266 
267 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock021, TestSize.Level1)
268 {
269     EXPECT_CALL(RiskEventRdbHelper::GetInstance(), DeleteOldEventByEventId).WillOnce(Return(SUCCESS));
270     EXPECT_CALL(ConfigDataManager::GetInstance(), GetTableFromEventId).WillOnce(Return("audit_event")).WillOnce(
271         Return("risk_event")).WillOnce(Return(""));
272     int64_t eventId = 0;
273     int64_t count = 0;
274     int ret = DatabaseManager::GetInstance().DeleteOldEventByEventId(eventId, count);
275     EXPECT_EQ(ret, SUCCESS);
276     ret = DatabaseManager::GetInstance().DeleteOldEventByEventId(eventId, count);
277     EXPECT_EQ(ret, SUCCESS);
278     ret = DatabaseManager::GetInstance().DeleteOldEventByEventId(eventId, count);
279     EXPECT_EQ(ret, NOT_SUPPORT);
280 }
281 
282 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock022, TestSize.Level1)
283 {
284     EXPECT_CALL(RiskEventRdbHelper::GetInstance(), DeleteAllEventByEventId).WillOnce(Return(SUCCESS));
285     EXPECT_CALL(ConfigDataManager::GetInstance(), GetTableFromEventId).WillOnce(Return("audit_event")).WillOnce(
286         Return("risk_event")).WillOnce(Return(""));
287     int64_t eventId = 0;
288     int ret = DatabaseManager::GetInstance().DeleteAllEventByEventId(eventId);
289     EXPECT_EQ(ret, SUCCESS);
290     ret = DatabaseManager::GetInstance().DeleteAllEventByEventId(eventId);
291     EXPECT_EQ(ret, SUCCESS);
292     ret = DatabaseManager::GetInstance().DeleteAllEventByEventId(eventId);
293     EXPECT_EQ(ret, NOT_SUPPORT);
294 }
295 
296 HWTEST_F(SecurityGuardDatabaseManagerTest, TestDatabaseManagerMock023, TestSize.Level1)
297 {
298     auto mockListener = std::make_shared<MockDbListener>();
299     EXPECT_CALL(*mockListener, OnChange).Times(Exactly(2));
300     std::vector<int64_t> eventIds{0, 1, 2, 3};
301     int ret = DatabaseManager::GetInstance().SubscribeDb(eventIds, nullptr);
302     EXPECT_EQ(ret, NULL_OBJECT);
303     ret = DatabaseManager::GetInstance().SubscribeDb(eventIds, mockListener);
304     EXPECT_EQ(ret, SUCCESS);
305     SecEvent event{};
306     event.eventId = 0;
307     DatabaseManager::GetInstance().DbChanged(1, event);
308     event.eventId = 1;
309     DatabaseManager::GetInstance().DbChanged(1, event);
310     event.eventId = 5;
311     DatabaseManager::GetInstance().DbChanged(1, event);
312     std::vector<int64_t> tmpEventIds{5, 6, 7, 8};
313     ret = DatabaseManager::GetInstance().UnSubscribeDb(eventIds, nullptr);
314     EXPECT_EQ(ret, NULL_OBJECT);
315     ret = DatabaseManager::GetInstance().UnSubscribeDb(tmpEventIds, mockListener);
316     EXPECT_EQ(ret, SUCCESS);
317     ret = DatabaseManager::GetInstance().UnSubscribeDb(eventIds, mockListener);
318     EXPECT_EQ(ret, SUCCESS);
319 }
320 }