1/*
2 * Copyright (c) 2022 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 */
15import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
16import ddm from '@ohos.data.distributedData';
17
18const TEST_BUNDLE_NAME = 'com.example.myapplication';
19const TEST_STORE_ID = 'storeId';
20
21var kvManager = null;
22var kvStore = null;
23
24function putBatchString(len, prefix) {
25    let entries = [];
26    for (var i = 0; i < len; i++) {
27        entries.push({
28            key : prefix + i,
29            value : {
30                type : ddm.ValueType.STRING,
31                value : '{"english":{"first":"leda' + i + '", "second":"yang"}}'
32            }
33        });
34    }
35    return entries;
36}
37
38async function testPutAndGet(kvManager, options) {
39    try {
40        await kvManager.getKVStore(TEST_STORE_ID, options).then(async (store) => {
41            console.info('testPutAndGet getKVStore success' + JSON.stringify(options));
42            kvStore = store;
43            expect(store != null).assertTrue();
44        }).catch((err) => {
45            console.info('testPutAndGet getKVStore fail ' + err);
46            expect(null).assertFail();
47        });
48        var canGet = new Promise((resolve, reject) => {
49            kvStore.on('dataChange', 0, function (data) {
50                console.info('testPutAndGet resolve on data change: ' + JSON.stringify(data));
51                resolve(data.deviceId);
52            });
53            let entries = putBatchString(10, 'test_key_');
54            kvStore.putBatch(entries).then((data) => {
55                console.info('testPutAndGet put success');
56                expect(data == undefined).assertTrue();
57            });
58            setTimeout(() => {
59                reject(new Error('not resolved in 2 second, reject it.'))
60            }, 2000);
61        });
62        await canGet.then(async function(deviceId) {
63            var query = new ddm.Query();
64            query.prefixKey('test_key_');
65            query.like('$.english.first', 'led%');
66            if (options.kvStoreType == ddm.KVStoreType.DEVICE_COLLABORATION) {
67                console.info('testPutAndGet deviceId = ' + deviceId);
68                query.deviceId(deviceId);
69            }
70            await kvStore.getEntries(query).then((entries) => {
71                console.info('testPutAndGet get success : ' + JSON.stringify(entries));
72                expect(entries.length == 10).assertTrue();
73            }).catch((err) => {
74                console.info('testPutAndGet get fail ' + err);
75                expect(null).assertFail();
76            });
77        }).catch((error) => {
78            console.info('testPutAndGet canGet fail: ' + error);
79            expect(null).assertFail();
80        });
81    } catch (e) {
82        console.info('testPutAndGet get exception: ' + e);
83    }
84}
85
86describe('schemaTest', function() {
87    const config = {
88        bundleName : TEST_BUNDLE_NAME,
89        userInfo : {
90            userId : '0',
91            userType : ddm.UserType.SAME_USER_ID
92        }
93    }
94
95    var options = {
96        createIfMissing : true,
97        encrypt : false,
98        backup : false,
99        autoSync : true,
100        kvStoreType : ddm.KVStoreType.SINGLE_VERSION,
101        schema : {},
102        securityLevel : ddm.SecurityLevel.NO_LEVEL,
103    }
104
105    beforeAll(async function (done) {
106        try {
107            console.info("beforeAll: createKVManager (single) with " + JSON.stringify(options));
108            await ddm.createKVManager(config).then((manager) => {
109                kvManager = manager;
110                console.info('beforeAll createKVManager success');
111            }).catch((err) => {
112                console.info('beforeAll createKVManager err ' + err);
113            });
114        } catch (e) {
115            console.info("fail on exception: " + e);
116            expect(null).assertFail();
117        }
118        done();
119    })
120
121    afterAll(async function (done) {
122        console.info('afterAll');
123        kvManager = null;
124        kvStore = null;
125        done();
126    })
127
128    beforeEach(async function (done) {
129        console.info('beforeEach testcase will update options:' + JSON.stringify(options));
130        done();
131    })
132
133    afterEach(async function (done) {
134        console.info('afterEach');
135        await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, kvStore).then(async () => {
136            console.info('afterEach closeKVStore success');
137            await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => {
138                console.info('afterEach deleteKVStore success');
139            }).catch((err) => {
140                console.info('afterEach deleteKVStore err ' + err);
141            });
142        }).catch((err) => {
143            console.info('afterEach closeKVStore err ' + err);
144        });
145        kvStore = null;
146        done();
147    })
148
149    /**
150     * @tc.name SchemaToJsonStringTest001
151     * @tc.desc  Test Js Api Schema.ToJsonString() testcase 001
152     * @tc.type: FUNC
153     * @tc.require: issueNumber
154     */
155    it('SchemaToJsonStringTest001', 0, async function(done) {
156        try {
157            let first = new ddm.FieldNode('first');
158            first.type = ddm.ValueType.STRING;
159            first.nullable = false;
160            first.default = 'first name';
161
162            let second = new ddm.FieldNode('second');
163            second.type = ddm.ValueType.STRING;
164            second.nullable = false;
165            second.default = 'second name';
166
167            let english = new ddm.FieldNode('english');
168            english.type = ddm.ValueType.STRING;
169            english.appendChild(first);
170            english.appendChild(second);
171
172            let schema = new ddm.Schema();
173            schema.root.appendChild(english);
174            schema.indexes = ['$.english.first', '$.english.second'];
175        } catch (e) {
176            console.info("schema fail on exception: " + e);
177            expect(null).assertFail();
178        }
179        done();
180    })
181
182    /**
183     * @tc.name SchemaToJsonStringTest002
184     * @tc.desc  Test Js Api Schema.ToJsonString() testcase 002
185     * @tc.type: FUNC
186     * @tc.require: issueNumber
187     */
188    it('SchemaToJsonStringTest002', 0, async function(done) {
189        try {
190            let first = new ddm.FieldNode('first');
191            first.type = ddm.ValueType.STRING;
192            first.nullable = false;
193            first.default = 'first name';
194
195            let second = new ddm.FieldNode('second');
196            second.type = ddm.ValueType.STRING;
197            second.nullable = false;
198            second.default = 'second name';
199
200            let english = new ddm.FieldNode('english');
201            english.type = ddm.ValueType.STRING;
202            english.appendChild(first);
203            english.appendChild(second);
204
205            let schema = new ddm.Schema();
206            schema.root.appendChild(english);
207            schema.indexes = ['$.english.first', '$.english.second'];
208            options.kvStoreType = ddm.KVStoreType.DEVICE_COLLABORATION;
209            options.schema = schema;
210            await testPutAndGet(kvManager, options);
211            console.info("schematestPutAndGet done");
212        } catch (e) {
213            console.info("schema fail on exception: " + e);
214            expect(null).assertFail();
215        }
216        done();
217    })
218
219    /**
220     * @tc.name SchemaToJsonStringTest003
221     * @tc.desc  Test Js Api Schema.ToJsonString() testcase 003
222     * @tc.type: FUNC
223     * @tc.require: issueNumber
224     */
225    it('SchemaToJsonStringTest003', 0, async function(done) {
226        try {
227            let name = new ddm.FieldNode('name');
228            name.type = ddm.ValueType.INTEGER;
229            name.nullable = false;
230            name.default = '0';
231
232            let schema = new ddm.Schema();
233            schema.root.appendChild(name);
234            schema.indexes = ['$.name'];
235            schema.mode = 1; // STRICT
236            options.kvStoreType = ddm.KVStoreType.SINGLE_VERSION;
237            options.schema = schema;
238            await kvManager.getKVStore(TEST_STORE_ID, options).then(async (store) => {
239                console.info('SchemaToJsonStringTest003 getKVStore success' + JSON.stringify(options));
240                kvStore = store;
241                expect(store != null).assertTrue();
242                await kvStore.put("test_key_1", '{"name":1}');
243                await kvStore.put("test_key_2", '{"name":2}');
244                await kvStore.put("test_key_3", '{"name":3}');
245                console.info('SchemaToJsonStringTest003 Put success');
246            });
247            console.info('SchemaToJsonStringTest003 start Query ...');
248            var query = new ddm.Query();
249            query.prefixKey('test_key_');
250            query.notEqualTo("$.name", 3);
251            await kvStore.getEntries(query).then((entries) => {
252                console.info('SchemaToJsonStringTest003 get success : ' + JSON.stringify(entries));
253                expect(entries.length == 2).assertTrue();
254            }).catch((err) => {
255                console.info('SchemaToJsonStringTest003 get fail ' + err);
256                expect(null).assertFail();
257            });
258        } catch (e) {
259            console.info("SchemaToJsonStringTest003 fail on exception: " + e);
260            expect(null).assertFail();
261        }
262        done();
263    })
264
265    /**
266     * @tc.name SchemaToJsonStringTest004
267     * @tc.desc  Test Js Api Schema.ToJsonString() testcase 004
268     * @tc.type: FUNC
269     * @tc.require: issueNumber
270     */
271    it('SchemaToJsonStringTest004', 0, async function(done) {
272        try {
273            let name = new ddm.FieldNode('name');
274            name.type = ddm.ValueType.FLOAT;
275            name.nullable = true;
276            name.default = '3.14';
277
278            let schema = new ddm.Schema();
279            schema.root.appendChild(name);
280            schema.indexes = [];
281            schema.mode = 1; // COMPATIBLE
282            options.kvStoreType = ddm.KVStoreType.SINGLE_VERSION;
283            options.schema = schema;
284            await kvManager.getKVStore(TEST_STORE_ID, options).then(async (store) => {
285                console.info('SchemaToJsonStringTest005 getKVStore success' + JSON.stringify(options));
286                kvStore = store;
287                expect(store != null).assertTrue();
288                await kvStore.put("test_key_1", '{"name":1.5}');
289                await kvStore.put("test_key_2", '{"name":2.5}');
290                await kvStore.put("test_key_3", '{}');
291                console.info('SchemaToJsonStringTest005 Put success');
292            });
293            console.info('SchemaToJsonStringTest005 start Query ...');
294            await kvStore.getEntries('test_key_').then((entries) => {
295                console.info('SchemaToJsonStringTest005 get success : ' + JSON.stringify(entries));
296                expect(entries.length == 3).assertTrue();
297            }).catch((err) => {
298                console.info('SchemaToJsonStringTest005 get fail ' + err);
299                expect(null).assertFail();
300            });
301        } catch (e) {
302            console.info("SchemaToJsonStringTest005 fail on exception: " + e);
303            expect(null).assertFail();
304        }
305        done();
306    })
307
308    /**
309    * @tc.name SchemaToJsonStringTest005
310    * @tc.desc Test Js Api Schema.ToJsonString() testcase 003
311    * @tc.type: FUNC
312    * @tc.require: issueNumber
313    */
314    it('SchemaToJsonStringTest005', 0, async function (done) {
315        try {
316            let name = new ddm.FieldNode('name');
317            name.type = ddm.ValueType.FLOAT;
318            name.nullable = true;
319            name.default = '3.14';
320
321            let schema = new ddm.Schema();
322            schema.root.appendChild(name);
323            schema.indexes = ['$.name'];
324            schema.mode = 1; // STRICT
325            options.kvStoreType = ddm.KVStoreType.SINGLE_VERSION;
326            options.schema = schema;
327            await kvManager.getKVStore(TEST_STORE_ID, options).then(async (store) => {
328                console.info('SchemaToJsonStringTest005 getKVStore success' + JSON.stringify(options));
329                kvStore = store;
330                expect(store != null).assertTrue();
331                await kvStore.put("test_key_1", '{"name":1.5}');
332                await kvStore.put("test_key_2", '{"name":2.5}');
333                await kvStore.put("test_key_3", '{}');
334                console.info('SchemaToJsonStringTest005 Put success');
335            });
336            console.info('SchemaToJsonStringTest005 start Query ...');
337            var query = new ddm.Query();
338            query.prefixKey('test_key_');
339            query.equalTo("$.name", 3.14);
340            await kvStore.getEntries(query).then((entries) => {
341                console.info('SchemaToJsonStringTest005 get success : ' + JSON.stringify(entries));
342                expect(entries.length == 1).assertTrue();
343            }).catch((err) => {
344                console.info('SchemaToJsonStringTest005 get fail ' + err);
345                expect(null).assertFail();
346            });
347        } catch (e) {
348            console.info("SchemaToJsonStringTest005 fail on exception: " + e);
349            expect(null).assertFail();
350        }
351        done();
352    })
353
354    /**
355     * @tc.name SchemaToJsonStringTest006
356     * @tc.desc  Test Js Api Schema.ToJsonString() testcase 003
357     * @tc.type: FUNC
358     * @tc.require: issueNumber
359     */
360    it('SchemaToJsonStringTest006', 0, async function (done) {
361        try {
362            let name = new ddm.FieldNode('name');
363            name.type = ddm.ValueType.DOUBLE;
364            name.nullable = true;
365            name.default = '3.1415';
366
367            let schema = new ddm.Schema();
368            schema.root.appendChild(name);
369            schema.indexes = ['$.name'];
370            schema.mode = 1; // STRICT
371            options.kvStoreType = ddm.KVStoreType.SINGLE_VERSION;
372            options.schema = schema;
373            await kvManager.getKVStore(TEST_STORE_ID, options).then(async (store) => {
374                console.info('SchemaToJsonStringTest006 getKVStore success' + JSON.stringify(options));
375                kvStore = store;
376                expect(store != null).assertTrue();
377                await kvStore.put("test_key_1", '{"name":1.51}');
378                await kvStore.put("test_key_2", '{}');
379                await kvStore.put("test_key_3", '{}');
380                console.info('SchemaToJsonStringTest006 Put success');
381            });
382            console.info('SchemaToJsonStringTest006 start Query ...');
383            var query = new ddm.Query();
384            query.prefixKey('test_key_');
385            query.equalTo("$.name", 3.1415);
386            await kvStore.getEntries(query).then((entries) => {
387                console.info('SchemaToJsonStringTest006 get success : ' + JSON.stringify(entries));
388                expect(entries.length == 2).assertTrue();
389            }).catch((err) => {
390                console.info('SchemaToJsonStringTest006 get fail ' + err);
391                expect(null).assertFail();
392            });
393        } catch (e) {
394            console.info("SchemaToJsonStringTest006 fail on exception: " + e);
395            expect(null).assertFail();
396        }
397        done();
398    })
399
400    /**
401     * @tc.name SchemaToJsonStringTest007
402     * @tc.desc  Test Js Api Schema.ToJsonString() testcase 003
403     * @tc.type: FUNC
404     * @tc.require: issueNumber
405     */
406    it('SchemaToJsonStringTest007', 0, async function (done) {
407        try {
408            let name = new ddm.FieldNode('name');
409            name.type = ddm.ValueType.BOOLEAN;
410            name.nullable = true;
411            name.default = 'false';
412
413            let schema = new ddm.Schema();
414            schema.root.appendChild(name);
415            schema.indexes = ['$.name'];
416            schema.mode = 1; // STRICT
417            options.kvStoreType = ddm.KVStoreType.SINGLE_VERSION;
418            options.schema = schema;
419            await kvManager.getKVStore(TEST_STORE_ID, options).then(async (store) => {
420                console.info('SchemaToJsonStringTest007 getKVStore success' + JSON.stringify(options));
421                kvStore = store;
422                expect(store != null).assertTrue();
423                await kvStore.put("test_key_1", '{"name":false}');
424                await kvStore.put("test_key_2", '{"name":true}');
425                await kvStore.put("test_key_3", '{}');
426                console.info('SchemaToJsonStringTest007 Put success');
427            });
428            console.info('SchemaToJsonStringTest007 start Query ...');
429            var query = new ddm.Query();
430            query.prefixKey('test_key_');
431            query.equalTo("$.name", false);
432            await kvStore.getEntries(query).then((entries) => {
433                console.info('SchemaToJsonStringTest007 get success : ' + JSON.stringify(entries));
434                expect(entries.length == 2).assertTrue();
435            }).catch((err) => {
436                console.info('SchemaToJsonStringTest007 get fail ' + err);
437                expect(null).assertFail();
438            });
439        } catch (e) {
440            console.info("SchemaToJsonStringTest007 fail on exception: " + e);
441            expect(null).assertFail();
442        }
443        done();
444    })
445
446    /**
447     * @tc.name SchemarootTest001
448     * @tc.desc  Test Js Api Schema.root testcase 001
449     * @tc.type: FUNC
450     * @tc.require: issueNumber
451     */
452     it('SchemarootTest001', 0, async function(done) {
453        try {
454            let english = new ddm.FieldNode('english');
455            english.type = ddm.ValueType.STRING;
456
457            let schema = new ddm.Schema();
458            expect(schema.root instanceof ddm.FieldNode).assertTrue();
459        } catch (e) {
460            console.info("schema fail on exception: " + e);
461            expect(null).assertFail();
462        }
463        done();
464    })
465
466    /**
467     * @tc.name SchemaindexesTest001
468     * @tc.desc  Test Js Api Schema.indexes testcase 001
469     * @tc.type: FUNC
470     * @tc.require: issueNumber
471     */
472     it('SchemaindexesTest001', 0, async function(done) {
473        try {
474
475            let schema = new ddm.Schema();
476            schema.indexes = ['$.english.first', '$.english.second'];
477            expect(schema.indexes[0] === '$.english.first' && schema.indexes[1] === '$.english.second').assertTrue();
478        } catch (e) {
479            console.info("schema fail on exception: " + e);
480            expect(null).assertFail();
481        }
482        done();
483    })
484
485    /**
486     * @tc.name SchemamodeTest001
487     * @tc.desc  Test Js Api Schema.mode testcase 001
488     * @tc.type: FUNC
489     * @tc.require: issueNumber
490     */
491     it('SchemamodeTest001', 0, async function(done) {
492        try {
493
494            let schema = new ddm.Schema();
495            schema.mode = 1;
496            console.info("schema mode = "+schema.mode)
497            expect(schema.mode === 1).assertTrue();
498        } catch (e) {
499            console.info("schema fail on exception: " + e);
500            expect(null).assertFail();
501        }
502        done();
503    })
504
505    /**
506     * @tc.name SchemamodeTest002
507     * @tc.desc  Test Js Api Schema.mode testcase 002
508     * @tc.type: FUNC
509     * @tc.require: issueNumber
510     */
511     it('SchemamodeTest002', 0, async function(done) {
512        try {
513
514            let schema = new ddm.Schema();
515            schema.mode = 0;
516            console.info("schema mode = "+schema.mode)
517            expect(schema.mode === 0).assertTrue();
518        } catch (e) {
519            console.info("schema fail on exception: " + e);
520            expect(null).assertFail();
521        }
522        done();
523    })
524
525    /**
526     * @tc.name SchemaskipTest001
527     * @tc.desc  Test Js Api Schema.skip testcase 001
528     * @tc.type: FUNC
529     * @tc.require: issueNumber
530     */
531     it('SchemaskipTest001', 0, async function(done) {
532        try {
533
534            let schema = new ddm.Schema();
535            schema.skip = 0;
536            expect(schema.skip === 0).assertTrue();
537        } catch (e) {
538            console.info("schema fail on exception: " + e);
539            expect(null).assertFail();
540        }
541        done();
542    })
543})
544