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 factory from '@ohos.data.distributedData';
17import abilityFeatureAbility from '@ohos.ability.featureAbility';
18
19var context = abilityFeatureAbility.getContext();
20var contextApplication = context.getApplicationContext()
21
22const TEST_BUNDLE_NAME = 'com.example.myapplication';
23const TEST_STORE_ID = 'storeId';
24var kvManager = null;
25var kvStore = null;
26const STORE_KEY = 'key_test_string';
27const STORE_VALUE = 'value-test-string';
28
29describe('KvManagerPromiseTest', function () {
30    const config = {
31        bundleName: TEST_BUNDLE_NAME,
32        userInfo: {
33            userId: '0',
34            userType: factory.UserType.SAME_USER_ID
35        }
36    }
37
38    const options = {
39        createIfMissing: true,
40        encrypt: false,
41        backup: false,
42        autoSync: true,
43        kvStoreType: factory.KVStoreType.SINGLE_VERSION,
44        schema: '',
45        securityLevel: factory.SecurityLevel.S2,
46    }
47
48    beforeAll(async function (done) {
49        console.info('beforeAll');
50        await factory.createKVManager(config).then((manager) => {
51            kvManager = manager;
52            console.info('beforeAll createKVManager success');
53        }).catch((err) => {
54            console.error('beforeAll createKVManager err ' + `, error code is ${err.code}, message is ${err.message}`);
55        });
56        console.info('beforeAll end');
57        done();
58    })
59
60    afterAll(async function (done) {
61        console.info('afterAll');
62        done();
63    })
64
65    beforeEach(async function (done) {
66        console.info('beforeEach');
67        done();
68    })
69
70    afterEach(async function (done) {
71        console.info('afterEach');
72        await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, kvStore).then(async () => {
73            console.info('afterEach closeKVStore success');
74            await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => {
75                console.info('afterEach deleteKVStore success');
76            }).catch((err) => {
77                console.error('afterEach deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
78            });
79        }).catch((err) => {
80            console.error('afterEach closeKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
81        });
82        kvStore = null;
83        done();
84    })
85
86    /**
87     * @tc.name KVManagerGetKVStorePromiseTest001
88     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 001
89     * @tc.type: FUNC
90     * @tc.require: issueNumber
91     */
92    it('KVManagerGetKVStorePromiseTest001', 0, async function (done) {
93        console.info('KVManagerGetKVStorePromiseTest001');
94        try {
95            await kvManager.getKVStore(TEST_STORE_ID).then((store) => {
96                console.info('KVManagerGetKVStorePromiseTest001 getKVStore success');
97                expect(null).assertFail();
98            }).catch((err) => {
99                console.error('KVManagerGetKVStorePromiseTest001 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
100            });
101        } catch (e) {
102            console.error('KVManagerGetKVStorePromiseTest001 getKVStore e ' + `, error code is ${e.code}, message is ${e.message}`);
103        }
104        done();
105    })
106
107    /**
108     * @tc.name KVManagerGetKVStorePromiseTest002
109     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 002
110     * @tc.type: FUNC
111     * @tc.require: issueNumber
112     */
113    it('KVManagerGetKVStorePromiseTest002', 0, async function (done) {
114        console.info('KVManagerGetKVStorePromiseTest002');
115        try {
116            await kvManager.getKVStore(options).then((store) => {
117                console.info('KVManagerGetKVStorePromiseTest002 getKVStore success');
118                expect(null).assertFail();
119            }).catch((err) => {
120                console.error('KVManagerGetKVStorePromiseTest002 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
121            });
122        } catch (e) {
123            console.error('KVManagerGetKVStorePromiseTest002 getKVStore e ' + `, error code is ${e.code}, message is ${e.message}`);
124        }
125        done();
126    })
127
128    /**
129     * @tc.name KVManagerGetKVStorePromiseTest003
130     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 003
131     * @tc.type: FUNC
132     * @tc.require: issueNumber
133     */
134    it('KVManagerGetKVStorePromiseTest003', 0, async function (done) {
135        console.info('KVManagerGetKVStorePromiseTest003');
136        const optionsInfo = {
137            createIfMissing: true,
138            encrypt: false,
139            backup: false,
140            autoSync: true,
141            kvStoreType: factory.KVStoreType.SINGLE_VERSION,
142            schema: '',
143            securityLevel: factory.SecurityLevel.NO_LEVEL,
144        }
145        await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
146            console.info('KVManagerGetKVStorePromiseTest003 getKVStore success');
147            kvStore = store;
148            expect(store != null).assertTrue();
149        }).catch((err) => {
150            console.error('KVManagerGetKVStorePromiseTest003 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
151            expect(null).assertFail();
152        });
153        done();
154    })
155
156    /**
157     * @tc.name KVManagerGetKVStorePromiseTest004
158     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 004
159     * @tc.type: FUNC
160     * @tc.require: issueNumber
161     */
162    it('KVManagerGetKVStorePromiseTest004', 0, async function (done) {
163        console.info('KVManagerGetKVStorePromiseTest004');
164        const optionsInfo = {
165            createIfMissing: false,
166            encrypt: false,
167            backup: false,
168            autoSync: true,
169            kvStoreType: factory.KVStoreType.SINGLE_VERSION,
170            schema: '',
171            securityLevel: factory.SecurityLevel.S1,
172        }
173        await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
174            console.info('KVManagerGetKVStorePromiseTest004 getKVStore success');
175            expect(null).assertFail();
176        }).catch((err) => {
177            console.error('KVManagerGetKVStorePromiseTest004 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
178        });
179        done();
180    })
181
182    /**
183     * @tc.name KVManagerGetKVStorePromiseTest005
184     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 005
185     * @tc.type: FUNC
186     * @tc.require: issueNumber
187     */
188    it('KVManagerGetKVStorePromiseTest005', 0, async function (done) {
189        console.info('KVManagerGetKVStorePromiseTest005');
190        const optionsInfo = {
191            createIfMissing: true,
192            encrypt: true,
193            backup: false,
194            autoSync: true,
195            kvStoreType: factory.KVStoreType.SINGLE_VERSION,
196            schema: '',
197            securityLevel: factory.SecurityLevel.S2,
198        }
199        await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
200            console.info('KVManagerGetKVStorePromiseTest005 getKVStore success');
201            kvStore = store;
202            expect(store != null).assertTrue();
203        }).catch((err) => {
204            console.error('KVManagerGetKVStorePromiseTest005 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
205            expect(null).assertFail();
206        });
207        done();
208    })
209
210    /**
211     * @tc.name KVManagerGetKVStorePromiseTest006
212     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 006
213     * @tc.type: FUNC
214     * @tc.require: issueNumber
215     */
216    it('KVManagerGetKVStorePromiseTest006', 0, async function (done) {
217        console.info('KVManagerGetKVStorePromiseTest006');
218        const optionsInfo = {
219            createIfMissing: true,
220            encrypt: false,
221            backup: false,
222            autoSync: true,
223            kvStoreType: factory.KVStoreType.SINGLE_VERSION,
224            schema: '',
225            securityLevel: factory.SecurityLevel.S3,
226        }
227        await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
228            console.info('KVManagerGetKVStorePromiseTest006 getKVStore success');
229            kvStore = store;
230            expect(store != null).assertTrue();
231        }).catch((err) => {
232            console.error('KVManagerGetKVStorePromiseTest006 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
233            expect(null).assertFail();
234        });
235        done();
236    })
237
238    /**
239     * @tc.name KVManagerGetKVStorePromiseTest007
240     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 007
241     * @tc.type: FUNC
242     * @tc.require: issueNumber
243     */
244    it('KVManagerGetKVStorePromiseTest007', 0, async function (done) {
245        console.info('KVManagerGetKVStorePromiseTest006');
246        const optionsInfo = {
247            createIfMissing: true,
248            encrypt: false,
249            backup: true,
250            autoSync: true,
251            kvStoreType: factory.KVStoreType.SINGLE_VERSION,
252            schema: '',
253            securityLevel: factory.SecurityLevel.S4,
254        }
255        await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
256            console.info('KVManagerGetKVStorePromiseTest007 getKVStore success');
257            kvStore = store;
258            expect(store != null).assertTrue();
259        }).catch((err) => {
260            console.error('KVManagerGetKVStorePromiseTest007 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
261            expect(null).assertFail();
262        });
263        done();
264    })
265
266    /**
267     * @tc.name KVManagerGetKVStorePromiseTest008
268     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 008
269     * @tc.type: FUNC
270     * @tc.require: issueNumber
271     */
272    it('KVManagerGetKVStorePromiseTest008', 0, async function (done) {
273        console.info('KVManagerGetKVStorePromiseTest008');
274        const optionsInfo = {
275            createIfMissing: true,
276            encrypt: false,
277            backup: false,
278            autoSync: true,
279            kvStoreType: factory.KVStoreType.DEVICE_COLLABORATION,
280            schema: '',
281            securityLevel: factory.SecurityLevel.NO_LEVEL,
282        }
283        await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
284            console.info('KVManagerGetKVStorePromiseTest008 getKVStore success');
285            kvStore = store;
286            expect(store != null).assertTrue();
287        }).catch((err) => {
288            console.error('KVManagerGetKVStorePromiseTest008 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
289            expect(null).assertFail();
290        });
291        done();
292    })
293
294    /**
295     * @tc.name KVManagerGetKVStorePromiseTest009
296     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 009
297     * @tc.type: FUNC
298     * @tc.require: issueNumber
299     */
300    it('KVManagerGetKVStorePromiseTest009', 0, async function (done) {
301        console.info('KVManagerGetKVStorePromiseTest009');
302        const optionsInfo = {
303            createIfMissing: true,
304            encrypt: false,
305            backup: false,
306            autoSync: true,
307            kvStoreType: factory.KVStoreType.DEVICE_COLLABORATION,
308            schema: '',
309            securityLevel: factory.SecurityLevel.S0,
310        }
311        await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
312            console.info('KVManagerGetKVStorePromiseTest009 getKVStore success');
313            kvStore = store;
314            expect(store != null).assertTrue();
315        }).catch((err) => {
316            console.error('KVManagerGetKVStorePromiseTest009 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
317            expect(null).assertFail();
318        });
319        done();
320    })
321
322    /**
323     * @tc.name KVManagerGetKVStorePromiseTest010
324     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 010
325     * @tc.type: FUNC
326     * @tc.require: issueNumber
327     */
328    it('KVManagerGetKVStorePromiseTest010', 0, async function (done) {
329        console.info('KVManagerGetKVStorePromiseTest010');
330        const optionsInfo = {
331            createIfMissing: true,
332            encrypt: false,
333            backup: false,
334            autoSync: false,
335            kvStoreType: factory.KVStoreType.DEVICE_COLLABORATION,
336            schema: '',
337            securityLevel: factory.SecurityLevel.S1,
338        }
339        await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
340            console.info('KVManagerGetKVStorePromiseTest010 getKVStore success');
341            kvStore = store;
342            expect(store != null).assertTrue();
343        }).catch((err) => {
344            console.error('KVManagerGetKVStorePromiseTest010 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
345            expect(null).assertFail();
346        });
347        done();
348    })
349
350    /**
351     * @tc.name KVManagerGetKVStorePromiseTest011
352     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 011
353     * @tc.type: FUNC
354     * @tc.require: issueNumber
355     */
356    it('KVManagerGetKVStorePromiseTest011', 0, async function (done) {
357        console.info('KVManagerGetKVStorePromiseTest011');
358        const optionsInfo = {
359            createIfMissing: true,
360            encrypt: false,
361            backup: false,
362            autoSync: true,
363            kvStoreType: factory.KVStoreType.DEVICE_COLLABORATION,
364            schema: '',
365            securityLevel: factory.SecurityLevel.S2,
366        }
367        await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
368            console.info('KVManagerGetKVStorePromiseTest011 getKVStore success');
369            kvStore = store;
370            expect(store != null).assertTrue();
371        }).catch((err) => {
372            console.error('KVManagerGetKVStorePromiseTest011 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
373            expect(null).assertFail();
374        });
375        done();
376    })
377
378    /**
379     * @tc.name KVManagerGetKVStorePromiseTest012
380     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 012
381     * @tc.type: FUNC
382     * @tc.require: issueNumber
383     */
384    it('KVManagerGetKVStorePromiseTest012', 0, async function (done) {
385        console.info('KVManagerGetKVStorePromiseTest012');
386        const optionsInfo = {
387            createIfMissing: true,
388            encrypt: false,
389            backup: false,
390            autoSync: true,
391            kvStoreType: factory.KVStoreType.DEVICE_COLLABORATION,
392            schema: '',
393            securityLevel: factory.SecurityLevel.S3,
394        }
395        await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
396            console.info('KVManagerGetKVStorePromiseTest012 getKVStore success');
397            kvStore = store;
398            expect(store != null).assertTrue();
399        }).catch((err) => {
400            console.error('KVManagerGetKVStorePromiseTest012 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
401            expect(null).assertFail();
402        });
403        done();
404    })
405
406    /**
407     * @tc.name KVManagerGetKVStorePromiseTest013
408     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 013
409     * @tc.type: FUNC
410     * @tc.require: issueNumber
411     */
412    it('KVManagerGetKVStorePromiseTest013', 0, async function (done) {
413        console.info('KVManagerGetKVStorePromiseTest013');
414        const optionsInfo = {
415            createIfMissing: true,
416            encrypt: false,
417            backup: false,
418            autoSync: true,
419            kvStoreType: factory.KVStoreType.DEVICE_COLLABORATION,
420            schema: '',
421            securityLevel: factory.SecurityLevel.S4,
422        }
423        try {
424            await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
425                console.info('KVManagerGetKVStorePromiseTest013 getKVStore success');
426            }).catch((err) => {
427                console.error('KVManagerGetKVStorePromiseTest013 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
428                expect(null).assertFail();
429            });
430        } catch (e) {
431            console.error('KVManagerGetKVStorePromiseTest013 getKVStore e ' + `, error code is ${e.code}, message is ${e.message}`);
432        }
433        done();
434    })
435
436    /**
437     * @tc.name KVManagerGetKVStorePromiseTest014
438     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 014
439     * @tc.type: FUNC
440     * @tc.require: issueNumber
441     */
442    it('KVManagerGetKVStorePromiseTest014', 0, async function (done) {
443        console.info('KVManagerGetKVStorePromiseTest014');
444        const optionsInfo = {
445            createIfMissing: true,
446            encrypt: false,
447            backup: false,
448            autoSync: true,
449            kvStoreType: factory.KVStoreType.MULTI_VERSION,
450            schema: '',
451            securityLevel: factory.SecurityLevel.NO_LEVEL,
452        }
453        await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
454            console.info('KVManagerGetKVStorePromiseTest014 getKVStore success');
455            expect(null).assertFail();
456        }).catch((err) => {
457            console.error('KVManagerGetKVStorePromiseTest014 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
458            expect(true).assertTrue();
459        });
460        done();
461    })
462
463    /**
464     * @tc.name KVManagerGetKVStorePromiseTest015
465     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 015
466     * @tc.type: FUNC
467     * @tc.require: issueNumber
468     */
469    it('KVManagerGetKVStorePromiseTest015', 0, async function (done) {
470        console.info('KVManagerGetKVStorePromiseTest015');
471        const optionsInfo = {
472            createIfMissing: true,
473            encrypt: false,
474            backup: false,
475            autoSync: true,
476            kvStoreType: factory.KVStoreType.MULTI_VERSION,
477            schema: '',
478            securityLevel: factory.SecurityLevel.S0,
479        }
480        await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
481            console.info('KVManagerGetKVStorePromiseTest015 getKVStore success');
482            expect(null).assertFail();
483        }).catch((err) => {
484            console.error('KVManagerGetKVStorePromiseTest015 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
485            expect(true).assertTrue();
486        });
487        done();
488    })
489
490    /**
491     * @tc.name KVManagerGetKVStorePromiseTest016
492     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 016
493     * @tc.type: FUNC
494     * @tc.require: issueNumber
495     */
496    it('KVManagerGetKVStorePromiseTest016', 0, async function (done) {
497        console.info('KVManagerGetKVStorePromiseTest016');
498        const optionsInfo = {
499            createIfMissing: true,
500            encrypt: false,
501            backup: false,
502            autoSync: true,
503            kvStoreType: factory.KVStoreType.MULTI_VERSION,
504            schema: '',
505            securityLevel: factory.SecurityLevel.S1,
506        }
507        await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
508            console.info('KVManagerGetKVStorePromiseTest016 getKVStore success');
509            expect(null).assertFail();
510        }).catch((err) => {
511            console.error('KVManagerGetKVStorePromiseTest016 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
512            expect(true).assertTrue();
513        });
514        done();
515    })
516
517    /**
518     * @tc.name KVManagerGetKVStorePromiseTest017
519     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 017
520     * @tc.type: FUNC
521     * @tc.require: issueNumber
522     */
523    it('KVManagerGetKVStorePromiseTest017', 0, async function (done) {
524        console.info('KVManagerGetKVStorePromiseTest017');
525        const optionsInfo = {
526            createIfMissing: true,
527            encrypt: false,
528            backup: false,
529            autoSync: true,
530            kvStoreType: factory.KVStoreType.MULTI_VERSION,
531            schema: '',
532            securityLevel: factory.SecurityLevel.S2,
533        }
534        await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
535            console.info('KVManagerGetKVStorePromiseTest017 getKVStore success');
536            expect(null).assertFail();
537        }).catch((err) => {
538            console.error('KVManagerGetKVStorePromiseTest017 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
539            expect(true).assertTrue();
540        });
541        done();
542    })
543
544    /**
545     * @tc.name KVManagerGetKVStorePromiseTest018
546     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 018
547     * @tc.type: FUNC
548     * @tc.require: issueNumber
549     */
550    it('KVManagerGetKVStorePromiseTest018', 0, async function (done) {
551        console.info('KVManagerGetKVStorePromiseTest018');
552        const optionsInfo = {
553            createIfMissing: true,
554            encrypt: false,
555            backup: false,
556            autoSync: true,
557            kvStoreType: factory.KVStoreType.MULTI_VERSION,
558            schema: '',
559            securityLevel: factory.SecurityLevel.S3,
560        }
561        await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
562            console.info('KVManagerGetKVStorePromiseTest018 getKVStore success');
563            expect(null).assertFail();
564        }).catch((err) => {
565            console.error('KVManagerGetKVStorePromiseTest018 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
566            expect(true).assertTrue();
567        });
568        done();
569    })
570
571    /**
572     * @tc.name KVManagerGetKVStorePromiseTest019
573     * @tc.desc Test Js Api KVManager.GetKVStore() testcase 019
574     * @tc.type: FUNC
575     * @tc.require: issueNumber
576     */
577    it('KVManagerGetKVStorePromiseTest019', 0, async function (done) {
578        console.info('KVManagerGetKVStorePromiseTest019');
579        const optionsInfo = {
580            createIfMissing: true,
581            encrypt: false,
582            backup: false,
583            autoSync: true,
584            kvStoreType: factory.KVStoreType.MULTI_VERSION,
585            schema: '',
586            securityLevel: factory.SecurityLevel.S4,
587        }
588        await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
589            console.info('KVManagerGetKVStorePromiseTest019 getKVStore success');
590            expect(null).assertFail();
591        }).catch((err) => {
592            console.error('KVManagerGetKVStorePromiseTest019 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
593            expect(true).assertTrue();
594        });
595        done();
596    })
597
598    /**
599     * @tc.name KVManagerCloseKVStorePromiseTest001
600     * @tc.desc Test Js Api KVManager.CloseKVStore() testcase 001
601     * @tc.type: FUNC
602     * @tc.require: issueNumber
603     */
604    it('KVManagerCloseKVStorePromiseTest001', 0, async function (done) {
605        console.info('KVManagerCloseKVStorePromiseTest004');
606        await kvManager.getKVStore(TEST_STORE_ID, options, async function (err, store) {
607            console.info('KVManagerCloseKVStorePromiseTest001 getKVStore success');
608            kvStore = store;
609            await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, kvStore);
610        });
611        console.info('KVManagerCloseKVStorePromiseTest001 closeKVStore redo.');
612        await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, kvStore).then(() => {
613            console.info('KVManagerCloseKVStorePromiseTest001 closeKVStore twice');
614            expect(null).assertFail();
615        }).catch((err) => {
616            console.error('KVManagerCloseKVStorePromiseTest001 closeKVStore twice err ' + `, error code is ${err.code}, message is ${err.message}`);
617        });
618        done();
619    })
620
621    /**
622     * @tc.name KVManagerDeleteKVStorePromiseTest001
623     * @tc.desc Test Js Api KVManager.DeleteKVStore() testcase 001
624     * @tc.type: FUNC
625     * @tc.require: issueNumber
626     */
627    it('KVManagerDeleteKVStorePromiseTest001', 0, async function (done) {
628        console.info('KVManagerDeleteKVStorePromiseTest001');
629        await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => {
630            console.info('KVManagerDeleteKVStorePromiseTest001 deleteKVStore success');
631        }).catch((err) => {
632            expect(null).assertFail();
633            console.error('KVManagerDeleteKVStorePromiseTest001 deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
634        });
635        done();
636    })
637
638    /**
639     * @tc.name KVManagerGetAllKVStoreIdPromiseTest001
640     * @tc.desc Test Js Api KVManager.GetAllKVStoreId() testcase 001
641     * @tc.type: FUNC
642     * @tc.require: issueNumber
643     */
644    it('KVManagerGetAllKVStoreIdPromiseTest001', 0, async function (done) {
645        console.info('KVManagerGetAllKVStoreIdPromiseTest001');
646        await kvManager.getAllKVStoreId(TEST_BUNDLE_NAME).then((data) => {
647            console.info('KVManagerGetAllKVStoreIdPromiseTest001 getAllKVStoreId success');
648            console.info('KVManagerGetAllKVStoreIdPromiseTest001 size = ' + data.length);
649            expect(0).assertEqual(data.length);
650        }).catch((err) => {
651            console.error('KVManagerGetAllKVStoreIdPromiseTest001 getAllKVStoreId err ' + `, error code is ${err.code}, message is ${err.message}`);
652            expect(null).assertFail();
653        });
654        done();
655    })
656
657    /**
658     * @tc.name KVManagerGetAllKVStoreIdPromiseTest002
659     * @tc.desc Test Js Api KVManager.GetAllKVStoreId() testcase 002
660     * @tc.type: FUNC
661     * @tc.require: issueNumber
662     */
663    it('KVManagerGetAllKVStoreIdPromiseTest002', 0, async function (done) {
664        console.info('KVManagerGetAllKVStoreIdPromiseTest002');
665        await kvManager.getKVStore(TEST_STORE_ID, options).then(async (store) => {
666            console.info('KVManagerGetAllKVStoreIdPromiseTest002 getKVStore success');
667            kvStore = store;
668            await kvManager.getAllKVStoreId(TEST_BUNDLE_NAME).then((data) => {
669                console.info('KVManagerGetAllKVStoreIdPromiseTest002 getAllKVStoreId success');
670                console.info('KVManagerGetAllKVStoreIdPromiseTest002 size = ' + data.length);
671                expect(1).assertEqual(data.length);
672                console.info('KVManagerGetAllKVStoreIdPromiseTest002 data[0] = ' + data[0]);
673                expect(TEST_STORE_ID).assertEqual(data[0]);
674            }).catch((err) => {
675                console.error('KVManagerGetAllKVStoreIdPromiseTest002 getAllKVStoreId err ' + `, error code is ${err.code}, message is ${err.message}`);
676                expect(null).assertFail();
677            });
678        }).catch((err) => {
679            console.error('KVManagerGetAllKVStoreIdPromiseTest002 getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
680            expect(null).assertFail();
681        });
682        done();
683    })
684
685    /**
686     * @tc.name KVManagerOnPromiseTest001
687     * @tc.desc Test Js Api KVManager.On() testcase 001
688     * @tc.type: FUNC
689     * @tc.require: issueNumber
690     */
691    it('KVManagerOnPromiseTest001', 0, function (done) {
692        console.info('KVManagerOnPromiseTest001');
693        var deathCallback = function () {
694            console.info('death callback call');
695        }
696        kvManager.on('distributedDataServiceDie', deathCallback);
697        kvManager.off('distributedDataServiceDie', deathCallback);
698        done();
699    })
700
701    /**
702     * @tc.name KVManagerOnPromiseTest002
703     * @tc.desc Test Js Api KVManager.On() testcase 002
704     * @tc.type: FUNC
705     * @tc.require: issueNumber
706     */
707    it('KVManagerOnPromiseTest002', 0, function (done) {
708        console.info('KVManagerOnPromiseTest002');
709        var deathCallback1 = function () {
710            console.info('death callback call');
711        }
712        var deathCallback2 = function () {
713            console.info('death callback call');
714        }
715        kvManager.on('distributedDataServiceDie', deathCallback1);
716        kvManager.on('distributedDataServiceDie', deathCallback2);
717        kvManager.off('distributedDataServiceDie', deathCallback1);
718        kvManager.off('distributedDataServiceDie', deathCallback2);
719        done();
720    })
721
722    /**
723     * @tc.name KVManagerOnPromiseTest003
724     * @tc.desc Test Js Api KVManager.On() testcase 003
725     * @tc.type: FUNC
726     * @tc.require: issueNumber
727     */
728    it('KVManagerOnPromiseTest003', 0, function (done) {
729        console.info('KVManagerOnPromiseTest003');
730        var deathCallback = function () {
731            console.info('death callback call');
732        }
733        kvManager.on('distributedDataServiceDie', deathCallback);
734        kvManager.on('distributedDataServiceDie', deathCallback);
735        kvManager.off('distributedDataServiceDie', deathCallback);
736        done();
737    })
738
739    /**
740     * @tc.name KVManagerOffPromiseTest001
741     * @tc.desc Test Js Api KVManager.Off() testcase 001
742     * @tc.type: FUNC
743     * @tc.require: issueNumber
744     */
745    it('KVManagerOffPromiseTest001', 0, function (done) {
746        console.info('KVManagerOffPromiseTest001');
747        var deathCallback = function () {
748            console.info('death callback call');
749        }
750        kvManager.off('distributedDataServiceDie', deathCallback);
751        done();
752    })
753
754    /**
755     * @tc.name KVManagerOffPromiseTest002
756     * @tc.desc Test Js Api KVManager.Off() testcase 002
757     * @tc.type: FUNC
758     * @tc.require: issueNumber
759     */
760    it('KVManagerOffPromiseTest002', 0, function (done) {
761        console.info('KVManagerOffPromiseTest002');
762        var deathCallback = function () {
763            console.info('death callback call');
764        }
765        kvManager.on('distributedDataServiceDie', deathCallback);
766        kvManager.off('distributedDataServiceDie', deathCallback);
767        done();
768    })
769
770    /**
771     * @tc.name KVManagerOffPromiseTest003
772     * @tc.desc Test Js Api KVManager.Off() testcase 003
773     * @tc.type: FUNC
774     * @tc.require: issueNumber
775     */
776    it('KVManagerOffPromiseTest003', 0, function (done) {
777        console.info('KVManagerOffPromiseTest003');
778        var deathCallback1 = function () {
779            console.info('death callback call');
780        }
781        var deathCallback2 = function () {
782            console.info('death callback call');
783        }
784        kvManager.on('distributedDataServiceDie', deathCallback1);
785        kvManager.on('distributedDataServiceDie', deathCallback2);
786        kvManager.off('distributedDataServiceDie', deathCallback1);
787        done();
788    })
789
790    /**
791     * @tc.name KVManagerOffPromiseTest004
792     * @tc.desc Test Js Api KVManager.Off() testcase 004
793     * @tc.type: FUNC
794     * @tc.require: issueNumber
795     */
796    it('KVManagerOffPromiseTest004', 0, function (done) {
797        console.info('KVManagerOffPromiseTest004');
798        var deathCallback = function () {
799            console.info('death callback call');
800        }
801        kvManager.on('distributedDataServiceDie', deathCallback);
802        kvManager.off('distributedDataServiceDie', deathCallback);
803        kvManager.off('distributedDataServiceDie', deathCallback);
804        done();
805    })
806
807    /**
808     * @tc.name KVManagerOffPromiseTest005
809     * @tc.desc Test Js Api KVManager.Off() testcase 005
810     * @tc.type: FUNC
811     * @tc.require: issueNumber
812     */
813    it('KVManagerOffPromiseTest005', 0, function (done) {
814        console.info('KVManagerOffPromiseTest001');
815        var deathCallback = function () {
816            console.info('death callback call');
817        }
818        kvManager.on('distributedDataServiceDie', deathCallback);
819        kvManager.off('distributedDataServiceDie');
820        done();
821    })
822
823    /**
824     * @tc.name: CreateKVManagerPromiseTest001
825     * @tc.desc: Test Js Api createKVManager testcase 001
826     * @tc.type: FUNC
827     * @tc.require: issueNumber
828     */
829     it('CreateKVManagerPromiseTest001', 0, async function (done) {
830        console.info('CreateKVManagerPromiseTest001');
831        const config = {
832            bundleName: TEST_BUNDLE_NAME,
833            userInfo: {
834                userId: '0',
835                userType: factory.UserType.SAME_USER_ID
836            },
837            context:context
838        }
839        try {
840            await factory.createKVManager(config).then(async (manager) => {
841                kvManager = manager;
842                expect(manager !=null).assertTrue();
843                console.info('CreateKVManagerPromiseTest001 createKVManager success');
844                await kvManager.getKVStore(TEST_STORE_ID, options).then(async (store) => {
845                    console.info("testcreateKVManager001 getKVStore success");
846                    kvStore = store;
847                    await store.put(STORE_KEY, STORE_VALUE).then(async (data) => {
848                        console.info('CreateKVManagerPromiseTest001 put data success');
849                        await store.get(STORE_KEY).then((data) => {
850                            console.info("testcreateKVManager001  get data success");
851                            expect(data).assertEqual(STORE_VALUE);
852                        }).catch((err) => {
853                            console.error('CreateKVManagerPromiseTest001 get data err' + `, error code is ${err.code}, message is ${err.message}`);
854                        });
855                    }).catch((err) => {
856                        console.error('CreateKVManagerPromiseTest001 put data err' + `, error code is ${err.code}, message is ${err.message}`);
857                    });
858                }).catch((err) => {
859                    console.info("testcreateKVManager001 getKVStore err: "  + JSON.stringify(err));
860                    expect(null).assertFail();
861                });
862            }).catch((err) => {
863                console.error('CreateKVManagerPromiseTest001 createKVManager err ' + `, error code is ${err.code}, message is ${err.message}`);
864                expect(null).assertFail()
865            });
866        }catch (e) {
867            console.error('CreateKVManagerPromiseTest001 promise delete fail err' + `, error code is ${err.code}, message is ${err.message}`);
868            expect(null).assertFail();
869        }
870        done();
871    })
872
873    /**
874     * @tc.name: CreateKVManagerPromiseTest002
875     * @tc.desc: Test Js Api createKVManager testcase 002
876     * @tc.type: FUNC
877     * @tc.require: issueNumber
878     */
879     it('CreateKVManagerPromiseTest002', 0, async function (done) {
880        console.info('CreateKVManagerPromiseTest002');
881        const config = {
882            bundleName: TEST_BUNDLE_NAME,
883            userInfo: {
884                userId: '0',
885                userType: factory.UserType.SAME_USER_ID
886            },
887            context:contextApplication
888        }
889        try {
890            await factory.createKVManager(config).then(async (manager) => {
891                kvManager = manager;
892                console.info('CreateKVManagerPromiseTest002 createKVManager success');
893                await kvManager.getKVStore(TEST_STORE_ID, options).then(async (store) => {
894                    console.info("testcreateKVManager002 getKVStore success");
895                    kvStore = store;
896                    await store.put(STORE_KEY, STORE_VALUE).then(async (data) => {
897                        console.info('CreateKVManagerPromiseTest002 put data success');
898                        await store.get(STORE_KEY).then((data) => {
899                            console.info("testcreateKVManager002  get data success");
900                            expect(data).assertEqual(STORE_VALUE);
901                        }).catch((err) => {
902                            console.error('CreateKVManagerPromiseTest002 get data err' + `, error code is ${err.code}, message is ${err.message}`);
903                        });
904                    }).catch((err) => {
905                        console.error('CreateKVManagerPromiseTest002 put data err' + `, error code is ${err.code}, message is ${err.message}`);
906                    });
907                }).catch((err) => {
908                    console.info("testcreateKVManager002 getKVStore err: "  + JSON.stringify(err));
909                    expect(null).assertFail();
910                });
911            }).catch((err) => {
912                console.error('CreateKVManagerPromiseTest002 createKVManager err ' + `, error code is ${err.code}, message is ${err.message}`);
913                expect(null).assertFail()
914            });
915        }catch (e) {
916            console.error('CreateKVManagerPromiseTest002 promise delete fail err' + `, error code is ${err.code}, message is ${err.message}`);
917            expect(null).assertFail();
918        }
919        done();
920    })
921
922})
923