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