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 usb from '@ohos.usbManager'
17import deviceManager from '@ohos.driver.deviceManager'
18import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
19
20describe("PermissionJsTest", function () {
21    const TAG = "[PermissionJsTest]";
22    const PERMISSION_DENIED_CODE = 201;
23    const TEST_DEVICE_ID = 0;
24    const TEST_DRIVER_UID = 'testDriverUid'
25    const TEST_FUNCTION = () => {
26        console.info("Test function is called");
27    };
28
29    let deviceNum = 0;
30    const isDeviceConnected = done => {
31        if (deviceNum > 0) {
32            console.info("Test USB device is connected");
33            return true;
34        }
35        console.info("Test USB device is not connected");
36        expect(true).assertTrue();
37        if (typeof(done) === 'function') {
38            done();
39        }
40        return false;
41    }
42
43    beforeAll(function () {
44        console.info('beforeAll called');
45        try {
46            const devicesList = usb.getDevices();
47            if (Array.isArray(devicesList)) {
48                deviceNum = devicesList.length;
49            }
50        } catch (err) {
51            console.error(TAG, `getDevices failed, message is ${err.message}`);
52        }
53    })
54
55    afterAll(function () {
56        console.info('afterAll called');
57    })
58
59    beforeEach(function () {
60        console.info('beforeEach called');
61    })
62
63    afterEach(function () {
64        console.info('afterEach called');
65    })
66
67    /*
68     * @tc.name:Permission_queryDevices_001
69     * @tc.desc:verify permission of queryDevices
70     * @tc.type: FUNC
71     */
72    it("Permission_queryDevices_001", 0, done => {
73        console.info('----------------------Permission_queryDevices_001---------------------------');
74        if (!isDeviceConnected(done)) {
75            return;
76        }
77        try {
78            deviceManager.queryDevices();
79            expect(false).assertTrue();
80            done();
81        } catch (err) {
82            expect(err.code).assertEqual(PERMISSION_DENIED_CODE);
83            done();
84        }
85    });
86
87    /*
88     * @tc.name:Permission_bindDevice_001
89     * @tc.desc:verify permission of bindDevice
90     * @tc.type: FUNC
91     */
92    it("Permission_bindDevice_001", 0, done => {
93        console.info('----------------------Permission_bindDevice_001---------------------------');
94        if (!isDeviceConnected(done)) {
95            return;
96        }
97        try {
98            deviceManager.bindDevice(TEST_DEVICE_ID, TEST_FUNCTION, TEST_FUNCTION);
99            expect(false).assertTrue();
100            done();
101        } catch (err) {
102            expect(err.code).assertEqual(PERMISSION_DENIED_CODE);
103            done();
104        }
105    });
106
107    /*
108     * @tc.name:Permission_bindDevice_002
109     * @tc.desc:verify permission of bindDevice
110     * @tc.type: FUNC
111     */
112    it("Permission_bindDevice_002", 0, async done => {
113        console.info('----------------------Permission_bindDevice_002---------------------------');
114        if (!isDeviceConnected(done)) {
115            return;
116        }
117        try {
118            await deviceManager.bindDevice(TEST_DEVICE_ID, TEST_FUNCTION);
119            expect(false).assertTrue();
120            done();
121        } catch (err) {
122            expect(err.code).assertEqual(PERMISSION_DENIED_CODE);
123            done();
124        }
125    });
126
127    /*
128     * @tc.name:Permission_bindDeviceDriver_001
129     * @tc.desc:verify permission of bindDeviceDriver
130     * @tc.type: FUNC
131     */
132    it("Permission_bindDeviceDriver_001", 0, done => {
133        console.info('----------------------Permission_bindDeviceDriver_001---------------------------');
134        if (!isDeviceConnected(done)) {
135            return;
136        }
137        try {
138            deviceManager.bindDeviceDriver(TEST_DEVICE_ID, TEST_FUNCTION, TEST_FUNCTION);
139            expect(false).assertTrue();
140            done();
141        } catch (err) {
142            expect(err.code).assertEqual(PERMISSION_DENIED_CODE);
143            done();
144        }
145    });
146
147    /*
148     * @tc.name:Permission_bindDeviceDriver_002
149     * @tc.desc:verify permission of bindDeviceDriver
150     * @tc.type: FUNC
151     */
152    it("Permission_bindDeviceDriver_002", 0, async done => {
153        console.info('----------------------Permission_bindDeviceDriver_002---------------------------');
154        if (!isDeviceConnected(done)) {
155            return;
156        }
157        try {
158            await deviceManager.bindDeviceDriver(TEST_DEVICE_ID, TEST_FUNCTION);
159            expect(false).assertTrue();
160            done();
161        } catch (err) {
162            expect(err.code).assertEqual(PERMISSION_DENIED_CODE);
163            done();
164        }
165    });
166
167    /*
168     * @tc.name:Permission_unbindDevice_001
169     * @tc.desc:verify permission of unbindDevice
170     * @tc.type: FUNC
171     */
172    it("Permission_unbindDevice_001", 0, done => {
173        console.info('----------------------Permission_unbindDevice_001---------------------------');
174        if (!isDeviceConnected(done)) {
175            return;
176        }
177        try {
178            deviceManager.unbindDevice(TEST_DEVICE_ID, TEST_FUNCTION);
179            expect(false).assertTrue();
180            done();
181        } catch (err) {
182            expect(err.code).assertEqual(PERMISSION_DENIED_CODE);
183            done();
184        }
185    });
186
187    /*
188     * @tc.name:Permission_unbindDevice_002
189     * @tc.desc:verify permission of unbindDevice
190     * @tc.type: FUNC
191     */
192    it("Permission_unbindDevice_002", 0, async done => {
193        console.info('----------------------Permission_unbindDevice_002---------------------------');
194        if (!isDeviceConnected(done)) {
195            return;
196        }
197        try {
198            await deviceManager.unbindDevice(TEST_DEVICE_ID);
199            expect(false).assertTrue();
200            done();
201        } catch (err) {
202            expect(err.code).assertEqual(PERMISSION_DENIED_CODE);
203            done();
204        }
205    });
206
207    /*
208     * @tc.name:Permission_queryDeviceInfo_001
209     * @tc.desc:verify permission of queryDeviceInfo
210     * @tc.type: FUNC
211     */
212    it("Permission_queryDeviceInfo_001", 0, done => {
213        console.info('----------------------Permission_queryDeviceInfo_001---------------------------');
214        if (!isDeviceConnected(done)) {
215            return;
216        }
217        try {
218            deviceManager.queryDeviceInfo(TEST_DEVICE_ID);
219            expect(false).assertTrue();
220            done();
221        } catch (err) {
222            expect(err.code).assertEqual(PERMISSION_DENIED_CODE);
223            done();
224        }
225    });
226
227    /*
228     * @tc.name:Permission_queryDriverInfo_001
229     * @tc.desc:verify permission of queryDriverInfo
230     * @tc.type: FUNC
231     */
232    it("Permission_queryDriverInfo_001", 0, done => {
233        console.info('----------------------Permission_queryDriverInfo_001---------------------------');
234        if (!isDeviceConnected(done)) {
235            return;
236        }
237        try {
238            deviceManager.queryDriverInfo(TEST_DRIVER_UID);
239            expect(false).assertTrue();
240            done();
241        } catch (err) {
242            expect(err.code).assertEqual(PERMISSION_DENIED_CODE);
243            done();
244        }
245    });
246});