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 storage from '@system.storage';
17
18const TAG = '[SYSTEM_STORAGE_JSKITS_TEST]'
19describe('SystemStorageJsunit', function () {
20    beforeAll(function () {
21        console.info(TAG + 'beforeAll')
22    })
23
24    afterEach(async function (done) {
25        console.info(TAG + 'afterEach')
26        await storage.clear({
27            success: function () {
28                expect(true).assertTrue();
29                done();
30            },
31            fail: function (data, errCode) {
32                expect(false).assertTrue();
33                done();
34            }
35        });
36    })
37
38    /**
39     * @tc.name testSet001
40     * @tc.number SUB_DDM_AppDataFWK_SystemStorage_Set_0001
41     * @tc.desc set and can get correct value in success callback, finally get complete callback
42     */
43    it('testSet001', 0, async function () {
44        console.log(TAG + '************* testSet001 start *************');
45        let completeRet = false;
46        let successRet = false;
47        await storage.set({
48            key: 'storageKey',
49            value: 'testVal',
50            success: async function () {
51                successRet = true;
52                await expect(successRet).assertTrue();
53            },
54            complete: async function () {
55                completeRet = true;
56                await expect(completeRet).assertTrue();
57            }
58        });
59        await storage.get({
60            key: 'storageKey',
61            success: async function (data) {
62                await expect(data).assertEqual('testVal');
63            }
64        })
65        await expect(successRet).assertTrue();
66        await expect(completeRet).assertTrue();
67        console.log(TAG + '************* testSet001 end *************');
68    })
69
70    /**
71     * @tc.name testSet002
72     * @tc.number SUB_DDM_AppDataFWK_SystemStorage_Set_0002
73     * @tc.desc set null key can receive fail callback
74     */
75    it('testSet002', 0, async function () {
76        console.log(TAG + '************* testSet002 start *************');
77        let testData = undefined;
78        let testErrCode = undefined;
79        let compelteRet = false;
80        await storage.set({
81            key: '',
82            value: 'testValue',
83            success: async function () {
84                await expect(false).assertTrue();
85            },
86            fail: async function (data, errCode) {
87                testData = data;
88                testErrCode = errCode;
89            },
90            complete: async function () {
91                compelteRet = true;
92                await expect(compelteRet).assertTrue();
93            }
94        })
95        await expect("The key string is null or empty.").assertEqual(testData);
96        await expect(-1006).assertEqual(testErrCode);
97        await expect(compelteRet).assertTrue();
98        console.log(TAG + '************* testSet002 end *************');
99    })
100
101    /**
102     * @tc.name testSet003
103     * @tc.number SUB_DDM_AppDataFWK_SystemStorage_Set_0003
104     * @tc.desc set key which size over 32 bytes and can receive fail callback
105     */
106    it('testSet003', 0, async function () {
107        console.log(TAG + '************* testSet003 start *************');
108        let testData = undefined;
109        let testErrCode = undefined;
110        let compelteRet = false;
111        await storage.set({
112            key: 'x'.repeat(33),
113            value: 'testValue',
114            success: async function () {
115                await expect(false).assertTrue();
116            },
117            fail: async function (data, errCode) {
118                testData = data;
119                testErrCode = errCode;
120            },
121            complete: async function () {
122                compelteRet = true;
123                await expect(compelteRet).assertTrue();
124            }
125        })
126        await expect("The key string length should shorter than 32.").assertEqual(testData);
127        await expect(-1016).assertEqual(testErrCode);
128        await expect(compelteRet).assertTrue();
129        console.log(TAG + '************* testSet003 end *************');
130    })
131
132
133    /**
134     * @tc.name testSet004
135     * @tc.number SUB_DDM_AppDataFWK_SystemStorage_Set_0004
136     * @tc.desc set value which size over 128 bytes and can receive fail callback
137     */
138    it('testSet004', 0, async function () {
139        console.log(TAG + '************* testSet004 start *************');
140        let testData = undefined;
141        let testErrCode = undefined;
142        let compelteRet = false;
143        await storage.set({
144            key: 'testKey',
145            value: 'x'.repeat(129),
146            success: async function () {
147                await expect(false).assertTrue();
148            },
149            fail: async function (data, errCode) {
150                testData = data;
151                testErrCode = errCode;
152            },
153            complete: async function () {
154                compelteRet = true;
155            }
156        })
157        await expect("The value string length should shorter than 128.").assertEqual(testData);
158        await expect(-1017).assertEqual(testErrCode);
159        await expect(compelteRet).assertTrue();
160        console.log(TAG + '************* testSet004 end *************');
161    })
162
163    /**
164     * @tc.name testGet001
165     * @tc.number SUB_DDM_AppDataFWK_SystemStorage_Get_0001
166     * @tc.desc set and can get correct value in success callback, finally receive a get complete callback
167     */
168    it('testGet001', 0, async function () {
169        console.log(TAG + '************* testGet001 start *************');
170        let completeRet = false;
171        await storage.set({
172            key: 'storageKey',
173            value: 'storageVal',
174            success: async function () {
175                await expect(true).assertTrue();
176            },
177            fail: async function (data, err) {
178                await expect(false).assertTrue();
179            },
180        });
181        await storage.get({
182            key: 'storageKey',
183            success: async function (data) {
184                await expect('storageVal').assertEqual(data);
185            },
186            complete: async function () {
187                completeRet = true;
188                await expect(completeRet).assertTrue();
189            }
190        });
191        await expect(completeRet).assertTrue();
192        console.log(TAG + '************* testGet001 end *************');
193    })
194
195    /*
196     * @tc.name testGet002
197     * @tc.number SUB_DDM_AppDataFWK_SystemStorage_Get_0002
198     * @tc.desc get value without set any value and can get default in success callback
199     */
200    it('testGet002', 0, async function () {
201        console.log(TAG + '************* testGet002 start *************');
202        let completeRet = false;
203        await storage.get({
204            key: 'storageKey',
205            default: '123',
206            success: async function (data) {
207                await expect('123').assertEqual(data);
208            },
209            fail: async function (data, err) {
210                await expect(false).assertTrue();
211            },
212            complete: async function () {
213                completeRet = true;
214                await expect(completeRet).assertTrue();
215            }
216        })
217        await expect(completeRet).assertTrue();
218        console.log(TAG + '************* testGet002 end *************');
219    })
220
221
222    /*
223     * @tc.name testGet003
224     * @tc.number SUB_DDM_AppDataFWK_SystemStorage_Get_0003
225     * @tc.desc get default size over 128 and can receive fail callback
226     */
227    it('testGet003', 0, async function () {
228        console.log(TAG + '************* testGet003 start *************');
229        let testVal = undefined;
230        let testData = undefined;
231        let testErrCode = undefined;
232        let completeRet = false;
233        let failRet = false;
234        await storage.get({
235            key: 'storageKey',
236            default: 'x'.repeat(129),
237            success: async function (data) {
238                testVal = data;
239            },
240            fail: async function (data, errCode) {
241                testErrCode = errCode;
242                testData = data;
243                failRet = true;
244            },
245            complete: async function () {
246                completeRet = true;
247                await expect(completeRet).assertTrue();
248            }
249        })
250        expect(failRet).assertTrue();
251        expect(completeRet).assertTrue();
252        expect(-1018).assertEqual(testErrCode);
253        expect('The default string length should shorter than 128.').assertEqual(testData);
254        expect(testVal == undefined).assertTrue();
255        console.log(TAG + '************* testGet003 end *************');
256    })
257
258    /*
259     * @tc.name testGet004
260     * @tc.number SUB_DDM_AppDataFWK_SystemStorage_Get_0004
261     * @tc.desc get null key and can return default value
262     */
263    it('testGet004', 0, async function () {
264        console.log(TAG + '************* testGet004 start *************');
265        let testVal = undefined;
266        let completeRet = false;
267        await storage.get({
268            key: '',
269            default: 'storageVal',
270            success: async function (data) {
271                await expect(data).assertEqual('storageVal');
272            },
273            fail: async function (data, err) {
274                await expect(false).assertTrue();
275            },
276            complete: async function () {
277                completeRet = true;
278                await expect(completeRet).assertTrue();
279            }
280        })
281        await expect(completeRet).assertTrue();
282        console.log(TAG + '************* testGet004 end *************');
283    })
284
285    /*
286     * @tc.name testDelete001
287     * @tc.number SUB_DDM_AppDataFWK_SystemStorage_Delete_0001
288     * @tc.desc delete value and can not get value
289     */
290    it('testDelete001', 0, async function () {
291        console.log(TAG + '************* testDelete001 start *************');
292        let completeRet = false;
293        let successRet = false;
294        await storage.set({
295            key: 'storageKey',
296            value: 'storageVal',
297            success: async function () {
298                await expect(true).assertTrue();
299            },
300            fail: async function (data, err) {
301                await expect(false).assertTrue();
302            },
303        })
304        await storage.delete({
305            key: "storageKey",
306            success: async function () {
307                successRet = true;
308                await expect(successRet).assertTrue();
309            },
310            complete: async function () {
311                completeRet = true;
312                await expect(completeRet).assertTrue();
313            }
314        });
315        await storage.get({
316            key: 'storageKey',
317            default: 'testVal',
318            success: async function (data) {
319                await expect(data).assertEqual('testVal');
320            }
321        })
322        await expect(completeRet).assertTrue();
323        await expect(successRet).assertTrue();
324        console.log(TAG + '************* testDelete001 end *************');
325    })
326
327    /*
328     * @tc.name testDelete002
329     * @tc.number SUB_DDM_AppDataFWK_SystemStorage_Delete_0002
330     * @tc.desc delete null key and can get fail callback
331     */
332    it('testDelete002', 0, async function () {
333        console.log(TAG + '************* testDelete002 start *************');
334        let testData = undefined;
335        let testErrCode = undefined;
336        let completeRet = false;
337        let failRet = false;
338        await storage.set({
339            key: 'storageKey',
340            value: 'storageVal',
341            success: async function () {
342                await expect(true).assertTrue();
343            },
344            fail: async function (data, err) {
345                await expect(false).assertTrue();
346            },
347        })
348        await storage.delete({
349            key: '',
350            success: async function () {
351                await expect(false).assertTrue();
352            },
353            fail: async function (data, err) {
354                testErrCode = err;
355                testData = data;
356                failRet = true;
357            },
358            complete: async function () {
359                completeRet = true;
360                await expect(completeRet).assertTrue();
361            }
362        })
363        await expect(completeRet).assertTrue();
364        await expect("The key string is null or empty.").assertEqual(testData);
365        await expect(-1006).assertEqual(testErrCode);
366        await expect(failRet).assertTrue();
367        console.log(TAG + '************* testDelete002 end *************');
368    })
369
370    /*
371     * @tc.name testDelete003
372     * @tc.number SUB_DDM_AppDataFWK_SystemStorage_Delete_0003
373     * @tc.desc delete incorrect key and can get success callback
374     */
375    it('testDelete003', 0, async function () {
376        console.log(TAG + '************* testDelete003 start *************');
377        let completeRet = false;
378        await storage.set({
379            key: 'storageKey',
380            value: 'test',
381            success: async function () {
382                await expect(true).assertTrue();
383            },
384            fail: async function () {
385                await expect(false).assertTrue();
386            },
387        });
388        await storage.delete({
389            key: '123',
390            success: async function () {
391                await expect(true).assertTrue();
392            },
393            fail: async function (data, err) {
394                await expect(false).assertTrue();
395            },
396            complete: async function () {
397                completeRet = true;
398                expect(completeRet).assertTrue();
399            }
400        });
401        await storage.get({
402            key: 'storageKey',
403            success: async function (data) {
404                await expect(data).assertEqual('test');
405            },
406            fail: async function (data, err) {
407                await expect(false).assertTrue();
408            }
409        })
410        await expect(completeRet).assertTrue();
411        console.log(TAG + '************* testDelete003 end *************');
412    })
413
414    /*
415     * @tc.name testClear001
416     * @tc.number SUB_DDM_AppDataFWK_SystemStorage_Clear_0001
417     * @tc.desc clear and can receive success callback
418     */
419    it('testClear001', 0, async function () {
420        console.log(TAG + '************* testClear001 start *************');
421        let successRet = false;
422        await storage.set({
423            key: 'storageKey1',
424            value: 'storageVal1',
425            success:async function () {
426                await expect(true).assertTrue();
427            },
428            fail:async function () {
429                await expect(false).assertTrue();
430            },
431        });
432        await storage.set({
433            key: 'storageKey2',
434            value: 'storageVal2',
435            success:async function () {
436                await expect(true).assertTrue();
437            },
438            fail:async function () {
439                await expect(false).assertTrue();
440            },
441        });
442        await storage.clear({
443            success:async function() {
444                successRet = true;
445                await expect(successRet).assertTrue();
446            },
447            fail: async function (data, err) {
448                await expect(false).assertTrue();
449            }
450        });
451        await expect(successRet).assertTrue();
452        console.log(TAG + '************* testClear001 end *************');
453    })
454
455})