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 "security_guard_data_collect_sa_test.h"
17 
18 #include <thread>
19 #include <vector>
20 #include <fcntl.h>
21 #include <sys/stat.h>
22 #include <sys/types.h>
23 #include <unistd.h>
24 #include "directory_ex.h"
25 #include "file_ex.h"
26 #include "gmock/gmock.h"
27 #include "system_ability_definition.h"
28 
29 #include "security_guard_define.h"
30 #include "security_guard_log.h"
31 #include "security_guard_utils.h"
32 #include "security_config_update_info.h"
33 #define private public
34 #define protected public
35 #include "accesstoken_kit.h"
36 #include "acquire_data_subscribe_manager.h"
37 #include "collector_manager.h"
38 #include "config_data_manager.h"
39 #include "data_format.h"
40 #include "database_manager.h"
41 #include "data_collect_manager_service.h"
42 #include "security_event_query_callback_proxy.h"
43 #undef private
44 #undef protected
45 
46 using namespace testing;
47 using namespace testing::ext;
48 using namespace OHOS::Security::SecurityGuard;
49 using namespace OHOS::Security::SecurityGuardTest;
50 namespace OHOS {
51     std::shared_ptr<Security::SecurityGuard::MockDataFormatInterface> DataFormat::instance_ = nullptr;
52     std::shared_ptr<Security::AccessToken::MockAccessTokenKitInterface>
53         Security::AccessToken::AccessTokenKit::instance_ = nullptr;
54     std::shared_ptr<Security::AccessToken::MockTokenIdKitInterface>
55         Security::AccessToken::TokenIdKit::instance_ = nullptr;
56     std::mutex Security::SecurityGuard::DataFormat::mutex_ {};
57     std::mutex Security::AccessToken::AccessTokenKit::mutex_ {};
58     std::mutex Security::AccessToken::TokenIdKit::mutex_ {};
59 }
60 
61 namespace OHOS::Security::SecurityGuardTest {
62 
63 
SetUpTestCase()64 void SecurityGuardDataCollectSaTest::SetUpTestCase()
65 {
66 }
67 
TearDownTestCase()68 void SecurityGuardDataCollectSaTest::TearDownTestCase()
69 {
70     DataFormat::DelInterface();
71     AccessToken::AccessTokenKit::DelInterface();
72     AccessToken::TokenIdKit::DelInterface();
73 }
74 
SetUp()75 void SecurityGuardDataCollectSaTest::SetUp()
76 {
77 }
78 
TearDown()79 void SecurityGuardDataCollectSaTest::TearDown()
80 {
81 }
82 
83 HWTEST_F(SecurityGuardDataCollectSaTest, TestDumpWithInvalidFd, TestSize.Level1)
84 {
85     int fd = -1;
86     std::vector<std::u16string> args;
87     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
88     EXPECT_EQ(service.Dump(fd, args), BAD_PARAM);
89 }
90 
91 HWTEST_F(SecurityGuardDataCollectSaTest, TestDumpWithInvalidArgs, TestSize.Level1)
92 {
93     int fd = 1;
94     std::vector<std::u16string> args;
95     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
96     EXPECT_EQ(service.Dump(fd, args), ERR_OK);
97 }
98 
99 HWTEST_F(SecurityGuardDataCollectSaTest, TestDumpWithHelpCommand, TestSize.Level1)
100 {
101     int fd = 1;
102     std::vector<std::u16string> args = { u"-h" };
103     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
104     EXPECT_EQ(service.Dump(fd, args), ERR_OK);
105 }
106 
107 HWTEST_F(SecurityGuardDataCollectSaTest, TestDumpWithOtherCommand, TestSize.Level1)
108 {
109     int fd = 1;
110     std::vector<std::u16string> args = { u"-s" };
111     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
112     EXPECT_EQ(service.Dump(fd, args), ERR_OK);
113 }
114 
115 HWTEST_F(SecurityGuardDataCollectSaTest, TestDumpWithInvalidEventId01, TestSize.Level1)
116 {
117     int fd = 1;
118     std::vector<std::u16string> args = { u"-i", u"invalid" };
119     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
120     EXPECT_EQ(service.Dump(fd, args), BAD_PARAM);
121 }
122 
123 HWTEST_F(SecurityGuardDataCollectSaTest, TestDumpWithInvalidEventId02, TestSize.Level1)
124 {
125     int fd = 1;
126     std::vector<std::u16string> args = { u"-i" };
127     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
128     EXPECT_EQ(service.Dump(fd, args), BAD_PARAM);
129 }
130 
131 HWTEST_F(SecurityGuardDataCollectSaTest, TestDumpWithValidEventId, TestSize.Level1)
132 {
133     int fd = 1;
134     std::vector<std::u16string> args = { u"-i", u"12345" };
135     EXPECT_CALL(DatabaseManager::GetInstance(), QueryRecentEventByEventId(_, _))
136         .WillOnce(Return(SUCCESS));
137     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
138     EXPECT_EQ(service.Dump(fd, args), ERR_OK);
139 }
140 
141 HWTEST_F(SecurityGuardDataCollectSaTest, DumpEventInfo_Success, TestSize.Level1) {
142     SecEvent secEvent;
143     secEvent.eventId = 1;
144     secEvent.date = "2022-01-01";
145     secEvent.version = "1.0";
146 
147     EXPECT_CALL(DatabaseManager::GetInstance(), QueryRecentEventByEventId(1, _))
148         .WillOnce(Return(SUCCESS));
149     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
150     service.DumpEventInfo(1, 1);
151 }
152 
153 HWTEST_F(SecurityGuardDataCollectSaTest, DumpEventInfo_QueryError, TestSize.Level1) {
154     EXPECT_CALL(DatabaseManager::GetInstance(), QueryRecentEventByEventId(1, _))
155         .WillOnce(Return(FAILED));
156     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
157     service.DumpEventInfo(1, 1);
158 }
159 
160 HWTEST_F(SecurityGuardDataCollectSaTest, GetSecEventsFromConditions_NoTimeCondition, TestSize.Level1) {
161     RequestCondition condition{};
162     EXPECT_CALL(DatabaseManager::GetInstance(), QueryEventByEventId(_, _, _))
163         .WillRepeatedly([] (std::string table, std::vector<int64_t> &eventIds,
__anon145630c50102(std::string table, std::vector<int64_t> &eventIds, std::vector<SecEvent> &events) 164             std::vector<SecEvent> &events) {
165             SecEvent event {};
166             event.eventId = 1;
167             events.emplace_back(event);
168             return SUCCESS;
169         });
170     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
171     std::vector<SecEvent> events = service.GetSecEventsFromConditions(condition);
172     EXPECT_EQ(events[0].eventId, 1);
173     EXPECT_EQ(events[1].eventId, 0);
174 }
175 
176 HWTEST_F(SecurityGuardDataCollectSaTest, GetSecEventsFromConditions_WithTimeCondition, TestSize.Level1) {
177     RequestCondition condition;
178     condition.riskEvent = {};
179     condition.auditEvent = {};
180     condition.beginTime = "2022-01-01";
181     condition.endTime = "2022-01-31";
182 
183     EXPECT_CALL(DatabaseManager::GetInstance(), QueryEventByEventIdAndDate(_, _, _, _, _))
184         .WillRepeatedly([] (std::string table, std::vector<int64_t> &eventIds, std::vector<SecEvent> &events,
__anon145630c50202(std::string table, std::vector<int64_t> &eventIds, std::vector<SecEvent> &events, std::string beginTime, std::string endTime) 185         std::string beginTime, std::string endTime) {
186             SecEvent event {};
187             event.eventId = 1;
188             events.emplace_back(event);
189             return SUCCESS;
190         });
191     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
192     std::vector<SecEvent> events = service.GetSecEventsFromConditions(condition);
193     EXPECT_EQ(events[0].eventId, 1);
194     EXPECT_EQ(events[1].eventId, 0);
195 }
196 
197 HWTEST_F(SecurityGuardDataCollectSaTest, QueryEventByRuler_GetEventConfigError, TestSize.Level1)
198 {
199     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
200     EXPECT_TRUE(obj != nullptr);
201     EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillOnce(Return(false));
202     sptr<SecurityEventQueryCallbackProxy> mockProxy = new (std::nothrow) SecurityEventQueryCallbackProxy(obj);
203     SecurityCollector::SecurityEventRuler ruler;
204     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
205     EXPECT_TRUE(service.QueryEventByRuler(mockProxy, ruler));
206 }
207 
208 HWTEST_F(SecurityGuardDataCollectSaTest, QueryEventByRuler_QueryInDatabase, TestSize.Level1)
209 {
210     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
211     EXPECT_TRUE(obj != nullptr);
212 
__anon145630c50302(int64_t eventId, EventCfg &config) 213     EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillOnce([] (int64_t eventId, EventCfg &config) {
214         config.eventType = 0;
215         return true;
216     });
217     SecEvent event;
218     event.eventId = 1;
219     event.version = 1;
220     event.content = "content";
221     std::vector<SecEvent> events{event};
222     EXPECT_CALL(DatabaseManager::GetInstance(), QueryEventByEventId(_, _)).WillRepeatedly(Return(true));
223     sptr<SecurityEventQueryCallbackProxy> mockProxy = new (std::nothrow) SecurityEventQueryCallbackProxy(obj);
224     SecurityCollector::SecurityEventRuler ruler;
225     EXPECT_CALL(*obj, SendRequest).Times(1);
226     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
227     EXPECT_TRUE(service.QueryEventByRuler(mockProxy, ruler));
228 }
229 
230 HWTEST_F(SecurityGuardDataCollectSaTest, QueryEventByRuler_QueryInCollector, TestSize.Level1)
231 {
__anon145630c50402(int64_t eventId, EventCfg &config) 232     EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillOnce([] (int64_t eventId, EventCfg &config) {
233         config.eventType = 1;
234         return true;
235     });
236     SecurityCollector::SecurityEvent event;
237     event.eventId_ = 1;
238     event.version_ = 1;
239     event.content_ = "content";
240     std::vector<SecurityCollector::SecurityEvent> events{event};
241     EXPECT_CALL(SecurityCollector::CollectorManager::GetInstance(), QuerySecurityEvent(_, _)).WillOnce(Return(SUCCESS));
242     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
243     EXPECT_TRUE(obj != nullptr);
244     sptr<SecurityEventQueryCallbackProxy> mockProxy = new (std::nothrow) SecurityEventQueryCallbackProxy(obj);
245     SecurityCollector::SecurityEventRuler ruler;
246     EXPECT_CALL(*obj, SendRequest).Times(1);
247     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
248     EXPECT_TRUE(service.QueryEventByRuler(mockProxy, ruler));
249 }
250 
251 HWTEST_F(SecurityGuardDataCollectSaTest, QueryEventByRuler_NotSupportType, TestSize.Level1)
252 {
__anon145630c50502(int64_t eventId, EventCfg &config) 253     EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillOnce([] (int64_t eventId, EventCfg &config) {
254         config.eventType = 2;
255         return true;
256     });
257     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
258     EXPECT_TRUE(obj != nullptr);
259     EXPECT_CALL(*obj, SendRequest).Times(1);
260     sptr<SecurityEventQueryCallbackProxy> mockProxy = new (std::nothrow) SecurityEventQueryCallbackProxy(obj);
261     SecurityCollector::SecurityEventRuler ruler;
262     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
263     EXPECT_TRUE(service.QueryEventByRuler(mockProxy, ruler));
264 }
265 
266 HWTEST_F(SecurityGuardDataCollectSaTest, TestPushDataCollectTask_NullProxy, TestSize.Level1)
267 {
268     std::shared_ptr<std::promise<int32_t>> promise = std::make_shared<std::promise<int32_t>>();
269     EXPECT_TRUE(promise != nullptr);
270     sptr<MockRemoteObject> mockObj = nullptr;
271     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
272     service.PushDataCollectTask(mockObj, "conditions", "devId", promise);
273     EXPECT_EQ(0, promise->get_future().get());
274 }
275 
276 HWTEST_F(SecurityGuardDataCollectSaTest, TestPushDataCollectTask_EmptyConditions, TestSize.Level1)
277 {
278     std::shared_ptr<std::promise<int32_t>> promise = std::make_shared<std::promise<int32_t>>();
279     EXPECT_TRUE(promise != nullptr);
280     sptr<MockRemoteObject> mockObj(new (std::nothrow) MockRemoteObject());
281     EXPECT_TRUE(mockObj != nullptr);
282     EXPECT_CALL(*(DataFormat::GetInterface()), ParseConditions).WillOnce([]
__anon145630c50602(std::string conditions, RequestCondition &reqCondition) 283         (std::string conditions, RequestCondition &reqCondition) {
284             reqCondition = {};
285         });
286     EXPECT_CALL(*mockObj, SendRequest).Times(1);
287     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
288     ON_CALL(*mockObj, SendRequest)
__anon145630c50702(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 289         .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
290             service.OnRemoteRequest(code, data, reply, option);
291             return SUCCESS;
292         });
293     service.PushDataCollectTask(mockObj, "", "devId", promise);
294     EXPECT_EQ(0, promise->get_future().get());
295 }
296 
297 HWTEST_F(SecurityGuardDataCollectSaTest, TestPushDataCollectTask_ValidConditions01, TestSize.Level1)
298 {
299     std::shared_ptr<std::promise<int32_t>> promise = std::make_shared<std::promise<int32_t>>();
300     EXPECT_TRUE(promise != nullptr);
301     EXPECT_CALL(*(DataFormat::GetInterface()), ParseConditions).WillOnce([]
__anon145630c50802(std::string conditions, RequestCondition &reqCondition) 302         (std::string conditions, RequestCondition &reqCondition) {
303             reqCondition.auditEvent = {1};
304         });
305     EXPECT_CALL(DatabaseManager::GetInstance(), QueryEventByEventId(_, _, _))
306         .WillRepeatedly([] (std::string table, std::vector<int64_t> &eventIds,
__anon145630c50902(std::string table, std::vector<int64_t> &eventIds, std::vector<SecEvent> &events) 307             std::vector<SecEvent> &events) {
308             SecEvent event {};
309             event.eventId = 1;
310             events.emplace_back(event);
311             return SUCCESS;
312         });
313     sptr<MockRemoteObject> mockObj(new (std::nothrow) MockRemoteObject());
314     EXPECT_CALL(*mockObj, SendRequest).Times(1);
315     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
316     service.PushDataCollectTask(mockObj, "conditions", "devId", promise);
317     EXPECT_EQ(1, promise->get_future().get());
318 }
319 
320 HWTEST_F(SecurityGuardDataCollectSaTest, TestPushDataCollectTask_ValidConditions02, TestSize.Level1)
321 {
322     std::shared_ptr<std::promise<int32_t>> promise = std::make_shared<std::promise<int32_t>>();
323     EXPECT_TRUE(promise != nullptr);
324     sptr<MockRemoteObject> mockObj(new (std::nothrow) MockRemoteObject());
325     EXPECT_TRUE(mockObj != nullptr);
326     EXPECT_CALL(*(DataFormat::GetInterface()), ParseConditions).WillOnce([]
__anon145630c50a02(std::string conditions, RequestCondition &reqCondition) 327         (std::string conditions, RequestCondition &reqCondition) {
328             reqCondition.auditEvent = {1};
329         });
330     EXPECT_CALL(DatabaseManager::GetInstance(), QueryEventByEventId(_, _, _))
331         .WillRepeatedly([] (std::string table, std::vector<int64_t> &eventIds,
__anon145630c50b02(std::string table, std::vector<int64_t> &eventIds, std::vector<SecEvent> &events) 332             std::vector<SecEvent> &events) {
333             SecEvent event {};
334             event.eventId = 1;
335             return SUCCESS;
336         });
337     EXPECT_CALL(*mockObj, SendRequest).Times(1);
338     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
339     service.PushDataCollectTask(mockObj, "conditions", "devId", promise);
340     EXPECT_EQ(0, promise->get_future().get());
341 }
342 
343 HWTEST_F(SecurityGuardDataCollectSaTest, OnAddSystemAbility_RiskAnalysisManagerSaId, TestSize.Level1)
344 {
345     std::vector<int64_t> whiteList{};
346     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
347     service.OnAddSystemAbility(RISK_ANALYSIS_MANAGER_SA_ID, "deviceId");
348 }
349 
350 HWTEST_F(SecurityGuardDataCollectSaTest, OnAddSystemAbility_DfxSysHiviewAbilityId, TestSize.Level1)
351 {
352     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
353     service.OnAddSystemAbility(DFX_SYS_HIVIEW_ABILITY_ID, "deviceId");
354 }
355 
356 HWTEST_F(SecurityGuardDataCollectSaTest, RequestDataSubmit_NoPermission, TestSize.Level1)
357 {
358     int64_t eventId = 1;
359     std::string version = "1.0";
360     std::string time = "2022-01-01";
361     std::string content = "content";
362 
363     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillRepeatedly(
364         Return(AccessToken::PermissionState::PERMISSION_DENIED));
365     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
366     int32_t result = service.RequestDataSubmit(eventId, version, time, content);
367     EXPECT_EQ(result, NO_PERMISSION);
368 }
369 
370 HWTEST_F(SecurityGuardDataCollectSaTest, RequestDataSubmit_BadParam, TestSize.Level1)
371 {
372     int64_t eventId = 1;
373     std::string version = "1.0";
374     std::string time = "2022-01-01";
375     std::string content = "content";
376 
377     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
378         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
379     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
380         Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
381     EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
382         Return(true));
383     EXPECT_CALL(*(DataFormat::GetInterface()), CheckRiskContent).WillOnce(Return(false));
384     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
385     int32_t result = service.RequestDataSubmit(eventId, version, time, content);
386     EXPECT_EQ(result, BAD_PARAM);
387 }
388 
389 HWTEST_F(SecurityGuardDataCollectSaTest, RequestDataSubmit_Success01, TestSize.Level1)
390 {
391     int64_t eventId = 1;
392     std::string version = "1.0";
393     std::string time = "2022-01-01";
394     std::string content = "content";
395 
396     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken)
397         .WillOnce(Return(AccessToken::PermissionState::PERMISSION_GRANTED));
398     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
399         Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
400     EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
401         Return(true));
402     EXPECT_CALL(*(DataFormat::GetInterface()), CheckRiskContent).WillOnce(Return(true));
403     EXPECT_CALL(DatabaseManager::GetInstance(), InsertEvent).WillOnce(Return(FAILED));
404     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
405     int32_t result = service.RequestDataSubmit(eventId, version, time, content);
406     EXPECT_EQ(result, SUCCESS);
407 }
408 
409 HWTEST_F(SecurityGuardDataCollectSaTest, RequestDataSubmit_Success02, TestSize.Level1)
410 {
411     int64_t eventId = 1;
412     std::string version = "1.0";
413     std::string time = "2022-01-01";
414     std::string content = "content";
415 
416     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken)
417         .WillOnce(Return(AccessToken::PermissionState::PERMISSION_GRANTED));
418     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
419         Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
420     EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
421         Return(true));
422     EXPECT_CALL(*(DataFormat::GetInterface()), CheckRiskContent).WillOnce(Return(true));
423     EXPECT_CALL(DatabaseManager::GetInstance(), InsertEvent).WillOnce(Return(SUCCESS));
424     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
425     int32_t result = service.RequestDataSubmit(eventId, version, time, content);
426     EXPECT_EQ(result, SUCCESS);
427 }
428 
429 HWTEST_F(SecurityGuardDataCollectSaTest, RequestDataSubmit_Success03, TestSize.Level1)
430 {
431     int64_t eventId = 1;
432     std::string version = "1.0";
433     std::string time = "2022-01-01";
434     std::string content = "content";
435 
436     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken)
437         .WillOnce(Return(AccessToken::PermissionState::PERMISSION_GRANTED));
438     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType)
439         .WillOnce(Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
440     EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID)
441         .WillOnce(Return(true));
442     EXPECT_CALL(*(DataFormat::GetInterface()), CheckRiskContent).WillOnce(Return(true));
443     EXPECT_CALL(DatabaseManager::GetInstance(), InsertEvent).WillRepeatedly(Return(SUCCESS));
444     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
445     int32_t result = service.RequestDataSubmit(eventId, version, time, content, false);
446     EXPECT_EQ(result, SUCCESS);
447 }
448 
449 HWTEST_F(SecurityGuardDataCollectSaTest, RequestRiskData01, TestSize.Level1)
450 {
451     std::string devId = "devId";
452     std::string eventList = "eventList";
453     sptr<IRemoteObject> obj = nullptr;
454 
455     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken)
456         .WillOnce(Return(AccessToken::PermissionState::PERMISSION_DENIED));
457     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
458     int32_t result = service.RequestRiskData(devId, eventList, obj);
459     EXPECT_EQ(result, NO_PERMISSION);
460 }
461 
462 HWTEST_F(SecurityGuardDataCollectSaTest, RequestRiskData02, TestSize.Level1)
463 {
464     std::string devId = "devId";
465     std::string eventList = "eventList";
466     sptr<IRemoteObject> obj = nullptr;
467 
468     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken)
469         .WillOnce(Return(AccessToken::PermissionState::PERMISSION_GRANTED));
470     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
471         Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
472     EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
473         Return(true));
474     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
475     int32_t result = service.RequestRiskData(devId, eventList, obj);
476     EXPECT_EQ(result, SUCCESS);
477 }
478 
479 HWTEST_F(SecurityGuardDataCollectSaTest, Subscribe01, TestSize.Level1)
480 {
481     SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo{};
482     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
483 
484     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken)
485         .WillRepeatedly(Return(AccessToken::PermissionState::PERMISSION_DENIED));
486     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
487     int32_t result = service.Subscribe(subscribeInfo, obj);
488     EXPECT_EQ(result, NO_PERMISSION);
489 }
490 
491 HWTEST_F(SecurityGuardDataCollectSaTest, Unsubscribe01, TestSize.Level1)
492 {
493     SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo{};
494     sptr<MockRemoteObject> mockObj(new (std::nothrow) MockRemoteObject());
495 
496     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken)
497         .WillRepeatedly(Return(AccessToken::PermissionState::PERMISSION_DENIED));
498     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
499     int32_t result = service.Unsubscribe(mockObj);
500     EXPECT_EQ(result, NO_PERMISSION);
501 }
502 
503 HWTEST_F(SecurityGuardDataCollectSaTest, InsertSubscribeRecord_Success, TestSize.Level1)
504 {
505     SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo{};
506     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
507     EXPECT_CALL(DatabaseManager::GetInstance(), SubscribeDb).WillOnce(Return(SUCCESS));
508     EXPECT_CALL(DatabaseManager::GetInstance(), UnSubscribeDb).WillOnce(Return(SUCCESS));
509     EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(Return(true));
510     int32_t result = AcquireDataSubscribeManager::GetInstance().InsertSubscribeRecord(subscribeInfo, obj);
511     EXPECT_EQ(result, SUCCESS);
512     result = AcquireDataSubscribeManager::GetInstance().RemoveSubscribeRecord(obj);
513     EXPECT_EQ(result, SUCCESS);
514 }
515 
516 HWTEST_F(SecurityGuardDataCollectSaTest, InsertSubscribeRecord_Fail01, TestSize.Level1)
517 {
518     SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo{};
519     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
520     sptr<MockRemoteObject> obj2(new (std::nothrow) MockRemoteObject());
521     EXPECT_CALL(DatabaseManager::GetInstance(), SubscribeDb).WillOnce(Return(FAILED)).WillRepeatedly(Return(SUCCESS));
522     EXPECT_CALL(DatabaseManager::GetInstance(), UnSubscribeDb).WillOnce(Return(FAILED)).WillRepeatedly(Return(SUCCESS));
523     EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(Return(true));
524     int32_t result = AcquireDataSubscribeManager::GetInstance().InsertSubscribeRecord(subscribeInfo, obj);
525     EXPECT_NE(result, SUCCESS);
526     result = AcquireDataSubscribeManager::GetInstance().InsertSubscribeRecord(subscribeInfo, obj);
527     EXPECT_EQ(result, SUCCESS);
528     result = AcquireDataSubscribeManager::GetInstance().RemoveSubscribeRecord(obj2);
529     EXPECT_EQ(result, SUCCESS);
530     result = AcquireDataSubscribeManager::GetInstance().RemoveSubscribeRecord(obj);
531     EXPECT_EQ(result, FAILED);
532     result = AcquireDataSubscribeManager::GetInstance().InsertSubscribeRecord(subscribeInfo, obj2);
533     EXPECT_EQ(result, SUCCESS);
534     result = AcquireDataSubscribeManager::GetInstance().RemoveSubscribeRecord(obj);
535     EXPECT_EQ(result, SUCCESS);
536 }
537 
538 HWTEST_F(SecurityGuardDataCollectSaTest, Publish_WithSubscribers, TestSize.Level1)
539 {
540     SecEvent event {
541         .eventId = 1,
542         .version = "version",
543         .content = "content"
544     };
545     EXPECT_TRUE(AcquireDataSubscribeManager::GetInstance().Publish(event));
546 }
547 
548 HWTEST_F(SecurityGuardDataCollectSaTest, Publish_NullProxy, TestSize.Level1)
549 {
550     SecEvent event {
551         .eventId = 2,
552         .version = "version",
553         .content = "content"
554     };
555     SecurityCollector::Event event2 {
556         .eventId = 2,
557         .version = "version",
558         .content = "content",
559         .extra = ""
560     };
561     SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo(event2);
562     sptr<MockRemoteObject> obj = nullptr;
563     EXPECT_CALL(DatabaseManager::GetInstance(), SubscribeDb).WillRepeatedly(Return(SUCCESS));
564     EXPECT_CALL(DatabaseManager::GetInstance(), UnSubscribeDb).WillRepeatedly(Return(SUCCESS));
565     EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(Return(true));
566     int32_t result = AcquireDataSubscribeManager::GetInstance().InsertSubscribeRecord(subscribeInfo, obj);
567     EXPECT_EQ(result, SUCCESS);
568     EXPECT_FALSE(AcquireDataSubscribeManager::GetInstance().Publish(event));
569     result = AcquireDataSubscribeManager::GetInstance().RemoveSubscribeRecord(obj);
570     EXPECT_EQ(result, SUCCESS);
571 }
572 
573 HWTEST_F(SecurityGuardDataCollectSaTest, Publish_NotNullProxy, TestSize.Level1)
574 {
575     SecEvent event {
576         .eventId = SecurityCollector::FILE_EVENTID,
577         .version = "version",
578         .content = "content"
579     };
580     SecurityCollector::Event event2 {
581         .eventId = SecurityCollector::FILE_EVENTID,
582         .version = "version",
583         .content = "content",
584         .extra = ""
585     };
586     SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo(event2);
587     sptr<MockRemoteObject> mockObject(new (std::nothrow) MockRemoteObject());
588     EXPECT_CALL(DatabaseManager::GetInstance(), SubscribeDb).WillRepeatedly(Return(SUCCESS));
589     EXPECT_CALL(DatabaseManager::GetInstance(), UnSubscribeDb).WillRepeatedly(Return(SUCCESS));
590     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
591     EXPECT_CALL(*mockObject, SendRequest)
__anon145630c50c02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 592         .WillOnce([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
593             service.OnRemoteRequest(code, data, reply, option);
594             return SUCCESS;
595         });
596     EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(Return(true));
597     int32_t result = AcquireDataSubscribeManager::GetInstance().InsertSubscribeRecord(subscribeInfo, mockObject);
598     EXPECT_EQ(result, SUCCESS);
599     EXPECT_TRUE(AcquireDataSubscribeManager::GetInstance().Publish(event));
600     result = AcquireDataSubscribeManager::GetInstance().RemoveSubscribeRecord(mockObject);
601     EXPECT_EQ(result, SUCCESS);
602 }
603 
604 HWTEST_F(SecurityGuardDataCollectSaTest, Publish_DifferentEventId01, TestSize.Level1)
605 {
606     SecEvent event {
607         .eventId = 1,
608         .version = "version",
609         .content = "content"
610     };
611     SecurityCollector::Event event2 {
612         .eventId = 1,
613         .version = "version",
614         .content = "content",
615         .extra = ""
616     };
617     SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo(event2);
618     sptr<MockRemoteObject> mockObj(new (std::nothrow) MockRemoteObject());
619     EXPECT_CALL(DatabaseManager::GetInstance(), SubscribeDb).WillRepeatedly(Return(SUCCESS));
620     EXPECT_CALL(DatabaseManager::GetInstance(), UnSubscribeDb).WillRepeatedly(Return(SUCCESS));
621     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
622     EXPECT_CALL(*mockObj, SendRequest)
__anon145630c50d02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 623         .WillOnce([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
624             service.OnRemoteRequest(code, data, reply, option);
625             return SUCCESS;
626         });
627     int32_t result = AcquireDataSubscribeManager::GetInstance().InsertSubscribeRecord(subscribeInfo, mockObj);
628     EXPECT_EQ(result, SUCCESS);
629     EXPECT_TRUE(AcquireDataSubscribeManager::GetInstance().Publish(event));
630     result = AcquireDataSubscribeManager::GetInstance().RemoveSubscribeRecord(mockObj);
631     EXPECT_EQ(result, SUCCESS);
632 }
633 
634 HWTEST_F(SecurityGuardDataCollectSaTest, Publish_DifferentEventId02, TestSize.Level1)
635 {
636     SecEvent event {
637         .eventId = SecurityCollector::PROCESS_EVENTID,
638         .version = "version",
639         .content = "content"
640     };
641     SecurityCollector::Event event2 {
642         .eventId = SecurityCollector::PROCESS_EVENTID,
643         .version = "version",
644         .content = "content",
645         .extra = ""
646     };
647     SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo(event2);
648     sptr<MockRemoteObject> object(new (std::nothrow) MockRemoteObject());
649     EXPECT_CALL(DatabaseManager::GetInstance(), SubscribeDb).WillRepeatedly(Return(SUCCESS));
650     EXPECT_CALL(DatabaseManager::GetInstance(), UnSubscribeDb).WillRepeatedly(Return(SUCCESS));
651     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
652     EXPECT_CALL(*object, SendRequest)
__anon145630c50e02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 653         .WillOnce([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
654             service.OnRemoteRequest(code, data, reply, option);
655             return SUCCESS;
656         });
657     int32_t result = AcquireDataSubscribeManager::GetInstance().InsertSubscribeRecord(subscribeInfo, object);
658     EXPECT_EQ(result, SUCCESS);
659     EXPECT_TRUE(AcquireDataSubscribeManager::GetInstance().Publish(event));
660     result = AcquireDataSubscribeManager::GetInstance().RemoveSubscribeRecord(object);
661     EXPECT_EQ(result, SUCCESS);
662 }
663 
664 HWTEST_F(SecurityGuardDataCollectSaTest, Publish_DifferentEventId03, TestSize.Level1)
665 {
666     SecEvent event {
667         .eventId = SecurityCollector::NETWORK_EVENTID,
668         .version = "version",
669         .content = "content"
670     };
671     SecurityCollector::Event event2 {
672         .eventId = SecurityCollector::NETWORK_EVENTID,
673         .version = "version",
674         .content = "content",
675         .extra = ""
676     };
677     SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo(event2);
678     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
679     EXPECT_CALL(DatabaseManager::GetInstance(), SubscribeDb).WillRepeatedly(Return(SUCCESS));
680     EXPECT_CALL(DatabaseManager::GetInstance(), UnSubscribeDb).WillRepeatedly(Return(SUCCESS));
681     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
682     EXPECT_CALL(*obj, SendRequest)
__anon145630c50f02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 683         .WillOnce([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
684             service.OnRemoteRequest(code, data, reply, option);
685             return SUCCESS;
686         });
687     int32_t result = AcquireDataSubscribeManager::GetInstance().InsertSubscribeRecord(subscribeInfo, obj);
688     EXPECT_EQ(result, SUCCESS);
689     EXPECT_TRUE(AcquireDataSubscribeManager::GetInstance().Publish(event));
690     result = AcquireDataSubscribeManager::GetInstance().RemoveSubscribeRecord(obj);
691     EXPECT_EQ(result, SUCCESS);
692 }
693 
694 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd01, TestSize.Level1)
695 {
696     MessageParcel data;
697     MessageParcel reply;
698     MessageOption option;
699 
700     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
701     data.WriteInt32(DataCollectManagerService::CMD_DATA_REQUEST);
702     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
703     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_DATA_COLLECT, data, reply, option);
704     EXPECT_EQ(result, BAD_PARAM);
705 }
706 
707 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd02, TestSize.Level1)
708 {
709     MessageParcel data;
710     MessageParcel reply;
711     MessageOption option;
712 
713     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
714     data.WriteInt32(DataCollectManagerService::CMD_DATA_REQUEST);
715     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
716     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_DATA_REQUEST, data, reply, option);
717     EXPECT_EQ(result, BAD_PARAM);
718 }
719 
720 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd03, TestSize.Level1)
721 {
722     MessageParcel data;
723     MessageParcel reply;
724     MessageOption option;
725 
726     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
727     data.WriteInt32(DataCollectManagerService::CMD_DATA_SUBSCRIBE);
728     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
729     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_DATA_SUBSCRIBE, data, reply, option);
730     EXPECT_EQ(result, BAD_PARAM);
731 }
732 
733 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd04, TestSize.Level1)
734 {
735     MessageParcel data;
736     MessageParcel reply;
737     MessageOption option;
738 
739     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
740     data.WriteInt32(DataCollectManagerService::CMD_DATA_UNSUBSCRIBE);
741     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
742     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_DATA_UNSUBSCRIBE, data, reply, option);
743     EXPECT_EQ(result, BAD_PARAM);
744 }
745 
746 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd05, TestSize.Level1)
747 {
748     MessageParcel data;
749     MessageParcel reply;
750     MessageOption option;
751 
752     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
753     data.WriteInt32(DataCollectManagerService::CMD_SECURITY_EVENT_QUERY);
754     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
755     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_EVENT_QUERY,
756         data, reply, option);
757     EXPECT_EQ(result, BAD_PARAM);
758 }
759 
760 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd06, TestSize.Level1)
761 {
762     MessageParcel data;
763     MessageParcel reply;
764     MessageOption option;
765 
766     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
767     data.WriteInt64(0);
768     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
769     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_DATA_COLLECT, data, reply, option);
770     EXPECT_EQ(result, BAD_PARAM);
771 }
772 
773 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd07, TestSize.Level1)
774 {
775     MessageParcel data;
776     MessageParcel reply;
777     MessageOption option;
778 
779     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
780     data.WriteInt64(0);
781     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
782     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_DATA_REQUEST, data, reply, option);
783     EXPECT_EQ(result, BAD_PARAM);
784 }
785 
786 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd08, TestSize.Level1)
787 {
788     MessageParcel data;
789     MessageParcel reply;
790     MessageOption option;
791 
792     SecurityCollector::Event event {
793         .eventId = 0,
794         .version = "version",
795         .content = "content",
796         .extra = ""
797     };
798     SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo(event);
799     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
800     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
801     data.WriteParcelable(&subscribeInfo);
802     data.WriteRemoteObject(obj);
803     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
804     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_DATA_SUBSCRIBE, data, reply, option);
805     EXPECT_EQ(result, BAD_PARAM);
806 }
807 
808 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd09, TestSize.Level1)
809 {
810     MessageParcel data;
811     MessageParcel reply;
812     MessageOption option;
813 
814     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
815     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
816     data.WriteRemoteObject(obj);
817 
818     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillRepeatedly(
819         Return(AccessToken::PermissionState::PERMISSION_DENIED));
820     EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(Return(true));
821     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
822     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_DATA_UNSUBSCRIBE, data, reply, option);
823     EXPECT_EQ(result, NO_PERMISSION);
824 }
825 
826 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd10, TestSize.Level1)
827 {
828     MessageParcel data;
829     MessageParcel reply;
830     MessageOption option;
831 
832     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
833     data.WriteUint32(MAX_QUERY_EVENT_SIZE + 1);
834     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
835     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_EVENT_QUERY,
836         data, reply, option);
837     EXPECT_EQ(result, BAD_PARAM);
838 }
839 
840 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd11, TestSize.Level1)
841 {
842     MessageParcel data;
843     MessageParcel reply;
844     MessageOption option;
845 
846     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
847     data.WriteUint32(1);
848     SecurityCollector::SecurityEventRuler ruler;
849     data.WriteParcelable(&ruler);
850     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
851     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_EVENT_QUERY,
852         data, reply, option);
853     EXPECT_EQ(result, BAD_PARAM);
854 }
855 
856 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd12, TestSize.Level1)
857 {
858     MessageParcel data;
859     MessageParcel reply;
860     MessageOption option;
861 
862     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
863     data.WriteUint32(1);
864     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
865     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_COLLECTOR_START,
866         data, reply, option);
867     EXPECT_EQ(result, BAD_PARAM);
868 }
869 
870 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd13, TestSize.Level1)
871 {
872     MessageParcel data;
873     MessageParcel reply;
874     MessageOption option;
875     SecurityCollector::Event event {};
876     SecurityCollector::SecurityCollectorSubscribeInfo subscriberInfo(event, -1, false);
877     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
878     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
879     data.WriteRemoteObject(obj);
880 
881     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
882     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_COLLECTOR_START,
883         data, reply, option);
884     EXPECT_EQ(result, BAD_PARAM);
885 }
886 
887 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd14, TestSize.Level1)
888 {
889     MessageParcel data;
890     MessageParcel reply;
891     MessageOption option;
892     SecurityCollector::Event event {};
893     SecurityCollector::SecurityCollectorSubscribeInfo subscriberInfo(event, -1, false);
894     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
895     data.WriteFileDescriptor(-1);
896     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
897     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_CONFIG_UPDATE,
898         data, reply, option);
899     EXPECT_EQ(result, BAD_PARAM);
900 }
901 
902 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd15, TestSize.Level1)
903 {
904     MessageParcel data;
905     MessageParcel reply;
906     MessageOption option;
907     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
908     data.WriteString("test");
909     data.WriteFileDescriptor(-1);
910     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
911     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_CONFIG_UPDATE,
912         data, reply, option);
913     EXPECT_EQ(result, BAD_PARAM);
914 }
915 
916 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd16, TestSize.Level1)
917 {
918     MessageParcel data;
919     MessageParcel reply;
920     MessageOption option;
921     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
922     data.WriteString("test");
923     data.WriteFileDescriptor(1);
924     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
925         Return(AccessToken::PermissionState::PERMISSION_DENIED));
926     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
927     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_CONFIG_UPDATE,
928         data, reply, option);
929     EXPECT_EQ(result, NO_PERMISSION);
930 }
931 
932 
933 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd17, TestSize.Level1)
934 {
935     MessageParcel data;
936     MessageParcel reply;
937     MessageOption option;
938     SecurityCollector::Event event {};
939     SecurityCollector::SecurityCollectorSubscribeInfo subscriberInfo(event, -1, false);
940     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
941     data.WriteUint32(1);
942     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
943     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_COLLECTOR_STOP,
944         data, reply, option);
945     EXPECT_EQ(result, BAD_PARAM);
946 }
947 
948 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd18, TestSize.Level1)
949 {
950     MessageParcel data;
951     MessageParcel reply;
952     MessageOption option;
953     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
954     data.WriteUint32(1);
955     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
956     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_COLLECTOR_STOP,
957         data, reply, option);
958     EXPECT_EQ(result, BAD_PARAM);
959 }
960 
961 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithInvalidCmd, TestSize.Level1)
962 {
963     MessageParcel data;
964     MessageParcel reply;
965     MessageOption option;
966 
967     data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
968     data.WriteInt32(100);
969     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
970     int32_t result = service.OnRemoteRequest(100, data, reply, option);
971 
972     EXPECT_EQ(result, 305);
973 }
974 
975 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithInvalidToken, TestSize.Level1)
976 {
977     MessageParcel data;
978     MessageParcel reply;
979     MessageOption option;
980 
981     data.WriteInterfaceToken(u"InvalidToken");
982     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
983     int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_DATA_COLLECT, data, reply, option);
984 
985     EXPECT_EQ(result, 305);
986 }
987 
988 HWTEST_F(SecurityGuardDataCollectSaTest, AcquireDataSubscribeSc01, TestSize.Level1)
989 {
990     AcquireDataSubscribeManager adsm {};
991     SecurityCollector::Event event {
992         .eventId = 111
993     };
994     adsm.scSubscribeMap_.insert({111,
995         std::make_shared<AcquireDataSubscribeManager::SecurityCollectorSubscriber>(event)});
996     int result = adsm.SubscribeSc(111);
997     EXPECT_EQ(result, SUCCESS);
998 }
999 
1000 HWTEST_F(SecurityGuardDataCollectSaTest, AcquireDataSubscribeSc02, TestSize.Level1)
1001 {
1002     AcquireDataSubscribeManager adsm {};
1003     SecurityCollector::Event event {
1004         .eventId = 111
1005     };
1006     EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(
__anon145630c51002(int64_t eventId, EventCfg &config) 1007         [] (int64_t eventId, EventCfg &config) {
1008         config.dbTable = "risk_event";
1009         config.eventType = 3;
1010         config.prog = "security_guard";
1011         return true;
1012     });
1013     int result = adsm.SubscribeSc(111);
1014     EXPECT_EQ(result, FAILED);
1015     result = adsm.UnSubscribeSc(111);
1016     EXPECT_EQ(result, FAILED);
1017 }
1018 
1019 HWTEST_F(SecurityGuardDataCollectSaTest, AcquireDataSubscribeSc03, TestSize.Level1)
1020 {
1021     AcquireDataSubscribeManager adsm {};
1022     SecurityCollector::Event event {
1023         .eventId = 111
1024     };
1025     EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(
__anon145630c51102(int64_t eventId, EventCfg &config) 1026         [] (int64_t eventId, EventCfg &config) {
1027         config.dbTable = "risk_event";
1028         config.eventType = 3;
1029         config.prog = "";
1030         return true;
1031     });
1032     EXPECT_CALL(SecurityCollector::CollectorManager::GetInstance(), Subscribe(_)).WillOnce(Return(FAILED));
1033     int result = adsm.SubscribeSc(111);
1034     EXPECT_EQ(result, FAILED);
1035     result = adsm.UnSubscribeSc(111);
1036     EXPECT_EQ(result, FAILED);
1037 }
1038 
1039 HWTEST_F(SecurityGuardDataCollectSaTest, AcquireDataSubscribeSc04, TestSize.Level1)
1040 {
1041     AcquireDataSubscribeManager adsm {};
1042     SecurityCollector::Event event {
1043         .eventId = 111
1044     };
1045     EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(
__anon145630c51202(int64_t eventId, EventCfg &config) 1046         [] (int64_t eventId, EventCfg &config) {
1047         config.dbTable = "risk_event";
1048         config.eventType = 3;
1049         config.prog = "";
1050         return true;
1051     });
1052     EXPECT_CALL(SecurityCollector::CollectorManager::GetInstance(), Subscribe(_)).WillOnce(Return(SUCCESS));
1053     int result = adsm.SubscribeSc(111);
1054     EXPECT_EQ(result, SUCCESS);
1055     EXPECT_CALL(SecurityCollector::CollectorManager::GetInstance(), Unsubscribe(_)).WillOnce(Return(SUCCESS));
1056     result = adsm.UnSubscribeSc(111);
1057     EXPECT_EQ(result, SUCCESS);
1058 }
1059 
1060 HWTEST_F(SecurityGuardDataCollectSaTest, AcquireDataUnSubscribeSc01, TestSize.Level1)
1061 {
1062     AcquireDataSubscribeManager adsm {};
1063     SecurityCollector::Event event {
1064         .eventId = 111
1065     };
1066     EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(
__anon145630c51302(int64_t eventId, EventCfg &config) 1067         [] (int64_t eventId, EventCfg &config) {
1068         config.dbTable = "risk_event";
1069         config.eventType = 3;
1070         config.prog = "";
1071         return false;
1072     });
1073     int32_t result = adsm.UnSubscribeSc(111);
1074     EXPECT_EQ(result, BAD_PARAM);
1075 }
1076 
1077 HWTEST_F(SecurityGuardDataCollectSaTest, QuerySecurityEvent, TestSize.Level1)
1078 {
1079     SecurityCollector::SecurityEventRuler rule(11111);
1080     std::vector<SecurityCollector::SecurityEventRuler> rules {};
1081     rules.emplace_back(rule);
1082     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1083     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillRepeatedly(
1084         Return(AccessToken::PermissionState::PERMISSION_DENIED));
1085     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1086     int32_t result = service.QuerySecurityEvent(rules, obj);
1087     EXPECT_EQ(result, NO_PERMISSION);
1088 }
1089 
1090 HWTEST_F(SecurityGuardDataCollectSaTest, QuerySecurityEvent01, TestSize.Level1)
1091 {
1092     SecurityCollector::SecurityEventRuler rule(11111);
1093     std::vector<SecurityCollector::SecurityEventRuler> rules {};
1094     rules.emplace_back(rule);
1095     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1096     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1097         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1098     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1099         Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1100     EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1101         Return(true));
1102     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1103     int32_t result = service.QuerySecurityEvent(rules, obj);
1104     EXPECT_CALL(*obj, SendRequest).Times(1);
1105     EXPECT_EQ(result, SUCCESS);
1106 }
1107 
1108 HWTEST_F(SecurityGuardDataCollectSaTest, QuerySecurityEvent02, TestSize.Level1)
1109 {
1110     SecurityCollector::SecurityEventRuler rule(11111);
1111     std::vector<SecurityCollector::SecurityEventRuler> rules {};
1112     rules.emplace_back(rule);
1113     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1114     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1115         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1116     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1117         Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1118     EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1119         Return(false));
1120     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1121     int32_t result = service.QuerySecurityEvent(rules, obj);
1122     EXPECT_EQ(result, NO_SYSTEMCALL);
1123 }
1124 
1125 HWTEST_F(SecurityGuardDataCollectSaTest, CollectorStart01, TestSize.Level1)
1126 {
1127     SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo {};
1128     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1129     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillRepeatedly(
1130         Return(AccessToken::PermissionState::PERMISSION_DENIED));
1131     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1132     int32_t result = service.CollectorStart(subscribeInfo, obj);
1133     EXPECT_EQ(result, NO_PERMISSION);
1134 }
1135 
1136 HWTEST_F(SecurityGuardDataCollectSaTest, CollectorStart02, TestSize.Level1)
1137 {
1138     SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo {};
1139     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1140     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1141         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1142     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1143         Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1144     EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1145         Return(false));
1146     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1147     int32_t result = service.CollectorStart(subscribeInfo, obj);
1148     EXPECT_EQ(result, NO_SYSTEMCALL);
1149 }
1150 
1151 HWTEST_F(SecurityGuardDataCollectSaTest, CollectorStart03, TestSize.Level1)
1152 {
1153     SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo {};
1154     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1155     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1156         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1157     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1158         Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1159     EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1160         Return(true));
1161     EXPECT_CALL(SecurityCollector::CollectorManager::GetInstance(), CollectorStart(_)).WillOnce(Return(FAILED));
1162     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1163     int32_t result = service.CollectorStart(subscribeInfo, obj);
1164     EXPECT_EQ(result, FAILED);
1165 }
1166 
1167 HWTEST_F(SecurityGuardDataCollectSaTest, CollectorStart04, TestSize.Level1)
1168 {
1169     SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo {};
1170     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1171     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1172         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1173     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1174         Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1175     EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1176         Return(true));
1177     EXPECT_CALL(SecurityCollector::CollectorManager::GetInstance(), CollectorStart(_)).WillOnce(Return(SUCCESS));
1178     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1179     int32_t result = service.CollectorStart(subscribeInfo, obj);
1180     EXPECT_EQ(result, SUCCESS);
1181 }
1182 
1183 HWTEST_F(SecurityGuardDataCollectSaTest, CollectorStop01, TestSize.Level1)
1184 {
1185     SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo {};
1186     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1187     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillRepeatedly(
1188         Return(AccessToken::PermissionState::PERMISSION_DENIED));
1189     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1190     int32_t result = service.CollectorStop(subscribeInfo, obj);
1191     EXPECT_EQ(result, NO_PERMISSION);
1192 }
1193 
1194 HWTEST_F(SecurityGuardDataCollectSaTest, CollectorStop02, TestSize.Level1)
1195 {
1196     SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo {};
1197     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1198     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1199         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1200     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1201         Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1202     EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1203         Return(false));
1204     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1205     int32_t result = service.CollectorStop(subscribeInfo, obj);
1206     EXPECT_EQ(result, NO_SYSTEMCALL);
1207 }
1208 
1209 HWTEST_F(SecurityGuardDataCollectSaTest, CollectorStop03, TestSize.Level1)
1210 {
1211     SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo {};
1212     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1213     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1214         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1215     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1216         Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1217     EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1218         Return(true));
1219     EXPECT_CALL(SecurityCollector::CollectorManager::GetInstance(), CollectorStop(_)).WillOnce(Return(FAILED));
1220     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1221     int32_t result = service.CollectorStop(subscribeInfo, obj);
1222     EXPECT_EQ(result, FAILED);
1223 }
1224 
1225 HWTEST_F(SecurityGuardDataCollectSaTest, CollectorStop04, TestSize.Level1)
1226 {
1227     SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo {};
1228     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1229     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1230         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1231     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1232         Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1233     EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1234         Return(true));
1235     EXPECT_CALL(SecurityCollector::CollectorManager::GetInstance(), CollectorStop(_)).WillOnce(Return(SUCCESS));
1236     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1237     int32_t result = service.CollectorStop(subscribeInfo, obj);
1238     EXPECT_EQ(result, SUCCESS);
1239 }
1240 
1241 HWTEST_F(SecurityGuardDataCollectSaTest, ConfigUpdate01, TestSize.Level1)
1242 {
1243     SecurityGuard::SecurityConfigUpdateInfo subscribeInfo {};
1244     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1245         Return(AccessToken::PermissionState::PERMISSION_DENIED));
1246     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1247     int32_t result = service.ConfigUpdate(subscribeInfo);
1248     EXPECT_EQ(result, NO_PERMISSION);
1249 }
1250 
1251 HWTEST_F(SecurityGuardDataCollectSaTest, ConfigUpdate02, TestSize.Level1)
1252 {
1253     SecurityGuard::SecurityConfigUpdateInfo subscribeInfo {};
1254     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1255         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1256     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1257         Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1258     EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1259         Return(false));
1260     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1261     int32_t result = service.ConfigUpdate(subscribeInfo);
1262     EXPECT_EQ(result, NO_SYSTEMCALL);
1263 }
1264 
1265 HWTEST_F(SecurityGuardDataCollectSaTest, ConfigUpdate03, TestSize.Level1)
1266 {
1267     SecurityGuard::SecurityConfigUpdateInfo subscribeInfo {};
1268     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1269         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1270     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1271         Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1272     EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1273         Return(true));
1274     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1275     int32_t result = service.ConfigUpdate(subscribeInfo);
1276     EXPECT_EQ(result, BAD_PARAM);
1277 }
1278 
1279 HWTEST_F(SecurityGuardDataCollectSaTest, ConfigUpdate04, TestSize.Level1)
1280 {
1281     SecurityGuard::SecurityConfigUpdateInfo subscribeInfo (-1, "local_app_attribute.json");
1282     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1283         Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1284     EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1285         Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1286     EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1287         Return(true));
1288     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1289     int32_t result = service.ConfigUpdate(subscribeInfo);
1290     EXPECT_EQ(result, FAILED);
1291 }
1292 
1293 HWTEST_F(SecurityGuardDataCollectSaTest, WriteRemoteFileToLocal01, TestSize.Level1)
1294 {
1295     std::ofstream out ("data/test/unittest/resource/test.json");
1296     std::string errTmp = R"({
1297         "version" : "001",
1298         "apps": ""
1299     })";
1300     out << errTmp << std::endl;
1301     int32_t fd = open("data/test/unittest/resource/test.json", O_RDONLY);
1302     SecurityGuard::SecurityConfigUpdateInfo subscribeInfo(fd, "test.json");
1303     DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1304     std::string toPath = "/data/test/unittest/resource/";
1305     int32_t result = service.WriteRemoteFileToLocal(subscribeInfo, toPath + "testFile.json");
1306     close(fd);
1307     EXPECT_EQ(result, FAILED);
1308 }
1309 }
1310