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
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    const TEST_DOMAIN = 'test_domain1';
50    const TEST_NAME = 'test_name1';
51    const TEST_PARAMS = { "key_int": 100 };
52    const MAX_LEN_OF_DOMAIN = 32;
53    const MAX_LENGTH_OF_EVENT_NAME = 48;
54    const MAX_NUM_OF_CUSTOM_PARAMS = 64;
55
56    function createError(code, message) {
57        return { code: code.toString(), message: message };
58    }
59
60    function createError1(name, type) {
61        return { code: "401", message: "Parameter error. The type of " + name + " must be " + type + "." };
62    }
63
64    function createError2(name) {
65        return { code: "401", message: "Parameter error. The " + name + " parameter is mandatory." };
66    }
67
68    function assertErrorEqual(actualErr, expectErr) {
69        expect(actualErr.code).assertEqual(expectErr.code)
70        expect(actualErr.message).assertEqual(expectErr.message)
71    }
72
73    function writeTest(params) {
74        hiAppEvent.write({
75            domain: TEST_DOMAIN,
76            name: TEST_NAME,
77            eventType: hiAppEvent.EventType.FAULT,
78            params: params
79        }, (err) => {
80            expect(err).assertNull()
81        });
82    }
83
84    function setEventParamTestWithNameTestCatch(params, domain, name, expectErr, done) {
85        try {
86            hiAppEvent.setEventParam(params, domain, name);
87        } catch (err) {
88            assertErrorEqual(err, expectErr);
89            console.info('HiAppEventSetEventParamTest setEventParam catch end');
90            done();
91        }
92    }
93
94    function setEventParamTestWithNameTest(params, domain, name, expectErr, done) {
95        hiAppEvent.setEventParam(params, domain, name).then(() => {
96            expect(expectErr).assertNull();
97            done();
98        }).catch((err) => {
99            assertErrorEqual(err, expectErr);
100            done();
101        });
102    }
103
104    function setEventParamTestCatch(params, domain, expectErr, done) {
105        try {
106            hiAppEvent.setEventParam(params, domain);
107        } catch (err) {
108            assertErrorEqual(err, expectErr);
109            console.info('HiAppEventSetEventParamTest setEventParam catch end');
110            done();
111        }
112    }
113
114    function setEventParamTest(params, domain, expectErr, done) {
115        hiAppEvent.setEventParam(params, domain).then(() => {
116            expect(expectErr).assertNull();
117            done();
118        }).catch((err) => {
119            assertErrorEqual(err, expectErr);
120            done();
121        });
122    }
123
124    /**
125     * @tc.number: HiAppEventSetEventParamTest001
126     * @tc.name: HiAppEventSetEventParamTest
127     * @tc.desc: SetEventParam with valid params.
128     * @tc.type: FUNC
129     * @tc.require: issueI8U2VO
130     */
131    it('HiAppEventSetEventParamTest001', 0, async function (done) {
132        let params = {
133            "key_int": 1000,
134            "key_string": "strValue",
135            "key_bool": true,
136            "key_float": 30949.3780498,
137            "key_string_arr": ["a", "b", "c"]
138        };
139        setEventParamTestWithNameTest(params, TEST_DOMAIN, TEST_NAME, null, done);
140        setEventParamTest(params, TEST_DOMAIN, null, done);
141    });
142
143    /**
144     * @tc.number: HiAppEventSetEventParamTest002
145     * @tc.name: HiAppEventSetEventParamTest
146     * @tc.desc: SetEventParam with invalid parameters num.
147     * @tc.type: FUNC
148     * @tc.require: issueI8U2VO
149     */
150    it('HiAppEventSetEventParamTest002', 0, async function (done) {
151        let expectErr = createError2("setEventParam");
152        try {
153            hiAppEvent.setEventParam();
154        } catch (err) {
155            assertErrorEqual(err, expectErr);
156            done();
157        }
158
159        try {
160            hiAppEvent.setEventParam("test");
161        } catch (err) {
162            assertErrorEqual(err, expectErr);
163            done();
164        }
165    });
166
167    /**
168     * @tc.number: HiAppEventSetEventParamTest003
169     * @tc.name: HiAppEventSetEventParamTest
170     * @tc.desc: SetEventParam with invalid domain.
171     * @tc.type: FUNC
172     * @tc.require: issueI8U2VO
173     */
174    it('HiAppEventSetEventParamTest003', 0, async function (done) {
175        let expectErr = createError1("domain", "string");
176        setEventParamTestCatch(TEST_PARAMS, 0, expectErr, done);
177        setEventParamTestCatch(TEST_PARAMS, null, expectErr, done);
178        setEventParamTestCatch(TEST_PARAMS, undefined, expectErr, done);
179
180        expectErr = createError(11101001, "Invalid event domain.");
181        setEventParamTest(TEST_PARAMS, "xxx***", expectErr, done);
182        setEventParamTest(TEST_PARAMS, "123_domain", expectErr, done);
183        setEventParamTest(TEST_PARAMS, "", expectErr, done);
184        setEventParamTest(TEST_PARAMS, "a".repeat(MAX_LEN_OF_DOMAIN + 1), expectErr, done);
185
186        setEventParamTest(TEST_PARAMS, "Domain", null, done);
187        setEventParamTest(TEST_PARAMS, 'a'.repeat(MAX_LEN_OF_DOMAIN), null, done);
188    });
189
190    /**
191     * @tc.number: HiAppEventSetEventParamTest004
192     * @tc.name: HiAppEventSetEventParamTest
193     * @tc.desc: Add processor with invalid name.
194     * @tc.type: FUNC
195     * @tc.require: issueI8U2VO
196     */
197    it('HiAppEventSetEventParamTest004', 0, async function (done) {
198        let expectErr = createError1("name", "string");
199        setEventParamTestWithNameTestCatch(TEST_PARAMS, TEST_DOMAIN, 0, expectErr, done);
200        setEventParamTestWithNameTestCatch(TEST_PARAMS, TEST_DOMAIN, null, expectErr, done);
201        setEventParamTestWithNameTestCatch(TEST_PARAMS, TEST_DOMAIN, undefined, expectErr, done);
202
203        expectErr = createError(11101002, "Invalid event name.");
204        setEventParamTestWithNameTest(TEST_PARAMS, TEST_DOMAIN, "xxx***", expectErr, done);
205        setEventParamTestWithNameTest(TEST_PARAMS, TEST_DOMAIN, "123_name", expectErr, done);
206        setEventParamTestWithNameTest(TEST_PARAMS, TEST_DOMAIN, "a".repeat(MAX_LENGTH_OF_EVENT_NAME + 1), expectErr, done);
207
208        setEventParamTestWithNameTest(TEST_PARAMS, TEST_DOMAIN, "", null, done);
209        setEventParamTestWithNameTest(TEST_PARAMS, TEST_DOMAIN, "Name", null, done);
210        setEventParamTestWithNameTest(TEST_PARAMS, TEST_DOMAIN, 'a'.repeat(MAX_LENGTH_OF_EVENT_NAME), null, done);
211    });
212
213    /**
214     * @tc.number: HiAppEventSetEventParamTest005
215     * @tc.name: HiAppEventSetEventParamTest
216     * @tc.desc: Add processor with invalid params.
217     * @tc.type: FUNC
218     * @tc.require: issueI8U2VO
219     */
220    it('HiAppEventSetEventParamTest005', 0, async function (done) {
221        let expectErr = createError1("params", "object");
222        setEventParamTestCatch(0, TEST_DOMAIN, expectErr, done);
223        setEventParamTestCatch(true, TEST_DOMAIN, expectErr, done);
224        setEventParamTestCatch("params_test", TEST_DOMAIN, expectErr, done);
225        setEventParamTestCatch(null, TEST_DOMAIN, expectErr, done);
226        setEventParamTestCatch(undefined, TEST_DOMAIN, expectErr, done);
227
228        expectErr = createError(11101007, "The number of parameter keys exceeds the limit.");
229        let params = {};
230        for (var i = 1; i <= MAX_NUM_OF_CUSTOM_PARAMS + 1; ++i) {
231            params["key" + i] = "value" + i;
232        }
233        setEventParamTest(params, TEST_DOMAIN, expectErr, done);
234
235        // fail
236        let params1 = {};
237        for (var i = 1; i <= MAX_NUM_OF_CUSTOM_PARAMS; ++i) {
238            params1["key" + i] = "value" + i;
239        }
240        setEventParamTest(params1, TEST_DOMAIN, null, done);
241    });
242});