flash-store
Version:
FlashStore is a Key-Value persistent storage with easy to use ES6 Map-like API(both Async and Sync support), powered by LevelDB and TypeScript.
277 lines • 11.5 kB
JavaScript
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
};
var __asyncValues = (this && this.__asyncValues) || function (o) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
};
import fs from 'fs';
import path from 'path';
import os from 'os';
import { test } from 'tstest';
// import { log } from './config'
// log.level('silly')
import { FlashStoreSync, } from './flash-store-sync';
function storeSyncFixture() {
return __asyncGenerator(this, arguments, function* storeSyncFixture_1() {
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), path.sep, 'cache-store-'));
const storeSync = new FlashStoreSync(tmpDir);
yield yield __await(storeSync);
yield __await(storeSync.destroy());
});
}
const KEY = 'test-key';
const VAL = 'test-val';
const VAL_OBJ = { obj_key: 'obj_val' };
test('version()', (t) => __awaiter(void 0, void 0, void 0, function* () {
var e_1, _a;
try {
for (var _b = __asyncValues(storeSyncFixture()), _c; _c = yield _b.next(), !_c.done;) {
const storeSync = _c.value;
t.ok(storeSync.version().match(/^\d+\.\d+\.\d+$/), 'should get semver version');
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
}));
test('Store as iterator', (t) => __awaiter(void 0, void 0, void 0, function* () {
yield t.test('iterator for empty store', (t) => __awaiter(void 0, void 0, void 0, function* () {
var e_2, _d;
try {
for (var _e = __asyncValues(storeSyncFixture()), _f; _f = yield _e.next(), !_f.done;) {
const storeSync = _f.value;
let n = 0;
for (const _ of storeSync) {
n++;
// break
}
t.equal(n, 0, 'should get empty iterator');
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (_f && !_f.done && (_d = _e.return)) yield _d.call(_e);
}
finally { if (e_2) throw e_2.error; }
}
}));
yield t.test('async iterator', (t) => __awaiter(void 0, void 0, void 0, function* () {
var e_3, _g;
try {
for (var _h = __asyncValues(storeSyncFixture()), _j; _j = yield _h.next(), !_j.done;) {
const storeSync = _j.value;
storeSync.set(KEY, VAL);
let n = 0;
for (const [key, val] of storeSync) {
t.equal(key, KEY, 'should get key back');
t.equal(val, VAL, 'should get val back');
n++;
}
t.equal(n, 1, 'should iterate once');
}
}
catch (e_3_1) { e_3 = { error: e_3_1 }; }
finally {
try {
if (_j && !_j.done && (_g = _h.return)) yield _g.call(_h);
}
finally { if (e_3) throw e_3.error; }
}
}));
}));
test('get()', (t) => __awaiter(void 0, void 0, void 0, function* () {
yield t.test('return null for non existing key', (t) => __awaiter(void 0, void 0, void 0, function* () {
var e_4, _k;
try {
for (var _l = __asyncValues(storeSyncFixture()), _m; _m = yield _l.next(), !_m.done;) {
const storeSync = _m.value;
const val = storeSync.get(KEY);
t.equal(val, undefined, 'should get undefined for not exist key');
}
}
catch (e_4_1) { e_4 = { error: e_4_1 }; }
finally {
try {
if (_m && !_m.done && (_k = _l.return)) yield _k.call(_l);
}
finally { if (e_4) throw e_4.error; }
}
}));
yield t.test('store string key/val', (t) => __awaiter(void 0, void 0, void 0, function* () {
var e_5, _o;
try {
for (var _p = __asyncValues(storeSyncFixture()), _q; _q = yield _p.next(), !_q.done;) {
const storeSync = _q.value;
storeSync.set(KEY, VAL);
const val = storeSync.get(KEY);
t.equal(val, VAL, 'should get VAL after set KEY');
}
}
catch (e_5_1) { e_5 = { error: e_5_1 }; }
finally {
try {
if (_q && !_q.done && (_o = _p.return)) yield _o.call(_p);
}
finally { if (e_5) throw e_5.error; }
}
}));
yield t.test('store object value', (t) => __awaiter(void 0, void 0, void 0, function* () {
var e_6, _r;
try {
for (var _s = __asyncValues(storeSyncFixture()), _t; _t = yield _s.next(), !_t.done;) {
const storeSync = _t.value;
storeSync.set(KEY, VAL_OBJ);
const val = storeSync.get(KEY);
t.same(val, VAL_OBJ, 'should get VAL_OBJ after set KEY');
}
}
catch (e_6_1) { e_6 = { error: e_6_1 }; }
finally {
try {
if (_t && !_t.done && (_r = _s.return)) yield _r.call(_s);
}
finally { if (e_6) throw e_6.error; }
}
}));
}));
test('set()', (t) => __awaiter(void 0, void 0, void 0, function* () {
var e_7, _u;
try {
for (var _v = __asyncValues(storeSyncFixture()), _w; _w = yield _v.next(), !_w.done;) {
const storeSync = _w.value;
storeSync.set(KEY, VAL);
const val = storeSync.get(KEY);
t.equal(val, VAL, 'should set VAL for KEY');
}
}
catch (e_7_1) { e_7 = { error: e_7_1 }; }
finally {
try {
if (_w && !_w.done && (_u = _v.return)) yield _u.call(_v);
}
finally { if (e_7) throw e_7.error; }
}
}));
test('size()', (t) => __awaiter(void 0, void 0, void 0, function* () {
var e_8, _x;
try {
for (var _y = __asyncValues(storeSyncFixture()), _z; _z = yield _y.next(), !_z.done;) {
const storeSync = _z.value;
let size = storeSync.size;
t.equal(size, 0, 'should get size 0 after init');
storeSync.set(KEY, VAL);
size = storeSync.size;
t.equal(size, 1, 'should get count 1 after put');
}
}
catch (e_8_1) { e_8 = { error: e_8_1 }; }
finally {
try {
if (_z && !_z.done && (_x = _y.return)) yield _x.call(_y);
}
finally { if (e_8) throw e_8.error; }
}
}));
test('keys()', (t) => __awaiter(void 0, void 0, void 0, function* () {
var e_9, _0;
try {
for (var _1 = __asyncValues(storeSyncFixture()), _2; _2 = yield _1.next(), !_2.done;) {
const storeSync = _2.value;
let count = 0;
for (const _ of storeSync.keys()) {
count++;
}
t.equal(count, 0, 'should get 0 key after init');
storeSync.set(KEY, VAL);
for (const key of storeSync.keys()) {
t.equal(key, KEY, 'should get back the key');
count++;
}
t.equal(count, 1, 'should get 1 key after 1 put');
}
}
catch (e_9_1) { e_9 = { error: e_9_1 }; }
finally {
try {
if (_2 && !_2.done && (_0 = _1.return)) yield _0.call(_1);
}
finally { if (e_9) throw e_9.error; }
}
}));
test('values()', (t) => __awaiter(void 0, void 0, void 0, function* () {
var e_10, _3;
try {
for (var _4 = __asyncValues(storeSyncFixture()), _5; _5 = yield _4.next(), !_5.done;) {
const storeSync = _5.value;
let count = 0;
for (const _ of storeSync.values()) {
count++;
}
t.equal(count, 0, 'should get 0 value after init');
storeSync.set(KEY, VAL);
for (const value of storeSync.values()) {
t.equal(value, VAL, 'should get back the value');
count++;
}
t.equal(count, 1, 'should get 1 value after 1 put');
}
}
catch (e_10_1) { e_10 = { error: e_10_1 }; }
finally {
try {
if (_5 && !_5.done && (_3 = _4.return)) yield _3.call(_4);
}
finally { if (e_10) throw e_10.error; }
}
}));
test('close()', (t) => __awaiter(void 0, void 0, void 0, function* () {
var e_11, _6;
try {
for (var _7 = __asyncValues(storeSyncFixture()), _8; _8 = yield _7.next(), !_8.done;) {
const storeSync = _8.value;
storeSync.set('KEY1', VAL);
storeSync.set('KEY2', VAL);
storeSync.set('KEY3', VAL);
storeSync.set('KEY4', VAL);
storeSync.set('KEY5', VAL);
yield storeSync.close();
t.pass('should close');
}
}
catch (e_11_1) { e_11 = { error: e_11_1 }; }
finally {
try {
if (_8 && !_8.done && (_6 = _7.return)) yield _6.call(_7);
}
finally { if (e_11) throw e_11.error; }
}
}));
//# sourceMappingURL=flash-store-sync.spec.js.map