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 */ 15 16import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' 17import factory from '@ohos.data.distributedKVStore' 18import dataShare from '@ohos.data.dataSharePredicates' 19import abilityFeatureAbility from '@ohos.ability.featureAbility' 20 21var context = abilityFeatureAbility.getContext(); 22const KEY_TEST_INT_ELEMENT = 'key_test_int'; 23const KEY_TEST_FLOAT_ELEMENT = 'key_test_float'; 24const KEY_TEST_BOOLEAN_ELEMENT = 'key_test_boolean'; 25const KEY_TEST_STRING_ELEMENT = 'key_test_string'; 26const KEY_TEST_SYNC_ELEMENT = 'key_test_sync'; 27const file = ""; 28const files = [file]; 29 30const VALUE_TEST_INT_ELEMENT = 123; 31const VALUE_TEST_FLOAT_ELEMENT = 321.12; 32const VALUE_TEST_BOOLEAN_ELEMENT = true; 33const VALUE_TEST_STRING_ELEMENT = 'value-string-001'; 34const VALUE_TEST_SYNC_ELEMENT = 'value-string-001'; 35 36const TEST_BUNDLE_NAME = 'com.example.myapplication'; 37const TEST_STORE_ID = 'storeId1'; 38var kvManager = null; 39var kvStore = null; 40const USED_DEVICE_IDS = ['A12C1F9261528B21F95778D2FDC0B2E33943E6251AC5487F4473D005758905DB']; 41const UNUSED_DEVICE_IDS = []; /* add you test device-ids here */ 42var syncDeviceIds = USED_DEVICE_IDS.concat(UNUSED_DEVICE_IDS); 43 44function sleep(ms) { 45 return new Promise(resolve => setTimeout(resolve, ms)); 46} 47 48function putBatchString(len, prefix) { 49 let entries = []; 50 for (var i = 0; i < len; i++) { 51 var entry = { 52 key: prefix + i, 53 value: { 54 type: factory.ValueType.STRING, 55 value: 'batch_test_string_value' 56 } 57 } 58 entries.push(entry); 59 } 60 return entries; 61} 62 63describe('SingleKvStorePromiseTest', function () { 64 const config = { 65 bundleName: TEST_BUNDLE_NAME, 66 context: context 67 } 68 69 const options = { 70 createIfMissing: true, 71 encrypt: false, 72 backup: true, 73 autoSync: true, 74 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 75 schema: '', 76 securityLevel: factory.SecurityLevel.S2, 77 } 78 79 beforeAll(async function (done) { 80 console.info('beforeAll config:' + JSON.stringify(config)); 81 kvManager = factory.createKVManager(config); 82 console.info('beforeAll end'); 83 done(); 84 }) 85 86 afterAll(async function (done) { 87 console.info('afterAll'); 88 kvManager = null; 89 kvStore = null; 90 done(); 91 }) 92 beforeEach(async function (done) { 93 console.info('beforeEach' + JSON.stringify(options)); 94 await kvManager.getKVStore(TEST_STORE_ID, options, function (err, store) { 95 kvStore = store; 96 console.info('beforeEach getKVStore success'); 97 done(); 98 }); 99 }) 100 101 afterEach(async function (done) { 102 console.info('afterEach'); 103 try { 104 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, async function (err, data) { 105 console.info('afterEach closeKVStore success: err is: ' + err); 106 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, function (err, data) { 107 console.info('afterEach deleteKVStore success err is: ' + err); 108 done(); 109 }); 110 }); 111 kvStore = null; 112 } catch (e) { 113 console.error('afterEach closeKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 114 } 115 }) 116 117 /** 118 * @tc.name SingleKvStorePutStringPromiseInvalidArgsTest 119 * @tc.desc Test Js Api SingleKvStore.Put(String) with invalid args 120 * @tc.type: FUNC 121 * @tc.require: issueNumber 122 */ 123 it('SingleKvStorePutStringPromiseInvalidArgsTest', 0, async function (done) { 124 console.info('SingleKvStorePutStringPromiseInvalidArgsTest'); 125 try { 126 await kvStore.put(KEY_TEST_STRING_ELEMENT, null).then((data) => { 127 console.info('SingleKvStorePutStringPromiseInvalidArgsTest put success'); 128 expect(null).assertFail(); 129 }).catch((error) => { 130 console.error('SingleKvStorePutStringPromiseInvalidArgsTest put error' + `, error code is ${error.code}, message is ${error.message}`); 131 expect(null).assertFail(); 132 }); 133 } catch (e) { 134 console.error('SingleKvStorePutStringPromiseInvalidArgsTest e ' + `, error code is ${e.code}, message is ${e.message}`); 135 expect(e.code == 401).assertTrue(); 136 } 137 done(); 138 }) 139 140 /** 141 * @tc.name SingleKvStorePutStringPromiseClosedKVStoreTest 142 * @tc.desc Test Js Api SingleKvStore.Put(String) in a closed kvstore 143 * @tc.type: FUNC 144 * @tc.require: issueNumber 145 */ 146 it('SingleKvStorePutStringPromiseClosedKVStoreTest', 0, async function (done) { 147 console.info('SingleKvStorePutStringPromiseClosedKVStoreTest'); 148 try { 149 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 150 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 151 expect(true).assertTrue(); 152 }).catch((err) => { 153 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 154 }); 155 }) 156 await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then((data) => { 157 console.info('SingleKvStorePutStringPromiseClosedKVStoreTest put success'); 158 expect(null).assertFail(); 159 }).catch((error) => { 160 console.error('SingleKvStorePutStringPromiseClosedKVStoreTest put error' + `, error code is ${error.code}, message is ${error.message}`); 161 expect(error.code == 15100005).assertTrue(); 162 }); 163 } catch (e) { 164 console.error('SingleKvStorePutStringPromiseClosedKVStoreTest e ' + `, error code is ${e.code}, message is ${e.message}`); 165 expect(null).assertFail(); 166 } 167 done(); 168 }) 169 170 /** 171 * @tc.name SingleKvStorePutStringPromiseSucTest 172 * @tc.desc Test Js Api SingleKvStore.Put(String) success 173 * @tc.type: FUNC 174 * @tc.require: issueNumber 175 */ 176 it('SingleKvStorePutStringPromiseSucTest', 0, async function (done) { 177 console.info('SingleKvStorePutStringPromiseSucTest'); 178 try { 179 await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then((data) => { 180 console.info('SingleKvStorePutStringPromiseSucTest put success'); 181 expect(data == undefined).assertTrue(); 182 }).catch((error) => { 183 console.error('SingleKvStorePutStringPromiseSucTest put error' + `, error code is ${error.code}, message is ${error.message}`); 184 expect(null).assertFail(); 185 }); 186 } catch (e) { 187 console.error('SingleKvStorePutStringPromiseSucTest e ' + `, error code is ${e.code}, message is ${e.message}`); 188 expect(null).assertFail(); 189 } 190 done(); 191 }) 192 193 /** 194 * @tc.name SingleKvStoreGetStringPromiseSucTest 195 * @tc.desc Test Js Api SingleKvStoreGetString success 196 * @tc.type: FUNC 197 * @tc.require: issueNumber 198 */ 199 it('SingleKvStoreGetStringPromiseSucTest', 0, async function (done) { 200 console.info('SingleKvStoreGetStringPromiseSucTest'); 201 try { 202 await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then(async (data) => { 203 expect(data == undefined).assertTrue(); 204 await kvStore.get(KEY_TEST_STRING_ELEMENT).then((data) => { 205 expect(VALUE_TEST_STRING_ELEMENT == data).assertTrue(); 206 }).catch((err) => { 207 expect(null).assertFail(); 208 }); 209 }).catch((error) => { 210 expect(null).assertFail(); 211 }); 212 } catch (e) { 213 expect(null).assertFail(); 214 } 215 done(); 216 }) 217 218 /** 219 * @tc.name SingleKvStoreGetStringPromiseInvalidArgsTest 220 * @tc.desc Test Js Api SingleKvStoreGetString with invalid args 221 * @tc.type: FUNC 222 * @tc.require: issueNumber 223 */ 224 it('SingleKvStoreGetStringPromiseInvalidArgsTest', 0, async function (done) { 225 try { 226 await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then(async (data) => { 227 expect(data == undefined).assertTrue(); 228 await kvStore.get().then((data) => { 229 expect(null).assertFail(); 230 }).catch((err) => { 231 expect(null).assertFail(); 232 }); 233 }).catch((error) => { 234 expect(error.code == 401).assertTrue(); 235 }); 236 } catch (e) { 237 console.error('SingleKvStoreGetStringPromiseInvalidArgsTest e ' + `, error code is ${e.code}, message is ${e.message}`); 238 expect(null).assertFail(); 239 } 240 done(); 241 }) 242 243 /** 244 * @tc.name SingleKvStoreGetStringPromiseClosedKVStoreTest 245 * @tc.desc Test Js Api SingleKvStoreGetString from a closed kvstore 246 * @tc.type: FUNC 247 * @tc.require: issueNumber 248 */ 249 it('SingleKvStoreGetStringPromiseClosedKVStoreTest', 0, async function (done) { 250 try { 251 await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then(async (data) => { 252 expect(data == undefined).assertTrue(); 253 }).catch((error) => { 254 console.error('SingleKvStoreGetStringPromiseClosedKVStoreTest put error' + `, error code is ${error.code}, message is ${error.message}`); 255 expect(null).assertFail(); 256 }); 257 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 258 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 259 expect(true).assertTrue(); 260 }).catch((err) => { 261 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 262 }); 263 }) 264 await kvStore.get(KEY_TEST_STRING_ELEMENT).then((data) => { 265 expect(null).assertFail(); 266 }).catch((err) => { 267 expect(err.code == 15100005).assertTrue(); 268 }); 269 } catch (e) { 270 console.error('SingleKvStoreGetStringPromiseClosedKVStoreTest e ' + `, error code is ${e.code}, message is ${e.message}`); 271 expect(null).assertFail(); 272 } 273 done(); 274 }) 275 276 /** 277 * @tc.name SingleKvStoreGetStringPromiseNoPutTest 278 * @tc.desc Test Js Api SingleKvStoreGetString without put 279 * @tc.type: FUNC 280 * @tc.require: issueNumber 281 */ 282 it('SingleKvStoreGetStringPromiseNoPutTest', 0, async function (done) { 283 console.info('SingleKvStoreGetStringPromiseNoPutTest'); 284 try { 285 await kvStore.get(KEY_TEST_STRING_ELEMENT).then((data) => { 286 console.info('SingleKvStoreGetStringPromiseNoPutTest get success'); 287 expect(null).assertFail(); 288 }).catch((err) => { 289 console.error('SingleKvStoreGetStringPromiseNoPutTest get fail ' + `, error code is ${err.code}, message is ${err.message}`); 290 expect(err.code == 15100004).assertTrue(); 291 }); 292 } catch (e) { 293 console.error('SingleKvStoreGetStringPromiseNoPutTest get e ' + `, error code is ${e.code}, message is ${e.message}`); 294 expect(null).assertFail(); 295 } 296 done(); 297 }) 298 299 /** 300 * @tc.name SingleKvStorePutIntPromiseSucTest 301 * @tc.desc Test Js Api SingleKvStore.Put(Int) success 302 * @tc.type: FUNC 303 * @tc.require: issueNumber 304 */ 305 it('SingleKvStorePutIntPromiseSucTest', 0, async function (done) { 306 console.info('SingleKvStorePutIntPromiseSucTest'); 307 try { 308 await kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT).then((data) => { 309 console.info('SingleKvStorePutIntPromiseSucTest put success'); 310 expect(data == undefined).assertTrue(); 311 }).catch((err) => { 312 console.error('SingleKvStorePutIntPromiseSucTest put fail ' + `, error code is ${err.code}, message is ${err.message}`); 313 expect(null).assertFail(); 314 }); 315 } catch (e) { 316 console.error('SingleKvStorePutIntPromiseSucTest put e ' + `, error code is ${e.code}, message is ${e.message}`); 317 expect(null).assertFail(); 318 } 319 done(); 320 }) 321 322 /** 323 * @tc.name SingleKvStorePutIntPromiseMaxTest 324 * @tc.desc Test Js Api SingleKvStore.Put(Int) with max value 325 * @tc.type: FUNC 326 * @tc.require: issueNumber 327 */ 328 it('SingleKvStorePutIntPromiseMaxTest', 0, async function (done) { 329 console.info('SingleKvStorePutIntPromiseMaxTest'); 330 try { 331 var intValue = Number.MAX_VALUE; 332 await kvStore.put(KEY_TEST_INT_ELEMENT, intValue).then(async (data) => { 333 console.info('SingleKvStorePutIntPromiseMaxTest put success'); 334 expect(data == undefined).assertTrue(); 335 await kvStore.get(KEY_TEST_INT_ELEMENT).then((data) => { 336 console.info('SingleKvStorePutIntPromiseMaxTest get success'); 337 expect(intValue == data).assertTrue(); 338 }).catch((err) => { 339 console.error('SingleKvStorePutIntPromiseMaxTest get fail ' + `, error code is ${err.code}, message is ${err.message}`); 340 expect(null).assertFail(); 341 }); 342 }).catch((err) => { 343 console.error('SingleKvStorePutIntPromiseMaxTest put fail ' + `, error code is ${err.code}, message is ${err.message}`); 344 expect(null).assertFail(); 345 }); 346 } catch (e) { 347 console.error('SingleKvStorePutIntPromiseMaxTest put e ' + `, error code is ${e.code}, message is ${e.message}`); 348 expect(null).assertFail(); 349 } 350 done(); 351 }) 352 353 /** 354 * @tc.name SingleKvStorePutIntPromiseMinTest 355 * @tc.desc Test Js Api SingleKvStore.Put(Int) with min value 356 * @tc.type: FUNC 357 * @tc.require: issueNumber 358 */ 359 it('SingleKvStorePutIntPromiseMinTest', 0, async function (done) { 360 console.info('SingleKvStorePutIntPromiseMinTest'); 361 try { 362 var intValue = Number.MIN_VALUE; 363 await kvStore.put(KEY_TEST_INT_ELEMENT, intValue).then(async (data) => { 364 console.info('SingleKvStorePutIntPromiseMinTest put success'); 365 expect(data == undefined).assertTrue(); 366 await kvStore.get(KEY_TEST_INT_ELEMENT).then((data) => { 367 console.info('SingleKvStorePutIntPromiseMinTest get success'); 368 expect(intValue == data).assertTrue(); 369 }).catch((err) => { 370 console.error('SingleKvStorePutIntPromiseMinTest get fail ' + `, error code is ${err.code}, message is ${err.message}`); 371 expect(null).assertFail(); 372 }); 373 }).catch((err) => { 374 console.error('SingleKvStorePutIntPromiseMinTest put fail ' + `, error code is ${err.code}, message is ${err.message}`); 375 expect(null).assertFail(); 376 }); 377 } catch (e) { 378 console.error('SingleKvStorePutIntPromiseMinTest put e ' + `, error code is ${e.code}, message is ${e.message}`); 379 expect(null).assertFail(); 380 } 381 done(); 382 }) 383 384 /** 385 * @tc.name SingleKvStoreGetIntPromiseSucTest 386 * @tc.desc Test Js Api SingleKvStoreGetInt success 387 * @tc.type: FUNC 388 * @tc.require: issueNumber 389 */ 390 it('SingleKvStoreGetIntPromiseSucTest', 0, async function (done) { 391 console.info('SingleKvStoreGetIntPromiseSucTest'); 392 try { 393 await kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT).then(async (data) => { 394 console.info('SingleKvStoreGetIntPromiseSucTest put success'); 395 expect(data == undefined).assertTrue(); 396 await kvStore.get(KEY_TEST_INT_ELEMENT).then((data) => { 397 console.info('SingleKvStoreGetIntPromiseSucTest get success'); 398 expect(VALUE_TEST_INT_ELEMENT == data).assertTrue(); 399 }).catch((err) => { 400 console.error('SingleKvStoreGetIntPromiseSucTest get fail ' + `, error code is ${err.code}, message is ${err.message}`); 401 expect(null).assertFail(); 402 }); 403 }).catch((err) => { 404 console.error('SingleKvStoreGetIntPromiseSucTest put fail ' + `, error code is ${err.code}, message is ${err.message}`); 405 expect(null).assertFail(); 406 }); 407 } catch (e) { 408 console.error('SingleKvStoreGetIntPromiseSucTest put e ' + `, error code is ${e.code}, message is ${e.message}`); 409 expect(null).assertFail(); 410 } 411 done(); 412 }) 413 414 /** 415 * @tc.name SingleKvStorePutBoolPromiseSucTest 416 * @tc.desc Test Js Api SingleKvStore.Put(Bool) success 417 * @tc.type: FUNC 418 * @tc.require: issueNumber 419 */ 420 it('SingleKvStorePutBoolPromiseSucTest', 0, async function (done) { 421 console.info('SingleKvStorePutBoolPromiseSucTest'); 422 try { 423 await kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, VALUE_TEST_BOOLEAN_ELEMENT).then((data) => { 424 console.info('SingleKvStorePutBoolPromiseSucTest put success'); 425 expect(data == undefined).assertTrue(); 426 }).catch((err) => { 427 console.error('SingleKvStorePutBoolPromiseSucTest put fail ' + `, error code is ${err.code}, message is ${err.message}`); 428 expect(null).assertFail(); 429 }); 430 } catch (e) { 431 console.error('SingleKvStorePutBoolPromiseSucTest put e ' + `, error code is ${e.code}, message is ${e.message}`); 432 expect(null).assertFail(); 433 } 434 done(); 435 }) 436 437 /** 438 * @tc.name SingleKvStoreGetBoolPromiseSucTest 439 * @tc.desc Test Js Api SingleKvStoreGetBool success 440 * @tc.type: FUNC 441 * @tc.require: issueNumber 442 */ 443 it('SingleKvStoreGetBoolPromiseSucTest', 0, async function (done) { 444 console.info('SingleKvStoreGetBoolPromiseSucTest'); 445 try { 446 var boolValue = false; 447 await kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, boolValue).then(async (data) => { 448 console.info('SingleKvStoreGetBoolPromiseSucTest put success'); 449 expect(data == undefined).assertTrue(); 450 await kvStore.get(KEY_TEST_BOOLEAN_ELEMENT).then((data) => { 451 console.info('SingleKvStoreGetBoolPromiseSucTest get success'); 452 expect(boolValue == data).assertTrue(); 453 }).catch((err) => { 454 console.error('SingleKvStoreGetBoolPromiseSucTest get fail ' + `, error code is ${err.code}, message is ${err.message}`); 455 expect(null).assertFail(); 456 }); 457 }).catch((err) => { 458 console.error('SingleKvStoreGetBoolPromiseSucTest put fail ' + `, error code is ${err.code}, message is ${err.message}`); 459 expect(null).assertFail(); 460 }); 461 } catch (e) { 462 console.error('SingleKvStoreGetBoolPromiseSucTest put e ' + `, error code is ${e.code}, message is ${e.message}`); 463 expect(null).assertFail(); 464 } 465 done(); 466 }) 467 468 /** 469 * @tc.name SingleKvStorePutFloatPromiseSucTest 470 * @tc.desc Test Js Api SingleKvStore.Put(Float) success 471 * @tc.type: FUNC 472 * @tc.require: issueNumber 473 */ 474 it('SingleKvStorePutFloatPromiseSucTest', 0, async function (done) { 475 console.info('SingleKvStorePutFloatPromiseSucTest'); 476 try { 477 await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT).then((data) => { 478 console.info('SingleKvStorePutFloatPromiseSucTest put success'); 479 expect(data == undefined).assertTrue(); 480 }).catch((err) => { 481 console.error('SingleKvStorePutFloatPromiseSucTest put fail ' + `, error code is ${err.code}, message is ${err.message}`); 482 expect(null).assertFail(); 483 }); 484 } catch (e) { 485 console.error('SingleKvStorePutFloatPromiseSucTest put e ' + `, error code is ${e.code}, message is ${e.message}`); 486 expect(null).assertFail(); 487 } 488 done(); 489 }) 490 491 /** 492 * @tc.name SingleKvStoreGetFloatPromiseSucTest 493 * @tc.desc Test Js Api SingleKvStoreGetFloat success 494 * @tc.type: FUNC 495 * @tc.require: issueNumber 496 */ 497 it('SingleKvStoreGetFloatPromiseSucTest', 0, async function (done) { 498 console.info('SingleKvStoreGetFloatPromiseSucTest'); 499 try { 500 var floatValue = 123456.654321; 501 await kvStore.put(KEY_TEST_FLOAT_ELEMENT, floatValue).then(async (data) => { 502 console.info('SingleKvStoreGetFloatPromiseSucTest put success'); 503 expect(data == undefined).assertTrue(); 504 await kvStore.get(KEY_TEST_FLOAT_ELEMENT).then((data) => { 505 console.info('SingleKvStoreGetFloatPromiseSucTest get success'); 506 expect(floatValue == data).assertTrue(); 507 }).catch((err) => { 508 console.error('SingleKvStoreGetFloatPromiseSucTest get fail ' + `, error code is ${err.code}, message is ${err.message}`); 509 expect(null).assertFail(); 510 }); 511 }).catch((err) => { 512 console.error('SingleKvStoreGetFloatPromiseSucTest put fail ' + `, error code is ${err.code}, message is ${err.message}`); 513 expect(null).assertFail(); 514 }); 515 } catch (e) { 516 console.error('SingleKvStoreGetFloatPromiseSucTest put e ' + `, error code is ${e.code}, message is ${e.message}`); 517 expect(null).assertFail(); 518 } 519 done(); 520 }) 521 522 /** 523 * @tc.name SingleKvStoreDeleteStringPromiseSucTest 524 * @tc.desc Test Js Api SingleKvStoreDeleteString success 525 * @tc.type: FUNC 526 * @tc.require: issueNumber 527 */ 528 it('SingleKvStoreDeleteStringPromiseSucTest', 0, async function (done) { 529 console.info('SingleKvStoreDeleteStringPromiseSucTest'); 530 try { 531 var str = 'this is a test string'; 532 await kvStore.put(KEY_TEST_STRING_ELEMENT, str).then(async (data) => { 533 console.info('SingleKvStoreDeleteStringPromiseSucTest put success'); 534 expect(data == undefined).assertTrue(); 535 await kvStore.delete(KEY_TEST_STRING_ELEMENT).then((data) => { 536 console.info('SingleKvStoreDeleteStringPromiseSucTest delete success'); 537 expect(data == undefined).assertTrue(); 538 }).catch((err) => { 539 console.error('SingleKvStoreDeleteStringPromiseSucTest delete fail ' + `, error code is ${err.code}, message is ${err.message}`); 540 expect(null).assertFail(); 541 }); 542 }).catch((err) => { 543 console.error('SingleKvStoreDeleteStringPromiseSucTest put fail ' + `, error code is ${err.code}, message is ${err.message}`); 544 expect(null).assertFail(); 545 }); 546 } catch (e) { 547 console.error('SingleKvStoreDeleteStringPromiseSucTest put e ' + `, error code is ${e.code}, message is ${e.message}`); 548 expect(null).assertFail(); 549 } 550 done(); 551 }) 552 553 /** 554 * @tc.name SingleKvStoreDeleteStringPromiseInvalidArgsTest 555 * @tc.desc Test Js Api SingleKvStoreDeleteString with invalid args 556 * @tc.type: FUNC 557 * @tc.require: issueNumber 558 */ 559 it('SingleKvStoreDeleteStringPromiseInvalidArgsTest', 0, async function (done) { 560 console.info('SingleKvStoreDeleteStringPromiseInvalidArgsTest'); 561 try { 562 var str = 'this is a test string'; 563 await kvStore.put(KEY_TEST_STRING_ELEMENT, str).then(async () => { 564 expect(true).assertTrue(); 565 await kvStore.delete().then(() => { 566 expect(null).assertFail(); 567 }).catch((err) => { 568 expect(null).assertFail(); 569 }); 570 }).catch((err) => { 571 expect(err.code == 401).assertTrue(); 572 }); 573 } catch (e) { 574 expect(null).assertFail(); 575 } 576 done(); 577 }) 578 579 /** 580 * @tc.name SingleKvStoreDeleteStringPromiseClosedKVStoreTest 581 * @tc.desc Test Js Api SingleKvStoreDeleteString into a closed kvstore 582 * @tc.type: FUNC 583 * @tc.require: issueNumber 584 */ 585 it('SingleKvStoreDeleteStringPromiseClosedKVStoreTest', 0, async function (done) { 586 try { 587 let str = "test"; 588 589 await kvStore.put(KEY_TEST_STRING_ELEMENT, str).then(async () => { 590 console.info('SingleKvStoreDeleteStringPromiseSucTest put success'); 591 expect(true).assertTrue(); 592 }).catch((err) => { 593 console.error('SingleKvStoreDeleteStringPromiseClosedKVStoreTest put fail ' + `, error code is ${err.code}, message is ${err.message}`); 594 expect(null).assertFail(); 595 }); 596 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 597 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 598 expect(true).assertTrue(); 599 }).catch((err) => { 600 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 601 }); 602 }) 603 await kvStore.delete(KEY_TEST_STRING_ELEMENT).then((data) => { 604 console.info('SingleKvStoreDeleteStringPromiseSucTest delete success'); 605 expect(null).assertFail(); 606 }).catch((err) => { 607 console.error('SingleKvStoreDeleteStringPromiseSucTest delete fail ' + `, error code is ${err.code}, message is ${err.message}`); 608 expect(err.code == 15100005).assertTrue(); 609 }); 610 } catch (e) { 611 console.error('SingleKvStorePutStringPromiseClosedKVStoreTest e ' + `, error code is ${e.code}, message is ${e.message}`); 612 expect(null).assertFail(); 613 } 614 done(); 615 }) 616 617 /** 618 * @tc.name SingleKvStoreDeletePredicatesPromiseSucTest 619 * @tc.desc Test Js Api SingleKvStore.Delete() success 620 * @tc.type: FUNC 621 * @tc.require: issueNumber 622 */ 623 it('SingleKvStoreDeletePredicatesPromiseSucTest', 0, async function (done) { 624 console.log('SingleKvStoreDeletePredicatesPromiseSucTest'); 625 try { 626 let predicates = new dataShare.DataSharePredicates(); 627 let arr = ["name"]; 628 predicates.inKeys(arr); 629 await kvStore.put("name", "Bob").then(async (data) => { 630 console.log('SingleKvStoreDeletePredicatesPromiseSucTest put success'); 631 expect(data == undefined).assertTrue(); 632 await kvStore.delete(predicates).then((data) => { 633 console.log('SingleKvStoreDeletePredicatesPromiseSucTest delete success'); 634 expect(data == undefined).assertTrue(); 635 }).catch((err) => { 636 console.error('SingleKvStoreDeletePredicatesPromiseSucTest delete fail ' + `, error code is ${err.code}, message is ${err.message}`); 637 expect(null).assertFail(); 638 }); 639 }).catch((err) => { 640 console.error('SingleKvStoreDeletePredicatesPromiseSucTest put fail ' + `, error code is ${err.code}, message is ${err.message}`); 641 expect(null).assertFail(); 642 }); 643 } catch (e) { 644 console.error('SingleKvStoreDeletePredicatesPromiseSucTest put e ' + `, error code is ${e.code}, message is ${e.message}`); 645 expect(null).assertFail(); 646 } 647 done(); 648 }) 649 650 /** 651 * @tc.name SingleKvStoreDeletePredicatesPromiseClosedKVStoreTest 652 * @tc.desc Test Js Api SingleKvStoreDelete predicates into a closed kvstore 653 * @tc.type: FUNC 654 * @tc.require: issueNumber 655 */ 656 it('SingleKvStoreDeletePredicatesPromiseClosedKVStoreTest', 0, async function (done) { 657 try { 658 let predicates = new dataShare.DataSharePredicates(); 659 let arr = ["name"]; 660 predicates.inKeys(arr); 661 await kvStore.put("name", "Bob").then(async () => { 662 expect(true).assertTrue(); 663 }).catch((err) => { 664 expect(null).assertFail(); 665 }); 666 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 667 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 668 expect(true).assertTrue(); 669 }).catch((err) => { 670 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 671 }); 672 }) 673 await kvStore.delete(predicates).then((data) => { 674 expect(null).assertFail(); 675 }).catch((err) => { 676 expect(err.code == 15100005).assertTrue(); 677 }); 678 } catch (e) { 679 console.error('SingleKvStoreDeletePredicatesPromiseClosedKVStoreTest e ' + `, error code is ${e.code}, message is ${e.message}`); 680 expect(null).assertFail(); 681 } 682 done(); 683 }) 684 685 /** 686 * @tc.name SingleKvStoreDeletePredicatesPromiseInvalidArgsTest 687 * @tc.desc Test Js Api SingleKvStoreDelete predicates with invalid args 688 * @tc.type: FUNC 689 * @tc.require: issueNumber 690 */ 691 it('SingleKvStoreDeleteStringPromiseInvalidArgsTest', 0, async function (done) { 692 console.info('SingleKvStoreDeleteStringPromiseInvalidArgsTest'); 693 try { 694 let predicates = new dataShare.DataSharePredicates(); 695 let arr = ["name"]; 696 predicates.inKeys(arr); 697 await kvStore.put("name", "bob").then(async () => { 698 expect(true).assertTrue(); 699 await kvStore.delete().then(() => { 700 expect(null).assertFail(); 701 }).catch((err) => { 702 expect(null).assertFail(); 703 }); 704 }).catch((err) => { 705 expect(err.code == 401).assertTrue(); 706 }); 707 } catch (e) { 708 expect(null).assertFail(); 709 } 710 done(); 711 }) 712 713 /** 714 * @tc.name SingleKvStoreSetSyncRangePromiseDisjointTest 715 * @tc.desc Test Js Api SingleKvStoreSetSyncRange with disjoint ranges 716 * @tc.type: FUNC 717 * @tc.require: issueNumber 718 */ 719 it('SingleKvStoreSetSyncRangePromiseDisjointTest', 0, async function (done) { 720 console.info('SingleKvStoreSetSyncRangePromiseDisjointTest'); 721 try { 722 var localLabels = ['A', 'B']; 723 var remoteSupportLabels = ['C', 'D']; 724 await kvStore.setSyncRange(localLabels, remoteSupportLabels).then((err) => { 725 console.info('SingleKvStoreSetSyncRangePromiseDisjointTest setSyncRange success'); 726 expect(err == undefined).assertTrue(); 727 }).catch((err) => { 728 console.error('SingleKvStoreSetSyncRangePromiseDisjointTest delete fail ' + `, error code is ${err.code}, message is ${err.message}`); 729 expect(null).assertFail(); 730 }); 731 } catch (e) { 732 console.error('SingleKvStoreSetSyncRangePromiseDisjointTest e ' + `, error code is ${e.code}, message is ${e.message}`); 733 expect(null).assertFail(); 734 } 735 done(); 736 }) 737 738 /** 739 * @tc.name SingleKvStoreSetSyncRangePromiseJointTest 740 * @tc.desc Test Js Api SingleKvStoreSetSyncRange with joint range 741 * @tc.type: FUNC 742 * @tc.require: issueNumber 743 */ 744 it('SingleKvStoreSetSyncRangePromiseJointTest', 0, async function (done) { 745 console.info('SingleKvStoreSetSyncRangePromiseJointTest'); 746 try { 747 var localLabels = ['A', 'B']; 748 var remoteSupportLabels = ['B', 'C']; 749 await kvStore.setSyncRange(localLabels, remoteSupportLabels).then((err) => { 750 console.info('SingleKvStoreSetSyncRangePromiseJointTest setSyncRange success'); 751 expect(err == undefined).assertTrue(); 752 }).catch((err) => { 753 console.error('SingleKvStoreSetSyncRangePromiseJointTest delete fail ' + `, error code is ${err.code}, message is ${err.message}`); 754 expect(null).assertFail(); 755 }); 756 } catch (e) { 757 console.error('SingleKvStoreSetSyncRangePromiseJointTest e ' + `, error code is ${e.code}, message is ${e.message}`); 758 expect(null).assertFail(); 759 } 760 done(); 761 }) 762 763 /** 764 * @tc.name SingleKvStoreSetSyncRangePromiseSameTest 765 * @tc.desc Test Js Api SingleKvStoreSetSyncRange with same range 766 * @tc.type: FUNC 767 * @tc.require: issueNumber 768 */ 769 it('SingleKvStoreSetSyncRangePromiseSameTest', 0, async function (done) { 770 console.info('SingleKvStoreSetSyncRangePromiseSameTest'); 771 try { 772 var localLabels = ['A', 'B']; 773 var remoteSupportLabels = ['A', 'B']; 774 await kvStore.setSyncRange(localLabels, remoteSupportLabels).then((err) => { 775 console.info('SingleKvStoreSetSyncRangePromiseSameTest setSyncRange success'); 776 expect(err == undefined).assertTrue(); 777 }).catch((err) => { 778 console.error('SingleKvStoreSetSyncRangePromiseSameTest delete fail ' + `, error code is ${err.code}, message is ${err.message}`); 779 expect(null).assertFail(); 780 }); 781 } catch (e) { 782 console.error('SingleKvStoreSetSyncRangePromiseSameTest e ' + `, error code is ${e.code}, message is ${e.message}`); 783 expect(null).assertFail(); 784 } 785 done(); 786 }) 787 788 /** 789 * @tc.name SingleKvStoreSetSyncRangePromiseInvalidArgsTest 790 * @tc.desc Test Js Api SingleKvStoreSetSyncRange with invalid args 791 * @tc.type: FUNC 792 * @tc.require: issueNumber 793 */ 794 it('SingleKvStoreSetSyncRangePromiseInvalidArgsTest', 0, async function (done) { 795 console.info('SingleKvStoreSetSyncRangePromiseSameTest'); 796 try { 797 var remoteSupportLabels = ['A', 'B']; 798 await kvStore.setSyncRange(remoteSupportLabels).then((err) => { 799 expect(null).assertFail(); 800 }).catch((err) => { 801 expect(null).assertFail(); 802 }); 803 } catch (e) { 804 console.error('SingleKvStoreSetSyncRangePromiseSameTest e ' + `, error code is ${e.code}, message is ${e.message}`); 805 expect(e.code == 401).assertTrue(); 806 } 807 done(); 808 }) 809 810 /** 811 * @tc.name SingleKvStorePutBatchPromiseStringTest 812 * @tc.desc Test Js Api SingleKvStore.PutBatch() with string value 813 * @tc.type: FUNC 814 * @tc.require: issueNumber 815 */ 816 it('SingleKvStorePutBatchPromiseStringTest', 0, async function (done) { 817 console.info('SingleKvStorePutBatchPromiseStringTest'); 818 try { 819 let entries = putBatchString(10, 'batch_test_string_key'); 820 console.info('SingleKvStorePutBatchPromiseStringTest entries: ' + JSON.stringify(entries)); 821 await kvStore.putBatch(entries).then(async (err) => { 822 console.info('SingleKvStorePutBatchPromiseStringTest putBatch success'); 823 expect(err == undefined).assertTrue(); 824 await kvStore.getEntries('batch_test_string_key').then((entrys) => { 825 console.info('SingleKvStorePutBatchPromiseStringTest getEntries success'); 826 console.info('SingleKvStorePutBatchPromiseStringTest ' + JSON.stringify(entries)); 827 expect(entrys.length == 10).assertTrue(); 828 expect(entrys[0].value.value == 'batch_test_string_value').assertTrue(); 829 }).catch((err) => { 830 console.error('SingleKvStorePutBatchPromiseStringTest getEntries fail ' + `, error code is ${err.code}, message is ${err.message}`); 831 expect(null).assertFail(); 832 }); 833 }).catch((err) => { 834 console.error('SingleKvStorePutBatchPromiseStringTest putBatch fail ' + `, error code is ${err.code}, message is ${err.message}`); 835 expect(null).assertFail(); 836 }); 837 } catch (e) { 838 console.error('SingleKvStorePutBatchPromiseStringTest e ' + `, error code is ${e.code}, message is ${e.message}`); 839 expect(null).assertFail(); 840 } 841 done(); 842 }) 843 844 /** 845 * @tc.name SingleKvStorePutBatchPromiseIntegerTest 846 * @tc.desc Test Js Api SingleKvStore.PutBatch() with integer value 847 * @tc.type: FUNC 848 * @tc.require: issueNumber 849 */ 850 it('SingleKvStorePutBatchPromiseIntegerTest', 0, async function (done) { 851 console.info('SingleKvStorePutBatchPromiseIntegerTest'); 852 try { 853 let entries = []; 854 for (var i = 0; i < 10; i++) { 855 var key = 'batch_test_number_key'; 856 var entry = { 857 key: key + i, 858 value: { 859 type: factory.ValueType.INTEGER, 860 value: 222 861 } 862 } 863 entries.push(entry); 864 } 865 console.info('SingleKvStorePutBatchPromiseIntegerTest entries: ' + JSON.stringify(entries)); 866 await kvStore.putBatch(entries).then(async (err) => { 867 console.info('SingleKvStorePutBatchPromiseIntegerTest putBatch success'); 868 expect(err == undefined).assertTrue(); 869 await kvStore.getEntries('batch_test_number_key').then((entrys) => { 870 console.info('SingleKvStorePutBatchPromiseIntegerTest getEntries success'); 871 expect(entrys.length == 10).assertTrue(); 872 expect(entrys[0].value.value == 222).assertTrue(); 873 }).catch((err) => { 874 console.error('SingleKvStorePutBatchPromiseIntegerTest getEntries fail ' + `, error code is ${err.code}, message is ${err.message}`); 875 expect(null).assertFail(); 876 }); 877 }).catch((err) => { 878 console.error('SingleKvStorePutBatchPromiseIntegerTest putBatch fail ' + `, error code is ${err.code}, message is ${err.message}`); 879 expect(null).assertFail(); 880 }); 881 } catch (e) { 882 console.error('SingleKvStorePutBatchPromiseIntegerTest e ' + `, error code is ${e.code}, message is ${e.message}`); 883 expect(null).assertFail(); 884 } 885 done(); 886 }) 887 888 /** 889 * @tc.name SingleKvStorePutBatchPromiseFloatTest 890 * @tc.desc Test Js Api SingleKvStore.PutBatch() with float value 891 * @tc.type: FUNC 892 * @tc.require: issueNumber 893 */ 894 it('SingleKvStorePutBatchPromiseFloatTest', 0, async function (done) { 895 console.info('SingleKvStorePutBatchPromiseFloatTest'); 896 try { 897 let entries = []; 898 for (var i = 0; i < 10; i++) { 899 var key = 'batch_test_number_key'; 900 var entry = { 901 key: key + i, 902 value: { 903 type: factory.ValueType.FLOAT, 904 value: 2.0 905 } 906 } 907 entries.push(entry); 908 } 909 console.info('SingleKvStorePutBatchPromiseFloatTest entries: ' + JSON.stringify(entries)); 910 await kvStore.putBatch(entries).then(async (err) => { 911 console.info('SingleKvStorePutBatchPromiseFloatTest putBatch success'); 912 expect(err == undefined).assertTrue(); 913 await kvStore.getEntries('batch_test_number_key').then((entrys) => { 914 console.info('SingleKvStorePutBatchPromiseFloatTest getEntries success'); 915 expect(entrys.length == 10).assertTrue(); 916 expect(entrys[0].value.value == 2.0).assertTrue(); 917 }).catch((err) => { 918 console.error('SingleKvStorePutBatchPromiseFloatTest getEntries fail ' + `, error code is ${err.code}, message is ${err.message}`); 919 expect(null).assertFail(); 920 }); 921 }).catch((err) => { 922 console.error('SingleKvStorePutBatchPromiseFloatTest putBatch fail ' + `, error code is ${err.code}, message is ${err.message}`); 923 expect(null).assertFail(); 924 }); 925 } catch (e) { 926 console.error('SingleKvStorePutBatchPromiseFloatTest e ' + `, error code is ${e.code}, message is ${e.message}`); 927 expect(null).assertFail(); 928 } 929 done(); 930 }) 931 932 /** 933 * @tc.name SingleKvStorePutBatchPromiseDoubleTest 934 * @tc.desc Test Js Api SingleKvStore.PutBatch() with double value 935 * @tc.type: FUNC 936 * @tc.require: issueNumber 937 */ 938 it('SingleKvStorePutBatchPromiseDoubleTest', 0, async function (done) { 939 console.info('SingleKvStorePutBatchPromiseDoubleTest'); 940 try { 941 let entries = []; 942 for (var i = 0; i < 10; i++) { 943 var key = 'batch_test_number_key'; 944 var entry = { 945 key: key + i, 946 value: { 947 type: factory.ValueType.DOUBLE, 948 value: 2.00 949 } 950 } 951 entries.push(entry); 952 } 953 console.info('SingleKvStorePutBatchPromiseDoubleTest entries: ' + JSON.stringify(entries)); 954 await kvStore.putBatch(entries).then(async (err) => { 955 console.info('SingleKvStorePutBatchPromiseDoubleTest putBatch success'); 956 expect(err == undefined).assertTrue(); 957 await kvStore.getEntries('batch_test_number_key').then((entrys) => { 958 console.info('SingleKvStorePutBatchPromiseDoubleTest getEntries success'); 959 expect(entrys.length == 10).assertTrue(); 960 expect(entrys[0].value.value == 2.00).assertTrue(); 961 }).catch((err) => { 962 console.error('SingleKvStorePutBatchPromiseDoubleTest getEntries fail ' + `, error code is ${err.code}, message is ${err.message}`); 963 expect(null).assertFail(); 964 }); 965 }).catch((err) => { 966 console.error('SingleKvStorePutBatchPromiseDoubleTest putBatch fail ' + `, error code is ${err.code}, message is ${err.message}`); 967 expect(null).assertFail(); 968 }); 969 } catch (e) { 970 console.error('SingleKvStorePutBatchPromiseDoubleTest e ' + `, error code is ${e.code}, message is ${e.message}`); 971 expect(null).assertFail(); 972 } 973 done(); 974 }) 975 976 /** 977 * @tc.name SingleKvStorePutBatchPromiseBooleanTest 978 * @tc.desc Test Js Api SingleKvStore.PutBatch() with boolean value 979 * @tc.type: FUNC 980 * @tc.require: issueNumber 981 */ 982 it('SingleKvStorePutBatchPromiseBooleanTest', 0, async function (done) { 983 console.info('SingleKvStorePutBatchPromiseBooleanTest'); 984 try { 985 var bo = false; 986 let entries = []; 987 for (var i = 0; i < 10; i++) { 988 var key = 'batch_test_bool_key'; 989 var entry = { 990 key: key + i, 991 value: { 992 type: factory.ValueType.BOOLEAN, 993 value: bo 994 } 995 } 996 entries.push(entry); 997 } 998 console.info('SingleKvStorePutBatchPromiseBooleanTest entries: ' + JSON.stringify(entries)); 999 await kvStore.putBatch(entries).then(async (err) => { 1000 console.info('SingleKvStorePutBatchPromiseBooleanTest putBatch success'); 1001 expect(err == undefined).assertTrue(); 1002 await kvStore.getEntries('batch_test_bool_key').then((entrys) => { 1003 console.info('SingleKvStorePutBatchPromiseBooleanTest getEntries success'); 1004 expect(entrys.length == 10).assertTrue(); 1005 expect(entrys[0].value.value == bo).assertTrue(); 1006 }).catch((err) => { 1007 console.error('SingleKvStorePutBatchPromiseBooleanTest getEntries fail ' + `, error code is ${err.code}, message is ${err.message}`); 1008 expect(null).assertFail(); 1009 }); 1010 }).catch((err) => { 1011 console.error('SingleKvStorePutBatchPromiseBooleanTest putBatch fail ' + `, error code is ${err.code}, message is ${err.message}`); 1012 expect(null).assertFail(); 1013 }); 1014 } catch (e) { 1015 console.error('SingleKvStorePutBatchPromiseBooleanTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1016 expect(null).assertFail(); 1017 } 1018 done(); 1019 }) 1020 1021 /** 1022 * @tc.name SingleKvStorePutBatchPromiseByteArrayTest 1023 * @tc.desc Test Js Api SingleKvStore.PutBatch() with byte array value 1024 * @tc.type: FUNC 1025 * @tc.require: issueNumber 1026 */ 1027 it('SingleKvStorePutBatchPromiseByteArrayTest', 0, async function (done) { 1028 console.info('SingleKvStorePutBatchPromiseByteArrayTest'); 1029 try { 1030 var arr = new Uint8Array([21, 31]); 1031 let entries = []; 1032 for (var i = 0; i < 10; i++) { 1033 var key = 'batch_test_bool_key'; 1034 var entry = { 1035 key: key + i, 1036 value: { 1037 type: factory.ValueType.BYTE_ARRAY, 1038 value: arr 1039 } 1040 } 1041 entries.push(entry); 1042 } 1043 console.info('SingleKvStorePutBatchPromiseByteArrayTest entries: ' + JSON.stringify(entries)); 1044 await kvStore.putBatch(entries).then(async (err) => { 1045 console.info('SingleKvStorePutBatchPromiseByteArrayTest putBatch success'); 1046 expect(err == undefined).assertTrue(); 1047 await kvStore.getEntries('batch_test_bool_key').then((entrys) => { 1048 console.info('SingleKvStorePutBatchPromiseByteArrayTest getEntries success'); 1049 expect(entrys.length == 10).assertTrue(); 1050 expect(entrys[0].value.value.toString() == arr.toString()).assertTrue(); 1051 }).catch((err) => { 1052 console.error('SingleKvStorePutBatchPromiseByteArrayTest getEntries fail ' + `, error code is ${err.code}, message is ${err.message}`); 1053 expect(null).assertFail(); 1054 }); 1055 }).catch((err) => { 1056 console.error('SingleKvStorePutBatchPromiseByteArrayTest putBatch fail ' + `, error code is ${err.code}, message is ${err.message}`); 1057 expect(null).assertFail(); 1058 }); 1059 } catch (e) { 1060 console.error('SingleKvStorePutBatchPromiseBooleanTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1061 expect(null).assertFail(); 1062 } 1063 done(); 1064 }) 1065 1066 /** 1067 * @tc.name SingleKvStorePutBatchValuePromiseUint8ArrayTest 1068 * @tc.desc Test Js Api SingleKvStore.PutBatch() put Uint8Array 1069 * @tc.type: FUNC 1070 * @tc.require: issueNumber 1071 */ 1072 it('SingleKvStorePutBatchValuePromiseUint8ArrayTest', 0, async function (done) { 1073 console.info('SingleKvStorePutBatchValuePromiseUint8ArrayTest'); 1074 try { 1075 let values = []; 1076 let arr1 = new Uint8Array([4, 5, 6, 7]); 1077 let arr2 = new Uint8Array([4, 5, 6, 7, 8]); 1078 let vb1 = {key: "name_1", value: arr1}; 1079 let vb2 = {key: "name_2", value: arr2}; 1080 values.push(vb1); 1081 values.push(vb2); 1082 console.info('SingleKvStorePutBatchValuePromiseUint8ArrayTest values: ' + JSON.stringify(values)); 1083 await kvStore.putBatch(values).then(async (err) => { 1084 console.info('SingleKvStorePutBatchValuePromiseUint8ArrayTest putBatch success'); 1085 expect(err == undefined).assertTrue(); 1086 var query = new factory.Query(); 1087 query.prefixKey("name_"); 1088 await kvStore.getEntries(query).then((entrys) => { 1089 expect(entrys.length == 2).assertTrue(); 1090 done(); 1091 }); 1092 }); 1093 } catch (e) { 1094 console.error('SingleKvStorePutBatchValuePromiseUint8ArrayTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1095 expect(null).assertFail(); 1096 done(); 1097 } 1098 }) 1099 1100 /** 1101 * @tc.name SingleKvStorePutBatchValuePromiseStringTest 1102 * @tc.desc Test Js Api SingleKvStore.PutBatch() put String 1103 * @tc.type: FUNC 1104 * @tc.require: issueNumber 1105 */ 1106 it('SingleKvStorePutBatchValuePromiseStringTest', 0, async function (done) { 1107 console.info('SingleKvStorePutBatchValuePromiseStringTest'); 1108 try { 1109 let values = []; 1110 let vb1 = {key: "name_1", value: "arr1"}; 1111 let vb2 = {key: "name_2", value: "arr2"}; 1112 values.push(vb1); 1113 values.push(vb2); 1114 console.info('SingleKvStorePutBatchValuePromiseStringTest values: ' + JSON.stringify(values)); 1115 await kvStore.putBatch(values).then(async (err) => { 1116 console.info('SingleKvStorePutBatchValuePromiseUint8ArrayTest putBatch success'); 1117 expect(err == undefined).assertTrue(); 1118 var query = new factory.Query(); 1119 query.prefixKey("name_"); 1120 await kvStore.getEntries(query).then((entrys) => { 1121 expect(entrys.length == 2).assertTrue(); 1122 done(); 1123 }).catch((err) => { 1124 console.log('SingleKvStorePutBatchValueTest delete fail ' + err); 1125 expect(null).assertFail(); 1126 }); 1127 }).catch((err) => { 1128 console.log('SingleKvStorePutBatchValueTest delete fail ' + err); 1129 expect(null).assertFail(); 1130 }); 1131 } catch (e) { 1132 console.error('SingleKvStorePutBatchValuePromiseStringTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1133 expect(null).assertFail(); 1134 } 1135 done(); 1136 }) 1137 1138 /** 1139 * @tc.name SingleKvStorePutBatchValuePromiseNumbersTest 1140 * @tc.desc Test Js Api SingleKvStore.PutBatch() put numbers 1141 * @tc.type: FUNC 1142 * @tc.require: issueNumber 1143 */ 1144 it('SingleKvStorePutBatchValuePromiseNumbersTest', 0, async function (done) { 1145 try { 1146 let values = []; 1147 let vb1 = {key: "name_1", value: 123}; 1148 let vb2 = {key: "name_2", value: 321.0}; 1149 let vb3 = {key: "name_3", value: 321.00}; 1150 values.push(vb1); 1151 values.push(vb2); 1152 values.push(vb3); 1153 await kvStore.putBatch(values).then(async (err) => { 1154 expect(err == undefined).assertTrue(); 1155 var query = new factory.Query(); 1156 query.prefixKey("name_"); 1157 await kvStore.getEntries(query).then((entrys) => { 1158 expect(entrys.length == 3).assertTrue(); 1159 done(); 1160 }); 1161 }); 1162 } catch (e) { 1163 console.error('SingleKvStorePutBatchValuePromiseTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1164 expect(null).assertFail(); 1165 done(); 1166 } 1167 }) 1168 1169 /** 1170 * @tc.name SingleKvStorePutBatchValuePromiseBooleanTest 1171 * @tc.desc Test Js Api SingleKvStore.PutBatch() put booleans 1172 * @tc.type: FUNC 1173 * @tc.require: issueNumber 1174 */ 1175 it('SingleKvStorePutBatchValuePromiseBooleanTest', 0, async function (done) { 1176 try { 1177 let values = []; 1178 let vb1 = {key: "name_1", value: true}; 1179 let vb2 = {key: "name_2", value: false}; 1180 values.push(vb1); 1181 values.push(vb2); 1182 await kvStore.putBatch(values).then(async (err) => { 1183 expect(err == undefined).assertTrue(); 1184 var query = new factory.Query(); 1185 query.prefixKey("name_"); 1186 await kvStore.getEntries(query).then((entrys) => { 1187 expect(entrys.length == 2).assertTrue(); 1188 done(); 1189 }); 1190 }); 1191 } catch (e) { 1192 console.error('SingleKvStorePutBatchValuePromiseTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1193 expect(null).assertFail(); 1194 done(); 1195 } 1196 }) 1197 1198 /** 1199 * @tc.name SingleKvStorePutBatchValuePromiseNullTest 1200 * @tc.desc Test Js Api SingleKvStore.PutBatch() put null 1201 * @tc.type: FUNC 1202 * @tc.require: issueNumber 1203 */ 1204 it('SingleKvStorePutBatchValuePromiseNullTest', 0, async function (done) { 1205 console.info('SingleKvStorePutBatchValuePromiseNullTest'); 1206 try { 1207 let values = []; 1208 let vb1 = {key: "name_1", value: null}; 1209 let vb2 = {key: "name_2", value: null}; 1210 values.push(vb1); 1211 values.push(vb2); 1212 console.info('SingleKvStorePutBatchValuePromiseNullTest values: ' + JSON.stringify(values)); 1213 await kvStore.putBatch(values).then(async (err) => { 1214 console.info('SingleKvStorePutBatchValuePromiseNullTest putBatch success'); 1215 expect(err == undefined).assertTrue(); 1216 var query = new factory.Query(); 1217 query.prefixKey("name_"); 1218 await kvStore.getEntries(query).then((entrys) => { 1219 expect(entrys.length == 2).assertTrue(); 1220 expect(entrys[0].value == null).assertTrue(); 1221 done(); 1222 }); 1223 }); 1224 } catch (e) { 1225 console.error('SingleKvStorePutBatchValuePromiseNullTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1226 expect(null).assertFail(); 1227 done(); 1228 } 1229 }) 1230 1231 /** 1232 * @tc.name SingleKvStorePutBatchValuePromiseInvalidArgsTest 1233 * @tc.desc Test Js Api SingleKvStore.PutBatch() put invalid args 1234 * @tc.type: FUNC 1235 * @tc.require: issueNumber 1236 */ 1237 it('SingleKvStorePutBatchValuePromiseInvalidArgsTest', 0, async function (done) { 1238 try { 1239 await kvStore.putBatch().then(() => { 1240 expect(null).assertFail(); 1241 }).catch((err) => { 1242 expect(null).assertFail(); 1243 }); 1244 } catch (e) { 1245 console.error('SingleKvStorePutBatchValuePromiseNullTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1246 expect(e.code == 401).assertTrue(); 1247 } 1248 done(); 1249 }) 1250 1251 /** 1252 * @tc.name SingleKvStorePutBatchValuePromiseClosedKvstoreTest 1253 * @tc.desc Test Js Api SingleKvStore.PutBatch() put into closed kvstore 1254 * @tc.type: FUNC 1255 * @tc.require: issueNumber 1256 */ 1257 it('SingleKvStorePutBatchValuePromiseClosedKvstoreTest', 0, async function (done) { 1258 try { 1259 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 1260 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 1261 expect(true).assertTrue(); 1262 }).catch((err) => { 1263 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 1264 }); 1265 }) 1266 let values = []; 1267 let vb1 = {key: "name_1", value: null}; 1268 let vb2 = {key: "name_2", value: null}; 1269 values.push(vb1); 1270 values.push(vb2); 1271 await kvStore.putBatch(values).then(() => { 1272 expect(null).assertFail(); 1273 }).catch((err) => { 1274 expect(err.code == 15100005).assertTrue(); 1275 }); 1276 } catch (e) { 1277 console.error('SingleKvStorePutBatchValuePromiseNullTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1278 expect(null).assertFail(); 1279 } 1280 done(); 1281 }) 1282 1283 /** 1284 * @tc.name SingleKvStoreDeleteBatchPromiseSucTest 1285 * @tc.desc Test Js Api SingleKvStoreDeleteBatch success 1286 * @tc.type: FUNC 1287 * @tc.require: issueNumber 1288 */ 1289 it('SingleKvStoreDeleteBatchPromiseSucTest', 0, async function (done) { 1290 console.info('SingleKvStoreDeleteBatchPromiseSucTest'); 1291 try { 1292 let entries = []; 1293 let keys = []; 1294 for (var i = 0; i < 5; i++) { 1295 var key = 'batch_test_string_key'; 1296 var entry = { 1297 key: key + i, 1298 value: { 1299 type: factory.ValueType.STRING, 1300 value: 'batch_test_string_value' 1301 } 1302 } 1303 entries.push(entry); 1304 keys.push(key + i); 1305 } 1306 await kvStore.putBatch(entries).then(async (err) => { 1307 expect(err == undefined).assertTrue(); 1308 await kvStore.deleteBatch(keys).then((err) => { 1309 expect(err == undefined).assertTrue(); 1310 }).catch((err) => { 1311 expect(null).assertFail(); 1312 }); 1313 }).catch((err) => { 1314 expect(null).assertFail(); 1315 }); 1316 } catch (e) { 1317 console.error('SingleKvStoreDeleteBatchPromiseSucTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1318 expect(null).assertFail(); 1319 } 1320 done(); 1321 }) 1322 1323 /** 1324 * @tc.name SingleKvStoreDeleteBatchPromiseInvalidArgsTest 1325 * @tc.desc Test Js Api SingleKvStoreDeleteBatch with invalid args 1326 * @tc.type: FUNC 1327 * @tc.require: issueNumber 1328 */ 1329 it('SingleKvStoreDeleteBatchPromiseInvalidArgsTest', 0, async function (done) { 1330 console.info('SingleKvStoreDeleteBatchPromiseInvalidArgsTest'); 1331 try { 1332 let entries = []; 1333 let keys = []; 1334 for (var i = 0; i < 5; i++) { 1335 var key = 'batch_test_string_key'; 1336 var entry = { 1337 key: key + i, 1338 value: { 1339 type: factory.ValueType.STRING, 1340 value: 'batch_test_string_value' 1341 } 1342 } 1343 entries.push(entry); 1344 keys.push(key + i); 1345 } 1346 await kvStore.putBatch(entries).then(async (err) => { 1347 expect(err == undefined).assertTrue(); 1348 await kvStore.deleteBatch(1).then((err) => { 1349 console.log("fail1") 1350 expect(null).assertFail(); 1351 }).catch((err) => { 1352 console.log("fail2") 1353 expect(null).assertFail(); 1354 }); 1355 }).catch((err) => { 1356 console.log("fail3") 1357 expect(err.code == 401).assertTrue(); 1358 }); 1359 } catch (e) { 1360 console.error('SingleKvStoreDeleteBatchPromiseInvalidArgsTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1361 expect(null).assertFail(); 1362 } 1363 done(); 1364 }) 1365 1366 /** 1367 * @tc.name SingleKvStoreDeleteBatchPromiseClosedKVStoreTest 1368 * @tc.desc Test Js Api SingleKvStoreDeleteBatch into closed kvstore 1369 * @tc.type: FUNC 1370 * @tc.require: issueNumber 1371 */ 1372 it('SingleKvStoreDeleteBatchPromiseClosedKVStoreTest', 0, async function (done) { 1373 console.info('SingleKvStoreDeleteBatchPromiseClosedKVStoreTest'); 1374 try { 1375 let entries = []; 1376 let keys = []; 1377 for (var i = 0; i < 5; i++) { 1378 var key = 'batch_test_string_key'; 1379 var entry = { 1380 key: key + i, 1381 value: { 1382 type: factory.ValueType.STRING, 1383 value: 'batch_test_string_value' 1384 } 1385 } 1386 entries.push(entry); 1387 keys.push(key + i); 1388 } 1389 await kvStore.putBatch(entries).then((err) => { 1390 expect(err == undefined).assertTrue(); 1391 }).catch((err) => { 1392 expect(null).assertFail(); 1393 }); 1394 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 1395 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 1396 expect(true).assertTrue(); 1397 }).catch((err) => { 1398 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 1399 }); 1400 }) 1401 kvStore.deleteBatch(keys).then((err) => { 1402 expect(null).assertFail(); 1403 }).catch((err) => { 1404 expect(null).assertFail(); 1405 expect(err.code == 15100005).assertTrue(); 1406 }); 1407 } catch (e) { 1408 console.error('SingleKvStoreDeleteBatchPromiseClosedKVStoreTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1409 expect(null).assertFail(); 1410 } 1411 done(); 1412 }) 1413 1414 /** 1415 * @tc.name SingleKvStoreGetEntriesPromiseQueryTest 1416 * @tc.desc Test Js Api SingleKvStore.GetEntries() with query 1417 * @tc.type: FUNC 1418 * @tc.require: issueNumber 1419 */ 1420 it('SingleKvStoreGetEntriesPromiseQueryTest', 0, async function (done) { 1421 console.info('SingleKvStoreGetEntriesPromiseQueryTest'); 1422 try { 1423 var arr = new Uint8Array([21, 31]); 1424 let entries = []; 1425 for (var i = 0; i < 10; i++) { 1426 var key = 'batch_test_bool_key'; 1427 var entry = { 1428 key: key + i, 1429 value: { 1430 type: factory.ValueType.BYTE_ARRAY, 1431 value: arr 1432 } 1433 } 1434 entries.push(entry); 1435 } 1436 console.info('SingleKvStoreGetEntriesPromiseQueryTest entries: ' + JSON.stringify(entries)); 1437 await kvStore.putBatch(entries).then(async (err) => { 1438 console.info('SingleKvStoreGetEntriesPromiseQueryTest putBatch success'); 1439 expect(err == undefined).assertTrue(); 1440 let query = new factory.Query(); 1441 query.prefixKey("batch_test"); 1442 await kvStore.getEntries(query).then((entrys) => { 1443 expect(entrys.length == 10).assertTrue(); 1444 expect(entrys[0].value.value.toString() == arr.toString()).assertTrue(); 1445 }).catch((err) => { 1446 console.log("errr1") 1447 expect(null).assertFail(); 1448 }); 1449 }).catch((err) => { 1450 console.log("errr2") 1451 expect(null).assertFail(); 1452 }); 1453 } catch (e) { 1454 console.error('SingleKvStoreGetEntriesPromiseQueryTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1455 console.log("errr3") 1456 expect(null).assertFail(); 1457 } 1458 done(); 1459 }) 1460 1461 /** 1462 * @tc.name SingleKvStoreGetEntriesPromiseQueryClosedKVStoreTest 1463 * @tc.desc Test Js Api SingleKvStore.GetEntries() query from a closed kvstore 1464 * @tc.type: FUNC 1465 * @tc.require: issueNumber 1466 */ 1467 it('SingleKvStoreGetEntriesPromiseQueryClosedKVStoreTest', 0, async function (done) { 1468 try { 1469 var arr = new Uint8Array([21, 31]); 1470 let entries = []; 1471 for (var i = 0; i < 10; i++) { 1472 var key = 'batch_test_bool_key'; 1473 var entry = { 1474 key: key + i, 1475 value: { 1476 type: factory.ValueType.BYTE_ARRAY, 1477 value: arr 1478 } 1479 } 1480 entries.push(entry); 1481 } 1482 await kvStore.putBatch(entries).then(async (err) => { 1483 expect(err == undefined).assertTrue(); 1484 }).catch((err) => { 1485 expect(null).assertFail(); 1486 }); 1487 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 1488 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 1489 expect(true).assertTrue(); 1490 }).catch((err) => { 1491 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 1492 }); 1493 }) 1494 let query = new factory.Query(); 1495 query.prefixKey("batch_test"); 1496 await kvStore.getEntries(query).then(() => { 1497 expect(null).assertFail(); 1498 }).catch((err) => { 1499 expect(err.code == 15100005).assertTrue(); 1500 }); 1501 } catch (e) { 1502 console.error('SingleKvStoreGetEntriesPromiseQueryClosedKVStoreTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1503 expect(null).assertFail(); 1504 } 1505 done(); 1506 }) 1507 1508 /** 1509 * @tc.name SingleKvStoreGetEntriesPromiseSucTest 1510 * @tc.desc Test Js Api SingleKvStore.GetEntries() success 1511 * @tc.type: FUNC 1512 * @tc.require: issueNumber 1513 */ 1514 it('SingleKvStoreGetEntriesPromiseSucTest', 0, async function (done) { 1515 console.info('SingleKvStoreGetEntriesPromiseSucTest'); 1516 try { 1517 var arr = new Uint8Array([21, 31]); 1518 let entries = []; 1519 for (var i = 0; i < 10; i++) { 1520 var key = 'batch_test_bool_key'; 1521 var entry = { 1522 key: key + i, 1523 value: { 1524 type: factory.ValueType.BYTE_ARRAY, 1525 value: arr 1526 } 1527 } 1528 entries.push(entry); 1529 } 1530 await kvStore.putBatch(entries).then(async (err) => { 1531 expect(err == undefined).assertTrue(); 1532 await kvStore.getEntries("batch_test").then((entrys) => { 1533 expect(entrys.length == 10).assertTrue(); 1534 expect(entrys[0].value.value.toString() == arr.toString()).assertTrue(); 1535 }).catch((err) => { 1536 console.log("faillll1" + `${err.code}`) 1537 expect(err == undefined).assertTrue(); 1538 }); 1539 }).catch((error) => { 1540 console.log("faillll2"`${error.code}`) 1541 expect(error == undefined).assertTrue(); 1542 }); 1543 } catch (e) { 1544 console.error('SingleKvStoreGetEntriesPromiseSucTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1545 expect(null).assertFail(); 1546 } 1547 done(); 1548 }) 1549 1550 /** 1551 * @tc.name SingleKvStoreGetEntriesPromiseClosedKVStoreTest 1552 * @tc.desc Test Js Api SingleKvStore.GetEntries() from a closed kvstore 1553 * @tc.type: FUNC 1554 * @tc.require: issueNumber 1555 */ 1556 it('SingleKvStoreGetEntriesPromiseClosedKVStoreTest', 0, async function (done) { 1557 try { 1558 var arr = new Uint8Array([21, 31]); 1559 let entries = []; 1560 for (var i = 0; i < 10; i++) { 1561 var key = 'batch_test_bool_key'; 1562 var entry = { 1563 key: key + i, 1564 value: { 1565 type: factory.ValueType.BYTE_ARRAY, 1566 value: arr 1567 } 1568 } 1569 entries.push(entry); 1570 } 1571 await kvStore.putBatch(entries).then(async (err) => { 1572 expect(err == undefined).assertTrue(); 1573 }).catch((err) => { 1574 expect(null).assertFail(); 1575 }); 1576 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 1577 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 1578 expect(true).assertTrue(); 1579 }).catch((err) => { 1580 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 1581 }); 1582 }) 1583 await kvStore.getEntries("batch_test").then(() => { 1584 expect(null).assertFail(); 1585 }).catch((err) => { 1586 expect(err.code == 15100005).assertTrue(); 1587 }); 1588 } catch (e) { 1589 console.error('SingleKvStoreGetEntriesPromiseSucTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1590 expect(null).assertFail(); 1591 } 1592 done(); 1593 }) 1594 1595 /** 1596 * @tc.name SingleKvStoreGetEntriesPromiseInvalidArgsTest 1597 * @tc.desc Test Js Api SingleKvStore.GetEntries() with invalid args 1598 * @tc.type: FUNC 1599 * @tc.require: issueNumber 1600 */ 1601 it('SingleKvStoreGetEntriesPromiseInvalidArgsTest', 0, async function (done) { 1602 console.info('SingleKvStoreGetEntriesPromiseInvalidArgsTest'); 1603 try { 1604 var arr = new Uint8Array([21, 31]); 1605 let entries = []; 1606 for (var i = 0; i < 10; i++) { 1607 var key = 'batch_test_bool_key'; 1608 var entry = { 1609 key: key + i, 1610 value: { 1611 type: factory.ValueType.BYTE_ARRAY, 1612 value: arr 1613 } 1614 } 1615 entries.push(entry); 1616 } 1617 await kvStore.putBatch(entries).then(async (err) => { 1618 expect(err == undefined).assertTrue(); 1619 await kvStore.getEntries().then(() => { 1620 expect(null).assertFail(); 1621 }).catch((err) => { 1622 expect(null).assertFail(); 1623 }); 1624 }).catch((err) => { 1625 expect(err.code == 401).assertTrue(); 1626 }); 1627 } catch (e) { 1628 console.error('SingleKvStoreGetEntriesPromiseInvalidArgsTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1629 expect(null).assertFail(); 1630 } 1631 done(); 1632 }) 1633 1634 /** 1635 * @tc.name SingleKvStorestartTransactionPromiseCommitTest 1636 * @tc.desc Test Js Api SingleKvStorestartTransaction with commit 1637 * @tc.type: FUNC 1638 * @tc.require: issueNumber 1639 */ 1640 it('SingleKvStorestartTransactionPromiseCommitTest', 0, async function (done) { 1641 console.info('SingleKvStorestartTransactionPromiseCommitTest'); 1642 try { 1643 var count = 0; 1644 kvStore.on('dataChange', factory.SubscribeType.SUBSCRIBE_TYPE_ALL, function (data) { 1645 count++; 1646 }); 1647 await kvStore.startTransaction().then(async (err) => { 1648 expect(err == undefined).assertTrue(); 1649 }).catch((err) => { 1650 expect(null).assertFail(); 1651 }); 1652 let entries = putBatchString(10, 'batch_test_string_key'); 1653 await kvStore.putBatch(entries).then(async (err) => { 1654 expect(err == undefined).assertTrue(); 1655 }).catch((err) => { 1656 expect(null).assertFail(); 1657 }); 1658 let keys = Object.keys(entries).slice(5); 1659 await kvStore.deleteBatch(keys).then((err) => { 1660 expect(err == undefined).assertTrue(); 1661 }).catch((err) => { 1662 expect(null).assertFail(); 1663 }); 1664 await kvStore.commit().then(async (err) => { 1665 expect(err == undefined).assertTrue(); 1666 }).catch((err) => { 1667 expect(null).assertFail(); 1668 }); 1669 await sleep(2000); 1670 expect(count == 1).assertTrue(); 1671 } catch (e) { 1672 expect(null).assertFail(); 1673 } 1674 done(); 1675 }) 1676 1677 /** 1678 * @tc.name SingleKvStorestartTransactionPromiseRollbackTest 1679 * @tc.desc Test Js Api SingleKvStorestartTransaction with Rollback 1680 * @tc.type: FUNC 1681 * @tc.require: issueNumber 1682 */ 1683 it('SingleKvStorestartTransactionPromiseRollbackTest', 0, async function (done) { 1684 console.info('SingleKvStorestartTransactionPromiseRollbackTest'); 1685 try { 1686 var count = 0; 1687 kvStore.on('dataChange', 0, function (data) { 1688 console.info('SingleKvStorestartTransactionPromiseRollbackTest ' + JSON.stringify(data)); 1689 count++; 1690 }); 1691 await kvStore.startTransaction().then(async (err) => { 1692 expect(err == undefined).assertTrue(); 1693 }).catch((err) => { 1694 expect(null).assertFail(); 1695 }); 1696 let entries = putBatchString(10, 'batch_test_string_key'); 1697 await kvStore.putBatch(entries).then(async (err) => { 1698 expect(err == undefined).assertTrue(); 1699 }).catch((err) => { 1700 expect(null).assertFail(); 1701 }); 1702 let keys = Object.keys(entries).slice(5); 1703 await kvStore.deleteBatch(keys).then((err) => { 1704 expect(err == undefined).assertTrue(); 1705 }).catch((err) => { 1706 expect(null).assertFail(); 1707 }); 1708 await kvStore.rollback().then(async (err) => { 1709 expect(err == undefined).assertTrue(); 1710 }).catch((err) => { 1711 expect(null).assertFail(); 1712 }); 1713 await sleep(2000); 1714 expect(count == 0).assertTrue(); 1715 } catch (e) { 1716 expect(null).assertFail(); 1717 } 1718 done(); 1719 }) 1720 1721 /** 1722 * @tc.name SingleKvStorestartTransactionPromiseClosedKVStoreTest 1723 * @tc.desc Test Js Api SingleKvStorestartTransaction with a closed kvstore 1724 * @tc.type: FUNC 1725 * @tc.require: issueNumber 1726 */ 1727 it('SingleKvStorestartTransactionPromiseClosedKVStoreTest', 0, async function (done) { 1728 try { 1729 var count = 0; 1730 kvStore.on('dataChange', 0, function (data) { 1731 count++; 1732 }); 1733 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 1734 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 1735 expect(true).assertTrue(); 1736 }).catch((err) => { 1737 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 1738 }); 1739 }) 1740 await kvStore.startTransaction().then(async (err) => { 1741 expect(null).assertFail(); 1742 }).catch((err) => { 1743 expect(err.code == 15100005).assertTrue(); 1744 }); 1745 1746 } catch (e) { 1747 expect(null).assertFail(); 1748 } 1749 done(); 1750 }) 1751 1752 /** 1753 * @tc.name SingleKvStorestartTransactionPromiseInvalidArgsTest 1754 * @tc.desc Test Js Api SingleKvStorestartTransaction with invalid args 1755 * @tc.type: FUNC 1756 * @tc.require: issueNumber 1757 */ 1758 it('SingleKvStorestartTransactionPromiseInvalidArgsTest', 0, async function (done) { 1759 console.info('SingleKvStorestartTransactionPromiseRollbackTest'); 1760 try { 1761 await kvStore.startTransaction(1).then(async (err) => { 1762 expect(null).assertFail(); 1763 }).catch((err) => { 1764 expect(true).assertTrue(); 1765 }); 1766 } catch (e) { 1767 expect(null).assertFail(); 1768 } 1769 done(); 1770 }) 1771 1772 /** 1773 * @tc.name SingleKvStoreCommitPromiseClosedKVStoreTest 1774 * @tc.desc Test Js Api SingleKvStoreCommit with a closed kvstore 1775 * @tc.type: FUNC 1776 * @tc.require: issueNumber 1777 */ 1778 it('SingleKvStoreCommitPromiseClosedKVStoreTest', 0, async function (done) { 1779 console.info('SingleKvStoreCommitPromiseClosedKVStoreTest'); 1780 try { 1781 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 1782 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 1783 expect(true).assertTrue(); 1784 }).catch((err) => { 1785 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 1786 }); 1787 }) 1788 await kvStore.commit().then(async (err) => { 1789 expect(null).assertFail(); 1790 }).catch((err) => { 1791 expect(err.code == 15100005).assertTrue(); 1792 }); 1793 } catch (e) { 1794 expect(null).assertFail(); 1795 } 1796 done(); 1797 }) 1798 1799 /** 1800 * @tc.name SingleKvStoreRollbackPromiseClosedKVStoreTest 1801 * @tc.desc Test Js Api SingleKvStoreRollback with a closed kvstore 1802 * @tc.type: FUNC 1803 * @tc.require: issueNumber 1804 */ 1805 it('SingleKvStoreRollbackPromiseClosedKVStoreTest', 0, async function (done) { 1806 try { 1807 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 1808 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 1809 expect(true).assertTrue(); 1810 }).catch((err) => { 1811 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 1812 }); 1813 }) 1814 await kvStore.rollback().then(async (err) => { 1815 expect(null).assertFail(); 1816 }).catch((err) => { 1817 expect(err.code == 15100005).assertTrue(); 1818 }); 1819 } catch (e) { 1820 expect(null).assertFail(); 1821 } 1822 done(); 1823 }) 1824 1825 /** 1826 * @tc.name SingleKvStoreEnableSyncPromiseTrueTest 1827 * @tc.desc Test Js Api SingleKvStoreEnableSync true 1828 * @tc.type: FUNC 1829 * @tc.require: issueNumber 1830 */ 1831 it('SingleKvStoreEnableSyncPromiseTrueTest', 0, async function (done) { 1832 try { 1833 await kvStore.enableSync(true).then((err) => { 1834 expect(err == undefined).assertTrue(); 1835 }).catch((err) => { 1836 expect(null).assertFail(); 1837 }); 1838 } catch (e) { 1839 expect(null).assertFail(); 1840 } 1841 done(); 1842 }) 1843 1844 /** 1845 * @tc.name SingleKvStoreEnableSyncPromiseFalseTest 1846 * @tc.desc Test Js Api SingleKvStoreEnableSync false 1847 * @tc.type: FUNC 1848 * @tc.require: issueNumber 1849 */ 1850 it('SingleKvStoreEnableSyncPromiseFalseTest', 0, async function (done) { 1851 console.info('SingleKvStoreEnableSyncPromiseFalseTest'); 1852 try { 1853 await kvStore.enableSync(false).then((err) => { 1854 expect(err == undefined).assertTrue(); 1855 }).catch((err) => { 1856 expect(null).assertFail(); 1857 }); 1858 } catch (e) { 1859 expect(null).assertFail(); 1860 } 1861 done(); 1862 }) 1863 1864 /** 1865 * @tc.name SingleKvStoreEnableSyncPromiseInvalidArgsTest 1866 * @tc.desc Test Js Api SingleKvStoreEnableSync with invalid args 1867 * @tc.type: FUNC 1868 * @tc.require: issueNumber 1869 */ 1870 it('SingleKvStoreEnableSyncPromiseInvalidArgsTest', 0, async function (done) { 1871 try { 1872 await kvStore.enableSync().then((err) => { 1873 expect(null).assertFail(); 1874 }).catch((err) => { 1875 expect(null).assertFail(); 1876 }); 1877 } catch (e) { 1878 expect(e.code == 401).assertTrue(); 1879 } 1880 done(); 1881 }) 1882 1883 /** 1884 * @tc.name SingleKvStoreSetSyncRangePromiseSameTest 1885 * @tc.desc Test Js Api SingleKvStore.SetSyncRange() with same range 1886 * @tc.type: FUNC 1887 * @tc.require: issueNumber 1888 */ 1889 it('SingleKvStoreSetSyncRangePromiseSameTest', 0, async function (done) { 1890 try { 1891 var localLabels = ['A', 'B']; 1892 var remoteSupportLabels = ['A', 'B']; 1893 await kvStore.setSyncRange(localLabels, remoteSupportLabels).then((err) => { 1894 expect(err == undefined).assertTrue(); 1895 }).catch((err) => { 1896 expect(null).assertFail(); 1897 }); 1898 } catch (e) { 1899 expect(null).assertFail(); 1900 } 1901 done(); 1902 }) 1903 1904 /** 1905 * @tc.name SingleKvStoreSetSyncRangePromiseSameTest 1906 * @tc.desc Test Js Api SingleKvStore.SetSyncRange() with invalid args 1907 * @tc.type: FUNC 1908 * @tc.require: issueNumber 1909 */ 1910 it('SingleKvStoreSetSyncRangePromiseSameTest', 0, async function (done) { 1911 try { 1912 await kvStore.setSyncRange().then((err) => { 1913 expect(null).assertFail(); 1914 }).catch((err) => { 1915 expect(null).assertFail(); 1916 }); 1917 } catch (e) { 1918 expect(e.code == 401).assertTrue(); 1919 } 1920 done(); 1921 }) 1922 1923 /** 1924 * @tc.name SingleKvStoreRemoveDeviceDataPromiseInvalidArgsTest 1925 * @tc.desc Test Js Api SingleKvStoreRemoveDeviceData with invalid args 1926 * @tc.type: FUNC 1927 * @tc.require: issueNumber 1928 */ 1929 it('SingleKvStoreRemoveDeviceDataPromiseInvalidArgsTest', 0, async function (done) { 1930 console.info('SingleKvStoreRemoveDeviceDataPromiseInvalidArgsTest'); 1931 try { 1932 await kvStore.removeDeviceData().then((err) => { 1933 console.info('SingleKvStoreRemoveDeviceDataPromiseInvalidArgsTest removeDeviceData success'); 1934 expect(null).assertFail(); 1935 }).catch((err) => { 1936 console.error('SingleKvStoreRemoveDeviceDataPromiseInvalidArgsTest removeDeviceData fail ' + `, error code is ${err.code}, message is ${err.message}`); 1937 expect(null).assertFail(); 1938 }); 1939 } catch (e) { 1940 console.error('SingleKvStoreRemoveDeviceDataPromiseInvalidArgsTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1941 expect(e.code == 401).assertTrue(); 1942 } 1943 done(); 1944 }) 1945 1946 /** 1947 * @tc.name SingleKvStoreRemoveDeviceDataPromiseClosedKVStoreTest 1948 * @tc.desc Test Js Api SingleKvStoreRemoveDeviceData in a closed kvstore 1949 * @tc.type: FUNC 1950 * @tc.require: issueNumber 1951 */ 1952 it('SingleKvStoreRemoveDeviceDataPromiseClosedKVStoreTest', 0, async function (done) { 1953 try { 1954 await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then((err) => { 1955 expect(err == undefined).assertTrue(); 1956 }).catch((err) => { 1957 expect(null).assertFail(); 1958 }); 1959 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 1960 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 1961 expect(true).assertTrue(); 1962 }).catch((err) => { 1963 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 1964 expect(null).assertFail(); 1965 }); 1966 }) 1967 var deviceid = 'no_exist_device_id'; 1968 await kvStore.removeDeviceData(deviceid).then(() => { 1969 expect(null).assertFail(); 1970 }).catch((err) => { 1971 expect(err.code == 15100005).assertTrue(); 1972 }); 1973 1974 } catch (e) { 1975 console.error('SingleKvStoreRemoveDeviceDataPromiseClosedKVStoreTest e ' + `, error code is ${e.code}, message is ${e.message}`); 1976 expect(null).assertFail(); 1977 } 1978 done(); 1979 }) 1980 1981 /** 1982 * @tc.name SingleKvStoreSetSyncParamPromiseSucTest 1983 * @tc.desc Test Js Api SingleKvStoreSetSyncParam success 1984 * @tc.type: FUNC 1985 * @tc.require: issueNumber 1986 */ 1987 it('SingleKvStoreSetSyncParamPromiseSucTest', 0, async function (done) { 1988 try { 1989 var defaultAllowedDelayMs = 500; 1990 await kvStore.setSyncParam(defaultAllowedDelayMs).then((err) => { 1991 expect(err == undefined).assertTrue(); 1992 }).catch((err) => { 1993 expect(null).assertFail(); 1994 }); 1995 } catch (e) { 1996 expect(null).assertFail(); 1997 } 1998 done(); 1999 }) 2000 2001 /** 2002 * @tc.name SingleKvStoreSetSyncParamPromiseInvalidArgsTest 2003 * @tc.desc Test Js Api SingleKvStoreSetSyncParam with invalid args 2004 * @tc.type: FUNC 2005 * @tc.require: issueNumber 2006 */ 2007 it('SingleKvStoreSetSyncParamPromiseInvalidArgsTest', 0, async function (done) { 2008 console.info('SingleKvStoreSetSyncParamPromiseInvalidArgsTest'); 2009 try { 2010 await kvStore.setSyncParam().then((err) => { 2011 expect(null).assertFail(); 2012 }).catch((err) => { 2013 expect(null).assertFail(); 2014 }); 2015 } catch (e) { 2016 console.error('SingleKvStoreSetSyncParamPromiseInvalidArgsTest e ' + `, error code is ${e.code}, message is ${e.message}`); 2017 expect(e.code == 401).assertTrue(); 2018 } 2019 done(); 2020 }) 2021 2022 /** 2023 * @tc.name SingleKvStoreGetSecurityLevelPromiseSucTest 2024 * @tc.desc Test Js Api SingleKvStoreGetSecurityLevel success 2025 * @tc.type: FUNC 2026 * @tc.require: issueNumber 2027 */ 2028 it('SingleKvStoreGetSecurityLevelPromiseSucTest', 0, async function (done) { 2029 console.info('SingleKvStoreGetSecurityLevelPromiseSucTest'); 2030 try { 2031 await kvStore.getSecurityLevel().then((data) => { 2032 expect(data == factory.SecurityLevel.S2).assertTrue(); 2033 }).catch((err) => { 2034 expect(null).assertFail(); 2035 }); 2036 } catch (e) { 2037 expect(null).assertFail(); 2038 } 2039 done(); 2040 }) 2041 2042 /** 2043 * @tc.name SingleKvStoreGetSecurityLevelPromiseClosedKvStoreTest 2044 * @tc.desc Test Js Api SingleKvStoreGetSecurityLevel from a closed kvstore 2045 * @tc.type: FUNC 2046 * @tc.require: issueNumber 2047 */ 2048 it('SingleKvStoreGetSecurityLevelPromiseSucTest', 0, async function (done) { 2049 console.info('SingleKvStoreGetSecurityLevelPromiseSucTest'); 2050 try { 2051 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 2052 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 2053 expect(true).assertTrue(); 2054 }).catch((err) => { 2055 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 2056 }); 2057 }) 2058 await kvStore.getSecurityLevel().then((data) => { 2059 expect(null).assertFail(); 2060 }).catch((err) => { 2061 console.error('SingleKvStoreGetSecurityLevelPromiseSucTest getSecurityLevel fail ' + `, error code is ${err.code}, message is ${err.message}`); 2062 expect(err.code == 15100005).assertTrue(); 2063 }); 2064 } catch (e) { 2065 console.error('SingleKvStoreGetSecurityLevelPromiseSucTest e ' + `, error code is ${e.code}, message is ${e.message}`); 2066 expect(null).assertFail(); 2067 } 2068 done(); 2069 }) 2070 2071 /** 2072 * @tc.name SingleKvStoreGetResultSetPromiseSucTest 2073 * @tc.desc Test Js Api SingleKvStoreGetResultSet success 2074 * @tc.type: FUNC 2075 * @tc.require: issueNumber 2076 */ 2077 it('SingleKvStoreGetResultSetPromiseSucTest', 0, async function (done) { 2078 console.info('SingleKvStoreGetResultSetPromiseSucTest'); 2079 try { 2080 let resultSet; 2081 let entries = []; 2082 for (var i = 0; i < 10; i++) { 2083 var key = 'batch_test_string_key'; 2084 var entry = { 2085 key: key + i, 2086 value: { 2087 type: factory.ValueType.STRING, 2088 value: 'batch_test_string_value' 2089 } 2090 } 2091 entries.push(entry); 2092 } 2093 await kvStore.putBatch(entries).then(async (err) => { 2094 expect(err == undefined).assertTrue(); 2095 }).catch((err) => { 2096 expect(null).assertFail(); 2097 }); 2098 await kvStore.getResultSet('batch_test_string_key').then((result) => { 2099 resultSet = result; 2100 expect(resultSet.getCount() == 10).assertTrue(); 2101 }).catch((err) => { 2102 expect(null).assertFail(); 2103 }); 2104 await kvStore.closeResultSet(resultSet).then((err) => { 2105 expect(err == undefined).assertTrue(); 2106 }).catch((err) => { 2107 expect(null).assertFail(); 2108 }); 2109 } catch (e) { 2110 console.error('SingleKvStoreGetResultSetPromiseSucTest e ' + `, error code is ${e.code}, message is ${e.message}`); 2111 expect(null).assertFail(); 2112 } 2113 done(); 2114 }) 2115 2116 /** 2117 * @tc.name SingleKvStoreGetResultSetPromiseInvalidArgsTest 2118 * @tc.desc Test Js Api SingleKvStoreGetResultSet with invalid args 2119 * @tc.type: FUNC 2120 * @tc.require: issueNumber 2121 */ 2122 it('SingleKvStoreGetResultSetPromiseInvalidArgsTest', 0, async function (done) { 2123 console.info('SingleKvStoreGetResultSetPromiseInvalidArgsTest'); 2124 try { 2125 let resultSet; 2126 await kvStore.getResultSet().then((result) => { 2127 console.info('SingleKvStoreGetResultSetPromiseInvalidArgsTest getResultSet success'); 2128 expect(null).assertFail(); 2129 }).catch((err) => { 2130 console.error('SingleKvStoreGetResultSetPromiseInvalidArgsTest getResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`); 2131 expect(null).assertFail(); 2132 }); 2133 } catch (e) { 2134 console.error('SingleKvStoreGetResultSetPromiseInvalidArgsTest e ' + `, error code is ${e.code}, message is ${e.message}`); 2135 expect(e.code == 401).assertTrue(); 2136 } 2137 done(); 2138 }) 2139 2140 /** 2141 * @tc.name SingleKvStoreGetResultSetPromiseClosedKVStoreTest 2142 * @tc.desc Test Js Api SingleKvStoreGetResultSet from a closed kvstore 2143 * @tc.type: FUNC 2144 * @tc.require: issueNumber 2145 */ 2146 it('SingleKvStoreGetResultSetPromiseClosedKVStoreTest', 0, async function (done) { 2147 try { 2148 let resultSet; 2149 let entries = []; 2150 await kvStore.putBatch(entries).then(async (err) => { 2151 expect(err == undefined).assertTrue(); 2152 }).catch((err) => { 2153 expect(null).assertFail(); 2154 }); 2155 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 2156 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 2157 expect(true).assertTrue(); 2158 }).catch((err) => { 2159 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 2160 }); 2161 }); 2162 await kvStore.getResultSet('batch_test_string_key').then((result) => { 2163 expect(null).assertFail(); 2164 }).catch((err) => { 2165 console.error('SingleKvStoreGetResultSetPromiseClosedKVStoreTest getResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`); 2166 expect(err.code == 15100005).assertTrue(); 2167 }); 2168 } catch (e) { 2169 console.error('SingleKvStoreGetResultSetPromiseClosedKVStoreTest e ' + `, error code is ${e.code}, message is ${e.message}`); 2170 expect(null).assertFail(); 2171 } 2172 done(); 2173 }) 2174 2175 /** 2176 * @tc.name SingleKvStoreGetResultSetPromiseQueryTest 2177 * @tc.desc Test Js Api SingleKvStoreGetResultSet with query 2178 * @tc.type: FUNC 2179 * @tc.require: issueNumber 2180 */ 2181 it('SingleKvStoreGetResultSetPromiseQueryTest', 0, async function (done) { 2182 console.info('SingleKvStoreGetResultSetPromiseQueryTest'); 2183 try { 2184 let resultSet; 2185 let entries = []; 2186 for (var i = 0; i < 10; i++) { 2187 var key = 'batch_test_string_key'; 2188 var entry = { 2189 key: key + i, 2190 value: { 2191 type: factory.ValueType.STRING, 2192 value: 'batch_test_string_value' 2193 } 2194 } 2195 entries.push(entry); 2196 } 2197 await kvStore.putBatch(entries).then(async (err) => { 2198 console.info('SingleKvStoreGetResultSetPromiseQueryTest putBatch success'); 2199 expect(err == undefined).assertTrue(); 2200 }).catch((err) => { 2201 console.error('SingleKvStorePutBatchPromiseStringTest putBatch fail ' + `, error code is ${err.code}, message is ${err.message}`); 2202 expect(null).assertFail(); 2203 }); 2204 var query = new factory.Query(); 2205 query.prefixKey("batch_test"); 2206 await kvStore.getResultSet(query).then((result) => { 2207 console.info('SingleKvStoreGetResultSetPromiseQueryTest getResultSet success'); 2208 resultSet = result; 2209 expect(resultSet.getCount() == 10).assertTrue(); 2210 }).catch((err) => { 2211 console.error('SingleKvStoreGetResultSetPromiseQueryTest getResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`); 2212 expect(null).assertFail(); 2213 }); 2214 await kvStore.closeResultSet(resultSet).then((err) => { 2215 console.info('SingleKvStoreGetResultSetPromiseQueryTest closeResultSet success'); 2216 expect(err == undefined).assertTrue(); 2217 }).catch((err) => { 2218 console.error('SingleKvStoreGetResultSetPromiseQueryTest closeResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`); 2219 expect(null).assertFail(); 2220 }); 2221 } catch (e) { 2222 console.error('SingleKvStoreGetResultSetPromiseQueryTest e ' + `, error code is ${e.code}, message is ${e.message}`); 2223 expect(null).assertFail(); 2224 } 2225 done(); 2226 }) 2227 2228 /** 2229 * @tc.name SingleKvStoreGetResultSetQueryPromiseClosedKVStoreTest 2230 * @tc.desc Test Js Api SingleKvStoreGetResultSet query from a closed kvstore 2231 * @tc.type: FUNC 2232 * @tc.require: issueNumber 2233 */ 2234 it('SingleKvStoreGetResultSetQueryPromiseClosedKVStoreTest', 0, async function (done) { 2235 try { 2236 let resultSet; 2237 let entries = []; 2238 for (var i = 0; i < 10; i++) { 2239 var key = 'batch_test_string_key'; 2240 var entry = { 2241 key: key + i, 2242 value: { 2243 type: factory.ValueType.STRING, 2244 value: 'batch_test_string_value' 2245 } 2246 } 2247 entries.push(entry); 2248 } 2249 await kvStore.putBatch(entries).then(async (err) => { 2250 expect(err == undefined).assertTrue(); 2251 }).catch((err) => { 2252 expect(null).assertFail(); 2253 }); 2254 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 2255 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 2256 expect(true).assertTrue(); 2257 }).catch((err) => { 2258 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 2259 }); 2260 }); 2261 var query = new factory.Query(); 2262 query.prefixKey("batch_test"); 2263 await kvStore.getResultSet(query).then((result) => { 2264 expect(null).assertFail(); 2265 }).catch((err) => { 2266 expect(err.code == 15100005).assertTrue(); 2267 }); 2268 } catch (e) { 2269 console.error('SingleKvStoreGetResultSetQueryPromiseClosedKVStoreTest e ' + `, error code is ${e.code}, message is ${e.message}`); 2270 expect(null).assertFail(); 2271 } 2272 done(); 2273 }) 2274 2275 /** 2276 * @tc.name SingleKvStoreGetResultSetPredicatesPromiseSucTest 2277 * @tc.desc Test Js Api SingleKvStore.GetResultSet() with predicates success 2278 * @tc.type: FUNC 2279 * @tc.require: issueNumber 2280 */ 2281 it('SingleKvStoreGetResultSetPredicatesPromiseSucTest', 0, async function (done) { 2282 console.log('SingleKvStoreGetResultSetPredicatesPromiseSucTest'); 2283 try { 2284 let entries = []; 2285 let resultSet; 2286 for (let i = 0; i < 10; i++) { 2287 let key = 'name_'; 2288 let value = 'Bob_' 2289 let entry = { 2290 key: key + i, 2291 value: { 2292 type: factory.ValueType.STRING, 2293 value: value + i 2294 } 2295 } 2296 entries.push(entry); 2297 } 2298 await kvStore.putBatch(entries).then(async (err) => { 2299 expect(err == undefined).assertTrue(); 2300 }).catch((err) => { 2301 expect(null).assertFail(); 2302 }); 2303 let predicates = new dataShare.DataSharePredicates(); 2304 predicates.prefixKey("name_"); 2305 await kvStore.getResultSet(predicates).then((result) => { 2306 resultSet = result; 2307 expect(resultSet.getCount() == 10).assertTrue(); 2308 }).catch((err) => { 2309 expect(null).assertFail(); 2310 }); 2311 await kvStore.closeResultSet(resultSet).then((err) => { 2312 expect(err == undefined).assertTrue(); 2313 }).catch((err) => { 2314 expect(null).assertFail(); 2315 }); 2316 } catch (e) { 2317 expect(null).assertFail(); 2318 } 2319 done(); 2320 }) 2321 2322 /** 2323 * @tc.name SingleKvStoreGetResultSetPredicatesPromiseClosedKVStoreTest 2324 * @tc.desc Test Js Api SingleKvStoreGetResultSet predicates from a closed kvstore 2325 * @tc.type: FUNC 2326 * @tc.require: issueNumber 2327 */ 2328 it('SingleKvStoreGetResultSetPredicatesPromiseClosedKVStoreTest', 0, async function (done) { 2329 try { 2330 let resultSet; 2331 let entries = []; 2332 for (var i = 0; i < 10; i++) { 2333 var key = 'batch_test_string_key'; 2334 var entry = { 2335 key: key + i, 2336 value: { 2337 type: factory.ValueType.STRING, 2338 value: 'batch_test_string_value' 2339 } 2340 } 2341 entries.push(entry); 2342 } 2343 await kvStore.putBatch(entries).then(async (err) => { 2344 expect(err == undefined).assertTrue(); 2345 }).catch((err) => { 2346 expect(null).assertFail(); 2347 }); 2348 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 2349 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 2350 expect(true).assertTrue(); 2351 }).catch((err) => { 2352 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 2353 }); 2354 }); 2355 let predicates = new dataShare.DataSharePredicates(); 2356 predicates.prefixKey("batch_test"); 2357 await kvStore.getResultSet(predicates).then((result) => { 2358 expect(null).assertFail(); 2359 }).catch((err) => { 2360 expect(err.code == 15100005).assertTrue(); 2361 }); 2362 } catch (e) { 2363 console.error('SingleKvStoreGetResultSetPredicatesPromiseClosedKVStoreTest e ' + `, error code is ${e.code}, message is ${e.message}`); 2364 expect(null).assertFail(); 2365 } 2366 done(); 2367 }) 2368 2369 /** 2370 * @tc.name SingleKvStoreCloseResultSetPromiseSucTest 2371 * @tc.desc Test Js Api SingleKvStoreCloseResultSet success 2372 * @tc.type: FUNC 2373 * @tc.require: issueNumber 2374 */ 2375 it('SingleKvStoreCloseResultSetPromiseSucTest', 0, async function (done) { 2376 console.info('SingleKvStoreCloseResultSetPromiseSucTest'); 2377 try { 2378 console.info('SingleKvStoreCloseResultSetPromiseSucTest success'); 2379 let resultSet = null; 2380 await kvStore.getResultSet('batch_test_string_key').then((result) => { 2381 console.info('SingleKvStoreCloseResultSetPromiseSucTest getResultSet success'); 2382 resultSet = result; 2383 }).catch((err) => { 2384 console.error('SingleKvStoreCloseResultSetPromiseSucTest getResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`); 2385 expect(null).assertFail(); 2386 }); 2387 await kvStore.closeResultSet(resultSet).then((err) => { 2388 console.info('SingleKvStoreCloseResultSetPromiseSucTest closeResultSet success'); 2389 expect(err == undefined).assertTrue(); 2390 }).catch((err) => { 2391 console.error('SingleKvStoreCloseResultSetPromiseSucTest closeResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`); 2392 expect(null).assertFail(); 2393 }); 2394 } catch (e) { 2395 console.error('SingleKvStoreCloseResultSetPromiseSucTest e ' + `, error code is ${e.code}, message is ${e.message}`); 2396 expect(null).assertFail(); 2397 } 2398 done(); 2399 }) 2400 2401 /** 2402 * @tc.name SingleKvStoreCloseResultSetPromiseInvalidArgsTest 2403 * @tc.desc Test Js Api SingleKvStoreCloseResultSet with invalid args 2404 * @tc.type: FUNC 2405 * @tc.require: issueNumber 2406 */ 2407 it('SingleKvStoreCloseResultSetPromiseInvalidArgsTest', 0, async function (done) { 2408 try { 2409 await kvStore.closeResultSet().then(() => { 2410 expect(null).assertFail(); 2411 }).catch((err) => { 2412 console.error('SingleKvStoreCloseResultSetPromiseInvalidArgsTest closeResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`); 2413 }); 2414 } catch (e) { 2415 console.error('SingleKvStoreCloseResultSetPromiseInvalidArgsTest e ' + `, error code is ${e.code}, message is ${e.message}`); 2416 expect(e.code == 401).assertTrue(); 2417 } 2418 done(); 2419 }) 2420 2421 /** 2422 * @tc.name SingleKvStoreGetResultSizePromiseQueryTest 2423 * @tc.desc Test Js Api SingleKvStoreGetResultSize with query 2424 * @tc.type: FUNC 2425 * @tc.require: issueNumber 2426 */ 2427 it('SingleKvStoreGetResultSizePromiseQueryTest', 0, async function (done) { 2428 try { 2429 let entries = []; 2430 for (var i = 0; i < 10; i++) { 2431 var key = 'batch_test_string_key'; 2432 var entry = { 2433 key: key + i, 2434 value: { 2435 type: factory.ValueType.STRING, 2436 value: 'batch_test_string_value' 2437 } 2438 } 2439 entries.push(entry); 2440 } 2441 await kvStore.putBatch(entries).then(async (err) => { 2442 console.info('SingleKvStoreGetResultSizePromiseQueryTest putBatch success'); 2443 expect(err == undefined).assertTrue(); 2444 }).catch((err) => { 2445 console.error('SingleKvStorePutBatchPromiseStringTest putBatch fail ' + `, error code is ${err.code}, message is ${err.message}`); 2446 expect(null).assertFail(); 2447 }); 2448 var query = new factory.Query(); 2449 query.prefixKey("batch_test"); 2450 await kvStore.getResultSize(query).then((resultSize) => { 2451 console.info('SingleKvStoreGetResultSizePromiseQueryTest getResultSet success'); 2452 expect(resultSize == 10).assertTrue(); 2453 }).catch((err) => { 2454 console.error('SingleKvStoreGetResultSizePromiseQueryTest getResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`); 2455 expect(null).assertFail(); 2456 }); 2457 } catch (e) { 2458 console.error('SingleKvStoreGetResultSizePromiseQueryTest e ' + `, error code is ${e.code}, message is ${e.message}`); 2459 expect(null).assertFail(); 2460 } 2461 done(); 2462 }) 2463 2464 /** 2465 * @tc.name SingleKvStoreGetResultSizePromiseInvalidArgsTest 2466 * @tc.desc Test Js Api SingleKvStoreGetResultSize with invalid args 2467 * @tc.type: FUNC 2468 * @tc.require: issueNumber 2469 */ 2470 it('SingleKvStoreGetResultSizePromiseInvalidArgsTest', 0, async function (done) { 2471 try { 2472 let entries = []; 2473 for (var i = 0; i < 10; i++) { 2474 var key = 'batch_test_string_key'; 2475 var entry = { 2476 key: key + i, 2477 value: { 2478 type: factory.ValueType.STRING, 2479 value: 'batch_test_string_value' 2480 } 2481 } 2482 entries.push(entry); 2483 } 2484 await kvStore.putBatch(entries).then(async (err) => { 2485 expect(err == undefined).assertTrue(); 2486 }).catch((err) => { 2487 expect(null).assertFail(); 2488 }); 2489 await kvStore.getResultSize().then(() => { 2490 expect(null).assertFail(); 2491 }).catch((err) => { 2492 expect(null).assertFail(); 2493 }); 2494 } catch (e) { 2495 console.error('SingleKvStoreGetResultSizePromiseInvalidArgsTest e ' + `, error code is ${e.code}, message is ${e.message}`); 2496 expect(e.code == 401).assertTrue(); 2497 } 2498 done(); 2499 }) 2500 2501 /** 2502 * @tc.name SingleKvStoreGetResultSizePromiseClosedKVStoreTest 2503 * @tc.desc Test Js Api SingleKvStoreGetResultSize from a closed kvstore 2504 * @tc.type: FUNC 2505 * @tc.require: issueNumber 2506 */ 2507 it('SingleKvStoreGetResultSizePromiseClosedKVStoreTest', 0, async function (done) { 2508 try { 2509 let entries = []; 2510 for (var i = 0; i < 10; i++) { 2511 var key = 'batch_test_string_key'; 2512 var entry = { 2513 key: key + i, 2514 value: { 2515 type: factory.ValueType.STRING, 2516 value: 'batch_test_string_value' 2517 } 2518 } 2519 entries.push(entry); 2520 } 2521 await kvStore.putBatch(entries).then(async (err) => { 2522 expect(err == undefined).assertTrue(); 2523 }).catch((err) => { 2524 expect(null).assertFail(); 2525 }); 2526 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 2527 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 2528 expect(true).assertTrue(); 2529 }).catch((err) => { 2530 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 2531 }); 2532 }); 2533 var query = new factory.Query(); 2534 query.prefixKey("batch_test"); 2535 await kvStore.getResultSize(query).then(() => { 2536 console.info('SingleKvStoreGetResultSizePromiseClosedKVStoreTest getResultSet success'); 2537 expect(null).assertFail(); 2538 }).catch((err) => { 2539 console.error('SingleKvStoreGetResultSizePromiseClosedKVStoreTest getResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`); 2540 expect(err.code == 15100005).assertTrue(); 2541 }); 2542 } catch (e) { 2543 console.error('SingleKvStoreGetResultSizePromiseQueryTest e ' + `, error code is ${e.code}, message is ${e.message}`); 2544 expect(null).assertFail(); 2545 } 2546 done(); 2547 }) 2548 2549 /** 2550 * @tc.name SingleKvStoreChangeNotificationPromiseTest 2551 * @tc.desc Test Js Api SingleKvStoreChangeNotification 2552 * @tc.type: FUNC 2553 * @tc.require: issueNumber 2554 */ 2555 it('SingleKvStoreChangeNotificationPromiseTest', 0, async function (done) { 2556 var getInsertEntries = new Promise((resolve, reject) => { 2557 kvStore.on('dataChange', 0, function (ChangeNotification) { 2558 resolve(ChangeNotification.insertEntries); 2559 }); 2560 kvStore.put("getInsertEntries", "byPut").then(() => { 2561 console.info('SingleKvStoreChangeNotificationPromiseTest put success'); 2562 }); 2563 }); 2564 await getInsertEntries.then(function (insertEntries) { 2565 console.info('SingleKvStoreChangeNotificationPromiseTest getInsertEntries' + JSON.stringify(insertEntries)); 2566 expect(insertEntries != null).assertTrue(); 2567 }).catch((error) => { 2568 console.error('SingleKvStoreChangeNotificationPromiseTest can NOT getInsertEntries, fail:' + `, error code is ${error.code}, message is ${error.message}`); 2569 expect(null).assertFail(); 2570 }); 2571 done(); 2572 }) 2573 2574 /** 2575 * @tc.name SingleKvStoreChangeNotificationPromisePutTest 2576 * @tc.desc Test Js Api SingleKvStoreChangeNotification put 2577 * @tc.type: FUNC 2578 * @tc.require: issueNumber 2579 */ 2580 it('SingleKvStoreChangeNotificationPromisePutTest', 0, async function (done) { 2581 await kvStore.put('getUpdateEntries', 'byPut').then(() => { 2582 console.info('SingleKvStoreChangeNotificationPromisePutTest put success'); 2583 }); 2584 var getUpdateEntries = new Promise((resolve, reject) => { 2585 kvStore.on('dataChange', 0, function (ChangeNotification) { 2586 resolve(ChangeNotification.updateEntries); 2587 }); 2588 kvStore.put("getUpdateEntries", "byPut").then(() => { 2589 console.info('SingleKvStoreChangeNotificationPromisePutTest update success'); 2590 }); 2591 }); 2592 await getUpdateEntries.then(function (updateEntries) { 2593 console.info('SingleKvStoreChangeNotificationPromisePutTest getUpdateEntries' + JSON.stringify(updateEntries)); 2594 expect(updateEntries != null).assertTrue(); 2595 }).catch((error) => { 2596 console.error('SingleKvStoreChangeNotificationPromisePutTest can NOT getUpdateEntries, fail:' + `, error code is ${error.code}, message is ${error.message}`); 2597 expect(null).assertFail(); 2598 }); 2599 done(); 2600 }) 2601 2602 /** 2603 * @tc.name SingleKvStoreChangeNotificationPromiseDeleteTest 2604 * @tc.desc Test Js Api SingleKvStoreChangeNotification delete 2605 * @tc.type: FUNC 2606 * @tc.require: issueNumber 2607 */ 2608 it('SingleKvStoreChangeNotificationPromiseDeleteTest', 0, async function (done) { 2609 await kvStore.put('deleteEntries', 'byPut').then(() => { 2610 console.info('SingleKvStoreChangeNotificationPromiseDeleteTest put success'); 2611 }); 2612 var getdeleteEntries = new Promise((resolve, reject) => { 2613 kvStore.on('dataChange', 0, function (ChangeNotification) { 2614 resolve(ChangeNotification.deleteEntries); 2615 }); 2616 kvStore.delete("deleteEntries").then(() => { 2617 console.info('SingleKvStoreChangeNotificationPromiseDeleteTest delete success'); 2618 }); 2619 }); 2620 await getdeleteEntries.then(function (deleteEntries) { 2621 console.info('SingleKvStoreChangeNotificationPromiseDeleteTest deleteEntries' + JSON.stringify(getdeleteEntries)); 2622 expect(deleteEntries != null).assertTrue(); 2623 }).catch((error) => { 2624 console.error('SingleKvStoreChangeNotificationPromiseDeleteTest can NOT getdeleteEntries, fail:' + `, error code is ${error.code}, message is ${error.message}`); 2625 expect(null).assertFail(); 2626 }); 2627 done(); 2628 }) 2629}) 2630