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 #include <memory> 16 #include "gmock/gmock.h" 17 #define private public 18 #include "data_collection.h" 19 #include "security_event_ruler.h" 20 #include "collector_cfg_marshalling.h" 21 #undef private 22 using namespace testing; 23 using namespace testing::ext; 24 using namespace OHOS::Security::SecurityCollector; 25 namespace OHOS::Security::SecurityCollectorTest { 26 class DataCollectionTest : public testing::Test { 27 public: SetUpTestCase()28 static void SetUpTestCase() {}; 29 TearDownTestCase()30 static void TearDownTestCase() {}; 31 SetUp()32 void SetUp() override {}; 33 TearDown()34 void TearDown() override {}; 35 }; 36 37 class TestFwk : public SecurityCollector::ICollectorFwk { 38 public: OnNotify(const Event & event)39 void OnNotify(const Event &event) override {}; GetExtraInfo()40 std::string GetExtraInfo() override { return "";}; 41 }; 42 43 class TestCollector : public SecurityCollector::ICollector { 44 public: Start(std::shared_ptr<ICollectorFwk> api)45 int Start(std::shared_ptr<ICollectorFwk> api) override {return 0;}; Stop()46 int Stop() override {return 0;}; 47 }; 48 49 class MockMyClass : public DataCollection { 50 public: 51 MOCK_METHOD3(LoadCollector, ErrorCode( 52 int64_t eventId, std::string path, std::shared_ptr<ICollectorFwk> api)); 53 MOCK_METHOD2(GetCollectorPath, ErrorCode(int64_t eventId, std::string &path)); 54 MOCK_METHOD1(IsCollectorStarted, bool(int64_t eventId)); 55 }; 56 57 HWTEST_F(DataCollectionTest, Instance01, testing::ext::TestSize.Level0) 58 { 59 int32_t type = 0; 60 EXPECT_TRUE(DataCollection::GetInstance().GetCollectorType(0, type) != SUCCESS); 61 } 62 63 HWTEST_F(DataCollectionTest, Instance02, testing::ext::TestSize.Level0) 64 { 65 std::shared_ptr<ICollectorFwk> api = std::make_shared<TestFwk> (); 66 EXPECT_EQ(DataCollection::GetInstance().LoadCollector(1, "", api), FAILED); 67 std::vector<SecurityEvent> eventIds {}; 68 SecurityEventRuler ruler; 69 EXPECT_EQ(DataCollection::GetInstance().LoadCollector("", ruler, eventIds), FAILED); 70 } 71 72 HWTEST_F(DataCollectionTest, StartCollectors01, testing::ext::TestSize.Level0) 73 { 74 DataCollection collec {}; 75 std::vector<int64_t> eventIds {}; 76 std::shared_ptr<SecurityCollector::ICollectorFwk> api; 77 EXPECT_FALSE(collec.StartCollectors(eventIds, api)); 78 eventIds.emplace_back(1); 79 EXPECT_FALSE(collec.StartCollectors(eventIds, api)); 80 } 81 82 HWTEST_F(DataCollectionTest, StartCollectors02, testing::ext::TestSize.Level0) 83 { 84 DataCollection collec {}; 85 std::vector<int64_t> eventIds {1}; 86 std::shared_ptr<SecurityCollector::ICollectorFwk> api = std::make_shared<TestFwk> (); 87 EXPECT_FALSE(collec.StartCollectors(eventIds, api)); 88 } 89 90 HWTEST_F(DataCollectionTest, StartCollectors03, testing::ext::TestSize.Level0) 91 { 92 MockMyClass myOb; 93 std::vector<int64_t> eventIds {1}; 94 std::shared_ptr<SecurityCollector::ICollectorFwk> api = std::make_shared<TestFwk> (); 95 EXPECT_CALL(myOb, IsCollectorStarted).WillOnce(Return(false)); 96 EXPECT_CALL(myOb, GetCollectorPath).WillOnce(Return(SUCCESS)); 97 EXPECT_CALL(myOb, LoadCollector(1, "", api)).WillOnce(Return(SUCCESS)); 98 EXPECT_TRUE(myOb.StartCollectors(eventIds, api)); 99 } 100 101 HWTEST_F(DataCollectionTest, StartCollectors04, testing::ext::TestSize.Level0) 102 { 103 MockMyClass myOb; 104 std::vector<int64_t> eventIds {1}; 105 std::shared_ptr<SecurityCollector::ICollectorFwk> api = std::make_shared<TestFwk> (); 106 EXPECT_CALL(myOb, IsCollectorStarted).WillOnce(Return(false)); 107 EXPECT_CALL(myOb, GetCollectorPath).WillOnce(Return(SUCCESS)); 108 EXPECT_CALL(myOb, LoadCollector(1, "", api)).WillOnce(Return(FAILED)); 109 EXPECT_FALSE(myOb.StartCollectors(eventIds, api)); 110 } 111 112 HWTEST_F(DataCollectionTest, StartCollectors05, testing::ext::TestSize.Level0) 113 { 114 MockMyClass myOb; 115 std::vector<int64_t> eventIds {1}; 116 std::shared_ptr<SecurityCollector::ICollectorFwk> api = std::make_shared<TestFwk> (); 117 EXPECT_CALL(myOb, GetCollectorPath).WillOnce(Return(FAILED)); 118 EXPECT_CALL(myOb, IsCollectorStarted).WillOnce(Return(false)); 119 EXPECT_FALSE(myOb.StartCollectors(eventIds, api)); 120 } 121 122 HWTEST_F(DataCollectionTest, StartCollectors06, testing::ext::TestSize.Level0) 123 { 124 MockMyClass myOb; 125 std::vector<int64_t> eventIds {1}; 126 std::shared_ptr<SecurityCollector::ICollectorFwk> api = std::make_shared<TestFwk> (); 127 EXPECT_CALL(myOb, IsCollectorStarted).WillOnce(Return(true)); 128 EXPECT_TRUE(myOb.StartCollectors(eventIds, api)); 129 } 130 131 HWTEST_F(DataCollectionTest, StopCollectors01, testing::ext::TestSize.Level0) 132 { 133 DataCollection myOb; 134 std::vector<int64_t> eventIds; 135 EXPECT_TRUE(myOb.StopCollectors(eventIds)); 136 } 137 138 HWTEST_F(DataCollectionTest, StopCollectors02, testing::ext::TestSize.Level0) 139 { 140 DataCollection myOb; 141 std::vector<int64_t> eventIds {1}; 142 EXPECT_TRUE(myOb.StopCollectors(eventIds)); 143 } 144 145 HWTEST_F(DataCollectionTest, StopCollectors03, testing::ext::TestSize.Level0) 146 { 147 DataCollection myOb; 148 std::vector<int64_t> eventIds {1}; 149 EXPECT_TRUE(myOb.StopCollectors(eventIds)); 150 } 151 152 HWTEST_F(DataCollectionTest, StopCollectors04, testing::ext::TestSize.Level0) 153 { 154 DataCollection myOb; 155 myOb.eventIdToLoaderMap_.emplace(1, LibLoader("testPath")); 156 std::vector<int64_t> eventIds {1}; 157 EXPECT_FALSE(myOb.StopCollectors(eventIds)); 158 } 159 160 class MockMyCheckFileStreamClass : public DataCollection { 161 public: 162 MOCK_METHOD1(CheckFileStream, ErrorCode(std::ifstream &stream)); 163 }; 164 165 HWTEST_F(DataCollectionTest, GetCollectorPath01, testing::ext::TestSize.Level0) 166 { 167 MockMyCheckFileStreamClass myOb; 168 std::string path; 169 EXPECT_CALL(myOb, CheckFileStream).WillOnce(Return(FAILED)); 170 EXPECT_EQ(myOb.GetCollectorPath(1, path), FAILED); 171 } 172 173 HWTEST_F(DataCollectionTest, GetCollectorPath02, testing::ext::TestSize.Level0) 174 { 175 MockMyCheckFileStreamClass myOb; 176 std::string path; 177 EXPECT_CALL(myOb, CheckFileStream).WillOnce(Return(SUCCESS)); 178 EXPECT_EQ(myOb.GetCollectorPath(0, path), FAILED); 179 } 180 181 HWTEST_F(DataCollectionTest, GetCollectorType01, testing::ext::TestSize.Level0) 182 { 183 MockMyCheckFileStreamClass myOb; 184 int32_t collectorType; 185 EXPECT_CALL(myOb, CheckFileStream).WillOnce(Return(FAILED)); 186 EXPECT_EQ(myOb.GetCollectorType(1, collectorType), FAILED); 187 } 188 189 HWTEST_F(DataCollectionTest, GetCollectorType02, testing::ext::TestSize.Level0) 190 { 191 MockMyCheckFileStreamClass myOb; 192 int32_t collectorType; 193 EXPECT_CALL(myOb, CheckFileStream).WillOnce(Return(SUCCESS)); 194 EXPECT_EQ(myOb.GetCollectorType(0, collectorType), FAILED); 195 } 196 197 class MockQuerySecurityEventClass : public DataCollection { 198 public: 199 MOCK_METHOD3(LoadCollector, ErrorCode(std::string path, const SecurityEventRuler &ruler, 200 std::vector<SecurityEvent> &events)); 201 MOCK_METHOD2(GetCollectorPath, ErrorCode(int64_t eventId, std::string& path)); 202 }; 203 204 HWTEST_F(DataCollectionTest, SecurityGuardSubscribeCollector01, testing::ext::TestSize.Level0) 205 { 206 std::vector<int64_t> eventIds; 207 MockMyClass myOb; 208 EXPECT_TRUE(myOb.SecurityGuardSubscribeCollector(eventIds)); 209 } 210 211 HWTEST_F(DataCollectionTest, SecurityGuardSubscribeCollector04, testing::ext::TestSize.Level0) 212 { 213 std::vector<int64_t> eventIds {1}; 214 MockMyClass myOb; 215 std::shared_ptr<SecurityCollector::ICollectorFwk> api; 216 EXPECT_CALL(myOb, GetCollectorPath).WillOnce(Return(SUCCESS)); 217 EXPECT_CALL(myOb, LoadCollector(1, "", api)).WillOnce(Return(SUCCESS)); 218 EXPECT_CALL(myOb, IsCollectorStarted).WillOnce(Return(false)); 219 EXPECT_TRUE(myOb.SecurityGuardSubscribeCollector(eventIds)); 220 } 221 222 HWTEST_F(DataCollectionTest, SecurityGuardSubscribeCollector02, testing::ext::TestSize.Level0) 223 { 224 std::vector<int64_t> eventIds {1}; 225 MockMyClass myOb; 226 std::shared_ptr<SecurityCollector::ICollectorFwk> api; 227 EXPECT_CALL(myOb, GetCollectorPath).WillOnce(Return(SUCCESS)); 228 EXPECT_CALL(myOb, LoadCollector(1, "", api)).WillOnce(Return(FAILED)); 229 EXPECT_CALL(myOb, IsCollectorStarted).WillOnce(Return(false)); 230 EXPECT_TRUE(myOb.SecurityGuardSubscribeCollector(eventIds)); 231 } 232 233 HWTEST_F(DataCollectionTest, SecurityGuardSubscribeCollector03, testing::ext::TestSize.Level0) 234 { 235 std::vector<int64_t> eventIds {1}; 236 MockMyClass myOb; 237 EXPECT_CALL(myOb, GetCollectorPath).WillOnce(Return(FAILED)); 238 EXPECT_CALL(myOb, IsCollectorStarted).WillOnce(Return(false)); 239 EXPECT_TRUE(myOb.SecurityGuardSubscribeCollector(eventIds)); 240 } 241 242 HWTEST_F(DataCollectionTest, SecurityGuardSubscribeCollector05, testing::ext::TestSize.Level0) 243 { 244 std::vector<int64_t> eventIds {1}; 245 MockMyClass myOb; 246 std::shared_ptr<SecurityCollector::ICollectorFwk> api = std::make_shared<TestFwk> (); 247 EXPECT_CALL(myOb, IsCollectorStarted).WillOnce(Return(true)); 248 EXPECT_TRUE(myOb.SecurityGuardSubscribeCollector(eventIds)); 249 } 250 251 HWTEST_F(DataCollectionTest, SecurityGuardSubscribeCollector06, testing::ext::TestSize.Level0) 252 { 253 MockQuerySecurityEventClass myOb; 254 std::vector<SecurityEvent> events; 255 std::vector<SecurityEventRuler> rulers; 256 EXPECT_EQ(myOb.QuerySecurityEvent(rulers, events), FAILED); 257 258 SecurityEventRuler rule(11111); 259 std::string path("/system/lib64/chipset-pub-sdk/libeventhandler.z.so"); 260 rulers.emplace_back(rule); 261 EXPECT_CALL(myOb, GetCollectorPath).WillOnce(Return(SUCCESS)); 262 EXPECT_CALL(myOb, LoadCollector).WillOnce(Return(SUCCESS)); 263 EXPECT_EQ(myOb.QuerySecurityEvent(rulers, events), SUCCESS); 264 } 265 266 HWTEST_F(DataCollectionTest, SecurityGuardSubscribeCollector07, testing::ext::TestSize.Level0) 267 { 268 MockQuerySecurityEventClass myOb; 269 std::vector<SecurityEvent> events; 270 std::vector<SecurityEventRuler> rulers; 271 EXPECT_EQ(myOb.QuerySecurityEvent(rulers, events), FAILED); 272 273 SecurityEventRuler rule(11111); 274 std::string path("/system/lib64/chipset-pub-sdk/libeventhandler.z.so"); 275 rulers.emplace_back(rule); 276 EXPECT_CALL(myOb, GetCollectorPath).WillOnce(Return(FAILED)); 277 278 EXPECT_EQ(myOb.QuerySecurityEvent(rulers, events), FAILED); 279 } 280 281 HWTEST_F(DataCollectionTest, SecurityGuardSubscribeCollector08, testing::ext::TestSize.Level0) 282 { 283 MockQuerySecurityEventClass myOb; 284 std::vector<SecurityEvent> events; 285 std::vector<SecurityEventRuler> rulers; 286 EXPECT_EQ(myOb.QuerySecurityEvent(rulers, events), FAILED); 287 288 SecurityEventRuler rule(11111); 289 std::string path("/system/lib64/chipset-pub-sdk/libeventhandler.z.so"); 290 rulers.emplace_back(rule); 291 292 EXPECT_CALL(myOb, GetCollectorPath).WillOnce(Return(SUCCESS)); 293 EXPECT_CALL(myOb, LoadCollector).WillOnce(Return(FAILED)); 294 EXPECT_EQ(myOb.QuerySecurityEvent(rulers, events), FAILED); 295 } 296 297 HWTEST_F(DataCollectionTest, LoadCollectorWithApi01, testing::ext::TestSize.Level0) 298 { 299 std::string path = "/system/lib64/module/security/libsecurityguard_napi.z.so"; 300 std::shared_ptr<ICollectorFwk> api = nullptr; 301 int64_t eventId = 1; 302 EXPECT_EQ(DataCollection::GetInstance().LoadCollector(eventId, path, api), FAILED); 303 } 304 305 HWTEST_F(DataCollectionTest, LoadCollectorWithNonApi01, testing::ext::TestSize.Level0) 306 { 307 std::string path = "/system/lib64/module/security/libsecurityguard_napi.z.so"; 308 std::vector<SecurityEvent> events; 309 SecurityCollector::SecurityEventRuler ruler(11111); 310 EXPECT_EQ(DataCollection::GetInstance().LoadCollector(path, ruler, events), FAILED); 311 } 312 313 HWTEST_F(DataCollectionTest, AddFilter, testing::ext::TestSize.Level1) 314 { 315 MockMyClass myOb; 316 SecurityCollector::SecurityCollectorEventMuteFilter collectorFilter {}; 317 collectorFilter.eventId = 1; 318 collectorFilter.mutes.insert("1111"); 319 collectorFilter.type = 1; 320 collectorFilter.isSetMute = false; 321 myOb.eventIdToLoaderMap_.emplace(1, LibLoader("testPath")); 322 EXPECT_CALL(myOb, IsCollectorStarted).WillOnce(Return(false)).WillOnce(Return(true)); 323 EXPECT_EQ(myOb.AddFilter(collectorFilter), FAILED); 324 EXPECT_EQ(myOb.AddFilter(collectorFilter), NULL_OBJECT); 325 } 326 327 HWTEST_F(DataCollectionTest, RemoveFilter, testing::ext::TestSize.Level1) 328 { 329 MockMyClass myOb; 330 SecurityCollector::SecurityCollectorEventMuteFilter collectorFilter {}; 331 collectorFilter.eventId = 1; 332 collectorFilter.mutes.insert("1111"); 333 collectorFilter.type = 1; 334 collectorFilter.isSetMute = false; 335 ModuleCfgSt st {}; 336 nlohmann::json json = st; 337 myOb.eventIdToLoaderMap_.emplace(1, LibLoader("testPath")); 338 EXPECT_CALL(myOb, IsCollectorStarted).WillOnce(Return(false)).WillOnce(Return(true)); 339 EXPECT_EQ(myOb.RemoveFilter(collectorFilter), FAILED); 340 EXPECT_EQ(myOb.RemoveFilter(collectorFilter), NULL_OBJECT); 341 } 342 343 HWTEST_F(DataCollectionTest, ICollector01, testing::ext::TestSize.Level1) 344 { 345 TestCollector collector; 346 SecurityCollector::SecurityCollectorEventMuteFilter collectorFilter {}; 347 std::vector<SecurityEvent> eventIds {}; 348 SecurityEventRuler ruler; 349 std::shared_ptr<ICollectorFwk> api = std::make_shared<TestFwk> (); 350 EXPECT_EQ(collector.IsStartWithSub(), 0); 351 EXPECT_EQ(collector.AddFilter(collectorFilter), -1); 352 EXPECT_EQ(collector.RemoveFilter(collectorFilter), -1); 353 EXPECT_EQ(collector.Query(ruler, eventIds), 0); 354 EXPECT_EQ(collector.Subscribe(api, 0), 0); 355 EXPECT_EQ(collector.Unsubscribe(0), 0); 356 } 357 358 HWTEST_F(DataCollectionTest, SubscribeCollectors01, testing::ext::TestSize.Level0) 359 { 360 DataCollection collec {}; 361 std::vector<int64_t> eventIds {}; 362 std::shared_ptr<SecurityCollector::ICollectorFwk> api; 363 EXPECT_FALSE(collec.SubscribeCollectors(eventIds, api)); 364 eventIds.emplace_back(1); 365 EXPECT_FALSE(collec.SubscribeCollectors(eventIds, api)); 366 } 367 368 HWTEST_F(DataCollectionTest, SubscribeCollectors02, testing::ext::TestSize.Level0) 369 { 370 DataCollection collec {}; 371 std::vector<int64_t> eventIds {1}; 372 std::shared_ptr<SecurityCollector::ICollectorFwk> api = std::make_shared<TestFwk> (); 373 EXPECT_FALSE(collec.SubscribeCollectors(eventIds, api)); 374 } 375 376 HWTEST_F(DataCollectionTest, SubscribeCollectors03, testing::ext::TestSize.Level0) 377 { 378 MockMyClass myOb; 379 std::vector<int64_t> eventIds {1}; 380 std::shared_ptr<SecurityCollector::ICollectorFwk> api = std::make_shared<TestFwk> (); 381 EXPECT_CALL(myOb, IsCollectorStarted).WillOnce(Return(false)); 382 EXPECT_CALL(myOb, GetCollectorPath).WillOnce(Return(SUCCESS)); 383 EXPECT_CALL(myOb, LoadCollector(1, "", api)).WillOnce(Return(SUCCESS)); 384 EXPECT_TRUE(myOb.SubscribeCollectors(eventIds, api)); 385 } 386 387 HWTEST_F(DataCollectionTest, SubscribeCollectors04, testing::ext::TestSize.Level0) 388 { 389 MockMyClass myOb; 390 std::vector<int64_t> eventIds {1}; 391 std::shared_ptr<SecurityCollector::ICollectorFwk> api = std::make_shared<TestFwk> (); 392 EXPECT_CALL(myOb, IsCollectorStarted).WillOnce(Return(false)); 393 EXPECT_CALL(myOb, GetCollectorPath).WillOnce(Return(SUCCESS)); 394 EXPECT_CALL(myOb, LoadCollector(1, "", api)).WillOnce(Return(FAILED)); 395 EXPECT_FALSE(myOb.SubscribeCollectors(eventIds, api)); 396 } 397 398 HWTEST_F(DataCollectionTest, SubscribeCollectors05, testing::ext::TestSize.Level0) 399 { 400 MockMyClass myOb; 401 std::vector<int64_t> eventIds {1}; 402 std::shared_ptr<SecurityCollector::ICollectorFwk> api = std::make_shared<TestFwk> (); 403 EXPECT_CALL(myOb, GetCollectorPath).WillOnce(Return(FAILED)); 404 EXPECT_CALL(myOb, IsCollectorStarted).WillOnce(Return(false)); 405 EXPECT_FALSE(myOb.SubscribeCollectors(eventIds, api)); 406 } 407 408 HWTEST_F(DataCollectionTest, SubscribeCollectors06, testing::ext::TestSize.Level0) 409 { 410 MockMyClass myOb; 411 std::vector<int64_t> eventIds {1}; 412 std::shared_ptr<SecurityCollector::ICollectorFwk> api = std::make_shared<TestFwk> (); 413 EXPECT_CALL(myOb, IsCollectorStarted).WillOnce(Return(true)); 414 EXPECT_TRUE(myOb.SubscribeCollectors(eventIds, api)); 415 } 416 417 HWTEST_F(DataCollectionTest, UnsubscribeCollectors01, testing::ext::TestSize.Level0) 418 { 419 DataCollection myOb; 420 std::vector<int64_t> eventIds; 421 EXPECT_TRUE(myOb.UnsubscribeCollectors(eventIds)); 422 } 423 424 HWTEST_F(DataCollectionTest, UnsubscribeCollectors02, testing::ext::TestSize.Level0) 425 { 426 DataCollection myOb; 427 std::vector<int64_t> eventIds {1}; 428 EXPECT_TRUE(myOb.UnsubscribeCollectors(eventIds)); 429 } 430 431 HWTEST_F(DataCollectionTest, UnsubscribeCollectors03, testing::ext::TestSize.Level0) 432 { 433 DataCollection myOb; 434 std::vector<int64_t> eventIds {1}; 435 EXPECT_TRUE(myOb.UnsubscribeCollectors(eventIds)); 436 } 437 438 HWTEST_F(DataCollectionTest, UnsubscribeCollectors04, testing::ext::TestSize.Level0) 439 { 440 DataCollection myOb; 441 myOb.eventIdToLoaderMap_.emplace(1, LibLoader("testPath")); 442 std::vector<int64_t> eventIds {1}; 443 EXPECT_FALSE(myOb.UnsubscribeCollectors(eventIds)); 444 } 445 }