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