flash-store/dist/src/flash-store.spec.js

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.

#!/usr/bin/env ts-node
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 __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); }
};
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]); }
};
import fs from 'fs';
import os from 'os';
import path from 'path';
// import rimraf from 'rimraf'
import { test } from 'tstest';
// import { log }    from './config'
// log.level('silly')
import { FlashStore, } from './flash-store';
const KEY = 'test-key';
const VAL = 'test-val';
const VAL_OBJ = { obj_key: 'obj_val' };
test('constructor()', (t) => __awaiter(void 0, void 0, void 0, function* () {
    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), path.sep, 'flash-store-'));
    yield t.resolves(() => __awaiter(void 0, void 0, void 0, function* () {
        const store = new FlashStore(tmpDir);
        // need to do something to create the db directory
        yield store.delete('init');
        t.ok(fs.existsSync(tmpDir), 'should create the workDir');
        yield store.destroy();
    }), 'should not reject with a non existing workDir');
}));
test('version()', (t) => __awaiter(void 0, void 0, void 0, function* () {
    var e_1, _a;
    try {
        for (var _b = __asyncValues(storeFixture()), _c; _c = yield _b.next(), !_c.done;) {
            const store = _c.value;
            t.ok(store.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 async iterator', (t) => __awaiter(void 0, void 0, void 0, function* () {
    yield t.test('async iterator for empty store', (t) => __awaiter(void 0, void 0, void 0, function* () {
        var e_2, _d, e_3, _e;
        try {
            for (var _f = __asyncValues(storeFixture()), _g; _g = yield _f.next(), !_g.done;) {
                const store = _g.value;
                let n = 0;
                try {
                    for (var store_1 = (e_3 = void 0, __asyncValues(store)), store_1_1; store_1_1 = yield store_1.next(), !store_1_1.done;) {
                        const _ = store_1_1.value;
                        n++;
                    }
                }
                catch (e_3_1) { e_3 = { error: e_3_1 }; }
                finally {
                    try {
                        if (store_1_1 && !store_1_1.done && (_e = store_1.return)) yield _e.call(store_1);
                    }
                    finally { if (e_3) throw e_3.error; }
                }
                t.equal(n, 0, 'should get empty iterator');
            }
        }
        catch (e_2_1) { e_2 = { error: e_2_1 }; }
        finally {
            try {
                if (_g && !_g.done && (_d = _f.return)) yield _d.call(_f);
            }
            finally { if (e_2) throw e_2.error; }
        }
    }));
    yield t.test('async iterator', (t) => __awaiter(void 0, void 0, void 0, function* () {
        var e_4, _h, e_5, _j;
        try {
            for (var _k = __asyncValues(storeFixture()), _l; _l = yield _k.next(), !_l.done;) {
                const store = _l.value;
                yield store.set(KEY, VAL);
                let n = 0;
                try {
                    for (var store_2 = (e_5 = void 0, __asyncValues(store)), store_2_1; store_2_1 = yield store_2.next(), !store_2_1.done;) {
                        const [key, val] = store_2_1.value;
                        t.equal(key, KEY, 'should get key back');
                        t.equal(val, VAL, 'should get val back');
                        n++;
                    }
                }
                catch (e_5_1) { e_5 = { error: e_5_1 }; }
                finally {
                    try {
                        if (store_2_1 && !store_2_1.done && (_j = store_2.return)) yield _j.call(store_2);
                    }
                    finally { if (e_5) throw e_5.error; }
                }
                t.equal(n, 1, 'should iterate once');
            }
        }
        catch (e_4_1) { e_4 = { error: e_4_1 }; }
        finally {
            try {
                if (_l && !_l.done && (_h = _k.return)) yield _h.call(_k);
            }
            finally { if (e_4) throw e_4.error; }
        }
    }));
}));
test('async 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_6, _m;
        try {
            for (var _o = __asyncValues(storeFixture()), _p; _p = yield _o.next(), !_p.done;) {
                const store = _p.value;
                const val = yield store.get(KEY);
                t.equal(val, undefined, 'should get undefined for not exist key');
            }
        }
        catch (e_6_1) { e_6 = { error: e_6_1 }; }
        finally {
            try {
                if (_p && !_p.done && (_m = _o.return)) yield _m.call(_o);
            }
            finally { if (e_6) throw e_6.error; }
        }
    }));
    yield t.test('store string key/val', (t) => __awaiter(void 0, void 0, void 0, function* () {
        var e_7, _q;
        try {
            for (var _r = __asyncValues(storeFixture()), _s; _s = yield _r.next(), !_s.done;) {
                const store = _s.value;
                yield store.set(KEY, VAL);
                const val = yield store.get(KEY);
                t.equal(val, VAL, 'should get VAL after set KEY');
            }
        }
        catch (e_7_1) { e_7 = { error: e_7_1 }; }
        finally {
            try {
                if (_s && !_s.done && (_q = _r.return)) yield _q.call(_r);
            }
            finally { if (e_7) throw e_7.error; }
        }
    }));
    yield t.test('store object value', (t) => __awaiter(void 0, void 0, void 0, function* () {
        var e_8, _t;
        try {
            for (var _u = __asyncValues(storeFixture()), _v; _v = yield _u.next(), !_v.done;) {
                const store = _v.value;
                yield store.set(KEY, VAL_OBJ);
                const val = yield store.get(KEY);
                t.same(val, VAL_OBJ, 'should get VAL_OBJ after set KEY');
            }
        }
        catch (e_8_1) { e_8 = { error: e_8_1 }; }
        finally {
            try {
                if (_v && !_v.done && (_t = _u.return)) yield _t.call(_u);
            }
            finally { if (e_8) throw e_8.error; }
        }
    }));
}));
test('async set()', (t) => __awaiter(void 0, void 0, void 0, function* () {
    var e_9, _w;
    try {
        for (var _x = __asyncValues(storeFixture()), _y; _y = yield _x.next(), !_y.done;) {
            const store = _y.value;
            yield store.set(KEY, VAL);
            const val = yield store.get(KEY);
            t.equal(val, VAL, 'should set VAL for KEY');
        }
    }
    catch (e_9_1) { e_9 = { error: e_9_1 }; }
    finally {
        try {
            if (_y && !_y.done && (_w = _x.return)) yield _w.call(_x);
        }
        finally { if (e_9) throw e_9.error; }
    }
}));
test('async size()', (t) => __awaiter(void 0, void 0, void 0, function* () {
    var e_10, _z;
    try {
        for (var _0 = __asyncValues(storeFixture()), _1; _1 = yield _0.next(), !_1.done;) {
            const store = _1.value;
            let size = yield store.size;
            t.equal(size, 0, 'should get size 0 after init');
            yield store.set(KEY, VAL);
            size = yield store.size;
            t.equal(size, 1, 'should get count 1 after put');
        }
    }
    catch (e_10_1) { e_10 = { error: e_10_1 }; }
    finally {
        try {
            if (_1 && !_1.done && (_z = _0.return)) yield _z.call(_0);
        }
        finally { if (e_10) throw e_10.error; }
    }
}));
test('async keys()', (t) => __awaiter(void 0, void 0, void 0, function* () {
    var e_11, _2, e_12, _3, e_13, _4;
    try {
        for (var _5 = __asyncValues(storeFixture()), _6; _6 = yield _5.next(), !_6.done;) {
            const store = _6.value;
            let count = 0;
            try {
                for (var _7 = (e_12 = void 0, __asyncValues(store.keys())), _8; _8 = yield _7.next(), !_8.done;) {
                    const _ = _8.value;
                    count++;
                }
            }
            catch (e_12_1) { e_12 = { error: e_12_1 }; }
            finally {
                try {
                    if (_8 && !_8.done && (_3 = _7.return)) yield _3.call(_7);
                }
                finally { if (e_12) throw e_12.error; }
            }
            t.equal(count, 0, 'should get 0 key after init');
            yield store.set(KEY, VAL);
            try {
                for (var _9 = (e_13 = void 0, __asyncValues(store.keys())), _10; _10 = yield _9.next(), !_10.done;) {
                    const key = _10.value;
                    t.equal(key, KEY, 'should get back the key');
                    count++;
                }
            }
            catch (e_13_1) { e_13 = { error: e_13_1 }; }
            finally {
                try {
                    if (_10 && !_10.done && (_4 = _9.return)) yield _4.call(_9);
                }
                finally { if (e_13) throw e_13.error; }
            }
            t.equal(count, 1, 'should get 1 key after 1 put');
        }
    }
    catch (e_11_1) { e_11 = { error: e_11_1 }; }
    finally {
        try {
            if (_6 && !_6.done && (_2 = _5.return)) yield _2.call(_5);
        }
        finally { if (e_11) throw e_11.error; }
    }
}));
test('async values()', (t) => __awaiter(void 0, void 0, void 0, function* () {
    var e_14, _11, e_15, _12, e_16, _13;
    try {
        for (var _14 = __asyncValues(storeFixture()), _15; _15 = yield _14.next(), !_15.done;) {
            const store = _15.value;
            let count = 0;
            try {
                for (var _16 = (e_15 = void 0, __asyncValues(store.values())), _17; _17 = yield _16.next(), !_17.done;) {
                    const _ = _17.value;
                    count++;
                }
            }
            catch (e_15_1) { e_15 = { error: e_15_1 }; }
            finally {
                try {
                    if (_17 && !_17.done && (_12 = _16.return)) yield _12.call(_16);
                }
                finally { if (e_15) throw e_15.error; }
            }
            t.equal(count, 0, 'should get 0 value after init');
            yield store.set(KEY, VAL);
            try {
                for (var _18 = (e_16 = void 0, __asyncValues(store.values())), _19; _19 = yield _18.next(), !_19.done;) {
                    const value = _19.value;
                    t.equal(value, VAL, 'should get back the value');
                    count++;
                }
            }
            catch (e_16_1) { e_16 = { error: e_16_1 }; }
            finally {
                try {
                    if (_19 && !_19.done && (_13 = _18.return)) yield _13.call(_18);
                }
                finally { if (e_16) throw e_16.error; }
            }
            t.equal(count, 1, 'should get 1 value after 1 put');
        }
    }
    catch (e_14_1) { e_14 = { error: e_14_1 }; }
    finally {
        try {
            if (_15 && !_15.done && (_11 = _14.return)) yield _11.call(_14);
        }
        finally { if (e_14) throw e_14.error; }
    }
}));
// test('deferred-leveldown json bug(fixed on version 2.0.2', async t => {
//   const encoding  = (await import('encoding-down')).default
//   const leveldown = (await import('leveldown')).default
//   const levelup   = (await import('levelup')).default
//   const tmpDir = fs.mkdtempSync(
//     path.join(
//       os.tmpdir(),
//       path.sep,
//       'flash-store-',
//     ),
//   )
//   const encoded = encoding(leveldown(tmpDir) as any, {
//     valueEncoding: 'json',
//   })
//   const levelDb = levelup(encoded)
//   const EXPECTED_OBJ = {a: 1}
//   await levelDb.put('test', EXPECTED_OBJ)
//   const value = await levelDb.get('test')
//   t.equal(typeof value, 'object', 'value type should be object')
//   t.deepEqual(value, EXPECTED_OBJ, 'should get back the original object')
//   // `rm -fr tmpDir`
//   await new Promise(r => rimraf(tmpDir, r))
// })
function storeFixture() {
    return __asyncGenerator(this, arguments, function* storeFixture_1() {
        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), path.sep, 'flash-store-'));
        const store = new FlashStore(tmpDir);
        yield yield __await(store);
        yield __await(store.destroy());
    });
}
//# sourceMappingURL=flash-store.spec.js.map