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,
__anon3c63228d0102(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,
__anon3c63228d0202(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
__anon3c63228d0302(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 {
__anon3c63228d0402(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 {
__anon3c63228d0502(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([]
__anon3c63228d0602(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)
__anon3c63228d0702(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([]
__anon3c63228d0802(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,
__anon3c63228d0902(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([]
__anon3c63228d0a02(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,
__anon3c63228d0b02(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, RequestRiskData01, TestSize.Level1)
430 {
431 std::string devId = "devId";
432 std::string eventList = "eventList";
433 sptr<IRemoteObject> obj = nullptr;
434
435 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken)
436 .WillOnce(Return(AccessToken::PermissionState::PERMISSION_DENIED));
437 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
438 int32_t result = service.RequestRiskData(devId, eventList, obj);
439 EXPECT_EQ(result, NO_PERMISSION);
440 }
441
442 HWTEST_F(SecurityGuardDataCollectSaTest, RequestRiskData02, TestSize.Level1)
443 {
444 std::string devId = "devId";
445 std::string eventList = "eventList";
446 sptr<IRemoteObject> obj = nullptr;
447
448 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken)
449 .WillOnce(Return(AccessToken::PermissionState::PERMISSION_GRANTED));
450 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
451 Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
452 EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
453 Return(true));
454 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
455 int32_t result = service.RequestRiskData(devId, eventList, obj);
456 EXPECT_EQ(result, SUCCESS);
457 }
458
459 HWTEST_F(SecurityGuardDataCollectSaTest, Subscribe01, TestSize.Level1)
460 {
461 SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo{};
462 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
463
464 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken)
465 .WillRepeatedly(Return(AccessToken::PermissionState::PERMISSION_DENIED));
466 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
467 int32_t result = service.Subscribe(subscribeInfo, obj);
468 EXPECT_EQ(result, NO_PERMISSION);
469 }
470
471 HWTEST_F(SecurityGuardDataCollectSaTest, Unsubscribe01, TestSize.Level1)
472 {
473 SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo{};
474 sptr<MockRemoteObject> mockObj(new (std::nothrow) MockRemoteObject());
475
476 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken)
477 .WillRepeatedly(Return(AccessToken::PermissionState::PERMISSION_DENIED));
478 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
479 int32_t result = service.Unsubscribe(mockObj);
480 EXPECT_EQ(result, NO_PERMISSION);
481 }
482
483 HWTEST_F(SecurityGuardDataCollectSaTest, InsertSubscribeRecord_Success, TestSize.Level1)
484 {
485 SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo{};
486 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
487 EXPECT_CALL(DatabaseManager::GetInstance(), SubscribeDb).WillOnce(Return(SUCCESS));
488 EXPECT_CALL(DatabaseManager::GetInstance(), UnSubscribeDb).WillOnce(Return(SUCCESS));
489 EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(Return(true));
490 int32_t result = AcquireDataSubscribeManager::GetInstance().InsertSubscribeRecord(subscribeInfo, obj);
491 EXPECT_EQ(result, SUCCESS);
492 result = AcquireDataSubscribeManager::GetInstance().RemoveSubscribeRecord(obj);
493 EXPECT_EQ(result, SUCCESS);
494 }
495
496 HWTEST_F(SecurityGuardDataCollectSaTest, InsertSubscribeRecord_Fail01, TestSize.Level1)
497 {
498 SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo{};
499 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
500 sptr<MockRemoteObject> obj2(new (std::nothrow) MockRemoteObject());
501 EXPECT_CALL(DatabaseManager::GetInstance(), SubscribeDb).WillOnce(Return(FAILED)).WillRepeatedly(Return(SUCCESS));
502 EXPECT_CALL(DatabaseManager::GetInstance(), UnSubscribeDb).WillOnce(Return(FAILED)).WillRepeatedly(Return(SUCCESS));
503 EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(Return(true));
504 int32_t result = AcquireDataSubscribeManager::GetInstance().InsertSubscribeRecord(subscribeInfo, obj);
505 EXPECT_NE(result, SUCCESS);
506 result = AcquireDataSubscribeManager::GetInstance().InsertSubscribeRecord(subscribeInfo, obj);
507 EXPECT_EQ(result, SUCCESS);
508 result = AcquireDataSubscribeManager::GetInstance().RemoveSubscribeRecord(obj2);
509 EXPECT_EQ(result, SUCCESS);
510 result = AcquireDataSubscribeManager::GetInstance().RemoveSubscribeRecord(obj);
511 EXPECT_EQ(result, FAILED);
512 result = AcquireDataSubscribeManager::GetInstance().InsertSubscribeRecord(subscribeInfo, obj2);
513 EXPECT_EQ(result, SUCCESS);
514 result = AcquireDataSubscribeManager::GetInstance().RemoveSubscribeRecord(obj);
515 EXPECT_EQ(result, SUCCESS);
516 }
517
518 HWTEST_F(SecurityGuardDataCollectSaTest, Publish_WithSubscribers, TestSize.Level1)
519 {
520 SecEvent event {
521 .eventId = 1,
522 .version = "version",
523 .content = "content"
524 };
525 EXPECT_TRUE(AcquireDataSubscribeManager::GetInstance().Publish(event));
526 }
527
528 HWTEST_F(SecurityGuardDataCollectSaTest, Publish_NullProxy, TestSize.Level1)
529 {
530 SecEvent event {
531 .eventId = 2,
532 .version = "version",
533 .content = "content"
534 };
535 SecurityCollector::Event event2 {
536 .eventId = 2,
537 .version = "version",
538 .content = "content",
539 .extra = ""
540 };
541 SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo(event2);
542 sptr<MockRemoteObject> obj = nullptr;
543 EXPECT_CALL(DatabaseManager::GetInstance(), SubscribeDb).WillRepeatedly(Return(SUCCESS));
544 EXPECT_CALL(DatabaseManager::GetInstance(), UnSubscribeDb).WillRepeatedly(Return(SUCCESS));
545 EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(Return(true));
546 int32_t result = AcquireDataSubscribeManager::GetInstance().InsertSubscribeRecord(subscribeInfo, obj);
547 EXPECT_EQ(result, SUCCESS);
548 EXPECT_FALSE(AcquireDataSubscribeManager::GetInstance().Publish(event));
549 result = AcquireDataSubscribeManager::GetInstance().RemoveSubscribeRecord(obj);
550 EXPECT_EQ(result, SUCCESS);
551 }
552
553 HWTEST_F(SecurityGuardDataCollectSaTest, Publish_NotNullProxy, TestSize.Level1)
554 {
555 SecEvent event {
556 .eventId = SecurityCollector::FILE_EVENTID,
557 .version = "version",
558 .content = "content"
559 };
560 SecurityCollector::Event event2 {
561 .eventId = SecurityCollector::FILE_EVENTID,
562 .version = "version",
563 .content = "content",
564 .extra = ""
565 };
566 SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo(event2);
567 sptr<MockRemoteObject> mockObject(new (std::nothrow) MockRemoteObject());
568 EXPECT_CALL(DatabaseManager::GetInstance(), SubscribeDb).WillRepeatedly(Return(SUCCESS));
569 EXPECT_CALL(DatabaseManager::GetInstance(), UnSubscribeDb).WillRepeatedly(Return(SUCCESS));
570 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
571 EXPECT_CALL(*mockObject, SendRequest)
__anon3c63228d0c02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 572 .WillOnce([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
573 service.OnRemoteRequest(code, data, reply, option);
574 return SUCCESS;
575 });
576 EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(Return(true));
577 int32_t result = AcquireDataSubscribeManager::GetInstance().InsertSubscribeRecord(subscribeInfo, mockObject);
578 EXPECT_EQ(result, SUCCESS);
579 EXPECT_TRUE(AcquireDataSubscribeManager::GetInstance().Publish(event));
580 result = AcquireDataSubscribeManager::GetInstance().RemoveSubscribeRecord(mockObject);
581 EXPECT_EQ(result, SUCCESS);
582 }
583
584 HWTEST_F(SecurityGuardDataCollectSaTest, Publish_DifferentEventId01, TestSize.Level1)
585 {
586 SecEvent event {
587 .eventId = 1,
588 .version = "version",
589 .content = "content"
590 };
591 SecurityCollector::Event event2 {
592 .eventId = 1,
593 .version = "version",
594 .content = "content",
595 .extra = ""
596 };
597 SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo(event2);
598 sptr<MockRemoteObject> mockObj(new (std::nothrow) MockRemoteObject());
599 EXPECT_CALL(DatabaseManager::GetInstance(), SubscribeDb).WillRepeatedly(Return(SUCCESS));
600 EXPECT_CALL(DatabaseManager::GetInstance(), UnSubscribeDb).WillRepeatedly(Return(SUCCESS));
601 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
602 EXPECT_CALL(*mockObj, SendRequest)
__anon3c63228d0d02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 603 .WillOnce([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
604 service.OnRemoteRequest(code, data, reply, option);
605 return SUCCESS;
606 });
607 int32_t result = AcquireDataSubscribeManager::GetInstance().InsertSubscribeRecord(subscribeInfo, mockObj);
608 EXPECT_EQ(result, SUCCESS);
609 EXPECT_TRUE(AcquireDataSubscribeManager::GetInstance().Publish(event));
610 result = AcquireDataSubscribeManager::GetInstance().RemoveSubscribeRecord(mockObj);
611 EXPECT_EQ(result, SUCCESS);
612 }
613
614 HWTEST_F(SecurityGuardDataCollectSaTest, Publish_DifferentEventId02, TestSize.Level1)
615 {
616 SecEvent event {
617 .eventId = SecurityCollector::PROCESS_EVENTID,
618 .version = "version",
619 .content = "content"
620 };
621 SecurityCollector::Event event2 {
622 .eventId = SecurityCollector::PROCESS_EVENTID,
623 .version = "version",
624 .content = "content",
625 .extra = ""
626 };
627 SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo(event2);
628 sptr<MockRemoteObject> object(new (std::nothrow) MockRemoteObject());
629 EXPECT_CALL(DatabaseManager::GetInstance(), SubscribeDb).WillRepeatedly(Return(SUCCESS));
630 EXPECT_CALL(DatabaseManager::GetInstance(), UnSubscribeDb).WillRepeatedly(Return(SUCCESS));
631 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
632 EXPECT_CALL(*object, SendRequest)
__anon3c63228d0e02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 633 .WillOnce([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
634 service.OnRemoteRequest(code, data, reply, option);
635 return SUCCESS;
636 });
637 int32_t result = AcquireDataSubscribeManager::GetInstance().InsertSubscribeRecord(subscribeInfo, object);
638 EXPECT_EQ(result, SUCCESS);
639 EXPECT_TRUE(AcquireDataSubscribeManager::GetInstance().Publish(event));
640 result = AcquireDataSubscribeManager::GetInstance().RemoveSubscribeRecord(object);
641 EXPECT_EQ(result, SUCCESS);
642 }
643
644 HWTEST_F(SecurityGuardDataCollectSaTest, Publish_DifferentEventId03, TestSize.Level1)
645 {
646 SecEvent event {
647 .eventId = SecurityCollector::NETWORK_EVENTID,
648 .version = "version",
649 .content = "content"
650 };
651 SecurityCollector::Event event2 {
652 .eventId = SecurityCollector::NETWORK_EVENTID,
653 .version = "version",
654 .content = "content",
655 .extra = ""
656 };
657 SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo(event2);
658 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
659 EXPECT_CALL(DatabaseManager::GetInstance(), SubscribeDb).WillRepeatedly(Return(SUCCESS));
660 EXPECT_CALL(DatabaseManager::GetInstance(), UnSubscribeDb).WillRepeatedly(Return(SUCCESS));
661 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
662 EXPECT_CALL(*obj, SendRequest)
__anon3c63228d0f02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 663 .WillOnce([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
664 service.OnRemoteRequest(code, data, reply, option);
665 return SUCCESS;
666 });
667 int32_t result = AcquireDataSubscribeManager::GetInstance().InsertSubscribeRecord(subscribeInfo, obj);
668 EXPECT_EQ(result, SUCCESS);
669 EXPECT_TRUE(AcquireDataSubscribeManager::GetInstance().Publish(event));
670 result = AcquireDataSubscribeManager::GetInstance().RemoveSubscribeRecord(obj);
671 EXPECT_EQ(result, SUCCESS);
672 }
673
674 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd01, TestSize.Level1)
675 {
676 MessageParcel data;
677 MessageParcel reply;
678 MessageOption option;
679
680 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
681 data.WriteInt32(DataCollectManagerService::CMD_DATA_REQUEST);
682 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
683 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_DATA_COLLECT, data, reply, option);
684 EXPECT_EQ(result, BAD_PARAM);
685 }
686
687 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd02, TestSize.Level1)
688 {
689 MessageParcel data;
690 MessageParcel reply;
691 MessageOption option;
692
693 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
694 data.WriteInt32(DataCollectManagerService::CMD_DATA_REQUEST);
695 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
696 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_DATA_REQUEST, data, reply, option);
697 EXPECT_EQ(result, BAD_PARAM);
698 }
699
700 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd03, TestSize.Level1)
701 {
702 MessageParcel data;
703 MessageParcel reply;
704 MessageOption option;
705
706 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
707 data.WriteInt32(DataCollectManagerService::CMD_DATA_SUBSCRIBE);
708 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
709 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_DATA_SUBSCRIBE, data, reply, option);
710 EXPECT_EQ(result, BAD_PARAM);
711 }
712
713 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd04, TestSize.Level1)
714 {
715 MessageParcel data;
716 MessageParcel reply;
717 MessageOption option;
718
719 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
720 data.WriteInt32(DataCollectManagerService::CMD_DATA_UNSUBSCRIBE);
721 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
722 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_DATA_UNSUBSCRIBE, data, reply, option);
723 EXPECT_EQ(result, BAD_PARAM);
724 }
725
726 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd05, TestSize.Level1)
727 {
728 MessageParcel data;
729 MessageParcel reply;
730 MessageOption option;
731
732 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
733 data.WriteInt32(DataCollectManagerService::CMD_SECURITY_EVENT_QUERY);
734 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
735 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_EVENT_QUERY,
736 data, reply, option);
737 EXPECT_EQ(result, BAD_PARAM);
738 }
739
740 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd06, TestSize.Level1)
741 {
742 MessageParcel data;
743 MessageParcel reply;
744 MessageOption option;
745
746 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
747 data.WriteInt64(0);
748 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
749 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_DATA_COLLECT, data, reply, option);
750 EXPECT_EQ(result, BAD_PARAM);
751 }
752
753 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd07, TestSize.Level1)
754 {
755 MessageParcel data;
756 MessageParcel reply;
757 MessageOption option;
758
759 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
760 data.WriteInt64(0);
761 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
762 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_DATA_REQUEST, data, reply, option);
763 EXPECT_EQ(result, BAD_PARAM);
764 }
765
766 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd08, TestSize.Level1)
767 {
768 MessageParcel data;
769 MessageParcel reply;
770 MessageOption option;
771
772 SecurityCollector::Event event {
773 .eventId = 0,
774 .version = "version",
775 .content = "content",
776 .extra = ""
777 };
778 SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo(event);
779 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
780 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
781 data.WriteParcelable(&subscribeInfo);
782 data.WriteRemoteObject(obj);
783 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
784 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_DATA_SUBSCRIBE, data, reply, option);
785 EXPECT_EQ(result, BAD_PARAM);
786 }
787
788 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd09, TestSize.Level1)
789 {
790 MessageParcel data;
791 MessageParcel reply;
792 MessageOption option;
793
794 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
795 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
796 data.WriteRemoteObject(obj);
797
798 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillRepeatedly(
799 Return(AccessToken::PermissionState::PERMISSION_DENIED));
800 EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(Return(true));
801 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
802 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_DATA_UNSUBSCRIBE, data, reply, option);
803 EXPECT_EQ(result, NO_PERMISSION);
804 }
805
806 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd10, TestSize.Level1)
807 {
808 MessageParcel data;
809 MessageParcel reply;
810 MessageOption option;
811
812 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
813 data.WriteUint32(MAX_QUERY_EVENT_SIZE + 1);
814 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
815 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_EVENT_QUERY,
816 data, reply, option);
817 EXPECT_EQ(result, BAD_PARAM);
818 }
819
820 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd11, TestSize.Level1)
821 {
822 MessageParcel data;
823 MessageParcel reply;
824 MessageOption option;
825
826 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
827 data.WriteUint32(1);
828 SecurityCollector::SecurityEventRuler ruler;
829 data.WriteParcelable(&ruler);
830 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
831 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_EVENT_QUERY,
832 data, reply, option);
833 EXPECT_EQ(result, BAD_PARAM);
834 }
835
836 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd12, TestSize.Level1)
837 {
838 MessageParcel data;
839 MessageParcel reply;
840 MessageOption option;
841
842 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
843 data.WriteUint32(1);
844 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
845 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_COLLECTOR_START,
846 data, reply, option);
847 EXPECT_EQ(result, BAD_PARAM);
848 }
849
850 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd13, TestSize.Level1)
851 {
852 MessageParcel data;
853 MessageParcel reply;
854 MessageOption option;
855 SecurityCollector::Event event {};
856 SecurityCollector::SecurityCollectorSubscribeInfo subscriberInfo(event, -1, false);
857 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
858 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
859 data.WriteRemoteObject(obj);
860
861 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
862 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_COLLECTOR_START,
863 data, reply, option);
864 EXPECT_EQ(result, BAD_PARAM);
865 }
866
867 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd14, TestSize.Level1)
868 {
869 MessageParcel data;
870 MessageParcel reply;
871 MessageOption option;
872 SecurityCollector::Event event {};
873 SecurityCollector::SecurityCollectorSubscribeInfo subscriberInfo(event, -1, false);
874 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
875 data.WriteFileDescriptor(-1);
876 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
877 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_CONFIG_UPDATE,
878 data, reply, option);
879 EXPECT_EQ(result, BAD_PARAM);
880 }
881
882 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd15, TestSize.Level1)
883 {
884 MessageParcel data;
885 MessageParcel reply;
886 MessageOption option;
887 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
888 data.WriteString("test");
889 data.WriteFileDescriptor(-1);
890 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
891 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_CONFIG_UPDATE,
892 data, reply, option);
893 EXPECT_EQ(result, BAD_PARAM);
894 }
895
896 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd16, TestSize.Level1)
897 {
898 MessageParcel data;
899 MessageParcel reply;
900 MessageOption option;
901 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
902 data.WriteString("test");
903 data.WriteFileDescriptor(1);
904 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
905 Return(AccessToken::PermissionState::PERMISSION_DENIED));
906 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
907 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_CONFIG_UPDATE,
908 data, reply, option);
909 EXPECT_EQ(result, NO_PERMISSION);
910 }
911
912
913 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd17, TestSize.Level1)
914 {
915 MessageParcel data;
916 MessageParcel reply;
917 MessageOption option;
918 SecurityCollector::Event event {};
919 SecurityCollector::SecurityCollectorSubscribeInfo subscriberInfo(event, -1, false);
920 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
921 data.WriteUint32(1);
922 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
923 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_COLLECTOR_STOP,
924 data, reply, option);
925 EXPECT_EQ(result, BAD_PARAM);
926 }
927
928 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithDataRequestCmd18, TestSize.Level1)
929 {
930 MessageParcel data;
931 MessageParcel reply;
932 MessageOption option;
933 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
934 data.WriteUint32(1);
935 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
936 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_SECURITY_COLLECTOR_STOP,
937 data, reply, option);
938 EXPECT_EQ(result, BAD_PARAM);
939 }
940
941 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithInvalidCmd, TestSize.Level1)
942 {
943 MessageParcel data;
944 MessageParcel reply;
945 MessageOption option;
946
947 data.WriteInterfaceToken(IDataCollectManager::GetDescriptor());
948 data.WriteInt32(100);
949 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
950 int32_t result = service.OnRemoteRequest(100, data, reply, option);
951
952 EXPECT_EQ(result, 305);
953 }
954
955 HWTEST_F(SecurityGuardDataCollectSaTest, TestOnRemoteRequestWithInvalidToken, TestSize.Level1)
956 {
957 MessageParcel data;
958 MessageParcel reply;
959 MessageOption option;
960
961 data.WriteInterfaceToken(u"InvalidToken");
962 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
963 int32_t result = service.OnRemoteRequest(DataCollectManagerService::CMD_DATA_COLLECT, data, reply, option);
964
965 EXPECT_EQ(result, 305);
966 }
967
968 HWTEST_F(SecurityGuardDataCollectSaTest, AcquireDataSubscribeSc01, TestSize.Level1)
969 {
970 AcquireDataSubscribeManager adsm {};
971 SecurityCollector::Event event {
972 .eventId = 111
973 };
974 adsm.scSubscribeMap_.insert({111,
975 std::make_shared<AcquireDataSubscribeManager::SecurityCollectorSubscriber>(event)});
976 int result = adsm.SubscribeSc(111);
977 EXPECT_EQ(result, SUCCESS);
978 }
979
980 HWTEST_F(SecurityGuardDataCollectSaTest, AcquireDataSubscribeSc02, TestSize.Level1)
981 {
982 AcquireDataSubscribeManager adsm {};
983 SecurityCollector::Event event {
984 .eventId = 111
985 };
986 EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(
__anon3c63228d1002(int64_t eventId, EventCfg &config) 987 [] (int64_t eventId, EventCfg &config) {
988 config.dbTable = "risk_event";
989 config.eventType = 3;
990 config.prog = "security_guard";
991 return true;
992 });
993 int result = adsm.SubscribeSc(111);
994 EXPECT_EQ(result, FAILED);
995 result = adsm.UnSubscribeSc(111);
996 EXPECT_EQ(result, FAILED);
997 }
998
999 HWTEST_F(SecurityGuardDataCollectSaTest, AcquireDataSubscribeSc03, TestSize.Level1)
1000 {
1001 AcquireDataSubscribeManager adsm {};
1002 SecurityCollector::Event event {
1003 .eventId = 111
1004 };
1005 EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(
__anon3c63228d1102(int64_t eventId, EventCfg &config) 1006 [] (int64_t eventId, EventCfg &config) {
1007 config.dbTable = "risk_event";
1008 config.eventType = 3;
1009 config.prog = "";
1010 return true;
1011 });
1012 EXPECT_CALL(SecurityCollector::CollectorManager::GetInstance(), Subscribe(_)).WillOnce(Return(FAILED));
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, AcquireDataSubscribeSc04, TestSize.Level1)
1020 {
1021 AcquireDataSubscribeManager adsm {};
1022 SecurityCollector::Event event {
1023 .eventId = 111
1024 };
1025 EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(
__anon3c63228d1202(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(SUCCESS));
1033 int result = adsm.SubscribeSc(111);
1034 EXPECT_EQ(result, SUCCESS);
1035 EXPECT_CALL(SecurityCollector::CollectorManager::GetInstance(), Unsubscribe(_)).WillOnce(Return(SUCCESS));
1036 result = adsm.UnSubscribeSc(111);
1037 EXPECT_EQ(result, SUCCESS);
1038 }
1039
1040 HWTEST_F(SecurityGuardDataCollectSaTest, AcquireDataUnSubscribeSc01, TestSize.Level1)
1041 {
1042 AcquireDataSubscribeManager adsm {};
1043 SecurityCollector::Event event {
1044 .eventId = 111
1045 };
1046 EXPECT_CALL(ConfigDataManager::GetInstance(), GetEventConfig).WillRepeatedly(
__anon3c63228d1302(int64_t eventId, EventCfg &config) 1047 [] (int64_t eventId, EventCfg &config) {
1048 config.dbTable = "risk_event";
1049 config.eventType = 3;
1050 config.prog = "";
1051 return false;
1052 });
1053 int32_t result = adsm.UnSubscribeSc(111);
1054 EXPECT_EQ(result, BAD_PARAM);
1055 }
1056
1057 HWTEST_F(SecurityGuardDataCollectSaTest, QuerySecurityEvent, TestSize.Level1)
1058 {
1059 SecurityCollector::SecurityEventRuler rule(11111);
1060 std::vector<SecurityCollector::SecurityEventRuler> rules {};
1061 rules.emplace_back(rule);
1062 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1063 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillRepeatedly(
1064 Return(AccessToken::PermissionState::PERMISSION_DENIED));
1065 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1066 int32_t result = service.QuerySecurityEvent(rules, obj);
1067 EXPECT_EQ(result, NO_PERMISSION);
1068 }
1069
1070 HWTEST_F(SecurityGuardDataCollectSaTest, QuerySecurityEvent01, TestSize.Level1)
1071 {
1072 SecurityCollector::SecurityEventRuler rule(11111);
1073 std::vector<SecurityCollector::SecurityEventRuler> rules {};
1074 rules.emplace_back(rule);
1075 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1076 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1077 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1078 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1079 Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1080 EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1081 Return(true));
1082 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1083 int32_t result = service.QuerySecurityEvent(rules, obj);
1084 EXPECT_CALL(*obj, SendRequest).Times(1);
1085 EXPECT_EQ(result, SUCCESS);
1086 }
1087
1088 HWTEST_F(SecurityGuardDataCollectSaTest, QuerySecurityEvent02, TestSize.Level1)
1089 {
1090 SecurityCollector::SecurityEventRuler rule(11111);
1091 std::vector<SecurityCollector::SecurityEventRuler> rules {};
1092 rules.emplace_back(rule);
1093 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1094 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1095 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1096 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1097 Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1098 EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1099 Return(false));
1100 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1101 int32_t result = service.QuerySecurityEvent(rules, obj);
1102 EXPECT_EQ(result, NO_SYSTEMCALL);
1103 }
1104
1105 HWTEST_F(SecurityGuardDataCollectSaTest, CollectorStart01, TestSize.Level1)
1106 {
1107 SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo {};
1108 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1109 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillRepeatedly(
1110 Return(AccessToken::PermissionState::PERMISSION_DENIED));
1111 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1112 int32_t result = service.CollectorStart(subscribeInfo, obj);
1113 EXPECT_EQ(result, NO_PERMISSION);
1114 }
1115
1116 HWTEST_F(SecurityGuardDataCollectSaTest, CollectorStart02, TestSize.Level1)
1117 {
1118 SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo {};
1119 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1120 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1121 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1122 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1123 Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1124 EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1125 Return(false));
1126 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1127 int32_t result = service.CollectorStart(subscribeInfo, obj);
1128 EXPECT_EQ(result, NO_SYSTEMCALL);
1129 }
1130
1131 HWTEST_F(SecurityGuardDataCollectSaTest, CollectorStart03, TestSize.Level1)
1132 {
1133 SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo {};
1134 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1135 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1136 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1137 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1138 Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1139 EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1140 Return(true));
1141 EXPECT_CALL(SecurityCollector::CollectorManager::GetInstance(), CollectorStart(_)).WillOnce(Return(FAILED));
1142 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1143 int32_t result = service.CollectorStart(subscribeInfo, obj);
1144 EXPECT_EQ(result, FAILED);
1145 }
1146
1147 HWTEST_F(SecurityGuardDataCollectSaTest, CollectorStart04, TestSize.Level1)
1148 {
1149 SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo {};
1150 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1151 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1152 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1153 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1154 Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1155 EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1156 Return(true));
1157 EXPECT_CALL(SecurityCollector::CollectorManager::GetInstance(), CollectorStart(_)).WillOnce(Return(SUCCESS));
1158 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1159 int32_t result = service.CollectorStart(subscribeInfo, obj);
1160 EXPECT_EQ(result, SUCCESS);
1161 }
1162
1163 HWTEST_F(SecurityGuardDataCollectSaTest, CollectorStop01, TestSize.Level1)
1164 {
1165 SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo {};
1166 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1167 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillRepeatedly(
1168 Return(AccessToken::PermissionState::PERMISSION_DENIED));
1169 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1170 int32_t result = service.CollectorStop(subscribeInfo, obj);
1171 EXPECT_EQ(result, NO_PERMISSION);
1172 }
1173
1174 HWTEST_F(SecurityGuardDataCollectSaTest, CollectorStop02, TestSize.Level1)
1175 {
1176 SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo {};
1177 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1178 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1179 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1180 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1181 Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1182 EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1183 Return(false));
1184 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1185 int32_t result = service.CollectorStop(subscribeInfo, obj);
1186 EXPECT_EQ(result, NO_SYSTEMCALL);
1187 }
1188
1189 HWTEST_F(SecurityGuardDataCollectSaTest, CollectorStop03, TestSize.Level1)
1190 {
1191 SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo {};
1192 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1193 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1194 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1195 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1196 Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1197 EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1198 Return(true));
1199 EXPECT_CALL(SecurityCollector::CollectorManager::GetInstance(), CollectorStop(_)).WillOnce(Return(FAILED));
1200 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1201 int32_t result = service.CollectorStop(subscribeInfo, obj);
1202 EXPECT_EQ(result, FAILED);
1203 }
1204
1205 HWTEST_F(SecurityGuardDataCollectSaTest, CollectorStop04, TestSize.Level1)
1206 {
1207 SecurityCollector::SecurityCollectorSubscribeInfo subscribeInfo {};
1208 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
1209 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1210 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1211 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1212 Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1213 EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1214 Return(true));
1215 EXPECT_CALL(SecurityCollector::CollectorManager::GetInstance(), CollectorStop(_)).WillOnce(Return(SUCCESS));
1216 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1217 int32_t result = service.CollectorStop(subscribeInfo, obj);
1218 EXPECT_EQ(result, SUCCESS);
1219 }
1220
1221 HWTEST_F(SecurityGuardDataCollectSaTest, ConfigUpdate01, TestSize.Level1)
1222 {
1223 SecurityGuard::SecurityConfigUpdateInfo subscribeInfo {};
1224 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1225 Return(AccessToken::PermissionState::PERMISSION_DENIED));
1226 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1227 int32_t result = service.ConfigUpdate(subscribeInfo);
1228 EXPECT_EQ(result, NO_PERMISSION);
1229 }
1230
1231 HWTEST_F(SecurityGuardDataCollectSaTest, ConfigUpdate02, TestSize.Level1)
1232 {
1233 SecurityGuard::SecurityConfigUpdateInfo subscribeInfo {};
1234 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1235 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1236 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1237 Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1238 EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1239 Return(false));
1240 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1241 int32_t result = service.ConfigUpdate(subscribeInfo);
1242 EXPECT_EQ(result, NO_SYSTEMCALL);
1243 }
1244
1245 HWTEST_F(SecurityGuardDataCollectSaTest, ConfigUpdate03, TestSize.Level1)
1246 {
1247 SecurityGuard::SecurityConfigUpdateInfo subscribeInfo {};
1248 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1249 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1250 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1251 Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1252 EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1253 Return(true));
1254 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1255 int32_t result = service.ConfigUpdate(subscribeInfo);
1256 EXPECT_EQ(result, BAD_PARAM);
1257 }
1258
1259 HWTEST_F(SecurityGuardDataCollectSaTest, ConfigUpdate04, TestSize.Level1)
1260 {
1261 SecurityGuard::SecurityConfigUpdateInfo subscribeInfo (-1, "local_app_attribute.json");
1262 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
1263 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
1264 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
1265 Return(AccessToken::TypeATokenTypeEnum::TOKEN_HAP));
1266 EXPECT_CALL(*(AccessToken::TokenIdKit::GetInterface()), IsSystemAppByFullTokenID).WillOnce(
1267 Return(true));
1268 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1269 int32_t result = service.ConfigUpdate(subscribeInfo);
1270 EXPECT_EQ(result, FAILED);
1271 }
1272
1273 HWTEST_F(SecurityGuardDataCollectSaTest, WriteRemoteFileToLocal01, TestSize.Level1)
1274 {
1275 std::ofstream out ("data/test/unittest/resource/test.json");
1276 std::string errTmp = R"({
1277 "version" : "001",
1278 "apps": ""
1279 })";
1280 out << errTmp << std::endl;
1281 int32_t fd = open("data/test/unittest/resource/test.json", O_RDONLY);
1282 SecurityGuard::SecurityConfigUpdateInfo subscribeInfo(fd, "test.json");
1283 DataCollectManagerService service(DATA_COLLECT_MANAGER_SA_ID, true);
1284 std::string toPath = "/data/test/unittest/resource/";
1285 int32_t result = service.WriteRemoteFileToLocal(subscribeInfo, toPath + "testFile.json");
1286 close(fd);
1287 EXPECT_EQ(result, FAILED);
1288 }
1289 }
1290