1 /*
2  * Copyright (c) 2022-2023 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 <iostream>
16 #include <map>
17 
18 #include <gtest/gtest.h>
19 
20 #include "app_event_store.h"
21 #include "app_event_watcher.h"
22 #include "app_event_observer_mgr.h"
23 #include "hiappevent_base.h"
24 #include "hiappevent_config.h"
25 
26 using namespace testing::ext;
27 using namespace OHOS::HiviewDFX;
28 using namespace OHOS::HiviewDFX::HiAppEvent;
29 
30 namespace {
31 const std::string TEST_DIR = "/data/test/hiappevent/";
32 const std::string TEST_WATCHER = "test_watcher";
33 const std::string TEST_WATCHER_ROW = "watcher_row";
34 const std::string TEST_WATCHER_SIZE = "watcher_size";
35 const std::string TEST_WATCHER_TIMEOUT = "watcher_time";
36 const std::string TEST_DOMAIN = "test_domain";
37 const std::string TEST_NAME = "test_name";
38 constexpr unsigned int TEST_TYPE = 1;
39 const std::string TEST_EVENT = R"~({"domain_":"hiappevent", "name_":"testEvent"})~";
40 
CreateAppEventPack(const std::string & domain=TEST_DOMAIN)41 std::shared_ptr<AppEventPack> CreateAppEventPack(const std::string& domain = TEST_DOMAIN)
42 {
43     return std::make_shared<AppEventPack>(domain, TEST_NAME, TEST_TYPE);
44 }
45 
46 class HiAppEventWatcherTest : public testing::Test {
47 public:
48     void SetUp();
49     void TearDown();
50 };
51 
SetUp()52 void HiAppEventWatcherTest::SetUp()
53 {
54     HiAppEventConfig::GetInstance().SetStorageDir(TEST_DIR);
55     (void)AppEventStore::GetInstance().InitDbStore();
56     AppEventObserverMgr::GetInstance().CreateEventHandler();
57 }
58 
TearDown()59 void HiAppEventWatcherTest::TearDown()
60 {
61     (void)AppEventStore::GetInstance().DestroyDbStore();
62     AppEventObserverMgr::GetInstance().DestroyEventHandler();
63 }
64 
65 class AppEventWatcherTest : public AppEventWatcher {
66 public:
AppEventWatcherTest(const std::string & name,const std::vector<AppEventFilter> & filters,TriggerCondition cond)67     AppEventWatcherTest(
68         const std::string& name,
69         const std::vector<AppEventFilter>& filters,
70         TriggerCondition cond)
71         : AppEventWatcher(name, filters, cond) {}
72 
OnTrigger(const TriggerCondition & triggerCond)73     void OnTrigger(const TriggerCondition& triggerCond) override
74     {
75         std::cout << GetName() << " onTrigger, row=" << triggerCond.row << ", size=" << triggerCond.size << std::endl;
76         triggerTimes++;
77     }
78 
GetTriggerTimes()79     int GetTriggerTimes()
80     {
81         return triggerTimes;
82     }
83 
OnEvents(const std::vector<std::shared_ptr<AppEventPack>> & events)84     void OnEvents(const std::vector<std::shared_ptr<AppEventPack>>& events) override
85     {
86         std::cout << GetName() << " OnEvents size=" << events.size() << std::endl;
87         for (const auto& event : events) {
88             std::cout << "domain=" << event->GetDomain() << ", eventName=" << event->GetName()
89                 << ", eventType=" << event->GetType() << std::endl;
90             std::cout << "params=" << event->GetParamStr() << std::endl;
91         }
92     }
93 
94 private:
95     int triggerTimes = 0;
96 };
97 
BuildSimpleFilters(std::vector<AppEventFilter> & filters)98 void BuildSimpleFilters(std::vector<AppEventFilter>& filters)
99 {
100     filters.emplace_back(AppEventFilter(TEST_DOMAIN, 0xff)); // 0xff means all types
101 }
102 
BuildSimpleOsFilters(std::vector<AppEventFilter> & filters)103 void BuildSimpleOsFilters(std::vector<AppEventFilter>& filters)
104 {
105     filters.emplace_back(AppEventFilter("OS", {"APP_CRASH"}));
106 }
107 
BuildCondition(int row,int size,int timeout)108 TriggerCondition BuildCondition(int row, int size, int timeout)
109 {
110     TriggerCondition cond = {
111         .row = row,
112         .size = size,
113         .timeout = timeout,
114     };
115     return cond;
116 }
117 
BuildSimpleWatcher()118 std::shared_ptr<AppEventWatcherTest> BuildSimpleWatcher()
119 {
120     std::vector<AppEventFilter> filters;
121     TriggerCondition cond = BuildCondition(0, 0, 0);
122     return std::make_shared<AppEventWatcherTest>(TEST_WATCHER, filters, cond);
123 }
124 
BuildWatcherWithRow()125 std::shared_ptr<AppEventWatcherTest> BuildWatcherWithRow()
126 {
127     std::vector<AppEventFilter> filters;
128     BuildSimpleFilters(filters);
129     TriggerCondition cond = BuildCondition(1, 0, 0); // row is 1
130     return std::make_shared<AppEventWatcherTest>(TEST_WATCHER_ROW, filters, cond);
131 }
132 
BuildWatcherWithSize()133 std::shared_ptr<AppEventWatcherTest> BuildWatcherWithSize()
134 {
135     std::vector<AppEventFilter> filters;
136     BuildSimpleFilters(filters);
137     TriggerCondition cond = BuildCondition(0, 10, 0); // size is 10 byte
138     return std::make_shared<AppEventWatcherTest>(TEST_WATCHER_SIZE, filters, cond);
139 }
140 
BuildWatcherWithTimeout()141 std::shared_ptr<AppEventWatcherTest> BuildWatcherWithTimeout()
142 {
143     std::vector<AppEventFilter> filters;
144     BuildSimpleFilters(filters);
145     TriggerCondition cond = BuildCondition(0, 0, 1); // timeout is 1
146     return std::make_shared<AppEventWatcherTest>(TEST_WATCHER_TIMEOUT, filters, cond);
147 }
148 
BuildWatcherWithTimeout2()149 std::shared_ptr<AppEventWatcherTest> BuildWatcherWithTimeout2()
150 {
151     std::vector<AppEventFilter> filters;
152     BuildSimpleFilters(filters);
153     TriggerCondition cond = BuildCondition(0, 0, 1); // timeout is 1
154     return std::make_shared<AppEventWatcherTest>("watcher_time2", filters, cond);
155 }
156 
BuildSimpleOsWatcher()157 std::shared_ptr<AppEventWatcherTest> BuildSimpleOsWatcher()
158 {
159     std::vector<AppEventFilter> filters;
160     BuildSimpleOsFilters(filters);
161     TriggerCondition cond = BuildCondition(0, 0, 0);
162     return std::make_shared<AppEventWatcherTest>(TEST_WATCHER, filters, cond);
163 }
164 }
165 
166 /**
167  * @tc.name: HiAppEventWatcherTest001
168  * @tc.desc: Test to add watcher with no condition.
169  * @tc.type: FUNC
170  * @tc.require: issueI5LB4N
171  */
172 HWTEST_F(HiAppEventWatcherTest, HiAppEventWatcherTest001, TestSize.Level3)
173 {
174     /**
175      * @tc.steps: step1. create AppEventWatcher object.
176      * @tc.steps: step2. add the watcher to AppEventObserverMgr.
177      */
178     std::cout << "HiAppEventWatcherTest001 start" << std::endl;
179 
180     auto watcher1 = BuildSimpleWatcher();
181     AppEventObserverMgr::GetInstance().RegisterObserver(watcher1);
182     auto watcher2 = BuildWatcherWithRow();
183     AppEventObserverMgr::GetInstance().RegisterObserver(watcher2);
184     auto watcher3 = BuildWatcherWithSize();
185     AppEventObserverMgr::GetInstance().RegisterObserver(watcher3);
186     auto watcher4 = BuildWatcherWithTimeout();
187     AppEventObserverMgr::GetInstance().RegisterObserver(watcher4);
188     auto watcher5 = BuildWatcherWithTimeout2();
189     AppEventObserverMgr::GetInstance().RegisterObserver(watcher5);
190 
191     std::vector<std::shared_ptr<AppEventPack>> events;
192     events.emplace_back(CreateAppEventPack());
193     AppEventObserverMgr::GetInstance().HandleEvents(events);
194     ASSERT_EQ(watcher1->GetTriggerTimes(), 0);
195     ASSERT_EQ(watcher2->GetTriggerTimes(), 1);
196     ASSERT_EQ(watcher3->GetTriggerTimes(), 1);
197     ASSERT_EQ(watcher4->GetTriggerTimes(), 0);
198 
199     events.clear();
200     events.emplace_back(CreateAppEventPack("invalid_domain"));
201     AppEventObserverMgr::GetInstance().HandleEvents(events);
202     ASSERT_EQ(watcher1->GetTriggerTimes(), 0);
203     ASSERT_EQ(watcher2->GetTriggerTimes(), 1);
204     ASSERT_EQ(watcher3->GetTriggerTimes(), 1);
205     ASSERT_EQ(watcher4->GetTriggerTimes(), 0);
206 
207     AppEventObserverMgr::GetInstance().HandleTimeout();
208     ASSERT_EQ(watcher4->GetTriggerTimes(), 1);
209     ASSERT_EQ(watcher5->GetTriggerTimes(), 1);
210 
211     AppEventObserverMgr::GetInstance().UnregisterObserver(watcher1->GetName());
212     AppEventObserverMgr::GetInstance().UnregisterObserver(watcher2->GetName());
213     AppEventObserverMgr::GetInstance().UnregisterObserver(watcher3->GetName());
214     AppEventObserverMgr::GetInstance().UnregisterObserver(watcher4->GetName());
215     AppEventObserverMgr::GetInstance().UnregisterObserver(watcher5->GetName());
216     std::cout << "HiAppEventWatcherTest001 end" << std::endl;
217 }
218 
219 /**
220  * @tc.name: HiAppEventWatcherTest002
221  * @tc.desc: Test failed to add watcher.
222  * @tc.type: FUNC
223  * @tc.require: issueI5LB4N
224  */
225 HWTEST_F(HiAppEventWatcherTest, HiAppEventWatcherTest002, TestSize.Level3)
226 {
227     /**
228      * @tc.steps: step1. create AppEventWatcher object.
229      * @tc.steps: step2. add the watcher to AppEventObserverMgr.
230      */
231     std::cout << "HiAppEventWatcherTest002 start" << std::endl;
232     (void)AppEventStore::GetInstance().DestroyDbStore();
233 
234     auto watcher = BuildSimpleWatcher();
235     AppEventObserverMgr::GetInstance().RegisterObserver(watcher);
236     std::vector<std::shared_ptr<AppEventPack>> events;
237     events.emplace_back(CreateAppEventPack());
238     AppEventObserverMgr::GetInstance().HandleEvents(events);
239     ASSERT_EQ(watcher->GetTriggerTimes(), 0);
240 
241     AppEventObserverMgr::GetInstance().UnregisterObserver(watcher->GetName());
242     std::cout << "HiAppEventWatcherTest002 end" << std::endl;
243 }
244 
245 /**
246  * @tc.name: HiAppEventWatcherTest003
247  * @tc.desc: Test to add watcher repeatedly.
248  * @tc.type: FUNC
249  * @tc.require: issueI5LB4N
250  */
251 HWTEST_F(HiAppEventWatcherTest, HiAppEventWatcherTest003, TestSize.Level3)
252 {
253     /**
254      * @tc.steps: step1. create AppEventWatcher object.
255      * @tc.steps: step2. add the watcher to AppEventObserverMgr.
256      */
257     std::cout << "HiAppEventWatcherTest003 start" << std::endl;
258 
259     auto watcher1 = BuildWatcherWithRow();
260     AppEventObserverMgr::GetInstance().RegisterObserver(watcher1);
261     auto watcher2 = BuildWatcherWithRow();
262     AppEventObserverMgr::GetInstance().RegisterObserver(watcher2);
263 
264     std::vector<std::shared_ptr<AppEventPack>> events;
265     events.emplace_back(CreateAppEventPack());
266     AppEventObserverMgr::GetInstance().HandleEvents(events);
267     ASSERT_EQ(watcher1->GetTriggerTimes(), 0);
268     ASSERT_EQ(watcher2->GetTriggerTimes(), 1);
269 
270     AppEventObserverMgr::GetInstance().UnregisterObserver(watcher1->GetName());
271     AppEventObserverMgr::GetInstance().UnregisterObserver(watcher2->GetName());
272     std::cout << "HiAppEventWatcherTest003 end" << std::endl;
273 }
274 
275 /**
276  * @tc.name: HiAppEventWatcherTest004
277  * @tc.desc: Test to add watcher onReceive.
278  * @tc.type: FUNC
279  * @tc.require: issueI5LB4N
280  */
281 HWTEST_F(HiAppEventWatcherTest, HiAppEventWatcherTest004, TestSize.Level3)
282 {
283     /**
284      * @tc.steps: step1. create AppEventWatcher object.
285      * @tc.steps: step2. add the watcher to AppEventObserverMgr.
286      */
287     std::cout << "HiAppEventWatcherTest004 start" << std::endl;
288 
289     auto watcher = BuildSimpleOsWatcher();
290     AppEventObserverMgr::GetInstance().RegisterObserver(watcher);
291     std::vector<std::shared_ptr<AppEventPack>> events;
292     events.emplace_back(std::make_shared<AppEventPack>("OS", "APP_CRASH", TEST_TYPE));
293     AppEventObserverMgr::GetInstance().HandleEvents(events);
294     ASSERT_EQ(watcher->GetTriggerTimes(), 0);
295 
296     AppEventObserverMgr::GetInstance().UnregisterObserver(watcher->GetName());
297     std::cout << "HiAppEventWatcherTest004 end" << std::endl;
298 }
299