diff --git a/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/DeviceKvStoreCallbackJsunit.test.js b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/DeviceKvStoreCallbackJsunit.test.js new file mode 100644 index 0000000000000000000000000000000000000000..62da9477f564a2febf67cf80b49acf25e2e534dc --- /dev/null +++ b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/DeviceKvStoreCallbackJsunit.test.js @@ -0,0 +1,1895 @@ +/* +* Copyright (c) 2021 Huawei Device Co., Ltd. +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' +import factory from '@ohos.data.distributedData' + +const KEY_TEST_INT_ELEMENT = 'key_test_int_2'; +const KEY_TEST_FLOAT_ELEMENT = 'key_test_float_2'; +const KEY_TEST_BOOLEAN_ELEMENT = 'key_test_boolean_2'; +const KEY_TEST_STRING_ELEMENT = 'key_test_string_2'; +const KEY_TEST_SYNC_ELEMENT = 'key_test_sync'; + +const VALUE_TEST_INT_ELEMENT = 1234; +const VALUE_TEST_FLOAT_ELEMENT = 4321.12; +const VALUE_TEST_BOOLEAN_ELEMENT = true; +const VALUE_TEST_STRING_ELEMENT = 'value-string-002'; +const VALUE_TEST_SYNC_ELEMENT = 'value-string-001'; + +const TEST_BUNDLE_NAME = 'ohos.acts.distributeddatamgr'; +const TEST_STORE_ID = 'storeId'; +var kvManager = null; +var kvStore = null; +var localDeviceId = null; + +function sleep(ms) { + return new Promise(resolve => setTimeout(resolve, ms)); +} + +function putBatchString(len, prefix) { + let entries = []; + for (var i = 0; i < len; i++) { + var entry = { + key : prefix + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + return entries; +} + +describe('DeviceKvStoreCallbackTest', function () { + const config = { + bundleName : TEST_BUNDLE_NAME, + userInfo : { + userId : '0', + userType : factory.UserType.SAME_USER_ID + } + } + + const options = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.DEVICE_COLLABORATION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + + beforeAll(async function (done) { + console.log('beforeAll config:'+ JSON.stringify(config)); + await factory.createKVManager(config).then((manager) => { + kvManager = manager; + console.log('beforeAll createKVManager success'); + }).catch((err) => { + console.log('beforeAll createKVManager err ' + err); + }); + // get localDeviceId - put, get deviceId on dataChange().. + await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { + kvStore = store; + console.log('beforeAll getKVStore success'); + }).catch((err) => { + console.log('beforeAll getKVStore err ' + err); + }); + kvStore.on('dataChange', 0, function (data) { + console.log('beforeAll on ' + JSON.stringify(data)) + localDeviceId = data.deviceId; + expect(localDeviceId != null).assertTrue(); + }); + await kvStore.put("getDeviceId", "byPut"); + console.log('beforeAll end'); + done(); + }) + + afterAll(async function (done) { + console.log('afterAll'); + kvManager = null; + kvStore = null; + done(); + }) + + beforeEach(async function (done) { + console.log('beforeEach' + JSON.stringify(options)); + await kvManager.getKVStore(TEST_STORE_ID, options, function (err, store) { + kvStore = store; + console.log('beforeEach getKVStore success'); + done(); + }); + }) + + afterEach(async function (done) { + console.log('afterEach'); + await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, kvStore, async function (err, data) { + console.log('afterEach closeKVStore success'); + await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, function (err, data) { + console.log('afterEach deleteKVStore success'); + done(); + }); + }); + }) + + it('testDeviceKvStorePutString101', 0, async function (done) { + console.log('testDeviceKvStorePutString101'); + try { + await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStorePutString101 put success'); + } else { + console.log('testDeviceKvStorePutString101 put fail' + err); + expect(null).assertFail(); + } + done(); + }); + }catch (e) { + console.log('testDeviceKvStorePutString101 put e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorePutString102', 0, async function (done) { + console.log('testDeviceKvStorePutString102'); + try { + var str = ''; + for (var i = 0 ; i < 4095; i++) { + str += 'x'; + } + await kvStore.put(KEY_TEST_STRING_ELEMENT+'102', str, async function (err,data) { + console.log('testDeviceKvStorePutString102 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_STRING_ELEMENT+'102', function (err,data) { + console.log('testDeviceKvStorePutString102 get success'); + expect(str == data).assertTrue(); + done(); + }); + }); + }catch (e) { + console.log('testDeviceKvStorePutString102 put e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreGetString101', 0, async function (done) { + console.log('testDeviceKvStoreGetString101'); + try{ + await kvStore.get(localDeviceId, KEY_TEST_STRING_ELEMENT, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreGetString101 get success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStoreGetString101 get fail'); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreGetString101 get e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreGetString102', 0, async function (done) { + console.log('testDeviceKvStoreGetString102'); + try{ + await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, async function (err,data) { + console.log('testDeviceKvStoreGetString102 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_STRING_ELEMENT, function (err,data) { + console.log('testDeviceKvStoreGetString102 get success'); + expect((err == undefined) && (VALUE_TEST_STRING_ELEMENT == data)).assertTrue(); + done(); + }); + }) + }catch(e) { + console.log('testDeviceKvStoreGetString102 get e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorePutInt101', 0, async function (done) { + console.log('testDeviceKvStorePutInt101'); + try { + await kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT, async function (err,data) { + console.log('testDeviceKvStorePutInt101 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_INT_ELEMENT, function (err,data) { + console.log('testDeviceKvStorePutInt101 get success'); + expect((err == undefined) && (VALUE_TEST_INT_ELEMENT == data)).assertTrue(); + done(); + }) + }); + }catch(e) { + console.log('testDeviceKvStorePutInt101 put e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorePutInt102', 0, async function (done) { + console.log('testDeviceKvStorePutInt102'); + try { + var intValue = 987654321; + await kvStore.put(KEY_TEST_INT_ELEMENT, intValue, async function (err,data) { + console.log('testDeviceKvStorePutInt102 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_INT_ELEMENT, function (err,data) { + console.log('testDeviceKvStorePutInt102 get success'); + expect((err == undefined) && (intValue == data)).assertTrue(); + done(); + }) + }); + }catch(e) { + console.log('testDeviceKvStorePutInt102 put e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorePutInt103', 0, async function (done) { + console.log('testDeviceKvStorePutInt103'); + try { + var intValue = Number.MIN_VALUE; + await kvStore.put(KEY_TEST_INT_ELEMENT, intValue, async function (err,data) { + console.log('testDeviceKvStorePutInt103 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_INT_ELEMENT, function (err,data) { + console.log('testDeviceKvStorePutInt103 get success'); + expect((err == undefined) && (intValue == data)).assertTrue(); + done(); + }) + }); + }catch(e) { + console.log('testDeviceKvStorePutInt103 put e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorePutInt104', 0, async function (done) { + console.log('testDeviceKvStorePutInt104'); + try { + var intValue = Number.MAX_VALUE; + await kvStore.put(KEY_TEST_INT_ELEMENT, intValue, async function (err,data) { + console.log('testDeviceKvStorePutInt104 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_INT_ELEMENT, function (err,data) { + console.log('testDeviceKvStorePutInt104 get success'); + expect((err == undefined) && (intValue == data)).assertTrue(); + done(); + }) + }); + }catch(e) { + console.log('testDeviceKvStorePutInt104 put e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreGetInt101', 0, async function (done) { + console.log('testDeviceKvStoreGetInt101'); + try { + await kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT, async function (err,data) { + console.log('testDeviceKvStoreGetInt101 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_INT_ELEMENT, function (err,data) { + console.log('testDeviceKvStoreGetInt101 get success'); + expect((err == undefined) && (VALUE_TEST_INT_ELEMENT == data)).assertTrue(); + done(); + }) + }); + }catch(e) { + console.log('testDeviceKvStoreGetInt101 put e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreGetInt102', 0, async function (done) { + console.log('testDeviceKvStoreGetInt102'); + try { + await kvStore.get(localDeviceId, KEY_TEST_INT_ELEMENT, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreGetInt102 get success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStoreGetInt102 get fail'); + } + done(); + }) + }catch(e) { + console.log('testDeviceKvStoreGetInt102 put e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorePutBool101', 0, async function (done) { + console.log('testDeviceKvStorePutBool101'); + try { + await kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, VALUE_TEST_BOOLEAN_ELEMENT, function (err,data) { + console.log('testDeviceKvStorePutBool101 put success'); + expect(err == undefined).assertTrue(); + done(); + }); + }catch(e) { + console.log('testDeviceKvStorePutBool101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreGetBool101', 0, async function (done) { + console.log('testDeviceKvStoreGetBool101'); + try { + await kvStore.get(localDeviceId, KEY_TEST_BOOLEAN_ELEMENT, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreGetBool101 get success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStoreGetBool101 get fail' + err); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreGetBool101 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreGetBool102', 0, async function (done) { + console.log('testDeviceKvStoreGetBool102'); + try { + await kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, VALUE_TEST_BOOLEAN_ELEMENT, async function (err, data) { + console.log('testDeviceKvStoreGetBool102 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_BOOLEAN_ELEMENT, function (err,data) { + console.log('testDeviceKvStoreGetBool102 get success'); + expect((err == undefined) && (VALUE_TEST_BOOLEAN_ELEMENT == data)).assertTrue(); + done(); + }); + }) + }catch(e) { + console.log('testDeviceKvStoreGetBool102 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorePutFloat101', 0, async function (done) { + console.log('testDeviceKvStorePutFloat101'); + try { + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT, function (err,data) { + console.log('testDeviceKvStorePutFloat101 put success'); + expect(err == undefined).assertTrue(); + done(); + }); + }catch(e) { + console.log('testDeviceKvStorePutFloat101 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorePutFloat102', 0, async function (done) { + console.log('testDeviceKvStorePutFloat102'); + try { + var floatValue = 123456.654321; + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, floatValue, async function (err,data) { + console.log('testDeviceKvStorePutFloat102 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_FLOAT_ELEMENT, function (err, data) { + console.log('testDeviceKvStorePutFloat102 get success'); + expect((err == undefined) && (floatValue == data)).assertTrue(); + done(); + }) + done(); + }); + }catch(e) { + console.log('testDeviceKvStorePutFloat102 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorePutFloat103', 0, async function (done) { + console.log('testDeviceKvStorePutFloat103'); + try { + var floatValue = 123456.0; + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, floatValue, async function (err,data) { + console.log('testDeviceKvStorePutFloat103 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_FLOAT_ELEMENT, function (err, data) { + console.log('testDeviceKvStorePutFloat103 get success'); + expect((err == undefined) && (floatValue == data)).assertTrue(); + done(); + }) + done(); + }); + }catch(e) { + console.log('testDeviceKvStorePutFloat103 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorePutFloat104', 0, async function (done) { + console.log('testDeviceKvStorePutFloat104'); + try { + var floatValue = 123456.00; + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, floatValue, async function (err,data) { + console.log('testDeviceKvStorePutFloat104 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_FLOAT_ELEMENT, function (err, data) { + console.log('testDeviceKvStorePutFloat104 get success'); + expect((err == undefined) && (floatValue == data)).assertTrue(); + done(); + }) + done(); + }); + }catch(e) { + console.log('testDeviceKvStorePutFloat104 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreGetFloat101', 0, async function (done) { + console.log('testDeviceKvStoreGetFloat101'); + try { + await kvStore.get(localDeviceId, KEY_TEST_FLOAT_ELEMENT, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreGetFloat101 get success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStoreGetFloat101 get fail' + err); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreGetFloat101 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreDeleteString101', 0, async function (done) { + console.log('testDeviceKvStoreDeleteString101'); + try { + await kvStore.delete(KEY_TEST_STRING_ELEMENT, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreDeleteString101 delete success'); + } else { + console.log('testDeviceKvStoreDeleteString101 delete fail' + err); + expect(null).assertFail(); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreDeleteString101 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreDeleteString102', 0, async function (done) { + console.log('testDeviceKvStoreDeleteString102'); + try { + await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, async function (err, data) { + console.log('testDeviceKvStoreDeleteString102 put success'); + expect(err == undefined).assertTrue(); + await kvStore.delete(KEY_TEST_STRING_ELEMENT, function (err,data) { + console.log('testDeviceKvStoreDeleteString102 delete success'); + expect(err == undefined).assertTrue(); + done(); + }); + }) + }catch(e) { + console.log('testDeviceKvStoreDeleteString102 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreDeleteInt101', 0, async function (done) { + console.log('testDeviceKvStoreDeleteInt101'); + try{ + await kvStore.delete(KEY_TEST_INT_ELEMENT, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreDeleteInt101 get success'); + } else { + console.log('testDeviceKvStoreDeleteInt101 get fail' + err); + expect(null).assertFail(); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreDeleteInt101 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreDeleteInt102', 0, async function (done) { + console.log('testDeviceKvStoreDeleteInt102'); + try{ + await kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT, async function (err,data) { + console.log('testDeviceKvStoreDeleteInt102 put success'); + expect(err == undefined).assertTrue(); + await kvStore.delete(KEY_TEST_INT_ELEMENT, function (err,data) { + console.log('testDeviceKvStoreDeleteInt102 delete success'); + expect(err == undefined).assertTrue(); + done(); + }); + }) + }catch(e) { + console.log('testDeviceKvStoreDeleteInt102 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreDeleteFloat101', 0, async function (done) { + console.log('testDeviceKvStoreDeleteFloat101'); + try{ + await kvStore.delete(KEY_TEST_FLOAT_ELEMENT, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreDeleteFloat101 get success'); + } else { + console.log('testDeviceKvStoreDeleteFloat101 get fail' + err); + expect(null).assertFail(); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreDeleteFloat101 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreDeleteFloat102', 0, async function (done) { + console.log('testDeviceKvStoreDeleteFloat102'); + try{ + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT, async function (err, data) { + console.log('testDeviceKvStoreDeleteFloat102 put success'); + expect(err == undefined).assertTrue(); + await kvStore.delete(KEY_TEST_FLOAT_ELEMENT, function (err,data) { + console.log('testDeviceKvStoreDeleteFloat102 delete success'); + expect(err == undefined).assertTrue(); + done(); + }); + }) + }catch(e) { + console.log('testDeviceKvStoreDeleteFloat102 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreDeleteBool101', 0, async function (done) { + console.log('testDeviceKvStoreDeleteBool101'); + try{ + await kvStore.delete(KEY_TEST_BOOLEAN_ELEMENT, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreDeleteBool101 get success'); + } else { + console.log('testDeviceKvStoreDeleteBool101 get fail' + err); + expect(null).assertFail(); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreDeleteBool101 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreDeleteBool102', 0, async function (done) { + console.log('testDeviceKvStoreDeleteBool102'); + try{ + await kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, VALUE_TEST_BOOLEAN_ELEMENT, async function (err, data) { + console.log('testDeviceKvStoreDeleteBool102 put success'); + expect(err == undefined).assertTrue(); + await kvStore.delete(KEY_TEST_BOOLEAN_ELEMENT, function (err,data) { + console.log('testDeviceKvStoreDeleteBool102 delete success'); + expect(err == undefined).assertTrue(); + done(); + }); + }) + }catch(e) { + console.log('testDeviceKvStoreDeleteBool102 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreOnChange101', 0, async function (done) { + console.log('testDeviceKvStoreOnChange101'); + try { + kvStore.on('dataChange', 0, function (data) { + console.log('testDeviceKvStoreOnChange101 dataChange'); + expect(data != null).assertTrue(); + }); + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT, function (err,data) { + console.log('testDeviceKvStoreOnChange101 put success'); + expect(err == undefined).assertTrue(); + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreOnChange101 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreOnChange102', 0, async function (done) { + console.log('testDeviceKvStoreOnChange102'); + try { + kvStore.on('dataChange', 1, function (data) { + console.log('testDeviceKvStoreOnChange102 dataChange'); + expect(data != null).assertTrue(); + }); + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT, function (err,data) { + console.log('testDeviceKvStoreOnChange102 put success'); + expect(err == undefined).assertTrue(); + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreOnChange102 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreOnChange103', 0, async function (done) { + console.log('testDeviceKvStoreOnChange103'); + try { + kvStore.on('dataChange', 2, function (data) { + console.log('testDeviceKvStoreOnChange103 dataChange'); + expect(data != null).assertTrue(); + }); + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT, function (err,data) { + console.log('testDeviceKvStoreOnChange103 put success'); + expect(err == undefined).assertTrue(); + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreOnChange103 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreOnSyncComplete101', 0, async function (done) { + try { + kvStore.on('syncComplete', function (data) { + console.log('testDeviceKvStoreOnSyncComplete101 dataChange'); + expect(data != null).assertTrue(); + }); + await kvStore.put(KEY_TEST_SYNC_ELEMENT + 'testSync101', VALUE_TEST_SYNC_ELEMENT, function (err,data) { + console.log('testDeviceKvStoreOnSyncComplete101 put success'); + expect(err == undefined).assertTrue(); + var devices = ['A12C1F9261528B21F95778D2FDC0B2E33943E6251AC5487F4473D005758905DB']; + var mode = factory.SyncMode.PULL_ONLY; + try { + kvStore.sync(devices, mode); + } catch(e) { + console.log('testDeviceKvStoreOnSyncComplete101 sync no peer device :e:' + e); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreOnSyncComplete101 no peer device :e:' + e); + done(); + } + }) + + it('testDeviceKvStoreOnSyncComplete102', 0, async function (done) { + try { + kvStore.on('syncComplete', function (data) { + console.log('testDeviceKvStoreOnSyncComplete102 dataChange'); + expect(data != null).assertTrue(); + }); + await kvStore.put(KEY_TEST_SYNC_ELEMENT + 'testSync101', VALUE_TEST_SYNC_ELEMENT, function (err,data) { + console.log('testDeviceKvStoreOnSyncComplete102 put success'); + expect(err == undefined).assertTrue(); + var devices = ['A12C1F9261528B21F95778D2FDC0B2E33943E6251AC5487F4473D005758905DB']; + var mode = factory.SyncMode.PUSH_ONLY; + try { + kvStore.sync(devices, mode); + } catch(e) { + console.log('testDeviceKvStoreOnSyncComplete101 sync no peer device :e:' + e); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreOnSyncComplete102 no peer device :e:' + e); + // expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreOnSyncComplete103', 0, async function (done) { + try { + kvStore.on('syncComplete', function (data) { + console.log('testDeviceKvStoreOnSyncComplete103 dataChange'); + expect(data != null).assertTrue(); + }); + await kvStore.put(KEY_TEST_SYNC_ELEMENT + 'testSync101', VALUE_TEST_SYNC_ELEMENT, function (err,data) { + console.log('testDeviceKvStoreOnSyncComplete103 put success'); + expect(err == undefined).assertTrue(); + var devices = ['A12C1F9261528B21F95778D2FDC0B2E33943E6251AC5487F4473D005758905DB']; + var mode = factory.SyncMode.PUSH_PULL; + try { + kvStore.sync(devices, mode); + } catch(e) { + console.log('testDeviceKvStoreOnSyncComplete101 sync no peer device :e:' + e); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreOnSyncComplete103 no peer device :e:' + e); + // expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreSetSyncRange101', 0, async function (done) { + console.log('testDeviceKvStoreSetSyncRange101'); + try { + var localLabels = ['A', 'B']; + var remoteSupportLabels = ['C', 'D']; + await kvStore.setSyncRange(localLabels, remoteSupportLabels, function (err,data) { + console.log('testDeviceKvStoreSetSyncRange101 put success'); + expect(err == undefined).assertTrue(); + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreSetSyncRange101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreSetSyncRange102', 0, async function (done) { + console.log('testDeviceKvStoreSetSyncRange102'); + try { + var localLabels = ['A', 'B']; + var remoteSupportLabels = ['B', 'C']; + await kvStore.setSyncRange(localLabels, remoteSupportLabels, function (err,data) { + console.log('testDeviceKvStoreSetSyncRange102 put success'); + expect(err == undefined).assertTrue(); + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreSetSyncRange102 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreSetSyncRange103', 0, async function (done) { + console.log('testDeviceKvStoreSetSyncRange103'); + try { + var localLabels = ['A', 'B']; + var remoteSupportLabels = ['A', 'B']; + await kvStore.setSyncRange(localLabels, remoteSupportLabels, function (err,data) { + console.log('testDeviceKvStoreSetSyncRange103 put success'); + expect(err == undefined).assertTrue(); + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreSetSyncRange103 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorePutBatch101', 0, async function (done) { + console.log('testDeviceKvStorePutBatch101'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + console.log('testDeviceKvStorePutBatch101 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testDeviceKvStorePutBatch101 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries(localDeviceId, 'batch_test_string_key', function (err,entrys) { + console.log('testDeviceKvStorePutBatch101 getEntries success'); + console.log('testDeviceKvStorePutBatch101 entrys.length: ' + entrys.length); + console.log('testDeviceKvStorePutBatch101 entrys[0]: ' + JSON.stringify(entrys[0])); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == 'batch_test_string_value').assertTrue(); + done(); + }); + }); + }catch(e) { + console.log('testDeviceKvStorePutBatch101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorePutBatch102', 0, async function (done) { + console.log('testDeviceKvStorePutBatch102'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_number_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.INTEGER, + value : 222 + } + } + entries.push(entry); + } + console.log('testDeviceKvStorePutBatch102 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testDeviceKvStorePutBatch102 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries(localDeviceId, 'batch_test_number_key', function (err,entrys) { + console.log('testDeviceKvStorePutBatch102 getEntries success'); + console.log('testDeviceKvStorePutBatch102 entrys.length: ' + entrys.length); + console.log('testDeviceKvStorePutBatch102 entrys[0]: ' + JSON.stringify(entrys[0])); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == 222).assertTrue(); + done(); + }); + }); + }catch(e) { + console.log('testDeviceKvStorePutBatch102 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorePutBatch103', 0, async function (done) { + console.log('testDeviceKvStorePutBatch103'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_number_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.FLOAT, + value : 2.0 + } + } + entries.push(entry); + } + console.log('testDeviceKvStorePutBatch103 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testDeviceKvStorePutBatch103 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries(localDeviceId, 'batch_test_number_key', function (err,entrys) { + console.log('testDeviceKvStorePutBatch103 getEntries success'); + console.log('testDeviceKvStorePutBatch103 entrys.length: ' + entrys.length); + console.log('testDeviceKvStorePutBatch103 entrys[0]: ' + JSON.stringify(entrys[0])); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == 2.0).assertTrue(); + done(); + }); + }); + }catch(e) { + console.log('testDeviceKvStorePutBatch103 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorePutBatch104', 0, async function (done) { + console.log('testDeviceKvStorePutBatch104'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_number_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.DOUBLE, + value : 2.00 + } + } + entries.push(entry); + } + console.log('testDeviceKvStorePutBatch104 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testDeviceKvStorePutBatch104 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries(localDeviceId, 'batch_test_number_key', function (err,entrys) { + console.log('testDeviceKvStorePutBatch104 getEntries success'); + console.log('testDeviceKvStorePutBatch104 entrys.length: ' + entrys.length); + console.log('testDeviceKvStorePutBatch104 entrys[0]: ' + JSON.stringify(entrys[0])); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == 2.00).assertTrue(); + done(); + }); + }); + }catch(e) { + console.log('testDeviceKvStorePutBatch104 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorePutBatch105', 0, async function (done) { + console.log('testDeviceKvStorePutBatch105'); + try { + var bo = false; + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_bool_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.BOOLEAN, + value : bo + } + } + entries.push(entry); + } + console.log('testDeviceKvStorePutBatch105 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testDeviceKvStorePutBatch105 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries(localDeviceId, 'batch_test_bool_key', function (err,entrys) { + console.log('testDeviceKvStorePutBatch105 getEntries success'); + console.log('testDeviceKvStorePutBatch105 entrys.length: ' + entrys.length); + console.log('testDeviceKvStorePutBatch105 entrys[0]: ' + JSON.stringify(entrys[0])); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == bo).assertTrue(); + done(); + }); + }); + }catch(e) { + console.log('testDeviceKvStorePutBatch105 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorePutBatch106', 0, async function (done) { + console.log('testDeviceKvStorePutBatch106'); + try { + var arr = new Uint8Array([21,31]); + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_bool_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.BYTE_ARRAY, + value : arr + } + } + entries.push(entry); + } + console.log('testDeviceKvStorePutBatch106 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testDeviceKvStorePutBatch106 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries(localDeviceId, 'batch_test_bool_key', function (err,entrys) { + console.log('testDeviceKvStorePutBatch106 getEntries success'); + console.log('testDeviceKvStorePutBatch106 entrys.length: ' + entrys.length); + console.log('testDeviceKvStorePutBatch106 entrys[0]: ' + JSON.stringify(entrys[0])); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value.toString() == arr.toString()).assertTrue(); + done(); + }); + }); + }catch(e) { + console.log('testDeviceKvStorePutBatch106 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreDeleteBatch101', 0, async function (done) { + console.log('testDeviceKvStoreDeleteBatch101'); + try { + let entries = []; + let keys = []; + for (var i = 0; i < 5; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + keys.push(key + i); + } + console.log('testDeviceKvStoreDeleteBatch101 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testDeviceKvStoreDeleteBatch101 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.deleteBatch(keys, async function (err,data) { + console.log('testDeviceKvStoreDeleteBatch101 deleteBatch success'); + expect(err == undefined).assertTrue(); + done(); + }); + }); + }catch(e) { + console.log('testDeviceKvStoreDeleteBatch101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreDeleteBatch102', 0, async function (done) { + console.log('testDeviceKvStoreDeleteBatch102'); + try { + let keys = ['batch_test_string_key1', 'batch_test_string_key2']; + await kvStore.deleteBatch(keys, function (err,data) { + console.log('testDeviceKvStoreDeleteBatch102 deleteBatch success'); + expect(err == undefined).assertTrue(); + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreDeleteBatch102 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreDeleteBatch103', 0, async function (done) { + console.log('testDeviceKvStoreDeleteBatch103'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + console.log('testDeviceKvStoreDeleteBatch103 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testDeviceKvStoreDeleteBatch103 putBatch success'); + expect(err == undefined).assertTrue(); + let keys = ['batch_test_string_key1', 'batch_test_string_keya']; + await kvStore.deleteBatch(keys, async function (err,data) { + console.log('testDeviceKvStoreDeleteBatch103 deleteBatch success'); + expect(err == undefined).assertTrue(); + done(); + }); + }); + }catch(e) { + console.log('testDeviceKvStoreDeleteBatch103 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorestartTransaction101', 0, async function (done) { + console.log('testDeviceKvStorestartTransaction101'); + try { + var count = 0; + kvStore.on('dataChange', 0, function (data) { + console.log('testDeviceKvStorestartTransaction101 0' + data) + count++; + }); + // startTransaction + await kvStore.startTransaction(async function (err,data) { + console.log('testDeviceKvStorestartTransaction101 startTransaction success'); + expect(err == undefined).assertTrue(); + let entries = putBatchString(10, 'batch_test_string_key'); + console.log('testDeviceKvStorestartTransaction101 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testDeviceKvStorestartTransaction101 putBatch success'); + expect(err == undefined).assertTrue(); + let keys = Object.keys(entries).slice(5); //delete 5 beginnings + await kvStore.deleteBatch(keys, async function (err,data) { + console.log('testDeviceKvStorestartTransaction101 deleteBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.commit(async function (err,data) { + console.log('testDeviceKvStorestartTransaction101 commit success'); + expect(err == undefined).assertTrue(); + await sleep(2000); + // assert + expect(count == 1).assertTrue(); + done(); + }); + }); + }); + }); + }catch(e) { + console.log('testDeviceKvStorestartTransaction101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorestartTransaction102', 0, async function (done) { + console.log('testDeviceKvStorestartTransaction102'); + try { + var count = 0; + kvStore.on('dataChange', 0, function (data) { + console.log('testDeviceKvStorestartTransaction102 0' + data) + count++; + }); + await kvStore.startTransaction(async function (err,data) { + console.log('testDeviceKvStorestartTransaction102 startTransaction success'); + expect(err == undefined).assertTrue(); + let entries = putBatchString(10, 'batch_test_string_key'); + console.log('testDeviceKvStorestartTransaction102 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testDeviceKvStorestartTransaction102 putBatch success'); + expect(err == undefined).assertTrue(); + let keys = Object.keys(entries).slice(5); //delete 5 beginnings + await kvStore.deleteBatch(keys, async function (err,data) { + console.log('testDeviceKvStorestartTransaction102 deleteBatch success'); + expect(err == undefined).assertTrue(); + // rollback + await kvStore.rollback(async function (err,data) { + console.log('testDeviceKvStorestartTransaction102 rollback success'); + expect(err == undefined).assertTrue(); + await sleep(2000); + expect(count == 0).assertTrue(); + done(); + }); + }); + }); + }); + }catch(e) { + console.log('testDeviceKvStorestartTransaction102 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStorestartTransaction103', 0, async function (done) { + console.log('testDeviceKvStorestartTransaction103'); + try { + await kvStore.startTransaction(1, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStorestartTransaction103 startTransaction success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStorestartTransaction103 startTransaction fail'); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStorestartTransaction103 e ' + e); + done(); + } + }) + + it('testDeviceKvStorestartTransaction104', 0, async function (done) { + console.log('testDeviceKvStorestartTransaction104'); + try { + await kvStore.startTransaction('test_string', function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStorestartTransaction104 startTransaction success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStorestartTransaction104 startTransaction fail'); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStorestartTransaction104 e ' + e); + done(); + } + }) + + it('testDeviceKvStorestartTransaction105', 0, async function (done) { + console.log('testDeviceKvStorestartTransaction105'); + try { + await kvStore.startTransaction(2.000, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStorestartTransaction105 startTransaction success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStorestartTransaction105 startTransaction fail'); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStorestartTransaction105 e ' + e); + done(); + } + }) + + it('testDeviceKvStoreCommit101', 0, async function (done) { + console.log('testDeviceKvStoreCommit101'); + try { + await kvStore.commit(1, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreCommit101 commit success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStoreCommit101 commit fail'); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreCommit101 e ' + e); + done(); + } + }) + + it('testDeviceKvStoreCommit102', 0, async function (done) { + console.log('testDeviceKvStoreCommit102'); + try { + await kvStore.commit('test_string', function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreCommit102 commit success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStoreCommit102 commit fail'); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreCommit102 e ' + e); + done(); + } + }) + + it('testDeviceKvStoreCommit103', 0, async function (done) { + console.log('testDeviceKvStoreCommit103'); + try { + await kvStore.commit(2.000, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreCommit103 commit success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStoreCommit103 commit fail'); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreCommit103 e ' + e); + done(); + } + }) + + it('testDeviceKvStoreRollback101', 0, async function (done) { + console.log('testDeviceKvStoreRollback101'); + try { + await kvStore.rollback(1, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreRollback101 commit success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStoreRollback101 commit fail'); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreRollback101 e ' + e); + done(); + } + }) + + it('testDeviceKvStoreRollback102', 0, async function (done) { + console.log('testDeviceKvStoreRollback102'); + try { + await kvStore.rollback('test_string', function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreRollback102 commit success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStoreRollback102 commit fail'); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreRollback102 e ' + e); + done(); + } + }) + + it('testDeviceKvStoreRollback103', 0, async function (done) { + console.log('testDeviceKvStoreRollback103'); + try { + await kvStore.rollback(2.000, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreRollback103 commit success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStoreRollback103 commit fail'); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreRollback103 e ' + e); + done(); + } + }) + + it('testDeviceKvStoreEnableSync101', 0, async function (done) { + console.log('testDeviceKvStoreEnableSync101'); + try { + await kvStore.enableSync(true, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreEnableSync101 enableSync success'); + expect(err == undefined).assertTrue(); + } else { + console.log('testDeviceKvStoreEnableSync101 enableSync fail'); + expect(null).assertFail(); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreEnableSync101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreEnableSync102', 0, async function (done) { + console.log('testDeviceKvStoreEnableSync102'); + try { + await kvStore.enableSync(false, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreEnableSync102 enableSync success'); + expect(err == undefined).assertTrue(); + } else { + console.log('testDeviceKvStoreEnableSync102 enableSync fail'); + expect(null).assertFail(); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreEnableSync102 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreEnableSync103', 0, async function (done) { + console.log('testDeviceKvStoreEnableSync103'); + try { + await kvStore.enableSync(function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreEnableSync103 enableSync success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStoreEnableSync103 enableSync fail'); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreEnableSync103 e ' + e); + done(); + } + }) + + it('testDeviceKvStoreEnableSync104', 0, async function (done) { + console.log('testDeviceKvStoreEnableSync104'); + try { + await kvStore.enableSync(null, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreEnableSync104 enableSync success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStoreEnableSync104 enableSync fail'); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreEnableSync104 e ' + e); + done(); + } + }) + + it('testDeviceKvStoreRemoveDeviceData101', 0, async function (done) { + console.log('testDeviceKvStoreRemoveDeviceData101'); + try { + await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, async function (err,data) { + console.log('testDeviceKvStoreRemoveDeviceData101 put success'); + expect(err == undefined).assertTrue(); + var deviceid = 'no_exist_device_id'; + await kvStore.removeDeviceData(deviceid, async function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreRemoveDeviceData101 removeDeviceData success'); + expect(null).assertFail(); + done(); + } else { + console.log('testDeviceKvStoreRemoveDeviceData101 removeDeviceData fail'); + await kvStore.get(localDeviceId, KEY_TEST_STRING_ELEMENT, async function (err,data) { + console.log('testDeviceKvStoreRemoveDeviceData101 get success'); + expect(data == VALUE_TEST_STRING_ELEMENT).assertTrue(); + done(); + }); + } + }); + }); + }catch(e) { + console.log('testDeviceKvStoreRemoveDeviceData101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreRemoveDeviceData102', 0, async function (done) { + console.log('testDeviceKvStoreRemoveDeviceData102'); + try { + await kvStore.removeDeviceData(function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreRemoveDeviceData102 removeDeviceData success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStoreRemoveDeviceData102 removeDeviceData fail'); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreRemoveDeviceData101 e ' + e); + done(); + } + }) + + it('testDeviceKvStoreRemoveDeviceData103', 0, async function (done) { + console.log('testDeviceKvStoreRemoveDeviceData103'); + try { + await kvStore.removeDeviceData('', function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreRemoveDeviceData103 removeDeviceData success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStoreRemoveDeviceData103 removeDeviceData fail'); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreRemoveDeviceData103 e ' + e); + done(); + } + }) + + it('testDeviceKvStoreRemoveDeviceData104', 0, async function (done) { + console.log('testDeviceKvStoreRemoveDeviceData104'); + try { + await kvStore.removeDeviceData(null, function (err,data) { + if (err == undefined) { + console.log('testDeviceKvStoreRemoveDeviceData104 removeDeviceData success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStoreRemoveDeviceData104 removeDeviceData fail'); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreRemoveDeviceData104 e ' + e); + done(); + } + }) + + it('testDeviceKvStoreGetResultSet101', 0, async function (done) { + console.log('testDeviceKvStoreGetResultSet101'); + try { + let resultSet; + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries, async function (err, data) { + console.log('testDeviceKvStoreGetResultSet101 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getResultSet(localDeviceId, 'batch_test_string_key', async function (err, result) { + console.log('testDeviceKvStoreGetResultSet101 getResultSet success'); + resultSet = result; + expect(resultSet.getCount() == 10).assertTrue(); + await kvStore.closeResultSet(resultSet, function (err, data) { + console.log('testDeviceKvStoreGetResultSet101 closeResultSet success'); + expect(err == undefined).assertTrue(); + done(); + }) + }); + }); + }catch(e) { + console.log('testDeviceKvStoreGetResultSet101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreGetResultSet102', 0, async function (done) { + console.log('testDeviceKvStoreGetResultSet102'); + try { + let resultSet; + await kvStore.getResultSet(localDeviceId, 'batch_test_string_key', async function (err, result) { + console.log('testDeviceKvStoreGetResultSet102 getResultSet success'); + resultSet = result; + expect(resultSet.getCount() == 0).assertTrue(); + await kvStore.closeResultSet(resultSet, function (err, data) { + console.log('testDeviceKvStoreGetResultSet102 closeResultSet success'); + expect(err == undefined).assertTrue(); + done(); + }) + }); + }catch(e) { + console.log('testDeviceKvStoreGetResultSet102 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreGetResultSet103', 0, async function (done) { + console.log('testDeviceKvStoreGetResultSet103'); + try { + let resultSet; + await kvStore.getResultSet(function (err, result) { + console.log('testDeviceKvStoreGetResultSet103 getResultSet success'); + expect(err != undefined).assertTrue(); + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreGetResultSet103 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreGetResultSet104', 0, async function (done) { + console.log('testDeviceKvStoreGetResultSet104'); + try { + let resultSet; + await kvStore.getResultSet('test_key_string', 123, function (err, result) { + console.log('testDeviceKvStoreGetResultSet104 getResultSet success'); + expect(err != undefined).assertTrue(); + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreGetResultSet104 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreGetResultSet105', 0, async function (done) { + console.log('testDeviceKvStoreGetResultSet105'); + try { + let resultSet; + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries, async function (err, data) { + console.log('testDeviceKvStoreGetResultSet105 putBatch success'); + expect(err == undefined).assertTrue(); + var query = new factory.Query(); + query.prefixKey("batch_test"); + await kvStore.getResultSet(localDeviceId, query, async function (err, result) { + console.log('testDeviceKvStoreGetResultSet105 getResultSet success'); + resultSet = result; + expect(resultSet.getCount() == 10).assertTrue(); + await kvStore.closeResultSet(resultSet, function (err, data) { + console.log('testDeviceKvStoreGetResultSet105 closeResultSet success'); + expect(err == undefined).assertTrue(); + done(); + }) + }); + }); + } catch(e) { + console.log('testDeviceKvStoreGetResultSet105 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreGetResultSet106', 0, async function (done) { + console.log('testDeviceKvStoreGetResultSet106'); + try { + let resultSet; + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries, async function (err, data) { + console.log('testDeviceKvStoreGetResultSet106 putBatch success'); + expect(err == undefined).assertTrue(); + var query = new factory.Query(); + query.prefixKey("batch_test"); + query.deviceId(localDeviceId); + await kvStore.getResultSet(query, async function (err, result) { + console.log('testDeviceKvStoreGetResultSet106 getResultSet success'); + resultSet = result; + expect(resultSet.getCount() == 10).assertTrue(); + await kvStore.closeResultSet(resultSet, function (err, data) { + console.log('testDeviceKvStoreGetResultSet106 closeResultSet success'); + expect(err == undefined).assertTrue(); + done(); + }) + }); + }); + } catch(e) { + console.log('testDeviceKvStoreGetResultSet106 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreCloseResultSet101', 0, async function (done) { + console.log('testDeviceKvStoreCloseResultSet101'); + try { + console.log('testDeviceKvStoreCloseResultSet101 success'); + let resultSet = null; + await kvStore.closeResultSet(resultSet, function (err, data) { + if (err == undefined) { + console.log('testDeviceKvStoreCloseResultSet101 closeResultSet success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStoreCloseResultSet101 closeResultSet fail'); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreCloseResultSet101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreCloseResultSet102', 0, async function (done) { + console.log('testDeviceKvStoreCloseResultSet102'); + try { + let resultSet = null; + await kvStore.getResultSet(localDeviceId, 'batch_test_string_key', async function(err, result) { + console.log('testDeviceKvStoreCloseResultSet102 getResultSet success'); + resultSet = result; + await kvStore.closeResultSet(resultSet, function (err, data) { + if (err == undefined) { + console.log('testDeviceKvStoreCloseResultSet102 closeResultSet success'); + expect(err == undefined).assertTrue(); + } else { + console.log('testDeviceKvStoreCloseResultSet102 closeResultSet fail'); + expect(null).assertFail(); + } + done(); + }); + }); + }catch(e) { + console.log('testDeviceKvStoreCloseResultSet102 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreCloseResultSet103', 0, async function (done) { + console.log('testDeviceKvStoreCloseResultSet103'); + try { + console.log('testDeviceKvStoreCloseResultSet103 success'); + await kvStore.closeResultSet(function (err, data) { + if (err == undefined) { + console.log('testDeviceKvStoreCloseResultSet103 closeResultSet success'); + expect(null).assertFail(); + } else { + console.log('testDeviceKvStoreCloseResultSet103 closeResultSet fail'); + } + done(); + }); + }catch(e) { + console.log('testDeviceKvStoreCloseResultSet103 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreCloseResultSet104', 0, async function (done) { + console.log('testDeviceKvStoreCloseResultSet104'); + try { + // pass query + console.log('testDeviceKvStoreCloseResultSet104 success'); + }catch(e) { + console.log('testDeviceKvStoreCloseResultSet104 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + + it('testDeviceKvStoreGetResultSize101', 0, async function (done) { + console.log('testDeviceKvStoreGetResultSize101'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries, async function (err, data) { + console.log('testDeviceKvStoreGetResultSize101 putBatch success'); + expect(err == undefined).assertTrue(); + var query = new factory.Query(); + query.prefixKey("batch_test"); + query.deviceId(localDeviceId); + await kvStore.getResultSize(query, async function (err, resultSize) { + console.log('testDeviceKvStoreGetResultSize101 getResultSet success'); + expect(resultSize == 10).assertTrue(); + done(); + }); + }); + } catch(e) { + console.log('testDeviceKvStoreGetResultSize101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreGetResultSize102', 0, async function (done) { + console.log('testDeviceKvStoreGetResultSize102'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries, async function (err, data) { + console.log('testDeviceKvStoreGetResultSize102 putBatch success'); + expect(err == undefined).assertTrue(); + var query = new factory.Query(); + query.prefixKey("batch_test"); + await kvStore.getResultSize(localDeviceId, query, async function (err, resultSize) { + console.log('testDeviceKvStoreGetResultSize102 getResultSet success'); + expect(resultSize == 10).assertTrue(); + done(); + }); + }); + } catch(e) { + console.log('testDeviceKvStoreGetResultSize102 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testDeviceKvStoreGetEntries101', 0, async function (done) { + console.log('testDeviceKvStoreGetEntries101'); + try { + var arr = new Uint8Array([21,31]); + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_bool_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.BYTE_ARRAY, + value : arr + } + } + entries.push(entry); + } + console.log('testDeviceKvStoreGetEntries101 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testDeviceKvStoreGetEntries101 putBatch success'); + expect(err == undefined).assertTrue(); + var query = new factory.Query(); + query.deviceId(localDeviceId); + query.prefixKey("batch_test"); + await kvStore.getEntries(localDeviceId, query, function (err,entrys) { + console.log('testDeviceKvStoreGetEntries101 getEntries success'); + console.log('testDeviceKvStoreGetEntries101 entrys.length: ' + entrys.length); + console.log('testDeviceKvStoreGetEntries101 entrys[0]: ' + JSON.stringify(entrys[0])); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value.toString() == arr.toString()).assertTrue(); + done(); + }); + }); + console.log('testDeviceKvStoreGetEntries101 success'); + }catch(e) { + console.log('testDeviceKvStoreGetEntries101 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreGetEntries102', 0, async function (done) { + console.log('testDeviceKvStoreGetEntries102'); + try { + var arr = new Uint8Array([21,31]); + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_bool_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.BYTE_ARRAY, + value : arr + } + } + entries.push(entry); + } + console.log('testDeviceKvStoreGetEntries102 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testDeviceKvStoreGetEntries102 putBatch success'); + expect(err == undefined).assertTrue(); + var query = new factory.Query(); + query.prefixKey("batch_test"); + query.deviceId(localDeviceId); + await kvStore.getEntries(query, function (err,entrys) { + console.log('testDeviceKvStoreGetEntries102 getEntries success'); + console.log('testDeviceKvStoreGetEntries102 entrys.length: ' + entrys.length); + console.log('testDeviceKvStoreGetEntries102 entrys[0]: ' + JSON.stringify(entrys[0])); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value.toString() == arr.toString()).assertTrue(); + done(); + }); + }); + console.log('testDeviceKvStoreGetEntries101 success'); + console.log('testDeviceKvStoreGetEntries102 success'); + }catch(e) { + console.log('testDeviceKvStoreGetEntries102 e ' + e); + expect(null).assertFail(); + } + done(); + }) +}) \ No newline at end of file diff --git a/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/DeviceKvStorePromiseJsunit.test.js b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/DeviceKvStorePromiseJsunit.test.js new file mode 100644 index 0000000000000000000000000000000000000000..ca51faea22727a959a5c1470b96df50090d28c94 --- /dev/null +++ b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/DeviceKvStorePromiseJsunit.test.js @@ -0,0 +1,2108 @@ +/* +* Copyright (c) 2021 Huawei Device Co., Ltd. +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' +import factory from '@ohos.data.distributedData' + +const KEY_TEST_INT_ELEMENT = 'key_test_int'; +const KEY_TEST_FLOAT_ELEMENT = 'key_test_float'; +const KEY_TEST_BOOLEAN_ELEMENT = 'key_test_boolean'; +const KEY_TEST_STRING_ELEMENT = 'key_test_string'; +const KEY_TEST_SYNC_ELEMENT = 'key_test_sync'; + +const VALUE_TEST_INT_ELEMENT = 123; +const VALUE_TEST_FLOAT_ELEMENT = 321.12; +const VALUE_TEST_BOOLEAN_ELEMENT = true; +const VALUE_TEST_STRING_ELEMENT = 'value-string-001'; +const VALUE_TEST_SYNC_ELEMENT = 'value-string-001'; + +const TEST_BUNDLE_NAME = 'ohos.acts.distributeddatamgr'; +const TEST_STORE_ID = 'storeId'; +var kvManager = null; +var kvStore = null; +var localDeviceId = null; + +function sleep(ms) { + return new Promise(resolve => setTimeout(resolve, ms)); +} + +function putBatchString(len, prefix) { + let entries = []; + for (var i = 0; i < len; i++) { + var entry = { + key : prefix + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + return entries; +} + +describe('DeviceKvStorePromiseTest', function () { + const config = { + bundleName : TEST_BUNDLE_NAME, + userInfo : { + userId : '0', + userType : factory.UserType.SAME_USER_ID + } + } + + const options = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.DEVICE_COLLABORATION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + + beforeAll(async function (done) { + console.log('beforeAll config:'+ JSON.stringify(config)); + await factory.createKVManager(config).then((manager) => { + kvManager = manager; + console.log('beforeAll createKVManager success'); + }).catch((err) => { + console.log('beforeAll createKVManager err ' + err); + }); + // get localDeviceId - put, get deviceId on dataChange().. + await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { + kvStore = store; + console.log('beforeAll getKVStore success'); + }).catch((err) => { + console.log('beforeAll getKVStore err ' + err); + }); + kvStore.on('dataChange', 0, function (data) { + console.log('beforeAll on ' + JSON.stringify(data)); + localDeviceId = data.deviceId; + expect(localDeviceId != null).assertTrue(); + }); + await kvStore.put("getDeviceId", "byPut"); + console.log('beforeAll end'); + done(); + }) + + afterAll(async function (done) { + console.log('afterAll'); + kvManager = null; + kvStore = null; + done(); + }) + + beforeEach(async function (done) { + console.log('beforeEach' + JSON.stringify(options)); + await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { + kvStore = store; + console.log('beforeEach getKVStore success'); + }).catch((err) => { + console.log('beforeEach getKVStore err ' + err); + }); + console.log('beforeEach end'); + done(); + }) + + afterEach(async function (done) { + console.log('afterEach'); + await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, kvStore).then(async () => { + console.log('afterEach closeKVStore success'); + await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { + console.log('afterEach deleteKVStore success'); + kvStore = null; + }).catch((err) => { + console.log('afterEach deleteKVStore err ' + err); + }); + }).catch((err) => { + console.log('afterEach closeKVStore err ' + err); + }); + done(); + }) + + it('testDeviceKvStorePutString001', 0, async function (done) { + console.log('testDeviceKvStorePutString001'); + try { + await kvStore.put(KEY_TEST_STRING_ELEMENT, null).then((data) => { + console.log('testDeviceKvStorePutString001 put success'); + expect(null).assertFail(); + }).catch((error) => { + console.log('testDeviceKvStorePutString001 put error' + error); + }); + } catch (e) { + console.log('testDeviceKvStorePutString001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStorePutString002', 0, async function (done) { + console.log('testDeviceKvStorePutString002'); + try { + await kvStore.put(KEY_TEST_STRING_ELEMENT, '').then((data) => { + console.log('testDeviceKvStorePutString002 put success'); + expect(data == undefined).assertTrue(); + }).catch((error) => { + console.log('testDeviceKvStorePutString002 put error' + error); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStorePutString002 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStorePutString003', 0, async function (done) { + console.log('testDeviceKvStorePutString003'); + try { + await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then((data) => { + console.log('testDeviceKvStorePutString003 put success'); + expect(data == undefined).assertTrue(); + }).catch((error) => { + console.log('testDeviceKvStorePutString003 put error' + error); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStorePutString003 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStorePutString004', 0, async function (done) { + console.log('testDeviceKvStorePutString004'); + try { + var str = ''; + for (var i = 0 ; i < 4095; i++) { + str += 'x'; + } + await kvStore.put(KEY_TEST_STRING_ELEMENT, str).then(async (data) => { + console.log('testDeviceKvStorePutString004 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_STRING_ELEMENT).then((data) => { + console.log('testDeviceKvStorePutString004 get success data ' + data); + expect(str == data).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorePutString004 get fail ' + err); + expect(null).assertFail(); + }); + }).catch((error) => { + console.log('testDeviceKvStorePutString004 put error' + error); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStorePutString004 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreGetString001', 0, async function (done) { + console.log('testDeviceKvStoreGetString001'); + try { + await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then(async (data) => { + console.log('testDeviceKvStoreGetString001 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_STRING_ELEMENT).then((data) => { + console.log('testDeviceKvStoreGetString001 get success'); + expect(VALUE_TEST_STRING_ELEMENT == data).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreGetString001 get fail ' + err); + expect(null).assertFail(); + }); + }).catch((error) => { + console.log('testDeviceKvStoreGetString001 put error' + error); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStoreGetString001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreGetString002', 0, async function (done) { + console.log('testDeviceKvStoreGetString002'); + try { + await kvStore.get(localDeviceId, KEY_TEST_STRING_ELEMENT).then((data) => { + console.log('testDeviceKvStoreGetString002 get success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStoreGetString002 get fail ' + err); + }); + } catch (e) { + console.log('testDeviceKvStoreGetString002 get e ' + e); + } + done(); + }) + + it('testDeviceKvStorePutInt001', 0, async function (done) { + console.log('testDeviceKvStorePutInt001'); + try { + await kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT).then((data) => { + console.log('testDeviceKvStorePutInt001 put success'); + expect(data == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorePutInt001 put fail ' + err); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStorePutInt001 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStorePutInt002', 0, async function (done) { + console.log('testDeviceKvStorePutInt002'); + try { + var intValue = 987654321; + await kvStore.put(KEY_TEST_INT_ELEMENT, intValue).then(async (data) => { + console.log('testDeviceKvStorePutInt002 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_INT_ELEMENT).then((data) => { + console.log('testDeviceKvStorePutInt002 get success'); + expect(intValue == data).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorePutInt002 get fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStorePutInt002 put fail ' + err); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStorePutInt002 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStorePutInt003', 0, async function (done) { + console.log('testDeviceKvStorePutInt003'); + try { + var intValue = Number.MAX_VALUE; + await kvStore.put(KEY_TEST_INT_ELEMENT, intValue).then(async (data) => { + console.log('testDeviceKvStorePutInt003 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_INT_ELEMENT).then((data) => { + console.log('testDeviceKvStorePutInt003 get success'); + expect(intValue == data).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorePutInt003 get fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStorePutInt003 put fail ' + err); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStorePutInt003 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStorePutInt004', 0, async function (done) { + console.log('testDeviceKvStorePutInt004'); + try { + var intValue = Number.MIN_VALUE; + await kvStore.put(KEY_TEST_INT_ELEMENT, intValue).then(async (data) => { + console.log('testDeviceKvStorePutInt004 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_INT_ELEMENT).then((data) => { + console.log('testDeviceKvStorePutInt004 get success'); + expect(intValue == data).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorePutInt004 get fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStorePutInt004 put fail ' + err); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStorePutInt004 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreGetInt001', 0, async function (done) { + console.log('testDeviceKvStoreGetInt001'); + try { + await kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT).then(async (data) => { + console.log('testDeviceKvStoreGetInt001 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_INT_ELEMENT).then((data) => { + console.log('testDeviceKvStoreGetInt001 get success'); + expect(VALUE_TEST_INT_ELEMENT == data).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreGetInt001 get fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStoreGetInt001 put fail ' + err); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStoreGetInt001 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStorePutBool001', 0, async function (done) { + console.log('testDeviceKvStorePutBool001'); + try { + await kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, VALUE_TEST_BOOLEAN_ELEMENT).then((data) => { + console.log('testDeviceKvStorePutBool001 put success'); + expect(data == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorePutBool001 put fail ' + err); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStorePutBool001 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreGetBool001', 0, async function (done) { + console.log('testDeviceKvStoreGetBool001'); + try { + var boolValue = false; + await kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, boolValue).then(async (data) => { + console.log('testDeviceKvStoreGetBool001 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_BOOLEAN_ELEMENT).then((data) => { + console.log('testDeviceKvStoreGetBool001 get success'); + expect(boolValue == data).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreGetBool001 get fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStoreGetBool001 put fail ' + err); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStoreGetBool001 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStorePutFloat001', 0, async function (done) { + console.log('testDeviceKvStorePutFloat001'); + try { + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT).then((data) => { + console.log('testDeviceKvStorePutFloat001 put success'); + expect(data == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorePutFloat001 put fail ' + err); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStorePutFloat001 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreGetFloat001', 0, async function (done) { + console.log('testDeviceKvStoreGetFloat001'); + try { + var floatValue = 123456.654321; + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, floatValue).then(async (data) => { + console.log('testDeviceKvStoreGetFloat001 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_FLOAT_ELEMENT).then((data) => { + console.log('testDeviceKvStoreGetFloat001 get success'); + expect(floatValue == data).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreGetFloat001 get fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStoreGetFloat001 put fail ' + err); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStoreGetFloat001 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreGetFloat002', 0, async function (done) { + console.log('testDeviceKvStoreGetFloat002'); + try { + var floatValue = 123456.0; + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, floatValue).then(async (data) => { + console.log('testDeviceKvStoreGetFloat002 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_FLOAT_ELEMENT).then((data) => { + console.log('testDeviceKvStoreGetFloat002 get success'); + expect(floatValue == data).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreGetFloat002 get fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStoreGetFloat002 put fail ' + err); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStoreGetFloat002 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreGetFloat003', 0, async function (done) { + console.log('testDeviceKvStoreGetFloat003'); + try { + var floatValue = 123456.00; + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, floatValue).then(async (data) => { + console.log('testDeviceKvStoreGetFloat003 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(localDeviceId, KEY_TEST_FLOAT_ELEMENT).then((data) => { + console.log('testDeviceKvStoreGetFloat003 get success'); + expect(floatValue == data).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreGetFloat003 get fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStoreGetFloat003 put fail ' + err); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStoreGetFloat003 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreDeleteString001', 0, async function (done) { + console.log('testDeviceKvStoreDeleteString001'); + try { + var str = 'this is a test string'; + await kvStore.put(KEY_TEST_STRING_ELEMENT, str).then(async (data) => { + console.log('testDeviceKvStoreDeleteString001 put success'); + expect(data == undefined).assertTrue(); + await kvStore.delete(KEY_TEST_STRING_ELEMENT).then((data) => { + console.log('testDeviceKvStoreDeleteString001 delete success'); + expect(data == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreDeleteString001 delete fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStoreDeleteString001 put fail ' + err); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStoreDeleteString001 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreDeleteString002', 0, async function (done) { + console.log('testDeviceKvStoreDeleteString002'); + try { + var str = ''; + for (var i = 0 ; i < 4096; i++) { + str += 'x'; + } + await kvStore.put(KEY_TEST_STRING_ELEMENT, str).then(async (data) => { + console.log('testDeviceKvStoreDeleteString002 put success'); + expect(data == undefined).assertTrue(); + await kvStore.delete(KEY_TEST_STRING_ELEMENT).then((data) => { + console.log('testDeviceKvStoreDeleteString002 delete success'); + expect(data == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreDeleteString002 delete fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStoreDeleteString002 put fail ' + err); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStoreDeleteString002 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreDeleteString003', 0, async function (done) { + console.log('testDeviceKvStoreDeleteString003'); + try { + await kvStore.delete(KEY_TEST_STRING_ELEMENT).then((data) => { + console.log('testDeviceKvStoreDeleteString003 delete success'); + expect(data == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreDeleteString003 delete fail ' + err); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStoreDeleteString003 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreDeleteInt001', 0, async function (done) { + console.log('testDeviceKvStoreDeleteInt001'); + try { + await kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT).then(async (data) => { + console.log('testDeviceKvStoreDeleteInt001 put success'); + expect(data == undefined).assertTrue(); + await kvStore.delete(KEY_TEST_INT_ELEMENT).then((data) => { + console.log('testDeviceKvStoreDeleteInt001 delete success'); + expect(data == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreDeleteInt001 delete fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStoreDeleteInt001 put fail ' + err); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStoreDeleteInt001 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreDeleteFloat001', 0, async function (done) { + console.log('testDeviceKvStoreDeleteFloat001'); + try { + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT).then(async (data) => { + console.log('testDeviceKvStoreDeleteFloat001 put success'); + expect(data == undefined).assertTrue(); + await kvStore.delete(KEY_TEST_FLOAT_ELEMENT).then((data) => { + console.log('testDeviceKvStoreDeleteFloat001 delete success'); + expect(data == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreDeleteFloat001 delete fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStoreDeleteFloat001 put fail ' + err); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStoreDeleteFloat001 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreDeleteBool001', 0, async function (done) { + console.log('testDeviceKvStoreDeleteBool001'); + try { + await kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, VALUE_TEST_BOOLEAN_ELEMENT).then(async (data) => { + console.log('testDeviceKvStoreDeleteBool001 put success'); + expect(data == undefined).assertTrue(); + await kvStore.delete(KEY_TEST_BOOLEAN_ELEMENT).then((data) => { + console.log('testDeviceKvStoreDeleteBool001 delete success'); + expect(data == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreDeleteBool001 delete fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStoreDeleteBool001 put fail ' + err); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testDeviceKvStoreDeleteBool001 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreOnChange001', 0, async function (done) { + try { + kvStore.on('dataChange', 0, function (data) { + console.log('testDeviceKvStoreOnChange001 0' + JSON.stringify(data)) + expect(data != null).assertTrue(); + }); + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT).then((data) => { + console.log('testDeviceKvStoreOnChange001 put success'); + expect(data == undefined).assertTrue(); + }).catch((error) => { + console.log('testDeviceKvStoreOnChange001 put fail ' + error); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStoreOnChange001 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreOnChange002', 0, async function (done) { + try { + kvStore.on('dataChange', 1, function (data) { + console.log('testDeviceKvStoreOnChange002 0' + JSON.stringify(data)) + expect(data != null).assertTrue(); + }); + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT).then((data) => { + console.log('testDeviceKvStoreOnChange002 put success'); + expect(data == undefined).assertTrue(); + }).catch((error) => { + console.log('testDeviceKvStoreOnChange002 put fail ' + error); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStoreOnChange002 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreOnChange003', 0, async function (done) { + try { + kvStore.on('dataChange', 2, function (data) { + console.log('testDeviceKvStoreOnChange003 0' + JSON.stringify(data)) + expect(data != null).assertTrue(); + }); + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT).then((data) => { + console.log('testDeviceKvStoreOnChange003 put success'); + expect(data == undefined).assertTrue(); + }).catch((error) => { + console.log('testDeviceKvStoreOnChange003 put fail ' + error); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStoreOnChange003 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreOnSyncComplete001', 0, async function (done) { + try { + kvStore.on('syncComplete', function (data) { + console.log('testDeviceKvStoreOnSyncComplete001 0' + data) + expect(data != null).assertTrue(); + }); + await kvStore.put(KEY_TEST_SYNC_ELEMENT, VALUE_TEST_SYNC_ELEMENT).then((data) => { + console.log('testDeviceKvStoreOnSyncComplete001 put success'); + expect(data == undefined).assertTrue(); + var devices = ['A12C1F9261528B21F95778D2FDC0B2E33943E6251AC5487F4473D005758905DB']; + var mode = factory.SyncMode.PULL_ONLY; + kvStore.sync(devices, mode); + }).catch((error) => { + console.log('testDeviceKvStoreOnSyncComplete001 no peer device :e:' + error); + // expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStoreOnSyncComplete001 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreOnSyncComplete002', 0, async function (done) { + try { + kvStore.on('syncComplete', function (data) { + console.log('testDeviceKvStoreOnSyncComplete002 0' + data) + expect(data != null).assertTrue(); + }); + await kvStore.put(KEY_TEST_SYNC_ELEMENT, VALUE_TEST_SYNC_ELEMENT).then((data) => { + console.log('testDeviceKvStoreOnSyncComplete002 put success'); + expect(data == undefined).assertTrue(); + var devices = ['A12C1F9261528B21F95778D2FDC0B2E33943E6251AC5487F4473D005758905DB']; + var mode = factory.SyncMode.PUSH_ONLY; + kvStore.sync(devices, mode); + }).catch((error) => { + console.log('testDeviceKvStoreOnSyncComplete002 no peer device :e:' + error); + // expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStoreOnSyncComplete002 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreOnSyncComplete003', 0, async function (done) { + try { + kvStore.on('syncComplete', function (data) { + console.log('testDeviceKvStoreOnSyncComplete003 0' + data) + expect(data != null).assertTrue(); + }); + await kvStore.put(KEY_TEST_SYNC_ELEMENT, VALUE_TEST_SYNC_ELEMENT).then((data) => { + console.log('testDeviceKvStoreOnSyncComplete003 put success'); + expect(data == undefined).assertTrue(); + var devices = ['A12C1F9261528B21F95778D2FDC0B2E33943E6251AC5487F4473D005758905DB']; + var mode = factory.SyncMode.PUSH_PULL; + kvStore.sync(devices, mode); + }).catch((error) => { + console.log('testDeviceKvStoreOnSyncComplete003 no peer device :e:' + error); + // expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStoreOnSyncComplete003 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreOffChange001', 0, async function (done) { + console.log('testDeviceKvStoreOffChange001'); + try { + var func = function (data) { + console.log('testDeviceKvStoreOffChange001 0' + data) + }; + kvStore.on('dataChange', 0, func); + kvStore.off('dataChange', func); + }catch(e) { + console.log('testDeviceKvStoreOffChange001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreOffChange002', 0, async function (done) { + console.log('testDeviceKvStoreOffChange002'); + try { + var func = function (data) { + console.log('testDeviceKvStoreOffChange002 0' + data) + }; + var func1 = function (data) { + console.log('testDeviceKvStoreOffChange002 0' + data) + }; + kvStore.on('dataChange', 0, func); + kvStore.on('dataChange', 0, func1); + kvStore.off('dataChange', func); + }catch(e) { + console.log('testDeviceKvStoreOffChange002 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreOffChange003', 0, async function (done) { + console.log('testDeviceKvStoreOffChange003'); + try { + var func = function (data) { + console.log('testDeviceKvStoreOffChange003 0' + data) + }; + var func1 = function (data) { + console.log('testDeviceKvStoreOffChange003 0' + data) + }; + kvStore.on('dataChange', 0, func); + kvStore.on('dataChange', 0, func1); + kvStore.off('dataChange', func); + kvStore.off('dataChange', func1); + }catch(e) { + console.log('testDeviceKvStoreOffChange003 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreOffChange004', 0, async function (done) { + console.log('testDeviceKvStoreOffChange004'); + try { + var func = function (data) { + console.log('testDeviceKvStoreOffChange004 0' + data) + }; + kvStore.on('dataChange', 0, func); + kvStore.off('dataChange'); + }catch(e) { + console.log('testDeviceKvStoreOffChange004 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreOffSyncComplete001', 0, async function (done) { + console.log('testDeviceKvStoreOffSyncComplete001'); + try { + var func = function (data) { + console.log('testDeviceKvStoreOffSyncComplete001 0' + data) + }; + kvStore.on('syncComplete', func); + kvStore.off('syncComplete', func); + }catch(e) { + console.log('testDeviceKvStoreOffSyncComplete001 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreOffSyncComplete002', 0, async function (done) { + console.log('testDeviceKvStoreOffSyncComplete002'); + try { + var func = function (data) { + console.log('testDeviceKvStoreOffSyncComplete002 0' + data) + }; + var func1 = function (data) { + console.log('testDeviceKvStoreOffSyncComplete002 0' + data) + }; + kvStore.on('syncComplete', func); + kvStore.on('syncComplete', func1); + kvStore.off('syncComplete', func); + expect(null).assertFail(); + }catch(e) { + console.log('testDeviceKvStoreOffSyncComplete002 put e ' + e); + expect(true).assertTrue(); + } + done(); + }) + + it('testDeviceKvStoreOffSyncComplete003', 0, async function (done) { + console.log('testDeviceKvStoreOffSyncComplete003'); + try { + var func = function (data) { + console.log('testDeviceKvStoreOffSyncComplete003 0' + data) + }; + var func1 = function (data) { + console.log('testDeviceKvStoreOffSyncComplete003 0' + data) + }; + kvStore.on('syncComplete', func); + kvStore.on('syncComplete', func1); + kvStore.off('syncComplete', func); + kvStore.off('syncComplete', func1); + expect(null).assertFail(); + }catch(e) { + console.log('testDeviceKvStoreOffSyncComplete003 put e ' + e); + expect(true).assertTrue(); + } + done(); + }) + + it('testDeviceKvStoreOffSyncComplete004', 0, async function (done) { + console.log('testDeviceKvStoreOffSyncComplete004'); + try { + var func = function (data) { + console.log('testDeviceKvStoreOffSyncComplete004 0' + data) + }; + kvStore.on('syncComplete', func); + kvStore.off('syncComplete'); + }catch(e) { + console.log('testDeviceKvStoreOffSyncComplete004 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreSetSyncRange001', 0, async function (done) { + console.log('testDeviceKvStoreSetSyncRange001'); + try { + var localLabels = ['A', 'B']; + var remoteSupportLabels = ['C', 'D']; + await kvStore.setSyncRange(localLabels, remoteSupportLabels).then((err) => { + console.log('testDeviceKvStoreSetSyncRange001 setSyncRange success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreDeleteString003 delete fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStoreSetSyncRange001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreSetSyncRange002', 0, async function (done) { + console.log('testDeviceKvStoreSetSyncRange002'); + try { + var localLabels = ['A', 'B']; + var remoteSupportLabels = ['B', 'C']; + await kvStore.setSyncRange(localLabels, remoteSupportLabels).then((err) => { + console.log('testDeviceKvStoreSetSyncRange002 setSyncRange success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreSetSyncRange002 delete fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStoreSetSyncRange002 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreSetSyncRange003', 0, async function (done) { + console.log('testDeviceKvStoreSetSyncRange003'); + try { + var localLabels = ['A', 'B']; + var remoteSupportLabels = ['A', 'B']; + await kvStore.setSyncRange(localLabels, remoteSupportLabels).then((err) => { + console.log('testDeviceKvStoreSetSyncRange003 setSyncRange success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreSetSyncRange003 delete fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStoreSetSyncRange003 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStorePutBatch001', 0, async function (done) { + console.log('testDeviceKvStorePutBatch001'); + try { + let entries = putBatchString(10, 'batch_test_string_key'); + console.log('testDeviceKvStorePutBatch001 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testDeviceKvStorePutBatch001 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries(localDeviceId, 'batch_test_string_key').then((entrys) => { + console.log('testDeviceKvStorePutBatch001 getEntries success'); + console.log('testDeviceKvStorePutBatch001 entrys.length: ' + entrys.length); + console.log('testDeviceKvStorePutBatch001 entrys[0]: ' + JSON.stringify(entrys[0])); + console.log('testDeviceKvStorePutBatch001 entrys[0].value: ' + JSON.stringify(entrys[0].value)); + console.log('testDeviceKvStorePutBatch001 entrys[0].value.value: ' + entrys[0].value.value); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == 'batch_test_string_value').assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorePutBatch001 getEntries fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStorePutBatch001 putBatch fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStorePutBatch001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStorePutBatch002', 0, async function (done) { + console.log('testDeviceKvStorePutBatch002'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_number_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.INTEGER, + value : 222 + } + } + entries.push(entry); + } + console.log('testDeviceKvStorePutBatch002 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testDeviceKvStorePutBatch002 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries(localDeviceId, 'batch_test_number_key').then((entrys) => { + console.log('testDeviceKvStorePutBatch002 getEntries success'); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == 222).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorePutBatch002 getEntries fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStorePutBatch002 putBatch fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStorePutBatch002 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStorePutBatch003', 0, async function (done) { + console.log('testDeviceKvStorePutBatch003'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_number_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.FLOAT, + value : 2.0 + } + } + entries.push(entry); + } + console.log('testDeviceKvStorePutBatch003 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testDeviceKvStorePutBatch003 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries(localDeviceId, 'batch_test_number_key').then((entrys) => { + console.log('testDeviceKvStorePutBatch003 getEntries success'); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == 2.0).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorePutBatch003 getEntries fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStorePutBatch003 putBatch fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStorePutBatch003 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStorePutBatch004', 0, async function (done) { + console.log('testDeviceKvStorePutBatch004'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_number_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.DOUBLE, + value : 2.00 + } + } + entries.push(entry); + } + console.log('testDeviceKvStorePutBatch004 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testDeviceKvStorePutBatch004 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries(localDeviceId, 'batch_test_number_key').then((entrys) => { + console.log('testDeviceKvStorePutBatch004 getEntries success'); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == 2.00).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorePutBatch004 getEntries fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStorePutBatch004 putBatch fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStorePutBatch004 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStorePutBatch005', 0, async function (done) { + console.log('testDeviceKvStorePutBatch005'); + try { + var bo = false; + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_bool_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.BOOLEAN, + value : bo + } + } + entries.push(entry); + } + console.log('testDeviceKvStorePutBatch005 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testDeviceKvStorePutBatch005 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries(localDeviceId, 'batch_test_bool_key').then((entrys) => { + console.log('testDeviceKvStorePutBatch005 getEntries success'); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == bo).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorePutBatch005 getEntries fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStorePutBatch005 putBatch fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStorePutBatch005 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStorePutBatch006', 0, async function (done) { + console.log('testDeviceKvStorePutBatch006'); + try { + var arr = new Uint8Array([21,31]); + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_bool_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.BYTE_ARRAY, + value : arr + } + } + entries.push(entry); + } + console.log('testDeviceKvStorePutBatch006 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testDeviceKvStorePutBatch006 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries(localDeviceId, 'batch_test_bool_key').then((entrys) => { + console.log('testDeviceKvStorePutBatch006 getEntries success'); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value.toString() == arr.toString()).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorePutBatch006 getEntries fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStorePutBatch006 putBatch fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStorePutBatch005 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreDeleteBatch001', 0, async function (done) { + console.log('testDeviceKvStoreDeleteBatch001'); + try { + let entries = []; + let keys = []; + for (var i = 0; i < 5; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + keys.push(key + i); + } + console.log('testDeviceKvStoreDeleteBatch001 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testDeviceKvStoreDeleteBatch001 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.deleteBatch(keys).then((err) => { + console.log('testDeviceKvStoreDeleteBatch001 deleteBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreDeleteBatch001 deleteBatch fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStoreDeleteBatch001 putBatch fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStoreDeleteBatch001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreDeleteBatch002', 0, async function (done) { + console.log('testDeviceKvStoreDeleteBatch002'); + try { + let keys = ['batch_test_string_key1', 'batch_test_string_key2']; + await kvStore.deleteBatch(keys).then((err) => { + console.log('testDeviceKvStoreDeleteBatch002 deleteBatch success'); + }).catch((err) => { + console.log('testDeviceKvStoreDeleteBatch002 deleteBatch fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStoreDeleteBatch002 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreDeleteBatch003', 0, async function (done) { + console.log('testDeviceKvStoreDeleteBatch003'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + console.log('testDeviceKvStoreDeleteBatch003 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testDeviceKvStoreDeleteBatch003 putBatch success'); + expect(err == undefined).assertTrue(); + let keys = ['batch_test_string_key1', 'batch_test_string_keya']; + await kvStore.deleteBatch(keys).then((err) => { + console.log('testDeviceKvStoreDeleteBatch003 deleteBatch success'); + }).catch((err) => { + console.log('testDeviceKvStoreDeleteBatch003 deleteBatch fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStoreDeleteBatch003 putBatch fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStoreDeleteBatch003 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStorestartTransaction001', 0, async function (done) { + console.log('testDeviceKvStorestartTransaction001'); + try { + var count = 0; + kvStore.on('dataChange', 0, function (data) { + console.log('testDeviceKvStoreOnChange001 0' + JSON.stringify(data)) + count++; + }); + await kvStore.startTransaction().then(async (err) => { + console.log('testDeviceKvStorestartTransaction001 startTransaction success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorestartTransaction001 startTransaction fail ' + err); + expect(null).assertFail(); + }); + let entries = putBatchString(10, 'batch_test_string_key'); + console.log('testDeviceKvStorestartTransaction001 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testDeviceKvStorestartTransaction001 putBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorestartTransaction001 putBatch fail ' + err); + expect(null).assertFail(); + }); + let keys = Object.keys(entries).slice(5); //delete 5 beginnings + await kvStore.deleteBatch(keys).then((err) => { + console.log('testDeviceKvStorestartTransaction001 deleteBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorestartTransaction001 deleteBatch fail ' + err); + expect(null).assertFail(); + }); + await kvStore.commit().then(async (err) => { + console.log('testDeviceKvStorestartTransaction001 commit success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorestartTransaction001 commit fail ' + err); + expect(null).assertFail(); + }); + await sleep(2000); + expect(count == 1).assertTrue(); + }catch(e) { + console.log('testDeviceKvStorestartTransaction001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStorestartTransaction002', 0, async function (done) { + console.log('testDeviceKvStorestartTransaction002'); + try { + var count = 0; + kvStore.on('dataChange', 0, function (data) { + console.log('testDeviceKvStoreOnChange001 0' + JSON.stringify(data)) + count++; + }); + await kvStore.startTransaction().then(async (err) => { + console.log('testDeviceKvStorestartTransaction002 startTransaction success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorestartTransaction002 startTransaction fail ' + err); + expect(null).assertFail(); + }); + let entries = putBatchString(10, 'batch_test_string_key'); + console.log('testDeviceKvStorestartTransaction002 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testDeviceKvStorestartTransaction002 putBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorestartTransaction002 putBatch fail ' + err); + expect(null).assertFail(); + }); + let keys = Object.keys(entries).slice(5); //delete 5 beginnings + await kvStore.deleteBatch(keys).then((err) => { + console.log('testDeviceKvStorestartTransaction002 deleteBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorestartTransaction002 deleteBatch fail ' + err); + expect(null).assertFail(); + }); + await kvStore.rollback().then(async (err) => { + console.log('testDeviceKvStorestartTransaction002 rollback success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorestartTransaction002 rollback fail ' + err); + expect(null).assertFail(); + }); + await sleep(2000); + expect(count == 0).assertTrue(); + }catch(e) { + console.log('testDeviceKvStorestartTransaction002 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStorestartTransaction003', 0, async function (done) { + console.log('testDeviceKvStorestartTransaction002'); + try { + await kvStore.startTransaction(1).then(async (err) => { + console.log('testDeviceKvStorestartTransaction003 startTransaction success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStorestartTransaction003 startTransaction fail ' + err); + }); + }catch(e) { + console.log('testDeviceKvStorestartTransaction003 e ' + e); + } + done(); + }) + + it('testDeviceKvStorestartTransaction004', 0, async function (done) { + console.log('testDeviceKvStorestartTransaction004'); + try { + await kvStore.startTransaction('test_string').then(async (err) => { + console.log('testDeviceKvStorestartTransaction004 startTransaction success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStorestartTransaction004 startTransaction fail ' + err); + }); + }catch(e) { + console.log('testDeviceKvStorestartTransaction004 e ' + e); + } + done(); + }) + + it('testDeviceKvStorestartTransaction005', 0, async function (done) { + console.log('testDeviceKvStorestartTransaction005'); + try { + await kvStore.startTransaction(2.000).then(async (err) => { + console.log('testDeviceKvStorestartTransaction005 startTransaction success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStorestartTransaction005 startTransaction fail ' + err); + }); + }catch(e) { + console.log('testDeviceKvStorestartTransaction005 e ' + e); + } + done(); + }) + + it('testDeviceKvStoreCommit001', 0, async function (done) { + console.log('testDeviceKvStoreCommit001'); + try { + await kvStore.commit(1).then(async (err) => { + console.log('testDeviceKvStoreCommit001 commit success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStoreCommit001 commit fail ' + err); + }); + }catch(e) { + console.log('testDeviceKvStoreCommit001 e ' + e); + } + done(); + }) + + it('testDeviceKvStoreCommit002', 0, async function (done) { + console.log('testDeviceKvStoreCommit002'); + try { + await kvStore.commit('test_string').then(async (err) => { + console.log('testDeviceKvStoreCommit002 commit success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStoreCommit002 commit fail ' + err); + }); + }catch(e) { + console.log('testDeviceKvStoreCommit002 e ' + e); + } + done(); + }) + + it('testDeviceKvStoreCommit003', 0, async function (done) { + console.log('testDeviceKvStoreCommit003'); + try { + await kvStore.commit(2.000).then(async (err) => { + console.log('testDeviceKvStoreCommit003 commit success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStoreCommit003 commit fail ' + err); + }); + }catch(e) { + console.log('testDeviceKvStoreCommit003 e ' + e); + } + done(); + }) + + it('testDeviceKvStoreRollback001', 0, async function (done) { + console.log('testDeviceKvStoreRollback001'); + try { + await kvStore.rollback(1).then(async (err) => { + console.log('testDeviceKvStoreRollback001 rollback success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStoreRollback001 rollback fail ' + err); + }); + }catch(e) { + console.log('testDeviceKvStoreRollback001 e ' + e); + } + done(); + }) + + it('testDeviceKvStoreRollback002', 0, async function (done) { + console.log('testDeviceKvStoreRollback002'); + try { + await kvStore.rollback('test_string').then(async (err) => { + console.log('testDeviceKvStoreRollback002 rollback success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStoreRollback002 rollback fail ' + err); + }); + }catch(e) { + console.log('testDeviceKvStoreRollback002 e ' + e); + } + done(); + }) + + it('testDeviceKvStoreRollback003', 0, async function (done) { + console.log('testDeviceKvStoreRollback003'); + try { + await kvStore.rollback(2.000).then(async (err) => { + console.log('testDeviceKvStoreRollback003 rollback success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStoreRollback003 rollback fail ' + err); + }); + }catch(e) { + console.log('testDeviceKvStoreRollback003 e ' + e); + } + done(); + }) + + it('testDeviceKvStoreEnableSync001', 0, async function (done) { + console.log('testDeviceKvStoreEnableSync001'); + try { + await kvStore.enableSync(true).then((err) => { + console.log('testDeviceKvStoreEnableSync001 enableSync success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreEnableSync001 enableSync fail ' + err); + expect(null).assertFail(); + }); + + }catch(e) { + console.log('testDeviceKvStoreEnableSync001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreEnableSync002', 0, async function (done) { + console.log('testDeviceKvStoreEnableSync002'); + try { + await kvStore.enableSync(false).then((err) => { + console.log('testDeviceKvStoreEnableSync002 enableSync success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreEnableSync002 enableSync fail ' + err); + expect(null).assertFail(); + }); + + }catch(e) { + console.log('testDeviceKvStoreEnableSync002 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreEnableSync003', 0, async function (done) { + console.log('testDeviceKvStoreEnableSync003'); + try { + await kvStore.enableSync().then((err) => { + console.log('testDeviceKvStoreEnableSync003 enableSync success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStoreEnableSync003 enableSync fail ' + err); + }); + }catch(e) { + console.log('testDeviceKvStoreEnableSync003 e ' + e); + } + done(); + }) + + it('testDeviceKvStoreEnableSync004', 0, async function (done) { + console.log('testDeviceKvStoreEnableSync004'); + try { + await kvStore.enableSync(null).then((err) => { + console.log('testDeviceKvStoreEnableSync004 enableSync success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStoreEnableSync004 enableSync fail ' + err); + }); + + }catch(e) { + console.log('testDeviceKvStoreEnableSync004 e ' + e); + } + done(); + }) + + it('testDeviceKvStoreRemoveDeviceData001', 0, async function (done) { + console.log('testDeviceKvStoreRemoveDeviceData001'); + try { + await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then((err) => { + console.log('testDeviceKvStoreRemoveDeviceData001 put success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreRemoveDeviceData001 put fail ' + err); + expect(null).assertFail(); + }); + + var deviceid = 'no_exist_device_id'; + await kvStore.removeDeviceData(deviceid).then((err) => { + console.log('testDeviceKvStoreRemoveDeviceData001 removeDeviceData success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStoreRemoveDeviceData001 removeDeviceData fail ' + err); + }); + + await kvStore.get(localDeviceId, KEY_TEST_STRING_ELEMENT).then((data) => { + console.log('testDeviceKvStoreRemoveDeviceData001 get success data:' + data); + expect(data == VALUE_TEST_STRING_ELEMENT).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreRemoveDeviceData001 get fail ' + err); + expect(null).assertFail(); + }); + + }catch(e) { + console.log('testDeviceKvStoreRemoveDeviceData001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreRemoveDeviceData002', 0, async function (done) { + console.log('testDeviceKvStoreRemoveDeviceData002'); + try { + await kvStore.removeDeviceData().then((err) => { + console.log('testDeviceKvStoreRemoveDeviceData002 removeDeviceData success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStoreRemoveDeviceData002 removeDeviceData fail ' + err); + }); + }catch(e) { + console.log('testDeviceKvStoreRemoveDeviceData002 e ' + e); + } + done(); + }) + + it('testDeviceKvStoreRemoveDeviceData003', 0, async function (done) { + console.log('testDeviceKvStoreRemoveDeviceData003'); + try { + await kvStore.removeDeviceData('').then((err) => { + console.log('testDeviceKvStoreRemoveDeviceData003 removeDeviceData success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStoreRemoveDeviceData003 removeDeviceData fail ' + err); + }); + }catch(e) { + console.log('testDeviceKvStoreRemoveDeviceData003 e ' + e); + } + done(); + }) + + it('testDeviceKvStoreRemoveDeviceData004', 0, async function (done) { + console.log('testDeviceKvStoreRemoveDeviceData004'); + try { + await kvStore.removeDeviceData(null).then((err) => { + console.log('testDeviceKvStoreRemoveDeviceData004 removeDeviceData success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStoreRemoveDeviceData004 removeDeviceData fail ' + err); + }); + }catch(e) { + console.log('testDeviceKvStoreRemoveDeviceData004 e ' + e); + } + done(); + }) + + it('testDeviceKvStoreGetResultSet001', 0, async function (done) { + console.log('testDeviceKvStoreGetResultSet001'); + try { + let resultSet; + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries).then(async (err) => { + console.log('testDeviceKvStoreGetResultSet001 putBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorePutBatch001 putBatch fail ' + err); + expect(null).assertFail(); + }); + await kvStore.getResultSet(localDeviceId, 'batch_test_string_key').then((result) => { + console.log('testDeviceKvStoreGetResultSet001 getResultSet success'); + resultSet = result; + expect(resultSet.getCount() == 10).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreGetResultSet001 getResultSet fail ' + err); + expect(null).assertFail(); + }); + await kvStore.closeResultSet(resultSet).then((err) => { + console.log('testDeviceKvStoreGetResultSet001 closeResultSet success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreGetResultSet001 closeResultSet fail ' + err); + expect(null).assertFail(); + }); + + }catch(e) { + console.log('testDeviceKvStoreGetResultSet001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreGetResultSet002', 0, async function (done) { + console.log('testDeviceKvStoreGetResultSet002'); + try { + let resultSet; + await kvStore.getResultSet(localDeviceId, 'batch_test_string_key').then((result) => { + console.log('testDeviceKvStoreGetResultSet002 getResultSet success'); + resultSet = result; + expect(resultSet.getCount() == 0).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreGetResultSet002 getResultSet fail ' + err); + expect(null).assertFail(); + }); + await kvStore.closeResultSet(resultSet).then((err) => { + console.log('testDeviceKvStoreGetResultSet002 closeResultSet success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreGetResultSet002 closeResultSet fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStoreGetResultSet002 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreGetResultSet003', 0, async function (done) { + console.log('testDeviceKvStoreGetResultSet003'); + try { + let resultSet; + await kvStore.getResultSet().then((result) => { + console.log('testDeviceKvStoreGetResultSet003 getResultSet success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStoreGetResultSet003 getResultSet fail ' + err); + + }); + }catch(e) { + console.log('testDeviceKvStoreGetResultSet003 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreGetResultSet004', 0, async function (done) { + console.log('testDeviceKvStoreGetResultSet004'); + try { + let resultSet; + await kvStore.getResultSet('test_key_string', 123).then((result) => { + console.log('testDeviceKvStoreGetResultSet004 getResultSet success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStoreGetResultSet004 getResultSet fail ' + err); + + }); + }catch(e) { + console.log('testDeviceKvStoreGetResultSet004 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreGetResultSet005', 0, async function (done) { + console.log('testDeviceKvStoreGetResultSet005'); + try { + let resultSet; + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries).then(async (err) => { + console.log('testDeviceKvStoreGetResultSet005 putBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorePutBatch001 putBatch fail ' + err); + expect(null).assertFail(); + }); + var query = new factory.Query(); + query.prefixKey("batch_test"); + await kvStore.getResultSet(localDeviceId, query).then((result) => { + console.log('testDeviceKvStoreGetResultSet005 getResultSet success'); + resultSet = result; + expect(resultSet.getCount() == 10).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreGetResultSet005 getResultSet fail ' + err); + expect(null).assertFail(); + }); + query.deviceId(localDeviceId); + console.log("testDeviceKvStoreGetResultSet005 " + query.getSqlLike()); + await kvStore.closeResultSet(resultSet).then((err) => { + console.log('testDeviceKvStoreGetResultSet005 closeResultSet success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreGetResultSet005 closeResultSet fail ' + err); + expect(null).assertFail(); + }); + + }catch(e) { + console.log('testDeviceKvStoreGetResultSet005 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreGetResultSet006', 0, async function (done) { + console.log('testDeviceKvStoreGetResultSet006'); + try { + let resultSet; + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries).then(async (err) => { + console.log('testDeviceKvStoreGetResultSet006 putBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorePutBatch001 putBatch fail ' + err); + expect(null).assertFail(); + }); + var query = new factory.Query(); + query.deviceId(localDeviceId); + query.prefixKey("batch_test"); + console.log("testDeviceKvStoreGetResultSet006 " + query.getSqlLike()); + await kvStore.getResultSet(query).then((result) => { + console.log('testDeviceKvStoreGetResultSet006 getResultSet success'); + resultSet = result; + expect(resultSet.getCount() == 10).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreGetResultSet006 getResultSet fail ' + err); + expect(null).assertFail(); + }); + await kvStore.closeResultSet(resultSet).then((err) => { + console.log('testDeviceKvStoreGetResultSet006 closeResultSet success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreGetResultSet006 closeResultSet fail ' + err); + expect(null).assertFail(); + }); + + }catch(e) { + console.log('testDeviceKvStoreGetResultSet006 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreCloseResultSet001', 0, async function (done) { + console.log('testDeviceKvStoreCloseResultSet001'); + try { + console.log('testDeviceKvStoreCloseResultSet001 success'); + let resultSet = null; + await kvStore.closeResultSet(resultSet).then(() => { + console.log('testDeviceKvStoreCloseResultSet001 closeResultSet success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStoreCloseResultSet001 closeResultSet fail ' + err); + }); + }catch(e) { + console.log('testDeviceKvStoreCloseResultSet001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreCloseResultSet002', 0, async function (done) { + console.log('testDeviceKvStoreCloseResultSet002'); + try { + console.log('testDeviceKvStoreCloseResultSet002 success'); + let resultSet = null; + await kvStore.getResultSet(localDeviceId, 'batch_test_string_key').then((result) => { + console.log('testDeviceKvStoreCloseResultSet002 getResultSet success'); + resultSet = result; + }).catch((err) => { + console.log('testDeviceKvStoreCloseResultSet002 getResultSet fail ' + err); + expect(null).assertFail(); + }); + await kvStore.closeResultSet(resultSet).then((err) => { + console.log('testDeviceKvStoreCloseResultSet002 closeResultSet success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreCloseResultSet002 closeResultSet fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStoreCloseResultSet002 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreCloseResultSet003', 0, async function (done) { + console.log('testDeviceKvStoreCloseResultSet003'); + try { + console.log('testDeviceKvStoreCloseResultSet003 success'); + let resultSet = null; + await kvStore.closeResultSet().then(() => { + console.log('testDeviceKvStoreCloseResultSet003 closeResultSet success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testDeviceKvStoreCloseResultSet003 closeResultSet fail ' + err); + }); + }catch(e) { + console.log('testDeviceKvStoreCloseResultSet003 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreCloseResultSet004', 0, async function (done) { + console.log('testDeviceKvStoreCloseResultSet004'); + try { + // pass query + console.log('testDeviceKvStoreCloseResultSet004 success'); + }catch(e) { + console.log('testDeviceKvStoreCloseResultSet004 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + + it('testDeviceKvStoreGetResultSize001', 0, async function (done) { + console.log('testDeviceKvStoreGetResultSize001'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries).then(async (err) => { + console.log('testDeviceKvStoreGetResultSize001 putBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorePutBatch001 putBatch fail ' + err); + expect(null).assertFail(); + }); + var query = new factory.Query(); + query.prefixKey("batch_test"); + query.deviceId(localDeviceId); + await kvStore.getResultSize(query).then((resultSize) => { + console.log('testDeviceKvStoreGetResultSize001 getResultSet success'); + expect(resultSize == 10).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreGetResultSize001 getResultSet fail ' + err); + expect(null).assertFail(); + }); + + }catch(e) { + console.log('testDeviceKvStoreGetResultSize001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreGetResultSize002', 0, async function (done) { + console.log('testDeviceKvStoreGetResultSize001'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries).then(async (err) => { + console.log('testDeviceKvStoreGetResultSize001 putBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStorePutBatch001 putBatch fail ' + err); + expect(null).assertFail(); + }); + var query = new factory.Query(); + query.prefixKey("batch_test"); + await kvStore.getResultSize(localDeviceId, query).then((resultSize) => { + console.log('testDeviceKvStoreGetResultSize001 getResultSet success'); + expect(resultSize == 10).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreGetResultSize001 getResultSet fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testDeviceKvStoreGetResultSize001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreGetEntries001', 0, async function (done) { + console.log('testDeviceKvStoreGetEntries001'); + try { + var arr = new Uint8Array([21,31]); + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_bool_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.BYTE_ARRAY, + value : arr + } + } + entries.push(entry); + } + console.log('testDeviceKvStoreGetEntries001 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testDeviceKvStoreGetEntries001 putBatch success'); + expect(err == undefined).assertTrue(); + var query = new factory.Query(); + query.deviceId(localDeviceId); + query.prefixKey("batch_test"); + await kvStore.getEntries(localDeviceId, query).then((entrys) => { + console.log('testDeviceKvStoreGetEntries001 getEntries success'); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value.toString() == arr.toString()).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreGetEntries001 getEntries fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStoreGetEntries001 putBatch fail ' + err); + expect(null).assertFail(); + }); + console.log('testDeviceKvStoreGetEntries001 success'); + }catch(e) { + console.log('testDeviceKvStoreGetEntries001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceKvStoreGetEntries002', 0, async function (done) { + console.log('testDeviceKvStoreGetEntries002'); + try { + var arr = new Uint8Array([21,31]); + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_bool_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.BYTE_ARRAY, + value : arr + } + } + entries.push(entry); + } + console.log('testDeviceKvStoreGetEntries002 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testDeviceKvStoreGetEntries002 putBatch success'); + expect(err == undefined).assertTrue(); + var query = new factory.Query(); + query.prefixKey("batch_test"); + query.deviceId(localDeviceId); + await kvStore.getEntries(query).then((entrys) => { + console.log('testDeviceKvStoreGetEntries002 getEntries success'); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value.toString() == arr.toString()).assertTrue(); + }).catch((err) => { + console.log('testDeviceKvStoreGetEntries002 getEntries fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testDeviceKvStoreGetEntries002 putBatch fail ' + err); + expect(null).assertFail(); + }); + console.log('testDeviceKvStoreGetEntries002 success'); + }catch(e) { + console.log('testDeviceKvStoreGetEntries002 e ' + e); + expect(null).assertFail(); + } + done(); + }) +}) \ No newline at end of file diff --git a/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/FieldNodeJsunit.test.js b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/FieldNodeJsunit.test.js new file mode 100644 index 0000000000000000000000000000000000000000..b5f5c7d2c46fa3790d3aeac1fac71fa1cbec4cdf --- /dev/null +++ b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/FieldNodeJsunit.test.js @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index' +import ddm from '@ohos.data.distributedData'; + +function sleep(ms) { + return new Promise(resolve => setTimeout(resolve, ms)); +} +describe('FieldNodeTest', function() { + + // appendChild(child: FieldNode): boolean + it('testAppendChild001', 0, async function(done) { + try { + let node = new ddm.FieldNode("root"); + let child1 = new ddm.FieldNode("child1"); + let child2 = new ddm.FieldNode("child2"); + let child3 = new ddm.FieldNode("child3"); + node.appendChild(child1); + node.appendChild(child2); + node.appendChild(child3); + console.log("appendNode " + node.toJson()); + child1 = null; + child2 = null; + child3 = null; + node = null; + } catch (e) { + console.log("testAppendChild001 " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testAppendChild002', 0, async function(done) { + try { + let node = new ddm.FieldNode("root"); + let child = new ddm.FieldNode("child"); + node.appendChild(child); + console.log("appendNode " + node.toJson()); + child = null; + node = null; + } catch (e) { + console.log("testAppendChild002 " + e); + } + done(); + }) + + it('testAppendChild003', 0, async function(done) { + try { + let node = new ddm.FieldNode("root"); + let child = new ddm.FieldNode(); + node.appendChild(child); + console.log("appendNode " + node.toJson()); + expect(null).assertFail(); + } catch (e) { + console.log("testAppendChild003 is ok :" + e); + } + done(); + }) + + // toJson(): string + it('testToJson001', 0, async function(done) { + try { + let node = new ddm.FieldNode("root"); + let child = new ddm.FieldNode("child"); + node.appendChild(child); + console.log("appendNode " + node.toJson()); + } catch (e) { + expect(null).assertFail(); + } + done(); + }) + + it('testToJson002', 0, async function(done) { + try { + let node = new ddm.FieldNode("root"); + let child = new ddm.FieldNode("child"); + node.appendChild(child); + console.log("appendNode " + node.toJson()); + } catch (e) { + expect(null).assertFail(); + } + done(); + }) + + it('testToJson003', 0, async function(done) { + try { + let node = new ddm.FieldNode(); + let child = new ddm.FieldNode(); + node.appendChild(child); + console.log("appendNode " + node.toJson()); + expect(null).assertFail(); + } catch (e) { + console.log("testToJson003 is ok : " + e); + } + done(); + }) +}) \ No newline at end of file diff --git a/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/KvManagerCallbackJsunit.test.js b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/KvManagerCallbackJsunit.test.js new file mode 100644 index 0000000000000000000000000000000000000000..41644620dcdc8905f05ddb4a3c7bf519c6b40cf5 --- /dev/null +++ b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/KvManagerCallbackJsunit.test.js @@ -0,0 +1,733 @@ +/* +* Copyright (c) 2021 Huawei Device Co., Ltd. +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' +import factory from '@ohos.data.distributedData'; + +const TEST_BUNDLE_NAME = 'ohos.acts.distributeddatamgr'; +const TEST_STORE_ID = 'storeId'; +var kvManager = null; +var kvStore = null; + +describe('KVManagerCallbackTest', function () { + const config = { + bundleName : TEST_BUNDLE_NAME, + userInfo : { + userId : '0', + userType : factory.UserType.SAME_USER_ID + } + } + + const options = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + + beforeAll(async function (done) { + console.log('beforeAll'); + await factory.createKVManager(config, function (err, manager) { + kvManager = manager; + done(); + }); + console.log('beforeAll end'); + }) + + afterAll(async function (done) { + console.log('afterAll'); + done(); + }) + + beforeEach(async function (done) { + console.log('beforeEach'); + done(); + }) + + afterEach(async function (done) { + console.log('afterEach'); + await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, kvStore, async function () { + console.log('afterEach closeKVStore success'); + await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, function () { + console.log('afterEach deleteKVStore success'); + done(); + }); + }); + }) + + it('testKVManagerGetKVStore101', 0, async function (done) { + console.log('testKVManagerGetKVStore101'); + try { + await kvManager.getKVStore(TEST_STORE_ID, options, function (err, store) { + console.log('testKVManagerGetKVStore101 getKVStore success'); + kvStore = store; + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore101 getKVStore e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerGetKVStore102', 0, async function (done) { + console.log('testKVManagerGetKVStore102'); + try { + await kvManager.getKVStore(options, function (err, store) { + if (err == undefined) { + console.log('testKVManagerGetKVStore102 getKVStore success'); + expect(null).assertFail(); + } else { + console.log('testKVManagerGetKVStore102 getKVStore fail'); + } + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore102 getKVStore e ' + e); + done(); + } + }) + + it('testKVManagerGetKVStore103', 0, async function (done) { + console.log('testKVManagerGetKVStore103'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + try { + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo, function (err, store) { + console.log('testKVManagerGetKVStore103 getKVStore success'); + console.log('testKVManagerGetKVStore103 err ' + err + ' store ' + store); + expect((err == undefined) && (store != null)).assertTrue(); + kvStore = store; + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore103 getKVStore e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerGetKVStore104', 0, async function (done) { + console.log('testKVManagerGetKVStore104'); + const optionsInfo = { + createIfMissing : false, // when false getkvstore error + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + try { + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo, function (err, store) { + if (err == undefined) { + console.log('testKVManagerGetKVStore104 getKVStore success'); + expect(null).assertFail(); + } else { + console.log('testKVManagerGetKVStore104 getKVStore fail'); + } + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore104 getKVStore e ' + e); + done(); + } + }) + + it('testKVManagerGetKVStore105', 0, async function (done) { + console.log('testKVManagerGetKVStore105'); + const optionsInfo = { + createIfMissing : true, + encrypt : true, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + try { + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo, function (err, store) { + console.log('testKVManagerGetKVStore105 getKVStore success'); + expect((err == undefined) && (store != null)).assertTrue(); + kvStore = store; + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore105 getKVStore e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerGetKVStore106', 0, async function (done) { + console.log('testKVManagerGetKVStore106'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + try { + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo, function (err, store) { + console.log('testKVManagerGetKVStore106 getKVStore success'); + expect((err == undefined) && (store != null)).assertTrue(); + kvStore = store; + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore106 getKVStore e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerGetKVStore107', 0, async function (done) { + console.log('testKVManagerGetKVStore107'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : true, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + try { + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo, function (err, store) { + console.log('testKVManagerGetKVStore107 getKVStore success'); + expect((err == undefined) && (store != null)).assertTrue(); + kvStore = store; + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore107 getKVStore e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerGetKVStore108', 0, async function (done) { + console.log('testKVManagerGetKVStore108'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + try { + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo, function (err, store) { + console.log('testKVManagerGetKVStore108 getKVStore success'); + expect((err == undefined) && (store != null)).assertTrue(); + kvStore = store; + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore108 getKVStore e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerGetKVStore109', 0, async function (done) { + console.log('testKVManagerGetKVStore109'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + try { + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo, function (err, store) { + console.log('testKVManagerGetKVStore109 getKVStore success'); + expect((err == undefined) && (store != null)).assertTrue(); + kvStore = store; + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore109 getKVStore e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerGetKVStore110', 0, async function (done) { + console.log('testKVManagerGetKVStore110'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : false, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + try { + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo, function (err, store) { + console.log('testKVManagerGetKVStore110 getKVStore success'); + expect((err == undefined) && (store != null)).assertTrue(); + kvStore = store; + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore110 getKVStore e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerGetKVStore111', 0, async function (done) { + console.log('testKVManagerGetKVStore111'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + try { + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo, function (err, store) { + console.log('testKVManagerGetKVStore111 getKVStore success'); + expect((err == undefined) && (store != null)).assertTrue(); + kvStore = store; + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore111 getKVStore e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerGetKVStore112', 0, async function (done) { + console.log('testKVManagerGetKVStore112'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.DEVICE_COLLABORATION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + try { + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo, function (err, store) { + console.log('testKVManagerGetKVStore112 getKVStore success'); + expect((err == undefined) && (store != null)).assertTrue(); + kvStore = store; + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore112 getKVStore e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerGetKVStore113', 0, async function (done) { + console.log('testKVManagerGetKVStore113'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.MULTI_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + try { + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo, function (err, store) { + if (err == undefined) { + console.log('testKVManagerGetKVStore113 getKVStore success'); + expect(null).assertFail(); + } else { + console.log('testKVManagerGetKVStore113 getKVStore fail'); + } + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore113 getKVStore e ' + e); + done(); + } + }) + + it('testKVManagerGetKVStore114', 0, async function (done) { + console.log('testKVManagerGetKVStore114'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.NO_LEVEL, + } + try { + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo, function (err, store) { + console.log('testKVManagerGetKVStore114 getKVStore success'); + expect((err == undefined) && (store != null)).assertTrue(); + kvStore = store; + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore114 getKVStore e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerGetKVStore115', 0, async function (done) { + console.log('testKVManagerGetKVStore115'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S0, + } + try { + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo, function (err, store) { + console.log('testKVManagerGetKVStore115 getKVStore success'); + expect((err == undefined) && (store != null)).assertTrue(); + kvStore = store; + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore115 getKVStore e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerGetKVStore116', 0, async function (done) { + console.log('testKVManagerGetKVStore116'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S1, + } + try { + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo, function (err, store) { + console.log('testKVManagerGetKVStore116 getKVStore success'); + expect((err == undefined) && (store != null)).assertTrue(); + kvStore = store; + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore116 getKVStore e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerGetKVStore117', 0, async function (done) { + console.log('testKVManagerGetKVStore117'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + try { + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo, function (err, store) { + console.log('testKVManagerGetKVStore117 getKVStore success'); + expect((err == undefined) && (store != null)).assertTrue(); + kvStore = store; + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore117 getKVStore e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerGetKVStore118', 0, async function (done) { + console.log('testKVManagerGetKVStore118'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S3, + } + try { + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo, function (err, store) { + console.log('testKVManagerGetKVStore118 getKVStore success'); + expect((err == undefined) && (store != null)).assertTrue(); + kvStore = store; + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore118 getKVStore e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerGetKVStore119', 0, async function (done) { + console.log('testKVManagerGetKVStore119'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S4, + } + try { + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo, function (err, store) { + console.log('testKVManagerGetKVStore119 getKVStore success'); + expect((err == undefined) && (store != null)).assertTrue(); + kvStore = store; + done(); + }); + } catch (e) { + console.log('testKVManagerGetKVStore119 getKVStore e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerCloseKVStore101', 0, async function (done) { + console.log('testKVManagerCloseKVStore101'); + try { + await kvManager.getKVStore(TEST_STORE_ID, options, async function (err, store) { + console.log('testKVManagerCloseKVStore101 getKVStore success'); + kvStore = store; + await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, kvStore, function (err, data) { + console.log('testKVManagerCloseKVStore101 closeKVStore success'); + expect((err == undefined) && (data == undefined)).assertTrue(); + done(); + }); + }); + } catch (e) { + console.log('testKVManagerCloseKVStore101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerCloseKVStore102', 0, async function (done) { + console.log('testKVManagerCloseKVStore102'); + try { + await kvManager.getKVStore(TEST_STORE_ID, options, async function (err, store) { + console.log('testKVManagerCloseKVStore102 getKVStore success'); + kvStore = store; + try { + await kvManager.closeKVStore(TEST_BUNDLE_NAME, function (err, data) { + if (err == undefined) { + console.log('testKVManagerCloseKVStore102 closeKVStore success'); + expect(null).assertFail(); + } else { + console.log('testKVManagerCloseKVStore102 closeKVStore fail'); + } + done(); + }); + } catch (e) { + console.log('testKVManagerCloseKVStore102 closeKVStore e ' + e); + done(); + } + }); + } catch (ee) { + console.log('testKVManagerCloseKVStore102 getKVStore ee ' + ee); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerCloseKVStore103', 0, async function (done) { + console.log('testKVManagerCloseKVStore103'); + try { + await kvManager.getKVStore(TEST_STORE_ID, options, async function (err, store) { + console.log('testKVManagerCloseKVStore103 getKVStore success'); + kvStore = store; + try { + await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, function (err, data) { + if (err == undefined) { + console.log('testKVManagerCloseKVStore103 closeKVStore success'); + expect(null).assertFail(); + } else { + console.log('testKVManagerCloseKVStore103 closeKVStore fail'); + } + done(); + }); + } catch (e) { + console.log('testKVManagerCloseKVStore103 closeKVStore e ' + e); + done(); + } + }); + } catch (ee) { + console.log('testKVManagerCloseKVStore103 getKVStore ee ' + ee); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerCloseKVStore104', 0, async function (done) { + console.log('testKVManagerCloseKVStore104'); + try { + await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, kvStore, function (err, data) { + console.log('testKVManagerCloseKVStore104 closeKVStore success'); + expect((err == undefined) && (data == undefined)).assertTrue(); + done(); + }); + } catch (e) { + console.log('testKVManagerCloseKVStore104 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerDeleteKVStore101', 0, async function (done) { + console.log('testKVManagerDeleteKVStore101'); + try { + await kvManager.getKVStore(TEST_STORE_ID, options, async function (err, store) { + console.log('testKVManagerDeleteKVStore101 getKVStore success'); + kvStore = store; + await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, function (err, data) { + console.log('testKVManagerDeleteKVStore101 deleteKVStore success'); + expect((err == undefined) && (data == undefined)).assertTrue(); + done(); + }); + }); + } catch (e) { + console.log('testKVManagerDeleteKVStore101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerDeleteKVStore102', 0, async function (done) { + console.log('testKVManagerDeleteKVStore102'); + try { + await kvManager.getKVStore(TEST_STORE_ID, options, async function (err, store) { + console.log('testKVManagerDeleteKVStore102 getKVStore success'); + kvStore = store; + try { + await kvManager.deleteKVStore(TEST_BUNDLE_NAME, function (err, data) { + if (err == undefined) { + console.log('testKVManagerDeleteKVStore102 deleteKVStore success'); + expect(null).assertFail(); + } else { + console.log('testKVManagerDeleteKVStore102 deleteKVStore fail'); + } + done(); + }); + } catch (e) { + console.log('testKVManagerDeleteKVStore102 deleteKVStore e ' + e); + done(); + } + }); + } catch (ee) { + console.log('testKVManagerDeleteKVStore102 getKVStore ee ' + ee); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerDeleteKVStore103', 0, async function (done) { + console.log('testKVManagerDeleteKVStore103'); + try { + await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, function (err, data) { + if (err == undefined){ + console.log('testKVManagerDeleteKVStore103 deleteKVStore success'); + expect(null).assertFail(); + } else { + console.log('testKVManagerDeleteKVStore103 deleteKVStore fail'); + } + done(); + }); + } catch (e) { + console.log('testKVManagerDeleteKVStore103 e ' + e); + done(); + } + }) + + it('testKVManagerGetAllKVStoreId101', 0, async function (done) { + console.log('testKVManagerGetAllKVStoreId101'); + try { + await kvManager.getAllKVStoreId(TEST_BUNDLE_NAME, function (err, data) { + console.log('testKVManagerGetAllKVStoreId101 getAllKVStoreId success'); + console.log('testKVManagerGetAllKVStoreId101 size = ' + data.length); + expect(0).assertEqual(data.length); + done(); + }); + } catch (e) { + console.log('testKVManagerGetAllKVStoreId101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testKVManagerGetAllKVStoreId102', 0, async function (done) { + console.log('testKVManagerGetAllKVStoreId102'); + try { + await kvManager.getKVStore(TEST_STORE_ID, options, async function (err, store) { + console.log('testKVManagerGetAllKVStoreId102 getKVStore success'); + kvStore = store; + try { + await kvManager.getAllKVStoreId(TEST_BUNDLE_NAME, function (err, data) { + console.log('testKVManagerGetAllKVStoreId102 getAllKVStoreId success'); + console.log('testKVManagerGetAllKVStoreId102 size = ' + data.length); + expect(1).assertEqual(data.length); + console.log('testKVManagerGetAllKVStoreId102 data[0] = ' + data[0]); + expect(TEST_STORE_ID).assertEqual(data[0]); + done(); + }); + } catch (e) { + console.log('testKVManagerGetAllKVStoreId102 getAllKVStoreId e ' + e); + expect(null).assertFail(); + done(); + } + }); + } catch (ee) { + console.log('testKVManagerGetAllKVStoreId102 getKVStore ee ' + ee); + expect(null).assertFail(); + done(); + } + }) +}) \ No newline at end of file diff --git a/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/KvManagerPromiseJsunit.test.js b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/KvManagerPromiseJsunit.test.js new file mode 100644 index 0000000000000000000000000000000000000000..853742c7c15bb55602c35111de7a7309d7160cca --- /dev/null +++ b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/KvManagerPromiseJsunit.test.js @@ -0,0 +1,731 @@ +/* +* Copyright (c) 2021 Huawei Device Co., Ltd. +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' +import factory from '@ohos.data.distributedData'; + +const TEST_BUNDLE_NAME = 'ohos.acts.distributeddatamgr'; +const TEST_STORE_ID = 'storeId'; +var kvManager = null; +var kvStore = null; + +describe('KVManagerPromiseTest', function () { + const config = { + bundleName : TEST_BUNDLE_NAME, + userInfo : { + userId : '0', + userType : factory.UserType.SAME_USER_ID + } + } + + const options = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + + beforeAll(async function (done) { + console.log('beforeAll'); + await factory.createKVManager(config).then((manager) => { + kvManager = manager; + console.log('beforeAll createKVManager success'); + }).catch((err) => { + console.log('beforeAll createKVManager err ' + err); + }); + console.log('beforeAll end'); + done(); + }) + + afterAll(async function (done) { + console.log('afterAll'); + done(); + }) + + beforeEach(async function (done) { + console.log('beforeEach'); + done(); + }) + + afterEach(async function (done) { + console.log('afterEach'); + await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, kvStore).then(async () => { + console.log('afterEach closeKVStore success'); + await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { + console.log('afterEach deleteKVStore success'); + }).catch((err) => { + console.log('afterEach deleteKVStore err ' + err); + }); + }).catch((err) => { + console.log('afterEach closeKVStore err ' + err); + }); + done(); + }) + + it('testKVManagerGetKVStore001', 0, async function (done) { + console.log('testKVManagerGetKVStore001'); + try { + await kvManager.getKVStore(TEST_STORE_ID).then((store) => { + console.log('testKVManagerGetKVStore001 getKVStore success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testKVManagerGetKVStore001 getKVStore err ' + err); + }); + }catch(e) { + console.log('testKVManagerGetKVStore001 getKVStore e ' + e); + } + done(); + }) + + it('testKVManagerGetKVStore002', 0, async function (done) { + console.log('testKVManagerGetKVStore002'); + try { + await kvManager.getKVStore(options).then((store) => { + console.log('testKVManagerGetKVStore002 getKVStore success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testKVManagerGetKVStore002 getKVStore err ' + err); + }); + }catch(e) { + console.log('testKVManagerGetKVStore002 getKVStore e ' + e); + } + done(); + }) + + it('testKVManagerGetKVStore003', 0, async function (done) { + console.log('testKVManagerGetKVStore003'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => { + console.log('testKVManagerGetKVStore003 getKVStore success'); + kvStore = store; + expect(store != null).assertTrue(); + }).catch((err) => { + console.log('testKVManagerGetKVStore003 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerGetKVStore004', 0, async function (done) { + console.log('testKVManagerGetKVStore004'); + const optionsInfo = { + createIfMissing : false, // when false getkvstore error + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => { + console.log('testKVManagerGetKVStore004 getKVStore success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testKVManagerGetKVStore004 getKVStore err ' + err); + }); + done(); + }) + + it('testKVManagerGetKVStore005', 0, async function (done) { + console.log('testKVManagerGetKVStore005'); + const optionsInfo = { + createIfMissing : true, + encrypt : true, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => { + console.log('testKVManagerGetKVStore005 getKVStore success'); + kvStore = store; + expect(store != null).assertTrue(); + }).catch((err) => { + console.log('testKVManagerGetKVStore005 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerGetKVStore006', 0, async function (done) { + console.log('testKVManagerGetKVStore006'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => { + console.log('testKVManagerGetKVStore006 getKVStore success'); + kvStore = store; + expect(store != null).assertTrue(); + }).catch((err) => { + console.log('testKVManagerGetKVStore006 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerGetKVStore007', 0, async function (done) { + console.log('testKVManagerGetKVStore006'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : true, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => { + console.log('testKVManagerGetKVStore007 getKVStore success'); + kvStore = store; + expect(store != null).assertTrue(); + }).catch((err) => { + console.log('testKVManagerGetKVStore007 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerGetKVStore008', 0, async function (done) { + console.log('testKVManagerGetKVStore008'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => { + console.log('testKVManagerGetKVStore008 getKVStore success'); + kvStore = store; + expect(store != null).assertTrue(); + }).catch((err) => { + console.log('testKVManagerGetKVStore008 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerGetKVStore009', 0, async function (done) { + console.log('testKVManagerGetKVStore009'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => { + console.log('testKVManagerGetKVStore009 getKVStore success'); + kvStore = store; + expect(store != null).assertTrue(); + }).catch((err) => { + console.log('testKVManagerGetKVStore009 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerGetKVStore010', 0, async function (done) { + console.log('testKVManagerGetKVStore010'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : false, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => { + console.log('testKVManagerGetKVStore010 getKVStore success'); + kvStore = store; + expect(store != null).assertTrue(); + }).catch((err) => { + console.log('testKVManagerGetKVStore010 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerGetKVStore011', 0, async function (done) { + console.log('testKVManagerGetKVStore011'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => { + console.log('testKVManagerGetKVStore011 getKVStore success'); + kvStore = store; + expect(store != null).assertTrue(); + }).catch((err) => { + console.log('testKVManagerGetKVStore011 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerGetKVStore012', 0, async function (done) { + console.log('testKVManagerGetKVStore012'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.DEVICE_COLLABORATION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => { + console.log('testKVManagerGetKVStore012 getKVStore success'); + kvStore = store; + expect(store != null).assertTrue(); + }).catch((err) => { + console.log('testKVManagerGetKVStore012 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerGetKVStore013', 0, async function (done) { + console.log('testKVManagerGetKVStore013'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.MULTI_VERSION, // unsupport MULTI_VERSION + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + try { + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => { + console.log('testKVManagerGetKVStore013 getKVStore success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testKVManagerGetKVStore013 getKVStore err ' + err); + }); + }catch(e) { + console.log('testKVManagerGetKVStore013 getKVStore e ' + e); + } + done(); + }) + + it('testKVManagerGetKVStore014', 0, async function (done) { + console.log('testKVManagerGetKVStore014'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.NO_LEVEL, + } + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => { + console.log('testKVManagerGetKVStore014 getKVStore success'); + kvStore = store; + expect(store != null).assertTrue(); + }).catch((err) => { + console.log('testKVManagerGetKVStore014 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerGetKVStore015', 0, async function (done) { + console.log('testKVManagerGetKVStore015'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S0, + } + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => { + console.log('testKVManagerGetKVStore015 getKVStore success'); + kvStore = store; + expect(store != null).assertTrue(); + }).catch((err) => { + console.log('testKVManagerGetKVStore015 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerGetKVStore016', 0, async function (done) { + console.log('testKVManagerGetKVStore016'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S1, + } + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => { + console.log('testKVManagerGetKVStore016 getKVStore success'); + kvStore = store; + expect(store != null).assertTrue(); + }).catch((err) => { + console.log('testKVManagerGetKVStore016 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerGetKVStore017', 0, async function (done) { + console.log('testKVManagerGetKVStore017'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => { + console.log('testKVManagerGetKVStore017 getKVStore success'); + kvStore = store; + expect(store != null).assertTrue(); + }).catch((err) => { + console.log('testKVManagerGetKVStore017 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerGetKVStore018', 0, async function (done) { + console.log('testKVManagerGetKVStore018'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S3, + } + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => { + console.log('testKVManagerGetKVStore018 getKVStore success'); + kvStore = store; + expect(store != null).assertTrue(); + }).catch((err) => { + console.log('testKVManagerGetKVStore018 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerGetKVStore019', 0, async function (done) { + console.log('testKVManagerGetKVStore019'); + const optionsInfo = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S4, + } + await kvManager.getKVStore(TEST_STORE_ID, optionsInfo).then((store) => { + console.log('testKVManagerGetKVStore019 getKVStore success'); + kvStore = store; + expect(store != null).assertTrue(); + }).catch((err) => { + console.log('testKVManagerGetKVStore019 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerCloseKVStore001', 0, async function (done) { + console.log('testKVManagerCloseKVStore001'); + await kvManager.getKVStore(TEST_STORE_ID, options).then(async (store) => { + console.log('testKVManagerCloseKVStore001 getKVStore success'); + kvStore = store; + await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, kvStore).then(() => { + console.log('testKVManagerCloseKVStore001 closeKVStore success'); + }).catch((err) => { + console.log('testKVManagerCloseKVStore001 closeKVStore err ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testKVManagerCloseKVStore001 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerCloseKVStore002', 0, async function (done) { + console.log('testKVManagerCloseKVStore002'); + await kvManager.getKVStore(TEST_STORE_ID, options).then(async (store) => { + console.log('testKVManagerCloseKVStore002 getKVStore success'); + kvStore = store; + try { + await kvManager.closeKVStore(TEST_BUNDLE_NAME).then(() => { + console.log('testKVManagerCloseKVStore002 closeKVStore success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testKVManagerCloseKVStore002 closeKVStore err ' + err); + }); + }catch(e) { + console.log('testKVManagerCloseKVStore002 closeKVStore e ' + e); + } + }).catch((err) => { + console.log('testKVManagerCloseKVStore002 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerCloseKVStore003', 0, async function (done) { + console.log('testKVManagerCloseKVStore003'); + await kvManager.getKVStore(TEST_STORE_ID, options).then(async (store) => { + console.log('testKVManagerCloseKVStore003 getKVStore success'); + kvStore = store; + try { + await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { + console.log('testKVManagerCloseKVStore003 closeKVStore success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testKVManagerCloseKVStore003 closeKVStore err ' + err); + }); + }catch(e) { + console.log('testKVManagerCloseKVStore003 closeKVStore e ' + e); + } + }).catch((err) => { + console.log('testKVManagerCloseKVStore003 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerCloseKVStore004', 0, async function (done) { + console.log('testKVManagerCloseKVStore004'); + await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, kvStore).then(() => { + console.log('testKVManagerCloseKVStore004 closeKVStore success'); + }).catch((err) => { + console.log('testKVManagerCloseKVStore004 closeKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerDeleteKVStore001', 0, async function (done) { + console.log('testKVManagerDeleteKVStore001'); + await kvManager.getKVStore(TEST_STORE_ID, options).then(async (store) => { + console.log('testKVManagerDeleteKVStore001 getKVStore success'); + kvStore = store; + await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { + console.log('testKVManagerDeleteKVStore001 deleteKVStore success'); + }).catch((err) => { + console.log('testKVManagerDeleteKVStore001 deleteKVStore err ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testKVManagerDeleteKVStore001 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerDeleteKVStore002', 0, async function (done) { + console.log('testKVManagerDeleteKVStore002'); + await kvManager.getKVStore(TEST_STORE_ID, options).then(async (store) => { + console.log('testKVManagerDeleteKVStore002 getKVStore success'); + kvStore = store; + try { + await kvManager.deleteKVStore(TEST_BUNDLE_NAME).then(() => { + console.log('testKVManagerDeleteKVStore002 deleteKVStore success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testKVManagerDeleteKVStore002 deleteKVStore err ' + err); + }); + }catch(e){ + console.log('testKVManagerDeleteKVStore002 deleteKVStore e ' + e); + } + }).catch((err) => { + console.log('testKVManagerDeleteKVStore002 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerDeleteKVStore003', 0, async function (done) { + console.log('testKVManagerDeleteKVStore003'); + await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { + console.log('testKVManagerDeleteKVStore003 deleteKVStore success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testKVManagerDeleteKVStore003 deleteKVStore err ' + err); + }); + done(); + }) + + it('testKVManagerGetAllKVStoreId001', 0, async function (done) { + console.log('testKVManagerGetAllKVStoreId001'); + await kvManager.getAllKVStoreId(TEST_BUNDLE_NAME).then((data) => { + console.log('testKVManagerGetAllKVStoreId001 getAllKVStoreId success'); + console.log('testKVManagerGetAllKVStoreId001 size = ' + data.length); + expect(0).assertEqual(data.length); + }).catch((err) => { + console.log('testKVManagerGetAllKVStoreId001 getAllKVStoreId err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerGetAllKVStoreId002', 0, async function (done) { + console.log('testKVManagerGetAllKVStoreId002'); + await kvManager.getKVStore(TEST_STORE_ID, options).then(async (store) => { + console.log('testKVManagerGetAllKVStoreId002 getKVStore success'); + kvStore = store; + await kvManager.getAllKVStoreId(TEST_BUNDLE_NAME).then((data) => { + console.log('testKVManagerGetAllKVStoreId002 getAllKVStoreId success'); + console.log('testKVManagerGetAllKVStoreId002 size = ' + data.length); + expect(1).assertEqual(data.length); + console.log('testKVManagerGetAllKVStoreId002 data[0] = ' + data[0]); + expect(TEST_STORE_ID).assertEqual(data[0]); + }).catch((err) => { + console.log('testKVManagerGetAllKVStoreId002 getAllKVStoreId err ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testKVManagerGetAllKVStoreId002 getKVStore err ' + err); + expect(null).assertFail(); + }); + done(); + }) + + it('testKVManagerOn001', 0, function (done) { + console.log('testKVManagerOn001'); + var deathCallback = function () { + console.log('death callback call'); + } + kvManager.on('distributedDataServiceDie', deathCallback); + kvManager.off('distributedDataServiceDie', deathCallback); + done(); + }) + + it('testKVManagerOn002', 0, function (done) { + console.log('testKVManagerOn002'); + var deathCallback1 = function () { + console.log('death callback call'); + } + var deathCallback2 = function () { + console.log('death callback call'); + } + kvManager.on('distributedDataServiceDie', deathCallback1); + kvManager.on('distributedDataServiceDie', deathCallback2); + kvManager.off('distributedDataServiceDie', deathCallback1); + kvManager.off('distributedDataServiceDie', deathCallback2); + done(); + }) + + it('testKVManagerOn003', 0, function (done) { + console.log('testKVManagerOn003'); + var deathCallback = function () { + console.log('death callback call'); + } + kvManager.on('distributedDataServiceDie', deathCallback); + kvManager.on('distributedDataServiceDie', deathCallback); + kvManager.off('distributedDataServiceDie', deathCallback); + done(); + }) + + it('testKVManagerOff001', 0, function (done) { + console.log('testKVManagerOff001'); + var deathCallback = function () { + console.log('death callback call'); + } + kvManager.off('distributedDataServiceDie', deathCallback); + done(); + }) + + it('testKVManagerOff002', 0, function (done) { + console.log('testKVManagerOff002'); + var deathCallback = function () { + console.log('death callback call'); + } + kvManager.on('distributedDataServiceDie', deathCallback); + kvManager.off('distributedDataServiceDie', deathCallback); + done(); + }) + + it('testKVManagerOff003', 0, function (done) { + console.log('testKVManagerOff003'); + var deathCallback1 = function () { + console.log('death callback call'); + } + var deathCallback2 = function () { + console.log('death callback call'); + } + kvManager.on('distributedDataServiceDie', deathCallback1); + kvManager.on('distributedDataServiceDie', deathCallback2); + kvManager.off('distributedDataServiceDie', deathCallback1); + done(); + }) + + it('testKVManagerOff004', 0, function (done) { + console.log('testKVManagerOff004'); + var deathCallback = function () { + console.log('death callback call'); + } + kvManager.on('distributedDataServiceDie', deathCallback); + kvManager.off('distributedDataServiceDie', deathCallback); + kvManager.off('distributedDataServiceDie', deathCallback); + done(); + }) + + it('testKVManagerOff005', 0, function (done) { + console.log('testKVManagerOff001'); + var deathCallback = function () { + console.log('death callback call'); + } + kvManager.on('distributedDataServiceDie', deathCallback); + kvManager.off('distributedDataServiceDie'); + done(); + }) +}) \ No newline at end of file diff --git a/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/KvStoreResultSetJsunit.test.js b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/KvStoreResultSetJsunit.test.js new file mode 100644 index 0000000000000000000000000000000000000000..3c4636ac453ec6117d6480ad001a33b90db3f5aa --- /dev/null +++ b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/KvStoreResultSetJsunit.test.js @@ -0,0 +1,828 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index' +import factory from '@ohos.data.distributedData' + +const TEST_BUNDLE_NAME = 'ohos.acts.distributeddatamgr'; +const TEST_STORE_ID = 'storeId'; +var kvManager = null; +var kvStore = null; +var resultSet = null; + +describe('KvStoreResultSetTest', function() { + const config = { + bundleName : TEST_BUNDLE_NAME, + userInfo : { + userId : '0', + userType : factory.UserType.SAME_USER_ID + } + } + + const options = { + createIfMissing : true, + encrypt : false, + backup : false, + autoSync : true, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, + schema : '', + securityLevel : factory.SecurityLevel.S2, + } + + beforeAll(async function (done) { + console.log('beforeAll'); + console.log('beforeAll config:' + JSON.stringify(config)); + await factory.createKVManager(config).then((manager) => { + kvManager = manager; + console.log('beforeAll createKVManager success'); + }).catch((err) => { + console.log('beforeAll createKVManager err ' + err); + }); + await kvManager.getAllKVStoreId(TEST_BUNDLE_NAME).then(async (data) => { + console.log('beforeAll getAllKVStoreId size = ' + data.length); + for (var i = 0; i < data.length; i++) { + await kvManager.deleteKVStore(TEST_BUNDLE_NAME, data[i]).then(() => { + console.log('beforeAll deleteKVStore success ' + data[i]); + }).catch((err) => { + console.log('beforeAll deleteKVStore store: ' + data[i]); + console.log('beforeAll deleteKVStore error ' + err); + }); + } + }).catch((err) => { + console.log('beforeAll getAllKVStoreId err ' + err); + }); + + console.log('beforeAll end'); + done(); + }) + + afterAll(async function (done) { + console.log('afterAll'); + kvManager = null; + kvStore = null; + done(); + }) + + beforeEach(async function (done) { + console.log('beforeEach'); + await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { + kvStore = store; + console.log('beforeEach getKVStore success'); + }).catch((err) => { + console.log('beforeEach getKVStore err ' + err); + }); + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries).then(async (err) => { + console.log('beforeEach putBatch success'); + }).catch((err) => { + console.log('beforeEach putBatch fail ' + err); + }); + await kvStore.getResultSet('batch_test_string_key').then((result) => { + console.log('beforeEach getResultSet success'); + resultSet = result; + }).catch((err) => { + console.log('beforeEach getResultSet fail ' + err); + }); + console.log('beforeEach end'); + done(); + }) + + afterEach(async function (done) { + console.log('afterEach'); + await kvStore.closeResultSet(resultSet).then((err) => { + console.log('afterEach closeResultSet success'); + }).catch((err) => { + console.log('afterEach closeResultSet fail ' + err); + }); + await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, kvStore).then(async () => { + console.log('afterEach closeKVStore success'); + await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { + console.log('afterEach deleteKVStore success'); + kvStore = null; + }).catch((err) => { + console.log('afterEach deleteKVStore err ' + err); + }); + }).catch((err) => { + console.log('afterEach closeKVStore err ' + err); + }); + done(); + }) + + // getCount(): number; + it('testKvStoreResultSetGetCount001', 0, async function(done) { + try { + var count = resultSet.getCount(); + console.log("testKvStoreResultSetGetCount001 getCount " + count); + expect(count == 10).assertTrue(); + } catch (e) { + console.log("testKvStoreResultSetGetCount001 fail " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testKvStoreResultSetGetCount002', 0, async function(done) { + try { + var rs; + await kvStore.getResultSet('test').then((result) => { + console.log('testKvStoreResultSetGetCount002 getResultSet success'); + rs = result; + expect(rs.getCount() == 0).assertTrue(); + }).catch((err) => { + console.log('testKvStoreResultSetGetCount002 getResultSet fail ' + err); + expect(null).assertFail(); + }); + await kvStore.closeResultSet(rs).then((err) => { + console.log('testKvStoreResultSetGetCount002 closeResultSet success'); + }).catch((err) => { + console.log('testKvStoreResultSetGetCount002 closeResultSet fail ' + err); + expect(null).assertFail(); + }); + } catch (e) { + console.log('testKvStoreResultSetGetCount002 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testKvStoreResultSetGetCount003', 0, async function(done) { + try { + var count = resultSet.getCount(123); + console.log("testKvStoreResultSetGetCount003 getCount " + count); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetGetCount003 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetGetCount004', 0, async function(done) { + try { + var count = resultSet.getCount(123, 'test_string'); + console.log("testKvStoreResultSetGetCount004 getCount " + count); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetGetCount004 fail " + e); + } + done(); + }) + + // getPosition(): number; + it('testKvStoreResultSetGetPosition001', 0, async function(done) { + try { + var positon = resultSet.getPosition(); + console.log("testKvStoreResultSetGetPosition001 getPosition " + positon); + expect(positon == -1).assertTrue(); + } catch (e) { + console.log("testKvStoreResultSetGetPosition001 fail " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testKvStoreResultSetGetPosition002', 0, async function(done) { + try { + var positon = resultSet.getPosition(); + console.log("testKvStoreResultSetGetPosition002 getPosition " + positon); + expect(positon).assertEqual(-1); + var flag = resultSet.moveToLast(); + expect(flag).assertTrue(); + positon = resultSet.getPosition(); + expect(positon).assertEqual(9); + } catch (e) { + console.log("testKvStoreResultSetGetPosition002 fail " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testKvStoreResultSetGetPosition003', 0, async function(done) { + try { + var positon = resultSet.getPosition(123); + console.log("testKvStoreResultSetGetPosition003 getPosition " + positon); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetGetPosition003 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetGetPosition004', 0, async function(done) { + try { + var positon = resultSet.getPosition(123, 'test_string'); + console.log("testKvStoreResultSetGetPosition004 getPosition " + positon); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetGetPosition004 fail " + e); + } + done(); + }) + + // moveToFirst(): boolean; + it('testKvStoreResultSetMoveToFirst001', 0, async function(done) { + try { + var moved = resultSet.moveToFirst(); + console.log("testKvStoreResultSetMoveToFirst001 moveToFirst " + moved); + expect(moved).assertTrue(); + } catch (e) { + expect(null).assertFail(); + console.log("testKvStoreResultSetMoveToFirst001 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetMoveToFirst002', 0, async function(done) { + try { + var moved = resultSet.moveToFirst(); + console.log("testKvStoreResultSetMoveToFirst002 moveToFirst " + moved); + expect(moved).assertTrue(); + var pos = resultSet.getPosition(); + console.log("testKvStoreResultSetMoveToFirst002 getPosition " + pos); + expect(pos == 0).assertTrue(); + } catch (e) { + expect(null).assertFail(); + console.log("testKvStoreResultSetMoveToFirst002 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetMoveToFirst003', 0, async function(done) { + try { + var moved = resultSet.moveToFirst(123); + console.log("testKvStoreResultSetMoveToFirst003 moveToFirst " + moved); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetMoveToFirst003 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetMoveToFirst004', 0, async function(done) { + try { + var moved = resultSet.moveToFirst(123, 'test_string'); + console.log("testKvStoreResultSetMoveToFirst004 moveToFirst " + moved); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetMoveToFirst004 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetMoveToFirst005', 0, async function(done) { + try { + var moved = resultSet.moveToLast(); + console.log("testKvStoreResultSetMoveToFirst004 moveToFirst " + moved); + expect(moved && (resultSet.getPosition() == 9)).assertTrue(); + moved = resultSet.moveToFirst(); + expect(moved && (resultSet.getPosition() == 0)).assertTrue(); + } catch (e) { + console.log("testKvStoreResultSetMoveToFirst004 fail " + e); + } + done(); + }) + + // moveToLast(): boolean; + it('testKvStoreResultSetMoveToLast001', 0, async function(done) { + try { + var moved = resultSet.moveToLast(); + console.log("testKvStoreResultSetMoveToLast001 moveToLast " + moved); + expect(moved).assertTrue(); + } catch (e) { + expect(null).assertFail(); + console.log("testKvStoreResultSetMoveToLast001 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetMoveToLast002', 0, async function(done) { + try { + var moved = resultSet.moveToLast(); + console.log("testKvStoreResultSetMoveToLast002 moveToLast " + moved); + expect(moved && (resultSet.getPosition() == 9)).assertTrue(); + } catch (e) { + expect(null).assertFail(); + console.log("testKvStoreResultSetMoveToLast002 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetMoveToLast003', 0, async function(done) { + try { + var moved = resultSet.moveToLast(123); + console.log("testKvStoreResultSetMoveToLast003 moveToLast " + moved); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetMoveToLast003 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetMoveToLast004', 0, async function(done) { + try { + var moved = resultSet.moveToLast(123, 'test_string'); + console.log("testKvStoreResultSetMoveToLast004 moveToLast " + moved); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetMoveToLast004 fail " + e); + } + done(); + }) + + // moveToNext(): boolean; + it('testKvStoreResultSetMoveToNext001', 0, async function(done) { + try { + var moved = resultSet.moveToNext(); + console.log("testKvStoreResultSetMoveToNext001 moveToNext " + moved); + expect(moved && (resultSet.getPosition() == 0)).assertTrue(); + } catch (e) { + expect(null).assertFail(); + console.log("testKvStoreResultSetMoveToNext001 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetMoveToNext002', 0, async function(done) { + try { + var moved = resultSet.moveToNext(); + console.log("testKvStoreResultSetMoveToNext002 moveToNext " + moved); + expect(moved && (resultSet.getPosition() == 0)).assertTrue(); + moved = resultSet.moveToNext(); + expect(moved && (resultSet.getPosition() == 1)).assertTrue(); + } catch (e) { + expect(null).assertFail(); + console.log("testKvStoreResultSetMoveToNext002 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetMoveToNext003', 0, async function(done) { + try { + var moved = resultSet.moveToNext(123); + console.log("testKvStoreResultSetMoveToNext003 moveToNext " + moved); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetMoveToNext003 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetMoveToNext004', 0, async function(done) { + try { + var moved = resultSet.moveToNext(123, 'test_string'); + console.log("testKvStoreResultSetMoveToNext004 moveToNext " + moved); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetMoveToNext004 fail " + e); + } + done(); + }) + + // moveToPrevious(): boolean; + it('testKvStoreResultSetMoveToPrevious001', 0, async function(done) { + try { + var moved = resultSet.moveToPrevious(); + console.log("testKvStoreResultSetMoveToPrevious001 moveToPrevious " + moved); + expect(!moved).assertTrue(); + } catch (e) { + expect(null).assertFail(); + console.log("testKvStoreResultSetMoveToPrevious001 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetMoveToPrevious002', 0, async function(done) { + try { + var moved = resultSet.moveToFirst(); + expect(moved && (resultSet.getPosition() == 0)).assertTrue(); + moved = resultSet.moveToNext(); + console.log("testKvStoreResultSetMoveToPrevious002 moveToNext " + moved); + expect(moved && (resultSet.getPosition() == 1)).assertTrue(); + moved = resultSet.moveToPrevious(); + console.log("testKvStoreResultSetMoveToPrevious002 moveToPrevious " + moved); + expect(moved && (resultSet.getPosition() == 0)).assertTrue(); + } catch (e) { + console.log("testKvStoreResultSetMoveToPrevious002 fail " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testKvStoreResultSetMoveToPrevious003', 0, async function(done) { + try { + var moved = resultSet.moveToPrevious(123); + console.log("testKvStoreResultSetMoveToPrevious003 moveToPrevious " + moved); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetMoveToPrevious003 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetMoveToPrevious004', 0, async function(done) { + try { + var moved = resultSet.moveToPrevious(123, 'test_string'); + console.log("testKvStoreResultSetMoveToPrevious004 moveToPrevious " + moved); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetMoveToPrevious004 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetMoveToPrevious005', 0, async function(done) { + try { + var moved = resultSet.moveToFirst(); + expect(moved && (resultSet.getPosition() == 0)).assertTrue(); + moved = resultSet.moveToPrevious(); + console.log("testKvStoreResultSetMoveToPrevious005 from 0 to -1 return" + moved); + expect(moved).assertFalse(); + console.log("testKvStoreResultSetMoveToPrevious005 from 0 to " + resultSet.getPosition()); + expect(-1).assertEqual(resultSet.getPosition()); + } catch (e) { + console.log("testKvStoreResultSetMoveToPrevious005 fail " + e); + expect(null).assertTrue(); + } + done(); + }) + // move(offset: number): boolean; + it('testKvStoreResultSetMove001', 0, async function(done) { + try { + var moved = resultSet.move(); + console.log("testKvStoreResultSetMove001 move " + moved); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetMove001 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetMove002', 0, async function(done) { + try { + resultSet.moveToFirst(); + expect(resultSet.getPosition() == 0).assertTrue(); + var moved = resultSet.move(3); + console.log("testKvStoreResultSetMove002 move " + moved); + expect(moved).assertTrue(); + expect(3).assertEqual(resultSet.getPosition()); + } catch (e) { + console.log("testKvStoreResultSetMove002 fail " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testKvStoreResultSetMove003', 0, async function(done) { + try { + expect(resultSet.getPosition() == -1).assertTrue(); + var moved = resultSet.move(3); + console.log("testKvStoreResultSetMove003 move " + moved); + expect(moved && (resultSet.getPosition() == 2)).assertTrue(); + moved = resultSet.move(2); + console.log("testKvStoreResultSetMove003 move " + moved); + expect(moved && (resultSet.getPosition() == 4)).assertTrue(); + } catch (e) { + console.log("testKvStoreResultSetMove003 fail " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testKvStoreResultSetMove004', 0, async function(done) { + try { + var moved = resultSet.move(3, 'test_string'); + console.log("testKvStoreResultSetMove004 move " + moved); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetMove004 fail " + e); + } + done(); + }) + + // moveToPosition(position: number): boolean; + it('testKvStoreResultSetMoveToPosition001', 0, async function(done) { + try { + var moved = resultSet.moveToPosition(); + console.log("testKvStoreResultSetMoveToPosition001 moveToPosition " + moved); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetMoveToPosition001 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetMoveToPosition002', 0, async function(done) { + try { + var moved = resultSet.moveToPosition(1, 'test_string'); + console.log("testKvStoreResultSetMoveToPosition002 moveToPosition " + moved); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetMoveToPosition002 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetMoveToPosition003', 0, async function(done) { + try { + var moved = resultSet.moveToPosition(5); + console.log("testKvStoreResultSetMoveToPosition003 moveToPosition " + moved); + expect(moved && (resultSet.getPosition() == 5)).assertTrue(); + } catch (e) { + console.log("testKvStoreResultSetMoveToPosition003 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetMoveToPosition004', 0, async function(done) { + try { + var moved = resultSet.move(3); + console.log("testKvStoreResultSetMoveToPosition004 moveToPosition " + moved); + expect(moved && (resultSet.getPosition() == 2)).assertTrue(); + moved = resultSet.moveToPosition(5); + console.log("testKvStoreResultSetMoveToPosition004 moveToPosition " + moved); + expect(moved && (resultSet.getPosition() == 5)).assertTrue(); + } catch (e) { + console.log("testKvStoreResultSetMoveToPosition004 fail " + e); + } + done(); + }) + + // isFirst(): boolean; + it('testKvStoreResultSetIsFirst001', 0, async function(done) { + try { + var flag = resultSet.isFirst(); + console.log("testKvStoreResultSetIsFirst001 isFirst " + flag); + expect(!flag).assertTrue(); + } catch (e) { + expect(null).assertFail(); + console.log("testKvStoreResultSetIsFirst001 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetIsFirst002', 0, async function(done) { + try { + var flag = resultSet.isFirst(); + console.log("testKvStoreResultSetIsFirst002 isFirst " + flag); + expect(!flag).assertTrue(); + resultSet.move(3); + flag = resultSet.isFirst(); + console.log("testKvStoreResultSetIsFirst002 isFirst " + flag); + expect(!flag).assertTrue(); + } catch (e) { + expect(null).assertFail(); + console.log("testKvStoreResultSetIsFirst002 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetIsFirst003', 0, async function(done) { + try { + var flag = resultSet.isFirst(1); + console.log("testKvStoreResultSetIsFirst003 isFirst " + flag); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetIsFirst003 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetIsFirst004', 0, async function(done) { + try { + var flag = resultSet.isFirst(1, 'test_string'); + console.log("testKvStoreResultSetIsFirst004 isFirst " + flag); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetIsFirst004 fail " + e); + } + done(); + }) + + // isLast(): boolean; + it('testKvStoreResultSetIsLast001', 0, async function(done) { + try { + var flag = resultSet.isLast(); + console.log("testKvStoreResultSetIsLast001 isLast " + flag); + expect(!flag).assertTrue(); + } catch (e) { + expect(null).assertFail(); + console.log("testKvStoreResultSetIsFirst004 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetIsLast002', 0, async function(done) { + try { + resultSet.moveToLast(); + var flag = resultSet.isLast(); + console.log("testKvStoreResultSetIsLast002 isLast " + flag); + expect(flag).assertTrue(); + } catch (e) { + expect(null).assertFail(); + console.log("testKvStoreResultSetIsLast002 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetIsLast003', 0, async function(done) { + try { + var flag = resultSet.isLast(1); + console.log("testKvStoreResultSetIsLast003 isLast " + flag); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetIsLast003 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetIsLast004', 0, async function(done) { + try { + var flag = resultSet.isLast(1, 'test_string'); + console.log("testKvStoreResultSetIsLast004 isLast " + flag); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetIsLast004 fail " + e); + } + done(); + }) + + // isBeforeFirst(): boolean; + it('testKvStoreResultSetIsBeforeFirst001', 0, async function(done) { + try { + var flag = resultSet.isBeforeFirst(); + console.log("testKvStoreResultSetIsBeforeFirst001 isBeforeFirst " + flag); + expect(flag).assertTrue(); + } catch (e) { + expect(null).assertFail(); + console.log("testKvStoreResultSetIsBeforeFirst001 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetIsBeforeFirst002', 0, async function(done) { + try { + var moved = resultSet.moveToPrevious(); + expect(!moved).assertTrue(); + var flag = resultSet.isBeforeFirst(); + console.log("testKvStoreResultSetIsBeforeFirst002 isBeforeFirst " + flag); + expect(flag).assertTrue(); + } catch (e) { + expect(null).assertFail(); + console.log("testKvStoreResultSetIsBeforeFirst002 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetIsBeforeFirst003', 0, async function(done) { + try { + var flag = resultSet.isBeforeFirst(1); + console.log("testKvStoreResultSetIsBeforeFirst003 isBeforeFirst " + flag); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetIsBeforeFirst003 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetIsBeforeFirst004', 0, async function(done) { + try { + var flag = resultSet.isBeforeFirst(1, 'test_string'); + console.log("testKvStoreResultSetIsBeforeFirst004 isBeforeFirst " + flag); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetIsBeforeFirst004 fail " + e); + } + done(); + }) + + // isAfterLast(): boolean; + it('testKvStoreResultSetIsAfterLast001', 0, async function(done) { + try { + var flag = resultSet.isAfterLast(); + console.log("testKvStoreResultSetIsAfterLast001 isAfterLast " + flag); + expect(!flag).assertTrue(); + } catch (e) { + expect(null).assertFail(); + console.log("testKvStoreResultSetIsAfterLast001 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetIsAfterLast002', 0, async function(done) { + try { + var moved = resultSet.moveToLast(); + console.log("testKvStoreResultSetIsAfterLast002 moveToLast moved=" + moved); + expect(moved).assertTrue(); + moved = resultSet.moveToNext(); + console.log("testKvStoreResultSetIsAfterLast002 moveToNext moved=" + moved); + expect(moved).assertFalse(); + var flag = resultSet.isAfterLast(); + console.log("testKvStoreResultSetIsAfterLast002 isAfterLast true=" + flag); + expect(flag).assertTrue(); + } catch (e) { + console.log("testKvStoreResultSetIsAfterLast002 fail " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testKvStoreResultSetIsAfterLast003', 0, async function(done) { + try { + var flag = resultSet.isAfterLast(1); + console.log("testKvStoreResultSetIsAfterLast003 isAfterLast " + flag); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetIsAfterLast003 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetIsAfterLast004', 0, async function(done) { + try { + var flag = resultSet.isAfterLast(1, 'test_string'); + console.log("testKvStoreResultSetIsAfterLast004 isAfterLast " + flag); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetIsAfterLast004 fail " + e); + } + done(); + }) + + // getEntry(): Entry; + it('testKvStoreResultSetGetEntry001', 0, async function(done) { + try { + var moved = resultSet.moveToNext(); + var entry = resultSet.getEntry(); + console.log("testKvStoreResultSetGetEntry001 getEntry " + entry); + expect(moved && (entry.key == 'batch_test_string_key0')).assertTrue(); + expect(moved && (entry.value.value == 'batch_test_string_value')).assertTrue(); + } catch (e) { + expect(null).assertFail(); + console.log("testKvStoreResultSetGetEntry001 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetGetEntry002', 0, async function(done) { + try { + var moved = resultSet.moveToNext(); + var entry = resultSet.getEntry(); + console.log("testKvStoreResultSetGetEntry002 getEntry " + entry); + expect(entry.key == 'batch_test_string_key0').assertTrue(); + expect(entry.value.value == 'batch_test_string_value').assertTrue(); + moved = resultSet.moveToNext(); + expect(moved).assertTrue(); + entry = resultSet.getEntry(); + console.log("testKvStoreResultSetGetEntry002 getEntry " + entry); + expect(entry.key == 'batch_test_string_key1').assertTrue(); + expect(entry.value.value == 'batch_test_string_value').assertTrue(); + } catch (e) { + expect(null).assertFail(); + console.log("testKvStoreResultSetGetEntry002 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetGetEntry003', 0, async function(done) { + try { + var entry = resultSet.getEntry(1); + console.log("testKvStoreResultSetGetEntry003 getEntry " + entry); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetGetEntry003 fail " + e); + } + done(); + }) + + it('testKvStoreResultSetGetEntry004', 0, async function(done) { + try { + var entry = resultSet.getEntry(1, 'test_string'); + console.log("testKvStoreResultSetGetEntry004 getEntry " + entry); + expect(null).assertFail(); + } catch (e) { + console.log("testKvStoreResultSetGetEntry004 fail " + e); + } + done(); + }) +}) \ No newline at end of file diff --git a/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/List.test.js b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/List.test.js index d157cc43b6cdbd5a938f9123eaae071eefe89e66..40724a96d93545556cf9c4ed70f204e3c6a2ca95 100755 --- a/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/List.test.js +++ b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/List.test.js @@ -12,6 +12,14 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +require('./DeviceKvStorePromiseJsunit.test.js') +require('./DeviceKvStoreCallbackJsunit.test.js') require('./SingleKvStorePromiseJsunit.test.js') require('./SingleKvStoreCallbackJsunit.test.js') -require('./SingleKvStoreEnumJsunit.test.js') \ No newline at end of file +require('./SingleKvStoreEnumJsunit.test.js') +require('./KvManagerPromiseJsunit.test.js') +require('./KvManagerCallbackJsunit.test.js') +require('./KvStoreResultSetJsunit.test.js') +require('./QueryJsunit.test.js') +require('./FieldNodeJsunit.test.js') +require('./SchemaJsunit.test.js') \ No newline at end of file diff --git a/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/QueryJsunit.test.js b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/QueryJsunit.test.js new file mode 100644 index 0000000000000000000000000000000000000000..d62ae86983d3a73ff32d3a1fb271df3ae684b665 --- /dev/null +++ b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/QueryJsunit.test.js @@ -0,0 +1,1710 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index' +import ddm from '@ohos.data.distributedData'; + +describe('QueryTest', function() { + + // reset + it('testReset001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.equalTo("test", 3); + console.log("query is " + query.getSqlLike()); + expect(query.getSqlLike() !== "").assertTrue(); + query.reset(); + expect("").assertEqual(query.getSqlLike()); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("simply calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testReset002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.equalTo("number", 5); + query.equalTo("string", 'v'); + query.equalTo("boolean", false); + console.log("query is " + query.getSqlLike()); + expect(query.getSqlLike() !== "").assertTrue(); + query.reset(); + query.reset(); + query.reset(); + expect("").assertEqual(query.getSqlLike()); + console.log("sql after reset: " + query.getSqlLike()); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testReset003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.equalTo("key", "value"); + expect(query.getSqlLike() !== "").assertTrue(); + let sql = query.getSqlLike(); + query.reset().equalTo("key", "value"); + console.log("query is " + query.getSqlLike()); + expect(sql === query.getSqlLike()).assertTrue(); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testReset004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.equalTo("key", "value"); + expect(query.getSqlLike() !== "").assertTrue(); + query.reset(3); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // equalTo + it('testEqaulTo001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.equalTo("key1", 5); // number - interger? + query.equalTo("key2", 5.0); // number - double? + query.equalTo("key3", false); // bool + query.equalTo("key3", "string");// string + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testEqualTo002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.equalTo("key1", 1).equalTo("key2", 2).equalTo("key3", 3); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testEqualTo003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.equalTo("key2", NaN); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + } catch (e) { + expect(null).assertFail(); + } + done(); + }) + + it('testEqualTo004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.equalTo("key1", "value", "too more"); + console.log("should throw exception on invalid arguments"); + console.log("query is " + query.getSqlLike()); + query = null; + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // notEqualTo + it('testNotEqualTo001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key1", 5); // number - interger? + query.notEqualTo("key2", 5.0); // number - double? + query.notEqualTo("key3", false); // bool + query.notEqualTo("key4", "string");// string + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testNotEqualTo002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key", 5); + query.reset(); + query.notEqualTo("key0", 5).equalTo("key1", 5).notEqualTo("key2", "str").notEqualTo("key3", false); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testNotEqualTo003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key2", NaN); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + expect(null).assertFail(); + } + done(); + }) + + it('testNotEqualTo004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key1", "value", "too more", 4); + console.log("should throw exception on invalid arguments"); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // greaterThan + it('testGreaterThan001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.greaterThan("key1", 5); // number - interger? + query.greaterThan("key2", 5.0); // number - double? + query.greaterThan("key3", true); // bool + query.greaterThan("key4", "string");// string + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testGreatThan002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.greaterThan("key", 5); + query.reset(); + query.greaterThan("key0", 5).greaterThan("key1", "v5").greaterThan("key3", false); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testGreatThan003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.greaterThan("key2", NaN); // how to get NaN? + console.log("should throw exception on invalid arguments"); + console.log("query is " + query.getSqlLike()); + } catch (e) { + expect(null).assertFail(); + } + done(); + }) + + it('testGreatThan004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.greaterThan("key1", "value", "too more", 4); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // lessThan + it('testLessThan001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.lessThan("key1", 5); // number - interger? + query.lessThan("key2", 5.0); // number - double? + query.lessThan("key3", true); // bool + query.lessThan("key4", "string");// string + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + } + done(); + }) + + it('testLessThan002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.lessThan("key", 5); + query.reset(); + query.lessThan("key0", 5).lessThan("key1", "v5").lessThan("key3", false); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertTrue(); + } + done(); + }) + + it('testLessThan003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.lessThan("key2", NaN); + console.log("query is " + query.getSqlLike()); + } catch (e) { + expect(null).assertFail(); + } + done(); + }) + + it('testLessThan004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.lessThan("key1", "value", "too more", 4); + console.log("query is " + query.getSqlLike()); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + // greaterThanOrEqualTo + it('testGreaterThanOrEqualTo001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.greaterThanOrEqualTo("key1", 5); // number - interger? + query.greaterThanOrEqualTo("key2", 5.0); // number - double? + query.greaterThanOrEqualTo("key3", true); // bool + query.greaterThanOrEqualTo("key4", "string");// string + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testGreaterThanOrEqualTo002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.greaterThanOrEqualTo("key", 5); + query.reset(); + query.greaterThanOrEqualTo("key0", 5) + .greaterThanOrEqualTo("key1", "v5") + .greaterThanOrEqualTo("key3", false); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testGreaterThanOrEqualTo003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.greaterThanOrEqualTo("key2", NaN); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + } catch (e) { + expect(null).assertFail(); + } + done(); + }) + + it('testGreaterThanOrEqualTo004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.greaterThanOrEqualTo("key1", "value", "too more", 4); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // lessThanOrEqualTo + it('testLessThanOrEqualTo001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.lessThanOrEqualTo("key1", 5); // number - interger? + query.lessThanOrEqualTo("key2", 5.0); // number - double? + query.lessThanOrEqualTo("key3", true); // bool + query.lessThanOrEqualTo("key4", "string");// string + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testLessThanOrEqualTo002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.lessThanOrEqualTo("key", 5); + query.reset(); + query.lessThanOrEqualTo("key0", 5).lessThanOrEqualTo("key1", "v5").lessThanOrEqualTo("key3", false); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testLessThanOrEqualTo003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.lessThanOrEqualTo("key2", NaN); + console.log("query is " + query.getSqlLike()); + } catch (e) { + expect(null).assertFail(); + } + done(); + }) + + it('testLessThanOrEqualTo004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.lessThanOrEqualTo("key1", "value", "too more", 4); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // isNull + it('testIsNull001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.isNull("key"); + query.isNull("key2"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testIsNull002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.isNull("key").notEqualTo("key1", 4).isNull("key2"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testIsNull003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.isNUll("key", 0); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testIsNull004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.isNUll(0); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + /* + * ======================================================================================= + * Int8Array | INTEGER + * Uint8Array | INTEGER + * Uint8ClampedArray | INTEGER + * Int16Array | INTEGER + * Uint16Array | INTEGER + * Int32Array | INTEGER + * Uint32Array | LONG + * Float32Array | DOUBLE + * Float64Array | DOUBLE + * BigInt64Array | ERROR: cannot convert to bigint + * BigUint64Array | ERROR: cannot convert to bigint + * ======================================================================================= + * Array | DOUBLE * not-typedArray treated as array of double. + */ + // inNumber + it('testInNumber001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + console.log("testInNumber001 start "); + var i8 = new Int8Array([-21,31]); + query.reset().inNumber("key", i8); + console.log("inNumber(Int8Array([-21,31]) => " + query.getSqlLike()); + var u8 = new Uint8Array([-21,31]); + query.reset().inNumber("key", u8); + console.log("inNumber(Uint8Array([-21,31]) => " + query.getSqlLike()); + var c8 = new Uint8ClampedArray([-21,31]); + query.reset().inNumber("key", c8); + console.log("inNumber(Uint8Array([-21,31]) => " + query.getSqlLike()); + var i16 = new Int16Array([-21,31]); + query.reset().inNumber("key", i16); + console.log("inNumber(Int16Array([-21,31]) => " + query.getSqlLike()); + var u16 = new Uint16Array([-21,31]); + query.reset().inNumber("key", u16); + console.log("inNumber(Uint16Array([-21,31]) => " + query.getSqlLike()); + var i32 = new Int32Array([-21, 31]); + query.reset().inNumber("key", i32); + console.log("inNumber(Int32Array([-21,31]) => " + query.getSqlLike()); + var u32 = new Uint32Array([-21, 31]); + query.reset().inNumber("key", u32); + console.log("inNumber(UInt32Array([-21,31]) => " + query.getSqlLike()); + var f32 = new Float32Array([-21, 31]); + query.reset().inNumber("key", f32); + console.log("inNumber(Float32Array([-21,31]) => " + query.getSqlLike()); + var f32e = new Float32Array([21, 31, "a"]); // "a" will be ignored as not a float. + query.reset().inNumber("key", f32e); + console.log("inNumber(Float32Array([-21,31, 'a']) => " + query.getSqlLike()); + var f64 = new Float64Array([-21, 31]); + query.reset().inNumber("key", f64); + console.log("inNumber(Float64Array([-21,31]) => " + query.getSqlLike()); + query.reset(); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testInNumber002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.inNumber("key", [1, 2.3, 987654]). + inNumber("key2", [0x10abcdef]). + inNumber("key2", [0xf0123456]). + inNumber("key2", [0b10101]); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testInNumber003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.inNumber("key", 0); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testInNumber004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.inNumber([0, 1]); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testInNumber005', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + + // var u64 = new BigUint64Array([21n, 31n]); // build error. + var u64 = new BigUint64Array([21, 31]); // cannot convert to bigint + query.inNumber("key", u64); + + // var b64 = new BigInt64Array([21n, 31n]); // build error. + var b64 = new BigInt64Array([21, 31]); // cannot convert to bigint + query.inNumber("key", b64); + + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testInNumber006', 0, async function(done) { + try { + let query = new ddm.Query(); + // no-typedArray treat as array of double. + console.log("typeof([1, 2, 97])" + typeof([1, 2, 97])) + console.log("typeof([1, 2, 97][0])" + typeof([1, 2, 97][0])) + query.inNumber("key", [1, 2, 97]); + console.log("inNumber([1, 2, 97]) => " + query.getSqlLike()); + query.reset(); + + query.inNumber("key1", [-1, 3, 987654.123, 0xabc123456]); + console.log("inNumber([1, 2, 0xa1234567890123456]) => " + query.getSqlLike()); + query.reset(); + + query.inNumber("key2", [-1, 3, -987654.123, 0xabc123456]); + console.log("inNumber([1, 2, 0xa1234567890123456]) => " + query.getSqlLike()); + query.reset(); + + query.inNumber("key3", [-1, 4, -987654.123, Number.MAX_VALUE]); + console.log("inNumber([1, 2, Number.MAX_VALUE]) => " + query.getSqlLike()); + query.reset(); + + query.inNumber("key4", [1, -2.3, Number.MIN_VALUE, Number.MAX_VALUE]); + console.log("inNumber([1, -2.3, Number.MAX_VALUE]) => " + query.getSqlLike()); + expect(query.getSqlLike() !== "").assertTrue(); + + console.log("query is " + query.getSqlLike()); + query.reset(); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + // inString + it('testInString001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.inString("key", ["a2z" , 'z2a']); + query.inString("key2", ["AAA" ]); + console.log("query is " + query.getSqlLike()); + expect(query.getSqlLike() !== "").assertTrue(); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testInString002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.inString("key", ["a2z" , 'z2a']) + .inString("key2", ["AAA" ]) + .inString("key2", ["AAA", "AAABBB","CCCAAA" ]); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testInString003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.inString("key", 0); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testInString004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.inString("key", [0, 1]); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // notInNumber + it('testNotInNumber001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notInNumber("key", [1, 2]); + query.notInNumber("key", [1000]); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testNotInNumber002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notInNumber("key", [1, 2, 3]).notInNumber("key", [1, 7, 8]).notEqualTo("kkk", 5); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testNotInNumber003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notInNumber("key", [1], 2); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testNotInNumber004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notInNumber("key", ["string"]); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // notInString + it('testNotInString001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notInString("key", ["v1", "v2"]); + query.notInString("key", ["v1", "NaN"]); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testNotInString002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notInString("key", ["v1", "v2", "v3"]).notEqualTo("kkk", "v3"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testNotInString003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notInString("key", ["", "abccd"], 2); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testNotInString004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notInString("key", [1, 2]); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // like + it('testLike001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.like("key", "v1"); + query.like("key2", "v2"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testLike002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.like("key", "v1").like("key", "v3").like("key", "v2"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testLike003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.like("key", 0); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testLike004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.like("key", "str1", "str2"); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // unlike + it('testUnlike001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.unlike("key", "v1"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testUnlike002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.unlike("key", "v1").unlike("key", "v3").unlike("key", "v2"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testUnlike003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.unlike("key", 0); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testUnlike004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.unlike("key", "str1", "str2"); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // and + it('testAnd001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key", 0); + query.and(); + query.notEqualTo("key", "v1"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testAnd002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.equalTo("key1", 0).and().equalTo("key2", "v1"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testAnd003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key", 0).and().notEqualTo("key", 1).and(); + expect(query.getSqlLike() !== "").assertTrue(); + query.reset(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + expect(null).assertFail(); + } + done(); + }) + + it('testAnd004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key", 0).and(1).notInNumber("key", [1, 3]); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // or + it('testOr001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key", 0); + query.or(); + query.notEqualTo("key", "v1"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testOr002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.equalTo("key1", 0).or().equalTo("key2", "v1"); + expect(query.getSqlLike() !== "").assertTrue(); + query.reset(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testOr003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key", 0).or(); + console.log("or ... sql:" + query.getSqlLike()); + expect(query.getSqlLike() !== "").assertTrue(); + query.reset(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("throw exception is ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testOr004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key", 0).or(1).notInNumber("key", [1, 3]); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // orderByAsc + it('testOrderByAsc001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key", 0); + query.orderByAsc("sortbykey"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testOrderByAsc002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key", "V0").orderByAsc("sortbykey1").orderByAsc("sortbykey2"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testOrderByAsc003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key", false).orderByAsc(1); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testOrderByAsc004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.orderByAsc(); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // orderByDesc + it('testOrderByDesc001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key", 0); + query.orderByDesc("sortbykey"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testOrderByDesc002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key", "V0").orderByDesc("sortbykey1").orderByDesc("sortbykey2"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testOrderByDesc003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key", false).orderByDesc(1); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testOrderByDesc004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.orderByDesc(); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // limit(total:number, offset:number) + it('testLimit001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key", "vx"); + query.limit(10, 2); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testLimit002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key", "vx").limit(10, 2) + .equalTo("key2", 2).limit(10, 2); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testLimit003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key", false).limit(10, 2, "any"); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testLimit004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key", false).limit(10); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testLimit005', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.notEqualTo("key", false).limit("any", 10); + console.log("should throw exception on invalid arguments"); + console.log("query is " + query.getSqlLike()); + query = null; + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // isNotNull + it('testIsNotNull001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.isNotNull("key"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testIsNotNull002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.isNotNull("key1").and().notEqualTo("key1", 123); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testIsNotNull003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.isNotNull("key2", "any"); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testIsNotNull004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.isNotNull(1); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // beginGroup + it('testBeginGroup001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.beginGroup(); + query.isNotNull("$.name"); + query.endGroup(); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testBeginGroup002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.beginGroup(); + query.beginGroup(); + query.notEqualTo("$.name", 0); + query.endGroup(); + query.beginGroup(); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testBeginGroup003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.beginGroup(1); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testBeginGroup004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.beginGroup("any", 1); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // endGroup + it('testEndGroup001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.beginGroup(); + query.isNotNull("$.name"); + query.endGroup(); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + expect(null).assertFail(); + } + done(); + }) + + it('testEndGroup002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.endGroup(); + query.beginGroup(); + query.isNotNull("$.name"); + query.endGroup(); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + expect(null).assertFail(); + } + done(); + }) + + it('testEndGroup003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.endGroup(0); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testEndGroup004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.endGroup("any"); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // prefixKey + it('testPrefixKey001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.prefixKey("$.name"); + query.prefixKey("0"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + expect(null).assertFail(); + } + done(); + }) + + it('testPrefixKey002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.prefixKey("kx1").or().prefixKey("kx2").or().prefixKey("kx3"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + expect(null).assertFail(); + } + done(); + }) + + it('testPrefixKey003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.prefixKey("k", "any"); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testPrefixKey004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.prefixKey(123); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // setSuggestIndex(index:string) + it('testSetSuggestIndex001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.setSuggestIndex("$.name"); + query.setSuggestIndex("0"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + expect(null).assertFail(); + } + done(); + }) + + it('testSetSuggestIndex002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.setSuggestIndex("kxx").or().equalTo("key2", "v1"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + expect(null).assertFail(); + } + done(); + }) + + it('testSetSuggestIndex003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.setSuggestIndex("k", "any"); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testSetSuggestIndex004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.setSuggestIndex(123); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // deviceId + it('testDeviceId001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.deviceId("$.name"); + query.deviceId("0"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceId002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.deviceId("kxx").equalTo("key2", "v1"); + expect(query.getSqlLike() !== "").assertTrue(); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testDeviceId003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.deviceId("k", "any"); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testDeviceId004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.deviceId(123); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + // getSqlLike + it('testGetSqlLike001', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + let sql1 = query.getSqlLike(); + console.log("testGetSqlLike001 sql=" + sql1); + let sql2 = query.getSqlLike(); + expect(sql1).assertEqual(sql2); + console.log("query is " + query.getSqlLike()); + query = null; + } catch (e) { + console.log("dumplicated calls should be ok : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testGetSqlLike002', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + let sql1 = query.getSqlLike(); + console.log("testGetSqlLike002 sql=" + sql1); + query.inString("key1", ["AAA", "BBB"]) + .or() + .notEqualTo("key2", 0); + let sql2 = query.getSqlLike(); + console.log("testGetSqlLike002 sql=" + sql2); + console.log("query is " + query.getSqlLike()); + expect(sql1 !== sql2).assertTrue(); + query = null; + } catch (e) { + console.log("should be ok on Method Chaining : " + e); + expect(null).assertFail(); + } + done(); + }) + + it('testGetSqlLike003', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.inNumber("key"); + query.getSqlLike(0); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) + + it('testGetSqlLike004', 0, async function(done) { + try { + let query = new ddm.Query(); + expect("").assertEqual(query.getSqlLike()); + query.inNumber("key"); + query.getSqlLike("any"); + console.log("should throw exception on invalid arguments"); + expect(null).assertFail(); + } catch (e) { + console.log("throw exception is ok : " + e); + } + done(); + }) +}) \ No newline at end of file diff --git a/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/SchemaJsunit.test.js b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/SchemaJsunit.test.js new file mode 100644 index 0000000000000000000000000000000000000000..2f3c2c50abd0977dd9b224f35ecb5546bee527fd --- /dev/null +++ b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/SchemaJsunit.test.js @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index' +import ddm from '@ohos.data.distributedData'; + +describe('SchemaTest', function() { + + // toJsonString():string + it('testToJsonString001', 0, async function(done) { + try { + let schema = new ddm.Schema(); + var str = schema.toJsonString(); + console.log("schema: " + str); + } catch (e) { + expect(null).assertFail(); + } + done(); + }) + + it('testToJsonString002', 0, async function(done) { + try { + let schema = new ddm.Schema(); + var str = schema.toJsonString(); + schema.root = new ddm.FieldNode(); + var node = schema.root; + console.log("schema: " + str); + } catch (e) { + expect(null).assertFail(); + } + done(); + }) + + it('testToJsonString003', 0, async function(done) { + try { + let schema = new ddm.Schema(); + var str = schema.toJsonString(); + console.log("schema: " + str); + } catch (e) { + expect(null).assertFail(); + } + done(); + }) +}) \ No newline at end of file diff --git a/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/SingleKvStoreCallbackJsunit.test.js b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/SingleKvStoreCallbackJsunit.test.js index 07df85ef90a5c07cb4a51e1e62b7f772f9a5efd6..4347f0ac0431d22175895cdc1bb2aa2cfeb93f14 100755 --- a/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/SingleKvStoreCallbackJsunit.test.js +++ b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/SingleKvStoreCallbackJsunit.test.js @@ -27,22 +27,36 @@ const VALUE_TEST_BOOLEAN_ELEMENT = true; const VALUE_TEST_STRING_ELEMENT = 'value-string-002'; const VALUE_TEST_SYNC_ELEMENT = 'value-string-001'; -const SINGLE_VERSION = 1; -const SECURITY_LEVEL = 3; - -const PULL_ONLY = 0; -const PUSH_ONLY = 1; -const PUSH_PULL = 2; - +const TEST_BUNDLE_NAME = 'ohos.acts.distributeddatamgr'; +const TEST_STORE_ID = 'storeId'; var kvManager = null; var kvStore = null; -describe('KvStoreTest', function () { +function sleep(ms) { + return new Promise(resolve => setTimeout(resolve, ms)); +} + +function putBatchString(len, prefix) { + let entries = []; + for (var i = 0; i < len; i++) { + var entry = { + key : prefix + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + return entries; +} + +describe('SingleKvStoreCallbackTest', function () { const config = { - bundleName : 'ohos.acts.distributeddatamgr', + bundleName : TEST_BUNDLE_NAME, userInfo : { userId : '0', - userType : 0 + userType : factory.UserType.SAME_USER_ID } } @@ -51,341 +65,1942 @@ describe('KvStoreTest', function () { encrypt : false, backup : false, autoSync : true, - kvStoreType : SINGLE_VERSION, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, schema : '', - securityLevel : SECURITY_LEVEL, + securityLevel : factory.SecurityLevel.S2, } - it('testCreateKVManager102', 0, async function (done) { + beforeAll(async function (done) { + console.log('beforeAll config:'+ JSON.stringify(config)); + await factory.createKVManager(config, function (err, manager) { + kvManager = manager; + console.log('beforeAll createKVManager success'); + done(); + }) + }) + + afterAll(async function (done) { + console.log('afterAll'); + kvManager = null; + kvStore = null; + done(); + }) + + beforeEach(async function (done) { + console.log('beforeEach' + JSON.stringify(options)); + await kvManager.getKVStore(TEST_STORE_ID, options, function (err, store) { + kvStore = store; + console.log('beforeEach getKVStore success'); + done(); + }); + }) + + afterEach(async function (done) { + console.log('afterEach'); + await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, kvStore, async function (err, data) { + console.log('afterEach closeKVStore success'); + await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, function (err, data) { + console.log('afterEach deleteKVStore success'); + done(); + }); + }); + }) + + it('testSingleKvStorePutString101', 0, async function (done) { + console.log('testSingleKvStorePutString101'); try { - await factory.createKVManager(null, function (err, manager) { - expect(null).assertFail(); + await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, function (err,data) { + if (err == undefined) { + console.log('testSingleKvStorePutString101 put success'); + } else { + console.log('testSingleKvStorePutString101 put fail' + err); + expect(null).assertFail(); + } + done(); }); }catch (e) { - console.log("testCreateKVManager102 fail " + e); + console.log('testSingleKvStorePutString101 put e' + e); + expect(null).assertFail(); + done(); } - done(); }) - it('testCreateKVManager103', 0, async function (done) { + it('testSingleKvStorePutString102', 0, async function (done) { + console.log('testSingleKvStorePutString102'); try { - await factory.createKVManager('', function (err, manager) { - expect(null).assertFail(); + var str = ''; + for (var i = 0 ; i < 4095; i++) { + str += 'x'; + } + await kvStore.put(KEY_TEST_STRING_ELEMENT+'102', str, async function (err,data) { + console.log('testSingleKvStorePutString102 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(KEY_TEST_STRING_ELEMENT+'102', function (err,data) { + console.log('testSingleKvStorePutString102 get success'); + expect(str == data).assertTrue(); + done(); + }); }); - }catch(e) { - console.log("testCreateKVManager103 fail " + e); + }catch (e) { + console.log('testSingleKvStorePutString102 put e' + e); + expect(null).assertFail(); + done(); } - done(); }) - it('testCreateKVManager101', 0, async function (done) { - try { - await factory.createKVManager(config, function (err, manager) { - kvManager = manager; - expect(false).assertEqual(manager == null); + it('testSingleKvStoreGetString101', 0, async function (done) { + console.log('testSingleKvStoreGetString101'); + try{ + await kvStore.get(KEY_TEST_STRING_ELEMENT, function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreGetString101 get success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreGetString101 get fail'); + } done(); }); }catch(e) { - console.log("testCreateKVManager101 fail " + e); + console.log('testSingleKvStoreGetString101 get e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreGetString102', 0, async function (done) { + console.log('testSingleKvStoreGetString102'); + try{ + await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, async function (err,data) { + console.log('testSingleKvStoreGetString102 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(KEY_TEST_STRING_ELEMENT, function (err,data) { + console.log('testSingleKvStoreGetString102 get success'); + expect((err == undefined) && (VALUE_TEST_STRING_ELEMENT == data)).assertTrue(); + done(); + }); + }) + }catch(e) { + console.log('testSingleKvStoreGetString102 get e' + e); expect(null).assertFail(); + done(); } }) - it('testGetKVStore101', 0, async function (done) { + it('testSingleKvStorePutInt101', 0, async function (done) { + console.log('testSingleKvStorePutInt101'); try { - await kvManager.getKVStore(options, function (err, store) { - expect(null).assertFail(); + await kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT, async function (err,data) { + console.log('testSingleKvStorePutInt101 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(KEY_TEST_INT_ELEMENT, function (err,data) { + console.log('testSingleKvStorePutInt101 get success'); + expect((err == undefined) && (VALUE_TEST_INT_ELEMENT == data)).assertTrue(); + done(); + }) }); }catch(e) { - console.log("testGetKVStore101 fail " + e); + console.log('testSingleKvStorePutInt101 put e' + e); + expect(null).assertFail(); + done(); } - done(); }) - it('testGetKVStore102', 0, async function (done) { + it('testSingleKvStorePutInt102', 0, async function (done) { + console.log('testSingleKvStorePutInt102'); try { - await kvManager.getKVStore('storeId', options, function (err, store) { - kvStore = store; - expect(false).assertEqual(store == null); - done(); + var intValue = 987654321; + await kvStore.put(KEY_TEST_INT_ELEMENT, intValue, async function (err,data) { + console.log('testSingleKvStorePutInt102 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(KEY_TEST_INT_ELEMENT, function (err,data) { + console.log('testSingleKvStorePutInt102 get success'); + expect((err == undefined) && (intValue == data)).assertTrue(); + done(); + }) }); }catch(e) { - console.log("testGetKVStore102 fail " + e); + console.log('testSingleKvStorePutInt102 put e' + e); expect(null).assertFail(); + done(); } }) - it('testPutString101', 0, async function (done) { + it('testSingleKvStorePutInt103', 0, async function (done) { + console.log('testSingleKvStorePutInt103'); try { - await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, function (err,data) { - if (err != undefined) { - expect(null).assertFail(); - } + var intValue = Number.MIN_VALUE; + await kvStore.put(KEY_TEST_INT_ELEMENT, intValue, async function (err,data) { + console.log('testSingleKvStorePutInt103 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(KEY_TEST_INT_ELEMENT, function (err,data) { + console.log('testSingleKvStorePutInt103 get success'); + expect((err == undefined) && (intValue == data)).assertTrue(); + done(); + }) }); - }catch (e) { + }catch(e) { + console.log('testSingleKvStorePutInt103 put e' + e); expect(null).assertFail(); + done(); } - done(); }) - it('testGetString101', 0, async function (done) { - try{ - await kvStore.get(KEY_TEST_STRING_ELEMENT, function (err,data) { - expect(VALUE_TEST_STRING_ELEMENT).assertEqual(data); + it('testSingleKvStorePutInt104', 0, async function (done) { + console.log('testSingleKvStorePutInt104'); + try { + var intValue = Number.MAX_VALUE; + await kvStore.put(KEY_TEST_INT_ELEMENT, intValue, async function (err,data) { + console.log('testSingleKvStorePutInt104 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(KEY_TEST_INT_ELEMENT, function (err,data) { + console.log('testSingleKvStorePutInt104 get success'); + expect((err == undefined) && (intValue == data)).assertTrue(); + done(); + }) }); }catch(e) { + console.log('testSingleKvStorePutInt104 put e' + e); expect(null).assertFail(); + done(); } - done(); }) - it('testPutString102', 0, async function (done) { + it('testSingleKvStoreGetInt101', 0, async function (done) { + console.log('testSingleKvStoreGetInt101'); try { - var str = ''; - for (var i = 0 ; i < 4095; i++) { - str += 'x'; - } - await kvStore.put(KEY_TEST_STRING_ELEMENT+'102', str, function (err,data) { - kvStore.get(KEY_TEST_STRING_ELEMENT+'102', function (err,data) { - expect(str).assertEqual(data); - }); + await kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT, async function (err,data) { + console.log('testSingleKvStoreGetInt101 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(KEY_TEST_INT_ELEMENT, function (err,data) { + console.log('testSingleKvStoreGetInt101 get success'); + expect((err == undefined) && (VALUE_TEST_INT_ELEMENT == data)).assertTrue(); + done(); + }) }); - }catch (e) { + }catch(e) { + console.log('testSingleKvStoreGetInt101 put e' + e); expect(null).assertFail(); + done(); } - done(); }) - it('testPutInt101', 0, async function (done) { + it('testSingleKvStoreGetInt102', 0, async function (done) { + console.log('testSingleKvStoreGetInt102'); try { - await kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT, function (err,data) { - if (err != undefined) { + await kvStore.get(KEY_TEST_INT_ELEMENT, function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreGetInt102 get success'); expect(null).assertFail(); + } else { + console.log('testSingleKvStoreGetInt102 get fail'); } - }); + done(); + }) }catch(e) { + console.log('testSingleKvStoreGetInt102 put e' + e); expect(null).assertFail(); + done(); } - done(); }) - it('testGetInt101', 0, async function (done) { + it('testSingleKvStorePutBool101', 0, async function (done) { + console.log('testSingleKvStorePutBool101'); try { - await kvStore.get(KEY_TEST_INT_ELEMENT, function (err,data) { - expect(VALUE_TEST_INT_ELEMENT).assertEqual(data); + await kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, VALUE_TEST_BOOLEAN_ELEMENT, function (err,data) { + console.log('testSingleKvStorePutBool101 put success'); + expect(err == undefined).assertTrue(); + done(); }); }catch(e) { + console.log('testSingleKvStorePutBool101 e ' + e); expect(null).assertFail(); + done(); } - done(); }) - it('testPutBoolean101', 0, async function (done) { + it('testSingleKvStoreGetBool101', 0, async function (done) { + console.log('testSingleKvStoreGetBool101'); try { - await kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, VALUE_TEST_BOOLEAN_ELEMENT, function (err,data) { - if (err != undefined) { + await kvStore.get(KEY_TEST_BOOLEAN_ELEMENT, function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreGetBool101 get success'); expect(null).assertFail(); + } else { + console.log('testSingleKvStoreGetBool101 get fail' + err); } + done(); }); }catch(e) { + console.log('testSingleKvStoreGetBool101 e' + e); expect(null).assertFail(); + done(); } - done(); }) - it('testGetBoolean101', 0, async function (done) { + it('testSingleKvStoreGetBool102', 0, async function (done) { + console.log('testSingleKvStoreGetBool102'); try { - await kvStore.get(KEY_TEST_BOOLEAN_ELEMENT, function (err,data) { - expect(VALUE_TEST_BOOLEAN_ELEMENT).assertEqual(data); - }); + await kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, VALUE_TEST_BOOLEAN_ELEMENT, async function (err, data) { + console.log('testSingleKvStoreGetBool102 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(KEY_TEST_BOOLEAN_ELEMENT, function (err,data) { + console.log('testSingleKvStoreGetBool102 get success'); + expect((err == undefined) && (VALUE_TEST_BOOLEAN_ELEMENT == data)).assertTrue(); + done(); + }); + }) }catch(e) { + console.log('testSingleKvStoreGetBool102 e' + e); expect(null).assertFail(); + done(); } - done(); }) - it('testPutFloat101', 0, async function (done) { + it('testSingleKvStorePutFloat101', 0, async function (done) { + console.log('testSingleKvStorePutFloat101'); try { await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT, function (err,data) { - if (err != undefined) { - expect(null).assertFail(); - } + console.log('testSingleKvStorePutFloat101 put success'); + expect(err == undefined).assertTrue(); + done(); }); }catch(e) { + console.log('testSingleKvStorePutFloat101 e' + e); expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStorePutFloat102', 0, async function (done) { + console.log('testSingleKvStorePutFloat102'); + try { + var floatValue = 123456.654321; + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, floatValue, async function (err,data) { + console.log('testSingleKvStorePutFloat102 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(KEY_TEST_FLOAT_ELEMENT, function (err, data) { + console.log('testSingleKvStorePutFloat102 get success'); + expect((err == undefined) && (floatValue == data)).assertTrue(); + done(); + }) + done(); + }); + }catch(e) { + console.log('testSingleKvStorePutFloat102 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStorePutFloat103', 0, async function (done) { + console.log('testSingleKvStorePutFloat103'); + try { + var floatValue = 123456.0; + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, floatValue, async function (err,data) { + console.log('testSingleKvStorePutFloat103 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(KEY_TEST_FLOAT_ELEMENT, function (err, data) { + console.log('testSingleKvStorePutFloat103 get success'); + expect((err == undefined) && (floatValue == data)).assertTrue(); + done(); + }) + done(); + }); + }catch(e) { + console.log('testSingleKvStorePutFloat103 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStorePutFloat104', 0, async function (done) { + console.log('testSingleKvStorePutFloat104'); + try { + var floatValue = 123456.00; + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, floatValue, async function (err,data) { + console.log('testSingleKvStorePutFloat104 put success'); + expect(err == undefined).assertTrue(); + await kvStore.get(KEY_TEST_FLOAT_ELEMENT, function (err, data) { + console.log('testSingleKvStorePutFloat104 get success'); + expect((err == undefined) && (floatValue == data)).assertTrue(); + done(); + }) + done(); + }); + }catch(e) { + console.log('testSingleKvStorePutFloat104 e' + e); + expect(null).assertFail(); + done(); } - done(); }) - it('testGetFloat101', 0, async function (done) { + it('testSingleKvStoreGetFloat101', 0, async function (done) { + console.log('testSingleKvStoreGetFloat101'); try { await kvStore.get(KEY_TEST_FLOAT_ELEMENT, function (err,data) { - expect(VALUE_TEST_FLOAT_ELEMENT).assertEqual(data); + if (err == undefined) { + console.log('testSingleKvStoreGetFloat101 get success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreGetFloat101 get fail' + err); + } + done(); }); }catch(e) { + console.log('testSingleKvStoreGetFloat101 e' + e); expect(null).assertFail(); + done(); } - done(); }) - it('testDeleteString101', 0, async function (done) { + it('testSingleKvStoreDeleteString101', 0, async function (done) { + console.log('testSingleKvStoreDeleteString101'); try { await kvStore.delete(KEY_TEST_STRING_ELEMENT, function (err,data) { - if (err != undefined) { + if (err == undefined) { + console.log('testSingleKvStoreDeleteString101 delete success'); + } else { + console.log('testSingleKvStoreDeleteString101 delete fail' + err); expect(null).assertFail(); } + done(); }); }catch(e) { + console.log('testSingleKvStoreDeleteString101 e' + e); expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreDeleteString102', 0, async function (done) { + console.log('testSingleKvStoreDeleteString102'); + try { + await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, async function (err, data) { + console.log('testSingleKvStoreDeleteString102 put success'); + expect(err == undefined).assertTrue(); + await kvStore.delete(KEY_TEST_STRING_ELEMENT, function (err,data) { + console.log('testSingleKvStoreDeleteString102 delete success'); + expect(err == undefined).assertTrue(); + done(); + }); + }) + }catch(e) { + console.log('testSingleKvStoreDeleteString102 e' + e); + expect(null).assertFail(); + done(); } - done(); }) - it('testDeleteInt101', 0, async function (done) { + it('testSingleKvStoreDeleteInt101', 0, async function (done) { + console.log('testSingleKvStoreDeleteInt101'); try{ await kvStore.delete(KEY_TEST_INT_ELEMENT, function (err,data) { - if (err != undefined) { + if (err == undefined) { + console.log('testSingleKvStoreDeleteInt101 get success'); + } else { + console.log('testSingleKvStoreDeleteInt101 get fail' + err); expect(null).assertFail(); } + done(); }); }catch(e) { + console.log('testSingleKvStoreDeleteInt101 e' + e); expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreDeleteInt102', 0, async function (done) { + console.log('testSingleKvStoreDeleteInt102'); + try{ + await kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT, async function (err,data) { + console.log('testSingleKvStoreDeleteInt102 put success'); + expect(err == undefined).assertTrue(); + await kvStore.delete(KEY_TEST_INT_ELEMENT, function (err,data) { + console.log('testSingleKvStoreDeleteInt102 delete success'); + expect(err == undefined).assertTrue(); + done(); + }); + }) + }catch(e) { + console.log('testSingleKvStoreDeleteInt102 e' + e); + expect(null).assertFail(); + done(); } - done(); }) - it('testDeleteFloat101', 0, async function (done) { + it('testSingleKvStoreDeleteFloat101', 0, async function (done) { + console.log('testSingleKvStoreDeleteFloat101'); try{ await kvStore.delete(KEY_TEST_FLOAT_ELEMENT, function (err,data) { - if (err != undefined) { + if (err == undefined) { + console.log('testSingleKvStoreDeleteFloat101 get success'); + } else { + console.log('testSingleKvStoreDeleteFloat101 get fail' + err); expect(null).assertFail(); } + done(); }); }catch(e) { + console.log('testSingleKvStoreDeleteFloat101 e' + e); expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreDeleteFloat102', 0, async function (done) { + console.log('testSingleKvStoreDeleteFloat102'); + try{ + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT, async function (err, data) { + console.log('testSingleKvStoreDeleteFloat102 put success'); + expect(err == undefined).assertTrue(); + await kvStore.delete(KEY_TEST_FLOAT_ELEMENT, function (err,data) { + console.log('testSingleKvStoreDeleteFloat102 delete success'); + expect(err == undefined).assertTrue(); + done(); + }); + }) + }catch(e) { + console.log('testSingleKvStoreDeleteFloat102 e' + e); + expect(null).assertFail(); + done(); } - done(); }) - it('testDeleteBoolean101', 0, async function (done) { + it('testSingleKvStoreDeleteBool101', 0, async function (done) { + console.log('testSingleKvStoreDeleteBool101'); try{ await kvStore.delete(KEY_TEST_BOOLEAN_ELEMENT, function (err,data) { - if (err != undefined) { + if (err == undefined) { + console.log('testSingleKvStoreDeleteBool101 get success'); + } else { + console.log('testSingleKvStoreDeleteBool101 get fail' + err); expect(null).assertFail(); } + done(); }); }catch(e) { + console.log('testSingleKvStoreDeleteBool101 e' + e); expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreDeleteBool102', 0, async function (done) { + console.log('testSingleKvStoreDeleteBool102'); + try{ + await kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, VALUE_TEST_BOOLEAN_ELEMENT, async function (err, data) { + console.log('testSingleKvStoreDeleteBool102 put success'); + expect(err == undefined).assertTrue(); + await kvStore.delete(KEY_TEST_BOOLEAN_ELEMENT, function (err,data) { + console.log('testSingleKvStoreDeleteBool102 delete success'); + expect(err == undefined).assertTrue(); + done(); + }); + }) + }catch(e) { + console.log('testSingleKvStoreDeleteBool102 e' + e); + expect(null).assertFail(); + done(); } - done(); }) - it('testOnChange100', 0, async function (done) { + it('testSingleKvStoreOnChange101', 0, async function (done) { + console.log('testSingleKvStoreOnChange101'); try { kvStore.on('dataChange', 0, function (data) { - expect(true).assertEqual(data !=null); + console.log('testSingleKvStoreOnChange101 dataChange'); + expect(data != null).assertTrue(); }); await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT, function (err,data) { - if (err != undefined) { - expect(null).assertFail(); - } + console.log('testSingleKvStoreOnChange101 put success'); + expect(err == undefined).assertTrue(); + done(); }); - await(3000); }catch(e) { + console.log('testSingleKvStoreOnChange101 e' + e); expect(null).assertFail(); + done(); } - done(); }) - it('testOnChange101', 0, async function (done) { + it('testSingleKvStoreOnChange102', 0, async function (done) { + console.log('testSingleKvStoreOnChange102'); try { kvStore.on('dataChange', 1, function (data) { - expect(true).assertEqual(data !=null); + console.log('testSingleKvStoreOnChange102 dataChange'); + expect(data != null).assertTrue(); }); await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT, function (err,data) { - if (err != undefined) { - expect(null).assertFail(); - } + console.log('testSingleKvStoreOnChange102 put success'); + expect(err == undefined).assertTrue(); + done(); }); - await(3000); }catch(e) { + console.log('testSingleKvStoreOnChange102 e' + e); expect(null).assertFail(); + done(); } - done(); }) - it('testOnChange102', 0, async function (done) { + it('testSingleKvStoreOnChange103', 0, async function (done) { + console.log('testSingleKvStoreOnChange103'); try { kvStore.on('dataChange', 2, function (data) { - expect(true).assertEqual(data !=null); + console.log('testSingleKvStoreOnChange103 dataChange'); + expect(data != null).assertTrue(); }); - await kvStore.put(KEY_TEST_FLOAT_ELEMENT+ '102', VALUE_TEST_FLOAT_ELEMENT, function (err,data) { - if (err != undefined) { - expect(null).assertFail(); - } + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT, function (err,data) { + console.log('testSingleKvStoreOnChange103 put success'); + expect(err == undefined).assertTrue(); + done(); }); - await(3000); }catch(e) { + console.log('testSingleKvStoreOnChange103 e' + e); expect(null).assertFail(); + done(); } - done(); }) - it('testOnSyncComplete101', 0, async function (done) { + it('testSingleKvStoreOnSyncComplete101', 0, async function (done) { try { kvStore.on('syncComplete', function (data) { - expect(true).assertEqual(data !=null); + console.log('testSingleKvStoreOnSyncComplete101 dataChange'); + expect(data != null).assertTrue(); }); await kvStore.put(KEY_TEST_SYNC_ELEMENT + 'testSync101', VALUE_TEST_SYNC_ELEMENT, function (err,data) { - if (err != undefined) { - expect(null).assertFail(); - } + console.log('testSingleKvStoreOnSyncComplete101 put success'); + expect(err == undefined).assertTrue(); var devices = ['A12C1F9261528B21F95778D2FDC0B2E33943E6251AC5487F4473D005758905DB']; - var mode = PULL_ONLY; + var mode = factory.SyncMode.PULL_ONLY; kvStore.sync(devices, mode, 10); + done(); }); - await(3000); }catch(e) { + console.log('testSingleKvStoreOnSyncComplete101 e' + e); expect(null).assertFail(); + done(); } - done(); }) - it('testOnSyncComplete102', 0, async function (done) { + it('testSingleKvStoreOnSyncComplete102', 0, async function (done) { try { kvStore.on('syncComplete', function (data) { - expect(true).assertEqual(data !=null); + console.log('testSingleKvStoreOnSyncComplete102 dataChange'); + expect(data != null).assertTrue(); }); await kvStore.put(KEY_TEST_SYNC_ELEMENT + 'testSync101', VALUE_TEST_SYNC_ELEMENT, function (err,data) { - if (err != undefined) { - expect(null).assertFail(); - } + console.log('testSingleKvStoreOnSyncComplete102 put success'); + expect(err == undefined).assertTrue(); var devices = ['A12C1F9261528B21F95778D2FDC0B2E33943E6251AC5487F4473D005758905DB']; - var mode = PUSH_ONLY; + var mode = factory.SyncMode.PUSH_ONLY; kvStore.sync(devices, mode, 10); + done(); }); - await(3000); }catch(e) { + console.log('testSingleKvStoreOnSyncComplete102 e' + e); expect(null).assertFail(); + done(); } - done(); }) - it('testOnSyncComplete103', 0, async function (done) { + it('testSingleKvStoreOnSyncComplete103', 0, async function (done) { try { kvStore.on('syncComplete', function (data) { - expect(true).assertEqual(data !=null); + console.log('testSingleKvStoreOnSyncComplete103 dataChange'); + expect(data != null).assertTrue(); }); await kvStore.put(KEY_TEST_SYNC_ELEMENT + 'testSync101', VALUE_TEST_SYNC_ELEMENT, function (err,data) { - if (err != undefined) { - expect(null).assertFail(); - } + console.log('testSingleKvStoreOnSyncComplete103 put success'); + expect(err == undefined).assertTrue(); var devices = ['A12C1F9261528B21F95778D2FDC0B2E33943E6251AC5487F4473D005758905DB']; - var mode = PUSH_PULL; + var mode = factory.SyncMode.PUSH_PULL; kvStore.sync(devices, mode, 10); + done(); + }); + }catch(e) { + console.log('testSingleKvStoreOnSyncComplete103 e' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreSetSyncRange101', 0, async function (done) { + console.log('testSingleKvStoreSetSyncRange101'); + try { + var localLabels = ['A', 'B']; + var remoteSupportLabels = ['C', 'D']; + await kvStore.setSyncRange(localLabels, remoteSupportLabels, function (err,data) { + console.log('testSingleKvStoreSetSyncRange101 put success'); + expect(err == undefined).assertTrue(); + done(); + }); + }catch(e) { + console.log('testSingleKvStoreSetSyncRange101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreSetSyncRange102', 0, async function (done) { + console.log('testSingleKvStoreSetSyncRange102'); + try { + var localLabels = ['A', 'B']; + var remoteSupportLabels = ['B', 'C']; + await kvStore.setSyncRange(localLabels, remoteSupportLabels, function (err,data) { + console.log('testSingleKvStoreSetSyncRange102 put success'); + expect(err == undefined).assertTrue(); + done(); + }); + }catch(e) { + console.log('testSingleKvStoreSetSyncRange102 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreSetSyncRange103', 0, async function (done) { + console.log('testSingleKvStoreSetSyncRange103'); + try { + var localLabels = ['A', 'B']; + var remoteSupportLabels = ['A', 'B']; + await kvStore.setSyncRange(localLabels, remoteSupportLabels, function (err,data) { + console.log('testSingleKvStoreSetSyncRange103 put success'); + expect(err == undefined).assertTrue(); + done(); + }); + }catch(e) { + console.log('testSingleKvStoreSetSyncRange103 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStorePutBatch101', 0, async function (done) { + console.log('testSingleKvStorePutBatch101'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + console.log('testSingleKvStorePutBatch101 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testSingleKvStorePutBatch101 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries('batch_test_string_key', function (err,entrys) { + console.log('testSingleKvStorePutBatch101 getEntries success'); + console.log('testSingleKvStorePutBatch101 entrys.length: ' + entrys.length); + console.log('testSingleKvStorePutBatch101 entrys[0]: ' + JSON.stringify(entrys[0])); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == 'batch_test_string_value').assertTrue(); + done(); + }); + }); + }catch(e) { + console.log('testSingleKvStorePutBatch101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStorePutBatch102', 0, async function (done) { + console.log('testSingleKvStorePutBatch102'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_number_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.INTEGER, + value : 222 + } + } + entries.push(entry); + } + console.log('testSingleKvStorePutBatch102 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testSingleKvStorePutBatch102 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries('batch_test_number_key', function (err,entrys) { + console.log('testSingleKvStorePutBatch102 getEntries success'); + console.log('testSingleKvStorePutBatch102 entrys.length: ' + entrys.length); + console.log('testSingleKvStorePutBatch102 entrys[0]: ' + JSON.stringify(entrys[0])); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == 222).assertTrue(); + done(); + }); + }); + }catch(e) { + console.log('testSingleKvStorePutBatch102 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStorePutBatch103', 0, async function (done) { + console.log('testSingleKvStorePutBatch103'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_number_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.FLOAT, + value : 2.0 + } + } + entries.push(entry); + } + console.log('testSingleKvStorePutBatch103 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testSingleKvStorePutBatch103 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries('batch_test_number_key', function (err,entrys) { + console.log('testSingleKvStorePutBatch103 getEntries success'); + console.log('testSingleKvStorePutBatch103 entrys.length: ' + entrys.length); + console.log('testSingleKvStorePutBatch103 entrys[0]: ' + JSON.stringify(entrys[0])); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == 2.0).assertTrue(); + done(); + }); + }); + }catch(e) { + console.log('testSingleKvStorePutBatch103 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStorePutBatch104', 0, async function (done) { + console.log('testSingleKvStorePutBatch104'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_number_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.DOUBLE, + value : 2.00 + } + } + entries.push(entry); + } + console.log('testSingleKvStorePutBatch104 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testSingleKvStorePutBatch104 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries('batch_test_number_key', function (err,entrys) { + console.log('testSingleKvStorePutBatch104 getEntries success'); + console.log('testSingleKvStorePutBatch104 entrys.length: ' + entrys.length); + console.log('testSingleKvStorePutBatch104 entrys[0]: ' + JSON.stringify(entrys[0])); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == 2.00).assertTrue(); + done(); + }); + }); + }catch(e) { + console.log('testSingleKvStorePutBatch104 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStorePutBatch105', 0, async function (done) { + console.log('testSingleKvStorePutBatch105'); + try { + var bo = false; + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_bool_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.BOOLEAN, + value : bo + } + } + entries.push(entry); + } + console.log('testSingleKvStorePutBatch105 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testSingleKvStorePutBatch105 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries('batch_test_bool_key', function (err,entrys) { + console.log('testSingleKvStorePutBatch105 getEntries success'); + console.log('testSingleKvStorePutBatch105 entrys.length: ' + entrys.length); + console.log('testSingleKvStorePutBatch105 entrys[0]: ' + JSON.stringify(entrys[0])); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == bo).assertTrue(); + done(); + }); + }); + }catch(e) { + console.log('testSingleKvStorePutBatch105 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStorePutBatch106', 0, async function (done) { + console.log('testSingleKvStorePutBatch106'); + try { + var arr = new Uint8Array([21,31]); + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_bool_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.BYTE_ARRAY, + value : arr + } + } + entries.push(entry); + } + console.log('testSingleKvStorePutBatch106 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testSingleKvStorePutBatch106 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries('batch_test_bool_key', function (err,entrys) { + console.log('testSingleKvStorePutBatch106 getEntries success'); + console.log('testSingleKvStorePutBatch106 entrys.length: ' + entrys.length); + console.log('testSingleKvStorePutBatch106 entrys[0]: ' + JSON.stringify(entrys[0])); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value.toString() == arr.toString()).assertTrue(); + done(); + }); + }); + }catch(e) { + console.log('testSingleKvStorePutBatch106 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreDeleteBatch101', 0, async function (done) { + console.log('testSingleKvStoreDeleteBatch101'); + try { + let entries = []; + let keys = []; + for (var i = 0; i < 5; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + keys.push(key + i); + } + console.log('testSingleKvStoreDeleteBatch101 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testSingleKvStoreDeleteBatch101 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.deleteBatch(keys, async function (err,data) { + console.log('testSingleKvStoreDeleteBatch101 deleteBatch success'); + expect(err == undefined).assertTrue(); + done(); + }); + }); + }catch(e) { + console.log('testSingleKvStoreDeleteBatch101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreDeleteBatch102', 0, async function (done) { + console.log('testSingleKvStoreDeleteBatch102'); + try { + let keys = ['batch_test_string_key1', 'batch_test_string_key2']; + await kvStore.deleteBatch(keys, function (err,data) { + console.log('testSingleKvStoreDeleteBatch102 deleteBatch success'); + expect(err == undefined).assertTrue(); + done(); + }); + }catch(e) { + console.log('testSingleKvStoreDeleteBatch102 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreDeleteBatch103', 0, async function (done) { + console.log('testSingleKvStoreDeleteBatch103'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + console.log('testSingleKvStoreDeleteBatch103 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testSingleKvStoreDeleteBatch103 putBatch success'); + expect(err == undefined).assertTrue(); + let keys = ['batch_test_string_key1', 'batch_test_string_keya']; + await kvStore.deleteBatch(keys, async function (err,data) { + console.log('testSingleKvStoreDeleteBatch103 deleteBatch success'); + expect(err == undefined).assertTrue(); + done(); + }); + }); + }catch(e) { + console.log('testSingleKvStoreDeleteBatch103 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStorestartTransaction101', 0, async function (done) { + console.log('testSingleKvStorestartTransaction101'); + try { + // register dataChange callback + var count = 0; + kvStore.on('dataChange', 0, function (data) { + console.log('testSingleKvStorestartTransaction101 0' + data) + count++; + }); + // startTransaction + await kvStore.startTransaction(async function (err,data) { + console.log('testSingleKvStorestartTransaction101 startTransaction success'); + expect(err == undefined).assertTrue(); + let entries = putBatchString(10, 'batch_test_string_key'); + console.log('testSingleKvStorestartTransaction101 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testSingleKvStorestartTransaction101 putBatch success'); + expect(err == undefined).assertTrue(); + let keys = Object.keys(entries).slice(5); //delete 5 beginnings + await kvStore.deleteBatch(keys, async function (err,data) { + console.log('testSingleKvStorestartTransaction101 deleteBatch success'); + expect(err == undefined).assertTrue(); + // commit + await kvStore.commit(async function (err,data) { + console.log('testSingleKvStorestartTransaction101 commit success'); + expect(err == undefined).assertTrue(); + await sleep(2000); + // assert + expect(count == 1).assertTrue(); + done(); + }); + }); + }); + }); + }catch(e) { + console.log('testSingleKvStorestartTransaction101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStorestartTransaction102', 0, async function (done) { + console.log('testSingleKvStorestartTransaction102'); + try { + // register dataChange callback + var count = 0; + kvStore.on('dataChange', 0, function (data) { + console.log('testSingleKvStorestartTransaction102 0' + data) + count++; + }); + await kvStore.startTransaction(async function (err,data) { + console.log('testSingleKvStorestartTransaction102 startTransaction success'); + expect(err == undefined).assertTrue(); + let entries = putBatchString(10, 'batch_test_string_key'); + console.log('testSingleKvStorestartTransaction102 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testSingleKvStorestartTransaction102 putBatch success'); + expect(err == undefined).assertTrue(); + let keys = Object.keys(entries).slice(5); //delete 5 beginnings + await kvStore.deleteBatch(keys, async function (err,data) { + console.log('testSingleKvStorestartTransaction102 deleteBatch success'); + expect(err == undefined).assertTrue(); + // rollback + await kvStore.rollback(async function (err,data) { + console.log('testSingleKvStorestartTransaction102 rollback success'); + expect(err == undefined).assertTrue(); + await sleep(2000); + // assert + expect(count == 0).assertTrue(); + done(); + }); + }); + }); + }); + }catch(e) { + console.log('testSingleKvStorestartTransaction102 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStorestartTransaction103', 0, async function (done) { + console.log('testSingleKvStorestartTransaction103'); + try { + await kvStore.startTransaction(1, function (err,data) { + if (err == undefined) { + console.log('testSingleKvStorestartTransaction103 startTransaction success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStorestartTransaction103 startTransaction fail'); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStorestartTransaction103 e ' + e); + done(); + } + }) + + it('testSingleKvStorestartTransaction104', 0, async function (done) { + console.log('testSingleKvStorestartTransaction104'); + try { + await kvStore.startTransaction('test_string', function (err,data) { + if (err == undefined) { + console.log('testSingleKvStorestartTransaction104 startTransaction success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStorestartTransaction104 startTransaction fail'); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStorestartTransaction104 e ' + e); + done(); + } + }) + + it('testSingleKvStorestartTransaction105', 0, async function (done) { + console.log('testSingleKvStorestartTransaction105'); + try { + await kvStore.startTransaction(2.000, function (err,data) { + if (err == undefined) { + console.log('testSingleKvStorestartTransaction105 startTransaction success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStorestartTransaction105 startTransaction fail'); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStorestartTransaction105 e ' + e); + done(); + } + }) + + it('testSingleKvStoreCommit101', 0, async function (done) { + console.log('testSingleKvStoreCommit101'); + try { + await kvStore.commit(1, function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreCommit101 commit success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreCommit101 commit fail'); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreCommit101 e ' + e); + done(); + } + }) + + it('testSingleKvStoreCommit102', 0, async function (done) { + console.log('testSingleKvStoreCommit102'); + try { + await kvStore.commit('test_string', function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreCommit102 commit success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreCommit102 commit fail'); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreCommit102 e ' + e); + done(); + } + }) + + it('testSingleKvStoreCommit103', 0, async function (done) { + console.log('testSingleKvStoreCommit103'); + try { + await kvStore.commit(2.000, function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreCommit103 commit success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreCommit103 commit fail'); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreCommit103 e ' + e); + done(); + } + }) + + it('testSingleKvStoreRollback101', 0, async function (done) { + console.log('testSingleKvStoreRollback101'); + try { + await kvStore.rollback(1, function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreRollback101 commit success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreRollback101 commit fail'); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreRollback101 e ' + e); + done(); + } + }) + + it('testSingleKvStoreRollback102', 0, async function (done) { + console.log('testSingleKvStoreRollback102'); + try { + await kvStore.rollback('test_string', function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreRollback102 commit success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreRollback102 commit fail'); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreRollback102 e ' + e); + done(); + } + }) + + it('testSingleKvStoreRollback103', 0, async function (done) { + console.log('testSingleKvStoreRollback103'); + try { + await kvStore.rollback(2.000, function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreRollback103 commit success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreRollback103 commit fail'); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreRollback103 e ' + e); + done(); + } + }) + + it('testSingleKvStoreEnableSync101', 0, async function (done) { + console.log('testSingleKvStoreEnableSync101'); + try { + await kvStore.enableSync(true, function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreEnableSync101 enableSync success'); + expect(err == undefined).assertTrue(); + } else { + console.log('testSingleKvStoreEnableSync101 enableSync fail'); + expect(null).assertFail(); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreEnableSync101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreEnableSync102', 0, async function (done) { + console.log('testSingleKvStoreEnableSync102'); + try { + await kvStore.enableSync(false, function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreEnableSync102 enableSync success'); + expect(err == undefined).assertTrue(); + } else { + console.log('testSingleKvStoreEnableSync102 enableSync fail'); + expect(null).assertFail(); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreEnableSync102 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreEnableSync103', 0, async function (done) { + console.log('testSingleKvStoreEnableSync103'); + try { + await kvStore.enableSync(function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreEnableSync103 enableSync success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreEnableSync103 enableSync fail'); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreEnableSync103 e ' + e); + done(); + } + }) + + it('testSingleKvStoreEnableSync104', 0, async function (done) { + console.log('testSingleKvStoreEnableSync104'); + try { + await kvStore.enableSync(null, function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreEnableSync104 enableSync success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreEnableSync104 enableSync fail'); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreEnableSync104 e ' + e); + done(); + } + }) + + it('testSingleKvStoreRemoveDeviceData101', 0, async function (done) { + console.log('testSingleKvStoreRemoveDeviceData101'); + try { + await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, async function (err,data) { + console.log('testSingleKvStoreRemoveDeviceData101 put success'); + expect(err == undefined).assertTrue(); + var deviceid = 'no_exist_device_id'; + await kvStore.removeDeviceData(deviceid, async function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreRemoveDeviceData101 removeDeviceData success'); + expect(null).assertFail(); + done(); + } else { + console.log('testSingleKvStoreRemoveDeviceData101 removeDeviceData fail'); + await kvStore.get(KEY_TEST_STRING_ELEMENT, async function (err,data) { + console.log('testSingleKvStoreRemoveDeviceData101 get success'); + expect(data == VALUE_TEST_STRING_ELEMENT).assertTrue(); + done(); + }); + } + }); + }); + }catch(e) { + console.log('testSingleKvStoreRemoveDeviceData101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreRemoveDeviceData102', 0, async function (done) { + console.log('testSingleKvStoreRemoveDeviceData102'); + try { + await kvStore.removeDeviceData(function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreRemoveDeviceData102 removeDeviceData success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreRemoveDeviceData102 removeDeviceData fail'); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreRemoveDeviceData101 e ' + e); + done(); + } + }) + + it('testSingleKvStoreRemoveDeviceData103', 0, async function (done) { + console.log('testSingleKvStoreRemoveDeviceData103'); + try { + await kvStore.removeDeviceData('', function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreRemoveDeviceData103 removeDeviceData success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreRemoveDeviceData103 removeDeviceData fail'); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreRemoveDeviceData103 e ' + e); + done(); + } + }) + + it('testSingleKvStoreRemoveDeviceData104', 0, async function (done) { + console.log('testSingleKvStoreRemoveDeviceData104'); + try { + await kvStore.removeDeviceData(null, function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreRemoveDeviceData104 removeDeviceData success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreRemoveDeviceData104 removeDeviceData fail'); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreRemoveDeviceData104 e ' + e); + done(); + } + }) + + it('testSingleKvStoreSetSyncParam101', 0, async function (done) { + console.log('testSingleKvStoreSetSyncParam101'); + try { + var defaultAllowedDelayMs = 500; + await kvStore.setSyncParam(defaultAllowedDelayMs, function (err,data) { + console.log('testSingleKvStoreSetSyncParam101 put success'); + expect(err == undefined).assertTrue(); + done(); + }); + }catch(e) { + console.log('testSingleKvStoreSetSyncParam101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreSetSyncParam102', 0, async function (done) { + console.log('testSingleKvStoreSetSyncParam102'); + try { + await kvStore.setSyncParam(function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreSetSyncParam102 put success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreSetSyncParam102 put err' + err); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreSetSyncParam102 e ' + e); + done(); + } + }) + + it('testSingleKvStoreSetSyncParam103', 0, async function (done) { + console.log('testSingleKvStoreSetSyncParam103'); + try { + await kvStore.setSyncParam('', function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreSetSyncParam103 put success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreSetSyncParam103 put err' + err); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreSetSyncParam103 e ' + e); + done(); + } + }) + + it('testSingleKvStoreSetSyncParam104', 0, async function (done) { + console.log('testSingleKvStoreSetSyncParam104'); + try { + await kvStore.setSyncParam(null, function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreSetSyncParam104 put success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreSetSyncParam104 put err' + err); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreSetSyncParam104 e ' + e); + done(); + } + }) + + it('testSingleKvStoreGetSecurityLevel101', 0, async function (done) { + console.log('testSingleKvStoreGetSecurityLevel101'); + try { + await kvStore.getSecurityLevel(function (err,data) { + console.log('testSingleKvStoreGetSecurityLevel101 getSecurityLevel success'); + expect(data == factory.SecurityLevel.S2).assertTrue(); + done(); + }); + }catch(e) { + console.log('testSingleKvStoreGetSecurityLevel101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreGetSecurityLevel102', 0, async function (done) { + console.log('testSingleKvStoreGetSecurityLevel102'); + try { + await kvStore.getSecurityLevel(1, function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreGetSecurityLevel102 getSecurityLevel success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreGetSecurityLevel102 getSecurityLevel fail' + err); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreGetSecurityLevel102 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreGetSecurityLevel103', 0, async function (done) { + console.log('testSingleKvStoreGetSecurityLevel103'); + try { + await kvStore.getSecurityLevel('test_string', function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreGetSecurityLevel103 getSecurityLevel success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreGetSecurityLevel103 getSecurityLevel fail' + err); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreGetSecurityLevel103 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreGetSecurityLevel104', 0, async function (done) { + console.log('testSingleKvStoreGetSecurityLevel104'); + try { + await kvStore.getSecurityLevel(2.00, function (err,data) { + if (err == undefined) { + console.log('testSingleKvStoreGetSecurityLevel104 getSecurityLevel success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreGetSecurityLevel104 getSecurityLevel fail' + err); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreGetSecurityLevel104 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreGetResultSet101', 0, async function (done) { + console.log('testSingleKvStoreGetResultSet101'); + try { + let resultSet; + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries, async function (err, data) { + console.log('testSingleKvStoreGetResultSet101 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getResultSet('batch_test_string_key', async function (err, result) { + console.log('testSingleKvStoreGetResultSet101 getResultSet success'); + resultSet = result; + expect(resultSet.getCount() == 10).assertTrue(); + await kvStore.closeResultSet(resultSet, function (err, data) { + console.log('testSingleKvStoreGetResultSet101 closeResultSet success'); + expect(err == undefined).assertTrue(); + done(); + }) + }); + }); + }catch(e) { + console.log('testSingleKvStoreGetResultSet101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreGetResultSet102', 0, async function (done) { + console.log('testSingleKvStoreGetResultSet102'); + try { + let resultSet; + await kvStore.getResultSet('batch_test_string_key', async function (err, result) { + console.log('testSingleKvStoreGetResultSet102 getResultSet success'); + resultSet = result; + expect(resultSet.getCount() == 0).assertTrue(); + await kvStore.closeResultSet(resultSet, function (err, data) { + console.log('testSingleKvStoreGetResultSet102 closeResultSet success'); + expect(err == undefined).assertTrue(); + done(); + }) + }); + }catch(e) { + console.log('testSingleKvStoreGetResultSet102 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreGetResultSet103', 0, async function (done) { + console.log('testSingleKvStoreGetResultSet103'); + try { + let resultSet; + await kvStore.getResultSet(function (err, result) { + console.log('testSingleKvStoreGetResultSet103 getResultSet success'); + expect(err != undefined).assertTrue(); + done(); + }); + }catch(e) { + console.log('testSingleKvStoreGetResultSet103 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreGetResultSet104', 0, async function (done) { + console.log('testSingleKvStoreGetResultSet104'); + try { + let resultSet; + await kvStore.getResultSet('test_key_string', 123, function (err, result) { + console.log('testSingleKvStoreGetResultSet104 getResultSet success'); + expect(err != undefined).assertTrue(); + done(); + }); + }catch(e) { + console.log('testSingleKvStoreGetResultSet104 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreGetResultSet105', 0, async function (done) { + console.log('testSingleKvStoreGetResultSet105'); + try { + let resultSet; + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries, async function (err, data) { + console.log('testSingleKvStoreGetResultSet105 putBatch success'); + expect(err == undefined).assertTrue(); + var query = new factory.Query(); + query.prefixKey("batch_test"); + await kvStore.getResultSet(query, async function (err, result) { + console.log('testSingleKvStoreGetResultSet105 getResultSet success'); + resultSet = result; + expect(resultSet.getCount() == 10).assertTrue(); + await kvStore.closeResultSet(resultSet, function (err, data) { + console.log('testSingleKvStoreGetResultSet105 closeResultSet success'); + expect(err == undefined).assertTrue(); + done(); + }) + }); + }); + } catch(e) { + console.log('testSingleKvStoreGetResultSet105 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreGetResultSet106', 0, async function (done) { + console.log('testSingleKvStoreGetResultSet106'); + try { + let resultSet; + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries, async function (err, data) { + console.log('testSingleKvStoreGetResultSet106 putBatch success'); + expect(err == undefined).assertTrue(); + var query = new factory.Query(); + query.prefixKey("batch_test"); + await kvStore.getResultSet(query, async function (err, result) { + console.log('testSingleKvStoreGetResultSet106 getResultSet success'); + resultSet = result; + expect(resultSet.getCount() == 10).assertTrue(); + await kvStore.closeResultSet(resultSet, function (err, data) { + console.log('testSingleKvStoreGetResultSet106 closeResultSet success'); + expect(err == undefined).assertTrue(); + done(); + }) + }); + }); + } catch(e) { + console.log('testSingleKvStoreGetResultSet106 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreCloseResultSet101', 0, async function (done) { + console.log('testSingleKvStoreCloseResultSet101'); + try { + console.log('testSingleKvStoreCloseResultSet101 success'); + let resultSet = null; + await kvStore.closeResultSet(resultSet, function (err, data) { + if (err == undefined) { + console.log('testSingleKvStoreCloseResultSet101 closeResultSet success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreCloseResultSet101 closeResultSet fail'); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreCloseResultSet101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreCloseResultSet102', 0, async function (done) { + console.log('testSingleKvStoreCloseResultSet102'); + try { + let resultSet = null; + await kvStore.getResultSet('batch_test_string_key', async function(err, result) { + console.log('testSingleKvStoreCloseResultSet102 getResultSet success'); + resultSet = result; + await kvStore.closeResultSet(resultSet, function (err, data) { + if (err == undefined) { + console.log('testSingleKvStoreCloseResultSet102 closeResultSet success'); + expect(err == undefined).assertTrue(); + } else { + console.log('testSingleKvStoreCloseResultSet102 closeResultSet fail'); + expect(null).assertFail(); + } + done(); + }); + }); + }catch(e) { + console.log('testSingleKvStoreCloseResultSet102 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreCloseResultSet103', 0, async function (done) { + console.log('testSingleKvStoreCloseResultSet103'); + try { + console.log('testSingleKvStoreCloseResultSet103 success'); + await kvStore.closeResultSet(function (err, data) { + if (err == undefined) { + console.log('testSingleKvStoreCloseResultSet103 closeResultSet success'); + expect(null).assertFail(); + } else { + console.log('testSingleKvStoreCloseResultSet103 closeResultSet fail'); + } + done(); + }); + }catch(e) { + console.log('testSingleKvStoreCloseResultSet103 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreCloseResultSet104', 0, async function (done) { + console.log('testSingleKvStoreCloseResultSet104'); + try { + // pass query + console.log('testSingleKvStoreCloseResultSet104 success'); + }catch(e) { + console.log('testSingleKvStoreCloseResultSet104 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreGetResultSize101', 0, async function (done) { + console.log('testSingleKvStoreGetResultSize101'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries, async function (err, data) { + console.log('testSingleKvStoreGetResultSize101 putBatch success'); + expect(err == undefined).assertTrue(); + var query = new factory.Query(); + query.prefixKey("batch_test"); + await kvStore.getResultSize(query, async function (err, resultSize) { + console.log('testSingleKvStoreGetResultSize101 getResultSet success'); + expect(resultSize == 10).assertTrue(); + done(); + }); + }); + } catch(e) { + console.log('testSingleKvStoreGetResultSize101 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreGetResultSize102', 0, async function (done) { + console.log('testSingleKvStoreGetResultSize102'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries, async function (err, data) { + console.log('testSingleKvStoreGetResultSize102 putBatch success'); + expect(err == undefined).assertTrue(); + var query = new factory.Query(); + query.prefixKey("batch_test"); + await kvStore.getResultSize(query, async function (err, resultSize) { + console.log('testSingleKvStoreGetResultSize102 getResultSet success'); + expect(resultSize == 10).assertTrue(); + done(); + }); + }); + } catch(e) { + console.log('testSingleKvStoreGetResultSize102 e ' + e); + expect(null).assertFail(); + done(); + } + }) + + it('testSingleKvStoreGetEntries101', 0, async function (done) { + console.log('testSingleKvStoreGetEntries101'); + try { + var arr = new Uint8Array([21,31]); + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_bool_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.BYTE_ARRAY, + value : arr + } + } + entries.push(entry); + } + console.log('testSingleKvStoreGetEntries101 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testSingleKvStoreGetEntries101 putBatch success'); + expect(err == undefined).assertTrue(); + var query = new factory.Query(); + query.prefixKey("batch_test"); + await kvStore.getEntries(query, function (err,entrys) { + console.log('testSingleKvStoreGetEntries101 getEntries success'); + console.log('testSingleKvStoreGetEntries101 entrys.length: ' + entrys.length); + console.log('testSingleKvStoreGetEntries101 entrys[0]: ' + JSON.stringify(entrys[0])); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value.toString() == arr.toString()).assertTrue(); + done(); + }); + }); + console.log('testSingleKvStoreGetEntries101 success'); + }catch(e) { + console.log('testSingleKvStoreGetEntries101 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreGetEntries102', 0, async function (done) { + console.log('testSingleKvStoreGetEntries102'); + try { + var arr = new Uint8Array([21,31]); + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_bool_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.BYTE_ARRAY, + value : arr + } + } + entries.push(entry); + } + console.log('testSingleKvStoreGetEntries102 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries, async function (err,data) { + console.log('testSingleKvStoreGetEntries102 putBatch success'); + expect(err == undefined).assertTrue(); + var query = new factory.Query(); + query.prefixKey("batch_test"); + await kvStore.getEntries(query, function (err,entrys) { + console.log('testSingleKvStoreGetEntries102 getEntries success'); + console.log('testSingleKvStoreGetEntries102 entrys.length: ' + entrys.length); + console.log('testSingleKvStoreGetEntries102 entrys[0]: ' + JSON.stringify(entrys[0])); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value.toString() == arr.toString()).assertTrue(); + done(); + }); }); - await(3000); + console.log('testSingleKvStoreGetEntries101 success'); + console.log('testSingleKvStoreGetEntries102 success'); }catch(e) { + console.log('testSingleKvStoreGetEntries102 e ' + e); expect(null).assertFail(); } done(); diff --git a/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/SingleKvStoreEnumJsunit.test.js b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/SingleKvStoreEnumJsunit.test.js index 598b66480ed6dc963d42bc2fae5b1cdb33f53296..535f6803a5e2f1542aa26eae5ec784e4f3a5dd6f 100644 --- a/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/SingleKvStoreEnumJsunit.test.js +++ b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/SingleKvStoreEnumJsunit.test.js @@ -16,169 +16,169 @@ import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from ' import factory from '@ohos.data.distributedData'; describe('KvStoreEnumTest', function () { - it('enum_usertype_test_same_user_id', 0, function () { + it('enumUsertypeTestSameUserId', 0, function () { var sameUserId = factory.UserType.SAME_USER_ID; console.info('sameUserId = ' + sameUserId); expect(sameUserId == 0).assertTrue() }) - it('enum_constants_test_max_key_length', 0, function () { + it('enumConstantsTestMaxKeyLength', 0, function () { var maxKeyLength = factory.Constants.MAX_KEY_LENGTH; console.info('maxKeyLength = ' + maxKeyLength); expect(maxKeyLength == 1024).assertTrue() }) - it('enum_constants_test_max_value_length', 0, function () { + it('enumConstantsTestMaxValueLength', 0, function () { var maxValueLength = factory.Constants.MAX_VALUE_LENGTH; console.info('maxValueLength = ' + maxValueLength); expect(maxValueLength == 4194303).assertTrue() }) - it('enum_constants_test_max_key_length_device', 0, function () { + it('enumConstantsTestMaxKeyLengthDevice', 0, function () { var maxKeyLengthDevice = factory.Constants.MAX_KEY_LENGTH_DEVICE; console.info('maxKeyLengthDevice = ' + maxKeyLengthDevice); expect(maxKeyLengthDevice == 896).assertTrue() }) - it('enum_constants_test_max_store_id_length', 0, function () { + it('enumConstantsTestMaxStoreIdLength', 0, function () { var maxStoreIdLength = factory.Constants.MAX_STORE_ID_LENGTH; console.info('maxStoreIdLength = ' + maxStoreIdLength); expect(maxStoreIdLength == 128).assertTrue() }) - it('enum_constants_test_max_query_length', 0, function () { + it('enumConstantsTestMaxQueryLength', 0, function () { var maxQueryLength = factory.Constants.MAX_QUERY_LENGTH; console.info('maxQueryLength = ' + maxQueryLength); expect(maxQueryLength == 512000).assertTrue() }) - it('enum_constants_test_max_batch_size', 0, function () { + it('enumConstantsTestMaxBatchSize', 0, function () { var maxBatchSize = factory.Constants.MAX_BATCH_SIZE; console.info('maxBatchSize = ' + maxBatchSize); expect(maxBatchSize == 128).assertTrue() }) - it('enum_valuetype_test_string', 0, function () { + it('enumValuetypeTestString', 0, function () { var string = factory.ValueType.STRING; console.info('string = ' + string); expect(string == 0).assertTrue() }) - it('enum_valuetype_test_integer', 0, function () { + it('enumValuetypeTestInteger', 0, function () { var integer = factory.ValueType.INTEGER; console.info('integer = ' + integer); expect(integer == 1).assertTrue() }) - it('enum_valuetype_test_float', 0, function () { + it('enumValuetypeTestFloat', 0, function () { var float = factory.ValueType.FLOAT; console.info('float = ' + float); expect(float == 2).assertTrue() }) - it('enum_valuetype_test_byte_array', 0, function () { + it('enumValuetypeTestByteArray', 0, function () { var byteArray = factory.ValueType.BYTE_ARRAY; console.info('byteArray = ' + byteArray); expect(byteArray == 3).assertTrue() }) - it('enum_valuetype_test_boolean', 0, function () { + it('enumValuetypeTestBoolean', 0, function () { var boolean = factory.ValueType.BOOLEAN; console.info('boolean = ' + boolean); expect(boolean == 4).assertTrue() }) - it('enum_valuetype_test_double', 0, function () { + it('enumValuetypeTestDouble', 0, function () { var double = factory.ValueType.DOUBLE; console.info('double = ' + double); expect(double == 5).assertTrue() }) - it('enum_syncmode_test_pull_only', 0, function () { + it('enumSyncmodeTestPullOnly', 0, function () { var pullonly = factory.SyncMode.PULL_ONLY; console.info('pullonly = ' + pullonly); expect(pullonly == 0).assertTrue() }) - it('enum_syncmode_test_push_only', 0, function () { + it('enumSyncmodeTestPushOnly', 0, function () { var pushonly = factory.SyncMode.PUSH_ONLY; console.info('pushonly = ' + pushonly); expect(pushonly == 1).assertTrue() }) - it('enum_syncmode_test_push_pull', 0, function () { + it('enumSyncmodeTestPushPull', 0, function () { var pushpull = factory.SyncMode.PUSH_PULL; console.info('pushpull = ' + pushpull); expect(pushpull == 2).assertTrue() }) - it('enum_subscribetype_test_subscribe_type_local', 0, function () { + it('enumSubscribetypeTestSubscribeTypeLocal', 0, function () { var local = factory.SubscribeType.SUBSCRIBE_TYPE_LOCAL; console.info('local = ' + local); expect(local == 0).assertTrue() }) - it('enum_subscribetype_test_subscribe_type_remote', 0, function () { + it('enumSubscribetypeTestSubscribeTypeRemote', 0, function () { var remote = factory.SubscribeType.SUBSCRIBE_TYPE_REMOTE; console.info('remote = ' + remote); expect(remote == 1).assertTrue() }) - it('enum_subscribetype_test_subscribe_type_all', 0, function () { + it('enumSubscribetypeTestSubscribeTypeAll', 0, function () { var all = factory.SubscribeType.SUBSCRIBE_TYPE_ALL; console.info('all = ' + all); expect(all == 2).assertTrue() }) - it('enum_kvstoretype_test_device_collaboration', 0, function () { + it('enumKvstoretypeTestDeviceCollaboration', 0, function () { var collaboration = factory.KVStoreType.DEVICE_COLLABORATION; console.info('collaboration = ' + collaboration); expect(collaboration == 0).assertTrue() }) - it('enum_kvstoretype_test_single_version', 0, function () { + it('enumKvstoretypeTestSingleVersion', 0, function () { var single = factory.KVStoreType.SINGLE_VERSION; console.info('single = ' + single); expect(single == 1).assertTrue() }) - it('enum_kvstoretype_test_multi_version', 0, function () { + it('enumKvstoretypeTestMultiVersion', 0, function () { var multi = factory.KVStoreType.MULTI_VERSION; console.info('multi = ' + multi); expect(multi == 2).assertTrue() }) - it('enum_securitylevel_test_no_level', 0, function () { + it('enumSecuritylevelTestNoLevel', 0, function () { var nolevel = factory.SecurityLevel.NO_LEVEL; console.info('nolevel = ' + nolevel); expect(nolevel == 0).assertTrue() }) - it('enum_securitylevel_test_s0', 0, function () { + it('enumSecuritylevelTestS0', 0, function () { var s0 = factory.SecurityLevel.S0; console.info('s0 = ' + s0); expect(s0 == 1).assertTrue() }) - it('enum_securitylevel_test_s1', 0, function () { + it('enumSecuritylevelTestS1', 0, function () { var s1 = factory.SecurityLevel.S1; console.info('s1 = ' + s1); expect(s1 == 2).assertTrue() }) - it('enum_securitylevel_test_s2', 0, function () { + it('enumSecuritylevelTestS2', 0, function () { var s2 = factory.SecurityLevel.S2; console.info('s2 = ' + s2); expect(s2 == 3).assertTrue() }) - it('enum_securitylevel_test_s3', 0, function () { + it('enumSecuritylevelTestS3', 0, function () { var s3 = factory.SecurityLevel.S3; console.info('s3 = ' + s3); expect(s3 == 5).assertTrue() }) - it('enum_securitylevel_test_s4', 0, function () { + it('enumSecuritylevelTestS4', 0, function () { var s4 = factory.SecurityLevel.S4; console.info('s4 = ' + s4); expect(s4 == 6).assertTrue() diff --git a/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/SingleKvStorePromiseJsunit.test.js b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/SingleKvStorePromiseJsunit.test.js index efa15af31c2ecd07cf546a1057192b90f00bc564..37a6e1c03a42ec192d263e1bb311fceda50eb231 100755 --- a/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/SingleKvStorePromiseJsunit.test.js +++ b/distributeddatamgr/distributeddatamgrjstest/hap/src/main/js/default/test/SingleKvStorePromiseJsunit.test.js @@ -26,25 +26,37 @@ const VALUE_TEST_FLOAT_ELEMENT = 321.12; const VALUE_TEST_BOOLEAN_ELEMENT = true; const VALUE_TEST_STRING_ELEMENT = 'value-string-001'; const VALUE_TEST_SYNC_ELEMENT = 'value-string-001'; -const SINGLE_VERSION = 1; -const SECURITY_LEVEL = 3; - -const PULL_ONLY = 0; -const PUSH_ONLY = 1; -const PUSH_PULL = 2; +const TEST_BUNDLE_NAME = 'ohos.acts.distributeddatamgr'; +const TEST_STORE_ID = 'storeId'; var kvManager = null; var kvStore = null; function sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); } -describe('KvStoreTest', function () { + +function putBatchString(len, prefix) { + let entries = []; + for (var i = 0; i < len; i++) { + var entry = { + key : prefix + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + return entries; +} + +describe('SingleKvStorePromiseTest', function () { const config = { - bundleName : 'ohos.acts.distributeddatamgr', + bundleName : TEST_BUNDLE_NAME, userInfo : { userId : '0', - userType : 0 + userType : factory.UserType.SAME_USER_ID } } @@ -53,585 +65,2145 @@ describe('KvStoreTest', function () { encrypt : false, backup : false, autoSync : true, - kvStoreType : SINGLE_VERSION, + kvStoreType : factory.KVStoreType.SINGLE_VERSION, schema : '', - securityLevel : SECURITY_LEVEL, + securityLevel : factory.SecurityLevel.S2, } - it('testCreateKVManager001', 0, async function (done) { - try { - const promise = factory.createKVManager(config); - promise.then((manager) => { - kvManager = manager; - expect(false).assertEqual(manager == null); - }).catch((err) => { - expect(null).assertFail(); - }); - await sleep(3000); - }catch (e) { - expect(null).assertFail(); - } + beforeAll(async function (done) { + console.log('beforeAll config:'+ JSON.stringify(config)); + await factory.createKVManager(config).then((manager) => { + kvManager = manager; + console.log('beforeAll createKVManager success'); + }).catch((err) => { + console.log('beforeAll createKVManager err ' + err); + }); + console.log('beforeAll end'); done(); }) - it('testGetKVStore001', 0, async function (done) { - try { - const promise = kvManager.getKVStore(options); - promise.then((store) => { - kvStore = store; - expect(false).assertEqual(store == null); - }).catch((err) => { - expect(null).assertFail(); - }); - expect(null).assertFail(); - await sleep(3000); - } catch (e) { - } + afterAll(async function (done) { + console.log('afterAll'); + kvManager = null; + kvStore = null; done(); }) - it('testGetKVStore001', 0, async function (done) { - try { - const promise = kvManager.getKVStore('storeId', options); - promise.then((store) => { - kvStore = store; - expect(false).assertEqual(store == null); + beforeEach(async function (done) { + console.log('beforeEach' + JSON.stringify(options)); + await kvManager.getKVStore(TEST_STORE_ID, options).then((store) => { + kvStore = store; + console.log('beforeEach getKVStore success'); + }).catch((err) => { + console.log('beforeEach getKVStore err ' + err); + }); + console.log('beforeEach end'); + done(); + }) + + afterEach(async function (done) { + console.log('afterEach'); + await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, kvStore).then(async () => { + console.log('afterEach closeKVStore success'); + await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID).then(() => { + console.log('afterEach deleteKVStore success'); + kvStore = null; }).catch((err) => { - expect(null).assertFail(); + console.log('afterEach deleteKVStore err ' + err); }); - await sleep(3000); - }catch(e) { - expect(null).assertFail(); - } + }).catch((err) => { + console.log('afterEach closeKVStore err ' + err); + }); done(); }) - it('testPutString003', 0, async function (done) { + it('testSingleKvStorePutString001', 0, async function (done) { + console.log('testSingleKvStorePutString001'); try { - const promise = kvStore.put(KEY_TEST_STRING_ELEMENT, null); - promise.then((data) => { - }).catch((err) => { + await kvStore.put(KEY_TEST_STRING_ELEMENT, null).then((data) => { + console.log('testSingleKvStorePutString001 put success'); expect(null).assertFail(); + }).catch((error) => { + console.log('testSingleKvStorePutString001 put error' + error); }); - await sleep(3000); } catch (e) { + console.log('testSingleKvStorePutString001 e ' + e); expect(null).assertFail(); } done(); }) - it('testPutString004', 0, async function (done) { + it('testSingleKvStorePutString002', 0, async function (done) { + console.log('testSingleKvStorePutString002'); try { - const promise = kvStore.put(KEY_TEST_STRING_ELEMENT, ''); - promise.then((data) => { - }).catch((err) => { + await kvStore.put(KEY_TEST_STRING_ELEMENT, '').then((data) => { + console.log('testSingleKvStorePutString002 put success'); + expect(data == undefined).assertTrue(); + }).catch((error) => { + console.log('testSingleKvStorePutString002 put error' + error); expect(null).assertFail(); }); - await sleep(3000); } catch (e) { + console.log('testSingleKvStorePutString002 e ' + e); expect(null).assertFail(); } done(); }) - it('testPutString0051', 0, async function (done) { + it('testSingleKvStorePutString003', 0, async function (done) { + console.log('testSingleKvStorePutString003'); try { - const promise = kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT); - promise.then((data) => { - }).catch((err) => { + await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then((data) => { + console.log('testSingleKvStorePutString003 put success'); + expect(data == undefined).assertTrue(); + }).catch((error) => { + console.log('testSingleKvStorePutString003 put error' + error); expect(null).assertFail(); }); - await sleep(3000); } catch (e) { + console.log('testSingleKvStorePutString003 e ' + e); expect(null).assertFail(); } done(); }) - it('testGetString001', 0, async function (done) { + it('testSingleKvStorePutString004', 0, async function (done) { + console.log('testSingleKvStorePutString004'); try { - const promise = kvStore.get(KEY_TEST_STRING_ELEMENT); - promise.then((data) => { - expect(VALUE_TEST_STRING_ELEMENT).assertEqual(data); - }).catch((err) => { + var str = ''; + for (var i = 0 ; i < 4095; i++) { + str += 'x'; + } + await kvStore.put(KEY_TEST_STRING_ELEMENT, str).then(async (data) => { + console.log('testSingleKvStorePutString004 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(KEY_TEST_STRING_ELEMENT).then((data) => { + console.log('testSingleKvStorePutString004 get success data ' + data); + expect(str == data).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorePutString004 get fail ' + err); + expect(null).assertFail(); + }); + }).catch((error) => { + console.log('testSingleKvStorePutString004 put error' + error); expect(null).assertFail(); }); - await sleep(3000); - }catch (e){ + } catch (e) { + console.log('testSingleKvStorePutString004 e ' + e); expect(null).assertFail(); } done(); }) - it('testPutString0021', 0, async function (done) { + it('testSingleKvStoreGetString001', 0, async function (done) { + console.log('testSingleKvStoreGetString001'); try { - var str = ''; - for (var i = 0 ; i < 4095; i++) { - str += 'x'; - } - const promise = kvStore.put(KEY_TEST_STRING_ELEMENT+'002', str); - promise.then((data) => { - const promise1 = kvStore.get(KEY_TEST_STRING_ELEMENT + '002'); - promise1.then((data) => { - expect(str).assertEqual(data); + await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then(async (data) => { + console.log('testSingleKvStoreGetString001 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(KEY_TEST_STRING_ELEMENT).then((data) => { + console.log('testSingleKvStoreGetString001 get success'); + expect(VALUE_TEST_STRING_ELEMENT == data).assertTrue(); }).catch((err) => { + console.log('testSingleKvStoreGetString001 get fail ' + err); expect(null).assertFail(); }); - }).catch((err) => { + }).catch((error) => { + console.log('testSingleKvStoreGetString001 put error' + error); expect(null).assertFail(); }); - await sleep(3000); - }catch (e) { + } catch (e) { + console.log('testSingleKvStoreGetString001 e ' + e); expect(null).assertFail(); } done(); }) - it('testPutString005', 0, async function (done) { + it('testSingleKvStoreGetString002', 0, async function (done) { + console.log('testSingleKvStoreGetString002'); try { - const promise1 = kvStore.get(KEY_TEST_STRING_ELEMENT + '005'); - promise1.then((data) => { + await kvStore.get(KEY_TEST_STRING_ELEMENT).then((data) => { + console.log('testSingleKvStoreGetString002 get success'); expect(null).assertFail(); }).catch((err) => { + console.log('testSingleKvStoreGetString002 get fail ' + err); }); - await sleep(3000); - }catch(e) { + } catch (e) { + console.log('testSingleKvStoreGetString002 get e ' + e); } done(); }) - it('testPutInt001', 0, async function (done) { + it('testSingleKvStorePutInt001', 0, async function (done) { + console.log('testSingleKvStorePutInt001'); try { - const promise = kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT); - promise.then((data) => { + await kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT).then((data) => { + console.log('testSingleKvStorePutInt001 put success'); + expect(data == undefined).assertTrue(); }).catch((err) => { + console.log('testSingleKvStorePutInt001 put fail ' + err); expect(null).assertFail(); }); - await sleep(3000); - }catch(e) { + } catch (e) { + console.log('testSingleKvStorePutInt001 put e ' + e); expect(null).assertFail(); } done(); }) - it('testGetInt001', 0, async function (done) { + it('testSingleKvStorePutInt002', 0, async function (done) { + console.log('testSingleKvStorePutInt002'); try { - const promise = kvStore.put(KEY_TEST_INT_ELEMENT+ '001', VALUE_TEST_INT_ELEMENT); - promise.then((data) => { - const promise1 = kvStore.get(KEY_TEST_INT_ELEMENT+ '001'); - promise1.then((data) => { - expect(VALUE_TEST_INT_ELEMENT).assertEqual(data); + var intValue = 987654321; + await kvStore.put(KEY_TEST_INT_ELEMENT, intValue).then(async (data) => { + console.log('testSingleKvStorePutInt002 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(KEY_TEST_INT_ELEMENT).then((data) => { + console.log('testSingleKvStorePutInt002 get success'); + expect(intValue == data).assertTrue(); }).catch((err) => { + console.log('testSingleKvStorePutInt002 get fail ' + err); expect(null).assertFail(); }); }).catch((err) => { + console.log('testSingleKvStorePutInt002 put fail ' + err); expect(null).assertFail(); }); - await sleep(3000); - }catch(e) { + } catch (e) { + console.log('testSingleKvStorePutInt002 put e ' + e); expect(null).assertFail(); } done(); }) - it('testPutInt002', 0, async function (done) { + it('testSingleKvStorePutInt003', 0, async function (done) { + console.log('testSingleKvStorePutInt003'); try { - var intValue = 987654321; - const promise = kvStore.put(KEY_TEST_INT_ELEMENT+'002', intValue); - promise.then((data) => { - const promise1 = kvStore.get(KEY_TEST_INT_ELEMENT+'002'); - promise1.then((data) => { - expect(intValue).assertEqual(data); + var intValue = Number.MAX_VALUE; + await kvStore.put(KEY_TEST_INT_ELEMENT, intValue).then(async (data) => { + console.log('testSingleKvStorePutInt003 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(KEY_TEST_INT_ELEMENT).then((data) => { + console.log('testSingleKvStorePutInt003 get success'); + expect(intValue == data).assertTrue(); }).catch((err) => { + console.log('testSingleKvStorePutInt003 get fail ' + err); expect(null).assertFail(); }); }).catch((err) => { + console.log('testSingleKvStorePutInt003 put fail ' + err); expect(null).assertFail(); }); - await sleep(3000); - }catch(e) { + } catch (e) { + console.log('testSingleKvStorePutInt003 put e ' + e); expect(null).assertFail(); } done(); }) - it('testPutInt003', 0, async function (done) { - try{ - var intValue = Number.MAX_VALUE; - const promise = kvStore.put(KEY_TEST_INT_ELEMENT+'003', intValue); - promise.then((data) => { - const promise1 = kvStore.get(KEY_TEST_INT_ELEMENT+'003'); - promise1.then((data) => { - expect(intValue).assertEqual(data); + it('testSingleKvStorePutInt004', 0, async function (done) { + console.log('testSingleKvStorePutInt004'); + try { + var intValue = Number.MIN_VALUE; + await kvStore.put(KEY_TEST_INT_ELEMENT, intValue).then(async (data) => { + console.log('testSingleKvStorePutInt004 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(KEY_TEST_INT_ELEMENT).then((data) => { + console.log('testSingleKvStorePutInt004 get success'); + expect(intValue == data).assertTrue(); }).catch((err) => { + console.log('testSingleKvStorePutInt004 get fail ' + err); expect(null).assertFail(); }); }).catch((err) => { + console.log('testSingleKvStorePutInt004 put fail ' + err); expect(null).assertFail(); }); - await sleep(3000); - }catch(e) { + } catch (e) { + console.log('testSingleKvStorePutInt004 put e ' + e); expect(null).assertFail(); } done(); }) - it('testPutInt004', 0, async function (done) { - try{ - var intValue = Number.MIN_VALUE; - const promise = kvStore.put(KEY_TEST_INT_ELEMENT+'004', intValue); - promise.then((data) => { - const promise1 = kvStore.get(KEY_TEST_INT_ELEMENT+'004'); - promise1.then((data) => { - expect(intValue).assertEqual(data); + it('testSingleKvStoreGetInt001', 0, async function (done) { + console.log('testSingleKvStoreGetInt001'); + try { + await kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT).then(async (data) => { + console.log('testSingleKvStoreGetInt001 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(KEY_TEST_INT_ELEMENT).then((data) => { + console.log('testSingleKvStoreGetInt001 get success'); + expect(VALUE_TEST_INT_ELEMENT == data).assertTrue(); }).catch((err) => { + console.log('testSingleKvStoreGetInt001 get fail ' + err); expect(null).assertFail(); }); }).catch((err) => { + console.log('testSingleKvStoreGetInt001 put fail ' + err); expect(null).assertFail(); }); - await sleep(3000); - }catch(e) { + } catch (e) { + console.log('testSingleKvStoreGetInt001 put e ' + e); expect(null).assertFail(); } done(); }) - it('testPutBoolean001', 0, async function (done) { - try{ - const promise = kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, VALUE_TEST_BOOLEAN_ELEMENT); - promise.then((data) => { + it('testSingleKvStorePutBool001', 0, async function (done) { + console.log('testSingleKvStorePutBool001'); + try { + await kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, VALUE_TEST_BOOLEAN_ELEMENT).then((data) => { + console.log('testSingleKvStorePutBool001 put success'); + expect(data == undefined).assertTrue(); }).catch((err) => { + console.log('testSingleKvStorePutBool001 put fail ' + err); expect(null).assertFail(); }); - await sleep(3000); - }catch(e) { + } catch (e) { + console.log('testSingleKvStorePutBool001 put e ' + e); expect(null).assertFail(); } done(); }) - it('testGetBoolean002', 0, async function (done) { - var boolValue = false; - const promise = kvStore.put(KEY_TEST_BOOLEAN_ELEMENT+ '002', boolValue); - promise.then((data) => { - const promise1 = kvStore.get(KEY_TEST_BOOLEAN_ELEMENT+ '002'); - promise1.then((data) => { - expect(boolValue).assertEqual(data); + it('testSingleKvStoreGetBool001', 0, async function (done) { + console.log('testSingleKvStoreGetBool001'); + try { + var boolValue = false; + await kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, boolValue).then(async (data) => { + console.log('testSingleKvStoreGetBool001 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(KEY_TEST_BOOLEAN_ELEMENT).then((data) => { + console.log('testSingleKvStoreGetBool001 get success'); + expect(boolValue == data).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreGetBool001 get fail ' + err); + expect(null).assertFail(); + }); }).catch((err) => { + console.log('testSingleKvStoreGetBool001 put fail ' + err); expect(null).assertFail(); }); - }).catch((err) => { + } catch (e) { + console.log('testSingleKvStoreGetBool001 put e ' + e); expect(null).assertFail(); - }); - await sleep(3000); + } done(); }) - it('testPutFloat001', 0, async function (done) { + it('testSingleKvStorePutFloat001', 0, async function (done) { + console.log('testSingleKvStorePutFloat001'); try { - const promise = kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT); - promise.then((data) => { + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT).then((data) => { + console.log('testSingleKvStorePutFloat001 put success'); + expect(data == undefined).assertTrue(); }).catch((err) => { + console.log('testSingleKvStorePutFloat001 put fail ' + err); expect(null).assertFail(); }); - await sleep(3000); - }catch(e) { + } catch (e) { + console.log('testSingleKvStorePutFloat001 put e ' + e); expect(null).assertFail(); } done(); }) - it('testGetFloat002', 0, async function (done) { + it('testSingleKvStoreGetFloat001', 0, async function (done) { + console.log('testSingleKvStoreGetFloat001'); try { var floatValue = 123456.654321; - const promise = kvStore.put(KEY_TEST_FLOAT_ELEMENT+ '002', floatValue); - promise.then((data) => { - const promise1 = kvStore.get(KEY_TEST_FLOAT_ELEMENT+ '002'); - promise1.then((data) => { - expect(floatValue).assertEqual(data); + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, floatValue).then(async (data) => { + console.log('testSingleKvStoreGetFloat001 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(KEY_TEST_FLOAT_ELEMENT).then((data) => { + console.log('testSingleKvStoreGetFloat001 get success'); + expect(floatValue == data).assertTrue(); }).catch((err) => { + console.log('testSingleKvStoreGetFloat001 get fail ' + err); expect(null).assertFail(); }); }).catch((err) => { + console.log('testSingleKvStoreGetFloat001 put fail ' + err); expect(null).assertFail(); }); - await sleep(3000); - }catch (e) { + } catch (e) { + console.log('testSingleKvStoreGetFloat001 put e ' + e); expect(null).assertFail(); } done(); }) - it('testGetFloat003', 0, async function (done) { + it('testSingleKvStoreGetFloat002', 0, async function (done) { + console.log('testSingleKvStoreGetFloat002'); try { var floatValue = 123456.0; - const promise = kvStore.put(KEY_TEST_FLOAT_ELEMENT+ '003', floatValue); - promise.then((data) => { - const promise1 = kvStore.get(KEY_TEST_FLOAT_ELEMENT+ '003'); - promise1.then((data) => { - expect(floatValue).assertEqual(data); + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, floatValue).then(async (data) => { + console.log('testSingleKvStoreGetFloat002 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(KEY_TEST_FLOAT_ELEMENT).then((data) => { + console.log('testSingleKvStoreGetFloat002 get success'); + expect(floatValue == data).assertTrue(); }).catch((err) => { + console.log('testSingleKvStoreGetFloat002 get fail ' + err); expect(null).assertFail(); }); }).catch((err) => { + console.log('testSingleKvStoreGetFloat002 put fail ' + err); expect(null).assertFail(); }); - await sleep(3000); - }catch (e) { + } catch (e) { + console.log('testSingleKvStoreGetFloat002 put e ' + e); expect(null).assertFail(); } done(); }) - it('testGetFloat004', 0, async function (done) { + it('testSingleKvStoreGetFloat003', 0, async function (done) { + console.log('testSingleKvStoreGetFloat003'); try { var floatValue = 123456.00; - const promise = kvStore.put(KEY_TEST_FLOAT_ELEMENT+ '004', floatValue); - promise.then((data) => { - const promise1 = kvStore.get(KEY_TEST_FLOAT_ELEMENT+ '004'); - promise1.then((data) => { - expect(floatValue).assertEqual(data); + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, floatValue).then(async (data) => { + console.log('testSingleKvStoreGetFloat003 put success'); + expect(data == undefined).assertTrue(); + await kvStore.get(KEY_TEST_FLOAT_ELEMENT).then((data) => { + console.log('testSingleKvStoreGetFloat003 get success'); + expect(floatValue == data).assertTrue(); }).catch((err) => { + console.log('testSingleKvStoreGetFloat003 get fail ' + err); expect(null).assertFail(); }); }).catch((err) => { + console.log('testSingleKvStoreGetFloat003 put fail ' + err); expect(null).assertFail(); }); - await sleep(3000); - }catch (e) { + } catch (e) { + console.log('testSingleKvStoreGetFloat003 put e ' + e); expect(null).assertFail(); } done(); }) - it('testDeleteString001', 0, async function (done) { + it('testSingleKvStoreDeleteString001', 0, async function (done) { + console.log('testSingleKvStoreDeleteString001'); try { var str = 'this is a test string'; - const promise = kvStore.put(KEY_TEST_STRING_ELEMENT+'003', str); - promise.then((data) => { - const promise1 = kvStore.delete(KEY_TEST_STRING_ELEMENT+'003'); - promise1.then((data) => { + await kvStore.put(KEY_TEST_STRING_ELEMENT, str).then(async (data) => { + console.log('testSingleKvStoreDeleteString001 put success'); + expect(data == undefined).assertTrue(); + await kvStore.delete(KEY_TEST_STRING_ELEMENT).then((data) => { + console.log('testSingleKvStoreDeleteString001 delete success'); + expect(data == undefined).assertTrue(); }).catch((err) => { + console.log('testSingleKvStoreDeleteString001 delete fail ' + err); expect(null).assertFail(); }); }).catch((err) => { + console.log('testSingleKvStoreDeleteString001 put fail ' + err); expect(null).assertFail(); }); - await sleep(3000); - }catch(e) { + } catch (e) { + console.log('testSingleKvStoreDeleteString001 put e ' + e); expect(null).assertFail(); } done(); }) - it('testDeleteString002', 0, async function (done) { + it('testSingleKvStoreDeleteString002', 0, async function (done) { + console.log('testSingleKvStoreDeleteString002'); try { var str = ''; for (var i = 0 ; i < 4096; i++) { str += 'x'; } - const promise = kvStore.put(KEY_TEST_STRING_ELEMENT+'003', str); - promise.then((data) => { - const promise1 = kvStore.delete(KEY_TEST_STRING_ELEMENT+'003'); - promise1.then((data) => { + await kvStore.put(KEY_TEST_STRING_ELEMENT, str).then(async (data) => { + console.log('testSingleKvStoreDeleteString002 put success'); + expect(data == undefined).assertTrue(); + await kvStore.delete(KEY_TEST_STRING_ELEMENT).then((data) => { + console.log('testSingleKvStoreDeleteString002 delete success'); + expect(data == undefined).assertTrue(); }).catch((err) => { + console.log('testSingleKvStoreDeleteString002 delete fail ' + err); expect(null).assertFail(); }); }).catch((err) => { + console.log('testSingleKvStoreDeleteString002 put fail ' + err); expect(null).assertFail(); }); - await sleep(3000); - }catch(e) { + } catch (e) { + console.log('testSingleKvStoreDeleteString002 put e ' + e); expect(null).assertFail(); } done(); }) - it('testDeleteString003', 0, async function (done) { + it('testSingleKvStoreDeleteString003', 0, async function (done) { + console.log('testSingleKvStoreDeleteString003'); try { - const promise1 = kvStore.delete(KEY_TEST_STRING_ELEMENT+'unkonwn'); - promise1.then((data) => { + await kvStore.delete(KEY_TEST_STRING_ELEMENT).then((data) => { + console.log('testSingleKvStoreDeleteString003 delete success'); + expect(data == undefined).assertTrue(); }).catch((err) => { + console.log('testSingleKvStoreDeleteString003 delete fail ' + err); expect(null).assertFail(); }); - await sleep(3000); - }catch(e) { + } catch (e) { + console.log('testSingleKvStoreDeleteString003 put e ' + e); expect(null).assertFail(); } done(); }) - it('testDeleteInt001', 0, async function (done) { + it('testSingleKvStoreDeleteInt001', 0, async function (done) { + console.log('testSingleKvStoreDeleteInt001'); try { - const promise = kvStore.delete(KEY_TEST_INT_ELEMENT); - promise.then((data) => { + await kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT).then(async (data) => { + console.log('testSingleKvStoreDeleteInt001 put success'); + expect(data == undefined).assertTrue(); + await kvStore.delete(KEY_TEST_INT_ELEMENT).then((data) => { + console.log('testSingleKvStoreDeleteInt001 delete success'); + expect(data == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreDeleteInt001 delete fail ' + err); + expect(null).assertFail(); + }); }).catch((err) => { + console.log('testSingleKvStoreDeleteInt001 put fail ' + err); expect(null).assertFail(); }); - await sleep(3000); - }catch(e) { + } catch (e) { + console.log('testSingleKvStoreDeleteInt001 put e ' + e); expect(null).assertFail(); } done(); }) - it('testDeleteFloat001', 0, async function (done) { + it('testSingleKvStoreDeleteFloat001', 0, async function (done) { + console.log('testSingleKvStoreDeleteFloat001'); try { - const promise = kvStore.delete(KEY_TEST_FLOAT_ELEMENT); - promise.then((data) => { + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT).then(async (data) => { + console.log('testSingleKvStoreDeleteFloat001 put success'); + expect(data == undefined).assertTrue(); + await kvStore.delete(KEY_TEST_FLOAT_ELEMENT).then((data) => { + console.log('testSingleKvStoreDeleteFloat001 delete success'); + expect(data == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreDeleteFloat001 delete fail ' + err); + expect(null).assertFail(); + }); }).catch((err) => { + console.log('testSingleKvStoreDeleteFloat001 put fail ' + err); expect(null).assertFail(); }); - await sleep(3000); - }catch(e) { + } catch (e) { + console.log('testSingleKvStoreDeleteFloat001 put e ' + e); expect(null).assertFail(); } done(); }) - it('testDeleteFloat002', 0, async function (done) { + it('testSingleKvStoreDeleteBool001', 0, async function (done) { + console.log('testSingleKvStoreDeleteBool001'); try { - const promise = kvStore.put(KEY_TEST_FLOAT_ELEMENT+'002', VALUE_TEST_FLOAT_ELEMENT); - promise.then((data) => { - const promise1 = kvStore.delete(KEY_TEST_FLOAT_ELEMENT+'002'); - promise1.then((data) => { + await kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, VALUE_TEST_BOOLEAN_ELEMENT).then(async (data) => { + console.log('testSingleKvStoreDeleteBool001 put success'); + expect(data == undefined).assertTrue(); + await kvStore.delete(KEY_TEST_BOOLEAN_ELEMENT).then((data) => { + console.log('testSingleKvStoreDeleteBool001 delete success'); + expect(data == undefined).assertTrue(); }).catch((err) => { + console.log('testSingleKvStoreDeleteBool001 delete fail ' + err); expect(null).assertFail(); }); }).catch((err) => { + console.log('testSingleKvStoreDeleteBool001 put fail ' + err); expect(null).assertFail(); }); - await sleep(3000); - }catch(e) { + } catch (e) { + console.log('testSingleKvStoreDeleteBool001 put e ' + e); expect(null).assertFail(); } done(); }) - it('testDeleteBoolean001', 0, async function (done) { + it('testSingleKvStoreOnChange001', 0, async function (done) { try { - const promise = kvStore.delete(KEY_TEST_BOOLEAN_ELEMENT); - promise.then((data) => { - }).catch((err) => { + kvStore.on('dataChange', 0, function (data) { + console.log('testSingleKvStoreOnChange001 ' + JSON.stringify(data)); + expect(data != null).assertTrue(); + }); + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT).then((data) => { + console.log('testSingleKvStoreOnChange001 put success'); + expect(data == undefined).assertTrue(); + }).catch((error) => { + console.log('testSingleKvStoreOnChange001 put fail ' + error); expect(null).assertFail(); }); - await sleep(3000); - }catch (e) { + }catch(e) { + console.log('testSingleKvStoreOnChange001 put e ' + e); expect(null).assertFail(); } done(); }) - it('testOnChange001', 0, async function (done) { + it('testSingleKvStoreOnChange002', 0, async function (done) { try { - kvStore.on('dataChange', 0, function (data) { - console.log('testOnChange001 0' + data) - expect(true).assertEqual(data !=null); + kvStore.on('dataChange', 1, function (data) { + console.log('testSingleKvStoreOnChange002 on ' + JSON.stringify(data)); + expect(data != null).assertTrue(); }); - const promise = kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT); - promise.then((data) => { - }).catch((err) => { + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT).then((data) => { + console.log('testSingleKvStoreOnChange002 put success'); + expect(data == undefined).assertTrue(); + }).catch((error) => { + console.log('testSingleKvStoreOnChange002 put fail ' + error); expect(null).assertFail(); }); - await sleep(3000); }catch(e) { + console.log('testSingleKvStoreOnChange002 put e ' + e); expect(null).assertFail(); } done(); }) - it('testOnChange002', 0, async function (done) { + it('testSingleKvStoreOnChange003', 0, async function (done) { try { - kvStore.on('dataChange', 1, function (data) { //remote - console.log('testOnChange001 1' + data) - expect(true).assertEqual(data !=null); + kvStore.on('dataChange', 2, function (data) { + console.log('testSingleKvStoreOnChange003 ' + JSON.stringify(data)); + expect(data != null).assertTrue(); }); - const promise = kvStore.put(KEY_TEST_INT_ELEMENT + '002', VALUE_TEST_INT_ELEMENT); - promise.then((data) => { - }).catch((err) => { + await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT).then((data) => { + console.log('testSingleKvStoreOnChange003 put success'); + expect(data == undefined).assertTrue(); + }).catch((error) => { + console.log('testSingleKvStoreOnChange003 put fail ' + error); expect(null).assertFail(); }); - await sleep(3000); }catch(e) { + console.log('testSingleKvStoreOnChange003 put e ' + e); expect(null).assertFail(); } done(); }) - it('testOnChange003', 0, async function (done) { + it('testSingleKvStoreOnSyncComplete001', 0, async function (done) { try { - kvStore.on('dataChange', 2, function (data) { - console.log('testOnChange001 2' + data) - expect(true).assertEqual(data !=null); + kvStore.on('syncComplete', function (data) { + console.log('testSingleKvStoreOnSyncComplete001 0' + data) + expect(data != null).assertTrue(); }); - const promise = kvStore.put(KEY_TEST_INT_ELEMENT + '003', VALUE_TEST_INT_ELEMENT); - promise.then((data) => { - }).catch((err) => { + await kvStore.put(KEY_TEST_SYNC_ELEMENT, VALUE_TEST_SYNC_ELEMENT).then((data) => { + console.log('testSingleKvStoreOnSyncComplete001 put success'); + expect(data == undefined).assertTrue(); + var devices = ['A12C1F9261528B21F95778D2FDC0B2E33943E6251AC5487F4473D005758905DB']; + var mode = factory.SyncMode.PULL_ONLY; + kvStore.sync(devices, mode, 10); + }).catch((error) => { + console.log('testSingleKvStoreOnSyncComplete001 put fail ' + error); expect(null).assertFail(); }); - await sleep(3000); }catch(e) { + console.log('testSingleKvStoreOnSyncComplete001 put e ' + e); expect(null).assertFail(); } done(); }) - it('testOnSyncComplete001', 0, async function (done) { + it('testSingleKvStoreOnSyncComplete002', 0, async function (done) { try { kvStore.on('syncComplete', function (data) { - expect(true).assertEqual(data !=null); + console.log('testSingleKvStoreOnSyncComplete002 0' + data) + expect(data != null).assertTrue(); }); - const promise = kvStore.put(KEY_TEST_SYNC_ELEMENT + 'testSync001', VALUE_TEST_SYNC_ELEMENT); - promise.then((data) => { + await kvStore.put(KEY_TEST_SYNC_ELEMENT, VALUE_TEST_SYNC_ELEMENT).then((data) => { + console.log('testSingleKvStoreOnSyncComplete002 put success'); + expect(data == undefined).assertTrue(); var devices = ['A12C1F9261528B21F95778D2FDC0B2E33943E6251AC5487F4473D005758905DB']; - var mode = PULL_ONLY; + var mode = factory.SyncMode.PUSH_ONLY; kvStore.sync(devices, mode, 10); - }).catch((err) => { + }).catch((error) => { + console.log('testSingleKvStoreOnSyncComplete002 put fail ' + error); expect(null).assertFail(); }); - await sleep(3000); }catch(e) { + console.log('testSingleKvStoreOnSyncComplete002 put e ' + e); expect(null).assertFail(); } done(); }) - it('testOnSyncComplete002', 0, async function (done) { + it('testSingleKvStoreOnSyncComplete003', 0, async function (done) { try { kvStore.on('syncComplete', function (data) { - expect(true).assertEqual(data !=null); + console.log('testSingleKvStoreOnSyncComplete003 0' + data) + expect(data != null).assertTrue(); }); - const promise = kvStore.put(KEY_TEST_SYNC_ELEMENT + 'testSync001', VALUE_TEST_SYNC_ELEMENT); - promise.then((data) => { + await kvStore.put(KEY_TEST_SYNC_ELEMENT, VALUE_TEST_SYNC_ELEMENT).then((data) => { + console.log('testSingleKvStoreOnSyncComplete003 put success'); + expect(data == undefined).assertTrue(); var devices = ['A12C1F9261528B21F95778D2FDC0B2E33943E6251AC5487F4473D005758905DB']; - var mode = PUSH_ONLY; + var mode = factory.SyncMode.PUSH_PULL; kvStore.sync(devices, mode, 10); + }).catch((error) => { + console.log('testSingleKvStoreOnSyncComplete003 put fail ' + error); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testSingleKvStoreOnSyncComplete003 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreOffChange001', 0, async function (done) { + console.log('testSingleKvStoreOffChange001'); + try { + var func = function (data) { + console.log('testSingleKvStoreOffChange001 ' + JSON.stringify(data)); + }; + kvStore.on('dataChange', 0, func); + kvStore.off('dataChange', func); + }catch(e) { + console.log('testSingleKvStoreOffChange001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreOffChange002', 0, async function (done) { + console.log('testSingleKvStoreOffChange002'); + try { + var func = function (data) { + console.log('testSingleKvStoreOffChange002 ' + JSON.stringify(data)); + }; + var func1 = function (data) { + console.log('testSingleKvStoreOffChange002 ' + JSON.stringify(data)); + }; + kvStore.on('dataChange', 0, func); + kvStore.on('dataChange', 0, func1); + kvStore.off('dataChange', func); + }catch(e) { + console.log('testSingleKvStoreOffChange002 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreOffChange003', 0, async function (done) { + console.log('testSingleKvStoreOffChange003'); + try { + var func = function (data) { + console.log('testSingleKvStoreOffChange003 0' + data) + }; + var func1 = function (data) { + console.log('testSingleKvStoreOffChange003 0' + data) + }; + kvStore.on('dataChange', 0, func); + kvStore.on('dataChange', 0, func1); + kvStore.off('dataChange', func); + kvStore.off('dataChange', func1); + }catch(e) { + console.log('testSingleKvStoreOffChange003 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreOffChange004', 0, async function (done) { + console.log('testSingleKvStoreOffChange004'); + try { + var func = function (data) { + console.log('testSingleKvStoreOffChange004 ' + JSON.stringify(data)); + }; + kvStore.on('dataChange', 0, func); + kvStore.off('dataChange'); + }catch(e) { + console.log('testSingleKvStoreOffChange004 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreOffSyncComplete001', 0, async function (done) { + console.log('testSingleKvStoreOffSyncComplete001'); + try { + var func = function (data) { + console.log('testSingleKvStoreOffSyncComplete001 0' + data) + }; + kvStore.on('syncComplete', func); + kvStore.off('syncComplete', func); + }catch(e) { + console.log('testSingleKvStoreOffSyncComplete001 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreOffSyncComplete002', 0, async function (done) { + console.log('testSingleKvStoreOffSyncComplete002'); + try { + var func = function (data) { + console.log('testSingleKvStoreOffSyncComplete002 0' + data) + }; + var func1 = function (data) { + console.log('testSingleKvStoreOffSyncComplete002 0' + data) + }; + kvStore.on('syncComplete', func); + kvStore.on('syncComplete', func1); + kvStore.off('syncComplete', func); + expect(null).assertFail(); + }catch(e) { + console.log('testSingleKvStoreOffSyncComplete002 put e ' + e); + expect(true).assertTrue(); + } + done(); + }) + + it('testSingleKvStoreOffSyncComplete003', 0, async function (done) { + console.log('testSingleKvStoreOffSyncComplete003'); + try { + var func = function (data) { + console.log('testSingleKvStoreOffSyncComplete003 0' + data) + }; + var func1 = function (data) { + console.log('testSingleKvStoreOffSyncComplete003 0' + data) + }; + kvStore.on('syncComplete', func); + kvStore.on('syncComplete', func1); + kvStore.off('syncComplete', func); + kvStore.off('syncComplete', func1); + expect(null).assertFail(); + }catch(e) { + console.log('testSingleKvStoreOffSyncComplete003 put e ' + e); + expect(true).assertTrue(); + } + done(); + }) + + it('testSingleKvStoreOffSyncComplete004', 0, async function (done) { + console.log('testSingleKvStoreOffSyncComplete004'); + try { + var func = function (data) { + console.log('testSingleKvStoreOffSyncComplete004 0' + data) + }; + kvStore.on('syncComplete', func); + kvStore.off('syncComplete'); + }catch(e) { + console.log('testSingleKvStoreOffSyncComplete004 put e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreSetSyncRange001', 0, async function (done) { + console.log('testSingleKvStoreSetSyncRange001'); + try { + var localLabels = ['A', 'B']; + var remoteSupportLabels = ['C', 'D']; + await kvStore.setSyncRange(localLabels, remoteSupportLabels).then((err) => { + console.log('testSingleKvStoreSetSyncRange001 setSyncRange success'); + expect(err == undefined).assertTrue(); }).catch((err) => { + console.log('testSingleKvStoreDeleteString003 delete fail ' + err); expect(null).assertFail(); }); - await sleep(3000); }catch(e) { + console.log('testSingleKvStoreSetSyncRange001 e ' + e); expect(null).assertFail(); } done(); }) - it('testOnSyncComplete003', 0, async function (done) { + it('testSingleKvStoreSetSyncRange002', 0, async function (done) { + console.log('testSingleKvStoreSetSyncRange002'); try { - kvStore.on('syncComplete', function (data) { - expect(true).assertEqual(data !=null); + var localLabels = ['A', 'B']; + var remoteSupportLabels = ['B', 'C']; + await kvStore.setSyncRange(localLabels, remoteSupportLabels).then((err) => { + console.log('testSingleKvStoreSetSyncRange002 setSyncRange success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreSetSyncRange002 delete fail ' + err); + expect(null).assertFail(); }); - const promise = kvStore.put(KEY_TEST_SYNC_ELEMENT + 'testSync001', VALUE_TEST_SYNC_ELEMENT); - promise.then((data) => { - var devices = ['A12C1F9261528B21F95778D2FDC0B2E33943E6251AC5487F4473D005758905DB']; - var mode = PUSH_PULL; - kvStore.sync(devices, mode, 10); + }catch(e) { + console.log('testSingleKvStoreSetSyncRange002 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreSetSyncRange003', 0, async function (done) { + console.log('testSingleKvStoreSetSyncRange003'); + try { + var localLabels = ['A', 'B']; + var remoteSupportLabels = ['A', 'B']; + await kvStore.setSyncRange(localLabels, remoteSupportLabels).then((err) => { + console.log('testSingleKvStoreSetSyncRange003 setSyncRange success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreSetSyncRange003 delete fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testSingleKvStoreSetSyncRange003 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStorePutBatch001', 0, async function (done) { + console.log('testSingleKvStorePutBatch001'); + try { + let entries = putBatchString(10, 'batch_test_string_key'); + console.log('testSingleKvStorePutBatch001 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testSingleKvStorePutBatch001 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries('batch_test_string_key').then((entrys) => { + console.log('testSingleKvStorePutBatch001 getEntries success'); + console.log('testSingleKvStorePutBatch001 ' + JSON.stringify(entries)); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == 'batch_test_string_value').assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorePutBatch001 getEntries fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testSingleKvStorePutBatch001 putBatch fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testSingleKvStorePutBatch001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStorePutBatch002', 0, async function (done) { + console.log('testSingleKvStorePutBatch002'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_number_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.INTEGER, + value : 222 + } + } + entries.push(entry); + } + console.log('testSingleKvStorePutBatch002 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testSingleKvStorePutBatch002 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries('batch_test_number_key').then((entrys) => { + console.log('testSingleKvStorePutBatch002 getEntries success'); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == 222).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorePutBatch002 getEntries fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testSingleKvStorePutBatch002 putBatch fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testSingleKvStorePutBatch002 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStorePutBatch003', 0, async function (done) { + console.log('testSingleKvStorePutBatch003'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_number_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.FLOAT, + value : 2.0 + } + } + entries.push(entry); + } + console.log('testSingleKvStorePutBatch003 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testSingleKvStorePutBatch003 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries('batch_test_number_key').then((entrys) => { + console.log('testSingleKvStorePutBatch003 getEntries success'); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == 2.0).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorePutBatch003 getEntries fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testSingleKvStorePutBatch003 putBatch fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testSingleKvStorePutBatch003 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStorePutBatch004', 0, async function (done) { + console.log('testSingleKvStorePutBatch004'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_number_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.DOUBLE, + value : 2.00 + } + } + entries.push(entry); + } + console.log('testSingleKvStorePutBatch004 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testSingleKvStorePutBatch004 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries('batch_test_number_key').then((entrys) => { + console.log('testSingleKvStorePutBatch004 getEntries success'); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == 2.00).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorePutBatch004 getEntries fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testSingleKvStorePutBatch004 putBatch fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testSingleKvStorePutBatch004 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStorePutBatch005', 0, async function (done) { + console.log('testSingleKvStorePutBatch005'); + try { + var bo = false; + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_bool_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.BOOLEAN, + value : bo + } + } + entries.push(entry); + } + console.log('testSingleKvStorePutBatch005 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testSingleKvStorePutBatch005 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries('batch_test_bool_key').then((entrys) => { + console.log('testSingleKvStorePutBatch005 getEntries success'); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value == bo).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorePutBatch005 getEntries fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testSingleKvStorePutBatch005 putBatch fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testSingleKvStorePutBatch005 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStorePutBatch006', 0, async function (done) { + console.log('testSingleKvStorePutBatch006'); + try { + var arr = new Uint8Array([21,31]); + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_bool_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.BYTE_ARRAY, + value : arr + } + } + entries.push(entry); + } + console.log('testSingleKvStorePutBatch006 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testSingleKvStorePutBatch006 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.getEntries('batch_test_bool_key').then((entrys) => { + console.log('testSingleKvStorePutBatch006 getEntries success'); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value.toString() == arr.toString()).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorePutBatch006 getEntries fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testSingleKvStorePutBatch006 putBatch fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testSingleKvStorePutBatch005 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreDeleteBatch001', 0, async function (done) { + console.log('testSingleKvStoreDeleteBatch001'); + try { + let entries = []; + let keys = []; + for (var i = 0; i < 5; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + keys.push(key + i); + } + console.log('testSingleKvStoreDeleteBatch001 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testSingleKvStoreDeleteBatch001 putBatch success'); + expect(err == undefined).assertTrue(); + await kvStore.deleteBatch(keys).then((err) => { + console.log('testSingleKvStoreDeleteBatch001 deleteBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreDeleteBatch001 deleteBatch fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testSingleKvStoreDeleteBatch001 putBatch fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testSingleKvStoreDeleteBatch001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreDeleteBatch002', 0, async function (done) { + console.log('testSingleKvStoreDeleteBatch002'); + try { + let keys = ['batch_test_string_key1', 'batch_test_string_key2']; + await kvStore.deleteBatch(keys).then((err) => { + console.log('testSingleKvStoreDeleteBatch002 deleteBatch success'); + }).catch((err) => { + console.log('testSingleKvStoreDeleteBatch002 deleteBatch fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testSingleKvStoreDeleteBatch002 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreDeleteBatch003', 0, async function (done) { + console.log('testSingleKvStoreDeleteBatch003'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + console.log('testSingleKvStoreDeleteBatch003 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testSingleKvStoreDeleteBatch003 putBatch success'); + expect(err == undefined).assertTrue(); + let keys = ['batch_test_string_key1', 'batch_test_string_keya']; + await kvStore.deleteBatch(keys).then((err) => { + console.log('testSingleKvStoreDeleteBatch003 deleteBatch success'); + }).catch((err) => { + console.log('testSingleKvStoreDeleteBatch003 deleteBatch fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testSingleKvStoreDeleteBatch003 putBatch fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testSingleKvStoreDeleteBatch003 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStorestartTransaction001', 0, async function (done) { + console.log('testSingleKvStorestartTransaction001'); + try { + var count = 0; + kvStore.on('dataChange', factory.SubscribeType.SUBSCRIBE_TYPE_ALL, function (data) { + console.log('testSingleKvStorestartTransaction001 ' + JSON.stringify(data)); + count++; + }); + await kvStore.startTransaction().then(async (err) => { + console.log('testSingleKvStorestartTransaction001 startTransaction success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorestartTransaction001 startTransaction fail ' + err); + expect(null).assertFail(); + }); + let entries = putBatchString(10, 'batch_test_string_key'); + console.log('testSingleKvStorestartTransaction001 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testSingleKvStorestartTransaction001 putBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorestartTransaction001 putBatch fail ' + err); + expect(null).assertFail(); + }); + let keys = Object.keys(entries).slice(5); //delete 5 beginnings + await kvStore.deleteBatch(keys).then((err) => { + console.log('testSingleKvStorestartTransaction001 deleteBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorestartTransaction001 deleteBatch fail ' + err); + expect(null).assertFail(); + }); + await kvStore.commit().then(async (err) => { + console.log('testSingleKvStorestartTransaction001 commit success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorestartTransaction001 commit fail ' + err); + expect(null).assertFail(); + }); + await sleep(2000); + expect(count == 1).assertTrue(); + }catch(e) { + console.log('testSingleKvStorestartTransaction001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStorestartTransaction002', 0, async function (done) { + console.log('testSingleKvStorestartTransaction002'); + try { + var count = 0; + kvStore.on('dataChange', 0, function (data) { + console.log('testSingleKvStorestartTransaction002 ' + JSON.stringify(data)); + count++; + }); + await kvStore.startTransaction().then(async (err) => { + console.log('testSingleKvStorestartTransaction002 startTransaction success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorestartTransaction002 startTransaction fail ' + err); + expect(null).assertFail(); + }); + let entries = putBatchString(10, 'batch_test_string_key'); + console.log('testSingleKvStorestartTransaction002 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testSingleKvStorestartTransaction002 putBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorestartTransaction002 putBatch fail ' + err); + expect(null).assertFail(); + }); + let keys = Object.keys(entries).slice(5); //delete 5 beginnings + await kvStore.deleteBatch(keys).then((err) => { + console.log('testSingleKvStorestartTransaction002 deleteBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorestartTransaction002 deleteBatch fail ' + err); + expect(null).assertFail(); + }); + // rollback + await kvStore.rollback().then(async (err) => { + console.log('testSingleKvStorestartTransaction002 rollback success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorestartTransaction002 rollback fail ' + err); + expect(null).assertFail(); + }); + await sleep(2000); + expect(count == 0).assertTrue(); + }catch(e) { + console.log('testSingleKvStorestartTransaction002 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStorestartTransaction003', 0, async function (done) { + console.log('testSingleKvStorestartTransaction002'); + try { + await kvStore.startTransaction(1).then(async (err) => { + console.log('testSingleKvStorestartTransaction003 startTransaction success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStorestartTransaction003 startTransaction fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStorestartTransaction003 e ' + e); + } + done(); + }) + + it('testSingleKvStorestartTransaction004', 0, async function (done) { + console.log('testSingleKvStorestartTransaction004'); + try { + await kvStore.startTransaction('test_string').then(async (err) => { + console.log('testSingleKvStorestartTransaction004 startTransaction success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStorestartTransaction004 startTransaction fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStorestartTransaction004 e ' + e); + } + done(); + }) + + it('testSingleKvStorestartTransaction005', 0, async function (done) { + console.log('testSingleKvStorestartTransaction005'); + try { + await kvStore.startTransaction(2.000).then(async (err) => { + console.log('testSingleKvStorestartTransaction005 startTransaction success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStorestartTransaction005 startTransaction fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStorestartTransaction005 e ' + e); + } + done(); + }) + + it('testSingleKvStoreCommit001', 0, async function (done) { + console.log('testSingleKvStoreCommit001'); + try { + await kvStore.commit(1).then(async (err) => { + console.log('testSingleKvStoreCommit001 commit success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreCommit001 commit fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreCommit001 e ' + e); + } + done(); + }) + + it('testSingleKvStoreCommit002', 0, async function (done) { + console.log('testSingleKvStoreCommit002'); + try { + await kvStore.commit('test_string').then(async (err) => { + console.log('testSingleKvStoreCommit002 commit success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreCommit002 commit fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreCommit002 e ' + e); + } + done(); + }) + + it('testSingleKvStoreCommit003', 0, async function (done) { + console.log('testSingleKvStoreCommit003'); + try { + await kvStore.commit(2.000).then(async (err) => { + console.log('testSingleKvStoreCommit003 commit success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreCommit003 commit fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreCommit003 e ' + e); + } + done(); + }) + + it('testSingleKvStoreRollback001', 0, async function (done) { + console.log('testSingleKvStoreRollback001'); + try { + await kvStore.rollback(1).then(async (err) => { + console.log('testSingleKvStoreRollback001 rollback success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreRollback001 rollback fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreRollback001 e ' + e); + } + done(); + }) + + it('testSingleKvStoreRollback002', 0, async function (done) { + console.log('testSingleKvStoreRollback002'); + try { + await kvStore.rollback('test_string').then(async (err) => { + console.log('testSingleKvStoreRollback002 rollback success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreRollback002 rollback fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreRollback002 e ' + e); + } + done(); + }) + + it('testSingleKvStoreRollback003', 0, async function (done) { + console.log('testSingleKvStoreRollback003'); + try { + await kvStore.rollback(2.000).then(async (err) => { + console.log('testSingleKvStoreRollback003 rollback success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreRollback003 rollback fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreRollback003 e ' + e); + } + done(); + }) + + it('testSingleKvStoreEnableSync001', 0, async function (done) { + console.log('testSingleKvStoreEnableSync001'); + try { + await kvStore.enableSync(true).then((err) => { + console.log('testSingleKvStoreEnableSync001 enableSync success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreEnableSync001 enableSync fail ' + err); + expect(null).assertFail(); + }); + + }catch(e) { + console.log('testSingleKvStoreEnableSync001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreEnableSync002', 0, async function (done) { + console.log('testSingleKvStoreEnableSync002'); + try { + await kvStore.enableSync(false).then((err) => { + console.log('testSingleKvStoreEnableSync002 enableSync success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreEnableSync002 enableSync fail ' + err); + expect(null).assertFail(); + }); + + }catch(e) { + console.log('testSingleKvStoreEnableSync002 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreEnableSync003', 0, async function (done) { + console.log('testSingleKvStoreEnableSync003'); + try { + await kvStore.enableSync().then((err) => { + console.log('testSingleKvStoreEnableSync003 enableSync success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreEnableSync003 enableSync fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreEnableSync003 e ' + e); + } + done(); + }) + + it('testSingleKvStoreEnableSync004', 0, async function (done) { + console.log('testSingleKvStoreEnableSync004'); + try { + await kvStore.enableSync(null).then((err) => { + console.log('testSingleKvStoreEnableSync004 enableSync success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreEnableSync004 enableSync fail ' + err); + }); + + }catch(e) { + console.log('testSingleKvStoreEnableSync004 e ' + e); + } + done(); + }) + + it('testSingleKvStoreRemoveDeviceData001', 0, async function (done) { + console.log('testSingleKvStoreRemoveDeviceData001'); + try { + await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then((err) => { + console.log('testSingleKvStoreRemoveDeviceData001 put success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreRemoveDeviceData001 put fail ' + err); + expect(null).assertFail(); + }); + + var deviceid = 'no_exist_device_id'; + await kvStore.removeDeviceData(deviceid).then((err) => { + console.log('testSingleKvStoreRemoveDeviceData001 removeDeviceData success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreRemoveDeviceData001 removeDeviceData fail ' + err); + }); + + await kvStore.get(KEY_TEST_STRING_ELEMENT).then((data) => { + console.log('testSingleKvStoreRemoveDeviceData001 get success data:' + data); + expect(data == VALUE_TEST_STRING_ELEMENT).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreRemoveDeviceData001 get fail ' + err); + expect(null).assertFail(); + }); + + }catch(e) { + console.log('testSingleKvStoreRemoveDeviceData001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreRemoveDeviceData002', 0, async function (done) { + console.log('testSingleKvStoreRemoveDeviceData002'); + try { + await kvStore.removeDeviceData().then((err) => { + console.log('testSingleKvStoreRemoveDeviceData002 removeDeviceData success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreRemoveDeviceData002 removeDeviceData fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreRemoveDeviceData002 e ' + e); + } + done(); + }) + + it('testSingleKvStoreRemoveDeviceData003', 0, async function (done) { + console.log('testSingleKvStoreRemoveDeviceData003'); + try { + await kvStore.removeDeviceData('').then((err) => { + console.log('testSingleKvStoreRemoveDeviceData003 removeDeviceData success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreRemoveDeviceData003 removeDeviceData fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreRemoveDeviceData003 e ' + e); + } + done(); + }) + + it('testSingleKvStoreRemoveDeviceData004', 0, async function (done) { + console.log('testSingleKvStoreRemoveDeviceData004'); + try { + await kvStore.removeDeviceData(null).then((err) => { + console.log('testSingleKvStoreRemoveDeviceData004 removeDeviceData success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreRemoveDeviceData004 removeDeviceData fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreRemoveDeviceData004 e ' + e); + } + done(); + }) + + it('testSingleKvStoreSetSyncParam001', 0, async function (done) { + console.log('testSingleKvStoreSetSyncParam001'); + try { + var defaultAllowedDelayMs = 500; + await kvStore.setSyncParam(defaultAllowedDelayMs).then((err) => { + console.log('testSingleKvStoreSetSyncParam001 put success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreSetSyncParam001 put fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testSingleKvStoreSetSyncParam001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreSetSyncParam002', 0, async function (done) { + console.log('testSingleKvStoreSetSyncParam002'); + try { + await kvStore.setSyncParam().then((err) => { + console.log('testSingleKvStoreSetSyncParam002 put success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreSetSyncParam002 put fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreSetSyncParam002 e ' + e); + } + done(); + }) + + it('testSingleKvStoreSetSyncParam003', 0, async function (done) { + console.log('testSingleKvStoreSetSyncParam003'); + try { + await kvStore.setSyncParam('').then((err) => { + console.log('testSingleKvStoreSetSyncParam003 put success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreSetSyncParam003 put fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreSetSyncParam003 e ' + e); + } + done(); + }) + + it('testSingleKvStoreSetSyncParam004', 0, async function (done) { + console.log('testSingleKvStoreSetSyncParam004'); + try { + await kvStore.setSyncParam(null).then((err) => { + console.log('testSingleKvStoreSetSyncParam004 put success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreSetSyncParam004 put fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreSetSyncParam004 e ' + e); + } + done(); + }) + + it('testSingleKvStoreGetSecurityLevel001', 0, async function (done) { + console.log('testSingleKvStoreGetSecurityLevel001'); + try { + await kvStore.getSecurityLevel().then((data) => { + console.log('testSingleKvStoreGetSecurityLevel001 getSecurityLevel success'); + expect(data == factory.SecurityLevel.S2).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreGetSecurityLevel001 getSecurityLevel fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testSingleKvStoreGetSecurityLevel001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreGetSecurityLevel002', 0, async function (done) { + console.log('testSingleKvStoreGetSecurityLevel002'); + try { + await kvStore.getSecurityLevel(1).then((data) => { + console.log('testSingleKvStoreGetSecurityLevel002 getSecurityLevel success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreGetSecurityLevel002 getSecurityLevel fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreGetSecurityLevel002 e ' + e); + } + done(); + }) + + it('testSingleKvStoreGetSecurityLevel003', 0, async function (done) { + console.log('testSingleKvStoreGetSecurityLevel003'); + try { + await kvStore.getSecurityLevel('test_string').then((data) => { + console.log('testSingleKvStoreGetSecurityLevel003 getSecurityLevel success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreGetSecurityLevel003 getSecurityLevel fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreGetSecurityLevel003 e ' + e); + } + done(); + }) + + it('testSingleKvStoreGetSecurityLevel004', 0, async function (done) { + console.log('testSingleKvStoreGetSecurityLevel004'); + try { + await kvStore.getSecurityLevel(2.000).then((data) => { + console.log('testSingleKvStoreGetSecurityLevel004 getSecurityLevel success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreGetSecurityLevel004 getSecurityLevel fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreGetSecurityLevel004 e ' + e); + } + done(); + }) + + it('testSingleKvStoreGetResultSet001', 0, async function (done) { + console.log('testSingleKvStoreGetResultSet001'); + try { + let resultSet; + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries).then(async (err) => { + console.log('testSingleKvStoreGetResultSet001 putBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorePutBatch001 putBatch fail ' + err); + expect(null).assertFail(); + }); + await kvStore.getResultSet('batch_test_string_key').then((result) => { + console.log('testSingleKvStoreGetResultSet001 getResultSet success'); + resultSet = result; + expect(resultSet.getCount() == 10).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreGetResultSet001 getResultSet fail ' + err); + expect(null).assertFail(); + }); + await kvStore.closeResultSet(resultSet).then((err) => { + console.log('testSingleKvStoreGetResultSet001 closeResultSet success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreGetResultSet001 closeResultSet fail ' + err); + expect(null).assertFail(); + }); + + }catch(e) { + console.log('testSingleKvStoreGetResultSet001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreGetResultSet002', 0, async function (done) { + console.log('testSingleKvStoreGetResultSet002'); + try { + let resultSet; + await kvStore.getResultSet('batch_test_string_key').then((result) => { + console.log('testSingleKvStoreGetResultSet002 getResultSet success'); + resultSet = result; + expect(resultSet.getCount() == 0).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreGetResultSet002 getResultSet fail ' + err); + expect(null).assertFail(); + }); + await kvStore.closeResultSet(resultSet).then((err) => { + console.log('testSingleKvStoreGetResultSet002 closeResultSet success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreGetResultSet002 closeResultSet fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testSingleKvStoreGetResultSet002 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreGetResultSet003', 0, async function (done) { + console.log('testSingleKvStoreGetResultSet003'); + try { + let resultSet; + await kvStore.getResultSet().then((result) => { + console.log('testSingleKvStoreGetResultSet003 getResultSet success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreGetResultSet003 getResultSet fail ' + err); + + }); + }catch(e) { + console.log('testSingleKvStoreGetResultSet003 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreGetResultSet004', 0, async function (done) { + console.log('testSingleKvStoreGetResultSet004'); + try { + let resultSet; + await kvStore.getResultSet('test_key_string', 123).then((result) => { + console.log('testSingleKvStoreGetResultSet004 getResultSet success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreGetResultSet004 getResultSet fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreGetResultSet004 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreGetResultSet005', 0, async function (done) { + console.log('testSingleKvStoreGetResultSet005'); + try { + let resultSet; + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries).then(async (err) => { + console.log('testSingleKvStoreGetResultSet005 putBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorePutBatch001 putBatch fail ' + err); + expect(null).assertFail(); + }); + var query = new factory.Query(); + query.prefixKey("batch_test"); + await kvStore.getResultSet(query).then((result) => { + console.log('testSingleKvStoreGetResultSet005 getResultSet success'); + resultSet = result; + expect(resultSet.getCount() == 10).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreGetResultSet005 getResultSet fail ' + err); + expect(null).assertFail(); + }); + await kvStore.closeResultSet(resultSet).then((err) => { + console.log('testSingleKvStoreGetResultSet005 closeResultSet success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreGetResultSet005 closeResultSet fail ' + err); + expect(null).assertFail(); + }); + + }catch(e) { + console.log('testSingleKvStoreGetResultSet005 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreGetResultSet006', 0, async function (done) { + console.log('testSingleKvStoreGetResultSet006'); + try { + let resultSet; + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries).then(async (err) => { + console.log('testSingleKvStoreGetResultSet006 putBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorePutBatch001 putBatch fail ' + err); + expect(null).assertFail(); + }); + var query = new factory.Query(); + query.prefixKey("batch_test"); + await kvStore.getResultSet(query).then((result) => { + console.log('testSingleKvStoreGetResultSet006 getResultSet success'); + resultSet = result; + expect(resultSet.getCount() == 10).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreGetResultSet006 getResultSet fail ' + err); + expect(null).assertFail(); + }); + await kvStore.closeResultSet(resultSet).then((err) => { + console.log('testSingleKvStoreGetResultSet006 closeResultSet success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreGetResultSet006 closeResultSet fail ' + err); + expect(null).assertFail(); + }); + + }catch(e) { + console.log('testSingleKvStoreGetResultSet006 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreCloseResultSet001', 0, async function (done) { + console.log('testSingleKvStoreCloseResultSet001'); + try { + console.log('testSingleKvStoreCloseResultSet001 success'); + let resultSet = null; + await kvStore.closeResultSet(resultSet).then(() => { + console.log('testSingleKvStoreCloseResultSet001 closeResultSet success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreCloseResultSet001 closeResultSet fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreCloseResultSet001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreCloseResultSet002', 0, async function (done) { + console.log('testSingleKvStoreCloseResultSet002'); + try { + console.log('testSingleKvStoreCloseResultSet002 success'); + let resultSet = null; + await kvStore.getResultSet('batch_test_string_key').then((result) => { + console.log('testSingleKvStoreCloseResultSet002 getResultSet success'); + resultSet = result; + }).catch((err) => { + console.log('testSingleKvStoreCloseResultSet002 getResultSet fail ' + err); + expect(null).assertFail(); + }); + await kvStore.closeResultSet(resultSet).then((err) => { + console.log('testSingleKvStoreCloseResultSet002 closeResultSet success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreCloseResultSet002 closeResultSet fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testSingleKvStoreCloseResultSet002 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreCloseResultSet003', 0, async function (done) { + console.log('testSingleKvStoreCloseResultSet003'); + try { + console.log('testSingleKvStoreCloseResultSet003 success'); + let resultSet = null; + await kvStore.closeResultSet().then(() => { + console.log('testSingleKvStoreCloseResultSet003 closeResultSet success'); + expect(null).assertFail(); + }).catch((err) => { + console.log('testSingleKvStoreCloseResultSet003 closeResultSet fail ' + err); + }); + }catch(e) { + console.log('testSingleKvStoreCloseResultSet003 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreCloseResultSet004', 0, async function (done) { + console.log('testSingleKvStoreCloseResultSet004'); + try { + // pass query + console.log('testSingleKvStoreCloseResultSet004 success'); + }catch(e) { + console.log('testSingleKvStoreCloseResultSet004 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + + it('testSingleKvStoreGetResultSize001', 0, async function (done) { + console.log('testSingleKvStoreGetResultSize001'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries).then(async (err) => { + console.log('testSingleKvStoreGetResultSize001 putBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorePutBatch001 putBatch fail ' + err); + expect(null).assertFail(); + }); + var query = new factory.Query(); + query.prefixKey("batch_test"); + + await kvStore.getResultSize(query).then((resultSize) => { + console.log('testSingleKvStoreGetResultSize001 getResultSet success'); + expect(resultSize == 10).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreGetResultSize001 getResultSet fail ' + err); + expect(null).assertFail(); + }); + + }catch(e) { + console.log('testSingleKvStoreGetResultSize001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreGetResultSize002', 0, async function (done) { + console.log('testSingleKvStoreGetResultSize001'); + try { + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_string_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.STRING, + value : 'batch_test_string_value' + } + } + entries.push(entry); + } + await kvStore.putBatch(entries).then(async (err) => { + console.log('testSingleKvStoreGetResultSize001 putBatch success'); + expect(err == undefined).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStorePutBatch001 putBatch fail ' + err); + expect(null).assertFail(); + }); + var query = new factory.Query(); + query.prefixKey("batch_test"); + + await kvStore.getResultSize(query).then((resultSize) => { + console.log('testSingleKvStoreGetResultSize001 getResultSet success'); + expect(resultSize == 10).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreGetResultSize001 getResultSet fail ' + err); + expect(null).assertFail(); + }); + }catch(e) { + console.log('testSingleKvStoreGetResultSize001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreGetEntries001', 0, async function (done) { + console.log('testSingleKvStoreGetEntries001'); + try { + var arr = new Uint8Array([21,31]); + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_bool_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.BYTE_ARRAY, + value : arr + } + } + entries.push(entry); + } + console.log('testSingleKvStoreGetEntries001 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testSingleKvStoreGetEntries001 putBatch success'); + expect(err == undefined).assertTrue(); + var query = new factory.Query(); + query.prefixKey("batch_test"); + await kvStore.getEntries(query).then((entrys) => { + console.log('testSingleKvStoreGetEntries001 getEntries success'); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value.toString() == arr.toString()).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreGetEntries001 getEntries fail ' + err); + expect(null).assertFail(); + }); + }).catch((err) => { + console.log('testSingleKvStoreGetEntries001 putBatch fail ' + err); + expect(null).assertFail(); + }); + console.log('testSingleKvStoreGetEntries001 success'); + }catch(e) { + console.log('testSingleKvStoreGetEntries001 e ' + e); + expect(null).assertFail(); + } + done(); + }) + + it('testSingleKvStoreGetEntries002', 0, async function (done) { + console.log('testSingleKvStoreGetEntries002'); + try { + var arr = new Uint8Array([21,31]); + let entries = []; + for (var i = 0; i < 10; i++) { + var key = 'batch_test_bool_key'; + var entry = { + key : key + i, + value : { + type : factory.ValueType.BYTE_ARRAY, + value : arr + } + } + entries.push(entry); + } + console.log('testSingleKvStoreGetEntries002 entries: ' + JSON.stringify(entries)); + await kvStore.putBatch(entries).then(async (err) => { + console.log('testSingleKvStoreGetEntries002 putBatch success'); + expect(err == undefined).assertTrue(); + var query = new factory.Query(); + query.prefixKey("batch_test"); + await kvStore.getEntries(query).then((entrys) => { + console.log('testSingleKvStoreGetEntries002 getEntries success'); + expect(entrys.length == 10).assertTrue(); + expect(entrys[0].value.value.toString() == arr.toString()).assertTrue(); + }).catch((err) => { + console.log('testSingleKvStoreGetEntries002 getEntries fail ' + err); + expect(null).assertFail(); + }); }).catch((err) => { + console.log('testSingleKvStoreGetEntries002 putBatch fail ' + err); expect(null).assertFail(); }); - await sleep(3000); + console.log('testSingleKvStoreGetEntries002 success'); }catch(e) { + console.log('testSingleKvStoreGetEntries002 e ' + e); expect(null).assertFail(); } done();