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 fail' + `, error code is ${error.code}, message is ${error.message}`); 131 expect(null).assertFail(); 132 }); 133 } catch (e) { 134 console.error('SingleKvStorePutStringPromiseInvalidArgsTest fail' + `, 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 fail' + `, error code is ${error.code}, message is ${error.message}`); 161 expect(error.code == 15100005).assertTrue(); 162 }); 163 } catch (e) { 164 console.error('SingleKvStorePutStringPromiseClosedKVStoreTest fail' + `, 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 fail' + `, error code is ${error.code}, message is ${error.message}`); 184 expect(null).assertFail(); 185 }); 186 } catch (e) { 187 console.error('SingleKvStorePutStringPromiseSucTest fail' + `, 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 fail' + `, 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 fail' + `, 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 fail' + `, 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 fail' + `, 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 fail' + `, 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 fail' + `, 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 fail' + `, 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 fail' + `, 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 fail' + `, 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 fail' + `, 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 fail' + `, 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 fail' + `, 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 fail' + `, 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('SingleKvStoreDeleteStringPromiseClosedKVStoreTest fail' + `, 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.delete(predicates).then((data) => { 630 console.error('SingleKvStoreDeletePredicatesPromiseSucTest delete success'); 631 expect(null).assertFail(); 632 }).catch((err) => { 633 console.error('SingleKvStoreDeletePredicatesPromiseSucTest delete fail' + `, error code is ${err.code}, message is ${err.message}`); 634 expect(null).assertFail(); 635 }); 636 } catch (e) { 637 console.log('SingleKvStoreDeletePredicatesPromiseSucTest fail' + `, error code is ${e.code}, message is ${e.message}`); 638 expect(e.code == 202).assertTrue(); 639 } 640 done(); 641 }) 642 643 /** 644 * @tc.name SingleKvStoreDeletePredicatesPromiseClosedKVStoreTest 645 * @tc.desc Test Js Api SingleKvStoreDelete predicates into a closed kvstore 646 * @tc.type: FUNC 647 * @tc.require: issueNumber 648 */ 649 it('SingleKvStoreDeletePredicatesPromiseClosedKVStoreTest', 0, async function (done) { 650 try { 651 let predicates = new dataShare.DataSharePredicates(); 652 let arr = ["name"]; 653 predicates.inKeys(arr); 654 await kvStore.put("name", "Bob").then(async () => { 655 expect(true).assertTrue(); 656 }).catch((err) => { 657 expect(null).assertFail(); 658 }); 659 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 660 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 661 expect(true).assertTrue(); 662 }).catch((err) => { 663 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 664 }); 665 }) 666 await kvStore.delete(predicates).then((data) => { 667 console.error('SingleKvStoreDeletePredicatesPromiseClosedKVStoreTest delete success'); 668 expect(null).assertFail(); 669 }).catch((err) => { 670 console.error('SingleKvStoreDeletePredicatesPromiseClosedKVStoreTest delete fail' + `, error code is ${err.code}, message is ${err.message}`); 671 expect(null).assertFail(); 672 }); 673 } catch (e) { 674 console.log('SingleKvStoreDeletePredicatesPromiseClosedKVStoreTest fail' + `, error code is ${e.code}, message is ${e.message}`); 675 expect(e.code == 202).assertTrue(); 676 } 677 done(); 678 }) 679 680 /** 681 * @tc.name SingleKvStoreDeletePredicatesPromiseInvalidArgsTest 682 * @tc.desc Test Js Api SingleKvStoreDelete predicates with invalid args 683 * @tc.type: FUNC 684 * @tc.require: issueNumber 685 */ 686 it('SingleKvStoreDeleteStringPromiseInvalidArgsTest', 0, async function (done) { 687 console.info('SingleKvStoreDeleteStringPromiseInvalidArgsTest'); 688 try { 689 let predicates = new dataShare.DataSharePredicates(); 690 let arr = ["name"]; 691 predicates.inKeys(arr); 692 await kvStore.put("name", "bob").then(async () => { 693 expect(true).assertTrue(); 694 await kvStore.delete().then(() => { 695 expect(null).assertFail(); 696 }).catch((err) => { 697 expect(null).assertFail(); 698 }); 699 }).catch((err) => { 700 expect(err.code == 401).assertTrue(); 701 }); 702 } catch (e) { 703 expect(null).assertFail(); 704 } 705 done(); 706 }) 707 708 /** 709 * @tc.name SingleKvStoreSetSyncRangePromiseDisjointTest 710 * @tc.desc Test Js Api SingleKvStoreSetSyncRange with disjoint ranges 711 * @tc.type: FUNC 712 * @tc.require: issueNumber 713 */ 714 it('SingleKvStoreSetSyncRangePromiseDisjointTest', 0, async function (done) { 715 console.info('SingleKvStoreSetSyncRangePromiseDisjointTest'); 716 try { 717 var localLabels = ['A', 'B']; 718 var remoteSupportLabels = ['C', 'D']; 719 await kvStore.setSyncRange(localLabels, remoteSupportLabels).then((err) => { 720 console.info('SingleKvStoreSetSyncRangePromiseDisjointTest setSyncRange success'); 721 expect(err == undefined).assertTrue(); 722 }).catch((err) => { 723 console.error('SingleKvStoreSetSyncRangePromiseDisjointTest setSyncRange fail' + `, error code is ${err.code}, message is ${err.message}`); 724 expect(null).assertFail(); 725 }); 726 } catch (e) { 727 console.error('SingleKvStoreSetSyncRangePromiseDisjointTest fail' + `, error code is ${e.code}, message is ${e.message}`); 728 expect(null).assertFail(); 729 } 730 done(); 731 }) 732 733 /** 734 * @tc.name SingleKvStoreSetSyncRangePromiseJointTest 735 * @tc.desc Test Js Api SingleKvStoreSetSyncRange with joint range 736 * @tc.type: FUNC 737 * @tc.require: issueNumber 738 */ 739 it('SingleKvStoreSetSyncRangePromiseJointTest', 0, async function (done) { 740 console.info('SingleKvStoreSetSyncRangePromiseJointTest'); 741 try { 742 var localLabels = ['A', 'B']; 743 var remoteSupportLabels = ['B', 'C']; 744 await kvStore.setSyncRange(localLabels, remoteSupportLabels).then((err) => { 745 console.info('SingleKvStoreSetSyncRangePromiseJointTest setSyncRange success'); 746 expect(err == undefined).assertTrue(); 747 }).catch((err) => { 748 console.error('SingleKvStoreSetSyncRangePromiseJointTest setSyncRange fail' + `, error code is ${err.code}, message is ${err.message}`); 749 expect(null).assertFail(); 750 }); 751 } catch (e) { 752 console.error('SingleKvStoreSetSyncRangePromiseJointTest fail' + `, error code is ${e.code}, message is ${e.message}`); 753 expect(null).assertFail(); 754 } 755 done(); 756 }) 757 758 /** 759 * @tc.name SingleKvStoreSetSyncRangePromiseSameTest 760 * @tc.desc Test Js Api SingleKvStoreSetSyncRange with same range 761 * @tc.type: FUNC 762 * @tc.require: issueNumber 763 */ 764 it('SingleKvStoreSetSyncRangePromiseSameTest', 0, async function (done) { 765 console.info('SingleKvStoreSetSyncRangePromiseSameTest'); 766 try { 767 var localLabels = ['A', 'B']; 768 var remoteSupportLabels = ['A', 'B']; 769 await kvStore.setSyncRange(localLabels, remoteSupportLabels).then((err) => { 770 console.info('SingleKvStoreSetSyncRangePromiseSameTest setSyncRange success'); 771 expect(err == undefined).assertTrue(); 772 }).catch((err) => { 773 console.error('SingleKvStoreSetSyncRangePromiseSameTest setSyncRange fail' + `, error code is ${err.code}, message is ${err.message}`); 774 expect(null).assertFail(); 775 }); 776 } catch (e) { 777 console.error('SingleKvStoreSetSyncRangePromiseSameTest fail' + `, error code is ${e.code}, message is ${e.message}`); 778 expect(null).assertFail(); 779 } 780 done(); 781 }) 782 783 /** 784 * @tc.name SingleKvStoreSetSyncRangePromiseInvalidArgsTest 785 * @tc.desc Test Js Api SingleKvStoreSetSyncRange with invalid args 786 * @tc.type: FUNC 787 * @tc.require: issueNumber 788 */ 789 it('SingleKvStoreSetSyncRangePromiseInvalidArgsTest', 0, async function (done) { 790 console.info('SingleKvStoreSetSyncRangePromiseSameTest'); 791 try { 792 var remoteSupportLabels = ['A', 'B']; 793 await kvStore.setSyncRange(remoteSupportLabels).then((err) => { 794 expect(null).assertFail(); 795 }).catch((err) => { 796 expect(null).assertFail(); 797 }); 798 } catch (e) { 799 console.error('SingleKvStoreSetSyncRangePromiseSameTest fail' + `, error code is ${e.code}, message is ${e.message}`); 800 expect(e.code == 401).assertTrue(); 801 } 802 done(); 803 }) 804 805 /** 806 * @tc.name SingleKvStorePutBatchPromiseStringTest 807 * @tc.desc Test Js Api SingleKvStore.PutBatch() with string value 808 * @tc.type: FUNC 809 * @tc.require: issueNumber 810 */ 811 it('SingleKvStorePutBatchPromiseStringTest', 0, async function (done) { 812 console.info('SingleKvStorePutBatchPromiseStringTest'); 813 try { 814 let entries = putBatchString(10, 'batch_test_string_key'); 815 console.info('SingleKvStorePutBatchPromiseStringTest entries: ' + JSON.stringify(entries)); 816 await kvStore.putBatch(entries).then(async (err) => { 817 console.info('SingleKvStorePutBatchPromiseStringTest putBatch success'); 818 expect(err == undefined).assertTrue(); 819 await kvStore.getEntries('batch_test_string_key').then((entrys) => { 820 console.info('SingleKvStorePutBatchPromiseStringTest getEntries success'); 821 console.info('SingleKvStorePutBatchPromiseStringTest ' + JSON.stringify(entries)); 822 expect(entrys.length == 10).assertTrue(); 823 expect(entrys[0].value.value == 'batch_test_string_value').assertTrue(); 824 }).catch((err) => { 825 console.error('SingleKvStorePutBatchPromiseStringTest getEntries fail' + `, error code is ${err.code}, message is ${err.message}`); 826 expect(null).assertFail(); 827 }); 828 }).catch((err) => { 829 console.error('SingleKvStorePutBatchPromiseStringTest putBatch fail' + `, error code is ${err.code}, message is ${err.message}`); 830 expect(null).assertFail(); 831 }); 832 } catch (e) { 833 console.error('SingleKvStorePutBatchPromiseStringTest fail' + `, error code is ${e.code}, message is ${e.message}`); 834 expect(null).assertFail(); 835 } 836 done(); 837 }) 838 839 /** 840 * @tc.name SingleKvStorePutBatchPromiseIntegerTest 841 * @tc.desc Test Js Api SingleKvStore.PutBatch() with integer value 842 * @tc.type: FUNC 843 * @tc.require: issueNumber 844 */ 845 it('SingleKvStorePutBatchPromiseIntegerTest', 0, async function (done) { 846 console.info('SingleKvStorePutBatchPromiseIntegerTest'); 847 try { 848 let entries = []; 849 for (var i = 0; i < 10; i++) { 850 var key = 'batch_test_number_key'; 851 var entry = { 852 key: key + i, 853 value: { 854 type: factory.ValueType.INTEGER, 855 value: 222 856 } 857 } 858 entries.push(entry); 859 } 860 console.info('SingleKvStorePutBatchPromiseIntegerTest entries: ' + JSON.stringify(entries)); 861 await kvStore.putBatch(entries).then(async (err) => { 862 console.info('SingleKvStorePutBatchPromiseIntegerTest putBatch success'); 863 expect(err == undefined).assertTrue(); 864 await kvStore.getEntries('batch_test_number_key').then((entrys) => { 865 console.info('SingleKvStorePutBatchPromiseIntegerTest getEntries success'); 866 expect(entrys.length == 10).assertTrue(); 867 expect(entrys[0].value.value == 222).assertTrue(); 868 }).catch((err) => { 869 console.error('SingleKvStorePutBatchPromiseIntegerTest getEntries fail' + `, error code is ${err.code}, message is ${err.message}`); 870 expect(null).assertFail(); 871 }); 872 }).catch((err) => { 873 console.error('SingleKvStorePutBatchPromiseIntegerTest putBatch fail' + `, error code is ${err.code}, message is ${err.message}`); 874 expect(null).assertFail(); 875 }); 876 } catch (e) { 877 console.error('SingleKvStorePutBatchPromiseIntegerTest fail' + `, error code is ${e.code}, message is ${e.message}`); 878 expect(null).assertFail(); 879 } 880 done(); 881 }) 882 883 /** 884 * @tc.name SingleKvStorePutBatchPromiseFloatTest 885 * @tc.desc Test Js Api SingleKvStore.PutBatch() with float value 886 * @tc.type: FUNC 887 * @tc.require: issueNumber 888 */ 889 it('SingleKvStorePutBatchPromiseFloatTest', 0, async function (done) { 890 console.info('SingleKvStorePutBatchPromiseFloatTest'); 891 try { 892 let entries = []; 893 for (var i = 0; i < 10; i++) { 894 var key = 'batch_test_number_key'; 895 var entry = { 896 key: key + i, 897 value: { 898 type: factory.ValueType.FLOAT, 899 value: 2.0 900 } 901 } 902 entries.push(entry); 903 } 904 console.info('SingleKvStorePutBatchPromiseFloatTest entries: ' + JSON.stringify(entries)); 905 await kvStore.putBatch(entries).then(async (err) => { 906 console.info('SingleKvStorePutBatchPromiseFloatTest putBatch success'); 907 expect(err == undefined).assertTrue(); 908 await kvStore.getEntries('batch_test_number_key').then((entrys) => { 909 console.info('SingleKvStorePutBatchPromiseFloatTest getEntries success'); 910 expect(entrys.length == 10).assertTrue(); 911 expect(entrys[0].value.value == 2.0).assertTrue(); 912 }).catch((err) => { 913 console.error('SingleKvStorePutBatchPromiseFloatTest getEntries fail' + `, error code is ${err.code}, message is ${err.message}`); 914 expect(null).assertFail(); 915 }); 916 }).catch((err) => { 917 console.error('SingleKvStorePutBatchPromiseFloatTest putBatch fail' + `, error code is ${err.code}, message is ${err.message}`); 918 expect(null).assertFail(); 919 }); 920 } catch (e) { 921 console.error('SingleKvStorePutBatchPromiseFloatTest fail' + `, error code is ${e.code}, message is ${e.message}`); 922 expect(null).assertFail(); 923 } 924 done(); 925 }) 926 927 /** 928 * @tc.name SingleKvStorePutBatchPromiseDoubleTest 929 * @tc.desc Test Js Api SingleKvStore.PutBatch() with double value 930 * @tc.type: FUNC 931 * @tc.require: issueNumber 932 */ 933 it('SingleKvStorePutBatchPromiseDoubleTest', 0, async function (done) { 934 console.info('SingleKvStorePutBatchPromiseDoubleTest'); 935 try { 936 let entries = []; 937 for (var i = 0; i < 10; i++) { 938 var key = 'batch_test_number_key'; 939 var entry = { 940 key: key + i, 941 value: { 942 type: factory.ValueType.DOUBLE, 943 value: 2.00 944 } 945 } 946 entries.push(entry); 947 } 948 console.info('SingleKvStorePutBatchPromiseDoubleTest entries: ' + JSON.stringify(entries)); 949 await kvStore.putBatch(entries).then(async (err) => { 950 console.info('SingleKvStorePutBatchPromiseDoubleTest putBatch success'); 951 expect(err == undefined).assertTrue(); 952 await kvStore.getEntries('batch_test_number_key').then((entrys) => { 953 console.info('SingleKvStorePutBatchPromiseDoubleTest getEntries success'); 954 expect(entrys.length == 10).assertTrue(); 955 expect(entrys[0].value.value == 2.00).assertTrue(); 956 }).catch((err) => { 957 console.error('SingleKvStorePutBatchPromiseDoubleTest getEntries fail' + `, error code is ${err.code}, message is ${err.message}`); 958 expect(null).assertFail(); 959 }); 960 }).catch((err) => { 961 console.error('SingleKvStorePutBatchPromiseDoubleTest putBatch fail' + `, error code is ${err.code}, message is ${err.message}`); 962 expect(null).assertFail(); 963 }); 964 } catch (e) { 965 console.error('SingleKvStorePutBatchPromiseDoubleTest fail' + `, error code is ${e.code}, message is ${e.message}`); 966 expect(null).assertFail(); 967 } 968 done(); 969 }) 970 971 /** 972 * @tc.name SingleKvStorePutBatchPromiseBooleanTest 973 * @tc.desc Test Js Api SingleKvStore.PutBatch() with boolean value 974 * @tc.type: FUNC 975 * @tc.require: issueNumber 976 */ 977 it('SingleKvStorePutBatchPromiseBooleanTest', 0, async function (done) { 978 console.info('SingleKvStorePutBatchPromiseBooleanTest'); 979 try { 980 var bo = false; 981 let entries = []; 982 for (var i = 0; i < 10; i++) { 983 var key = 'batch_test_bool_key'; 984 var entry = { 985 key: key + i, 986 value: { 987 type: factory.ValueType.BOOLEAN, 988 value: bo 989 } 990 } 991 entries.push(entry); 992 } 993 console.info('SingleKvStorePutBatchPromiseBooleanTest entries: ' + JSON.stringify(entries)); 994 await kvStore.putBatch(entries).then(async (err) => { 995 console.info('SingleKvStorePutBatchPromiseBooleanTest putBatch success'); 996 expect(err == undefined).assertTrue(); 997 await kvStore.getEntries('batch_test_bool_key').then((entrys) => { 998 console.info('SingleKvStorePutBatchPromiseBooleanTest getEntries success'); 999 expect(entrys.length == 10).assertTrue(); 1000 expect(entrys[0].value.value == bo).assertTrue(); 1001 }).catch((err) => { 1002 console.error('SingleKvStorePutBatchPromiseBooleanTest getEntries fail' + `, error code is ${err.code}, message is ${err.message}`); 1003 expect(null).assertFail(); 1004 }); 1005 }).catch((err) => { 1006 console.error('SingleKvStorePutBatchPromiseBooleanTest putBatch fail' + `, error code is ${err.code}, message is ${err.message}`); 1007 expect(null).assertFail(); 1008 }); 1009 } catch (e) { 1010 console.error('SingleKvStorePutBatchPromiseBooleanTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1011 expect(null).assertFail(); 1012 } 1013 done(); 1014 }) 1015 1016 /** 1017 * @tc.name SingleKvStorePutBatchPromiseByteArrayTest 1018 * @tc.desc Test Js Api SingleKvStore.PutBatch() with byte array value 1019 * @tc.type: FUNC 1020 * @tc.require: issueNumber 1021 */ 1022 it('SingleKvStorePutBatchPromiseByteArrayTest', 0, async function (done) { 1023 console.info('SingleKvStorePutBatchPromiseByteArrayTest'); 1024 try { 1025 var arr = new Uint8Array([21, 31]); 1026 let entries = []; 1027 for (var i = 0; i < 10; i++) { 1028 var key = 'batch_test_bool_key'; 1029 var entry = { 1030 key: key + i, 1031 value: { 1032 type: factory.ValueType.BYTE_ARRAY, 1033 value: arr 1034 } 1035 } 1036 entries.push(entry); 1037 } 1038 console.info('SingleKvStorePutBatchPromiseByteArrayTest entries: ' + JSON.stringify(entries)); 1039 await kvStore.putBatch(entries).then(async (err) => { 1040 console.info('SingleKvStorePutBatchPromiseByteArrayTest putBatch success'); 1041 expect(err == undefined).assertTrue(); 1042 await kvStore.getEntries('batch_test_bool_key').then((entrys) => { 1043 console.info('SingleKvStorePutBatchPromiseByteArrayTest getEntries success'); 1044 expect(entrys.length == 10).assertTrue(); 1045 expect(entrys[0].value.value.toString() == arr.toString()).assertTrue(); 1046 }).catch((err) => { 1047 console.error('SingleKvStorePutBatchPromiseByteArrayTest getEntries fail' + `, error code is ${err.code}, message is ${err.message}`); 1048 expect(null).assertFail(); 1049 }); 1050 }).catch((err) => { 1051 console.error('SingleKvStorePutBatchPromiseByteArrayTest putBatch fail' + `, error code is ${err.code}, message is ${err.message}`); 1052 expect(null).assertFail(); 1053 }); 1054 } catch (e) { 1055 console.error('SingleKvStorePutBatchPromiseByteArrayTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1056 expect(null).assertFail(); 1057 } 1058 done(); 1059 }) 1060 1061 /** 1062 * @tc.name SingleKvStorePutBatchValuePromiseUint8ArrayTest 1063 * @tc.desc Test Js Api SingleKvStore.PutBatch() put Uint8Array 1064 * @tc.type: FUNC 1065 * @tc.require: issueNumber 1066 */ 1067 it('SingleKvStorePutBatchValuePromiseUint8ArrayTest', 0, async function (done) { 1068 console.info('SingleKvStorePutBatchValuePromiseUint8ArrayTest'); 1069 try { 1070 let values = []; 1071 let arr1 = new Uint8Array([4, 5, 6, 7]); 1072 let arr2 = new Uint8Array([4, 5, 6, 7, 8]); 1073 let vb1 = {key: "name_1", value: arr1}; 1074 let vb2 = {key: "name_2", value: arr2}; 1075 values.push(vb1); 1076 values.push(vb2); 1077 console.info('SingleKvStorePutBatchValuePromiseUint8ArrayTest values: ' + JSON.stringify(values)); 1078 await kvStore.putBatch(values).then(async (err) => { 1079 console.error('SingleKvStorePutBatchValuePromiseUint8ArrayTest putBatch success'); 1080 expect(null).assertFail(); 1081 }).catch((err) => { 1082 console.error('SingleKvStorePutBatchValuePromiseUint8ArrayTest putBatch fail' + `, error code is ${err.code}, message is ${err.message}`); 1083 expect(null).assertFail(); 1084 }); 1085 } catch (e) { 1086 console.info('SingleKvStorePutBatchValuePromiseUint8ArrayTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1087 expect(e.code == 202).assertTrue(); 1088 } 1089 done(); 1090 }) 1091 1092 /** 1093 * @tc.name SingleKvStorePutBatchValuePromiseStringTest 1094 * @tc.desc Test Js Api SingleKvStore.PutBatch() put String 1095 * @tc.type: FUNC 1096 * @tc.require: issueNumber 1097 */ 1098 it('SingleKvStorePutBatchValuePromiseStringTest', 0, async function (done) { 1099 console.info('SingleKvStorePutBatchValuePromiseStringTest'); 1100 try { 1101 let values = []; 1102 let vb1 = {key: "name_1", value: "arr1"}; 1103 let vb2 = {key: "name_2", value: "arr2"}; 1104 values.push(vb1); 1105 values.push(vb2); 1106 console.info('SingleKvStorePutBatchValuePromiseStringTest values: ' + JSON.stringify(values)); 1107 await kvStore.putBatch(values).then(async (err) => { 1108 console.error('SingleKvStorePutBatchValuePromiseStringTest putBatch success'); 1109 expect(null).assertFail(); 1110 }).catch((err) => { 1111 console.error('SingleKvStorePutBatchValuePromiseStringTest putBatch fail' + `, error code is ${err.code}, message is ${err.message}`); 1112 expect(null).assertFail(); 1113 }); 1114 } catch (e) { 1115 console.info('SingleKvStorePutBatchValuePromiseStringTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1116 expect(e.code == 202).assertTrue(); 1117 } 1118 done(); 1119 }) 1120 1121 /** 1122 * @tc.name SingleKvStorePutBatchValuePromiseNumbersTest 1123 * @tc.desc Test Js Api SingleKvStore.PutBatch() put numbers 1124 * @tc.type: FUNC 1125 * @tc.require: issueNumber 1126 */ 1127 it('SingleKvStorePutBatchValuePromiseNumbersTest', 0, async function (done) { 1128 try { 1129 let values = []; 1130 let vb1 = {key: "name_1", value: 123}; 1131 let vb2 = {key: "name_2", value: 321.0}; 1132 let vb3 = {key: "name_3", value: 321.00}; 1133 values.push(vb1); 1134 values.push(vb2); 1135 values.push(vb3); 1136 await kvStore.putBatch(values).then(async (err) => { 1137 console.info('SingleKvStorePutBatchValuePromiseNumbersTest putBatch success'); 1138 expect(null).assertFail(); 1139 }).catch((err) => { 1140 console.error('SingleKvStorePutBatchValuePromiseNumbersTest putBatch fail' + `, error code is ${err.code}, message is ${err.message}`); 1141 expect(null).assertFail(); 1142 }); 1143 } catch (e) { 1144 console.error('SingleKvStorePutBatchValuePromiseNumbersTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1145 expect(e.code == 202).assertTrue(); 1146 } 1147 done(); 1148 }) 1149 1150 /** 1151 * @tc.name SingleKvStorePutBatchValuePromiseBooleanTest 1152 * @tc.desc Test Js Api SingleKvStore.PutBatch() put booleans 1153 * @tc.type: FUNC 1154 * @tc.require: issueNumber 1155 */ 1156 it('SingleKvStorePutBatchValuePromiseBooleanTest', 0, async function (done) { 1157 try { 1158 let values = []; 1159 let vb1 = {key: "name_1", value: true}; 1160 let vb2 = {key: "name_2", value: false}; 1161 values.push(vb1); 1162 values.push(vb2); 1163 await kvStore.putBatch(values).then(async (err) => { 1164 console.error('SingleKvStorePutBatchValuePromiseBooleanTest putBatch success'); 1165 expect(null).assertFail(); 1166 }).catch((err) => { 1167 console.error('SingleKvStorePutBatchValuePromiseBooleanTest putBatch fail' + `, error code is ${err.code}, message is ${err.message}`); 1168 expect(null).assertFail(); 1169 }); 1170 } catch (e) { 1171 console.info('SingleKvStorePutBatchValuePromiseBooleanTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1172 expect(e.code == 202).assertTrue(); 1173 done(); 1174 } 1175 }) 1176 1177 /** 1178 * @tc.name SingleKvStorePutBatchValuePromiseNullTest 1179 * @tc.desc Test Js Api SingleKvStore.PutBatch() put null 1180 * @tc.type: FUNC 1181 * @tc.require: issueNumber 1182 */ 1183 it('SingleKvStorePutBatchValuePromiseNullTest', 0, async function (done) { 1184 console.info('SingleKvStorePutBatchValuePromiseNullTest'); 1185 try { 1186 let values = []; 1187 let vb1 = {key: "name_1", value: null}; 1188 let vb2 = {key: "name_2", value: null}; 1189 values.push(vb1); 1190 values.push(vb2); 1191 console.info('SingleKvStorePutBatchValuePromiseNullTest values: ' + JSON.stringify(values)); 1192 await kvStore.putBatch(values).then(async (err) => { 1193 console.error('SingleKvStorePutBatchValuePromiseNullTest putBatch success'); 1194 expect(null).assertFail(); 1195 }).catch((err) => { 1196 console.error('SingleKvStorePutBatchValuePromiseNullTest putBatch fail' + `, error code is ${err.code}, message is ${err.message}`); 1197 expect(null).assertFail(); 1198 }); 1199 } catch (e) { 1200 console.info('SingleKvStorePutBatchValuePromiseNullTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1201 expect(e.code == 202).assertTrue(); 1202 done(); 1203 } 1204 }) 1205 1206 /** 1207 * @tc.name SingleKvStorePutBatchValuePromiseInvalidArgsTest 1208 * @tc.desc Test Js Api SingleKvStore.PutBatch() put invalid args 1209 * @tc.type: FUNC 1210 * @tc.require: issueNumber 1211 */ 1212 it('SingleKvStorePutBatchValuePromiseInvalidArgsTest', 0, async function (done) { 1213 try { 1214 await kvStore.putBatch().then(() => { 1215 expect(null).assertFail(); 1216 }).catch((err) => { 1217 expect(null).assertFail(); 1218 }); 1219 } catch (e) { 1220 console.error('SingleKvStorePutBatchValuePromiseInvalidArgsTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1221 expect(e.code == 401).assertTrue(); 1222 } 1223 done(); 1224 }) 1225 1226 /** 1227 * @tc.name SingleKvStorePutBatchValuePromiseClosedKvstoreTest 1228 * @tc.desc Test Js Api SingleKvStore.PutBatch() put into closed kvstore 1229 * @tc.type: FUNC 1230 * @tc.require: issueNumber 1231 */ 1232 it('SingleKvStorePutBatchValuePromiseClosedKvstoreTest', 0, async function (done) { 1233 try { 1234 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 1235 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 1236 expect(true).assertTrue(); 1237 }).catch((err) => { 1238 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 1239 }); 1240 }) 1241 let values = []; 1242 let vb1 = {key: "name_1", value: null}; 1243 let vb2 = {key: "name_2", value: null}; 1244 values.push(vb1); 1245 values.push(vb2); 1246 await kvStore.putBatch(values).then(() => { 1247 console.error('SingleKvStorePutBatchValuePromiseClosedKvstoreTest putBatch success'); 1248 expect(null).assertFail(); 1249 }).catch((err) => { 1250 console.error('SingleKvStorePutBatchValuePromiseClosedKvstoreTest putBatch fail' + `, error code is ${err.code}, message is ${err.message}`); 1251 expect(null).assertFail(); 1252 }); 1253 } catch (e) { 1254 console.info('SingleKvStorePutBatchValuePromiseClosedKvstoreTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1255 expect(e.code == 202).assertTrue(); 1256 } 1257 done(); 1258 }) 1259 1260 /** 1261 * @tc.name SingleKvStoreDeleteBatchPromiseSucTest 1262 * @tc.desc Test Js Api SingleKvStoreDeleteBatch success 1263 * @tc.type: FUNC 1264 * @tc.require: issueNumber 1265 */ 1266 it('SingleKvStoreDeleteBatchPromiseSucTest', 0, async function (done) { 1267 console.info('SingleKvStoreDeleteBatchPromiseSucTest'); 1268 try { 1269 let entries = []; 1270 let keys = []; 1271 for (var i = 0; i < 5; i++) { 1272 var key = 'batch_test_string_key'; 1273 var entry = { 1274 key: key + i, 1275 value: { 1276 type: factory.ValueType.STRING, 1277 value: 'batch_test_string_value' 1278 } 1279 } 1280 entries.push(entry); 1281 keys.push(key + i); 1282 } 1283 await kvStore.putBatch(entries).then(async (err) => { 1284 expect(err == undefined).assertTrue(); 1285 await kvStore.deleteBatch(keys).then((err) => { 1286 expect(err == undefined).assertTrue(); 1287 }).catch((err) => { 1288 expect(null).assertFail(); 1289 }); 1290 }).catch((err) => { 1291 expect(null).assertFail(); 1292 }); 1293 } catch (e) { 1294 console.error('SingleKvStoreDeleteBatchPromiseSucTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1295 expect(null).assertFail(); 1296 } 1297 done(); 1298 }) 1299 1300 /** 1301 * @tc.name SingleKvStoreDeleteBatchPromiseInvalidArgsTest 1302 * @tc.desc Test Js Api SingleKvStoreDeleteBatch with invalid args 1303 * @tc.type: FUNC 1304 * @tc.require: issueNumber 1305 */ 1306 it('SingleKvStoreDeleteBatchPromiseInvalidArgsTest', 0, async function (done) { 1307 console.info('SingleKvStoreDeleteBatchPromiseInvalidArgsTest'); 1308 try { 1309 let entries = []; 1310 let keys = []; 1311 for (var i = 0; i < 5; i++) { 1312 var key = 'batch_test_string_key'; 1313 var entry = { 1314 key: key + i, 1315 value: { 1316 type: factory.ValueType.STRING, 1317 value: 'batch_test_string_value' 1318 } 1319 } 1320 entries.push(entry); 1321 keys.push(key + i); 1322 } 1323 await kvStore.putBatch(entries).then(async (err) => { 1324 expect(err == undefined).assertTrue(); 1325 await kvStore.deleteBatch(1).then((err) => { 1326 console.log("fail1") 1327 expect(null).assertFail(); 1328 }).catch((err) => { 1329 console.log("fail2") 1330 expect(null).assertFail(); 1331 }); 1332 }).catch((err) => { 1333 console.log("fail3") 1334 expect(err.code == 401).assertTrue(); 1335 }); 1336 } catch (e) { 1337 console.error('SingleKvStoreDeleteBatchPromiseInvalidArgsTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1338 expect(null).assertFail(); 1339 } 1340 done(); 1341 }) 1342 1343 /** 1344 * @tc.name SingleKvStoreDeleteBatchPromiseClosedKVStoreTest 1345 * @tc.desc Test Js Api SingleKvStoreDeleteBatch into closed kvstore 1346 * @tc.type: FUNC 1347 * @tc.require: issueNumber 1348 */ 1349 it('SingleKvStoreDeleteBatchPromiseClosedKVStoreTest', 0, async function (done) { 1350 console.info('SingleKvStoreDeleteBatchPromiseClosedKVStoreTest'); 1351 try { 1352 let entries = []; 1353 let keys = []; 1354 for (var i = 0; i < 5; i++) { 1355 var key = 'batch_test_string_key'; 1356 var entry = { 1357 key: key + i, 1358 value: { 1359 type: factory.ValueType.STRING, 1360 value: 'batch_test_string_value' 1361 } 1362 } 1363 entries.push(entry); 1364 keys.push(key + i); 1365 } 1366 await kvStore.putBatch(entries).then((err) => { 1367 expect(err == undefined).assertTrue(); 1368 }).catch((err) => { 1369 expect(null).assertFail(); 1370 }); 1371 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 1372 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 1373 expect(true).assertTrue(); 1374 }).catch((err) => { 1375 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 1376 }); 1377 }) 1378 kvStore.deleteBatch(keys).then((err) => { 1379 expect(null).assertFail(); 1380 }).catch((err) => { 1381 expect(null).assertFail(); 1382 expect(err.code == 15100005).assertTrue(); 1383 }); 1384 } catch (e) { 1385 console.error('SingleKvStoreDeleteBatchPromiseClosedKVStoreTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1386 expect(null).assertFail(); 1387 } 1388 done(); 1389 }) 1390 1391 /** 1392 * @tc.name SingleKvStoreGetEntriesPromiseQueryTest 1393 * @tc.desc Test Js Api SingleKvStore.GetEntries() with query 1394 * @tc.type: FUNC 1395 * @tc.require: issueNumber 1396 */ 1397 it('SingleKvStoreGetEntriesPromiseQueryTest', 0, async function (done) { 1398 console.info('SingleKvStoreGetEntriesPromiseQueryTest'); 1399 try { 1400 var arr = new Uint8Array([21, 31]); 1401 let entries = []; 1402 for (var i = 0; i < 10; i++) { 1403 var key = 'batch_test_bool_key'; 1404 var entry = { 1405 key: key + i, 1406 value: { 1407 type: factory.ValueType.BYTE_ARRAY, 1408 value: arr 1409 } 1410 } 1411 entries.push(entry); 1412 } 1413 console.info('SingleKvStoreGetEntriesPromiseQueryTest entries: ' + JSON.stringify(entries)); 1414 await kvStore.putBatch(entries).then(async (err) => { 1415 console.info('SingleKvStoreGetEntriesPromiseQueryTest putBatch success'); 1416 expect(err == undefined).assertTrue(); 1417 let query = new factory.Query(); 1418 query.prefixKey("batch_test"); 1419 await kvStore.getEntries(query).then((entrys) => { 1420 expect(entrys.length == 10).assertTrue(); 1421 expect(entrys[0].value.value.toString() == arr.toString()).assertTrue(); 1422 }).catch((err) => { 1423 console.log("errr1") 1424 expect(null).assertFail(); 1425 }); 1426 }).catch((err) => { 1427 console.log("errr2") 1428 expect(null).assertFail(); 1429 }); 1430 } catch (e) { 1431 console.error('SingleKvStoreGetEntriesPromiseQueryTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1432 console.log("errr3") 1433 expect(null).assertFail(); 1434 } 1435 done(); 1436 }) 1437 1438 /** 1439 * @tc.name SingleKvStoreGetEntriesPromiseQueryClosedKVStoreTest 1440 * @tc.desc Test Js Api SingleKvStore.GetEntries() query from a closed kvstore 1441 * @tc.type: FUNC 1442 * @tc.require: issueNumber 1443 */ 1444 it('SingleKvStoreGetEntriesPromiseQueryClosedKVStoreTest', 0, async function (done) { 1445 try { 1446 var arr = new Uint8Array([21, 31]); 1447 let entries = []; 1448 for (var i = 0; i < 10; i++) { 1449 var key = 'batch_test_bool_key'; 1450 var entry = { 1451 key: key + i, 1452 value: { 1453 type: factory.ValueType.BYTE_ARRAY, 1454 value: arr 1455 } 1456 } 1457 entries.push(entry); 1458 } 1459 await kvStore.putBatch(entries).then(async (err) => { 1460 expect(err == undefined).assertTrue(); 1461 }).catch((err) => { 1462 expect(null).assertFail(); 1463 }); 1464 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 1465 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 1466 expect(true).assertTrue(); 1467 }).catch((err) => { 1468 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 1469 }); 1470 }) 1471 let query = new factory.Query(); 1472 query.prefixKey("batch_test"); 1473 await kvStore.getEntries(query).then(() => { 1474 expect(null).assertFail(); 1475 }).catch((err) => { 1476 expect(err.code == 15100005).assertTrue(); 1477 }); 1478 } catch (e) { 1479 console.error('SingleKvStoreGetEntriesPromiseQueryClosedKVStoreTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1480 expect(null).assertFail(); 1481 } 1482 done(); 1483 }) 1484 1485 /** 1486 * @tc.name SingleKvStoreGetEntriesPromiseSucTest 1487 * @tc.desc Test Js Api SingleKvStore.GetEntries() success 1488 * @tc.type: FUNC 1489 * @tc.require: issueNumber 1490 */ 1491 it('SingleKvStoreGetEntriesPromiseSucTest', 0, async function (done) { 1492 console.info('SingleKvStoreGetEntriesPromiseSucTest'); 1493 try { 1494 var arr = new Uint8Array([21, 31]); 1495 let entries = []; 1496 for (var i = 0; i < 10; i++) { 1497 var key = 'batch_test_bool_key'; 1498 var entry = { 1499 key: key + i, 1500 value: { 1501 type: factory.ValueType.BYTE_ARRAY, 1502 value: arr 1503 } 1504 } 1505 entries.push(entry); 1506 } 1507 await kvStore.putBatch(entries).then(async (err) => { 1508 expect(err == undefined).assertTrue(); 1509 await kvStore.getEntries("batch_test").then((entrys) => { 1510 expect(entrys.length == 10).assertTrue(); 1511 expect(entrys[0].value.value.toString() == arr.toString()).assertTrue(); 1512 }).catch((err) => { 1513 console.log("faillll1" + `${err.code}`) 1514 expect(err == undefined).assertTrue(); 1515 }); 1516 }).catch((error) => { 1517 console.log("faillll2"`${error.code}`) 1518 expect(error == undefined).assertTrue(); 1519 }); 1520 } catch (e) { 1521 console.error('SingleKvStoreGetEntriesPromiseSucTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1522 expect(null).assertFail(); 1523 } 1524 done(); 1525 }) 1526 1527 /** 1528 * @tc.name SingleKvStoreGetEntriesPromiseClosedKVStoreTest 1529 * @tc.desc Test Js Api SingleKvStore.GetEntries() from a closed kvstore 1530 * @tc.type: FUNC 1531 * @tc.require: issueNumber 1532 */ 1533 it('SingleKvStoreGetEntriesPromiseClosedKVStoreTest', 0, async function (done) { 1534 try { 1535 var arr = new Uint8Array([21, 31]); 1536 let entries = []; 1537 for (var i = 0; i < 10; i++) { 1538 var key = 'batch_test_bool_key'; 1539 var entry = { 1540 key: key + i, 1541 value: { 1542 type: factory.ValueType.BYTE_ARRAY, 1543 value: arr 1544 } 1545 } 1546 entries.push(entry); 1547 } 1548 await kvStore.putBatch(entries).then(async (err) => { 1549 expect(err == undefined).assertTrue(); 1550 }).catch((err) => { 1551 expect(null).assertFail(); 1552 }); 1553 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 1554 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 1555 expect(true).assertTrue(); 1556 }).catch((err) => { 1557 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 1558 }); 1559 }) 1560 await kvStore.getEntries("batch_test").then(() => { 1561 expect(null).assertFail(); 1562 }).catch((err) => { 1563 expect(err.code == 15100005).assertTrue(); 1564 }); 1565 } catch (e) { 1566 console.error('SingleKvStoreGetEntriesPromiseSucTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1567 expect(null).assertFail(); 1568 } 1569 done(); 1570 }) 1571 1572 /** 1573 * @tc.name SingleKvStoreGetEntriesPromiseInvalidArgsTest 1574 * @tc.desc Test Js Api SingleKvStore.GetEntries() with invalid args 1575 * @tc.type: FUNC 1576 * @tc.require: issueNumber 1577 */ 1578 it('SingleKvStoreGetEntriesPromiseInvalidArgsTest', 0, async function (done) { 1579 console.info('SingleKvStoreGetEntriesPromiseInvalidArgsTest'); 1580 try { 1581 var arr = new Uint8Array([21, 31]); 1582 let entries = []; 1583 for (var i = 0; i < 10; i++) { 1584 var key = 'batch_test_bool_key'; 1585 var entry = { 1586 key: key + i, 1587 value: { 1588 type: factory.ValueType.BYTE_ARRAY, 1589 value: arr 1590 } 1591 } 1592 entries.push(entry); 1593 } 1594 await kvStore.putBatch(entries).then(async (err) => { 1595 expect(err == undefined).assertTrue(); 1596 await kvStore.getEntries().then(() => { 1597 expect(null).assertFail(); 1598 }).catch((err) => { 1599 expect(null).assertFail(); 1600 }); 1601 }).catch((err) => { 1602 expect(err.code == 401).assertTrue(); 1603 }); 1604 } catch (e) { 1605 console.error('SingleKvStoreGetEntriesPromiseInvalidArgsTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1606 expect(null).assertFail(); 1607 } 1608 done(); 1609 }) 1610 1611 /** 1612 * @tc.name SingleKvStorestartTransactionPromiseCommitTest 1613 * @tc.desc Test Js Api SingleKvStorestartTransaction with commit 1614 * @tc.type: FUNC 1615 * @tc.require: issueNumber 1616 */ 1617 it('SingleKvStorestartTransactionPromiseCommitTest', 0, async function (done) { 1618 console.info('SingleKvStorestartTransactionPromiseCommitTest'); 1619 try { 1620 var count = 0; 1621 kvStore.on('dataChange', factory.SubscribeType.SUBSCRIBE_TYPE_ALL, function (data) { 1622 count++; 1623 }); 1624 await kvStore.startTransaction().then(async (err) => { 1625 expect(err == undefined).assertTrue(); 1626 }).catch((err) => { 1627 expect(null).assertFail(); 1628 }); 1629 let entries = putBatchString(10, 'batch_test_string_key'); 1630 await kvStore.putBatch(entries).then(async (err) => { 1631 expect(err == undefined).assertTrue(); 1632 }).catch((err) => { 1633 expect(null).assertFail(); 1634 }); 1635 let keys = Object.keys(entries).slice(5); 1636 await kvStore.deleteBatch(keys).then((err) => { 1637 expect(err == undefined).assertTrue(); 1638 }).catch((err) => { 1639 expect(null).assertFail(); 1640 }); 1641 await kvStore.commit().then(async (err) => { 1642 expect(err == undefined).assertTrue(); 1643 }).catch((err) => { 1644 expect(null).assertFail(); 1645 }); 1646 await sleep(2000); 1647 expect(count == 1).assertTrue(); 1648 } catch (e) { 1649 expect(null).assertFail(); 1650 } 1651 done(); 1652 }) 1653 1654 /** 1655 * @tc.name SingleKvStorestartTransactionPromiseRollbackTest 1656 * @tc.desc Test Js Api SingleKvStorestartTransaction with Rollback 1657 * @tc.type: FUNC 1658 * @tc.require: issueNumber 1659 */ 1660 it('SingleKvStorestartTransactionPromiseRollbackTest', 0, async function (done) { 1661 console.info('SingleKvStorestartTransactionPromiseRollbackTest'); 1662 try { 1663 var count = 0; 1664 kvStore.on('dataChange', 0, function (data) { 1665 console.info('SingleKvStorestartTransactionPromiseRollbackTest ' + JSON.stringify(data)); 1666 count++; 1667 }); 1668 await kvStore.startTransaction().then(async (err) => { 1669 expect(err == undefined).assertTrue(); 1670 }).catch((err) => { 1671 expect(null).assertFail(); 1672 }); 1673 let entries = putBatchString(10, 'batch_test_string_key'); 1674 await kvStore.putBatch(entries).then(async (err) => { 1675 expect(err == undefined).assertTrue(); 1676 }).catch((err) => { 1677 expect(null).assertFail(); 1678 }); 1679 let keys = Object.keys(entries).slice(5); 1680 await kvStore.deleteBatch(keys).then((err) => { 1681 expect(err == undefined).assertTrue(); 1682 }).catch((err) => { 1683 expect(null).assertFail(); 1684 }); 1685 await kvStore.rollback().then(async (err) => { 1686 expect(err == undefined).assertTrue(); 1687 }).catch((err) => { 1688 expect(null).assertFail(); 1689 }); 1690 await sleep(2000); 1691 expect(count == 0).assertTrue(); 1692 } catch (e) { 1693 expect(null).assertFail(); 1694 } 1695 done(); 1696 }) 1697 1698 /** 1699 * @tc.name SingleKvStorestartTransactionPromiseClosedKVStoreTest 1700 * @tc.desc Test Js Api SingleKvStorestartTransaction with a closed kvstore 1701 * @tc.type: FUNC 1702 * @tc.require: issueNumber 1703 */ 1704 it('SingleKvStorestartTransactionPromiseClosedKVStoreTest', 0, async function (done) { 1705 try { 1706 var count = 0; 1707 kvStore.on('dataChange', 0, function (data) { 1708 count++; 1709 }); 1710 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 1711 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 1712 expect(true).assertTrue(); 1713 }).catch((err) => { 1714 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 1715 }); 1716 }) 1717 await kvStore.startTransaction().then(async (err) => { 1718 expect(null).assertFail(); 1719 }).catch((err) => { 1720 expect(err.code == 15100005).assertTrue(); 1721 }); 1722 1723 } catch (e) { 1724 expect(null).assertFail(); 1725 } 1726 done(); 1727 }) 1728 1729 /** 1730 * @tc.name SingleKvStorestartTransactionPromiseInvalidArgsTest 1731 * @tc.desc Test Js Api SingleKvStorestartTransaction with invalid args 1732 * @tc.type: FUNC 1733 * @tc.require: issueNumber 1734 */ 1735 it('SingleKvStorestartTransactionPromiseInvalidArgsTest', 0, async function (done) { 1736 console.info('SingleKvStorestartTransactionPromiseRollbackTest'); 1737 try { 1738 await kvStore.startTransaction(1).then(async (err) => { 1739 expect(null).assertFail(); 1740 }).catch((err) => { 1741 expect(true).assertTrue(); 1742 }); 1743 } catch (e) { 1744 expect(null).assertFail(); 1745 } 1746 done(); 1747 }) 1748 1749 /** 1750 * @tc.name SingleKvStoreCommitPromiseClosedKVStoreTest 1751 * @tc.desc Test Js Api SingleKvStoreCommit with a closed kvstore 1752 * @tc.type: FUNC 1753 * @tc.require: issueNumber 1754 */ 1755 it('SingleKvStoreCommitPromiseClosedKVStoreTest', 0, async function (done) { 1756 console.info('SingleKvStoreCommitPromiseClosedKVStoreTest'); 1757 try { 1758 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 1759 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 1760 expect(true).assertTrue(); 1761 }).catch((err) => { 1762 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 1763 }); 1764 }) 1765 await kvStore.commit().then(async (err) => { 1766 expect(null).assertFail(); 1767 }).catch((err) => { 1768 expect(err.code == 15100005).assertTrue(); 1769 }); 1770 } catch (e) { 1771 expect(null).assertFail(); 1772 } 1773 done(); 1774 }) 1775 1776 /** 1777 * @tc.name SingleKvStoreRollbackPromiseClosedKVStoreTest 1778 * @tc.desc Test Js Api SingleKvStoreRollback with a closed kvstore 1779 * @tc.type: FUNC 1780 * @tc.require: issueNumber 1781 */ 1782 it('SingleKvStoreRollbackPromiseClosedKVStoreTest', 0, async function (done) { 1783 try { 1784 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 1785 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 1786 expect(true).assertTrue(); 1787 }).catch((err) => { 1788 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 1789 }); 1790 }) 1791 await kvStore.rollback().then(async (err) => { 1792 expect(null).assertFail(); 1793 }).catch((err) => { 1794 expect(err.code == 15100005).assertTrue(); 1795 }); 1796 } catch (e) { 1797 expect(null).assertFail(); 1798 } 1799 done(); 1800 }) 1801 1802 /** 1803 * @tc.name SingleKvStoreEnableSyncPromiseTrueTest 1804 * @tc.desc Test Js Api SingleKvStoreEnableSync true 1805 * @tc.type: FUNC 1806 * @tc.require: issueNumber 1807 */ 1808 it('SingleKvStoreEnableSyncPromiseTrueTest', 0, async function (done) { 1809 try { 1810 await kvStore.enableSync(true).then((err) => { 1811 expect(err == undefined).assertTrue(); 1812 }).catch((err) => { 1813 expect(null).assertFail(); 1814 }); 1815 } catch (e) { 1816 expect(null).assertFail(); 1817 } 1818 done(); 1819 }) 1820 1821 /** 1822 * @tc.name SingleKvStoreEnableSyncPromiseFalseTest 1823 * @tc.desc Test Js Api SingleKvStoreEnableSync false 1824 * @tc.type: FUNC 1825 * @tc.require: issueNumber 1826 */ 1827 it('SingleKvStoreEnableSyncPromiseFalseTest', 0, async function (done) { 1828 console.info('SingleKvStoreEnableSyncPromiseFalseTest'); 1829 try { 1830 await kvStore.enableSync(false).then((err) => { 1831 expect(err == undefined).assertTrue(); 1832 }).catch((err) => { 1833 expect(null).assertFail(); 1834 }); 1835 } catch (e) { 1836 expect(null).assertFail(); 1837 } 1838 done(); 1839 }) 1840 1841 /** 1842 * @tc.name SingleKvStoreEnableSyncPromiseInvalidArgsTest 1843 * @tc.desc Test Js Api SingleKvStoreEnableSync with invalid args 1844 * @tc.type: FUNC 1845 * @tc.require: issueNumber 1846 */ 1847 it('SingleKvStoreEnableSyncPromiseInvalidArgsTest', 0, async function (done) { 1848 try { 1849 await kvStore.enableSync().then((err) => { 1850 expect(null).assertFail(); 1851 }).catch((err) => { 1852 expect(null).assertFail(); 1853 }); 1854 } catch (e) { 1855 expect(e.code == 401).assertTrue(); 1856 } 1857 done(); 1858 }) 1859 1860 /** 1861 * @tc.name SingleKvStoreSetSyncRangePromiseSameTest 1862 * @tc.desc Test Js Api SingleKvStore.SetSyncRange() with same range 1863 * @tc.type: FUNC 1864 * @tc.require: issueNumber 1865 */ 1866 it('SingleKvStoreSetSyncRangePromiseSameTest', 0, async function (done) { 1867 try { 1868 var localLabels = ['A', 'B']; 1869 var remoteSupportLabels = ['A', 'B']; 1870 await kvStore.setSyncRange(localLabels, remoteSupportLabels).then((err) => { 1871 expect(err == undefined).assertTrue(); 1872 }).catch((err) => { 1873 expect(null).assertFail(); 1874 }); 1875 } catch (e) { 1876 expect(null).assertFail(); 1877 } 1878 done(); 1879 }) 1880 1881 /** 1882 * @tc.name SingleKvStoreSetSyncRangePromiseSameTest 1883 * @tc.desc Test Js Api SingleKvStore.SetSyncRange() with invalid args 1884 * @tc.type: FUNC 1885 * @tc.require: issueNumber 1886 */ 1887 it('SingleKvStoreSetSyncRangePromiseSameTest', 0, async function (done) { 1888 try { 1889 await kvStore.setSyncRange().then((err) => { 1890 expect(null).assertFail(); 1891 }).catch((err) => { 1892 expect(null).assertFail(); 1893 }); 1894 } catch (e) { 1895 expect(e.code == 401).assertTrue(); 1896 } 1897 done(); 1898 }) 1899 1900 /** 1901 * @tc.name SingleKvStoreRemoveDeviceDataPromiseInvalidArgsTest 1902 * @tc.desc Test Js Api SingleKvStoreRemoveDeviceData with invalid args 1903 * @tc.type: FUNC 1904 * @tc.require: issueNumber 1905 */ 1906 it('SingleKvStoreRemoveDeviceDataPromiseInvalidArgsTest', 0, async function (done) { 1907 console.info('SingleKvStoreRemoveDeviceDataPromiseInvalidArgsTest'); 1908 try { 1909 await kvStore.removeDeviceData().then((err) => { 1910 console.info('SingleKvStoreRemoveDeviceDataPromiseInvalidArgsTest removeDeviceData success'); 1911 expect(null).assertFail(); 1912 }).catch((err) => { 1913 console.error('SingleKvStoreRemoveDeviceDataPromiseInvalidArgsTest removeDeviceData fail' + `, error code is ${err.code}, message is ${err.message}`); 1914 expect(null).assertFail(); 1915 }); 1916 } catch (e) { 1917 console.error('SingleKvStoreRemoveDeviceDataPromiseInvalidArgsTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1918 expect(e.code == 401).assertTrue(); 1919 } 1920 done(); 1921 }) 1922 1923 /** 1924 * @tc.name SingleKvStoreRemoveDeviceDataPromiseClosedKVStoreTest 1925 * @tc.desc Test Js Api SingleKvStoreRemoveDeviceData in a closed kvstore 1926 * @tc.type: FUNC 1927 * @tc.require: issueNumber 1928 */ 1929 it('SingleKvStoreRemoveDeviceDataPromiseClosedKVStoreTest', 0, async function (done) { 1930 try { 1931 await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then((err) => { 1932 expect(err == undefined).assertTrue(); 1933 }).catch((err) => { 1934 expect(null).assertFail(); 1935 }); 1936 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 1937 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 1938 expect(true).assertTrue(); 1939 }).catch((err) => { 1940 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 1941 expect(null).assertFail(); 1942 }); 1943 }) 1944 var deviceid = 'no_exist_device_id'; 1945 await kvStore.removeDeviceData(deviceid).then(() => { 1946 console.error('SingleKvStoreRemoveDeviceDataPromiseClosedKVStoreTest removeDeviceData success'); 1947 expect(null).assertFail(); 1948 }).catch((err) => { 1949 console.info('SingleKvStoreRemoveDeviceDataPromiseClosedKVStoreTest removeDeviceData fail' + `, error code is ${err.code}, message is ${err.message}`); 1950 expect(err.code == 15100005).assertTrue(); 1951 }); 1952 1953 } catch (e) { 1954 console.error('SingleKvStoreRemoveDeviceDataPromiseClosedKVStoreTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1955 expect(null).assertFail(); 1956 } 1957 done(); 1958 }) 1959 1960 /** 1961 * @tc.name SingleKvStoreSetSyncParamPromiseSucTest 1962 * @tc.desc Test Js Api SingleKvStoreSetSyncParam success 1963 * @tc.type: FUNC 1964 * @tc.require: issueNumber 1965 */ 1966 it('SingleKvStoreSetSyncParamPromiseSucTest', 0, async function (done) { 1967 try { 1968 var defaultAllowedDelayMs = 500; 1969 await kvStore.setSyncParam(defaultAllowedDelayMs).then((err) => { 1970 expect(err == undefined).assertTrue(); 1971 }).catch((err) => { 1972 expect(null).assertFail(); 1973 }); 1974 } catch (e) { 1975 expect(null).assertFail(); 1976 } 1977 done(); 1978 }) 1979 1980 /** 1981 * @tc.name SingleKvStoreSetSyncParamPromiseInvalidArgsTest 1982 * @tc.desc Test Js Api SingleKvStoreSetSyncParam with invalid args 1983 * @tc.type: FUNC 1984 * @tc.require: issueNumber 1985 */ 1986 it('SingleKvStoreSetSyncParamPromiseInvalidArgsTest', 0, async function (done) { 1987 console.info('SingleKvStoreSetSyncParamPromiseInvalidArgsTest'); 1988 try { 1989 await kvStore.setSyncParam().then((err) => { 1990 expect(null).assertFail(); 1991 }).catch((err) => { 1992 expect(null).assertFail(); 1993 }); 1994 } catch (e) { 1995 console.error('SingleKvStoreSetSyncParamPromiseInvalidArgsTest fail' + `, error code is ${e.code}, message is ${e.message}`); 1996 expect(e.code == 401).assertTrue(); 1997 } 1998 done(); 1999 }) 2000 2001 /** 2002 * @tc.name SingleKvStoreGetSecurityLevelPromiseSucTest 2003 * @tc.desc Test Js Api SingleKvStoreGetSecurityLevel success 2004 * @tc.type: FUNC 2005 * @tc.require: issueNumber 2006 */ 2007 it('SingleKvStoreGetSecurityLevelPromiseSucTest', 0, async function (done) { 2008 console.info('SingleKvStoreGetSecurityLevelPromiseSucTest'); 2009 try { 2010 await kvStore.getSecurityLevel().then((data) => { 2011 expect(data == factory.SecurityLevel.S2).assertTrue(); 2012 }).catch((err) => { 2013 expect(null).assertFail(); 2014 }); 2015 } catch (e) { 2016 expect(null).assertFail(); 2017 } 2018 done(); 2019 }) 2020 2021 /** 2022 * @tc.name SingleKvStoreGetSecurityLevelPromiseClosedKvStoreTest 2023 * @tc.desc Test Js Api SingleKvStoreGetSecurityLevel from a closed kvstore 2024 * @tc.type: FUNC 2025 * @tc.require: issueNumber 2026 */ 2027 it('SingleKvStoreGetSecurityLevelPromiseSucTest', 0, async function (done) { 2028 console.info('SingleKvStoreGetSecurityLevelPromiseSucTest'); 2029 try { 2030 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 2031 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 2032 expect(true).assertTrue(); 2033 }).catch((err) => { 2034 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 2035 }); 2036 }) 2037 await kvStore.getSecurityLevel().then((data) => { 2038 expect(null).assertFail(); 2039 }).catch((err) => { 2040 console.error('SingleKvStoreGetSecurityLevelPromiseSucTest getSecurityLevel fail' + `, error code is ${err.code}, message is ${err.message}`); 2041 expect(err.code == 15100005).assertTrue(); 2042 }); 2043 } catch (e) { 2044 console.error('SingleKvStoreGetSecurityLevelPromiseSucTest fail' + `, error code is ${e.code}, message is ${e.message}`); 2045 expect(null).assertFail(); 2046 } 2047 done(); 2048 }) 2049 2050 /** 2051 * @tc.name SingleKvStoreGetResultSetPromiseSucTest 2052 * @tc.desc Test Js Api SingleKvStoreGetResultSet success 2053 * @tc.type: FUNC 2054 * @tc.require: issueNumber 2055 */ 2056 it('SingleKvStoreGetResultSetPromiseSucTest', 0, async function (done) { 2057 console.info('SingleKvStoreGetResultSetPromiseSucTest'); 2058 try { 2059 let resultSet; 2060 let entries = []; 2061 for (var i = 0; i < 10; i++) { 2062 var key = 'batch_test_string_key'; 2063 var entry = { 2064 key: key + i, 2065 value: { 2066 type: factory.ValueType.STRING, 2067 value: 'batch_test_string_value' 2068 } 2069 } 2070 entries.push(entry); 2071 } 2072 await kvStore.putBatch(entries).then(async (err) => { 2073 expect(err == undefined).assertTrue(); 2074 }).catch((err) => { 2075 expect(null).assertFail(); 2076 }); 2077 await kvStore.getResultSet('batch_test_string_key').then((result) => { 2078 resultSet = result; 2079 expect(resultSet.getCount() == 10).assertTrue(); 2080 }).catch((err) => { 2081 expect(null).assertFail(); 2082 }); 2083 await kvStore.closeResultSet(resultSet).then((err) => { 2084 expect(err == undefined).assertTrue(); 2085 }).catch((err) => { 2086 expect(null).assertFail(); 2087 }); 2088 } catch (e) { 2089 console.error('SingleKvStoreGetResultSetPromiseSucTest fail' + `, error code is ${e.code}, message is ${e.message}`); 2090 expect(null).assertFail(); 2091 } 2092 done(); 2093 }) 2094 2095 /** 2096 * @tc.name SingleKvStoreGetResultSetPromiseInvalidArgsTest 2097 * @tc.desc Test Js Api SingleKvStoreGetResultSet with invalid args 2098 * @tc.type: FUNC 2099 * @tc.require: issueNumber 2100 */ 2101 it('SingleKvStoreGetResultSetPromiseInvalidArgsTest', 0, async function (done) { 2102 console.info('SingleKvStoreGetResultSetPromiseInvalidArgsTest'); 2103 try { 2104 let resultSet; 2105 await kvStore.getResultSet().then((result) => { 2106 console.info('SingleKvStoreGetResultSetPromiseInvalidArgsTest getResultSet success'); 2107 expect(null).assertFail(); 2108 }).catch((err) => { 2109 console.error('SingleKvStoreGetResultSetPromiseInvalidArgsTest getResultSet fail' + `, error code is ${err.code}, message is ${err.message}`); 2110 expect(null).assertFail(); 2111 }); 2112 } catch (e) { 2113 console.error('SingleKvStoreGetResultSetPromiseInvalidArgsTest fail' + `, error code is ${e.code}, message is ${e.message}`); 2114 expect(e.code == 401).assertTrue(); 2115 } 2116 done(); 2117 }) 2118 2119 /** 2120 * @tc.name SingleKvStoreGetResultSetPromiseClosedKVStoreTest 2121 * @tc.desc Test Js Api SingleKvStoreGetResultSet from a closed kvstore 2122 * @tc.type: FUNC 2123 * @tc.require: issueNumber 2124 */ 2125 it('SingleKvStoreGetResultSetPromiseClosedKVStoreTest', 0, async function (done) { 2126 try { 2127 let resultSet; 2128 let entries = []; 2129 await kvStore.putBatch(entries).then(async (err) => { 2130 expect(err == undefined).assertTrue(); 2131 }).catch((err) => { 2132 expect(null).assertFail(); 2133 }); 2134 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 2135 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 2136 expect(true).assertTrue(); 2137 }).catch((err) => { 2138 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 2139 }); 2140 }); 2141 await kvStore.getResultSet('batch_test_string_key').then((result) => { 2142 expect(null).assertFail(); 2143 }).catch((err) => { 2144 console.error('SingleKvStoreGetResultSetPromiseClosedKVStoreTest getResultSet fail' + `, error code is ${err.code}, message is ${err.message}`); 2145 expect(err.code == 15100005).assertTrue(); 2146 }); 2147 } catch (e) { 2148 console.error('SingleKvStoreGetResultSetPromiseClosedKVStoreTest fail' + `, error code is ${e.code}, message is ${e.message}`); 2149 expect(null).assertFail(); 2150 } 2151 done(); 2152 }) 2153 2154 /** 2155 * @tc.name SingleKvStoreGetResultSetPromiseQueryTest 2156 * @tc.desc Test Js Api SingleKvStoreGetResultSet with query 2157 * @tc.type: FUNC 2158 * @tc.require: issueNumber 2159 */ 2160 it('SingleKvStoreGetResultSetPromiseQueryTest', 0, async function (done) { 2161 console.info('SingleKvStoreGetResultSetPromiseQueryTest'); 2162 try { 2163 let resultSet; 2164 let entries = []; 2165 for (var i = 0; i < 10; i++) { 2166 var key = 'batch_test_string_key'; 2167 var entry = { 2168 key: key + i, 2169 value: { 2170 type: factory.ValueType.STRING, 2171 value: 'batch_test_string_value' 2172 } 2173 } 2174 entries.push(entry); 2175 } 2176 await kvStore.putBatch(entries).then(async (err) => { 2177 console.info('SingleKvStoreGetResultSetPromiseQueryTest putBatch success'); 2178 expect(err == undefined).assertTrue(); 2179 }).catch((err) => { 2180 console.error('SingleKvStorePutBatchPromiseStringTest putBatch fail' + `, error code is ${err.code}, message is ${err.message}`); 2181 expect(null).assertFail(); 2182 }); 2183 var query = new factory.Query(); 2184 query.prefixKey("batch_test"); 2185 await kvStore.getResultSet(query).then((result) => { 2186 console.info('SingleKvStoreGetResultSetPromiseQueryTest getResultSet success'); 2187 resultSet = result; 2188 expect(resultSet.getCount() == 10).assertTrue(); 2189 }).catch((err) => { 2190 console.error('SingleKvStoreGetResultSetPromiseQueryTest getResultSet fail' + `, error code is ${err.code}, message is ${err.message}`); 2191 expect(null).assertFail(); 2192 }); 2193 await kvStore.closeResultSet(resultSet).then((err) => { 2194 console.info('SingleKvStoreGetResultSetPromiseQueryTest closeResultSet success'); 2195 expect(err == undefined).assertTrue(); 2196 }).catch((err) => { 2197 console.error('SingleKvStoreGetResultSetPromiseQueryTest closeResultSet fail' + `, error code is ${err.code}, message is ${err.message}`); 2198 expect(null).assertFail(); 2199 }); 2200 } catch (e) { 2201 console.error('SingleKvStoreGetResultSetPromiseQueryTest fail' + `, error code is ${e.code}, message is ${e.message}`); 2202 expect(null).assertFail(); 2203 } 2204 done(); 2205 }) 2206 2207 /** 2208 * @tc.name SingleKvStoreGetResultSetQueryPromiseClosedKVStoreTest 2209 * @tc.desc Test Js Api SingleKvStoreGetResultSet query from a closed kvstore 2210 * @tc.type: FUNC 2211 * @tc.require: issueNumber 2212 */ 2213 it('SingleKvStoreGetResultSetQueryPromiseClosedKVStoreTest', 0, async function (done) { 2214 try { 2215 let resultSet; 2216 let entries = []; 2217 for (var i = 0; i < 10; i++) { 2218 var key = 'batch_test_string_key'; 2219 var entry = { 2220 key: key + i, 2221 value: { 2222 type: factory.ValueType.STRING, 2223 value: 'batch_test_string_value' 2224 } 2225 } 2226 entries.push(entry); 2227 } 2228 await kvStore.putBatch(entries).then(async (err) => { 2229 expect(err == undefined).assertTrue(); 2230 }).catch((err) => { 2231 expect(null).assertFail(); 2232 }); 2233 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 2234 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 2235 expect(true).assertTrue(); 2236 }).catch((err) => { 2237 console.error('deleteKVStore err ' + `, error code is ${err.code}, message is ${err.message}`); 2238 }); 2239 }); 2240 var query = new factory.Query(); 2241 query.prefixKey("batch_test"); 2242 await kvStore.getResultSet(query).then((result) => { 2243 expect(null).assertFail(); 2244 }).catch((err) => { 2245 expect(err.code == 15100005).assertTrue(); 2246 }); 2247 } catch (e) { 2248 console.error('SingleKvStoreGetResultSetQueryPromiseClosedKVStoreTest fail' + `, error code is ${e.code}, message is ${e.message}`); 2249 expect(null).assertFail(); 2250 } 2251 done(); 2252 }) 2253 2254 /** 2255 * @tc.name SingleKvStoreGetResultSetPredicatesPromiseTest 2256 * @tc.desc Test Js Api SingleKvStore.GetResultSet() with predicates 2257 * @tc.type: FUNC 2258 * @tc.require: issueNumber 2259 */ 2260 it('SingleKvStoreGetResultSetPredicatesPromiseTest', 0, async function (done) { 2261 console.log('SingleKvStoreGetResultSetPredicatesPromiseTest'); 2262 try { 2263 let entries = []; 2264 let resultSet; 2265 for (let i = 0; i < 10; i++) { 2266 let key = 'name_'; 2267 let value = 'Bob_' 2268 let entry = { 2269 key: key + i, 2270 value: { 2271 type: factory.ValueType.STRING, 2272 value: value + i 2273 } 2274 } 2275 entries.push(entry); 2276 } 2277 await kvStore.putBatch(entries).then(async (err) => { 2278 expect(err == undefined).assertTrue(); 2279 }).catch((err) => { 2280 expect(null).assertFail(); 2281 }); 2282 let predicates = new dataShare.DataSharePredicates(); 2283 predicates.prefixKey("name_"); 2284 await kvStore.getResultSet(predicates).then((result) => { 2285 console.error('SingleKvStoreGetResultSetPredicatesPromiseTest getResultSet success'); 2286 expect(null).assertFail(); 2287 }).catch((err) => { 2288 console.error('SingleKvStoreGetResultSetPredicatesPromiseTest getResultSet fail' + `, error code is ${err.code}, message is ${err.message}`); 2289 expect(null).assertFail(); 2290 }); 2291 } catch (e) { 2292 console.info('SingleKvStoreGetResultSetPredicatesPromiseTest fail' + `, error code is ${e.code}, message is ${e.message}`); 2293 expect(e.code == 202).assertTrue(); 2294 } 2295 done(); 2296 }) 2297 2298 /** 2299 * @tc.name SingleKvStoreGetResultSetPredicatesPromiseClosedKVStoreTest 2300 * @tc.desc Test Js Api SingleKvStoreGetResultSet predicates from a closed kvstore 2301 * @tc.type: FUNC 2302 * @tc.require: issueNumber 2303 */ 2304 it('SingleKvStoreGetResultSetPredicatesPromiseClosedKVStoreTest', 0, async function (done) { 2305 try { 2306 let resultSet; 2307 let entries = []; 2308 for (var i = 0; i < 10; i++) { 2309 var key = 'batch_test_string_key'; 2310 var entry = { 2311 key: key + i, 2312 value: { 2313 type: factory.ValueType.STRING, 2314 value: 'batch_test_string_value' 2315 } 2316 } 2317 entries.push(entry); 2318 } 2319 await kvStore.putBatch(entries).then(async (err) => { 2320 expect(err == undefined).assertTrue(); 2321 }).catch((err) => { 2322 expect(null).assertFail(); 2323 }); 2324 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 2325 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 2326 expect(true).assertTrue(); 2327 }).catch((err) => { 2328 console.error('SingleKvStoreGetResultSetPredicatesPromiseClosedKVStoreTest deleteKVStore fail' + `, error code is ${err.code}, message is ${err.message}`); 2329 }); 2330 }); 2331 let predicates = new dataShare.DataSharePredicates(); 2332 predicates.prefixKey("batch_test"); 2333 await kvStore.getResultSet(predicates).then((result) => { 2334 console.error('SingleKvStoreGetResultSetPredicatesPromiseClosedKVStoreTest getResultSet success'); 2335 expect(null).assertFail(); 2336 }).catch((err) => { 2337 console.error('SingleKvStoreGetResultSetPredicatesPromiseClosedKVStoreTest getResultSet fail' + `, error code is ${err.code}, message is ${err.message}`); 2338 expect(null).assertFail(); 2339 }); 2340 } catch (e) { 2341 console.info('SingleKvStoreGetResultSetPredicatesPromiseClosedKVStoreTest fail' + `, error code is ${e.code}, message is ${e.message}`); 2342 expect(e.code == 202).assertTrue(); 2343 } 2344 done(); 2345 }) 2346 2347 /** 2348 * @tc.name SingleKvStoreCloseResultSetPromiseSucTest 2349 * @tc.desc Test Js Api SingleKvStoreCloseResultSet success 2350 * @tc.type: FUNC 2351 * @tc.require: issueNumber 2352 */ 2353 it('SingleKvStoreCloseResultSetPromiseSucTest', 0, async function (done) { 2354 console.info('SingleKvStoreCloseResultSetPromiseSucTest'); 2355 try { 2356 console.info('SingleKvStoreCloseResultSetPromiseSucTest success'); 2357 let resultSet = null; 2358 await kvStore.getResultSet('batch_test_string_key').then((result) => { 2359 console.info('SingleKvStoreCloseResultSetPromiseSucTest getResultSet success'); 2360 resultSet = result; 2361 }).catch((err) => { 2362 console.error('SingleKvStoreCloseResultSetPromiseSucTest getResultSet fail' + `, error code is ${err.code}, message is ${err.message}`); 2363 expect(null).assertFail(); 2364 }); 2365 await kvStore.closeResultSet(resultSet).then((err) => { 2366 console.info('SingleKvStoreCloseResultSetPromiseSucTest closeResultSet success'); 2367 expect(err == undefined).assertTrue(); 2368 }).catch((err) => { 2369 console.error('SingleKvStoreCloseResultSetPromiseSucTest closeResultSet fail' + `, error code is ${err.code}, message is ${err.message}`); 2370 expect(null).assertFail(); 2371 }); 2372 } catch (e) { 2373 console.error('SingleKvStoreCloseResultSetPromiseSucTest fail' + `, error code is ${e.code}, message is ${e.message}`); 2374 expect(null).assertFail(); 2375 } 2376 done(); 2377 }) 2378 2379 /** 2380 * @tc.name SingleKvStoreCloseResultSetPromiseInvalidArgsTest 2381 * @tc.desc Test Js Api SingleKvStoreCloseResultSet with invalid args 2382 * @tc.type: FUNC 2383 * @tc.require: issueNumber 2384 */ 2385 it('SingleKvStoreCloseResultSetPromiseInvalidArgsTest', 0, async function (done) { 2386 try { 2387 await kvStore.closeResultSet().then(() => { 2388 expect(null).assertFail(); 2389 }).catch((err) => { 2390 console.error('SingleKvStoreCloseResultSetPromiseInvalidArgsTest closeResultSet fail' + `, error code is ${err.code}, message is ${err.message}`); 2391 }); 2392 } catch (e) { 2393 console.error('SingleKvStoreCloseResultSetPromiseInvalidArgsTest fail' + `, error code is ${e.code}, message is ${e.message}`); 2394 expect(e.code == 401).assertTrue(); 2395 } 2396 done(); 2397 }) 2398 2399 /** 2400 * @tc.name SingleKvStoreGetResultSizePromiseQueryTest 2401 * @tc.desc Test Js Api SingleKvStoreGetResultSize with query 2402 * @tc.type: FUNC 2403 * @tc.require: issueNumber 2404 */ 2405 it('SingleKvStoreGetResultSizePromiseQueryTest', 0, async function (done) { 2406 try { 2407 let entries = []; 2408 for (var i = 0; i < 10; i++) { 2409 var key = 'batch_test_string_key'; 2410 var entry = { 2411 key: key + i, 2412 value: { 2413 type: factory.ValueType.STRING, 2414 value: 'batch_test_string_value' 2415 } 2416 } 2417 entries.push(entry); 2418 } 2419 await kvStore.putBatch(entries).then(async (err) => { 2420 console.info('SingleKvStoreGetResultSizePromiseQueryTest putBatch success'); 2421 expect(err == undefined).assertTrue(); 2422 }).catch((err) => { 2423 console.error('SingleKvStoreGetResultSizePromiseQueryTest putBatch fail' + `, error code is ${err.code}, message is ${err.message}`); 2424 expect(null).assertFail(); 2425 }); 2426 var query = new factory.Query(); 2427 query.prefixKey("batch_test"); 2428 await kvStore.getResultSize(query).then((resultSize) => { 2429 console.info('SingleKvStoreGetResultSizePromiseQueryTest getResultSet success'); 2430 expect(resultSize == 10).assertTrue(); 2431 }).catch((err) => { 2432 console.error('SingleKvStoreGetResultSizePromiseQueryTest getResultSet fail' + `, error code is ${err.code}, message is ${err.message}`); 2433 expect(null).assertFail(); 2434 }); 2435 } catch (e) { 2436 console.error('SingleKvStoreGetResultSizePromiseQueryTest fail' + `, error code is ${e.code}, message is ${e.message}`); 2437 expect(null).assertFail(); 2438 } 2439 done(); 2440 }) 2441 2442 /** 2443 * @tc.name SingleKvStoreGetResultSizePromiseInvalidArgsTest 2444 * @tc.desc Test Js Api SingleKvStoreGetResultSize with invalid args 2445 * @tc.type: FUNC 2446 * @tc.require: issueNumber 2447 */ 2448 it('SingleKvStoreGetResultSizePromiseInvalidArgsTest', 0, async function (done) { 2449 try { 2450 let entries = []; 2451 for (var i = 0; i < 10; i++) { 2452 var key = 'batch_test_string_key'; 2453 var entry = { 2454 key: key + i, 2455 value: { 2456 type: factory.ValueType.STRING, 2457 value: 'batch_test_string_value' 2458 } 2459 } 2460 entries.push(entry); 2461 } 2462 await kvStore.putBatch(entries).then(async (err) => { 2463 expect(err == undefined).assertTrue(); 2464 }).catch((err) => { 2465 expect(null).assertFail(); 2466 }); 2467 await kvStore.getResultSize().then(() => { 2468 expect(null).assertFail(); 2469 }).catch((err) => { 2470 expect(null).assertFail(); 2471 }); 2472 } catch (e) { 2473 console.error('SingleKvStoreGetResultSizePromiseInvalidArgsTest fail' + `, error code is ${e.code}, message is ${e.message}`); 2474 expect(e.code == 401).assertTrue(); 2475 } 2476 done(); 2477 }) 2478 2479 /** 2480 * @tc.name SingleKvStoreGetResultSizePromiseClosedKVStoreTest 2481 * @tc.desc Test Js Api SingleKvStoreGetResultSize from a closed kvstore 2482 * @tc.type: FUNC 2483 * @tc.require: issueNumber 2484 */ 2485 it('SingleKvStoreGetResultSizePromiseClosedKVStoreTest', 0, async function (done) { 2486 try { 2487 let entries = []; 2488 for (var i = 0; i < 10; i++) { 2489 var key = 'batch_test_string_key'; 2490 var entry = { 2491 key: key + i, 2492 value: { 2493 type: factory.ValueType.STRING, 2494 value: 'batch_test_string_value' 2495 } 2496 } 2497 entries.push(entry); 2498 } 2499 await kvStore.putBatch(entries).then(async (err) => { 2500 expect(err == undefined).assertTrue(); 2501 }).catch((err) => { 2502 expect(null).assertFail(); 2503 }); 2504 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 2505 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 2506 expect(true).assertTrue(); 2507 }).catch((err) => { 2508 console.error('SingleKvStoreGetResultSizePromiseClosedKVStoreTest deleteKVStore fail' + `, error code is ${err.code}, message is ${err.message}`); 2509 }); 2510 }); 2511 var query = new factory.Query(); 2512 query.prefixKey("batch_test"); 2513 await kvStore.getResultSize(query).then(() => { 2514 console.info('SingleKvStoreGetResultSizePromiseClosedKVStoreTest getResultSet success'); 2515 expect(null).assertFail(); 2516 }).catch((err) => { 2517 console.error('SingleKvStoreGetResultSizePromiseClosedKVStoreTest getResultSet fail' + `, error code is ${err.code}, message is ${err.message}`); 2518 expect(err.code == 15100005).assertTrue(); 2519 }); 2520 } catch (e) { 2521 console.error('SingleKvStoreGetResultSizePromiseClosedKVStoreTest fail' + `, error code is ${e.code}, message is ${e.message}`); 2522 expect(null).assertFail(); 2523 } 2524 done(); 2525 }) 2526 2527 /** 2528 * @tc.name SingleKvStoreChangeNotificationPromiseTest 2529 * @tc.desc Test Js Api SingleKvStoreChangeNotification 2530 * @tc.type: FUNC 2531 * @tc.require: issueNumber 2532 */ 2533 it('SingleKvStoreChangeNotificationPromiseTest', 0, async function (done) { 2534 var getInsertEntries = new Promise((resolve, reject) => { 2535 kvStore.on('dataChange', 0, function (ChangeNotification) { 2536 resolve(ChangeNotification.insertEntries); 2537 }); 2538 kvStore.put("getInsertEntries", "byPut").then(() => { 2539 console.info('SingleKvStoreChangeNotificationPromiseTest put success'); 2540 }); 2541 }); 2542 await getInsertEntries.then(function (insertEntries) { 2543 console.info('SingleKvStoreChangeNotificationPromiseTest getInsertEntries' + JSON.stringify(insertEntries)); 2544 expect(insertEntries != null).assertTrue(); 2545 }).catch((error) => { 2546 console.error('SingleKvStoreChangeNotificationPromiseTest getInsertEntries fail' + `, error code is ${error.code}, message is ${error.message}`); 2547 expect(null).assertFail(); 2548 }); 2549 done(); 2550 }) 2551 2552 /** 2553 * @tc.name SingleKvStoreChangeNotificationPromisePutTest 2554 * @tc.desc Test Js Api SingleKvStoreChangeNotification put 2555 * @tc.type: FUNC 2556 * @tc.require: issueNumber 2557 */ 2558 it('SingleKvStoreChangeNotificationPromisePutTest', 0, async function (done) { 2559 await kvStore.put('getUpdateEntries', 'byPut').then(() => { 2560 console.info('SingleKvStoreChangeNotificationPromisePutTest put success'); 2561 }); 2562 var getUpdateEntries = new Promise((resolve, reject) => { 2563 kvStore.on('dataChange', 0, function (ChangeNotification) { 2564 resolve(ChangeNotification.updateEntries); 2565 }); 2566 kvStore.put("getUpdateEntries", "byPut").then(() => { 2567 console.info('SingleKvStoreChangeNotificationPromisePutTest update success'); 2568 }); 2569 }); 2570 await getUpdateEntries.then(function (updateEntries) { 2571 console.info('SingleKvStoreChangeNotificationPromisePutTest getUpdateEntries' + JSON.stringify(updateEntries)); 2572 expect(updateEntries != null).assertTrue(); 2573 }).catch((error) => { 2574 console.error('SingleKvStoreChangeNotificationPromisePutTest getUpdateEntries fail' + `, error code is ${error.code}, message is ${error.message}`); 2575 expect(null).assertFail(); 2576 }); 2577 done(); 2578 }) 2579 2580 /** 2581 * @tc.name SingleKvStoreChangeNotificationPromiseDeleteTest 2582 * @tc.desc Test Js Api SingleKvStoreChangeNotification delete 2583 * @tc.type: FUNC 2584 * @tc.require: issueNumber 2585 */ 2586 it('SingleKvStoreChangeNotificationPromiseDeleteTest', 0, async function (done) { 2587 await kvStore.put('deleteEntries', 'byPut').then(() => { 2588 console.info('SingleKvStoreChangeNotificationPromiseDeleteTest put success'); 2589 }); 2590 var getdeleteEntries = new Promise((resolve, reject) => { 2591 kvStore.on('dataChange', 0, function (ChangeNotification) { 2592 resolve(ChangeNotification.deleteEntries); 2593 }); 2594 kvStore.delete("deleteEntries").then(() => { 2595 console.info('SingleKvStoreChangeNotificationPromiseDeleteTest delete success'); 2596 }); 2597 }); 2598 await getdeleteEntries.then(function (deleteEntries) { 2599 console.info('SingleKvStoreChangeNotificationPromiseDeleteTest getdeleteEntries' + JSON.stringify(getdeleteEntries)); 2600 expect(deleteEntries != null).assertTrue(); 2601 }).catch((error) => { 2602 console.error('SingleKvStoreChangeNotificationPromiseDeleteTest getdeleteEntries fail' + `, error code is ${error.code}, message is ${error.message}`); 2603 expect(null).assertFail(); 2604 }); 2605 done(); 2606 }) 2607}) 2608