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

an eventually consistent database

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const implementation_1 = require("../implementation");
const utils_1 = require("../implementation/utils");
it("isAlive and remove", async function () {
    for (const store of [
        new implementation_1.IndexedDbStore("graph.test1", true),
        new implementation_1.MemoryStore(true),
    ]) {
        const instance = new implementation_1.Database({ store });
        await instance.ready;
        const vertex = await implementation_1.Vertex.create(instance);
        const aliveTime = (0, utils_1.generateTimestamp)();
        (0, utils_1.ensure)(await vertex.isAlive());
        await vertex.remove();
        const deadTime = (0, utils_1.generateTimestamp)();
        (0, utils_1.ensure)(!(await vertex.isAlive()));
        (0, utils_1.ensure)(await vertex.isAlive(aliveTime));
        await vertex.revive();
        (0, utils_1.ensure)(await vertex.isAlive());
        (0, utils_1.ensure)(!(await vertex.isAlive(deadTime)));
    }
});
it("edge_type.create", async function () {
    for (const store of [
        new implementation_1.IndexedDbStore("edge_type.create", true),
        new implementation_1.MemoryStore(true),
    ]) {
        const instance = new implementation_1.Database({ store });
        await instance.ready;
        const vertex1 = await implementation_1.Vertex.create(instance);
        const vertex2 = await implementation_1.Vertex.create(instance);
        const verb1 = await implementation_1.EdgeType.create(instance);
        const edge1 = await verb1.create(vertex1, vertex2);
        (0, utils_1.ensure)(edge1.getSourceVertex().equals(vertex1));
        (0, utils_1.ensure)(edge1.getTargetVertex().equals(vertex2));
        (0, utils_1.ensure)(!edge1.getSourceVertex().equals(vertex2));
        (0, utils_1.ensure)(edge1.getEdgeType().equals(verb1));
    }
});
it("from_to", async function () {
    for (const store of [
        new implementation_1.IndexedDbStore("from_to", true),
        new implementation_1.MemoryStore(true),
    ]) {
        const instance = new implementation_1.Database({ store });
        await instance.ready;
        const vertex1 = await implementation_1.Vertex.create(instance);
        const vertex2 = await implementation_1.Vertex.create(instance);
        const vertex3 = await implementation_1.Vertex.create(instance);
        const edge_type = await implementation_1.EdgeType.create(instance);
        const beforeEdge12 = (0, utils_1.generateTimestamp)();
        const edge12 = await edge_type.create(vertex1, vertex2);
        const edge13 = await edge_type.create(vertex1, vertex3);
        const edge11 = await edge_type.create(vertex1, vertex1);
        const edge21 = await edge_type.create(vertex2, vertex1);
        const edge22 = await edge_type.create(vertex2, vertex2);
        const edge23 = await edge_type.create(vertex2, vertex3);
        const edgesTo2 = await vertex2.getEdgesTo();
        (0, utils_1.ensure)(edgesTo2.length === 2, `wtf: ${edgesTo2.length}`);
        (0, utils_1.ensure)(edgesTo2[0].equals(edge12) || edgesTo2[0].equals(edge22));
        (0, utils_1.ensure)(edgesTo2[1].equals(edge12) || edgesTo2[1].equals(edge22));
        (0, utils_1.ensure)(!edgesTo2[0].equals(edgesTo2[1]));
        const edgesFrom2 = await vertex2.getEdgesFrom();
        (0, utils_1.ensure)(edgesFrom2.length === 3);
        (0, utils_1.ensure)(edgesFrom2[0].equals(edge21));
        (0, utils_1.ensure)(edgesFrom2[1].equals(edge22));
        (0, utils_1.ensure)(edgesFrom2[2].equals(edge23));
        await edge11.remove();
        const edgesFrom1 = await vertex1.getEdgesFrom();
        (0, utils_1.ensure)(edgesFrom1.length === 2);
        (0, utils_1.ensure)(edgesFrom1[0].equals(edge12));
        (0, utils_1.ensure)(edgesFrom1[1].equals(edge13));
        // move edge13 to the front
        await edge13.remove(beforeEdge12);
        const edgesFrom1b = await vertex1.getEdgesFrom();
        (0, utils_1.ensure)(edgesFrom1b.length === 2);
        (0, utils_1.ensure)(edgesFrom1b[0].equals(edge13));
        (0, utils_1.ensure)(edgesFrom1b[1].equals(edge12));
    }
});
it("edge_reorder", async function () {
    for (const store of [
        new implementation_1.IndexedDbStore("edge_reorder", true),
        new implementation_1.MemoryStore(true),
    ]) {
        const instance = new implementation_1.Database({ store });
        await instance.ready;
        const a = await implementation_1.Vertex.create(instance);
        const b = await implementation_1.Vertex.create(instance);
        const p = await implementation_1.EdgeType.create(instance);
        const prop = await implementation_1.Property.create(instance);
        const beforeX = (0, utils_1.generateTimestamp)();
        const x = await p.create(a, b);
        const y = await p.create(a, b);
        await prop.set(y, "foo");
        const afterX = (0, utils_1.generateTimestamp)();
        const entries = await store.getAllEntries();
        (0, utils_1.ensure)(entries.length === 3);
        const edges1 = await a.getEdgesFrom();
        (0, utils_1.ensure)(edges1.length === 2 && edges1[0].equals(x) && edges1[1].equals(y), edges1.toString());
        await y.remove(beforeX);
        const edges2 = await a.getEdgesFrom();
        const newY = edges2[0];
        (0, utils_1.ensure)(edges2.length === 2 && newY.equals(y) && edges2[1].equals(x), edges2.toString());
        // make sure property gets set again on "new" edge
        (0, utils_1.ensure)((await prop.get(newY)) === "foo");
        const edges3 = await b.getEdgesTo(afterX);
        (0, utils_1.ensure)(edges3.length === 2 && edges3[0].equals(x) && edges3[1].equals(y), edges3.toString());
        const edges4 = await b.getEdgesTo();
        (0, utils_1.ensure)(edges4.length === 2 && edges4[0].equals(y) && edges4[1].equals(x), edges4.toString());
    }
});
it("vertex reset", async function () {
    for (const store of [
        new implementation_1.IndexedDbStore("vertex reset", true),
        //new MemoryStore(true),
    ]) {
        const instance = new implementation_1.Database({ store });
        await instance.ready;
        const vertex = await implementation_1.Vertex.create(instance);
        const prop1 = await implementation_1.Property.create(instance);
        const prop2 = await implementation_1.Property.create(instance);
        await prop1.set(vertex, "foo");
        await prop2.set(vertex, "bar");
        const afterSet = (0, utils_1.generateTimestamp)();
        await vertex.remove();
        await prop1.set(vertex, "foo2");
        await prop2.set(vertex, "bar2");
        const afterSecond = (0, utils_1.generateTimestamp)();
        await vertex.reset(afterSet);
        await vertex.resetProperties(afterSet);
        // Vertex should be alive again, and properties should be reset
        (0, utils_1.ensure)(await vertex.isAlive());
        let val = await prop1.get(vertex);
        (0, utils_1.ensure)(val === "foo", `val=${val}`);
        (0, utils_1.ensure)((await prop2.get(vertex)) === "bar");
        await vertex.reset(afterSecond);
        // Vertex should be removed and properties should not have changed.
        (0, utils_1.ensure)(!(await vertex.isAlive()));
        val = await prop1.get(vertex);
        (0, utils_1.ensure)(val === "foo", `val=${val}`);
        (0, utils_1.ensure)((await prop2.get(vertex)) === "bar");
    }
});
it("edge_type reset", async function () {
    for (const store of [
        new implementation_1.IndexedDbStore("edgetype reset", true),
        new implementation_1.MemoryStore(true),
    ]) {
        const instance = new implementation_1.Database({ store });
        await instance.ready;
        const vertex1 = await implementation_1.Vertex.create(instance);
        const vertex2 = await implementation_1.Vertex.create(instance);
        const vertex3 = await implementation_1.Vertex.create(instance);
        const edgeType = await implementation_1.EdgeType.create(instance);
        const edge1 = await edgeType.create(vertex1, vertex2);
        const edge2 = await edgeType.create(vertex2, vertex1);
        const prop1 = await implementation_1.Property.create(instance);
        const prop2 = await implementation_1.Property.create(instance);
        await prop1.set(edgeType, "foo");
        await prop2.set(edgeType, "bar");
        const afterInit = (0, utils_1.generateTimestamp)();
        const edge3 = await edgeType.create(vertex1, vertex3);
        await prop1.set(edgeType, "foo");
        await prop2.set(edgeType, "baz");
        (0, utils_1.ensure)((await prop2.get(edgeType)) === "baz");
        const afterSecond = (0, utils_1.generateTimestamp)();
        await edgeType.reset(afterInit);
        await edgeType.resetProperties(afterInit);
        const edgesFrom1 = await vertex1.getEdgesFrom();
        const edgesFrom2 = await vertex2.getEdgesFrom();
        (0, utils_1.ensure)(edgesFrom1.length === 1);
        (0, utils_1.ensure)(edgesFrom2.length === 1);
        (0, utils_1.ensure)((await prop1.get(edgeType)) === "foo");
        (0, utils_1.ensure)((await prop2.get(edgeType)) === "bar");
        await edge1.remove();
        (0, utils_1.ensure)((await vertex1.getEdgesFrom()).length === 0);
        await edgeType.reset(afterSecond);
        (0, utils_1.ensure)((await vertex1.getEdgesFrom()).length === 2);
        (0, utils_1.ensure)((await vertex2.getEdgesFrom()).length === 1);
        (0, utils_1.ensure)((await vertex3.getEdgesTo()).length === 1);
        (0, utils_1.ensure)((await prop1.get(edgeType)) === "foo");
        (0, utils_1.ensure)((await prop2.get(edgeType)) === "bar");
    }
});
it("edge property restoration", async function () {
    for (const store of [
        new implementation_1.IndexedDbStore("edge property restore", true),
        new implementation_1.MemoryStore(true),
    ]) {
        const instance = new implementation_1.Database({ store });
        await instance.ready;
        const vertex1 = await implementation_1.Vertex.create(instance);
        const vertex2 = await implementation_1.Vertex.create(instance);
        const edgeType = await implementation_1.EdgeType.create(instance);
        const beforeEdges = (0, utils_1.generateTimestamp)();
        const edge1 = await edgeType.create(vertex1, vertex2);
        const edge2 = await edgeType.create(vertex1, vertex2);
        const prop1 = await implementation_1.Property.create(instance);
        const prop2 = await implementation_1.Property.create(instance);
        await prop1.set(edge1, "p1e1");
        await prop2.set(edge1, "p2e1");
        await prop1.set(edge2, "p1e2");
        await prop2.set(edge2, "p2e2");
        const beforeRemove = (0, utils_1.generateTimestamp)();
        await prop1.set(edge1, "changed");
        await prop2.set(edge1, "changed");
        await prop1.set(edge2, "changed");
        await prop2.set(edge2, "changed");
        await edge1.remove();
        await edgeType.reset(beforeRemove);
        const edges = await vertex1.getEdgesFrom();
        (0, utils_1.ensure)(edges.length === 2);
        (0, utils_1.ensure)((await prop1.get(edges[0])) === "p1e1");
        (0, utils_1.ensure)((await prop2.get(edges[0])) === "p2e1");
        (0, utils_1.ensure)((await prop1.get(edges[1])) === "p1e2");
        (0, utils_1.ensure)((await prop2.get(edges[1])) === "p2e2");
        // Move edge2 to the front
        await edge2.remove(beforeEdges);
        const edges2 = await vertex1.getEdgesFrom();
        (0, utils_1.ensure)(edges2.length === 2);
        (0, utils_1.ensure)((await prop1.get(edges2[0])) === "p1e2");
        (0, utils_1.ensure)((await prop2.get(edges2[0])) === "p2e2");
        const beforePropDel = (0, utils_1.generateTimestamp)();
        await prop2.delete(edges[0]); // delete e2 from prop2
        (0, utils_1.ensure)((await prop2.get(edges[0])) === undefined);
        await edgeType.reset(beforePropDel);
        const edges3 = await vertex1.getEdgesFrom();
        (0, utils_1.ensure)(edges3.length === 2);
        (0, utils_1.ensure)((await prop1.get(edges3[0])) === "p1e2");
        (0, utils_1.ensure)((await prop2.get(edges3[0])) === "p2e2");
    }
});
//# sourceMappingURL=graph.test.js.map