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.distributedKVStore'
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        context: context
33    }
34
35    const options = {
36        createIfMissing: true,
37        encrypt: false,
38        backup: false,
39        autoSync: true,
40        kvStoreType: factory.KVStoreType.SINGLE_VERSION,
41        schema: '',
42        securityLevel: factory.SecurityLevel.S2,
43    }
44
45    beforeAll(async function (done) {
46        console.info('beforeAll');
47        kvManager = factory.createKVManager(config);
48        console.info('beforeAll end');
49        done();
50    })
51
52    afterAll(async function (done) {
53        console.info('afterAll');
54        done();
55    })
56
57    beforeEach(async function (done) {
58        console.info('beforeEach');
59        done();
60    })
61
62    afterEach(async function (done) {
63        console.info('afterEach');
64        await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => {
65            console.info('afterEach closeKVStore success');
66            await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => {
67                console.info('afterEach deleteKVStore success');
68            }).catch((err) => {
69                console.error('afterEach deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
70            });
71        }).catch((err) => {
72            console.error('afterEach closeKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
73        });
74        kvStore = null;
75        done();
76    })
77
78    /**
79     * @tc.name KVManagerGetKVStorePromiseSucTest
80     * @tc.desc Test Js Api KVManager.GetKVStore() successfully
81     * @tc.type: FUNC
82     * @tc.require: issueNumber
83     */
84    it('KVManagerGetKVStorePromiseSucTest', 0, async function (done) {
85        console.info('KVManagerGetKVStorePromiseSucTest');
86        try {
87            await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => {
88                console.info('KVManagerGetKVStorePromiseSucTest getKVStore success');
89                expect(store != undefined && store != null).assertTrue();
90            }).catch((err) => {
91                console.error('KVManagerGetKVStorePromiseSucTest getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
92                expect(null).assertFail();
93            });
94        } catch (e) {
95            console.error('KVManagerGetKVStorePromiseSucTest getKVStore e ' + `, error code is ${e.code}, message is ${e.message}`);
96            expect(null).assertFail();
97        }
98        done();
99    })
100
101    /**
102     * @tc.name KVManagerGetKVStorePromiseParaError1Test
103     * @tc.desc Test Js Api KVManager.GetKVStore() with parameter error
104     * @tc.type: FUNC
105     * @tc.require: issueNumber
106     */
107    it('KVManagerGetKVStorePromiseParaError1Test', 0, async function (done) {
108        console.info('KVManagerGetKVStorePromiseParaError1Test');
109        try {
110            await kvManager.getKVStore(TEST_STORE_ID).then((store) => {
111                console.info('KVManagerGetKVStorePromiseParaError1Test getKVStore success');
112                expect(null).assertFail();
113            }).catch((err) => {
114                console.error('KVManagerGetKVStorePromiseParaError1Test getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
115                expect(null).assertFail();
116            });
117        } catch (e) {
118            console.error('KVManagerGetKVStorePromiseParaError1Test getKVStore e ' + `, error code is ${e.code}, message is ${e.message}`);
119            expect(e.code == 401).assertTrue();
120        }
121        done();
122    })
123
124    /**
125     * @tc.name KVManagerGetKVStorePromiseParaError2Test
126     * @tc.desc Test Js Api KVManager.GetKVStore()with parameter error
127     * @tc.type: FUNC
128     * @tc.require: issueNumber
129     */
130    it('KVManagerGetKVStorePromiseParaError2Test', 0, async function (done) {
131        console.info('KVManagerGetKVStorePromiseParaError2Test');
132        try {
133            await kvManager.getKVStore(options).then((store) => {
134                console.info('KVManagerGetKVStorePromiseParaError2Test getKVStore success');
135                expect(null).assertFail();
136            }).catch((err) => {
137                console.error('KVManagerGetKVStorePromiseParaError2Test getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
138                expect(null).assertFail();
139            });
140        } catch (e) {
141            console.error('KVManagerGetKVStorePromiseParaError2Test getKVStore e ' + `, error code is ${e.code}, message is ${e.message}`);
142            expect(e.code == 401).assertTrue();
143        }
144        done();
145    })
146
147    /**
148     * @tc.name KVManagerGetKVStorePromiseAlreadyOpenTest
149     * @tc.desc Test Js Api KVManager.GetKVStore() get an already open kvstore
150     * @tc.type: FUNC
151     * @tc.require: issueNumber
152     */
153    it('KVManagerGetKVStorePromiseAlreadyOpenTest', 0, async function (done) {
154        console.info('KVManagerGetKVStoreCallbackSucTest');
155        try {
156           await kvManager.getKVStore(TEST_STORE_ID, options).then(async (store) => {
157                expect(store != undefined).assertTrue();
158                kvStore = store;
159                const optionsInfo = {
160                    createIfMissing: true,
161                    encrypt: false,
162                    backup: false,
163                    autoSync: true,
164                    kvStoreType: factory.KVStoreType.DEVICE_COLLABORATION,
165                    schema: '',
166                    securityLevel: factory.SecurityLevel.S1,
167                }
168                await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then(() => {
169                    expect(null).assertFail();
170                }).catch((error) => {
171                    console.info("throw exception success");
172                    expect(error.code == 15100002).assertTrue();
173                });
174            }).catch((err) => {
175                expect(null).assertFail();
176            });
177        } catch (e) {
178            expect(null).assertFail();
179        }
180        await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => {
181            await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => {
182                expect(true).assertTrue();
183            }).catch((err) => {
184                console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
185                expect(null).assertFail();
186            });
187        })
188        done();
189    })
190
191    /**
192     * @tc.name KVManagerGetKVStorePromiseSingleS1Test
193     * @tc.desc Test Js Api KVManager.GetKVStore() single s1
194     * @tc.type: FUNC
195     * @tc.require: issueNumber
196     */
197    it('KVManagerGetKVStorePromiseSingleS1Test', 0, async function (done) {
198        console.info('KVManagerGetKVStorePromiseSingleS1Test');
199        const optionsInfo = {
200            createIfMissing: true,
201            encrypt: false,
202            backup: false,
203            autoSync: true,
204            kvStoreType: factory.KVStoreType.SINGLE_VERSION,
205            schema: '',
206            securityLevel: factory.SecurityLevel.S1,
207        };
208        try {
209            await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
210                console.info('KVManagerGetKVStorePromiseSingleS1Test getKVStore success');
211                expect(store != null && store != undefined).assertTrue();
212            }).catch((err) => {
213                console.error('KVManagerGetKVStorePromiseSingleS1Test getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
214                expect(null).assertFail();
215            });
216        } catch (e) {
217            expect(null).assertFail();
218        }
219        done();
220    })
221
222    /**
223     * @tc.name KVManagerGetKVStorePromiseSingleS2Test
224     * @tc.desc Test Js Api KVManager.GetKVStore() single s2
225     * @tc.type: FUNC
226     * @tc.require: issueNumber
227     */
228    it('KVManagerGetKVStorePromiseSingleS2Test', 0, async function (done) {
229        console.info('KVManagerGetKVStorePromiseSingleS2Test');
230        const optionsInfo = {
231            createIfMissing: true,
232            encrypt: true,
233            backup: false,
234            autoSync: true,
235            kvStoreType: factory.KVStoreType.SINGLE_VERSION,
236            schema: '',
237            securityLevel: factory.SecurityLevel.S2,
238        }
239        try {
240            await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
241                console.info('KVManagerGetKVStorePromiseSingleS2Test getKVStore success');
242                expect(store != null && store != undefined).assertTrue();
243            }).catch((err) => {
244                console.error('KVManagerGetKVStorePromiseSingleS2Test getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
245                expect(null).assertFail();
246            });
247        } catch (e) {
248            expect(null).assertFail();
249        }
250        done();
251    })
252
253    /**
254     * @tc.name KVManagerGetKVStorePromiseSingleS3Test
255     * @tc.desc Test Js Api KVManager.GetKVStore() single s3
256     * @tc.type: FUNC
257     * @tc.require: issueNumber
258     */
259    it('KVManagerGetKVStorePromiseSingleS3Test', 0, async function (done) {
260        console.info('KVManagerGetKVStorePromiseSingleS3Test');
261        const optionsInfo = {
262            createIfMissing: true,
263            encrypt: false,
264            backup: false,
265            autoSync: true,
266            kvStoreType: factory.KVStoreType.SINGLE_VERSION,
267            schema: '',
268            securityLevel: factory.SecurityLevel.S3,
269        }
270        try {
271            await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
272                console.info('KVManagerGetKVStorePromiseSingleS3Test getKVStore success');
273                expect(store != null && store != undefined).assertTrue();
274            }).catch((err) => {
275                console.error('KVManagerGetKVStorePromiseSingleS3Test getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
276                expect(null).assertFail();
277            });
278        } catch (e) {
279            expect(null).assertFail();
280        }
281        done();
282    })
283
284    /**
285     * @tc.name KVManagerGetKVStorePromiseSingleS4Test
286     * @tc.desc Test Js Api KVManager.GetKVStore() single s4
287     * @tc.type: FUNC
288     * @tc.require: issueNumber
289     */
290    it('KVManagerGetKVStorePromiseSingleS4Test', 0, async function (done) {
291        console.info('KVManagerGetKVStorePromiseSingleS4Test');
292        const optionsInfo = {
293            createIfMissing: true,
294            encrypt: false,
295            backup: true,
296            autoSync: true,
297            kvStoreType: factory.KVStoreType.SINGLE_VERSION,
298            schema: '',
299            securityLevel: factory.SecurityLevel.S4,
300        }
301        try {
302            await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
303                console.info('KVManagerGetKVStorePromiseSingleS4Test getKVStore success');
304                expect(store != null && store != undefined).assertTrue();
305            }).catch((err) => {
306                console.error('KVManagerGetKVStorePromiseSingleS4Test getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
307                expect(null).assertFail();
308            });
309        } catch (e) {
310            expect(null).assertFail();
311        }
312        done();
313    })
314
315    /**
316     * @tc.name KVManagerGetKVStorePromiseDeviceS1Test
317     * @tc.desc Test Js Api KVManager.GetKVStore() device s1
318     * @tc.type: FUNC
319     * @tc.require: issueNumber
320     */
321    it('KVManagerGetKVStorePromiseDeviceS1Test', 0, async function (done) {
322        console.info('KVManagerGetKVStorePromiseDeviceS1Test');
323        const optionsInfo = {
324            createIfMissing: true,
325            encrypt: false,
326            backup: false,
327            autoSync: false,
328            kvStoreType: factory.KVStoreType.DEVICE_COLLABORATION,
329            schema: '',
330            securityLevel: factory.SecurityLevel.S1,
331        }
332        try {
333            await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
334                console.info('KVManagerGetKVStorePromiseDeviceS1Test getKVStore success');
335                expect(store != null && store != undefined).assertTrue();
336            }).catch((err) => {
337                console.error('KVManagerGetKVStorePromiseDeviceS1Test getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
338                expect(null).assertFail();
339            });
340        } catch (e) {
341            expect(null).assertFail();
342        }
343        done();
344    })
345
346    /**
347     * @tc.name KVManagerGetKVStorePromiseDeviceS2Test
348     * @tc.desc Test Js Api KVManager.GetKVStore() device s2
349     * @tc.type: FUNC
350     * @tc.require: issueNumber
351     */
352    it('KVManagerGetKVStorePromiseDeviceS2Test', 0, async function (done) {
353        console.info('KVManagerGetKVStorePromiseDeviceS2Test');
354        const optionsInfo = {
355            createIfMissing: true,
356            encrypt: false,
357            backup: false,
358            autoSync: true,
359            kvStoreType: factory.KVStoreType.DEVICE_COLLABORATION,
360            schema: '',
361            securityLevel: factory.SecurityLevel.S2,
362        }
363        try {
364            await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
365                console.info('KVManagerGetKVStorePromiseDeviceS2Test getKVStore success');
366                expect(store != null && store != undefined).assertTrue();
367            }).catch((err) => {
368                console.error('KVManagerGetKVStorePromiseDeviceS2Test getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
369                expect(null).assertFail();
370            });
371        } catch (e) {
372            expect(null).assertFail();
373        }
374        done();
375    })
376
377    /**
378     * @tc.name KVManagerGetKVStorePromiseDeviceS3Test
379     * @tc.desc Test Js Api KVManager.GetKVStore() device s3
380     * @tc.type: FUNC
381     * @tc.require: issueNumber
382     */
383    it('KVManagerGetKVStorePromiseDeviceS3Test', 0, async function (done) {
384        console.info('KVManagerGetKVStorePromiseDeviceS3Test');
385        const optionsInfo = {
386            createIfMissing: true,
387            encrypt: false,
388            backup: false,
389            autoSync: true,
390            kvStoreType: factory.KVStoreType.DEVICE_COLLABORATION,
391            schema: '',
392            securityLevel: factory.SecurityLevel.S3,
393        }
394        try {
395            await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
396                console.info('KVManagerGetKVStorePromiseDeviceS3Test getKVStore success');
397                expect(store != null && store != undefined).assertTrue();
398            }).catch((err) => {
399                console.error('KVManagerGetKVStorePromiseDeviceS3Test getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
400                expect(null).assertFail();
401            });
402        } catch (e) {
403            expect(null).assertFail();
404        }
405        done();
406    })
407
408    /**
409     * @tc.name KVManagerGetKVStorePromiseDeviceS4Test
410     * @tc.desc Test Js Api KVManager.GetKVStore() device s4
411     * @tc.type: FUNC
412     * @tc.require: issueNumber
413     */
414    it('KVManagerGetKVStorePromiseDeviceS4Test', 0, async function (done) {
415        console.info('KVManagerGetKVStorePromiseDeviceS4Test');
416        const optionsInfo = {
417            createIfMissing: true,
418            encrypt: false,
419            backup: false,
420            autoSync: true,
421            kvStoreType: factory.KVStoreType.DEVICE_COLLABORATION,
422            schema: '',
423            securityLevel: factory.SecurityLevel.S4,
424        }
425        try {
426            await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => {
427                console.info('KVManagerGetKVStorePromiseDeviceS4Test getKVStore success');
428                expect(store != null && store != undefined).assertTrue();
429            }).catch((err) => {
430                console.error('KVManagerGetKVStorePromiseDeviceS4Test getKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
431                expect(null).assertFail();
432            });
433        } catch (e) {
434            expect(null).assertFail();
435        }
436        done();
437    })
438
439    /**
440     * @tc.name KVManagerCloseKVStorePromiseSucTest
441     * @tc.desc Test Js Api KVManager.CloseKVStore() successfully
442     * @tc.type: FUNC
443     * @tc.require: issueNumber
444     */
445    it('KVManagerCloseKVStorePromiseSucTest', 0, async function (done) {
446        console.info('KVManagerCloseKVStorePromiseSucTest');
447        await kvManager.getKVStore(TEST_STORE_ID, options).then(async () => {
448            console.info('KVManagerCloseKVStorePromiseSucTest getKVStore success');
449            await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => {
450                console.info('KVManagerCloseKVStorePromiseSucTest closeKVStore success');
451                expect(true).assertTrue();
452            }).catch((err) => {
453                console.error('KVManagerCloseKVStorePromiseSucTest closeKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
454            });
455        });
456        done();
457    })
458
459    /**
460     * @tc.name KVManagerCloseKVStorePromiseInvalidArgsTest
461     * @tc.desc Test Js Api KVManager.CloseKVStore() with invalid args
462     * @tc.type: FUNC
463     * @tc.require: issueNumber
464     */
465    it('KVManagerCloseKVStorePromiseInvalidArgsTest', 0, async function (done) {
466        console.info('KVManagerCloseKVStorePromiseInvalidArgsTest');
467        try {
468            await kvManager.getKVStore(TEST_STORE_ID, options).then(async () => {
469                console.info('KVManagerCloseKVStorePromiseInvalidArgsTest getKVStore success');
470                await kvManager.closeKVStore(TEST_BUNDLE_NAME).then(() => {
471                    console.info('KVManagerCloseKVStorePromiseInvalidArgsTest closeKVStore success');
472                    expect(null).assertFail();
473                }).catch((err) => {
474                    console.error('KVManagerCloseKVStorePromiseInvalidArgsTest closeKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
475                    expect(null).assertFail();
476                });
477            });
478        } catch (e) {
479            console.error('KVManagerCloseKVStorePromiseInvalidArgsTest closeKVStore e ' + `, error code is ${e.code}, message is ${e.message}`);
480            expect(e.code == 401).assertTrue();
481        }
482        done();
483    })
484
485    /**
486     * @tc.name KVManagerDeleteKVStorePromiseSucTest
487     * @tc.desc Test Js Api KVManager.DeleteKVStore() successfully
488     * @tc.type: FUNC
489     * @tc.require: issueNumber
490     */
491    it('KVManagerDeleteKVStorePromiseSucTest', 0, async function (done) {
492        console.info('KVManagerDeleteKVStorePromiseSucTest');
493        await kvManager.getKVStore(TEST_STORE_ID, options, async function (err, store) {
494            console.info('KVManagerDeleteKVStorePromiseSucTest getKVStore success');
495            kvStore = store;
496            await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID);
497        });
498        await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => {
499            console.info('KVManagerDeleteKVStorePromiseSucTest deleteKVStore success');
500        }).catch((err) => {
501            expect(null).assertFail();
502            console.error('KVManagerDeleteKVStorePromiseSucTest deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
503        });
504        done();
505    })
506
507    /**
508     * @tc.name KVManagerDeleteKVStorePromiseInvalidArgsTest
509     * @tc.desc Test Js Api KVManager.DeleteKVStore() with invalid args
510     * @tc.type: FUNC
511     * @tc.require: issueNumber
512     */
513    it('KVManagerDeleteKVStorePromiseInvalidArgsTest', 0, async function (done) {
514        try {
515            await kvManager.getKVStore(TEST_STORE_ID, options, async function (err, store) {
516                console.info('KVManagerDeleteKVStorePromiseInvalidArgsTest getKVStore success');
517                kvStore = store;
518                await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID);
519            });
520            await kvManager.deleteKVStore(TEST_BUNDLE_NAME).then(() => {
521                console.info('KVManagerDeleteKVStorePromiseInvalidArgsTest deleteKVStore success');
522                expect(null).assertFail();
523            }).catch((err) => {
524                expect(null).assertFail();
525                console.error('KVManagerDeleteKVStorePromiseInvalidArgsTest deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`);
526            });
527        } catch (e) {
528            console.error('KVManagerDeleteKVStorePromiseInvalidArgsTest deleteKVStore e ' + `, error code is ${e.code}, message is ${e.message}`);
529            expect(e.code == 401).assertTrue();
530        }
531        done();
532    })
533
534    /**
535     * @tc.name KVManagerDeleteKVStorePromiseNoGetTest
536     * @tc.desc Test Js Api KVManager.DeleteKVStore() without get
537     * @tc.type: FUNC
538     * @tc.require: issueNumber
539     */
540    it('KVManagerDeleteKVStorePromiseNoGetTest', 0, async function (done) {
541        try {
542            await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => {
543                console.info('KVManagerDeleteKVStorePromiseNoGetTest deleteKVStore success');
544                expect(null).assertFail();
545            }).catch((err) => {
546                console.info('KVManagerDeleteKVStoreCallbackNotGetTest deleteKVStore fail');
547                expect(err.code == 15100004).assertTrue();
548            });
549        } catch (e) {
550            expect(null).assertFail();
551        }
552        done();
553    })
554
555    /**
556     * @tc.name KVManagerGetAllKVStoreIdPromiseSucTest
557     * @tc.desc Test Js Api KVManager.GetAllKVStoreId() success
558     * @tc.type: FUNC
559     * @tc.require: issueNumber
560     */
561    it('KVManagerGetAllKVStoreIdPromiseSucTest', 0, async function (done) {
562        console.info('KVManagerGetAllKVStoreIdPromiseSucTest');
563        try {
564            await kvManager.getAllKVStoreId(TEST_BUNDLE_NAME).then((data) => {
565                expect(0 == data.length).assertTrue();
566            }).catch((err) => {
567                console.error('KVManagerGetAllKVStoreIdPromiseSucTest getAllKVStoreId err ' + `, error code is ${err.code}, message is ${err.message}`);
568                expect(null).assertFail();
569            });
570        } catch (e) {
571            expect(null).assertFail();
572        }
573        done();
574    })
575
576    /**
577     * @tc.name KVManagerGetAllKVStoreIdPromiseInvalidArgsTest
578     * @tc.desc Test Js Api KVManager.GetAllKVStoreId() with invalid args
579     * @tc.type: FUNC
580     * @tc.require: issueNumber
581     */
582    it('KVManagerGetAllKVStoreIdPromiseInvalidArgsTest', 0, async function (done) {
583        console.info('KVManagerGetAllKVStoreIdPromiseInvalidArgsTest');
584        try {
585            await kvManager.getAllKVStoreId().then((data) => {
586                expect(null).assertFail();
587            }).catch((err) => {
588                console.error('KVManagerGetAllKVStoreIdPromiseInvalidArgsTest getAllKVStoreId err ' + `, error code is ${err.code}, message is ${err.message}`);
589                expect(null).assertFail();
590            });
591        } catch (e) {
592            expect(e.code == 401).assertTrue();
593        }
594        done();
595    })
596
597    /**
598     * @tc.name KVManagerOnPromiseSucTest
599     * @tc.desc Test Js Api KVManager.On() success
600     * @tc.type: FUNC
601     * @tc.require: issueNumber
602     */
603    it('KVManagerOnPromiseSucTest', 0, function (done) {
604        console.info('KVManagerOnPromiseSucTest');
605        var deathCallback = function () {
606            console.info('death callback call');
607        }
608        try {
609            kvManager.on('distributedDataServiceDie', deathCallback);
610            kvManager.off('distributedDataServiceDie', deathCallback);
611            expect(true).assertTrue();
612        } catch (e) {
613            console.error(`KVManagerOnPromiseSucTest failed, error code is ${e.code}, message is ${e.message}`);
614            expect(null).assertFail();
615        }
616        done();
617    })
618
619    /**
620     * @tc.name KVManagerOnPromiseInvalidArgsTest
621     * @tc.desc Test Js Api KVManager.On() with invalid args
622     * @tc.type: FUNC
623     * @tc.require: issueNumber
624     */
625    it('KVManagerOnPromiseInvalidArgsTest', 0, function (done) {
626        console.info('KVManagerOnPromiseInvalidArgsTest');
627        try {
628            kvManager.on('distributedDataServiceDie');
629            expect(null).assertFail();
630        } catch (e) {
631            console.error(`KVManagerOnPromiseInvalidArgsTest failed, error code is ${e.code}, message is ${e.message}`);
632            expect(e.code == 401).assertTrue();
633        }
634        done();
635    })
636
637    /**
638     * @tc.name KVManagerOffPromiseWithoutOnTest
639     * @tc.desc Test Js Api KVManager.Off() without on
640     * @tc.type: FUNC
641     * @tc.require: issueNumber
642     */
643    it('KVManagerOffPromiseWithoutOnTest', 0, function (done) {
644        console.info('KVManagerOffPromiseWithoutOnTest');
645        var deathCallback = function () {
646            console.info('death callback call');
647        }
648        try {
649            kvManager.off('distributedDataServiceDie', deathCallback);
650            expect(true).assertTrue();
651        } catch (e) {
652            console.error(`KVManagerOffPromiseWithoutOnTest failed, error code is ${e.code}, message is ${e.message}`);
653            expect(null).assertFail();
654        }
655        done();
656    })
657
658    /**
659     * @tc.name KVManagerOffPromiseInvalidArgsTest
660     * @tc.desc Test Js Api KVManager.Off() with invalid args
661     * @tc.type: FUNC
662     * @tc.require: issueNumber
663     */
664    it('KVManagerOffPromiseInvalidArgsTest', 0, function (done) {
665        console.info('KVManagerOffPromiseInvalidArgsTest');
666        try {
667            kvManager.off();
668            expect(false).assertFail();
669        } catch (e) {
670            console.error(`KVManagerOffPromiseInvalidArgsTest failed, error code is ${e.code}, message is ${e.message}`);
671            expect(e.code == 401).assertTrue();
672        }
673        done();
674    })
675
676    /**
677     * @tc.name: CreateKVManagerPromiseFullFuncTest
678     * @tc.desc: Test Js Api createKVManager full functions test
679     * @tc.type: FUNC
680     * @tc.require: issueNumber
681     */
682    it('CreateKVManagerPromiseFullFuncTest', 0, async function (done) {
683        console.info('CreateKVManagerPromiseFullFuncTest');
684        const config = {
685            bundleName: TEST_BUNDLE_NAME,
686            context: context
687        }
688        try {
689            kvManager = factory.createKVManager(config);
690            expect(kvManager != null).assertTrue();
691                console.info('CreateKVManagerPromiseFullFuncTest createKVManager success');
692                await kvManager.getKVStore(TEST_STORE_ID, options).then(async (store) => {
693                    console.info("CreateKVManagerPromiseFullFuncTest getKVStore success");
694                    await store.put(STORE_KEY, STORE_VALUE).then(async (data) => {
695                        console.info('CreateKVManagerPromiseFullFuncTest put data success');
696                        await store.get(STORE_KEY).then((data) => {
697                            console.info("CreateKVManagerPromiseFullFuncTest  get data success");
698                            expect(data).assertEqual(STORE_VALUE);
699                        }).catch((err) => {
700                            console.error('CreateKVManagerPromiseFullFuncTest get data err' + `, error code is ${err.code}, message is ${err.message}`);
701                        });
702                    }).catch((err) => {
703                        console.error('CreateKVManagerPromiseFullFuncTest put data err' + `, error code is ${err.code}, message is ${err.message}`);
704                    });
705                }).catch((err) => {
706                    console.info("CreateKVManagerPromiseFullFuncTest getKVStore err: " + JSON.stringify(err));
707                    expect(null).assertFail();
708                });
709        } catch (e) {
710            console.error('CreateKVManagerPromiseFullFuncTest promise delete fail err' + `, error code is ${err.code}, message is ${err.message}`);
711            expect(null).assertFail();
712        }
713        done();
714    })
715
716    /**
717     * @tc.name: CreateKVManagerPromiseInvalidArgsTest
718     * @tc.desc: Test Js Api createKVManager with invalid args
719     * @tc.type: FUNC
720     * @tc.require: issueNumber
721     */
722    it('CreateKVManagerPromiseInvalidArgsTest', 0, async function (done) {
723        try {
724            kvManager = factory.createKVManager();
725            expect(null).assertFail();
726        } catch (e) {
727            expect(e.code == 401).assertTrue();
728        }
729        done();
730    })
731
732    /**
733     * @tc.name: CreateKVManagerPromiseInvalidConfigTest
734     * @tc.desc: Test Js Api createKVManager with invalid config
735     * @tc.type: FUNC
736     * @tc.require: issueNumber
737     */
738    it('CreateKVManagerPromiseInvalidConfigTest', 0, async function (done) {
739        try {
740            const config1  = {
741                bundleName : TEST_BUNDLE_NAME
742            }
743            kvManager = factory.createKVManager(config1);
744            expect(null).assertFail();
745        } catch (e) {
746            console.log(e.code);
747            console.log(e.message);
748            expect(e.code == 401).assertTrue();
749        }
750        done();
751    })
752})
753