1/* 2 * Copyright (C) 2024 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, Level, Size, TestType } from "@ohos/hypium"; 17import deviceManager from '@ohos.distributedDeviceManager'; 18import TestService from '../../../../../../../../../../testtools/disjsTest/client/testService.js'; 19import RemoteHelper from '../../../../../../../../../../testtools/disjsTest/client/remoteHelper.js'; 20import factory from '@ohos.data.distributedKVStore'; 21import { UiDriver, BY } from '@ohos.UiTest' 22import featureAbility from '@ohos.ability.featureAbility'; 23import deviceinfo from '@ohos.deviceInfo' 24 25const bundleNameKv = "com.acts.distributekvdisjs"; 26const abilityNameKv = "com.acts.distributekvdisjs.MainAbility"; 27 28let localDeviceId = undefined; 29let logTag = 'RpcClient: '; 30let testservice = null; 31let gIRemoteObject = null; 32let remoteHelpers = null; 33let deviceId = null; 34let kvManager = null; 35let kvStore = null; 36let syncDeviceIds = undefined; 37let deviceList = undefined; 38let dmInstance = undefined; 39 40const PULL = factory.SyncMode.PULL_ONLY; 41const PUSH = factory.SyncMode.PUSH_ONLY; 42const PUSH_PULL = factory.SyncMode.PUSH_PULL; 43const TEST_STRING_KEY = "TEST_STRING_KEY"; 44const TEST_STRING_VALUE = "TEST_STRING_VALUE"; 45const TEST_INT_KEY = "TEST_INT_KEY"; 46const TEST_INT_VALUE = 1; 47const TEST_FLOAT_KEY = "TEST_FLOAT_KEY"; 48const TEST_FLOAT_VALUE = 1.1; 49const TEST_STORE_ID = 'clientStoreId'; 50const SERVET_STORE_ID = 'clientStoreId'; 51const TEST_BUNDLE_NAME = 'com.acts.distributekvdisjs'; 52 53 54let g_context = featureAbility.getContext(); 55const config = { 56 context: g_context, 57 bundleName: TEST_BUNDLE_NAME, 58} 59 60 61function sleep(ms) { 62 return new Promise(resolve => setTimeout(resolve, ms)); 63} 64 65//检查当前应用是否有可信的设备 66async function checkAvailableDevice() { 67 console.info(logTag + "checkAvailableDevice in "); 68 dmInstance = deviceManager.createDeviceManager(TEST_BUNDLE_NAME); 69 deviceList = dmInstance.getAvailableDeviceListSync(); 70 console.info(logTag + "checkAvailableDevice get deviceList " + JSON.stringify(deviceList)); 71 if (deviceList.length != 0) { 72 console.info(logTag + "return false "); 73 return false; 74 } else{ 75 console.info(logTag + "return true "); 76 return true; 77 } 78} 79 80async function getPermission() { 81 console.info(`getPermission is start`); 82 let permissions = ['ohos.permission.DISTRIBUTED_DATASYNC']; 83 let context = featureAbility.getContext(); 84 context.requestPermissionsFromUser(permissions, 666, (data) => { 85 console.info("request success" + JSON.stringify(data)); 86 87 }) 88} 89async function driveFn() { 90 try { 91 let driver = await UiDriver.create(); 92 console.info(` come in driveFn`); 93 console.info(`driver is ${JSON.stringify(driver)}`); 94 await sleep(2000); 95 let button = await driver.findComponent(BY.text('允许')); 96 console.info(`button is ${JSON.stringify(button)}`); 97 await sleep(2000); 98 await button.click(); 99 } catch (err) { 100 console.info('err is ' + err); 101 return; 102 } 103 104} 105 106export default function kvSyncTestS1() { 107 describe('kvSyncTestS1', function () { 108 beforeAll(async function (done) { 109 console.info(logTag + '-----------------beforeAll begin-----------------'); 110 111 let flag_41 = 1; 112 let localOSVersion = ""; 113 let OSVersion41 = "OpenHarmony-4.1"; 114 115 let osReleaseTypeInfo = deviceinfo.osReleaseType; 116 console.info(logTag + 'the value of the deviceinfo osReleaseType is :' + osReleaseTypeInfo); 117 let osFullNameInfo = deviceinfo.osFullName; 118 console.info(logTag + 'the value of the deviceinfo osFullName is :' + osFullNameInfo); 119 120 localOSVersion = osFullNameInfo.substring(0, 15); 121 console.info(logTag + "localOSVersion is: " + localOSVersion); 122 123 if (localOSVersion == OSVersion41) { 124 flag_41 = 1; 125 console.info(logTag + "flag_41 is: " + flag_41); 126 } else { 127 flag_41 = 0; 128 console.info(logTag + "flag_41 is: " + flag_41); 129 } 130 await getPermission(); 131 await sleep(2000); 132 await driveFn(); 133 await sleep(2000); 134 135 testservice = new TestService(); 136 //环境初始化 137 let checkResult = await checkAvailableDevice(); 138 console.info(logTag + ' ========== checkResult' + checkResult); 139 //如果有可信的设备 就unbindStub 140 if (!checkResult) { 141 console.info(logTag + ' ==========checkResult unbindStub'); 142 testservice.unbindStub(TEST_BUNDLE_NAME); 143 } 144 await sleep(1000); 145 let checkResult1 = await checkAvailableDevice(); 146 console.info(logTag + ' ========== checkResult1' + checkResult1); 147 //如果没有可信的设备 需要通过PIN码bind 148 if (checkResult1) { 149 console.info(logTag + ' ==========checkResult1 startDiscovering'); 150 testservice.startDiscovering(TEST_BUNDLE_NAME); 151 await sleep(3000); 152 console.info(logTag + ' ==========checkResult1 bindStub'); 153 testservice.bindStub(TEST_BUNDLE_NAME); 154 await sleep(20000); 155 console.info(logTag + ' ==========checkResult1 stopDiscovering'); 156 testservice.stopDiscovering(TEST_BUNDLE_NAME); 157 await sleep(3000); 158 } 159 160 console.info(logTag + ' ========== createDeviceManager'); 161 dmInstance = deviceManager.createDeviceManager(TEST_BUNDLE_NAME); 162 deviceList = dmInstance.getAvailableDeviceListSync(); 163 console.info(logTag + "deviceList.length is: " + deviceList.length); 164 deviceId = deviceList[0].networkId; 165 console.info(logTag + "deviceId is: " + deviceId); 166 syncDeviceIds = [deviceId]; 167 console.info(logTag + "syncDeviceIds is: " + JSON.stringify(syncDeviceIds)); 168 169 try{ 170 console.info(logTag + "deviceId: " + deviceId); 171 let wantValue = { 172 bundleName: bundleNameKv, 173 abilityName: abilityNameKv, 174 deviceId: deviceId 175 }; 176 await featureAbility.startAbility({ 177 want: wantValue 178 }).then((data) => { 179 console.info(logTag + ' startAbility success. data=' + JSON.stringify(data)); 180 }).catch((err) => { 181 console.info(logTag + ' startAbility err: ' + err.code + err.message); 182 }); 183 }catch(error){ 184 console.info(logTag + "beforeAll startAbility:error = " + error); 185 } 186 await sleep(1000); 187 188 kvManager = factory.createKVManager(config); 189 console.info(logTag + "CLIENT create kvManager success, kvManager=" + kvManager); 190 191 await testservice.toConnectAbility().then(data => { 192 gIRemoteObject = data; 193 console.info(logTag + "toConnectAbility data is" + data); 194 remoteHelpers = new RemoteHelper(testservice, gIRemoteObject); 195 }) 196 await remoteHelpers.createKvManager().then(async (data) => { 197 console.info(logTag + "REMOTE create KvManager success,ret: " + data); 198 }) 199 200 console.info(logTag + '-----------------beforeAll end-----------------'); 201 done(); 202 }) 203 204 beforeEach(async function (done) { 205 console.info(logTag + "-----------------beforeEach 0 -----------------"); 206 done(); 207 }) 208 209 afterEach(async function (done) { 210 try{ 211 console.info(logTag + '-----------------afterEach begin-----------------'); 212 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(async () => { 213 console.info(logTag + 'CLIENT afterEach closeKVStore success'); 214 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { 215 console.info(logTag + 'CLIENT afterEach deleteKVStore success'); 216 }); 217 }); 218 219 await remoteHelpers.closeKvStore(SERVET_STORE_ID).then(async (ret) => { 220 console.info(logTag + "REMOTE afterEach close server kvStore success: " + ret); 221 }) 222 await sleep(2000); 223 kvStore = null; 224 console.info(logTag + '-----------------afterEach end-----------------'); 225 done(); 226 227 } catch (err) { 228 console.error('catch afterEach err:' + `, error code is ${err.code}, message is ${err.message}`); 229 done(); 230 } 231 232 }) 233 234 afterAll(async function (done) { 235 console.info(logTag + '-----------------afterAll-----------------'); 236 let testservice = new TestService(); 237 await sleep(1000); 238 // 删除当前应用的可信设备 239 let checkResult = await checkAvailableDevice(); 240 if (!checkResult) { 241 testservice.unbindStub(); 242 } 243 await sleep(1000); 244 console.info(logTag +"afterAll done"); 245 done(); 246 }) 247 248 /** 249 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0660 250 * @tc.name testServerS1Security0500 251 * @tc.desc Server kvStore security is S1,client kvStore security is S1 252 * @tc.level: Level 2 253 * @tc.type: Functiontion 254 * @tc.size: MediumTest 255 */ 256 it("testServerS1Security0500", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 257 console.info(logTag + "testServerS1Security0500 start"); 258 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 259 await sleep(1000); 260 const options = { 261 createIfMissing: true, 262 encrypt: false, 263 backup: false, 264 autoSync: false, 265 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 266 schema: '', 267 securityLevel: factory.SecurityLevel.S1, 268 } 269 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 270 kvStore = store; 271 console.info(logTag + " get kvStore success"); 272 }) 273 274 let result = undefined; 275 function call(data) { 276 console.info(logTag + "syncComplete: " + data); 277 kvStore.get(TEST_STRING_KEY, (err, data) => { 278 try { 279 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 280 if (err != null) { 281 console.info(logTag + " Sync complete get data error,err: " + err); 282 } else { 283 console.info(logTag + " Sycn complete get data success,result is: " + data); 284 result = data; 285 } 286 console.info(logTag + " get data finish,result is: " + result); 287 expect(result).assertEqual(TEST_STRING_VALUE); 288 console.info(logTag + "testServerS1Security0500 end"); 289 kvStore.off("syncComplete", call); 290 done(); 291 292 } catch (err) { 293 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 294 done(); 295 } 296 297 }) 298 } 299 kvStore.on("syncComplete", call); 300 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 301 await sleep(1000); 302 console.info(logTag + "Client sync start"); 303 304 kvStore.sync(syncDeviceIds, PULL); 305 }) 306 307 /** 308 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0670 309 * @tc.name testServerS1Security0600 310 * @tc.desc Server kvStore security is S1,client kvStore security is S1 311 * @tc.level: Level 2 312 * @tc.type: Functiontion 313 * @tc.size: MediumTest 314 */ 315 it("testServerS1Security0600", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 316 console.info(logTag + "testServerS1Security0600 start"); 317 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 318 await sleep(1000); 319 const options = { 320 createIfMissing: true, 321 encrypt: false, 322 backup: false, 323 autoSync: false, 324 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 325 schema: '', 326 securityLevel: factory.SecurityLevel.S1, 327 } 328 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 329 kvStore = store; 330 console.info(logTag + " get kvStore success"); 331 }) 332 333 let result = undefined; 334 function call(data) { 335 console.info(logTag + "syncComplete: " + data); 336 kvStore.get(TEST_STRING_KEY, (err, data) => { 337 try { 338 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 339 if (err != null) { 340 console.info(logTag + " Sync complete get data error,err: " + err); 341 } else { 342 console.info(logTag + " Sycn complete get data success,result is: " + data); 343 result = data; 344 } 345 console.info(logTag + " get data finish,result is: " + result); 346 expect(result).assertEqual(TEST_STRING_VALUE); 347 console.info(logTag + "testServerS1Security0600 end"); 348 kvStore.off("syncComplete", call); 349 done(); 350 351 } catch (err) { 352 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 353 done(); 354 } 355 356 }) 357 } 358 kvStore.on("syncComplete", call); 359 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 360 await sleep(1000); 361 console.info(logTag + "Client sync start"); 362 kvStore.sync(syncDeviceIds, PULL); 363 }) 364 365 /** 366 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0680 367 * @tc.name testServerS1Security0700 368 * @tc.desc Server kvStore security is S1,client kvStore security is S2 369 * @tc.level: Level 2 370 * @tc.type: Functiontion 371 * @tc.size: MediumTest 372 */ 373 it("testServerS1Security0700", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 374 console.info(logTag + "testServerS1Security0700 start"); 375 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 376 await sleep(1000); 377 const options = { 378 createIfMissing: true, 379 encrypt: false, 380 backup: false, 381 autoSync: false, 382 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 383 schema: '', 384 securityLevel: factory.SecurityLevel.S2, 385 } 386 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 387 kvStore = store; 388 console.info(logTag + " get kvStore success"); 389 }) 390 391 let result = undefined; 392 function call(data) { 393 console.info(logTag + "syncComplete: " + data); 394 kvStore.get(TEST_STRING_KEY, (err, data) => { 395 try { 396 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 397 if (err != null) { 398 console.info(logTag + " Sync complete get data error,err: " + err); 399 } else { 400 console.info(logTag + " Sycn complete get data success,result is: " + data); 401 result = data; 402 } 403 console.info(logTag + " get data finish,result is: " + result); 404 expect(result == undefined).assertTrue(); 405 console.info(logTag + "testServerS1Security0700 end"); 406 kvStore.off("syncComplete", call); 407 done(); 408 409 } catch (err) { 410 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 411 done(); 412 } 413 414 }) 415 } 416 kvStore.on("syncComplete", call); 417 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 418 await sleep(1000); 419 console.info(logTag + "Client sync start"); 420 kvStore.sync(syncDeviceIds, PULL); 421 }) 422 423 /** 424 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0690 425 * @tc.name testServerS1Security0800 426 * @tc.desc Server kvStore security is S1,client kvStore security is S2 427 * @tc.level: Level 2 428 * @tc.type: Functiontion 429 * @tc.size: MediumTest 430 */ 431 it("testServerS1Security0800", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 432 console.info(logTag + "testServerS1Security0800 start"); 433 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 434 await sleep(1000); 435 const options = { 436 createIfMissing: true, 437 encrypt: false, 438 backup: false, 439 autoSync: false, 440 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 441 schema: '', 442 securityLevel: factory.SecurityLevel.S2, 443 } 444 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 445 kvStore = store; 446 console.info(logTag + " get kvStore success"); 447 }) 448 449 let result = undefined; 450 function call(data) { 451 console.info(logTag + "syncComplete: " + data); 452 kvStore.get(TEST_STRING_KEY, (err, data) => { 453 try { 454 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 455 if (err != null) { 456 console.info(logTag + " Sync complete get data error,err: " + err); 457 } else { 458 console.info(logTag + " Sycn complete get data success,result is: " + data); 459 result = data; 460 } 461 console.info(logTag + " get data finish,result is: " + result); 462 expect(result == undefined).assertTrue(); 463 console.info(logTag + "testServerS1Security0800 end"); 464 kvStore.off("syncComplete", call); 465 done(); 466 467 } catch (err) { 468 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 469 done(); 470 } 471 472 }) 473 } 474 kvStore.on("syncComplete", call); 475 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 476 await sleep(1000); 477 console.info(logTag + "Client sync start"); 478 kvStore.sync(syncDeviceIds, PUSH_PULL); 479 }) 480 481 /** 482 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0700 483 * @tc.name testServerS1Security0900 484 * @tc.desc Server kvStore security is S1,client kvStore security is S3 485 * @tc.level: Level 2 486 * @tc.type: Functiontion 487 * @tc.size: MediumTest 488 */ 489 it("testServerS1Security0900", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 490 console.info(logTag + "testServerS1Security0900 start"); 491 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 492 await sleep(1000); 493 const options = { 494 createIfMissing: true, 495 encrypt: false, 496 backup: false, 497 autoSync: false, 498 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 499 schema: '', 500 securityLevel: factory.SecurityLevel.S3, 501 } 502 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 503 kvStore = store; 504 console.info(logTag + " get kvStore success"); 505 }) 506 507 let result = undefined; 508 function call(data) { 509 console.info(logTag + "syncComplete: " + data); 510 kvStore.get(TEST_STRING_KEY, (err, data) => { 511 try { 512 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 513 if (err != null) { 514 console.info(logTag + " Sync complete get data error,err: " + err); 515 } else { 516 console.info(logTag + " Sycn complete get data success,result is: " + data); 517 result = data; 518 } 519 console.info(logTag + " get data finish,result is: " + result); 520 expect(result == undefined).assertTrue(); 521 console.info(logTag + "testServerS1Security0900 end"); 522 kvStore.off("syncComplete", call); 523 done(); 524 525 } catch (err) { 526 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 527 done(); 528 } 529 530 }) 531 } 532 kvStore.on("syncComplete", call); 533 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 534 await sleep(1000); 535 console.info(logTag + "Client sync start"); 536 kvStore.sync(syncDeviceIds, PULL); 537 }) 538 /** 539 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0710 540 * @tc.name testServerS1Security1000 541 * @tc.desc Server kvStore security is S1,client kvStore security is S3 542 * @tc.level: Level 2 543 * @tc.type: Functiontion 544 * @tc.size: MediumTest 545 */ 546 it("testServerS1Security1000", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 547 console.info(logTag + "testServerS1Security1000 start"); 548 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 549 await sleep(1000); 550 const options = { 551 createIfMissing: true, 552 encrypt: false, 553 backup: false, 554 autoSync: false, 555 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 556 schema: '', 557 securityLevel: factory.SecurityLevel.S3, 558 } 559 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 560 kvStore = store; 561 console.info(logTag + " get kvStore success"); 562 }) 563 564 let result = undefined; 565 function call(data) { 566 console.info(logTag + "syncComplete: " + data); 567 kvStore.get(TEST_STRING_KEY, (err, data) => { 568 try { 569 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 570 if (err != null) { 571 console.info(logTag + " Sync complete get data error,err: " + err); 572 } else { 573 console.info(logTag + " Sycn complete get data success,result is: " + data); 574 result = data; 575 } 576 console.info(logTag + " get data finish,result is: " + result); 577 expect(result == undefined).assertTrue(); 578 console.info(logTag + "testServerS1Security1000 end"); 579 kvStore.off("syncComplete", call); 580 done(); 581 582 } catch (err) { 583 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 584 done(); 585 } 586 587 }) 588 } 589 kvStore.on("syncComplete", call); 590 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 591 await sleep(1000); 592 console.info(logTag + "Client sync start"); 593 kvStore.sync(syncDeviceIds, PUSH_PULL); 594 }) 595 596 /** 597 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0720 598 * @tc.name testServerS1Security1100 599 * @tc.desc Server kvStore security is S1,client kvStore security is S4 600 * @tc.level: Level 2 601 * @tc.type: Functiontion 602 * @tc.size: MediumTest 603 */ 604 it("testServerS1Security1100", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 605 console.info(logTag + "testServerS1Security1100 start"); 606 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 607 await sleep(1000); 608 const options = { 609 createIfMissing: true, 610 encrypt: false, 611 backup: false, 612 autoSync: false, 613 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 614 schema: '', 615 securityLevel: factory.SecurityLevel.S4, 616 } 617 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 618 kvStore = store; 619 console.info(logTag + " get kvStore success"); 620 }) 621 622 let result = undefined; 623 function call(data) { 624 console.info(logTag + "syncComplete: " + data); 625 kvStore.get(TEST_STRING_KEY, (err, data) => { 626 try { 627 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 628 if (err != null) { 629 console.info(logTag + " Sync complete get data error,err: " + err); 630 } else { 631 console.info(logTag + " Sycn complete get data success,result is: " + data); 632 result = data; 633 } 634 console.info(logTag + " get data finish,result is: " + result); 635 expect(result == undefined).assertTrue(); 636 console.info(logTag + "testServerS1Security1100 end"); 637 kvStore.off("syncComplete", call); 638 done(); 639 640 } catch (err) { 641 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 642 done(); 643 } 644 645 }) 646 } 647 kvStore.on("syncComplete", call); 648 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 649 await sleep(1000); 650 console.info(logTag + "Client sync start"); 651 kvStore.sync(syncDeviceIds, PULL); 652 }) 653 654 /** 655 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0730 656 * @tc.name testServerS1Security1200 657 * @tc.desc Server kvStore security is S1,client kvStore security is S4 658 * @tc.level: Level 2 659 * @tc.type: Functiontion 660 * @tc.size: MediumTest 661 */ 662 it("testServerS1Security1200", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 663 console.info(logTag + "testServerS1Security1200 start"); 664 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 665 await sleep(1000); 666 const options = { 667 createIfMissing: true, 668 encrypt: false, 669 backup: false, 670 autoSync: false, 671 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 672 schema: '', 673 securityLevel: factory.SecurityLevel.S4, 674 } 675 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 676 kvStore = store; 677 console.info(logTag + " get kvStore success"); 678 }) 679 680 let result = undefined; 681 function call(data) { 682 console.info(logTag + "syncComplete: " + data); 683 kvStore.get(TEST_STRING_KEY, (err, data) => { 684 try { 685 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 686 if (err != null) { 687 console.info(logTag + " Sync complete get data error,err: " + err); 688 } else { 689 console.info(logTag + " Sycn complete get data success,result is: " + data); 690 result = data; 691 } 692 console.info(logTag + " get data finish,result is: " + result); 693 expect(result == undefined).assertTrue(); 694 console.info(logTag + "testServerS1Security1200 end"); 695 kvStore.off("syncComplete", call); 696 done(); 697 698 } catch (err) { 699 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 700 done(); 701 } 702 703 }) 704 } 705 kvStore.on("syncComplete", call); 706 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 707 await sleep(1000); 708 console.info(logTag + "Client sync start"); 709 kvStore.sync(syncDeviceIds, PUSH_PULL); 710 }) 711 712 /** 713 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0760 714 * @tc.name testServerS2Security0500 715 * @tc.desc Server kvStore security is S2,client kvStore security is S1 716 * @tc.level: Level 2 717 * @tc.type: Functiontion 718 * @tc.size: MediumTest 719 */ 720 it("testServerS2Security0500", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 721 console.info(logTag + "testServerS2Security0500 start"); 722 await remoteHelpers.getKvStore(TEST_STORE_ID, "S2", false); 723 await sleep(1000); 724 const options = { 725 createIfMissing: true, 726 encrypt: false, 727 backup: false, 728 autoSync: false, 729 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 730 schema: '', 731 securityLevel: factory.SecurityLevel.S1, 732 } 733 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 734 kvStore = store; 735 console.info(logTag + " get kvStore success"); 736 }) 737 738 let result = undefined; 739 function call(data) { 740 console.info(logTag + "syncComplete: " + data); 741 kvStore.get(TEST_STRING_KEY, (err, data) => { 742 try { 743 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 744 if (err != null) { 745 console.info(logTag + " Sync complete get data error,err: " + err); 746 } else { 747 console.info(logTag + " Sycn complete get data success,result is: " + data); 748 result = data; 749 } 750 console.info(logTag + " get data finish,result is: " + result); 751 expect(result == undefined).assertTrue(); 752 console.info(logTag + "testServerS2Security0500 end"); 753 kvStore.off("syncComplete", call); 754 done(); 755 756 } catch (err) { 757 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 758 done(); 759 } 760 761 }) 762 } 763 kvStore.on("syncComplete", call); 764 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 765 await sleep(1000); 766 console.info(logTag + "Client sync start"); 767 kvStore.sync(syncDeviceIds, PULL); 768 }) 769 770 /** 771 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0820 772 * @tc.name testServerS2Security0600 773 * @tc.desc Server kvStore security is S2,client kvStore security is S1 774 * @tc.level: Level 2 775 * @tc.type: Functiontion 776 * @tc.size: MediumTest 777 */ 778 it("testServerS2Security0600", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 779 console.info(logTag + "testServerS2Security0600 start"); 780 await remoteHelpers.getKvStore(TEST_STORE_ID, "S2", false); 781 await sleep(1000); 782 const options = { 783 createIfMissing: true, 784 encrypt: false, 785 backup: false, 786 autoSync: false, 787 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 788 schema: '', 789 securityLevel: factory.SecurityLevel.S1, 790 } 791 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 792 kvStore = store; 793 console.info(logTag + " get kvStore success"); 794 }) 795 796 let result = undefined; 797 function call(data) { 798 console.info(logTag + "syncComplete: " + data); 799 kvStore.get(TEST_STRING_KEY, (err, data) => { 800 try { 801 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 802 if (err != null) { 803 console.info(logTag + " Sync complete get data error,err: " + err); 804 } else { 805 console.info(logTag + " Sycn complete get data success,result is: " + data); 806 result = data; 807 } 808 console.info(logTag + " get data finish,result is: " + result); 809 expect(result == undefined).assertTrue(); 810 console.info(logTag + "testServerS2Security0600 end"); 811 kvStore.off("syncComplete", call); 812 done(); 813 814 } catch (err) { 815 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 816 done(); 817 } 818 819 }) 820 } 821 kvStore.on("syncComplete", call); 822 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 823 await sleep(1000); 824 console.info(logTag + "Client sync start"); 825 kvStore.sync(syncDeviceIds, PUSH_PULL); 826 }) 827 828 /** 829 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0770 830 * @tc.name testServerS2Security0700 831 * @tc.desc Server kvStore security is S4,client kvStore security is S2 832 * @tc.level: Level 2 833 * @tc.type: Functiontion 834 * @tc.size: MediumTest 835 */ 836 it("testServerS2Security0700", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 837 console.info(logTag + "testServerS2Security0700 start"); 838 await remoteHelpers.getKvStore(TEST_STORE_ID, "S4", false); 839 await sleep(1000); 840 const options = { 841 createIfMissing: true, 842 encrypt: false, 843 backup: false, 844 autoSync: false, 845 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 846 schema: '', 847 securityLevel: factory.SecurityLevel.S2, 848 } 849 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 850 kvStore = store; 851 console.info(logTag + " get kvStore success"); 852 }) 853 854 let result = undefined; 855 function call(data) { 856 console.info(logTag + "syncComplete: " + data); 857 kvStore.get(TEST_STRING_KEY, (err, data) => { 858 try { 859 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 860 if (err != null) { 861 console.info(logTag + " Sync complete get data error,err: " + err); 862 } else { 863 console.info(logTag + " Sycn complete get data success,result is: " + data); 864 result = data; 865 } 866 console.info(logTag + " get data finish,result is: " + result); 867 expect(result == undefined).assertTrue(); 868 console.info(logTag + "testServerS2Security0700 end"); 869 kvStore.off("syncComplete", call); 870 done(); 871 872 } catch (err) { 873 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 874 done(); 875 } 876 877 }) 878 } 879 kvStore.on("syncComplete", call); 880 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 881 await sleep(1000); 882 console.info(logTag + "Client sync start"); 883 kvStore.sync(syncDeviceIds, PULL); 884 }) 885 886 /** 887 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0830 888 * @tc.name testServerS2Security0800 889 * @tc.desc Server kvStore security is S4,client kvStore security is S2 890 * @tc.level: Level 2 891 * @tc.type: Functiontion 892 * @tc.size: MediumTest 893 */ 894 it("testServerS2Security0800", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 895 console.info(logTag + "testServerS2Security0800 start"); 896 await remoteHelpers.getKvStore(TEST_STORE_ID, "S4", false); 897 await sleep(1000); 898 const options = { 899 createIfMissing: true, 900 encrypt: false, 901 backup: false, 902 autoSync: false, 903 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 904 schema: '', 905 securityLevel: factory.SecurityLevel.S2, 906 } 907 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 908 kvStore = store; 909 console.info(logTag + " get kvStore success"); 910 }) 911 912 let result = undefined; 913 function call(data) { 914 console.info(logTag + "syncComplete: " + data); 915 kvStore.get(TEST_STRING_KEY, (err, data) => { 916 try { 917 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 918 if (err != null) { 919 console.info(logTag + " Sync complete get data error,err: " + err); 920 } else { 921 console.info(logTag + " Sycn complete get data success,result is: " + data); 922 result = data; 923 } 924 console.info(logTag + " get data finish,result is: " + result); 925 expect(result == undefined).assertTrue(); 926 console.info(logTag + "testServerS2Security0800 end"); 927 kvStore.off("syncComplete", call); 928 done(); 929 930 } catch (err) { 931 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 932 done(); 933 } 934 935 }) 936 } 937 kvStore.on("syncComplete", call); 938 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 939 await sleep(1000); 940 console.info(logTag + "Client sync start"); 941 kvStore.sync(syncDeviceIds, PUSH_PULL); 942 }) 943 944 /** 945 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0780 946 * @tc.name testServerS2Security0900 947 * @tc.desc Server kvStore security is S2,client kvStore security is S3 948 * @tc.level: Level 2 949 * @tc.type: Functiontion 950 * @tc.size: MediumTest 951 */ 952 it("testServerS2Security0900", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 953 console.info(logTag + "testServerS2Security0900 start"); 954 await remoteHelpers.getKvStore(TEST_STORE_ID, "S2", false); 955 await sleep(1000); 956 const options = { 957 createIfMissing: true, 958 encrypt: false, 959 backup: false, 960 autoSync: false, 961 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 962 schema: '', 963 securityLevel: factory.SecurityLevel.S3, 964 } 965 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 966 kvStore = store; 967 console.info(logTag + " get kvStore success"); 968 }) 969 970 let result = undefined; 971 function call(data) { 972 console.info(logTag + "syncComplete: " + data); 973 kvStore.get(TEST_STRING_KEY, (err, data) => { 974 try { 975 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 976 if (err != null) { 977 console.info(logTag + " Sync complete get data error,err: " + err); 978 } else { 979 console.info(logTag + " Sycn complete get data success,result is: " + data); 980 result = data; 981 } 982 console.info(logTag + " get data finish,result is: " + result); 983 expect(result == undefined).assertTrue(); 984 console.info(logTag + "testServerS2Security0900 end"); 985 kvStore.off("syncComplete", call); 986 done(); 987 988 } catch (err) { 989 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 990 done(); 991 } 992 993 }) 994 } 995 kvStore.on("syncComplete", call); 996 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 997 await sleep(1000); 998 console.info(logTag + "Client sync start"); 999 kvStore.sync(syncDeviceIds, PULL); 1000 }) 1001 1002 /** 1003 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0840 1004 * @tc.name testServerS2Security1000 1005 * @tc.desc Server kvStore security is S2,client kvStore security is S3 1006 * @tc.level: Level 2 1007 * @tc.type: Functiontion 1008 * @tc.size: MediumTest 1009 */ 1010 it("testServerS2Security1000", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 1011 console.info(logTag + "testServerS2Security1000 start"); 1012 await remoteHelpers.getKvStore(TEST_STORE_ID, "S2", false); 1013 await sleep(1000); 1014 const options = { 1015 createIfMissing: true, 1016 encrypt: false, 1017 backup: false, 1018 autoSync: false, 1019 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 1020 schema: '', 1021 securityLevel: factory.SecurityLevel.S3, 1022 } 1023 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 1024 kvStore = store; 1025 console.info(logTag + " get kvStore success"); 1026 }) 1027 1028 let result = undefined; 1029 function call(data) { 1030 console.info(logTag + "syncComplete: " + data); 1031 kvStore.get(TEST_STRING_KEY, (err, data) => { 1032 try { 1033 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 1034 if (err != null) { 1035 console.info(logTag + " Sync complete get data error,err: " + err); 1036 } else { 1037 console.info(logTag + " Sycn complete get data success,result is: " + data); 1038 result = data; 1039 } 1040 console.info(logTag + " get data finish,result is: " + result); 1041 expect(result == undefined).assertTrue(); 1042 console.info(logTag + "testServerS2Security1000 end"); 1043 kvStore.off("syncComplete", call); 1044 done(); 1045 1046 } catch (err) { 1047 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 1048 done(); 1049 } 1050 1051 }) 1052 } 1053 kvStore.on("syncComplete", call); 1054 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 1055 await sleep(1000); 1056 console.info(logTag + "Client sync start"); 1057 kvStore.sync(syncDeviceIds, PUSH_PULL); 1058 }) 1059 1060 /** 1061 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0790 1062 * @tc.name testServerS2Security1100 1063 * @tc.desc Server kvStore security is S2,client kvStore security is S4 1064 * @tc.level: Level 2 1065 * @tc.type: Functiontion 1066 * @tc.size: MediumTest 1067 */ 1068 it("testServerS2Security1100", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 1069 console.info(logTag + "testServerS2Security1100 start"); 1070 await remoteHelpers.getKvStore(TEST_STORE_ID, "S2", false); 1071 await sleep(1000); 1072 const options = { 1073 createIfMissing: true, 1074 encrypt: false, 1075 backup: false, 1076 autoSync: false, 1077 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 1078 schema: '', 1079 securityLevel: factory.SecurityLevel.S4, 1080 } 1081 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 1082 kvStore = store; 1083 console.info(logTag + " get kvStore success"); 1084 }) 1085 1086 let result = undefined; 1087 function call(data) { 1088 console.info(logTag + "syncComplete: " + data); 1089 kvStore.get(TEST_STRING_KEY, (err, data) => { 1090 try { 1091 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 1092 if (err != null) { 1093 console.info(logTag + " Sync complete get data error,err: " + err); 1094 } else { 1095 console.info(logTag + " Sycn complete get data success,result is: " + data); 1096 result = data; 1097 } 1098 console.info(logTag + " get data finish,result is: " + result); 1099 expect(result == undefined).assertTrue(); 1100 console.info(logTag + "testServerS2Security1100 end"); 1101 kvStore.off("syncComplete", call); 1102 done(); 1103 1104 } catch (err) { 1105 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 1106 done(); 1107 } 1108 1109 }) 1110 } 1111 kvStore.on("syncComplete", call); 1112 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 1113 await sleep(1000); 1114 console.info(logTag + "Client sync start"); 1115 kvStore.sync(syncDeviceIds, PULL); 1116 }) 1117 1118 /** 1119 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0850 1120 * @tc.name testServerS2Security1200 1121 * @tc.desc Server kvStore security is S2,client kvStore security is S4 1122 * @tc.level: Level 2 1123 * @tc.type: Functiontion 1124 * @tc.size: MediumTest 1125 */ 1126 it("testServerS2Security1200", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 1127 console.info(logTag + "testServerS2Security1200 start"); 1128 await remoteHelpers.getKvStore(TEST_STORE_ID, "S2", false); 1129 await sleep(1000); 1130 const options = { 1131 createIfMissing: true, 1132 encrypt: false, 1133 backup: false, 1134 autoSync: false, 1135 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 1136 schema: '', 1137 securityLevel: factory.SecurityLevel.S4, 1138 } 1139 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 1140 kvStore = store; 1141 console.info(logTag + " get kvStore success"); 1142 }) 1143 1144 let result = undefined; 1145 function call(data) { 1146 console.info(logTag + "syncComplete: " + data); 1147 kvStore.get(TEST_STRING_KEY, (err, data) => { 1148 try { 1149 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 1150 if (err != null) { 1151 console.info(logTag + " Sync complete get data error,err: " + err); 1152 } else { 1153 console.info(logTag + " Sycn complete get data success,result is: " + data); 1154 result = data; 1155 } 1156 console.info(logTag + " get data finish,result is: " + result); 1157 expect(result == undefined).assertTrue(); 1158 console.info(logTag + "testServerS2Security1200 end"); 1159 kvStore.off("syncComplete", call); 1160 done(); 1161 1162 } catch (err) { 1163 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 1164 done(); 1165 } 1166 1167 }) 1168 } 1169 kvStore.on("syncComplete", call); 1170 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 1171 await sleep(1000); 1172 console.info(logTag + "Client sync start"); 1173 kvStore.sync(syncDeviceIds, PUSH_PULL); 1174 }) 1175 1176 /** 1177 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0880 1178 * @tc.name testServerS3Security0500 1179 * @tc.desc Server kvStore security is S3,client kvStore security is S1 1180 * @tc.level: Level 2 1181 * @tc.type: Functiontion 1182 * @tc.size: MediumTest 1183 */ 1184 it("testServerS3Security0500", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 1185 console.info(logTag + "testServerS3Security0500 start"); 1186 await remoteHelpers.getKvStore(TEST_STORE_ID, "S3", false); 1187 await sleep(1000); 1188 const options = { 1189 createIfMissing: true, 1190 encrypt: false, 1191 backup: false, 1192 autoSync: false, 1193 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 1194 schema: '', 1195 securityLevel: factory.SecurityLevel.S1, 1196 } 1197 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 1198 kvStore = store; 1199 console.info(logTag + " get kvStore success"); 1200 }) 1201 1202 let result = undefined; 1203 function call(data) { 1204 console.info(logTag + "syncComplete: " + data); 1205 kvStore.get(TEST_STRING_KEY, (err, data) => { 1206 try { 1207 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 1208 if (err != null) { 1209 console.info(logTag + " Sync complete get data error,err: " + err); 1210 } else { 1211 console.info(logTag + " Sycn complete get data success,result is: " + data); 1212 result = data; 1213 } 1214 console.info(logTag + " get data finish,result is: " + result); 1215 expect(result == undefined).assertTrue(); 1216 console.info(logTag + "testServerS3Security0500 end"); 1217 kvStore.off("syncComplete", call); 1218 done(); 1219 1220 } catch (err) { 1221 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 1222 done(); 1223 } 1224 1225 }) 1226 } 1227 kvStore.on("syncComplete", call); 1228 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 1229 await sleep(1000); 1230 console.info(logTag + "Client sync start"); 1231 kvStore.sync(syncDeviceIds, PULL); 1232 }) 1233 1234 /** 1235 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0940 1236 * @tc.name testServerS3Security0600 1237 * @tc.desc Server kvStore security is S3,client kvStore security is S1 1238 * @tc.level: Level 2 1239 * @tc.type: Functiontion 1240 * @tc.size: MediumTest 1241 */ 1242 it("testServerS3Security0600", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 1243 console.info(logTag + "testServerS3Security0600 start"); 1244 await remoteHelpers.getKvStore(TEST_STORE_ID, "S3", false); 1245 await sleep(1000); 1246 const options = { 1247 createIfMissing: true, 1248 encrypt: false, 1249 backup: false, 1250 autoSync: false, 1251 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 1252 schema: '', 1253 securityLevel: factory.SecurityLevel.S1, 1254 } 1255 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 1256 kvStore = store; 1257 console.info(logTag + " get kvStore success"); 1258 }) 1259 1260 let result = undefined; 1261 function call(data) { 1262 console.info(logTag + "syncComplete: " + data); 1263 kvStore.get(TEST_STRING_KEY, (err, data) => { 1264 try { 1265 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 1266 if (err != null) { 1267 console.info(logTag + " Sync complete get data error,err: " + err); 1268 } else { 1269 console.info(logTag + " Sycn complete get data success,result is: " + data); 1270 result = data; 1271 } 1272 console.info(logTag + " get data finish,result is: " + result); 1273 expect(result == undefined).assertTrue(); 1274 console.info(logTag + "testServerS3Security0600 end"); 1275 kvStore.off("syncComplete", call); 1276 done(); 1277 1278 } catch (err) { 1279 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 1280 done(); 1281 } 1282 1283 }) 1284 } 1285 kvStore.on("syncComplete", call); 1286 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 1287 await sleep(1000); 1288 console.info(logTag + "Client sync start"); 1289 kvStore.sync(syncDeviceIds, PUSH_PULL); 1290 }) 1291 1292 /** 1293 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0890 1294 * @tc.name testServerS3Security0700 1295 * @tc.desc Server kvStore security is S3,client kvStore security is S2 1296 * @tc.level: Level 2 1297 * @tc.type: Functiontion 1298 * @tc.size: MediumTest 1299 */ 1300 it("testServerS3Security0700", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 1301 console.info(logTag + "testServerS3Security0700 start"); 1302 await remoteHelpers.getKvStore(TEST_STORE_ID, "S3", false); 1303 await sleep(1000); 1304 const options = { 1305 createIfMissing: true, 1306 encrypt: false, 1307 backup: false, 1308 autoSync: false, 1309 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 1310 schema: '', 1311 securityLevel: factory.SecurityLevel.S2, 1312 } 1313 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 1314 kvStore = store; 1315 console.info(logTag + " get kvStore success"); 1316 }) 1317 1318 let result = undefined; 1319 function call(data) { 1320 console.info(logTag + "syncComplete: " + data); 1321 kvStore.get(TEST_STRING_KEY, (err, data) => { 1322 try { 1323 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 1324 if (err != null) { 1325 console.info(logTag + " Sync complete get data error,err: " + err); 1326 } else { 1327 console.info(logTag + " Sycn complete get data success,result is: " + data); 1328 result = data; 1329 } 1330 console.info(logTag + " get data finish,result is: " + result); 1331 expect(result == undefined).assertTrue(); 1332 console.info(logTag + "testServerS3Security0700 end"); 1333 kvStore.off("syncComplete", call); 1334 done(); 1335 1336 } catch (err) { 1337 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 1338 done(); 1339 } 1340 1341 }) 1342 } 1343 kvStore.on("syncComplete", call); 1344 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 1345 await sleep(1000); 1346 console.info(logTag + "Client sync start"); 1347 kvStore.sync(syncDeviceIds, PULL); 1348 }) 1349 1350 /** 1351 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0950 1352 * @tc.name testServerS3Security0800 1353 * @tc.desc Server kvStore security is S3,client kvStore security is S2 1354 * @tc.level: Level 2 1355 * @tc.type: Functiontion 1356 * @tc.size: MediumTest 1357 */ 1358 it("testServerS3Security0800", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 1359 console.info(logTag + "testServerS3Security0800 start"); 1360 await remoteHelpers.getKvStore(TEST_STORE_ID, "S3", false); 1361 await sleep(1000); 1362 const options = { 1363 createIfMissing: true, 1364 encrypt: false, 1365 backup: false, 1366 autoSync: false, 1367 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 1368 schema: '', 1369 securityLevel: factory.SecurityLevel.S2, 1370 } 1371 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 1372 kvStore = store; 1373 console.info(logTag + " get kvStore success"); 1374 }) 1375 1376 let result = undefined; 1377 function call(data) { 1378 console.info(logTag + "syncComplete: " + data); 1379 kvStore.get(TEST_STRING_KEY, (err, data) => { 1380 try { 1381 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 1382 if (err != null) { 1383 console.info(logTag + " Sync complete get data error,err: " + err); 1384 } else { 1385 console.info(logTag + " Sycn complete get data success,result is: " + data); 1386 result = data; 1387 } 1388 console.info(logTag + " get data finish,result is: " + result); 1389 expect(result == undefined).assertTrue(); 1390 console.info(logTag + "testServerS3Security0800 end"); 1391 kvStore.off("syncComplete", call); 1392 done(); 1393 1394 } catch (err) { 1395 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 1396 done(); 1397 } 1398 1399 }) 1400 } 1401 kvStore.on("syncComplete", call); 1402 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 1403 await sleep(1000); 1404 console.info(logTag + "Client sync start"); 1405 kvStore.sync(syncDeviceIds, PUSH_PULL); 1406 }) 1407 1408 /** 1409 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0900 1410 * @tc.name testServerS3Security0900 1411 * @tc.desc Server kvStore security is S4,client kvStore security is S3 1412 * @tc.level: Level 2 1413 * @tc.type: Functiontion 1414 * @tc.size: MediumTest 1415 */ 1416 it("testServerS3Security0900", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 1417 console.info(logTag + "testServerS3Security0900 start"); 1418 await remoteHelpers.getKvStore(TEST_STORE_ID, "S4", false); 1419 await sleep(1000); 1420 const options = { 1421 createIfMissing: true, 1422 encrypt: false, 1423 backup: false, 1424 autoSync: false, 1425 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 1426 schema: '', 1427 securityLevel: factory.SecurityLevel.S3, 1428 } 1429 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 1430 kvStore = store; 1431 console.info(logTag + " get kvStore success"); 1432 }) 1433 1434 let result = undefined; 1435 function call(data) { 1436 console.info(logTag + "syncComplete: " + data); 1437 kvStore.get(TEST_STRING_KEY, (err, data) => { 1438 try { 1439 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 1440 if (err != null) { 1441 console.info(logTag + " Sync complete get data error,err: " + err); 1442 } else { 1443 console.info(logTag + " Sycn complete get data success,result is: " + data); 1444 result = data; 1445 } 1446 console.info(logTag + " get data finish,result is: " + result); 1447 expect(result == undefined).assertTrue(); 1448 console.info(logTag + "testServerS3Security0900 end"); 1449 kvStore.off("syncComplete", call); 1450 done(); 1451 1452 } catch (err) { 1453 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 1454 done(); 1455 } 1456 1457 }) 1458 } 1459 kvStore.on("syncComplete", call); 1460 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 1461 await sleep(1000); 1462 console.info(logTag + "Client sync start"); 1463 kvStore.sync(syncDeviceIds, PULL); 1464 }) 1465 1466 /** 1467 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0960 1468 * @tc.name testServerS3Security1000 1469 * @tc.desc Server kvStore security is S4,client kvStore security is S3 1470 * @tc.level: Level 2 1471 * @tc.type: Functiontion 1472 * @tc.size: MediumTest 1473 */ 1474 it("testServerS3Security1000", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 1475 console.info(logTag + "testServerS3Security1000 start"); 1476 await remoteHelpers.getKvStore(TEST_STORE_ID, "S4", false); 1477 await sleep(1000); 1478 const options = { 1479 createIfMissing: true, 1480 encrypt: false, 1481 backup: false, 1482 autoSync: false, 1483 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 1484 schema: '', 1485 securityLevel: factory.SecurityLevel.S3, 1486 } 1487 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 1488 kvStore = store; 1489 console.info(logTag + " get kvStore success"); 1490 }) 1491 1492 let result = undefined; 1493 function call(data) { 1494 console.info(logTag + "syncComplete: " + data); 1495 kvStore.get(TEST_STRING_KEY, (err, data) => { 1496 try { 1497 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 1498 if (err != null) { 1499 console.info(logTag + " Sync complete get data error,err: " + err); 1500 } else { 1501 console.info(logTag + " Sycn complete get data success,result is: " + data); 1502 result = data; 1503 } 1504 console.info(logTag + " get data finish,result is: " + result); 1505 expect(result == undefined).assertTrue(); 1506 console.info(logTag + "testServerS3Security1000 end"); 1507 kvStore.off("syncComplete", call); 1508 done(); 1509 1510 } catch (err) { 1511 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 1512 done(); 1513 } 1514 1515 }) 1516 } 1517 kvStore.on("syncComplete", call); 1518 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 1519 await sleep(1000); 1520 console.info(logTag + "Client sync start"); 1521 kvStore.sync(syncDeviceIds, PUSH_PULL); 1522 }) 1523 1524 /** 1525 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0910 1526 * @tc.name testServerS3Security1100 1527 * @tc.desc Server kvStore security is S3,client kvStore security is S4 1528 * @tc.level: Level 2 1529 * @tc.type: Functiontion 1530 * @tc.size: MediumTest 1531 */ 1532 it("testServerS3Security1100", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 1533 console.info(logTag + "testServerS3Security1100 start"); 1534 await remoteHelpers.getKvStore(TEST_STORE_ID, "S3", false); 1535 await sleep(1000); 1536 const options = { 1537 createIfMissing: true, 1538 encrypt: false, 1539 backup: false, 1540 autoSync: false, 1541 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 1542 schema: '', 1543 securityLevel: factory.SecurityLevel.S4, 1544 } 1545 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 1546 kvStore = store; 1547 console.info(logTag + " get kvStore success"); 1548 }) 1549 1550 let result = undefined; 1551 function call(data) { 1552 console.info(logTag + "syncComplete: " + data); 1553 kvStore.get(TEST_STRING_KEY, (err, data) => { 1554 try { 1555 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 1556 if (err != null) { 1557 console.info(logTag + " Sync complete get data error,err: " + err); 1558 } else { 1559 console.info(logTag + " Sycn complete get data success,result is: " + data); 1560 result = data; 1561 } 1562 console.info(logTag + " get data finish,result is: " + result); 1563 expect(result == undefined).assertTrue(); 1564 console.info(logTag + "testServerS3Security1100 end"); 1565 kvStore.off("syncComplete", call); 1566 done(); 1567 1568 } catch (err) { 1569 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 1570 done(); 1571 } 1572 1573 }) 1574 } 1575 kvStore.on("syncComplete", call); 1576 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 1577 await sleep(1000); 1578 console.info(logTag + "Client sync start"); 1579 kvStore.sync(syncDeviceIds, PULL); 1580 }) 1581 1582 /** 1583 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0970 1584 * @tc.name testServerS3Security1200 1585 * @tc.desc Server kvStore security is S3,client kvStore security is S4 1586 * @tc.level: Level 2 1587 * @tc.type: Functiontion 1588 * @tc.size: MediumTest 1589 */ 1590 it("testServerS3Security1200", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 1591 console.info(logTag + "testServerS3Security1200 start"); 1592 await remoteHelpers.getKvStore(TEST_STORE_ID, "S3", false); 1593 await sleep(1000); 1594 const options = { 1595 createIfMissing: true, 1596 encrypt: false, 1597 backup: false, 1598 autoSync: false, 1599 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 1600 schema: '', 1601 securityLevel: factory.SecurityLevel.S4, 1602 } 1603 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 1604 kvStore = store; 1605 console.info(logTag + " get kvStore success"); 1606 }) 1607 1608 let result = undefined; 1609 function call(data) { 1610 console.info(logTag + "syncComplete: " + data); 1611 kvStore.get(TEST_STRING_KEY, (err, data) => { 1612 try { 1613 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 1614 if (err != null) { 1615 console.info(logTag + " Sync complete get data error,err: " + err); 1616 } else { 1617 console.info(logTag + " Sycn complete get data success,result is: " + data); 1618 result = data; 1619 } 1620 console.info(logTag + " get data finish,result is: " + result); 1621 expect(result == undefined).assertTrue(); 1622 console.info(logTag + "testServerS3Security1200 end"); 1623 kvStore.off("syncComplete", call); 1624 done(); 1625 1626 } catch (err) { 1627 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 1628 done(); 1629 } 1630 1631 }) 1632 } 1633 kvStore.on("syncComplete", call); 1634 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 1635 await sleep(1000); 1636 console.info(logTag + "Client sync start"); 1637 kvStore.sync(syncDeviceIds, PUSH_PULL); 1638 }) 1639 1640 /** 1641 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_1000 1642 * @tc.name testServerS4Security0500 1643 * @tc.desc Server kvStore security is S4,client kvStore security is S1 1644 * @tc.level: Level 2 1645 * @tc.type: Functiontion 1646 * @tc.size: MediumTest 1647 */ 1648 it("testServerS4Security0500", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 1649 console.info(logTag + "testServerS4Security0500 start"); 1650 await remoteHelpers.getKvStore(TEST_STORE_ID, "S4", false); 1651 await sleep(1000); 1652 const options = { 1653 createIfMissing: true, 1654 encrypt: false, 1655 backup: false, 1656 autoSync: false, 1657 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 1658 schema: '', 1659 securityLevel: factory.SecurityLevel.S1, 1660 } 1661 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 1662 kvStore = store; 1663 console.info(logTag + " get kvStore success"); 1664 }) 1665 1666 let result = undefined; 1667 function call(data) { 1668 console.info(logTag + "syncComplete: " + data); 1669 kvStore.get(TEST_STRING_KEY, (err, data) => { 1670 try { 1671 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 1672 if (err != null) { 1673 console.info(logTag + " Sync complete get data error,err: " + err); 1674 } else { 1675 console.info(logTag + " Sycn complete get data success,result is: " + data); 1676 result = data; 1677 } 1678 console.info(logTag + " get data finish,result is: " + result); 1679 expect(result == undefined).assertTrue(); 1680 console.info(logTag + "testServerS4Security0500 end"); 1681 kvStore.off("syncComplete", call); 1682 done(); 1683 1684 } catch (err) { 1685 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 1686 done(); 1687 } 1688 1689 }) 1690 } 1691 kvStore.on("syncComplete", call); 1692 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 1693 await sleep(1000); 1694 console.info(logTag + "Client sync start"); 1695 kvStore.sync(syncDeviceIds, PULL); 1696 }) 1697 1698 /** 1699 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_1060 1700 * @tc.name testServerS4Security0600 1701 * @tc.desc Server kvStore security is S4,client kvStore security is S1 1702 * @tc.level: Level 2 1703 * @tc.type: Functiontion 1704 * @tc.size: MediumTest 1705 */ 1706 it("testServerS4Security0600", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 1707 console.info(logTag + "testServerS4Security0600 start"); 1708 await remoteHelpers.getKvStore(TEST_STORE_ID, "S4", false); 1709 await sleep(1000); 1710 const options = { 1711 createIfMissing: true, 1712 encrypt: false, 1713 backup: false, 1714 autoSync: false, 1715 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 1716 schema: '', 1717 securityLevel: factory.SecurityLevel.S1, 1718 } 1719 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 1720 kvStore = store; 1721 console.info(logTag + " get kvStore success"); 1722 }) 1723 1724 let result = undefined; 1725 function call(data) { 1726 console.info(logTag + "syncComplete: " + data); 1727 kvStore.get(TEST_STRING_KEY, (err, data) => { 1728 try { 1729 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 1730 if (err != null) { 1731 console.info(logTag + " Sync complete get data error,err: " + err); 1732 } else { 1733 console.info(logTag + " Sycn complete get data success,result is: " + data); 1734 result = data; 1735 } 1736 console.info(logTag + " get data finish,result is: " + result); 1737 expect(result == undefined).assertTrue(); 1738 console.info(logTag + "testServerS4Security0600 end"); 1739 kvStore.off("syncComplete", call); 1740 done(); 1741 1742 } catch (err) { 1743 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 1744 done(); 1745 } 1746 1747 }) 1748 } 1749 kvStore.on("syncComplete", call); 1750 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 1751 await sleep(1000); 1752 console.info(logTag + "Client sync start"); 1753 kvStore.sync(syncDeviceIds, PUSH_PULL); 1754 }) 1755 1756 /** 1757 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_1010 1758 * @tc.name testServerS4Security0700 1759 * @tc.desc Server kvStore security is S4,client kvStore security is S2 1760 * @tc.level: Level 2 1761 * @tc.type: Functiontion 1762 * @tc.size: MediumTest 1763 */ 1764 it("testServerS4Security0700", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 1765 console.info(logTag + "testServerS4Security0700 start"); 1766 await remoteHelpers.getKvStore(TEST_STORE_ID, "S4", false); 1767 await sleep(1000); 1768 const options = { 1769 createIfMissing: true, 1770 encrypt: false, 1771 backup: false, 1772 autoSync: false, 1773 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 1774 schema: '', 1775 securityLevel: factory.SecurityLevel.S1, 1776 } 1777 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 1778 kvStore = store; 1779 console.info(logTag + " get kvStore success"); 1780 }) 1781 1782 let result = undefined; 1783 function call(data) { 1784 console.info(logTag + "syncComplete: " + data); 1785 kvStore.get(TEST_STRING_KEY, (err, data) => { 1786 try { 1787 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 1788 if (err != null) { 1789 console.info(logTag + " Sync complete get data error,err: " + err); 1790 } else { 1791 console.info(logTag + " Sycn complete get data success,result is: " + data); 1792 result = data; 1793 } 1794 console.info(logTag + " get data finish,result is: " + result); 1795 expect(result == undefined).assertTrue(); 1796 console.info(logTag + "testServerS4Security0700 end"); 1797 kvStore.off("syncComplete", call); 1798 done(); 1799 1800 } catch (err) { 1801 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 1802 done(); 1803 } 1804 1805 }) 1806 } 1807 kvStore.on("syncComplete", call); 1808 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 1809 await sleep(1000); 1810 console.info(logTag + "Client sync start"); 1811 kvStore.sync(syncDeviceIds, PULL); 1812 }) 1813 1814 /** 1815 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_1070 1816 * @tc.name testServerS4Security0800 1817 * @tc.desc Server kvStore security is S4,client kvStore security is S2 1818 * @tc.level: Level 2 1819 * @tc.type: Functiontion 1820 * @tc.size: MediumTest 1821 */ 1822 it("testServerS4Security0800", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 1823 console.info(logTag + "testServerS4Security0800 start"); 1824 await remoteHelpers.getKvStore(TEST_STORE_ID, "S4", false); 1825 await sleep(1000); 1826 const options = { 1827 createIfMissing: true, 1828 encrypt: false, 1829 backup: false, 1830 autoSync: false, 1831 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 1832 schema: '', 1833 securityLevel: factory.SecurityLevel.S1, 1834 } 1835 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 1836 kvStore = store; 1837 console.info(logTag + " get kvStore success"); 1838 }) 1839 1840 let result = undefined; 1841 function call(data) { 1842 console.info(logTag + "syncComplete: " + data); 1843 kvStore.get(TEST_STRING_KEY, (err, data) => { 1844 try { 1845 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 1846 if (err != null) { 1847 console.info(logTag + " Sync complete get data error,err: " + err); 1848 } else { 1849 console.info(logTag + " Sycn complete get data success,result is: " + data); 1850 result = data; 1851 } 1852 console.info(logTag + " get data finish,result is: " + result); 1853 expect(result == undefined).assertTrue(); 1854 console.info(logTag + "testServerS4Security0800 end"); 1855 kvStore.off("syncComplete", call); 1856 done(); 1857 1858 } catch (err) { 1859 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 1860 done(); 1861 } 1862 1863 }) 1864 } 1865 kvStore.on("syncComplete", call); 1866 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 1867 await sleep(1000); 1868 console.info(logTag + "Client sync start"); 1869 kvStore.sync(syncDeviceIds, PUSH_PULL); 1870 }) 1871 1872 /** 1873 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_1020 1874 * @tc.name testServerS4Security0900 1875 * @tc.desc Server kvStore security is S4,client kvStore security is S3 1876 * @tc.level: Level 2 1877 * @tc.type: Functiontion 1878 * @tc.size: MediumTest 1879 */ 1880 it("testServerS4Security0900", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 1881 console.info(logTag + "testServerS4Security0900 start"); 1882 await remoteHelpers.getKvStore(TEST_STORE_ID, "S4", false); 1883 await sleep(1000); 1884 const options = { 1885 createIfMissing: true, 1886 encrypt: false, 1887 backup: false, 1888 autoSync: false, 1889 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 1890 schema: '', 1891 securityLevel: factory.SecurityLevel.S1, 1892 } 1893 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 1894 kvStore = store; 1895 console.info(logTag + " get kvStore success"); 1896 }) 1897 1898 let result = undefined; 1899 function call(data) { 1900 console.info(logTag + "syncComplete: " + data); 1901 kvStore.get(TEST_STRING_KEY, (err, data) => { 1902 try { 1903 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 1904 if (err != null) { 1905 console.info(logTag + " Sync complete get data error,err: " + err); 1906 } else { 1907 console.info(logTag + " Sycn complete get data success,result is: " + data); 1908 result = data; 1909 } 1910 console.info(logTag + " get data finish,result is: " + result); 1911 expect(result == undefined).assertTrue(); 1912 console.info(logTag + "testServerS4Security0900 end"); 1913 kvStore.off("syncComplete", call); 1914 done(); 1915 1916 } catch (err) { 1917 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 1918 done(); 1919 } 1920 1921 }) 1922 } 1923 kvStore.on("syncComplete", call); 1924 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 1925 await sleep(1000); 1926 console.info(logTag + "Client sync start"); 1927 kvStore.sync(syncDeviceIds, PULL); 1928 }) 1929 1930 /** 1931 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_1080 1932 * @tc.name testServerS4Security1000 1933 * @tc.desc Server kvStore security is S4,client kvStore security is S3 1934 * @tc.level: Level 2 1935 * @tc.type: Functiontion 1936 * @tc.size: MediumTest 1937 */ 1938 it("testServerS4Security1000", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 1939 console.info(logTag + "testServerS4Security1000 start"); 1940 await remoteHelpers.getKvStore(TEST_STORE_ID, "S4", false); 1941 await sleep(1000); 1942 const options = { 1943 createIfMissing: true, 1944 encrypt: false, 1945 backup: false, 1946 autoSync: false, 1947 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 1948 schema: '', 1949 securityLevel: factory.SecurityLevel.S1, 1950 } 1951 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 1952 kvStore = store; 1953 console.info(logTag + " get kvStore success"); 1954 }) 1955 1956 let result = undefined; 1957 function call(data) { 1958 console.info(logTag + "syncComplete: " + data); 1959 kvStore.get(TEST_STRING_KEY, (err, data) => { 1960 try { 1961 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 1962 if (err != null) { 1963 console.info(logTag + " Sync complete get data error,err: " + err); 1964 } else { 1965 console.info(logTag + " Sycn complete get data success,result is: " + data); 1966 result = data; 1967 } 1968 console.info(logTag + " get data finish,result is: " + result); 1969 expect(result == undefined).assertTrue(); 1970 console.info(logTag + "testServerS4Security1000 end"); 1971 kvStore.off("syncComplete", call); 1972 done(); 1973 1974 } catch (err) { 1975 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 1976 done(); 1977 } 1978 1979 }) 1980 } 1981 kvStore.on("syncComplete", call); 1982 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 1983 await sleep(1000); 1984 console.info(logTag + "Client sync start"); 1985 kvStore.sync(syncDeviceIds, PUSH_PULL); 1986 }) 1987 1988 /** 1989 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_1030 1990 * @tc.name testServerS4Security1100 1991 * @tc.desc Server kvStore security is S4,client kvStore security is S4 1992 * @tc.level: Level 2 1993 * @tc.type: Functiontion 1994 * @tc.size: MediumTest 1995 */ 1996 it("testServerS4Security1100", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 1997 console.info(logTag + "testServerS4Security1100 start"); 1998 await remoteHelpers.getKvStore(TEST_STORE_ID, "S4", false); 1999 await sleep(1000); 2000 const options = { 2001 createIfMissing: true, 2002 encrypt: false, 2003 backup: false, 2004 autoSync: false, 2005 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 2006 schema: '', 2007 securityLevel: factory.SecurityLevel.S1, 2008 } 2009 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 2010 kvStore = store; 2011 console.info(logTag + " get kvStore success"); 2012 }) 2013 2014 let result = undefined; 2015 function call(data) { 2016 console.info(logTag + "syncComplete: " + data); 2017 kvStore.get(TEST_STRING_KEY, (err, data) => { 2018 try { 2019 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 2020 if (err != null) { 2021 console.info(logTag + " Sync complete get data error,err: " + err); 2022 } else { 2023 console.info(logTag + " Sycn complete get data success,result is: " + data); 2024 result = data; 2025 } 2026 console.info(logTag + " get data finish,result is: " + result); 2027 expect(result == undefined).assertTrue(); 2028 console.info(logTag + "testServerS4Security1100 end"); 2029 kvStore.off("syncComplete", call); 2030 done(); 2031 2032 } catch (err) { 2033 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 2034 done(); 2035 } 2036 2037 }) 2038 } 2039 kvStore.on("syncComplete", call); 2040 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 2041 await sleep(1000); 2042 console.info(logTag + "Client sync start"); 2043 kvStore.sync(syncDeviceIds, PULL); 2044 }) 2045 2046 /** 2047 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_1090 2048 * @tc.name testServerS4Security1200 2049 * @tc.desc Server kvStore security is S4,client kvStore security is S4 2050 * @tc.level: Level 2 2051 * @tc.type: Functiontion 2052 * @tc.size: MediumTest 2053 */ 2054 it("testServerS4Security1200", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 2055 console.info(logTag + "testServerS4Security1200 start"); 2056 await remoteHelpers.getKvStore(TEST_STORE_ID, "S4", false); 2057 await sleep(1000); 2058 const options = { 2059 createIfMissing: true, 2060 encrypt: false, 2061 backup: false, 2062 autoSync: false, 2063 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 2064 schema: '', 2065 securityLevel: factory.SecurityLevel.S1, 2066 } 2067 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 2068 kvStore = store; 2069 console.info(logTag + " get kvStore success"); 2070 }) 2071 2072 let result = undefined; 2073 function call(data) { 2074 console.info(logTag + "syncComplete: " + data); 2075 kvStore.get(TEST_STRING_KEY, (err, data) => { 2076 try { 2077 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 2078 if (err != null) { 2079 console.info(logTag + " Sync complete get data error,err: " + err); 2080 } else { 2081 console.info(logTag + " Sycn complete get data success,result is: " + data); 2082 result = data; 2083 } 2084 console.info(logTag + " get data finish,result is: " + result); 2085 expect(result == undefined).assertTrue(); 2086 console.info(logTag + "testServerS4Security1200 end"); 2087 kvStore.off("syncComplete", call); 2088 done(); 2089 2090 } catch (err) { 2091 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 2092 done(); 2093 } 2094 2095 }) 2096 } 2097 kvStore.on("syncComplete", call); 2098 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 2099 await sleep(1000); 2100 console.info(logTag + "Client sync start"); 2101 kvStore.sync(syncDeviceIds, PUSH_PULL); 2102 }) 2103 2104 /** 2105 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0040 2106 * @tc.name testServerKvStoreId0100 2107 * @tc.desc Get server kvstore with length of storeId is 129 bit. 2108 * @tc.level: Level 2 2109 * @tc.type: Functiontion 2110 * @tc.size: MediumTest 2111 */ 2112 it("testServerKvStoreId0100", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 2113 console.info(logTag + "testServerKvStoreId0100 start"); 2114 await remoteHelpers.getKvStore("x".repeat(129), "S1", false); 2115 await sleep(1000); 2116 const options = { 2117 createIfMissing: true, 2118 encrypt: false, 2119 backup: false, 2120 autoSync: false, 2121 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 2122 schema: '', 2123 securityLevel: factory.SecurityLevel.S1, 2124 } 2125 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 2126 kvStore = store; 2127 console.info(logTag + " get kvStore success"); 2128 }) 2129 let result = undefined; 2130 function call(data) { 2131 console.info(logTag + "syncComplete: " + data); 2132 kvStore.get(TEST_STRING_KEY, (err, data) => { 2133 try { 2134 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 2135 if (err != null) { 2136 console.info(logTag + " Sync complete get data error,err: " + err); 2137 } else { 2138 console.info(logTag + " Sycn complete get data success,result is: " + data); 2139 result = data; 2140 } 2141 console.info(logTag + " get data finish,result is: " + result); 2142 expect(result == undefined).assertTrue(); 2143 console.info(logTag + "testServerKvStoreId0100 end"); 2144 kvStore.off("syncComplete", call); 2145 done(); 2146 2147 } catch (err) { 2148 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 2149 done(); 2150 } 2151 2152 }) 2153 } 2154 kvStore.on("syncComplete", call); 2155 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 2156 await sleep(1000); 2157 console.info(logTag + "Client sync start"); 2158 kvStore.sync(syncDeviceIds, PULL); 2159 }) 2160 2161 /** 2162 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0200 2163 * @tc.name testServerKvStoreId0200 2164 * @tc.desc Get server kvstore with length of storeId is 129 bit. 2165 * @tc.level: Level 2 2166 * @tc.type: Functiontion 2167 * @tc.size: MediumTest 2168 */ 2169 it("testServerKvStoreId0200", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 2170 console.info(logTag + "testServerKvStoreId0200 start"); 2171 await remoteHelpers.getKvStore("x".repeat(129), "S1", false); 2172 await sleep(1000); 2173 const options = { 2174 createIfMissing: true, 2175 encrypt: false, 2176 backup: false, 2177 autoSync: false, 2178 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 2179 schema: '', 2180 securityLevel: factory.SecurityLevel.S1, 2181 } 2182 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 2183 kvStore = store; 2184 console.info(logTag + " get kvStore success"); 2185 }) 2186 let result = undefined; 2187 function call(data) { 2188 console.info(logTag + "syncComplete: " + data); 2189 kvStore.get(TEST_STRING_KEY, (err, data) => { 2190 try { 2191 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 2192 if (err != null) { 2193 console.info(logTag + " Sync complete get data error,err: " + err); 2194 } else { 2195 console.info(logTag + " Sycn complete get data success,result is: " + data); 2196 result = data; 2197 } 2198 console.info(logTag + " get data finish,result is: " + result); 2199 expect(result == undefined).assertTrue(); 2200 console.info(logTag + "testServerKvStoreId0200 end"); 2201 kvStore.off("syncComplete", call); 2202 done(); 2203 2204 } catch (err) { 2205 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 2206 done(); 2207 } 2208 2209 }) 2210 } 2211 kvStore.on("syncComplete", call); 2212 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 2213 await sleep(1000); 2214 console.info(logTag + "Client sync start"); 2215 kvStore.sync(syncDeviceIds, PUSH_PULL); 2216 }) 2217 2218 /** 2219 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0030 2220 * @tc.name testServerKvStoreId0300 2221 * @tc.desc Get server kvstore with length of storeId is 128 bit. 2222 * @tc.level: Level 2 2223 * @tc.type: Functiontion 2224 * @tc.size: MediumTest 2225 */ 2226 it("testServerKvStoreId0300", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 2227 console.info(logTag + "testServerKvStoreId0300 start"); 2228 await remoteHelpers.getKvStore("x".repeat(128), "S1", false); 2229 await sleep(1000); 2230 const options = { 2231 createIfMissing: true, 2232 encrypt: false, 2233 backup: false, 2234 autoSync: false, 2235 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 2236 schema: '', 2237 securityLevel: factory.SecurityLevel.S1, 2238 } 2239 await kvManager.getKVStore("x".repeat(128), options).then((store) => { 2240 kvStore = store; 2241 console.info(logTag + " get kvStore success"); 2242 }) 2243 2244 let result = undefined; 2245 function call(data) { 2246 console.info(logTag + "syncComplete: " + data); 2247 kvStore.get(TEST_STRING_KEY, async(err, data) => { 2248 try { 2249 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 2250 if (err != null) { 2251 console.info(logTag + " Sync complete get data error,err: " + err); 2252 } else { 2253 console.info(logTag + " Sycn complete get data success,result is: " + data); 2254 result = data; 2255 } 2256 console.info(logTag + " get data finish,result is: " + result); 2257 expect(result).assertEqual(TEST_STRING_VALUE); 2258 kvStore.off("syncComplete", call); 2259 2260 console.info(logTag + " ##### deleteKVStore begin #####" ); 2261 await kvManager.closeKVStore(TEST_BUNDLE_NAME, "x".repeat(128)).then(async () => { 2262 console.info(logTag + 'testServerKvStoreId0300 CLIENT closeKVStore success'); 2263 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, "x".repeat(128)).then(() => { 2264 console.info(logTag + 'testServerKvStoreId0300 CLIENT deleteKVStore success'); 2265 }); 2266 }); 2267 await remoteHelpers.closeKvStore("x".repeat(128)).then(async (ret) => { 2268 console.info(logTag + "testServerKvStoreId0300 remoteHelpers closeKvStore success: " + ret) 2269 }) 2270 await sleep(2000); 2271 console.info(logTag + "testServerKvStoreId0300 end"); 2272 done(); 2273 2274 } catch (err) { 2275 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 2276 done(); 2277 } 2278 2279 }) 2280 } 2281 kvStore.on("syncComplete", call); 2282 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 2283 await sleep(1000); 2284 console.info(logTag + "Client sync start"); 2285 kvStore.sync(syncDeviceIds, PULL); 2286 }) 2287 2288 /** 2289 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0190 2290 * @tc.name testServerKvStoreId0400 2291 * @tc.desc Get server kvstore with length of storeId is 128 bit. PUSH_PULL 2292 * @tc.level: Level 2 2293 * @tc.type: Functiontion 2294 * @tc.size: MediumTest 2295 */ 2296 it("testServerKvStoreId0400", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 2297 console.info(logTag + "testServerKvStoreId0400 start"); 2298 await remoteHelpers.getKvStore("x".repeat(128), "S1", false); 2299 await sleep(1000); 2300 const options = { 2301 createIfMissing: true, 2302 encrypt: false, 2303 backup: false, 2304 autoSync: false, 2305 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 2306 schema: '', 2307 securityLevel: factory.SecurityLevel.S1, 2308 } 2309 await kvManager.getKVStore("x".repeat(128), options).then((store) => { 2310 kvStore = store; 2311 console.info(logTag + " get kvStore success"); 2312 }) 2313 2314 let result = undefined; 2315 function call(data) { 2316 console.info(logTag + "syncComplete: " + data); 2317 kvStore.get(TEST_STRING_KEY, async(err, data) => { 2318 try { 2319 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 2320 if (err != null) { 2321 console.info(logTag + " Sync complete get data error,err: " + err); 2322 } else { 2323 console.info(logTag + " Sycn complete get data success,result is: " + data); 2324 result = data; 2325 } 2326 console.info(logTag + " get data finish,result is: " + result); 2327 expect(result).assertEqual(TEST_STRING_VALUE); 2328 kvStore.off("syncComplete", call); 2329 2330 console.info(logTag + " ##### deleteKVStore begin #####" ); 2331 await kvManager.closeKVStore(TEST_BUNDLE_NAME, "x".repeat(128)).then(async () => { 2332 console.info(logTag + 'testServerKvStoreId0400 CLIENT closeKVStore success'); 2333 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, "x".repeat(128)).then(() => { 2334 console.info(logTag + 'testServerKvStoreId0400 CLIENT deleteKVStore success'); 2335 }); 2336 }); 2337 await remoteHelpers.closeKvStore("x".repeat(128)).then(async (ret) => { 2338 console.info(logTag + "testServerKvStoreId0400 remoteHelpers closeKvStore success: " + ret) 2339 }) 2340 await sleep(2000); 2341 console.info(logTag + "testServerKvStoreId0400 end"); 2342 done(); 2343 2344 } catch (err) { 2345 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 2346 done(); 2347 } 2348 }) 2349 } 2350 kvStore.on("syncComplete", call); 2351 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 2352 await sleep(1000); 2353 console.info(logTag + "Client sync start"); 2354 kvStore.sync(syncDeviceIds, PUSH_PULL); 2355 }) 2356 2357 /** 2358 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0020 2359 * @tc.name testServerKvStoreId0500 2360 * @tc.desc The storeId of the two devices' kvstores are inconsistent 2361 * @tc.level: Level 2 2362 * @tc.type: Functiontion 2363 * @tc.size: MediumTest 2364 */ 2365 it("testServerKvStoreId0500", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 2366 console.info(logTag + "testServerKvStoreId0500 start"); 2367 await remoteHelpers.getKvStore("SERVER_KVSTORE", "S1", false); 2368 await sleep(1000); 2369 const options = { 2370 createIfMissing: true, 2371 encrypt: false, 2372 backup: false, 2373 autoSync: false, 2374 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 2375 schema: '', 2376 securityLevel: factory.SecurityLevel.S1, 2377 } 2378 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 2379 kvStore = store; 2380 console.info(logTag + " get kvStore success"); 2381 }) 2382 let result = undefined; 2383 function call(data) { 2384 console.info(logTag + "syncComplete: " + data); 2385 kvStore.get(TEST_STRING_KEY, async(err, data) => { 2386 try { 2387 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 2388 if (err != null) { 2389 console.info(logTag + " Sync complete get data error,err: " + err); 2390 } else { 2391 console.info(logTag + " Sycn complete get data success,result is: " + data); 2392 result = data; 2393 } 2394 console.info(logTag + " get data finish,result is: " + result); 2395 expect(result == undefined).assertTrue(); 2396 kvStore.off("syncComplete", call); 2397 2398 console.info(logTag + " ##### deleteKVStore begin #####" ); 2399 await remoteHelpers.closeKvStore("SERVER_KVSTORE").then(async (ret) => { 2400 console.info(logTag + "testServerKvStoreId0500 remoteHelpers closeKvStore success: " + ret) 2401 }) 2402 await sleep(2000); 2403 console.info(logTag + "testServerKvStoreId0500 end"); 2404 done(); 2405 2406 } catch (err) { 2407 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 2408 done(); 2409 } 2410 2411 }) 2412 } 2413 kvStore.on("syncComplete", call); 2414 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 2415 await sleep(1000); 2416 console.info(logTag + "Client sync start"); 2417 kvStore.sync(syncDeviceIds, PULL); 2418 }) 2419 2420 /** 2421 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0180 2422 * @tc.name testServerKvStoreId0600 2423 * @tc.desc The storeId of the two devices' kvstores are inconsistent 2424 * @tc.level: Level 2 2425 * @tc.type: Functiontion 2426 * @tc.size: MediumTest 2427 */ 2428 it("testServerKvStoreId0600", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 2429 console.info(logTag + "testServerKvStoreId0600 start"); 2430 await remoteHelpers.getKvStore("SERVER_KVSTORE", "S1", false); 2431 await sleep(1000); 2432 const options = { 2433 createIfMissing: true, 2434 encrypt: false, 2435 backup: false, 2436 autoSync: false, 2437 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 2438 schema: '', 2439 securityLevel: factory.SecurityLevel.S1, 2440 } 2441 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 2442 kvStore = store; 2443 console.info(logTag + " get kvStore success"); 2444 }) 2445 let result = undefined; 2446 function call(data) { 2447 console.info(logTag + "syncComplete: " + data); 2448 kvStore.get(TEST_STRING_KEY, async(err, data) => { 2449 try { 2450 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 2451 if (err != null) { 2452 console.info(logTag + " Sync complete get data error,err: " + err); 2453 } else { 2454 console.info(logTag + " Sycn complete get data success,result is: " + data); 2455 result = data; 2456 } 2457 console.info(logTag + " get data finish,result is: " + result); 2458 expect(result == undefined).assertTrue(); 2459 kvStore.off("syncComplete", call); 2460 2461 console.info(logTag + " ##### deleteKVStore begin #####" ); 2462 await remoteHelpers.closeKvStore("SERVER_KVSTORE").then(async (ret) => { 2463 console.info(logTag + "testServerKvStoreId0600 remoteHelpers closeKvStore success: " + ret) 2464 }) 2465 await sleep(2000); 2466 console.info(logTag + "testServerKvStoreId0600 end"); 2467 done(); 2468 2469 } catch (err) { 2470 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 2471 done(); 2472 } 2473 2474 }) 2475 } 2476 kvStore.on("syncComplete", call); 2477 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 2478 await sleep(1000); 2479 console.info(logTag + "Client sync start"); 2480 kvStore.sync(syncDeviceIds, PUSH_PULL); 2481 }) 2482 2483 /** 2484 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0330 2485 * @tc.name testServerEncryptKVStore0100 2486 * @tc.desc Unencrypt kvStore PULL from encrypt kvStore 2487 * @tc.level: Level 2 2488 * @tc.type: Functiontion 2489 * @tc.size: MediumTest 2490 */ 2491 it("testServerEncryptKVStore0100", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 2492 console.info(logTag + "testServerEncryptKVStore0100 start"); 2493 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", true); 2494 await sleep(1000); 2495 const options = { 2496 createIfMissing: true, 2497 encrypt: false, 2498 backup: false, 2499 autoSync: false, 2500 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 2501 schema: '', 2502 securityLevel: factory.SecurityLevel.S1, 2503 } 2504 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 2505 kvStore = store; 2506 console.info(logTag + " get kvStore success"); 2507 }) 2508 let result = undefined; 2509 function call(data) { 2510 console.info(logTag + "syncComplete: " + data); 2511 kvStore.get(TEST_STRING_KEY, (err, data) => { 2512 try { 2513 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 2514 if (err != null) { 2515 console.info(logTag + " Sync complete get data error,err: " + err); 2516 } else { 2517 console.info(logTag + " Sycn complete get data success,result is: " + data); 2518 result = data; 2519 } 2520 console.info(logTag + " get data finish,result is: " + result); 2521 expect(result).assertEqual(TEST_STRING_VALUE); 2522 kvStore.off("syncComplete", call); 2523 console.info(logTag + "testServerEncryptKVStore0100 end"); 2524 done(); 2525 2526 } catch (err) { 2527 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 2528 done(); 2529 } 2530 2531 }) 2532 } 2533 kvStore.on("syncComplete", call); 2534 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 2535 await sleep(1000); 2536 console.info(logTag + "Client sync start"); 2537 kvStore.sync(syncDeviceIds, PULL); 2538 }) 2539 2540 /** 2541 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0350 2542 * @tc.name testServerEncryptKVStore0200 2543 * @tc.desc Unencrypt kvStore PUSH_PULL to encrypt kvStore 2544 * @tc.level: Level 2 2545 * @tc.type: Functiontion 2546 * @tc.size: MediumTest 2547 */ 2548 it("testServerEncryptKVStore0200", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 2549 console.info(logTag + "testServerEncryptKVStore0200 start"); 2550 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", true); 2551 await sleep(1000); 2552 const options = { 2553 createIfMissing: true, 2554 encrypt: false, 2555 backup: false, 2556 autoSync: false, 2557 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 2558 schema: '', 2559 securityLevel: factory.SecurityLevel.S1, 2560 } 2561 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 2562 kvStore = store; 2563 console.info(logTag + " get kvStore success"); 2564 }) 2565 let result = undefined; 2566 function call(data) { 2567 console.info(logTag + "syncComplete: " + data); 2568 kvStore.get(TEST_STRING_KEY, (err, data) => { 2569 try { 2570 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 2571 if (err != null) { 2572 console.info(logTag + " Sync complete get data error,err: " + err); 2573 } else { 2574 console.info(logTag + " Sycn complete get data success,result is: " + data); 2575 result = data; 2576 } 2577 console.info(logTag + " get data finish,result is: " + result); 2578 expect(result).assertEqual(TEST_STRING_VALUE); 2579 kvStore.off("syncComplete", call); 2580 console.info(logTag + "testServerEncryptKVStore0200 end"); 2581 done(); 2582 2583 } catch (err) { 2584 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 2585 done(); 2586 } 2587 2588 }) 2589 } 2590 kvStore.on("syncComplete", call); 2591 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 2592 await sleep(1000); 2593 console.info(logTag + "Client sync start"); 2594 kvStore.sync(syncDeviceIds, PULL); 2595 }) 2596 2597 /** 2598 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0340 2599 * @tc.name testServerEncryptKVStore0300 2600 * @tc.desc Encrypt kvStore PULL from encrypt kvStore 2601 * @tc.level: Level 2 2602 * @tc.type: Functiontion 2603 * @tc.size: MediumTest 2604 */ 2605 it("testServerEncryptKVStore0300", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 2606 console.info(logTag + "testServerEncryptKVStore0300 start"); 2607 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", true); 2608 await sleep(1000); 2609 const options = { 2610 createIfMissing: true, 2611 encrypt: true, 2612 backup: false, 2613 autoSync: false, 2614 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 2615 schema: '', 2616 securityLevel: factory.SecurityLevel.S1, 2617 } 2618 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 2619 kvStore = store; 2620 console.info(logTag + " get kvStore success"); 2621 }) 2622 let result = undefined; 2623 function call(data) { 2624 console.info(logTag + "syncComplete: " + data); 2625 kvStore.get(TEST_STRING_KEY, (err, data) => { 2626 try { 2627 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 2628 if (err != null) { 2629 console.info(logTag + " Sync complete get data error,err: " + err); 2630 } else { 2631 console.info(logTag + " Sycn complete get data success,result is: " + data); 2632 result = data; 2633 } 2634 console.info(logTag + " get data finish,result is: " + result); 2635 expect(result).assertEqual(TEST_STRING_VALUE); 2636 kvStore.off("syncComplete", call); 2637 console.info(logTag + "testServerEncryptKVStore0300 end"); 2638 done(); 2639 2640 } catch (err) { 2641 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 2642 done(); 2643 } 2644 2645 }) 2646 } 2647 kvStore.on("syncComplete", call); 2648 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 2649 await sleep(1000); 2650 console.info(logTag + "Client sync start"); 2651 kvStore.sync(syncDeviceIds, PULL); 2652 }) 2653 2654 /** 2655 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0360 2656 * @tc.name testServerEncryptKVStore0400 2657 * @tc.desc Encrypt kvStore PUSH_PULL to encrypt kvStore 2658 * @tc.level: Level 2 2659 * @tc.type: Functiontion 2660 * @tc.size: MediumTest 2661 */ 2662 it("testServerEncryptKVStore0400", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 2663 console.info(logTag + "testServerEncryptKVStore0400 start"); 2664 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", true); 2665 await sleep(1000); 2666 const options = { 2667 createIfMissing: true, 2668 encrypt: true, 2669 backup: false, 2670 autoSync: false, 2671 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 2672 schema: '', 2673 securityLevel: factory.SecurityLevel.S1, 2674 } 2675 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 2676 kvStore = store; 2677 console.info(logTag + " get kvStore success"); 2678 }) 2679 let result = undefined; 2680 function call(data) { 2681 console.info(logTag + "syncComplete: " + data); 2682 kvStore.get(TEST_STRING_KEY, (err, data) => { 2683 try { 2684 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 2685 if (err != null) { 2686 console.info(logTag + " Sync complete get data error,err: " + err); 2687 } else { 2688 console.info(logTag + " Sycn complete get data success,result is: " + data); 2689 result = data; 2690 } 2691 console.info(logTag + " get data finish,result is: " + result); 2692 expect(result).assertEqual(TEST_STRING_VALUE); 2693 kvStore.off("syncComplete", call); 2694 console.info(logTag + "testServerEncryptKVStore0400 end"); 2695 done(); 2696 2697 } catch (err) { 2698 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 2699 done(); 2700 } 2701 2702 }) 2703 } 2704 kvStore.on("syncComplete", call); 2705 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 2706 await sleep(1000); 2707 console.info(logTag + "Client sync start"); 2708 kvStore.sync(syncDeviceIds, PULL); 2709 }) 2710 2711 /** 2712 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0310 2713 * @tc.name testServerEncryptKVStore0500 2714 * @tc.desc Encrypt kvStore PULL from unencrypt kvStore 2715 * @tc.level: Level 2 2716 * @tc.type: Functiontion 2717 * @tc.size: MediumTest 2718 */ 2719 it("testServerEncryptKVStore0500", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 2720 console.info(logTag + "testServerEncryptKVStore0500 start"); 2721 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 2722 await sleep(1000); 2723 const options = { 2724 createIfMissing: true, 2725 encrypt: true, 2726 backup: false, 2727 autoSync: false, 2728 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 2729 schema: '', 2730 securityLevel: factory.SecurityLevel.S1, 2731 } 2732 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 2733 kvStore = store; 2734 console.info(logTag + " get kvStore success"); 2735 }) 2736 let result = undefined; 2737 function call(data) { 2738 console.info(logTag + "syncComplete: " + data); 2739 kvStore.get(TEST_STRING_KEY, (err, data) => { 2740 try { 2741 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 2742 if (err != null) { 2743 console.info(logTag + " Sync complete get data error,err: " + err); 2744 } else { 2745 console.info(logTag + " Sycn complete get data success,result is: " + data); 2746 result = data; 2747 } 2748 console.info(logTag + " get data finish,result is: " + result); 2749 expect(result).assertEqual(TEST_STRING_VALUE); 2750 kvStore.off("syncComplete", call); 2751 console.info(logTag + "testServerEncryptKVStore0500 end"); 2752 done(); 2753 2754 } catch (err) { 2755 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 2756 done(); 2757 } 2758 2759 }) 2760 } 2761 kvStore.on("syncComplete", call); 2762 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 2763 await sleep(1000); 2764 console.info(logTag + "Client sync start"); 2765 kvStore.sync(syncDeviceIds, PULL); 2766 }) 2767 2768 /** 2769 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0320 2770 * @tc.name testServerEncryptKVStore0600 2771 * @tc.desc Encrypt kvStore PUSH_PULL unencrypt kvStore 2772 * @tc.level: Level 2 2773 * @tc.type: Functiontion 2774 * @tc.size: MediumTest 2775 */ 2776 it("testServerEncryptKVStore0600", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 2777 console.info(logTag + "testServerEncryptKVStore0600 start"); 2778 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 2779 await sleep(1000); 2780 const options = { 2781 createIfMissing: true, 2782 encrypt: true, 2783 backup: false, 2784 autoSync: false, 2785 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 2786 schema: '', 2787 securityLevel: factory.SecurityLevel.S1, 2788 } 2789 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 2790 kvStore = store; 2791 console.info(logTag + " get kvStore success"); 2792 }) 2793 let result = undefined; 2794 function call(data) { 2795 console.info(logTag + "syncComplete: " + data); 2796 kvStore.get(TEST_STRING_KEY, (err, data) => { 2797 try { 2798 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 2799 if (err != null) { 2800 console.info(logTag + " Sync complete get data error,err: " + err); 2801 } else { 2802 console.info(logTag + " Sycn complete get data success,result is: " + data); 2803 result = data; 2804 } 2805 console.info(logTag + " get data finish,result is: " + result); 2806 expect(result).assertEqual(TEST_STRING_VALUE); 2807 kvStore.off("syncComplete", call); 2808 console.info(logTag + "testServerEncryptKVStore0600 end"); 2809 done(); 2810 2811 } catch (err) { 2812 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 2813 done(); 2814 } 2815 2816 }) 2817 } 2818 kvStore.on("syncComplete", call); 2819 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 2820 await sleep(1000); 2821 console.info(logTag + "Client sync start"); 2822 kvStore.sync(syncDeviceIds, PULL); 2823 }) 2824 2825 /** 2826 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_1100 2827 * @tc.name testServerMaxKeyLength0100 2828 * @tc.desc Length of key greater than 1024 2829 * @tc.level: Level 2 2830 * @tc.type: Functiontion 2831 * @tc.size: MediumTest 2832 */ 2833 it("testServerMaxKeyLength0100", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 2834 console.info(logTag + "testServerMaxKeyLength0100 start"); 2835 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 2836 await sleep(1000); 2837 const options = { 2838 createIfMissing: true, 2839 encrypt: false, 2840 backup: false, 2841 autoSync: false, 2842 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 2843 schema: '', 2844 securityLevel: factory.SecurityLevel.S1, 2845 } 2846 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 2847 kvStore = store; 2848 console.info(logTag + " get kvStore success"); 2849 }) 2850 let result = undefined; 2851 function call(data) { 2852 console.info(logTag + "syncComplete: " + data); 2853 kvStore.get(TEST_STRING_KEY, (err, data) => { 2854 try { 2855 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 2856 if (err != null) { 2857 console.info(logTag + " Sync complete get data error,err: " + err); 2858 } else { 2859 console.info(logTag + " Sycn complete get data success,result is: " + data); 2860 result = data; 2861 } 2862 console.info(logTag + " get data finish,result is: " + result); 2863 expect(result == undefined).assertTrue(); 2864 kvStore.off("syncComplete", call); 2865 console.info(logTag + "testServerMaxKeyLength0100 end"); 2866 done(); 2867 2868 } catch (err) { 2869 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 2870 done(); 2871 } 2872 2873 }) 2874 } 2875 kvStore.on("syncComplete", call); 2876 await remoteHelpers.kvPut("x".repeat(1025), TEST_STRING_VALUE, "String"); 2877 await sleep(1000); 2878 console.info(logTag + "Client sync start"); 2879 kvStore.sync(syncDeviceIds, PULL); 2880 }) 2881 2882 /** 2883 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_1110 2884 * @tc.name testServerMaxKeyLength0200 2885 * @tc.desc Length of key greater than 1024 2886 * @tc.level: Level 2 2887 * @tc.type: Functiontion 2888 * @tc.size: MediumTest 2889 */ 2890 it("testServerMaxKeyLength0200", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 2891 console.info(logTag + "testServerMaxKeyLength0200 start"); 2892 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 2893 await sleep(1000); 2894 const options = { 2895 createIfMissing: true, 2896 encrypt: false, 2897 backup: false, 2898 autoSync: false, 2899 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 2900 schema: '', 2901 securityLevel: factory.SecurityLevel.S1, 2902 } 2903 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 2904 kvStore = store; 2905 console.info(logTag + " get kvStore success"); 2906 }) 2907 let result = undefined; 2908 function call(data) { 2909 console.info(logTag + "syncComplete: " + data); 2910 kvStore.get(TEST_STRING_KEY, (err, data) => { 2911 try { 2912 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 2913 if (err != null) { 2914 console.info(logTag + " Sync complete get data error,err: " + err); 2915 } else { 2916 console.info(logTag + " Sycn complete get data success,result is: " + data); 2917 result = data; 2918 } 2919 console.info(logTag + " get data finish,result is: " + result); 2920 expect(result == undefined).assertTrue(); 2921 kvStore.off("syncComplete", call); 2922 console.info(logTag + "testServerMaxKeyLength0200 end"); 2923 done(); 2924 2925 } catch (err) { 2926 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 2927 done(); 2928 } 2929 2930 }) 2931 } 2932 kvStore.on("syncComplete", call); 2933 await remoteHelpers.kvPut("x".repeat(1025), TEST_STRING_VALUE, "String"); 2934 await sleep(1000); 2935 console.info(logTag + "Client sync start"); 2936 kvStore.sync(syncDeviceIds, PUSH_PULL); 2937 }) 2938 2939 /** 2940 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_1120 2941 * @tc.name testServerMaxKeyLength0300 2942 * @tc.desc Length of key is 1024 2943 * @tc.level: Level 2 2944 * @tc.type: Functiontion 2945 * @tc.size: MediumTest 2946 */ 2947 it("testServerMaxKeyLength0300", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 2948 console.info(logTag + "testServerMaxKeyLength0300 start"); 2949 const KEY = "x".repeat(1024) 2950 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 2951 await sleep(1000); 2952 const options = { 2953 createIfMissing: true, 2954 encrypt: false, 2955 backup: false, 2956 autoSync: false, 2957 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 2958 schema: '', 2959 securityLevel: factory.SecurityLevel.S1, 2960 } 2961 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 2962 kvStore = store; 2963 console.info(logTag + " get kvStore success"); 2964 }) 2965 let result = undefined; 2966 function call(data) { 2967 console.info(logTag + "syncComplete: " + data); 2968 kvStore.get(KEY, (err, data) => { 2969 try { 2970 console.info(logTag + " Sync complete get data,key is " + KEY) 2971 if (err != null) { 2972 console.info(logTag + " Sync complete get data error,err: " + err); 2973 } else { 2974 console.info(logTag + " Sycn complete get data success,result is: " + data); 2975 result = data; 2976 } 2977 console.info(logTag + " get data finish,result is: " + result); 2978 expect(result).assertEqual(TEST_STRING_VALUE); 2979 kvStore.off("syncComplete", call); 2980 console.info(logTag + "testServerMaxKeyLength0300 end"); 2981 done(); 2982 2983 } catch (err) { 2984 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 2985 done(); 2986 } 2987 2988 }) 2989 } 2990 kvStore.on("syncComplete", call); 2991 await remoteHelpers.kvPut(KEY, TEST_STRING_VALUE, "String"); 2992 await sleep(1000); 2993 console.info(logTag + "Client sync start"); 2994 kvStore.sync(syncDeviceIds, PULL); 2995 }) 2996 2997 /** 2998 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_1130 2999 * @tc.name testServerMaxKeyLength0400 3000 * @tc.desc Length of key is 1024 3001 * @tc.level: Level 2 3002 * @tc.type: Functiontion 3003 * @tc.size: MediumTest 3004 */ 3005 it("testServerMaxKeyLength0400", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 3006 console.info(logTag + "testServerMaxKeyLength0400 start"); 3007 const KEY = "x".repeat(1024) 3008 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 3009 await sleep(1000); 3010 const options = { 3011 createIfMissing: true, 3012 encrypt: false, 3013 backup: false, 3014 autoSync: false, 3015 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 3016 schema: '', 3017 securityLevel: factory.SecurityLevel.S1, 3018 } 3019 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 3020 kvStore = store; 3021 console.info(logTag + " get kvStore success"); 3022 }) 3023 let result = undefined; 3024 function call(data) { 3025 console.info(logTag + "syncComplete: " + data); 3026 kvStore.get(KEY, (err, data) => { 3027 try { 3028 console.info(logTag + " Sync complete get data,key is " + KEY) 3029 if (err != null) { 3030 console.info(logTag + " Sync complete get data error,err: " + err); 3031 } else { 3032 console.info(logTag + " Sycn complete get data success,result is: " + data); 3033 result = data; 3034 } 3035 console.info(logTag + " get data finish,result is: " + result); 3036 expect(result).assertEqual(TEST_STRING_VALUE); 3037 kvStore.off("syncComplete", call); 3038 console.info(logTag + "testServerMaxKeyLength0400 end"); 3039 done(); 3040 3041 } catch (err) { 3042 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 3043 done(); 3044 } 3045 3046 }) 3047 } 3048 kvStore.on("syncComplete", call); 3049 await remoteHelpers.kvPut(KEY, TEST_STRING_VALUE, "String"); 3050 await sleep(1000); 3051 console.info(logTag + "Client sync start"); 3052 kvStore.sync(syncDeviceIds, PUSH_PULL); 3053 }) 3054 3055 /** 3056 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0140 3057 * @tc.name testSyncStringType0100 3058 * @tc.desc Sync string type data 3059 * @tc.level: Level 2 3060 * @tc.type: Functiontion 3061 * @tc.size: MediumTest 3062 */ 3063 it("testSyncStringType0100", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 3064 console.info(logTag + "testSyncStringType0100 start"); 3065 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 3066 await sleep(1000); 3067 const options = { 3068 createIfMissing: true, 3069 encrypt: false, 3070 backup: false, 3071 autoSync: false, 3072 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 3073 schema: '', 3074 securityLevel: factory.SecurityLevel.S1, 3075 } 3076 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 3077 kvStore = store; 3078 console.info(logTag + " get kvStore success"); 3079 }) 3080 let result = undefined; 3081 function call(data) { 3082 console.info(logTag + "syncComplete: " + data); 3083 kvStore.get(TEST_STRING_KEY, (err, data) => { 3084 try { 3085 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 3086 if (err != null) { 3087 console.info(logTag + " Sync complete get data error,err: " + err); 3088 } else { 3089 console.info(logTag + " Sycn complete get data success,result is: " + data); 3090 result = data; 3091 } 3092 console.info(logTag + " get data finish,result is: " + result); 3093 expect(result).assertEqual(TEST_STRING_VALUE); 3094 kvStore.off("syncComplete", call); 3095 console.info(logTag + "testSyncStringType0100 end"); 3096 done(); 3097 3098 } catch (err) { 3099 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 3100 done(); 3101 } 3102 3103 }) 3104 } 3105 kvStore.on("syncComplete", call); 3106 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 3107 await sleep(1000); 3108 console.info(logTag + "Client sync start"); 3109 kvStore.sync(syncDeviceIds, PULL); 3110 }) 3111 3112 /** 3113 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0280 3114 * @tc.name testSyncStringType0200 3115 * @tc.desc Sync string type data 3116 * @tc.level: Level 2 3117 * @tc.type: Functiontion 3118 * @tc.size: MediumTest 3119 */ 3120 it("testSyncStringType0200", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 3121 console.info(logTag + "testSyncStringType0200 start"); 3122 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 3123 await sleep(1000); 3124 const options = { 3125 createIfMissing: true, 3126 encrypt: false, 3127 backup: false, 3128 autoSync: false, 3129 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 3130 schema: '', 3131 securityLevel: factory.SecurityLevel.S1, 3132 } 3133 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 3134 kvStore = store; 3135 console.info(logTag + " get kvStore success"); 3136 }) 3137 let result = undefined; 3138 function call(data) { 3139 console.info(logTag + "syncComplete: " + data); 3140 kvStore.get(TEST_STRING_KEY, (err, data) => { 3141 try { 3142 console.info(logTag + " Sync complete get data,key is " + TEST_STRING_KEY); 3143 if (err != null) { 3144 console.info(logTag + " Sync complete get data error,err: " + err); 3145 } else { 3146 console.info(logTag + " Sycn complete get data success,result is: " + data); 3147 result = data; 3148 } 3149 console.info(logTag + " get data finish,result is: " + result); 3150 expect(result).assertEqual(TEST_STRING_VALUE); 3151 kvStore.off("syncComplete", call); 3152 console.info(logTag + "testSyncStringType0200 end"); 3153 done(); 3154 3155 } catch (err) { 3156 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 3157 done(); 3158 } 3159 3160 }) 3161 } 3162 kvStore.on("syncComplete", call); 3163 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 3164 await sleep(1000); 3165 console.info(logTag + "Client sync start"); 3166 kvStore.sync(syncDeviceIds, PULL); 3167 }) 3168 3169 /** 3170 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0060 3171 * @tc.name testSyncIntType0100 3172 * @tc.desc Sync int type data 3173 * @tc.level: Level 2 3174 * @tc.type: Functiontion 3175 * @tc.size: MediumTest 3176 */ 3177 it("testSyncIntType0100", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 3178 console.info(logTag + "testSyncIntType0100 start"); 3179 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 3180 await sleep(1000); 3181 const options = { 3182 createIfMissing: true, 3183 encrypt: false, 3184 backup: false, 3185 autoSync: false, 3186 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 3187 schema: '', 3188 securityLevel: factory.SecurityLevel.S1, 3189 } 3190 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 3191 kvStore = store; 3192 console.info(logTag + " get kvStore success"); 3193 }) 3194 let result = undefined; 3195 function call(data) { 3196 console.info(logTag + "syncComplete: " + data); 3197 kvStore.get(TEST_INT_KEY, (err, data) => { 3198 try { 3199 console.info(logTag + " Sync complete get data,key is " + TEST_INT_KEY) 3200 if (err != null) { 3201 console.info(logTag + " Sync complete get data error,err: " + err); 3202 } else { 3203 console.info(logTag + " Sycn complete get data success,result is: " + data); 3204 result = data; 3205 } 3206 console.info(logTag + " get data finish,result is: " + result); 3207 expect(result).assertEqual(TEST_INT_VALUE); 3208 kvStore.off("syncComplete", call); 3209 console.info(logTag + "testSyncIntType0100 end"); 3210 done(); 3211 3212 } catch (err) { 3213 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 3214 done(); 3215 } 3216 3217 }) 3218 } 3219 kvStore.on("syncComplete", call); 3220 await remoteHelpers.kvPut(TEST_INT_KEY, TEST_INT_VALUE, "Number") 3221 await sleep(1000); 3222 console.info(logTag + "Client sync start"); 3223 kvStore.sync(syncDeviceIds, PULL); 3224 }) 3225 3226 /** 3227 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0220 3228 * @tc.name testSyncIntType0200 3229 * @tc.desc Sync int type data 3230 * @tc.level: Level 2 3231 * @tc.type: Functiontion 3232 * @tc.size: MediumTest 3233 */ 3234 it("testSyncIntType0200", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 3235 console.info(logTag + "testSyncIntType0200 start"); 3236 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 3237 await sleep(1000); 3238 const options = { 3239 createIfMissing: true, 3240 encrypt: false, 3241 backup: false, 3242 autoSync: false, 3243 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 3244 schema: '', 3245 securityLevel: factory.SecurityLevel.S1, 3246 } 3247 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 3248 kvStore = store; 3249 console.info(logTag + " get kvStore success"); 3250 }) 3251 let result = undefined; 3252 function call(data) { 3253 console.info(logTag + "syncComplete: " + data); 3254 kvStore.get(TEST_INT_KEY, (err, data) => { 3255 try { 3256 console.info(logTag + " Sync complete get data,key is " + TEST_INT_KEY) 3257 if (err != null) { 3258 console.info(logTag + " Sync complete get data error,err: " + err); 3259 } else { 3260 console.info(logTag + " Sycn complete get data success,result is: " + data); 3261 result = data; 3262 } 3263 console.info(logTag + " get data finish,result is: " + result); 3264 expect(result).assertEqual(TEST_INT_VALUE); 3265 kvStore.off("syncComplete", call); 3266 console.info(logTag + "testSyncIntType0200 end"); 3267 done(); 3268 3269 } catch (err) { 3270 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 3271 done(); 3272 } 3273 3274 }) 3275 } 3276 kvStore.on("syncComplete", call); 3277 await remoteHelpers.kvPut(TEST_INT_KEY, TEST_INT_VALUE, "Number") 3278 await sleep(1000); 3279 console.info(logTag + "Client sync start"); 3280 kvStore.sync(syncDeviceIds, PUSH_PULL); 3281 }) 3282 3283 3284 /** 3285 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0070 3286 * @tc.name testSyncIntType0300 3287 * @tc.desc Sync int type data 3288 * @tc.level: Level 2 3289 * @tc.type: Functiontion 3290 * @tc.size: MediumTest 3291 */ 3292 it("testSyncIntType0300", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 3293 console.info(logTag + "testSyncIntType0300 start"); 3294 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 3295 await sleep(1000); 3296 const options = { 3297 createIfMissing: true, 3298 encrypt: false, 3299 backup: false, 3300 autoSync: false, 3301 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 3302 schema: '', 3303 securityLevel: factory.SecurityLevel.S1, 3304 } 3305 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 3306 kvStore = store; 3307 console.info(logTag + " get kvStore success"); 3308 }) 3309 let result = undefined; 3310 let intValue = Number.MAX_VALUE; 3311 console.info(logTag + "testSyncIntType0300 intValue " + intValue); 3312 function call(data) { 3313 console.info(logTag + "syncComplete: " + data); 3314 kvStore.get(TEST_INT_KEY, (err, data) => { 3315 try { 3316 console.info(logTag + " Sync complete get data,key is " + TEST_INT_KEY); 3317 if (err != null) { 3318 console.info(logTag + " Sync complete get data error,err: " + err); 3319 } else { 3320 console.info(logTag + " Sycn complete get data success,result is: " + data); 3321 result = data; 3322 } 3323 console.info(logTag + " get data finish,result is: " + result); 3324 expect(result).assertEqual(intValue); 3325 kvStore.off("syncComplete", call); 3326 console.info(logTag + "testSyncIntType0300 end"); 3327 done(); 3328 3329 } catch (err) { 3330 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 3331 done(); 3332 } 3333 3334 }) 3335 } 3336 kvStore.on("syncComplete", call); 3337 await remoteHelpers.kvPut(TEST_INT_KEY, intValue, "Number"); 3338 await sleep(1000); 3339 console.info(logTag + "Client sync start"); 3340 kvStore.sync(syncDeviceIds, PULL); 3341 }) 3342 3343 /** 3344 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0230 3345 * @tc.name testSyncIntType0400 3346 * @tc.desc Sync int type data 3347 * @tc.level: Level 2 3348 * @tc.type: Functiontion 3349 * @tc.size: MediumTest 3350 */ 3351 it("testSyncIntType0400", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 3352 console.info(logTag + "testSyncIntType0400 start"); 3353 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 3354 await sleep(1000); 3355 const options = { 3356 createIfMissing: true, 3357 encrypt: false, 3358 backup: false, 3359 autoSync: false, 3360 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 3361 schema: '', 3362 securityLevel: factory.SecurityLevel.S1, 3363 } 3364 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 3365 kvStore = store; 3366 console.info(logTag + " get kvStore success"); 3367 }) 3368 let result = undefined; 3369 let intValue = Number.MAX_VALUE; 3370 let putValue = Number(intValue); 3371 console.info(logTag + "testSyncIntType0400 intValue = " + intValue + " putValue = " + putValue); 3372 function call(data) { 3373 console.info(logTag + "syncComplete: " + data); 3374 kvStore.get(TEST_INT_KEY, (err, data) => { 3375 try { 3376 console.info(logTag + " Sync complete get data,key is " + TEST_INT_KEY); 3377 if (err != null) { 3378 console.info(logTag + " Sync complete get data error,err: " + err); 3379 } else { 3380 console.info(logTag + " Sycn complete get data success,result is: " + data); 3381 result = data; 3382 } 3383 console.info(logTag + " get data finish,result is: " + result); 3384 expect(result).assertEqual(intValue); 3385 kvStore.off("syncComplete", call); 3386 console.info(logTag + "testSyncIntType0400 end"); 3387 done(); 3388 3389 } catch (err) { 3390 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 3391 done(); 3392 } 3393 3394 }) 3395 } 3396 kvStore.on("syncComplete", call); 3397 await remoteHelpers.kvPut(TEST_INT_KEY, intValue, "Number"); 3398 await sleep(1000); 3399 console.info(logTag + "Client sync start"); 3400 kvStore.sync(syncDeviceIds, PUSH_PULL); 3401 }) 3402 3403 /** 3404 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0090 3405 * @tc.name testSyncIntType0500 3406 * @tc.desc Sync int type data 3407 * @tc.level: Level 2 3408 * @tc.type: Functiontion 3409 * @tc.size: MediumTest 3410 */ 3411 it("testSyncIntType0500", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 3412 console.info(logTag + "testSyncIntType0500 start"); 3413 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 3414 await sleep(1000); 3415 const options = { 3416 createIfMissing: true, 3417 encrypt: false, 3418 backup: false, 3419 autoSync: false, 3420 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 3421 schema: '', 3422 securityLevel: factory.SecurityLevel.S1, 3423 } 3424 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 3425 kvStore = store; 3426 console.info(logTag + " get kvStore success"); 3427 }) 3428 3429 let result = undefined; 3430 let intValue = Number.MIN_VALUE; 3431 console.info(logTag + "testSyncIntType0500 intValue " + intValue); 3432 function call(data) { 3433 console.info(logTag + "syncComplete: " + data); 3434 kvStore.get(TEST_INT_KEY, (err, data) => { 3435 try { 3436 console.info(logTag + " Sync complete get data,key is " + TEST_INT_KEY); 3437 if (err != null) { 3438 console.info(logTag + " Sync complete get data error,err: " + err); 3439 } else { 3440 console.info(logTag + " Sycn complete get data success,result is: " + data); 3441 result = data; 3442 } 3443 console.info(logTag + " get data finish,result is: " + result); 3444 expect(result).assertEqual(intValue); 3445 kvStore.off("syncComplete", call); 3446 console.info(logTag + "testSyncIntType0500 end"); 3447 done(); 3448 3449 } catch (err) { 3450 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 3451 done(); 3452 } 3453 3454 }) 3455 } 3456 kvStore.on("syncComplete", call); 3457 await remoteHelpers.kvPut(TEST_INT_KEY, intValue, "Number_Min"); 3458 await sleep(1000); 3459 console.info(logTag + "Client sync start"); 3460 kvStore.sync(syncDeviceIds, PULL); 3461 }) 3462 3463 /** 3464 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0240 3465 * @tc.name testSyncIntType0600 3466 * @tc.desc Sync int type data 3467 * @tc.level: Level 2 3468 * @tc.type: Functiontion 3469 * @tc.size: MediumTest 3470 */ 3471 it("testSyncIntType0600", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 3472 console.info(logTag + "testSyncIntType0600 start"); 3473 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 3474 await sleep(1000); 3475 const options = { 3476 createIfMissing: true, 3477 encrypt: false, 3478 backup: false, 3479 autoSync: false, 3480 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 3481 schema: '', 3482 securityLevel: factory.SecurityLevel.S1, 3483 } 3484 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 3485 kvStore = store; 3486 console.info(logTag + " get kvStore success"); 3487 }) 3488 let result = undefined; 3489 let intValue = Number.MIN_VALUE; 3490 console.info(logTag + "testSyncIntType0600 intValue " + intValue); 3491 function call(data) { 3492 console.info(logTag + "syncComplete: " + data); 3493 kvStore.get(TEST_INT_KEY, (err, data) => { 3494 try { 3495 console.info(logTag + " Sync complete get data,key is " + TEST_INT_KEY); 3496 if (err != null) { 3497 console.info(logTag + " Sync complete get data error,err: " + err); 3498 } else { 3499 console.info(logTag + " Sycn complete get data success,result is: " + data); 3500 result = data; 3501 } 3502 console.info(logTag + " get data finish,result is: " + result); 3503 expect(result).assertEqual(intValue); 3504 kvStore.off("syncComplete", call); 3505 console.info(logTag + "testSyncIntType0600 end"); 3506 done(); 3507 3508 } catch (err) { 3509 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 3510 done(); 3511 } 3512 3513 }) 3514 } 3515 kvStore.on("syncComplete", call); 3516 await remoteHelpers.kvPut(TEST_INT_KEY, intValue, "Number_Min"); 3517 await sleep(1000); 3518 console.info(logTag + "Client sync start"); 3519 kvStore.sync(syncDeviceIds, PUSH_PULL); 3520 }) 3521 3522 3523 /** 3524 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0110 3525 * @tc.name testSyncIntType0700 3526 * @tc.desc Sync int type data 3527 * @tc.level: Level 2 3528 * @tc.type: Functiontion 3529 * @tc.size: MediumTest 3530 */ 3531 it("testSyncIntType0700", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 3532 console.info(logTag + "testSyncIntType0700 start"); 3533 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 3534 await sleep(1000); 3535 const options = { 3536 createIfMissing: true, 3537 encrypt: false, 3538 backup: false, 3539 autoSync: false, 3540 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 3541 schema: '', 3542 securityLevel: factory.SecurityLevel.S1, 3543 } 3544 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 3545 kvStore = store; 3546 console.info(logTag + " get kvStore success"); 3547 }) 3548 let result = undefined; 3549 let intValue = Number.NaN; 3550 console.info(logTag + "testSyncIntType0700 intValue " + intValue); 3551 function call(data) { 3552 console.info(logTag + "syncComplete: " + data); 3553 kvStore.get(TEST_INT_KEY, (err, data) => { 3554 try { 3555 console.info(logTag + " Sync complete get data,key is " + TEST_INT_KEY); 3556 if (err != null) { 3557 console.info(logTag + " Sync complete get data error,err: " + err); 3558 } else { 3559 console.info(logTag + " Sycn complete get data success,result is: " + data); 3560 result = data; 3561 } 3562 console.info(logTag + " get data finish,result is: " + result); 3563 expect(Number.isNaN(result)).assertTrue(); 3564 kvStore.off("syncComplete", call); 3565 console.info(logTag + "testSyncIntType0700 end"); 3566 done(); 3567 3568 } catch (err) { 3569 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 3570 done(); 3571 } 3572 3573 }) 3574 } 3575 kvStore.on("syncComplete", call); 3576 await remoteHelpers.kvPut(TEST_INT_KEY, intValue, "Number"); 3577 await sleep(1000); 3578 console.info(logTag + "Client sync start"); 3579 kvStore.sync(syncDeviceIds, PULL); 3580 }) 3581 3582 /** 3583 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0250 3584 * @tc.name testSyncIntType0800 3585 * @tc.desc Sync int type data 3586 * @tc.level: Level 2 3587 * @tc.type: Functiontion 3588 * @tc.size: MediumTest 3589 */ 3590 it("testSyncIntType0800", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 3591 console.info(logTag + "testSyncIntType0800 start"); 3592 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 3593 await sleep(1000); 3594 const options = { 3595 createIfMissing: true, 3596 encrypt: false, 3597 backup: false, 3598 autoSync: false, 3599 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 3600 schema: '', 3601 securityLevel: factory.SecurityLevel.S1, 3602 } 3603 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 3604 kvStore = store; 3605 console.info(logTag + " get kvStore success"); 3606 }) 3607 let result = undefined; 3608 let intValue = Number.NaN; 3609 console.info(logTag + "testSyncIntType0800 intValue " + intValue); 3610 function call(data) { 3611 console.info(logTag + "syncComplete: " + data); 3612 kvStore.get(TEST_INT_KEY, (err, data) => { 3613 try { 3614 console.info(logTag + " Sync complete get data,key is " + TEST_INT_KEY); 3615 if (err != null) { 3616 console.info(logTag + " Sync complete get data error,err: " + err); 3617 } else { 3618 console.info(logTag + " Sycn complete get data success,result is: " + data); 3619 result = data; 3620 } 3621 console.info(logTag + " get data finish,result is: " + result); 3622 expect(Number.isNaN(result)).assertTrue(); 3623 kvStore.off("syncComplete", call); 3624 console.info(logTag + "testSyncIntType0800 end"); 3625 done(); 3626 3627 } catch (err) { 3628 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 3629 done(); 3630 } 3631 3632 }) 3633 } 3634 kvStore.on("syncComplete", call); 3635 await remoteHelpers.kvPut(TEST_INT_KEY, intValue, "Number"); 3636 await sleep(1000); 3637 console.info(logTag + "Client sync start"); 3638 kvStore.sync(syncDeviceIds, PUSH_PULL); 3639 }) 3640 3641 /** 3642 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0120 3643 * @tc.name testSyncIntType0900 3644 * @tc.desc Sync int type data 3645 * @tc.level: Level 2 3646 * @tc.type: Functiontion 3647 * @tc.size: MediumTest 3648 */ 3649 it("testSyncIntType0900", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 3650 console.info(logTag + "testSyncIntType0900 start"); 3651 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 3652 await sleep(1000); 3653 const options = { 3654 createIfMissing: true, 3655 encrypt: false, 3656 backup: false, 3657 autoSync: false, 3658 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 3659 schema: '', 3660 securityLevel: factory.SecurityLevel.S1, 3661 } 3662 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 3663 kvStore = store; 3664 console.info(logTag + " get kvStore success"); 3665 }) 3666 let result = undefined; 3667 let intValue = Number.NEGATIVE_INFINITY; 3668 console.info(logTag + "testSyncIntType0900 intValue " + intValue); 3669 function call(data) { 3670 console.info(logTag + "syncComplete: " + data); 3671 kvStore.get(TEST_INT_KEY, (err, data) => { 3672 try { 3673 console.info(logTag + " Sync complete get data,key is " + TEST_INT_KEY); 3674 if (err != null) { 3675 console.info(logTag + " Sync complete get data error,err: " + err); 3676 } else { 3677 console.info(logTag + " Sycn complete get data success,result is: " + data); 3678 result = data; 3679 } 3680 console.info(logTag + " get data finish,result is: " + result); 3681 expect(result).assertEqual(intValue); 3682 kvStore.off("syncComplete", call); 3683 console.info(logTag + "testSyncIntType0900 end"); 3684 done(); 3685 3686 } catch (err) { 3687 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 3688 done(); 3689 } 3690 3691 }) 3692 } 3693 kvStore.on("syncComplete", call); 3694 await remoteHelpers.kvPut(TEST_INT_KEY, intValue, "Number"); 3695 await sleep(1000); 3696 console.info(logTag + "Client sync start"); 3697 kvStore.sync(syncDeviceIds, PULL); 3698 }) 3699 3700 /** 3701 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0260 3702 * @tc.name testSyncIntType1000 3703 * @tc.desc Sync int type data 3704 * @tc.level: Level 2 3705 * @tc.type: Functiontion 3706 * @tc.size: MediumTest 3707 */ 3708 it("testSyncIntType1000", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 3709 console.info(logTag + "testSyncIntType1000 start"); 3710 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 3711 await sleep(1000); 3712 const options = { 3713 createIfMissing: true, 3714 encrypt: false, 3715 backup: false, 3716 autoSync: false, 3717 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 3718 schema: '', 3719 securityLevel: factory.SecurityLevel.S1, 3720 } 3721 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 3722 kvStore = store; 3723 console.info(logTag + " get kvStore success"); 3724 }) 3725 let result = undefined; 3726 let intValue = Number.NEGATIVE_INFINITY; 3727 console.info(logTag + "testSyncIntType1000 intValue " + intValue); 3728 function call(data) { 3729 console.info(logTag + "syncComplete: " + data); 3730 kvStore.get(TEST_INT_KEY, (err, data) => { 3731 try { 3732 console.info(logTag + " Sync complete get data,key is " + TEST_INT_KEY); 3733 if (err != null) { 3734 console.info(logTag + " Sync complete get data error,err: " + err); 3735 } else { 3736 console.info(logTag + " Sycn complete get data success,result is: " + data); 3737 result = data; 3738 } 3739 console.info(logTag + " get data finish,result is: " + result); 3740 expect(result).assertEqual(intValue); 3741 kvStore.off("syncComplete", call); 3742 console.info(logTag + "testSyncIntType1000 end"); 3743 done(); 3744 3745 } catch (err) { 3746 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 3747 done(); 3748 } 3749 3750 }) 3751 } 3752 kvStore.on("syncComplete", call); 3753 await remoteHelpers.kvPut(TEST_INT_KEY, intValue, "Number"); 3754 await sleep(1000); 3755 console.info(logTag + "Client sync start"); 3756 kvStore.sync(syncDeviceIds, PUSH_PULL); 3757 }) 3758 3759 3760 /** 3761 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0130 3762 * @tc.name testSyncIntType1100 3763 * @tc.desc Sync int type data 3764 * @tc.level: Level 2 3765 * @tc.type: Functiontion 3766 * @tc.size: MediumTest 3767 */ 3768 it("testSyncIntType1100", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 3769 console.info(logTag + "testSyncIntType1100 start"); 3770 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 3771 await sleep(1000); 3772 const options = { 3773 createIfMissing: true, 3774 encrypt: false, 3775 backup: false, 3776 autoSync: false, 3777 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 3778 schema: '', 3779 securityLevel: factory.SecurityLevel.S1, 3780 } 3781 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 3782 kvStore = store; 3783 console.info(logTag + " get kvStore success"); 3784 }) 3785 let result = undefined; 3786 let intValue = Number.POSITIVE_INFINITY; 3787 console.info(logTag + "testSyncIntType1100 intValue " + intValue); 3788 function call(data) { 3789 console.info(logTag + "syncComplete: " + data); 3790 kvStore.get(TEST_INT_KEY, (err, data) => { 3791 try { 3792 console.info(logTag + " Sync complete get data,key is " + TEST_INT_KEY); 3793 if (err != null) { 3794 console.info(logTag + " Sync complete get data error,err: " + err); 3795 } else { 3796 console.info(logTag + " Sycn complete get data success,result is: " + data); 3797 result = data; 3798 } 3799 console.info(logTag + " get data finish,result is: " + result); 3800 expect(result).assertEqual(intValue); 3801 kvStore.off("syncComplete", call); 3802 console.info(logTag + "testSyncIntType1100 end"); 3803 done(); 3804 3805 } catch (err) { 3806 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 3807 done(); 3808 } 3809 3810 }) 3811 } 3812 kvStore.on("syncComplete", call); 3813 await remoteHelpers.kvPut(TEST_INT_KEY, intValue, "Number"); 3814 await sleep(1000); 3815 console.info(logTag + "Client sync start"); 3816 kvStore.sync(syncDeviceIds, PULL); 3817 }) 3818 3819 /** 3820 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0270 3821 * @tc.name testSyncIntType1200 3822 * @tc.desc Sync int type data 3823 * @tc.level: Level 2 3824 * @tc.type: Functiontion 3825 * @tc.size: MediumTest 3826 */ 3827 it("testSyncIntType1200", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 3828 console.info(logTag + "testSyncIntType1200 start"); 3829 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 3830 await sleep(1000); 3831 const options = { 3832 createIfMissing: true, 3833 encrypt: false, 3834 backup: false, 3835 autoSync: false, 3836 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 3837 schema: '', 3838 securityLevel: factory.SecurityLevel.S1, 3839 } 3840 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 3841 kvStore = store; 3842 console.info(logTag + " get kvStore success"); 3843 }) 3844 let result = undefined; 3845 let intValue = Number.POSITIVE_INFINITY; 3846 console.info(logTag + "testSyncIntType1200 intValue " + intValue); 3847 function call(data) { 3848 console.info(logTag + "syncComplete: " + data); 3849 kvStore.get(TEST_INT_KEY, (err, data) => { 3850 try { 3851 console.info(logTag + " Sync complete get data,key is " + TEST_INT_KEY); 3852 if (err != null) { 3853 console.info(logTag + " Sync complete get data error,err: " + err); 3854 } else { 3855 console.info(logTag + " Sycn complete get data success,result is: " + data); 3856 result = data; 3857 } 3858 console.info(logTag + " get data finish,result is: " + result); 3859 expect(result).assertEqual(intValue); 3860 kvStore.off("syncComplete", call); 3861 console.info(logTag + "testSyncIntType1200 end"); 3862 done(); 3863 3864 } catch (err) { 3865 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 3866 done(); 3867 } 3868 3869 }) 3870 } 3871 kvStore.on("syncComplete", call); 3872 await remoteHelpers.kvPut(TEST_INT_KEY, intValue, "Number"); 3873 await sleep(1000); 3874 console.info(logTag + "Client sync start"); 3875 kvStore.sync(syncDeviceIds, PUSH_PULL); 3876 }) 3877 3878 /** 3879 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0050 3880 * @tc.name testSyncIntType1300 3881 * @tc.desc Sync int type data MaxValue+1 3882 * @tc.level: Level 2 3883 * @tc.type: Functiontion 3884 * @tc.size: MediumTest 3885 */ 3886 it("testSyncIntType1300", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 3887 console.info(logTag + "testSyncIntType1300 start"); 3888 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 3889 await sleep(1000); 3890 const options = { 3891 createIfMissing: true, 3892 encrypt: false, 3893 backup: false, 3894 autoSync: false, 3895 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 3896 schema: '', 3897 securityLevel: factory.SecurityLevel.S1, 3898 } 3899 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 3900 kvStore = store; 3901 console.info(logTag + " get kvStore success"); 3902 }) 3903 let result = undefined; 3904 let intValue = Number.MAX_VALUE+1; 3905 console.info(logTag + "testSyncIntType1300 intValue " + intValue); 3906 function call(data) { 3907 console.info(logTag + "syncComplete: " + data); 3908 kvStore.get(TEST_INT_KEY, (err, data) => { 3909 try { 3910 console.info(logTag + " Sync complete get data,key is " + TEST_INT_KEY); 3911 if (err != null) { 3912 console.info(logTag + " Sync complete get data error,err: " + err); 3913 } else { 3914 console.info(logTag + " Sycn complete get data success,result is: " + data); 3915 result = data; 3916 } 3917 console.info(logTag + " get data finish,result is: " + result); 3918 expect(result).assertEqual(intValue); 3919 kvStore.off("syncComplete", call); 3920 console.info(logTag + "testSyncIntType1300 end"); 3921 done(); 3922 3923 } catch (err) { 3924 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 3925 done(); 3926 } 3927 3928 }) 3929 } 3930 kvStore.on("syncComplete", call); 3931 await remoteHelpers.kvPut(TEST_INT_KEY, intValue, "Number"); 3932 await sleep(1000); 3933 console.info(logTag + "Client sync start"); 3934 kvStore.sync(syncDeviceIds, PULL); 3935 }) 3936 3937 /** 3938 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0210 3939 * @tc.name testSyncIntType1400 3940 * @tc.desc Sync int type data 3941 * @tc.level: Level 2 3942 * @tc.type: Functiontion 3943 * @tc.size: MediumTest 3944 */ 3945 it("testSyncIntType1400", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 3946 console.info(logTag + "testSyncIntType1400 start"); 3947 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 3948 await sleep(1000); 3949 const options = { 3950 createIfMissing: true, 3951 encrypt: false, 3952 backup: false, 3953 autoSync: false, 3954 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 3955 schema: '', 3956 securityLevel: factory.SecurityLevel.S1, 3957 } 3958 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 3959 kvStore = store; 3960 console.info(logTag + " get kvStore success"); 3961 }) 3962 let result = undefined; 3963 let intValue = Number.MIN_VALUE-1; 3964 console.info(logTag + "testSyncIntType1400 intValue " + intValue); 3965 function call(data) { 3966 console.info(logTag + "syncComplete: " + data); 3967 kvStore.get(TEST_INT_KEY, (err, data) => { 3968 try { 3969 console.info(logTag + "testSyncIntType1400 Sync complete get data,key is " + TEST_INT_KEY); 3970 if (err != null) { 3971 console.info(logTag + "testSyncIntType1400 Sync complete get data error,err: " + err); 3972 } else { 3973 console.info(logTag + "testSyncIntType1400 Sycn complete get data success,result is: " + data); 3974 result = data; 3975 } 3976 console.info(logTag + "testSyncIntType1400 get data finish,result is: " + result); 3977 expect(result).assertEqual(intValue); 3978 kvStore.off("syncComplete", call); 3979 console.info(logTag + "testSyncIntType1400 end"); 3980 done(); 3981 3982 } catch (err) { 3983 console.error('testSyncIntType1400 catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 3984 done(); 3985 } 3986 3987 }) 3988 } 3989 kvStore.on("syncComplete", call); 3990 await remoteHelpers.kvPut(TEST_INT_KEY, intValue, "Number"); 3991 await sleep(1000); 3992 console.info(logTag + "Client sync start"); 3993 kvStore.sync(syncDeviceIds, PULL); 3994 }) 3995 3996 /** 3997 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0010 3998 * @tc.name testSyncFloatType0100 3999 * @tc.desc Sync float type data 4000 * @tc.level: Level 2 4001 * @tc.type: Functiontion 4002 * @tc.size: MediumTest 4003 */ 4004 it("testSyncFloatType0100", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 4005 console.info(logTag + "testSyncFloatType0100 start"); 4006 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 4007 await sleep(1000); 4008 const options = { 4009 createIfMissing: true, 4010 encrypt: false, 4011 backup: false, 4012 autoSync: false, 4013 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 4014 schema: '', 4015 securityLevel: factory.SecurityLevel.S1, 4016 } 4017 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 4018 kvStore = store; 4019 console.info(logTag + " get kvStore success"); 4020 }) 4021 let result = undefined; 4022 function call(data) { 4023 console.info(logTag + "syncComplete: " + data); 4024 kvStore.get(TEST_FLOAT_KEY, (err, data) => { 4025 try { 4026 console.info(logTag + " Sync complete get data,key is " + TEST_FLOAT_KEY) 4027 if (err != null) { 4028 console.info(logTag + " Sync complete get data error,err: " + err); 4029 } else { 4030 console.info(logTag + " Sycn complete get data success,result is: " + data); 4031 result = data; 4032 } 4033 expect(result).assertEqual(TEST_FLOAT_VALUE); 4034 kvStore.off("syncComplete", call); 4035 console.info(logTag + "testSyncFloatType0100 end"); 4036 done(); 4037 4038 } catch (err) { 4039 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 4040 done(); 4041 } 4042 4043 }) 4044 } 4045 kvStore.on("syncComplete", call); 4046 await remoteHelpers.kvPut(TEST_FLOAT_KEY, TEST_FLOAT_VALUE, "Number") 4047 await sleep(1000); 4048 console.info(logTag + "Client sync start"); 4049 kvStore.sync(syncDeviceIds, PULL); 4050 }) 4051 4052 /** 4053 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0160 4054 * @tc.name testSyncFloatType0200 4055 * @tc.desc Sync float type data 4056 * @tc.level: Level 2 4057 * @tc.type: Functiontion 4058 * @tc.size: MediumTest 4059 */ 4060 it("testSyncFloatType0200", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 4061 console.info(logTag + "testSyncFloatType0200 start"); 4062 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 4063 await sleep(1000); 4064 const options = { 4065 createIfMissing: true, 4066 encrypt: false, 4067 backup: false, 4068 autoSync: false, 4069 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 4070 schema: '', 4071 securityLevel: factory.SecurityLevel.S1, 4072 } 4073 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 4074 kvStore = store; 4075 console.info(logTag + " get kvStore success"); 4076 }) 4077 let result = undefined; 4078 function call(data) { 4079 console.info(logTag + "syncComplete: " + data); 4080 kvStore.get(TEST_FLOAT_KEY, (err, data) => { 4081 try { 4082 console.info(logTag + " Sync complete get data,key is " + TEST_FLOAT_KEY) 4083 if (err != null) { 4084 console.info(logTag + " Sync complete get data error,err: " + err); 4085 } else { 4086 console.info(logTag + " Sycn complete get data success,result is: " + data); 4087 result = data; 4088 } 4089 console.info(logTag + " get data finish,result is: " + result); 4090 expect(result).assertEqual(TEST_FLOAT_VALUE); 4091 kvStore.off("syncComplete", call); 4092 console.info(logTag + "testSyncFloatType0200 end"); 4093 done(); 4094 4095 } catch (err) { 4096 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 4097 done(); 4098 } 4099 4100 }) 4101 } 4102 kvStore.on("syncComplete", call); 4103 await remoteHelpers.kvPut(TEST_FLOAT_KEY, TEST_FLOAT_VALUE, "Number") 4104 await sleep(1000); 4105 console.info(logTag + "Client sync start"); 4106 kvStore.sync(syncDeviceIds, PUSH_PULL); 4107 }) 4108 4109 /** 4110 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0290 4111 * @tc.name testSyncMultipleData0100 4112 * @tc.desc Synchronize multiple pieces of data 4113 * @tc.level: Level 2 4114 * @tc.type: Functiontion 4115 * @tc.size: MediumTest 4116 */ 4117 it("testSyncMultipleData0100", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 4118 console.info(logTag + "testSyncMultipleData0100 start"); 4119 let value1 = undefined; 4120 let value2 = undefined; 4121 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 4122 await sleep(1000); 4123 const options = { 4124 createIfMissing: true, 4125 encrypt: false, 4126 backup: false, 4127 autoSync: false, 4128 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 4129 schema: '', 4130 securityLevel: factory.SecurityLevel.S1, 4131 } 4132 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 4133 kvStore = store; 4134 console.info(logTag + " get kvStore success"); 4135 }) 4136 4137 function call(data) { 4138 console.info(logTag + "syncComplete: " + data); 4139 kvStore.get(TEST_STRING_KEY, (err, data) => { 4140 console.info(logTag + " Sync complete get data,key1 is " + TEST_STRING_KEY) 4141 if (err != null) { 4142 console.info(logTag + " Sync complete get data1 error,err: " + err) 4143 } else { 4144 console.info(logTag + " Sycn complete get data1 success,result1 is: " + data) 4145 value1 = data 4146 } 4147 kvStore.get(TEST_FLOAT_KEY, (err, data) => { 4148 try { 4149 console.info(logTag + " Sync complete get data,key2 is " + TEST_FLOAT_KEY) 4150 if (err != null) { 4151 console.info(logTag + " Sync complete get data2 error,err: " + err) 4152 } else { 4153 console.info(logTag + " Sycn complete get data2 success,result2 is: " + data) 4154 value2 = data 4155 } 4156 console.info(logTag + " get data finish") 4157 expect(value1).assertEqual(TEST_STRING_VALUE) 4158 expect(value2).assertEqual(TEST_FLOAT_VALUE); 4159 kvStore.off("syncComplete", call); 4160 console.info(logTag + "testSyncMultipleData0100 end"); 4161 done(); 4162 4163 } catch (err) { 4164 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 4165 done(); 4166 } 4167 4168 }) 4169 }) 4170 4171 } 4172 kvStore.on("syncComplete", call); 4173 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 4174 await remoteHelpers.kvPut(TEST_FLOAT_KEY, TEST_FLOAT_VALUE, "Number") 4175 await sleep(2000); 4176 console.info(logTag + "Client sync start"); 4177 kvStore.sync(syncDeviceIds, PULL); 4178 }) 4179 4180 /** 4181 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0150 4182 * @tc.name testSyncMultipleData0200 4183 * @tc.desc Synchronize multiple pieces of data 4184 * @tc.level: Level 2 4185 * @tc.type: Functiontion 4186 * @tc.size: MediumTest 4187 */ 4188 it("testSyncMultipleData0200", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 4189 console.info(logTag + "testSyncMultipleData0200 start"); 4190 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 4191 await sleep(1000); 4192 const options = { 4193 createIfMissing: true, 4194 encrypt: false, 4195 backup: false, 4196 autoSync: false, 4197 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 4198 schema: '', 4199 securityLevel: factory.SecurityLevel.S1, 4200 } 4201 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 4202 kvStore = store; 4203 console.info(logTag + " get kvStore success"); 4204 }) 4205 4206 let value1 = undefined; 4207 let value2 = undefined; 4208 function call(data) { 4209 console.info(logTag + "syncComplete: " + data); 4210 kvStore.get(TEST_STRING_KEY, (err, data) => { 4211 console.info(logTag + " Sync complete get data,key1 is " + TEST_STRING_KEY) 4212 if (err != null) { 4213 console.info(logTag + " Sync complete get data1 error,err: " + err) 4214 } else { 4215 console.info(logTag + " Sycn complete get data1 success,result1 is: " + data) 4216 value1 = data 4217 } 4218 kvStore.get(TEST_FLOAT_KEY, (err, data) => { 4219 try { 4220 console.info(logTag + " Sync complete get data,key2 is " + TEST_FLOAT_KEY) 4221 if (err != null) { 4222 console.info(logTag + " Sync complete get data2 error,err: " + err) 4223 } else { 4224 console.info(logTag + " Sycn complete get data2 success,result2 is: " + data) 4225 value2 = data 4226 } 4227 console.info(logTag + " get data finish") 4228 expect(value1).assertEqual(TEST_STRING_VALUE) 4229 expect(value2).assertEqual(TEST_FLOAT_VALUE); 4230 kvStore.off("syncComplete", call); 4231 console.info(logTag + "testSyncMultipleData0200 end"); 4232 done(); 4233 4234 } catch (err) { 4235 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 4236 done(); 4237 } 4238 4239 }) 4240 }) 4241 } 4242 kvStore.on("syncComplete", call); 4243 await remoteHelpers.kvPut(TEST_STRING_KEY, TEST_STRING_VALUE, "String"); 4244 await remoteHelpers.kvPut(TEST_FLOAT_KEY, TEST_FLOAT_VALUE, "Number") 4245 await sleep(2000); 4246 console.info(logTag + "Client sync start"); 4247 kvStore.sync(syncDeviceIds, PUSH_PULL); 4248 }) 4249 4250 /** 4251 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0300 4252 * @tc.name testSyncDeleteSync0100 4253 * @tc.desc Synchronize multiple pieces of data 4254 * @tc.level: Level 2 4255 * @tc.type: Functiontion 4256 * @tc.size: MediumTest 4257 */ 4258 it("testSyncDeleteSync0100", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 4259 console.info(logTag + "testSyncDeleteSync0100 start"); 4260 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 4261 await sleep(1000); 4262 const options = { 4263 createIfMissing: true, 4264 encrypt: false, 4265 backup: false, 4266 autoSync: false, 4267 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 4268 schema: '', 4269 securityLevel: factory.SecurityLevel.S1, 4270 } 4271 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 4272 kvStore = store; 4273 console.info(logTag + " get kvStore success"); 4274 }) 4275 await kvStore.put("key1", "value1"); 4276 let result = undefined; 4277 function call(data) { 4278 console.info(logTag + "syncComplete: " + data); 4279 kvStore.get("key1", (err, data) => { 4280 try { 4281 console.info(logTag + " Sync complete get data,key is key1"); 4282 if (err != null) { 4283 console.info(logTag + " Sync complete get data error,err: " + err); 4284 } else { 4285 console.info(logTag + " Sycn complete get data success,result is: " + data); 4286 result = data; 4287 } 4288 console.info(logTag + " get data finish,result is: " + result); 4289 expect(result == undefined).assertTrue(); 4290 kvStore.off("syncComplete", call); 4291 console.info(logTag + "testSyncDeleteSync0100 end"); 4292 done(); 4293 4294 } catch (err) { 4295 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 4296 done(); 4297 } 4298 4299 }) 4300 } 4301 kvStore.sync(syncDeviceIds, PUSH); 4302 await sleep(3000); 4303 4304 kvStore.on("syncComplete", call); 4305 await remoteHelpers.kvDelete("key1"); 4306 kvStore.on('dataChange', factory.SubscribeType.SUBSCRIBE_TYPE_LOCAL, function (data, err) { 4307 console.info(logTag + "local device data has changed,key is: " + data.deleteEntries.key); 4308 }) 4309 await sleep(2000); 4310 console.info(logTag + "Client sync start"); 4311 kvStore.sync(syncDeviceIds, PULL); 4312 await sleep(600); 4313 4314 }) 4315 4316 /** 4317 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0170 4318 * @tc.name testSyncDeleteSync0200 4319 * @tc.desc Synchronize multiple pieces of data 4320 * @tc.level: Level 2 4321 * @tc.type: Functiontion 4322 * @tc.size: MediumTest 4323 */ 4324 it("testSyncDeleteSync0200", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 4325 console.info(logTag + "testSyncDeleteSync0200 start"); 4326 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 4327 await sleep(1000); 4328 const options = { 4329 createIfMissing: true, 4330 encrypt: false, 4331 backup: false, 4332 autoSync: false, 4333 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 4334 schema: '', 4335 securityLevel: factory.SecurityLevel.S1, 4336 } 4337 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 4338 kvStore = store; 4339 console.info(logTag + " get kvStore success"); 4340 }) 4341 await kvStore.put("key1", "value1"); 4342 let result = undefined; 4343 function call(data) { 4344 console.info(logTag + "syncComplete: " + data); 4345 kvStore.get("key1", (err, data) => { 4346 try { 4347 console.info(logTag + " Sync complete get data,key is key1"); 4348 if (err != null) { 4349 console.info(logTag + " Sync complete get data error,err: " + err); 4350 } else { 4351 console.info(logTag + " Sycn complete get data success,result is: " + data); 4352 result = data; 4353 } 4354 console.info(logTag + " get data finish,result is: " + result); 4355 expect(result == undefined).assertTrue(); 4356 kvStore.off("syncComplete", call); 4357 console.info(logTag + "testSyncDeleteSync0200 end"); 4358 done(); 4359 4360 } catch (err) { 4361 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 4362 done(); 4363 } 4364 4365 }) 4366 } 4367 kvStore.sync(syncDeviceIds, PUSH_PULL); 4368 await sleep(3000); 4369 kvStore.on("syncComplete", call); 4370 await remoteHelpers.kvDelete("key1"); 4371 kvStore.on('dataChange', factory.SubscribeType.SUBSCRIBE_TYPE_LOCAL, function (data, err) { 4372 console.info(logTag + "local device data has changed,key is: " + data.deleteEntries.key); 4373 }) 4374 await sleep(2000); 4375 console.info(logTag + "Client sync start"); 4376 kvStore.sync(syncDeviceIds, PUSH_PULL); 4377 await sleep(600); 4378 4379 }) 4380 4381 /** 4382 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0230 4383 * @tc.name testSyncModifySync0100 4384 * @tc.desc Synchronize multiple pieces of data 4385 * @tc.level: Level 2 4386 * @tc.type: Functiontion 4387 * @tc.size: MediumTest 4388 */ 4389 it("testSyncModifySync0100", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 4390 console.info(logTag + "testSyncModifySync0100 start"); 4391 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 4392 await sleep(1000); 4393 const options = { 4394 createIfMissing: true, 4395 encrypt: false, 4396 backup: false, 4397 autoSync: false, 4398 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 4399 schema: '', 4400 securityLevel: factory.SecurityLevel.S1, 4401 } 4402 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 4403 kvStore = store; 4404 console.info(logTag + " get kvStore success"); 4405 }) 4406 await kvStore.put("key1", "value1"); 4407 let result = undefined; 4408 function call(data) { 4409 console.info(logTag + "syncComplete: " + data); 4410 kvStore.get("key1", (err, data) => { 4411 try { 4412 console.info(logTag + " Sync complete get data,key is key1"); 4413 if (err != null) { 4414 console.info(logTag + " Sync complete get data error,err: " + err); 4415 } else { 4416 console.info(logTag + " Sycn complete get data success,result is: " + data); 4417 result = data; 4418 } 4419 console.info(logTag + " get data finish,result is: " + result); 4420 expect(result).assertEqual("value2"); 4421 kvStore.off("syncComplete", call); 4422 console.info(logTag + "testSyncModifySync0100 end"); 4423 done(); 4424 4425 } catch (err) { 4426 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 4427 done(); 4428 } 4429 4430 }) 4431 } 4432 kvStore.sync(syncDeviceIds, PUSH); 4433 await sleep(3000); 4434 kvStore.on("syncComplete", call); 4435 await remoteHelpers.kvPut("key1", "value2", "String"); 4436 kvStore.on('dataChange', factory.SubscribeType.SUBSCRIBE_TYPE_LOCAL, function (data, err) { 4437 console.info(logTag + "local device data has changed,key is: " + data.updateEntries.key); 4438 }) 4439 await sleep(2000); 4440 console.info(logTag + "Client sync start"); 4441 kvStore.sync(syncDeviceIds, PULL); 4442 await sleep(600); 4443 }) 4444 4445 /** 4446 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_0090 4447 * @tc.name testSyncModifySync0200 4448 * @tc.desc Synchronize multiple pieces of data 4449 * @tc.level: Level 2 4450 * @tc.type: Functiontion 4451 * @tc.size: MediumTest 4452 */ 4453 it("testSyncModifySync0200", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 4454 console.info(logTag + "testSyncModifySync0200 start"); 4455 await remoteHelpers.getKvStore(TEST_STORE_ID, "S1", false); 4456 await sleep(1000); 4457 const options = { 4458 createIfMissing: true, 4459 encrypt: false, 4460 backup: false, 4461 autoSync: false, 4462 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 4463 schema: '', 4464 securityLevel: factory.SecurityLevel.S1, 4465 } 4466 await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { 4467 kvStore = store; 4468 console.info(logTag + " get kvStore success"); 4469 }) 4470 await kvStore.put("key1", "value1"); 4471 let result = undefined; 4472 function call(data) { 4473 console.info(logTag + "syncComplete: " + data); 4474 kvStore.get("key1", (err, data) => { 4475 try { 4476 console.info(logTag + " Sync complete get data,key is key1"); 4477 if (err != null) { 4478 console.info(logTag + " Sync complete get data error,err: " + err); 4479 } else { 4480 console.info(logTag + " Sycn complete get data success,result is: " + data); 4481 result = data; 4482 } 4483 console.info(logTag + " get data finish,result is: " + result); 4484 expect(result).assertEqual("value2"); 4485 kvStore.off("syncComplete", call); 4486 console.info(logTag + "testSyncModifySync0200 end"); 4487 done(); 4488 4489 } catch (err) { 4490 console.error('catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 4491 done(); 4492 } 4493 }) 4494 } 4495 kvStore.sync(syncDeviceIds, PUSH_PULL); 4496 await sleep(3000); 4497 kvStore.on("syncComplete", call); 4498 await remoteHelpers.kvPut("key1", "value2", "String"); 4499 kvStore.on('dataChange', factory.SubscribeType.SUBSCRIBE_TYPE_LOCAL, function (data, err) { 4500 console.info(logTag + "local device data has changed,key is: " + data.updateEntries.key); 4501 expect(data.updateEntries.key).assertEqual("key1"); 4502 }) 4503 await sleep(2000); 4504 console.info(logTag + "Client sync start"); 4505 kvStore.sync(syncDeviceIds, PUSH_PULL); 4506 await sleep(600); 4507 }) 4508 4509 4510 /** 4511 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_SYNCSCHEMA_0100 4512 * @tc.name testSyncSchema0100 4513 * @tc.desc Server kvStore security is S1,client kvStore security is S1, prefixKey("test_"), PULL 4514 * @tc.level: Level 2 4515 * @tc.type: Functiontion 4516 * @tc.size: MediumTest 4517 */ 4518 it("testSyncSchema0100", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 4519 console.info(logTag + "testSyncSchema0100 start"); 4520 4521 let options = { 4522 createIfMissing: true, 4523 encrypt: false, 4524 backup: false, 4525 autoSync: false, 4526 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 4527 schema: {}, 4528 securityLevel: factory.SecurityLevel.S1, 4529 } 4530 4531 let name = new factory.FieldNode('name'); 4532 name.type = factory.ValueType.INTEGER; 4533 name.nullable = false; 4534 name.default = '0'; 4535 4536 let schema = new factory.Schema(); 4537 schema.root.appendChild(name); 4538 schema.indexes = ['$.name']; 4539 schema.mode = 1; 4540 4541 let TEST_SCHEMA_STORE_ID = "SchemaStoreId_0100"; 4542 let TEST_SCHEMA_STORE_ID_PREF = "SchemaStoreId_"; 4543 let schemaIdPref = TEST_SCHEMA_STORE_ID.substring(0, 14); 4544 console.info(logTag + "testSyncSchema0100 schemaIdPref=" + schemaIdPref); 4545 if (schemaIdPref == TEST_SCHEMA_STORE_ID_PREF) { 4546 options.schema = schema; 4547 } 4548 console.info(logTag + "testSyncSchema0100 options.schema=" + options.schema); 4549 4550 await remoteHelpers.getKvStore(TEST_SCHEMA_STORE_ID, "S1", false); 4551 await sleep(1000); 4552 4553 await kvManager.getKVStore(TEST_SCHEMA_STORE_ID, options).then((store) => { 4554 kvStore = store; 4555 console.info(logTag + "testSyncSchema0100 getKVStore success. kvStore=" + kvStore); 4556 expect(store != null).assertTrue(); 4557 }).catch((err) => { 4558 console.info(logTag + 'testSyncSchema0100 getKVStore fail. error= ' + error.code + error.message); 4559 expect(null).assertFail(); 4560 }); 4561 4562 let schemaKey = "test_key_1"; 4563 let schemaValue = '{"name":1}'; 4564 4565 let result = undefined; 4566 await remoteHelpers.kvPut(schemaKey, schemaValue, "String"); 4567 await sleep(1000); 4568 console.info(logTag + "testSyncSchema0100 Client sync start"); 4569 4570 const query = new factory.Query(); 4571 query.prefixKey("test_"); 4572 kvStore.sync(syncDeviceIds, query, PULL, 1000); 4573 await sleep(5000); 4574 4575 await kvStore.get(schemaKey, (err, data) => { 4576 try { 4577 console.info(logTag + "testSyncSchema0100 get data,key is " + schemaKey); 4578 if (err != null) { 4579 console.info(logTag + "testSyncSchema0100 get data error,err: " + err); 4580 } else { 4581 console.info(logTag + "testSyncSchema0100 get data success,result is: " + data); 4582 result = data; 4583 } 4584 console.info(logTag + "testSyncSchema0100 get data finish,result is: " + result); 4585 expect(result).assertEqual(schemaValue); 4586 console.info(logTag + "testSyncSchema0100 end"); 4587 } catch (err) { 4588 console.error('testSyncSchema0100 catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 4589 } 4590 4591 }) 4592 await sleep(1000); 4593 4594 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_SCHEMA_STORE_ID, kvStore, async function () { 4595 console.info(logTag + 'testSyncSchema0100 CLIENT closeKVStore success'); 4596 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_SCHEMA_STORE_ID, function () { 4597 console.info(logTag + 'testSyncSchema0100 CLIENT deleteKVStore success'); 4598 }); 4599 }); 4600 await remoteHelpers.closeKvStore(TEST_SCHEMA_STORE_ID).then(async (ret) => { 4601 console.info(logTag + "testSyncSchema0100 REMOTE close server kvStore success: " + ret); 4602 }) 4603 await sleep(2000); 4604 kvStore = null; 4605 console.info(logTag + '-----------------testSyncSchema0100 end-----------------'); 4606 done(); 4607 }) 4608 4609 /** 4610 * @tc.number SUB_DistributedData_KVStore_DistributedSync_SDK_DifferentGradeSyncTest_SYNCSCHEMA_0200 4611 * @tc.name testSyncSchema0200 4612 * @tc.desc Server kvStore security is S1,client kvStore security is S1, prefixKey("test_"), PUSH_PULL 4613 * @tc.level: Level 2 4614 * @tc.type: Functiontion 4615 * @tc.size: MediumTest 4616 */ 4617 it("testSyncSchema0200", TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async function (done) { 4618 console.info(logTag + "testSyncSchema0200 start"); 4619 4620 let options = { 4621 createIfMissing: true, 4622 encrypt: false, 4623 backup: false, 4624 autoSync: false, 4625 kvStoreType: factory.KVStoreType.SINGLE_VERSION, 4626 schema: {}, 4627 securityLevel: factory.SecurityLevel.S1, 4628 } 4629 4630 let name = new factory.FieldNode('name'); 4631 name.type = factory.ValueType.INTEGER; 4632 name.nullable = false; 4633 name.default = '0'; 4634 4635 let schema = new factory.Schema(); 4636 schema.root.appendChild(name); 4637 schema.indexes = ['$.name']; 4638 schema.mode = 1; 4639 4640 let TEST_SCHEMA_STORE_ID = "SchemaStoreId_0200"; 4641 let TEST_SCHEMA_STORE_ID_PREF = "SchemaStoreId_"; 4642 let schemaIdPref = TEST_SCHEMA_STORE_ID.substring(0, 14); 4643 console.info(logTag + "testSyncSchema0200 schemaIdPref=" + schemaIdPref); 4644 if (schemaIdPref == TEST_SCHEMA_STORE_ID_PREF) { 4645 options.schema = schema; 4646 } 4647 console.info(logTag + "testSyncSchema0200 options.schema=" + options.schema); 4648 4649 await remoteHelpers.getKvStore(TEST_SCHEMA_STORE_ID, "S1", false); 4650 await sleep(1000); 4651 4652 await kvManager.getKVStore(TEST_SCHEMA_STORE_ID, options).then((store) => { 4653 kvStore = store; 4654 console.info(logTag + "testSyncSchema0200 getKVStore success. kvStore=" + kvStore); 4655 expect(store != null).assertTrue(); 4656 }).catch((err) => { 4657 console.info(logTag + 'testSyncSchema0200 getKVStore fail. error= ' + error.code + error.message); 4658 expect(null).assertFail(); 4659 }); 4660 4661 let schemaKey = "test_key_1"; 4662 let schemaValue = '{"name":1}'; 4663 4664 let result = undefined; 4665 await remoteHelpers.kvPut(schemaKey, schemaValue, "String"); 4666 await sleep(1000); 4667 console.info(logTag + "testSyncSchema0200 Client sync start"); 4668 4669 const query = new factory.Query(); 4670 query.prefixKey("test_"); 4671 kvStore.sync(syncDeviceIds, query, PUSH_PULL, 1000); 4672 await sleep(5000); 4673 4674 await kvStore.get(schemaKey, (err, data) => { 4675 try { 4676 console.info(logTag + "testSyncSchema0200 get data,key is " + schemaKey); 4677 if (err != null) { 4678 console.info(logTag + "testSyncSchema0200 get data error,err: " + err); 4679 } else { 4680 console.info(logTag + "testSyncSchema0200 get data success,result is: " + data); 4681 result = data; 4682 } 4683 console.info(logTag + "testSyncSchema0200 get data finish,result is: " + result); 4684 expect(result).assertEqual(schemaValue); 4685 console.info(logTag + "testSyncSchema0200 end"); 4686 } catch (err) { 4687 console.error('testSyncSchema0200 catch get err:' + `, error code is ${err.code}, message is ${err.message}`); 4688 } 4689 }) 4690 await sleep(1000); 4691 4692 await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_SCHEMA_STORE_ID, kvStore, async function () { 4693 console.info(logTag + 'testSyncSchema0200 CLIENT closeKVStore success'); 4694 await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_SCHEMA_STORE_ID, function () { 4695 console.info(logTag + 'testSyncSchema0200 CLIENT deleteKVStore success'); 4696 }); 4697 }); 4698 await remoteHelpers.closeKvStore(TEST_SCHEMA_STORE_ID).then(async (ret) => { 4699 console.info(logTag + "testSyncSchema0200 REMOTE close server kvStore success: " + ret); 4700 }) 4701 await sleep(2000); 4702 kvStore = null; 4703 console.info(logTag + '-----------------testSyncSchema0200 end-----------------'); 4704 done(); 4705 }) 4706 4707 }) 4708}