@x5e/gink/tsc.out/unit-tests/KeySet.test.js

an eventually consistent database

"use strict";
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); }
};
Object.defineProperty(exports, "__esModule", { value: true });
const test_utils_1 = require("./test_utils");
const implementation_1 = require("../implementation");
const utils_1 = require("../implementation/utils");
it("add and has basic data", async function () {
    // set up the objects
    for (const store of [
        new implementation_1.IndexedDbStore("ks-test1", true),
        new implementation_1.MemoryStore(true),
    ]) {
        const instance = new implementation_1.Database(store);
        await instance.ready;
        const ks = await instance.createKeySet();
        // add a value
        await ks.add("key1");
        // check that the result exists in the database
        (0, utils_1.ensure)(await ks.has("key1"));
        const myKey = new Uint8Array(3);
        myKey[0] = 94;
        myKey[2] = 255;
        await ks.add(myKey);
        (0, utils_1.ensure)(await ks.has(myKey));
    }
});
it("delete, and size work as intended", async function () {
    for (const store of [
        new implementation_1.IndexedDbStore("ks-test2", true),
        new implementation_1.MemoryStore(true),
    ]) {
        const instance = new implementation_1.Database(store);
        await instance.ready;
        const ks = await instance.createKeySet();
        await ks.add("key1");
        (0, utils_1.ensure)(await ks.has("key1"));
        (0, utils_1.ensure)((await ks.size()) === 1);
        await ks.delete("key1");
        (0, utils_1.ensure)(!(await ks.has("key1")));
        (0, utils_1.ensure)((await ks.size()) === 0);
        await ks.add("key1");
        await ks.add("key2");
        (0, utils_1.ensure)((await ks.size()) === 2);
        await ks.delete("key2");
        (0, utils_1.ensure)(!(await ks.has("key2")));
    }
});
it("entries works as intended", async function () {
    var _a, e_1, _b, _c;
    for (const store of [
        new implementation_1.IndexedDbStore("ks-test3", true),
        new implementation_1.MemoryStore(true),
    ]) {
        const instance = new implementation_1.Database(store);
        await instance.ready;
        const ks = await instance.createKeySet();
        await ks.update(["key1", "key2", "key3"]);
        const buffer = [];
        try {
            for (var _d = true, _e = (e_1 = void 0, __asyncValues(ks.entries())), _f; _f = await _e.next(), _a = _f.done, !_a;) {
                _c = _f.value;
                _d = false;
                try {
                    const [key, val] = _c;
                    await ks.delete(key);
                    buffer.push(key);
                }
                finally {
                    _d = true;
                }
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
            }
            finally { if (e_1) throw e_1.error; }
        }
        (0, utils_1.ensure)((0, utils_1.matches)(buffer, ["key1", "key2", "key3"]));
    }
});
it("add multiple keys within a bundler", async function () {
    for (const store of [
        new implementation_1.IndexedDbStore("ks-test4", true),
        new implementation_1.MemoryStore(true),
    ]) {
        const instance = new implementation_1.Database(store);
        await instance.ready;
        const ks = await instance.createKeySet();
        // make multiple changes in a change set
        const bundler = new implementation_1.Bundler();
        await ks.add("key1", bundler);
        await ks.add("key2", bundler);
        bundler.comment = "My first bundle!";
        await instance.addBundler(bundler);
        // verify the result
        (0, utils_1.ensure)(await ks.has("key1"));
        (0, utils_1.ensure)(await ks.has("key2"));
        (0, utils_1.ensure)(!(await ks.has("key3")));
    }
});
it("KeySet.toJson", async function () {
    for (const store of [
        new implementation_1.IndexedDbStore("ks-test6", true),
        new implementation_1.MemoryStore(true),
    ]) {
        const instance = new implementation_1.Database(store);
        await instance.ready;
        const ks = await instance.createKeySet();
        await ks.add("key1");
        await ks.update(["key2", "key3"]);
        const asJSON = await ks.toJson();
        (0, utils_1.ensure)(asJSON === `["key1","key2","key3"]`, asJSON);
    }
});
it("KeySet.asOf", async function () {
    for (const store of [
        new implementation_1.IndexedDbStore("ks-test7", true),
        new implementation_1.MemoryStore(true),
    ]) {
        const instance = new implementation_1.Database(store);
        await instance.ready;
        const ks = await instance.createKeySet();
        const time0 = Date.now() * 1000;
        await (0, test_utils_1.sleep)(10);
        await ks.add("key1");
        await (0, test_utils_1.sleep)(10);
        const time1 = Date.now() * 1000;
        await (0, test_utils_1.sleep)(10);
        await ks.add("key2");
        await (0, test_utils_1.sleep)(10);
        const time2 = Date.now() * 1000;
        // testing asOf for has
        (0, utils_1.ensure)(await ks.has("key1", time1));
        (0, utils_1.ensure)(await ks.has("key1", -1));
        (0, utils_1.ensure)(await ks.has("key1", time2));
        (0, utils_1.ensure)(!(await ks.has("key2", time1)));
        // testing asOf for toJson
        (0, utils_1.ensure)((await ks.toJson(false, time1)) === `["key1"]`);
        (0, utils_1.ensure)((await ks.toJson(false, time2)) === `["key1","key2"]`);
        // testing asOf for size
        (0, utils_1.ensure)((await ks.size(time0)) === 0);
        (0, utils_1.ensure)((await ks.size(time1)) === 1);
        (0, utils_1.ensure)((await ks.size(time2)) === 2);
        // testing asOf toSet
        const values = await ks.toSet(time0);
        const values1 = await ks.toSet(time1);
        (0, utils_1.ensure)(!values.size);
        (0, utils_1.ensure)(!values.has("key2"));
        (0, utils_1.ensure)(values1.size === 1);
        (0, utils_1.ensure)(values1.has("key1"));
    }
});
it("KeySet.clear", async function () {
    for (const store of [
        new implementation_1.IndexedDbStore("ks-test8", true),
        new implementation_1.MemoryStore(true),
    ]) {
        const instance = new implementation_1.Database(store);
        await instance.ready;
        const ks = await instance.createKeySet();
        await ks.update(["key1", "key2"]);
        const clearMuid = await ks.clear();
        (0, utils_1.ensure)((await ks.update(["key3", "key4"])) instanceof implementation_1.Bundler);
        const asSet = await ks.toSet();
        (0, utils_1.ensure)(asSet.has("key4") && !asSet.has("key1"), "did not clear");
        const asSetBeforeClear = await ks.toSet(clearMuid.timestamp);
        if (asSetBeforeClear.has("key4") || !asSetBeforeClear.has("key1")) {
            console.log(asSetBeforeClear);
            throw new Error("busted");
        }
    }
});
it("KeySet.clear(purge)", async function () {
    for (const store of [
        new implementation_1.IndexedDbStore("ks-test9", true),
        new implementation_1.MemoryStore(true),
    ]) {
        const instance = new implementation_1.Database(store);
        await instance.ready;
        const ks = await instance.createKeySet();
        await ks.add("key1");
        await (0, test_utils_1.sleep)(10);
        const middle = Date.now() * 1000;
        await (0, test_utils_1.sleep)(10);
        await ks.add("key2");
        (0, utils_1.ensure)(await ks.has("key2"));
        await ks.clear(true);
        const found = await instance.store.getKeyedEntries(ks.address, middle);
        (0, utils_1.ensure)(!found.size);
    }
});
it("KeySet.reset", async function () {
    for (const store of [
        new implementation_1.IndexedDbStore("ks-test10", true),
        new implementation_1.MemoryStore(true),
    ]) {
        const instance = new implementation_1.Database(store);
        await instance.ready;
        const ks = await instance.createKeySet();
        await ks.add("key1");
        const prop1 = await instance.createProperty();
        const prop2 = await instance.createProperty();
        await prop1.set(ks, "foo");
        await prop2.set(ks, "bar");
        const afterOne = (0, utils_1.generateTimestamp)();
        await ks.add("key2");
        await prop1.set(ks, "foo2");
        await prop2.set(ks, "bar2");
        (0, utils_1.ensure)(await ks.has("key2"));
        await ks.reset({ toTime: afterOne });
        (0, utils_1.ensure)(!(await ks.has("key2")));
        (0, utils_1.ensure)(await ks.has("key1"));
        (0, utils_1.ensure)((await prop1.get(ks)) === "foo");
        (0, utils_1.ensure)((await prop2.get(ks)) === "bar");
        await ks.reset();
        (0, utils_1.ensure)(!(await ks.has("key1")));
        (0, utils_1.ensure)((await ks.size()) === 0);
        (0, utils_1.ensure)((await prop1.get(ks)) === undefined);
        (0, utils_1.ensure)((await prop2.get(ks)) === undefined);
        await ks.add("key3");
        const after3 = (0, utils_1.generateTimestamp)();
        await ks.add("key4");
        (0, utils_1.ensure)((await ks.size()) === 2);
        await ks.delete("key3");
        (0, utils_1.ensure)((await ks.size()) === 1);
        await ks.reset({ toTime: after3, skipProperties: true });
        (0, utils_1.ensure)((await ks.size()) === 1);
        (0, utils_1.ensure)(await ks.has("key3"));
        (0, utils_1.ensure)(!(await ks.has("key4")));
        (0, utils_1.ensure)((await prop1.get(ks)) === undefined);
        (0, utils_1.ensure)((await prop2.get(ks)) === undefined);
    }
});
//# sourceMappingURL=KeySet.test.js.map