1/*
2 * Copyright (c) 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
16import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index';
17import UDC from '@ohos.data.unifiedDataChannel';
18import UTD from '@ohos.data.uniformTypeDescriptor';
19
20const TEXT_CONTEXT_01 = 'TextContent01';
21const TEXT_CONTEXT_02 = 'TextContent02';
22const ERROR_PARAMETER = '401';
23
24describe('UdmfCallbackJSTest', function () {
25
26  let gPlainText1 = new UDC.PlainText();
27  gPlainText1.textContent = TEXT_CONTEXT_01;
28  let gPlainText2 = new UDC.PlainText();
29  gPlainText2.textContent = TEXT_CONTEXT_02;
30
31  const optionsValid = { intention: 'DataHub', };
32  const optionsInValidIntention = { intention: 'Drag', };
33  const optionsInValidKey = { key: 'udmf://drag/com.test.demo/123456789', };
34  const optionsInValidAll = { intention: 'DataHub', key: 'udmf://drag/com.test.demo/123456789' };
35  const unifiedData01 = new UDC.UnifiedData(gPlainText1);
36  const unifiedData02 = new UDC.UnifiedData(gPlainText2);
37  const unifiedDataInvalid = new UDC.UnifiedData();
38
39  /**
40   * @tc.name UdmfInsertCallbackInvalidOptionsTest
41   * @tc.desc Test Js Api insertData with invalid options
42   * @tc.type: FUNC
43   * @tc.require: issueNumber
44   */
45  it('UdmfInsertCallbackInvalidOptionsTest', 0, async function (done) {
46    const TAG = 'UdmfInsertCallbackInvalidOptionsTest:';
47    console.info(TAG, 'start');
48    try {
49      UDC.insertData(optionsInValidIntention, unifiedData01, (err, data) => {
50        console.info(TAG, 'Unreachable code!');
51        expect(null).assertFail();
52        done();
53      });
54    } catch (e) {
55      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
56      expect(e.code === ERROR_PARAMETER).assertTrue();
57      done();
58    }
59    console.info(TAG, 'end');
60  });
61
62  /**
63   * @tc.name UdmfInsertCallbackInvalidDataTest
64   * @tc.desc Test Js Api insertData with invalid UnifiedData
65   * @tc.type: FUNC
66   * @tc.require: issueNumber
67   */
68  it('UdmfInsertCallbackInvalidDataTest', 0, async function (done) {
69    const TAG = 'UdmfInsertCallbackInvalidDataTest:';
70    console.info(TAG, 'start');
71    try {
72      UDC.insertData(optionsValid, unifiedDataInvalid, (err, data) => {
73        expect(data).assertUndefined();
74        console.error(TAG, `get fail. code is ${err.code},message is ${err.message} `);
75        expect(err.code === ERROR_PARAMETER).assertTrue();
76        done();
77      });
78    } catch (e) {
79      console.error(TAG, 'Unreachable code!');
80      expect(null).assertFail();
81      done();
82    }
83    console.info(TAG, 'end');
84  });
85
86  /**
87   * @tc.name UdmfInsertCallbackSucTest
88   * @tc.desc Test Js Api insertData successful
89   * @tc.type: FUNC
90   * @tc.require: issueNumber
91   */
92  it('UdmfInsertCallbackSucTest', 0, async function (done) {
93    const TAG = 'UdmfInsertCallbackSucTest:';
94    console.info(TAG, 'start');
95    try {
96      UDC.insertData(optionsValid, unifiedData01, (err, data) => {
97        expect(err).assertUndefined();
98        console.info(TAG, `insert success. The key: ${data}`);
99        let options = { key: data };
100        console.info(TAG, `query start. The options: ${JSON.stringify(options)}`);
101        UDC.queryData(options, (err, data) => {
102          expect(err).assertUndefined();
103          console.info(TAG, 'query success.');
104          console.info(TAG, `data.length = ${data.length}.`);
105          expect(data.length).assertEqual(1);
106          let records = data[0].getRecords();
107          console.info(TAG, `records.length = ${records.length}.`);
108          console.info(TAG, `records[0].getType() = ${records[0].getType()}.`);
109          console.info(TAG, `records[0].textContent = ${records[0].textContent}.`);
110          expect(records.length).assertEqual(1);
111          expect(records[0].getType()).assertEqual(UTD.UniformDataType.PLAIN_TEXT);
112          expect(records[0].textContent).assertEqual(TEXT_CONTEXT_01);
113          done();
114        });
115      });
116    } catch (e) {
117      console.error(TAG, 'Unreachable code!');
118      expect(null).assertFail();
119      done();
120    }
121    console.info(TAG, 'end');
122  });
123
124  /**
125   * @tc.name UdmfUpdateCallbackInvalidOptionsTest
126   * @tc.desc Test Js Api updateData with invalid options
127   * @tc.type: FUNC
128   * @tc.require: issueNumber
129   */
130  it('UdmfUpdateCallbackInvalidOptionsTest', 0, async function (done) {
131    const TAG = 'UdmfUpdateCallbackInvalidOptionsTest:';
132    console.info(TAG, 'start');
133    try {
134      UDC.updateData(optionsInValidKey, unifiedData01, (err) => {
135        console.error(TAG, 'Unreachable code!');
136        expect(null).assertFail();
137      });
138      done();
139    } catch (e) {
140      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
141      expect(e.code === ERROR_PARAMETER).assertTrue();
142      done();
143    }
144    console.info(TAG, 'end');
145  });
146
147  /**
148   * @tc.name UdmfUpdateCallbackInvalidDataTest
149   * @tc.desc Test Js Api updateData with invalid UnifiedData
150   * @tc.type: FUNC
151   * @tc.require: issueNumber
152   */
153  it('UdmfUpdateCallbackInvalidDataTest', 0, async function (done) {
154    const TAG = 'UdmfUpdateCallbackInvalidDataTest:';
155    console.info(TAG, 'start');
156    try {
157      UDC.insertData(optionsValid, unifiedData01, (err, data) => {
158        expect(err).assertUndefined();
159        console.info(TAG, `insert success. The key: ${data}`);
160        let options = { key: data };
161        console.info(TAG, `update start. The options: ${JSON.stringify(options)}`);
162        UDC.updateData(options, unifiedDataInvalid, (err) => {
163          console.error(TAG, `get fail. code is ${err.code},message is ${err.message} `);
164          expect(err.code === ERROR_PARAMETER).assertTrue();
165          done();
166        });
167      });
168    } catch (e) {
169      console.error(TAG, 'Unreachable code!');
170      expect(null).assertFail();
171      done();
172    }
173    console.info(TAG, 'end');
174  });
175
176  /**
177   * @tc.name UdmfUpdateCallbackSucTest
178   * @tc.desc Test Js Api updateData successful
179   * @tc.type: FUNC
180   * @tc.require: issueNumber
181   */
182  it('UdmfUpdateCallbackSucTest', 0, async function (done) {
183    const TAG = 'UdmfUpdateCallbackSucTest:';
184    console.info(TAG, 'start');
185    try {
186      UDC.insertData(optionsValid, unifiedData01, (err, data) => {
187        expect(err).assertUndefined();
188        console.info(TAG, `insert success. The key: ${data}`);
189        let options = { key: data };
190        console.info(TAG, `update start. The options: ${JSON.stringify(options)}`);
191        UDC.updateData(options, unifiedData02, (err) => {
192          expect(err).assertUndefined();
193          console.info(TAG, 'update success.');
194          UDC.queryData(options, (err, data) => {
195            expect(err).assertUndefined();
196            console.info(TAG, 'query success.');
197            expect(data.length).assertEqual(1);
198            let records = data[0].getRecords();
199            expect(records.length).assertEqual(1);
200            expect(records[0].getType()).assertEqual(UTD.UniformDataType.PLAIN_TEXT);
201            expect(records[0].textContent).assertEqual(TEXT_CONTEXT_02);
202            done();
203          });
204        });
205      });
206
207    } catch (e) {
208      console.error(TAG, 'Unreachable code!');
209      expect(null).assertFail();
210      done();
211    }
212    console.info(TAG, 'end');
213  });
214
215
216  /**
217   * @tc.name UdmfQueryCallbackInvalidOptionsTest
218   * @tc.desc Test Js Api queryData with invalid options
219   * @tc.type: FUNC
220   * @tc.require: issueNumber
221   */
222  it('UdmfQueryCallbackInvalidOptionsTest', 0, async function (done) {
223    const TAG = 'UdmfQueryCallbackInvalidOptionsTest:';
224    console.info(TAG, 'start');
225    try {
226      UDC.queryData(optionsInValidAll, (err, data) => {
227        console.error(TAG, 'Unreachable code!');
228        expect(null).assertFail();
229        done();
230      });
231    } catch (e) {
232      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
233      expect(e.code === ERROR_PARAMETER).assertTrue();
234      done();
235    }
236    console.info(TAG, 'end');
237  });
238
239  /**
240   * @tc.name UdmfQueryCallbackSucTest
241   * @tc.desc Test Js Api queryData successful
242   * @tc.type: FUNC
243   * @tc.require: issueNumber
244   */
245  it('UdmfQueryCallbackSucTest', 0, async function (done) {
246    const TAG = 'UdmfQueryCallbackSucTest:';
247    console.info(TAG, 'start');
248    try {
249      UDC.deleteData(optionsValid, (err, data) => {
250        expect(err).assertUndefined();
251        console.info(TAG, 'delete success.');
252        UDC.queryData(optionsValid, (err, data) => {
253          console.info(TAG, 'query has no data.');
254          expect(data).assertUndefined();
255          UDC.insertData(optionsValid, unifiedData01, (err, data) => {
256            expect(err).assertUndefined();
257            console.info(TAG, `insert success. The key: ${data}`);
258            UDC.insertData(optionsValid, unifiedData02, (err, data) => {
259              expect(err).assertUndefined();
260              console.info(TAG, `insert success. The key: ${data}`);
261              UDC.queryData(optionsValid, function (err, data) {
262                expect(err).assertUndefined();
263                console.info(TAG, 'query success.data.length=' + data.length);
264                expect(data.length).assertEqual(2);
265                done();
266              });
267            });
268          });
269        });
270      });
271    } catch (e) {
272      console.error(TAG, 'Unreachable code!');
273      expect(null).assertFail();
274      done();
275    }
276    console.info(TAG, 'end');
277  });
278
279
280  /**
281   * @tc.name UdmfDeleteCallbackInvalidOptionsTest
282   * @tc.desc Test Js Api deleteData with invalid options
283   * @tc.type: FUNC
284   * @tc.require: issueNumber
285   */
286  it('UdmfDeleteCallbackInvalidOptionsTest', 0, async function (done) {
287    const TAG = 'UdmfDeleteCallbackInvalidOptionsTest:';
288    console.info(TAG, 'start');
289    try {
290      UDC.deleteData(optionsInValidAll, (err, data) => {
291        console.error(TAG, 'Unreachable code!');
292        expect(null).assertFail();
293        done();
294      });
295    } catch (e) {
296      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
297      expect(e.code === ERROR_PARAMETER).assertTrue();
298      done();
299    }
300    console.info(TAG, 'end');
301  });
302
303  /**
304   * @tc.name UdmfDeleteCallbackSucTest
305   * @tc.desc Test Js Api deleteData successful
306   * @tc.type: FUNC
307   * @tc.require: issueNumber
308   */
309  it('UdmfDeleteCallbackSucTest', 0, async function (done) {
310    const TAG = 'UdmfDeleteCallbackSucTest:';
311    console.info(TAG, 'start');
312    try {
313      UDC.insertData(optionsValid, unifiedData01, (err, data) => {
314        expect(err).assertUndefined();
315        console.info(TAG, `insert success. The key: ${data}`);
316        let options = { key: data };
317        console.info(TAG, `query start. The options: ${JSON.stringify(options)}`);
318        UDC.queryData(options, (err, data) => {
319          expect(err).assertUndefined();
320          console.info(TAG, 'query success.');
321          expect(data.length).assertEqual(1);
322          UDC.deleteData(options, (err, data) => {
323            expect(err).assertUndefined();
324            console.info(TAG, 'delete success.');
325            expect(data.length).assertEqual(1);
326            let records = data[0].getRecords();
327            expect(records.length).assertEqual(1);
328            expect(records[0].getType()).assertEqual(UTD.UniformDataType.PLAIN_TEXT);
329            expect(records[0].textContent).assertEqual(TEXT_CONTEXT_01);
330            UDC.queryData(options, (err, data) => {
331              expect(data).assertUndefined();
332              console.info(TAG, 'query has no data.');
333              done();
334            });
335          });
336        });
337      });
338    } catch (e) {
339      console.error(TAG, 'Unreachable code!');
340      expect(null).assertFail();
341      done();
342    }
343    console.info(TAG, 'end');
344  });
345});