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