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