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
26using namespace testing::ext;
27using namespace OHOS::HiviewDFX;
28using namespace OHOS::HiviewDFX::HiAppEvent;
29
30namespace {
31const std::string TEST_DIR = "/data/test/hiappevent/";
32const std::string TEST_WATCHER = "test_watcher";
33const std::string TEST_WATCHER_ROW = "watcher_row";
34const std::string TEST_WATCHER_SIZE = "watcher_size";
35const std::string TEST_WATCHER_TIMEOUT = "watcher_time";
36const std::string TEST_DOMAIN = "test_domain";
37const std::string TEST_NAME = "test_name";
38constexpr unsigned int TEST_TYPE = 1;
39const std::string TEST_EVENT = R"~({"domain_":"hiappevent", "name_":"testEvent"})~";
40
41std::shared_ptr<AppEventPack> CreateAppEventPack(const std::string& domain = TEST_DOMAIN)
42{
43    return std::make_shared<AppEventPack>(domain, TEST_NAME, TEST_TYPE);
44}
45
46class HiAppEventWatcherTest : public testing::Test {
47public:
48    void SetUp();
49    void TearDown();
50};
51
52void HiAppEventWatcherTest::SetUp()
53{
54    HiAppEventConfig::GetInstance().SetStorageDir(TEST_DIR);
55    (void)AppEventStore::GetInstance().InitDbStore();
56    AppEventObserverMgr::GetInstance().CreateEventHandler();
57}
58
59void HiAppEventWatcherTest::TearDown()
60{
61    (void)AppEventStore::GetInstance().DestroyDbStore();
62    AppEventObserverMgr::GetInstance().DestroyEventHandler();
63}
64
65class AppEventWatcherTest : public AppEventWatcher {
66public:
67    AppEventWatcherTest(
68        const std::string& name,
69        const std::vector<AppEventFilter>& filters,
70        TriggerCondition cond)
71        : AppEventWatcher(name, filters, cond) {}
72
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
79    int GetTriggerTimes()
80    {
81        return triggerTimes;
82    }
83
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
94private:
95    int triggerTimes = 0;
96};
97
98void BuildSimpleFilters(std::vector<AppEventFilter>& filters)
99{
100    filters.emplace_back(AppEventFilter(TEST_DOMAIN, 0xff)); // 0xff means all types
101}
102
103void BuildSimpleOsFilters(std::vector<AppEventFilter>& filters)
104{
105    filters.emplace_back(AppEventFilter("OS", {"APP_CRASH"}));
106}
107
108TriggerCondition 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
118std::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
125std::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
133std::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
141std::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
149std::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
157std::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 */
172HWTEST_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 */
225HWTEST_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 */
251HWTEST_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 */
281HWTEST_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