1 /*
2 * Copyright (c) 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 "collector_interface_test.h"
17
18 #define private public
19 #include "event_define.h"
20 #include "security_collector_subscribe_info.h"
21 #include "security_collector_run_manager.h"
22 #include "i_collector_subscriber.h"
23 #include "security_collector_define.h"
24 #include "collector_manager.h"
25 #include "security_guard_define.h"
26 #include "security_event_ruler.h"
27 #include "i_collector.h"
28 #undef private
29
30 namespace OHOS::Security::SecurityCollector {
31
OnNotify(const Event & event)32 int32_t CollectorSubscriberTestImpl::OnNotify(const Event &event)
33 {
34 return 0;
35 }
36
OnNotify(const Event & event)37 void CollectorFwkTestImpl::OnNotify(const Event &event)
38 {
39 }
40
41 }
42
43 namespace OHOS::Security::SecurityGuardTest {
44 class SecurityCollectorSubscriber : public SecurityCollector::ICollectorSubscriber {
45 public:
SecurityCollectorSubscriber(const SecurityCollector::Event & event)46 explicit SecurityCollectorSubscriber(
47 const SecurityCollector::Event &event) : SecurityCollector::ICollectorSubscriber(event) {};
48 ~SecurityCollectorSubscriber() override = default;
OnNotify(const SecurityCollector::Event & event)49 int32_t OnNotify(const SecurityCollector::Event &event) override
50 {
51 return 0;
52 };
53 };
54 class TestCollector : public SecurityCollector::ICollector {
55 public:
Start(std::shared_ptr<SecurityCollector::ICollectorFwk> api)56 int Start(std::shared_ptr<SecurityCollector::ICollectorFwk> api) override { return 0; };
Stop()57 int Stop() override { return 0; };
58 };
59
SetUpTestCase()60 void CollectorInterfaceTest::SetUpTestCase()
61 {
62 }
63
TearDownTestCase()64 void CollectorInterfaceTest::TearDownTestCase()
65 {
66 }
67
SetUp()68 void CollectorInterfaceTest::SetUp()
69 {
70 }
71
TearDown()72 void CollectorInterfaceTest::TearDown()
73 {
74 }
75
76 /**
77 * @tc.name: GetExtraInfo001
78 * @tc.desc: ICollectorFwk GetExtraInfo
79 * @tc.type: FUNC
80 * @tc.require: AR20240110334295
81 */
82 HWTEST_F(CollectorInterfaceTest, GetExtraInfo001, testing::ext::TestSize.Level1)
83 {
84 int64_t eventId = 1;
85 std::string version = "version";
86 std::string content = "content";
87 std::string extra = "extra";
88 SecurityCollector::Event event = {eventId, version, content, extra};
89 int64_t duration = 2;
90 const SecurityCollector::SecurityCollectorSubscribeInfo subscriberInfo{event, duration, true};
91 std::shared_ptr<SecurityCollector::SecurityCollectorSubscriber> subscriber =
92 std::make_shared<SecurityCollector::SecurityCollectorSubscriber>("appName", subscriberInfo, nullptr, nullptr);
93 SecurityCollector::SecurityCollectorRunManager::CollectorListenner listener =
94 SecurityCollector::SecurityCollectorRunManager::CollectorListenner(subscriber);
95 std::string result = listener.GetExtraInfo();
96 EXPECT_EQ(result, extra);
97 SecurityCollector::CollectorFwkTestImpl impl =
98 SecurityCollector::CollectorFwkTestImpl(subscriber);
99 result = impl.GetExtraInfo();
100 std::string extra1 = std::string();
101 EXPECT_EQ(result, extra1);
102 }
103
104 /**
105 * @tc.name: QuerySecurityEvent001
106 * @tc.desc: CollectorManager QuerySecurityEvent
107 * @tc.type: FUNC
108 * @tc.require: AR20240110334295
109 */
110 HWTEST_F(CollectorInterfaceTest, QuerySecurityEvent001, testing::ext::TestSize.Level1)
111 {
112 const std::vector<SecurityCollector::SecurityEventRuler> rules;
113 std::vector<SecurityCollector::SecurityEvent> events;
114 int ret = SecurityCollector::CollectorManager::GetInstance().QuerySecurityEvent(rules, events);
115 EXPECT_EQ(ret, SecurityCollector::BAD_PARAM);
116 }
117
118 /**
119 * @tc.name: GetSubscribeInfo001
120 * @tc.desc: ICollectorSubscriber GetSubscribeInfo
121 * @tc.type: FUNC
122 * @tc.require: AR000IENKB
123 */
124 HWTEST_F(CollectorInterfaceTest, GetSubscribeInfo001, testing::ext::TestSize.Level1)
125 {
126 int64_t eventId = 1;
127 std::string version = "version";
128 std::string content = "content";
129 std::string extra = "extra";
130 SecurityCollector::Event event = {eventId, version, content, extra};
131 int64_t duration = 2;
132 SecurityCollector::CollectorSubscriberTestImpl subscriber{event, duration, true};
133 SecurityCollector::SecurityCollectorSubscribeInfo result = subscriber.GetSubscribeInfo();
134 EXPECT_EQ(event.eventId, result.GetEvent().eventId);
135 EXPECT_EQ(event.version, result.GetEvent().version);
136 EXPECT_EQ(event.content, result.GetEvent().content);
137 EXPECT_EQ(event.extra, result.GetEvent().extra);
138 }
139
140 /**
141 * @tc.name: Subscribe001
142 * @tc.desc: CollectorManager Subscribe
143 * @tc.type: FUNC
144 * @tc.require: AR000IENKB
145 */
146 HWTEST_F(CollectorInterfaceTest, Subscribe001, testing::ext::TestSize.Level1)
147 {
148 int ret = SecurityCollector::CollectorManager::GetInstance().Subscribe(nullptr);
149 EXPECT_EQ(ret, SecurityCollector::BAD_PARAM);
150 }
151
152 HWTEST_F(CollectorInterfaceTest, Subscribe002, testing::ext::TestSize.Level1)
153 {
154 SecurityCollector::CollectorManager manager {};
155 SecurityCollector::Event event {};
156 auto subscriber = std::make_shared<SecurityGuardTest::SecurityCollectorSubscriber> (event);
157 sptr<SecurityCollector::SecurityCollectorManagerCallbackService> callback =
158 new(std::nothrow) SecurityCollector::SecurityCollectorManagerCallbackService(nullptr);
159 manager.eventListeners_.insert({subscriber, callback});
160 int ret = manager.Subscribe(subscriber);
161 EXPECT_EQ(ret, SecurityCollector::BAD_PARAM);
162 }
163
164 HWTEST_F(CollectorInterfaceTest, Subscribe003, testing::ext::TestSize.Level1)
165 {
166 SecurityCollector::CollectorManager manager {};
167 SecurityCollector::Event event {};
168 auto subscriber = std::make_shared<SecurityGuardTest::SecurityCollectorSubscriber> (event);
169 sptr<SecurityCollector::SecurityCollectorManagerCallbackService> callback =
170 new(std::nothrow) SecurityCollector::SecurityCollectorManagerCallbackService(nullptr);
171 int ret = manager.Subscribe(subscriber);
172 EXPECT_EQ(ret, SecurityCollector::BAD_PARAM);
173 }
174
175 /**
176 * @tc.name: Unsubscribe001
177 * @tc.desc: CollectorManager Unsubscribe
178 * @tc.type: FUNC
179 * @tc.require: AR000IENKB
180 */
181 HWTEST_F(CollectorInterfaceTest, Unsubscribe001, testing::ext::TestSize.Level1)
182 {
183 int ret = SecurityCollector::CollectorManager::GetInstance().Unsubscribe(nullptr);
184 EXPECT_EQ(ret, SecurityCollector::BAD_PARAM);
185 }
186
187 HWTEST_F(CollectorInterfaceTest, UnSubscribe002, testing::ext::TestSize.Level1)
188 {
189 SecurityCollector::CollectorManager manager {};
190 SecurityCollector::Event event {};
191 auto subscriber = std::make_shared<SecurityGuardTest::SecurityCollectorSubscriber> (event);
192 sptr<SecurityCollector::SecurityCollectorManagerCallbackService> callback =
193 new(std::nothrow) SecurityCollector::SecurityCollectorManagerCallbackService(nullptr);
194 manager.eventListeners_.insert({subscriber, callback});
195 int ret = manager.Unsubscribe(subscriber);
196 EXPECT_EQ(ret, SecurityCollector::NO_PERMISSION);
197 }
198
199 HWTEST_F(CollectorInterfaceTest, UnSubscribe003, testing::ext::TestSize.Level1)
200 {
201 SecurityCollector::CollectorManager manager {};
202 SecurityCollector::Event event {};
203 auto subscriber = std::make_shared<SecurityGuardTest::SecurityCollectorSubscriber> (event);
204 int ret = manager.Unsubscribe(subscriber);
205 EXPECT_EQ(ret, SecurityCollector::BAD_PARAM);
206 }
207
208 /**
209 * @tc.name: OnRemoteDied001
210 * @tc.desc: CollectorManager DeathRecipient OnRemoteDied
211 * @tc.type: FUNC
212 * @tc.require: AR000IENKB
213 */
214 HWTEST_F(CollectorInterfaceTest, OnRemoteDied001, testing::ext::TestSize.Level1)
215 {
216 SecurityCollector::CollectorManager::DeathRecipient recipient =
217 SecurityCollector::CollectorManager::DeathRecipient();
218 recipient.OnRemoteDied(nullptr);
219 }
220
221 /**
222 * @tc.name: Query002
223 * @tc.desc: ICollector Query
224 * @tc.type: FUNC
225 * @tc.require: AR20240110334295
226 */
227 HWTEST_F(CollectorInterfaceTest, Query002, testing::ext::TestSize.Level1)
228 {
229 TestCollector collector;
230 int64_t eventId = 1;
231 const std::string beginTime = "20240406094000";
232 const std::string endTime = "20240406095000";
233 const std::string param = "param";
234 SecurityCollector::SecurityEventRuler
235 SecurityEventRuler{eventId, beginTime, endTime, param};
236 std::vector<SecurityCollector::SecurityEvent> events;
237 const std::string version = "1.0";
238 const std::string content = "content";
239 SecurityCollector::SecurityEvent event{eventId, version, content};
240 EXPECT_EQ(collector.Query(SecurityEventRuler, events), 0);
241 EXPECT_EQ(collector.Start(nullptr), 0);
242 EXPECT_EQ(collector.Stop(), 0);
243 }
244
245 /**
246 * @tc.name: Query002
247 * @tc.desc: ICollector Query
248 * @tc.type: FUNC
249 * @tc.require: AR20240110334295
250 */
251 HWTEST_F(CollectorInterfaceTest, Query003, testing::ext::TestSize.Level1)
252 {
253 TestCollector collector;
254 EXPECT_EQ(collector.Subscribe(0), 0);
255 EXPECT_EQ(collector.Unsubscribe(0), 0);
256 EXPECT_EQ(collector.IsStartWithSub(), 0);
257 }
258
259 /**
260 * @tc.name: CollectorStart001
261 * @tc.desc: ICollector Start
262 * @tc.type: FUNC
263 * @tc.require:
264 */
265 HWTEST_F(CollectorInterfaceTest, CollectorStart001, testing::ext::TestSize.Level1)
266 {
267 SecurityCollector::CollectorManager manager {};
268 SecurityCollector::Event event {};
269 SecurityCollector::SecurityCollectorSubscribeInfo subscriber (event, -1, false);
270 sptr<SecurityCollector::SecurityCollectorManagerCallbackService> callback =
271 new(std::nothrow) SecurityCollector::SecurityCollectorManagerCallbackService(nullptr);
272 int ret = manager.CollectorStart(subscriber);
273 EXPECT_EQ(ret, SecurityCollector::BAD_PARAM);
274 }
275
276 /**
277 * @tc.name: CollectorStart002
278 * @tc.desc: ICollector Start
279 * @tc.type: FUNC
280 * @tc.require:
281 */
282 HWTEST_F(CollectorInterfaceTest, CollectorStop001, testing::ext::TestSize.Level1)
283 {
284 SecurityCollector::CollectorManager manager {};
285 SecurityCollector::Event event {};
286 SecurityCollector::SecurityCollectorSubscribeInfo subscriber (event, -1, false);
287 sptr<SecurityCollector::SecurityCollectorManagerCallbackService> callback =
288 new(std::nothrow) SecurityCollector::SecurityCollectorManagerCallbackService(nullptr);
289 int ret = manager.CollectorStop(subscriber);
290 EXPECT_EQ(ret, SecurityCollector::BAD_PARAM);
291 }
292 }