1/*
2 * Copyright (C) 2023-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
16import hiAppEvent from "@ohos.hiviewdfx.hiAppEvent"
17
18import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index'
19
20describe('HiAppEventJsTest', function () {
21    beforeAll(function() {
22        /*
23         * @tc.setup: setup invoked before all test cases
24         */
25        console.info('HiAppEventJsTest beforeAll called')
26    })
27
28    afterAll(function() {
29        /*
30         * @tc.teardown: teardown invoked after all test cases
31         */
32        console.info('HiAppEventJsTest afterAll called')
33    })
34
35    beforeEach(function() {
36        /*
37         * @tc.setup: setup invoked before each test case
38         */
39        console.info('HiAppEventJsTest beforeEach called')
40    })
41
42    afterEach(function() {
43        /*
44         * @tc.teardown: teardown invoked after each test case
45         */
46        console.info('HiAppEventJsTest afterEach called')
47    })
48
49    function createError1(name, type) {
50        return { code: "401", message: "Parameter error. The type of " + name + " must be " + type + "." };
51    }
52
53    function createError2(message) {
54        return { code: "401", message: message };
55    }
56
57    function assertErrorEqual(actualErr, expectErr) {
58        expect(actualErr.code).assertEqual(expectErr.code)
59        expect(actualErr.message).assertEqual(expectErr.message)
60    }
61
62    function writeTest() {
63        hiAppEvent.write({
64            domain: "test_domain",
65            name: "test_name",
66            eventType: hiAppEvent.EventType.FAULT,
67            params: {"str_key":"str_value"}
68        }, (err) => {
69            expect(err).assertNull()
70        });
71    }
72
73    function validProcessorTest(processor, done) {
74        let processorId = hiAppEvent.addProcessor(processor);
75        expect(processorId).assertLarger(0);
76        writeTest();
77        setTimeout(() => {
78            hiAppEvent.removeProcessor(processorId);
79            done();
80        }, 1000);
81    }
82
83    function invalidProcessorTest(processor, expectErr) {
84        let processorId = 0;
85        try {
86            processorId = hiAppEvent.addProcessor(processor);
87        } catch (err) {
88            assertErrorEqual(err, expectErr);
89        }
90        hiAppEvent.removeProcessor(processorId);
91    }
92
93    /**
94     * @tc.number: HiAppEventProcessorTest001_1
95     * @tc.name: HiAppEventProcessorTest
96     * @tc.desc: Add processor with all configs.
97     * @tc.type: FUNC
98     * @tc.require: issueI8U2VO
99     */
100    it('HiAppEventProcessorTest001_1', 0, async function (done) {
101        let processor1 = {
102            name: "test_processor",
103            debugMode: true,
104            routeInfo: "routeInfo",
105            appId: "appId",
106            onStartReport: true,
107            onBackgroundReport: true,
108            periodReport: 0,
109            batchReport: 0,
110            userIds: ["id1", "id2"],
111            userProperties: ["prop1", "props"],
112            eventConfigs: [
113                {
114                    domain: "test_domain",
115                    name: "test_name",
116                    isRealTime: true,
117                }
118            ],
119            configId: 1,
120            customConfigs: {
121                "str_key": "str_value"
122            }
123        };
124        validProcessorTest(processor1, done);
125    });
126
127    /**
128     * @tc.number: HiAppEventProcessorTest001_2
129     * @tc.name: HiAppEventProcessorTest
130     * @tc.desc: Add processor with special eventConfigs.
131     * @tc.type: FUNC
132     * @tc.require: issueI8U2VO
133     */
134    it('HiAppEventProcessorTest001_2', 0, async function (done) {
135        let processor1 = {
136            name: "test_processor",
137            eventConfigs: [
138                {
139                    name: "test_name",
140                    isRealTime: true,
141                }
142            ]
143        };
144        validProcessorTest(processor1, done);
145
146        let processor2 = {
147            name: "test_processor",
148            eventConfigs: [
149                {
150                    domain: "test_domain",
151                    isRealTime: true,
152                }
153            ]
154        };
155        validProcessorTest(processor2, done);
156
157        let processor3 = {
158            name: "test_processor",
159            eventConfigs: [
160                {
161                    isRealTime: false,
162                }
163            ]
164        };
165        validProcessorTest(processor3, done);
166    });
167
168    /**
169     * @tc.number: HiAppEventProcessorTest002_1
170     * @tc.name: HiAppEventProcessorTest
171     * @tc.desc: Add processor with invalid types.
172     * @tc.type: FUNC
173     * @tc.require: issueI8U2VO
174     */
175    it('HiAppEventProcessorTest002_1', 0, function () {
176        let expectErr = createError1("config", "Processor");
177        invalidProcessorTest("str", expectErr);
178        invalidProcessorTest(0, expectErr);
179        invalidProcessorTest(null, expectErr);
180        invalidProcessorTest(undefined, expectErr);
181    });
182
183    /**
184     * @tc.number: HiAppEventProcessorTest002_2
185     * @tc.name: HiAppEventProcessorTest
186     * @tc.desc: Add processor with invalid name.
187     * @tc.type: FUNC
188     * @tc.require: issueI8U2VO
189     */
190    it('HiAppEventProcessorTest002_2', 0, function () {
191        let expectErr2 = createError2("Invalid processor name.");
192        let processor1 = {
193            name: "",
194        };
195        invalidProcessorTest(processor1, expectErr2);
196
197        let expectErr1 = createError1("name", "string");
198        let processor2 = {
199            name: null,
200        };
201        invalidProcessorTest(processor2, expectErr1);
202
203        let processor3 = {
204            name: 0,
205        };
206        invalidProcessorTest(processor3, expectErr1);
207
208        let processor4 = {
209            name: "xxx***",
210        };
211        invalidProcessorTest(processor4, expectErr2);
212
213        let processor5 = {
214            name: "123_processor",
215        };
216        invalidProcessorTest(processor5, expectErr2);
217
218        const maxLen = 256;
219        let processor6 = {
220            name: 'a'.repeat(maxLen + 1),
221        };
222        invalidProcessorTest(processor6, expectErr2);
223    });
224
225    /**
226     * @tc.number: HiAppEventProcessorTest003
227     * @tc.name: HiAppEventProcessorTest
228     * @tc.desc: Add processor with same processorId.
229     * @tc.type: FUNC
230     * @tc.require: issueI8U2VO
231     */
232    it('HiAppEventProcessorTest003', 0, function () {
233        let config = {
234            name: "test_processor",
235            configId: 1,
236        };
237        let processorId1 = hiAppEvent.addProcessor(config);
238        expect(processorId1).assertLarger(0);
239
240        config.customConfigs = {
241            "str_key": "str_value"
242        };
243        let processorId2 = hiAppEvent.addProcessor(config);
244        expect(processorId2).assertLarger(0);
245        expect(processorId2 == processorId1).assertTrue();
246
247        config.configId = 0;
248        let processorId3 = hiAppEvent.addProcessor(config);
249        expect(processorId3).assertLarger(0);
250        expect(processorId3 != processorId2).assertTrue();
251
252        hiAppEvent.removeProcessor(processorId1);
253        hiAppEvent.removeProcessor(processorId2);
254        hiAppEvent.removeProcessor(processorId3);
255    });
256
257    /**
258     * @tc.number: HiAppEventProcessorTest004_1
259     * @tc.name: HiAppEventProcessorTest
260     * @tc.desc: Add processor with invalid configId.
261     * @tc.type: FUNC
262     * @tc.require: issueI8U2VO
263     */
264    it('HiAppEventProcessorTest004_1', 0, function () {
265        let expectConfig = {
266            name: "test_processor",
267            configId: 0,
268        }
269        let processorId = hiAppEvent.addProcessor(expectConfig);
270        expect(processorId).assertLarger(0);
271
272        let config = {
273            name: "test_processor",
274            configId: -1,
275        };
276        let processorId1 = hiAppEvent.addProcessor(config);
277        expect(processorId1).assertLarger(0);
278        expect(processorId1 == processorId).assertTrue();
279
280        hiAppEvent.removeProcessor(processorId);
281    });
282
283    /**
284     * @tc.number: HiAppEventProcessorTest004_2
285     * @tc.name: HiAppEventProcessorTest
286     * @tc.desc: Add processor with invalid customConfigs.
287     * @tc.type: FUNC
288     * @tc.require: issueI8U2VO
289     */
290    it('HiAppEventProcessorTest004_2', 0, function () {
291        let expectConfig = {
292            name: "test_processor",
293            customConfigs: {},
294        }
295        let processorId = hiAppEvent.addProcessor(expectConfig);
296        expect(processorId).assertLarger(0);
297
298        let config = {
299            name: "test_processor",
300            customConfigs: {
301                "": "str_value"
302            },
303        };
304        let processorId1 = hiAppEvent.addProcessor(config);
305        expect(processorId1).assertLarger(0);
306        expect(processorId1 == processorId).assertTrue();
307
308        config.customConfigs = {
309            "***key": "str_value"
310        };
311        let processorId2 = hiAppEvent.addProcessor(config);
312        expect(processorId2).assertLarger(0);
313        expect(processorId2 == processorId).assertTrue();
314
315        let invalidName = "a".repeat(32 + 1);
316        config.customConfigs = {
317            invalidName: "str_value"
318        };
319        let processorId3 = hiAppEvent.addProcessor(config);
320        expect(processorId3).assertLarger(0);
321        expect(processorId3 == processorId).assertTrue();
322
323        config.customConfigs = {
324            "str_key": "a".repeat(1024 + 1)
325        };
326        let processorId4 = hiAppEvent.addProcessor(config);
327        expect(processorId4).assertLarger(0);
328        expect(processorId4 == processorId).assertTrue();
329
330        hiAppEvent.removeProcessor(processorId);
331    });
332});