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