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