@snowtop/ent 0.1.0-alpha160-test5 → 0.1.0-alpha160-test7

package/core/query/shared_test.js

@@ -1,736 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.commonTests = void 0;
-const ent_1 = require("../ent");
-const global_schema_1 = require("../global_schema");
-const viewer_1 = require("../viewer");
-const index_1 = require("../../testutils/fake_data/index");
-const test_helpers_1 = require("../../testutils/fake_data/test_helpers");
-const temp_db_1 = require("../../testutils/db/temp_db");
-const test_context_1 = require("../../testutils/context/test_context");
-const logger_1 = require("../logger");
-const test_edge_global_schema_1 = require("../../testutils/test_edge_global_schema");
-const builder_1 = require("../../testutils/builder");
-const action_1 = require("../../action");
-const clause_1 = require("../clause");
-const query_impl_1 = require("../query_impl");
-function getWhereClause(query) {
-    const idx = query.query.indexOf("WHERE");
-    if (idx !== -1) {
-        return query.query.substr(idx + 6);
-    }
-    return null;
-}
-const commonTests = (opts) => {
-    (0, logger_1.setLogLevels)(["query", "error"]);
-    const ml = opts.ml;
-    ml.mock();
-    function isCustomQuery(q) {
-        if (q.customQuery !== undefined) {
-            return q.customQuery;
-        }
-        // TODO sad not generic enough
-        return (q instanceof index_1.UserToContactsFkeyQuery ||
-            q instanceof index_1.UserToContactsFkeyQueryDeprecated ||
-            q instanceof index_1.UserToContactsFkeyQueryAsc);
-    }
-    class TestQueryFilter {
-        constructor(filter, newQuery, ents, defaultViewer) {
-            this.filter = filter;
-            this.newQuery = newQuery;
-            this.ents = ents;
-            this.defaultViewer = defaultViewer;
-            this.allContacts = [];
-            this.filteredContacts = [];
-            // @ts-ignore
-            const q = this.newQuery(this.defaultViewer);
-            this.customQuery = isCustomQuery(q);
-        }
-        async createData() {
-            [this.user, this.allContacts] = await (0, test_helpers_1.createAllContacts)();
-            //    this.allContacts = this.allContacts.reverse();
-            this.filteredContacts = this.ents(this.allContacts);
-            ml.clear();
-        }
-        getQuery(viewer) {
-            return this.filter(this.newQuery(viewer || this.defaultViewer, this.user), this.user, this.allContacts);
-        }
-        async testIDs() {
-            const ids = await this.getQuery().queryIDs();
-            this.verifyIDs(ids);
-        }
-        verifyIDs(ids) {
-            expect(ids).toEqual(this.filteredContacts.map((contact) => contact.id));
-        }
-        // rawCount isn't affected by filters...
-        async testRawCount(expectedCount) {
-            const count = await this.getQuery().queryRawCount();
-            this.verifyRawCount(count, expectedCount);
-        }
-        verifyRawCount(count, expectedCount) {
-            expect(count).toBe(expectedCount ?? test_helpers_1.inputs.length);
-        }
-        async testCount(expectedCount) {
-            const count = await this.getQuery().queryCount();
-            this.verifyCount(count, expectedCount);
-        }
-        verifyCount(count, expectedCount) {
-            expect(count).toBe(expectedCount ?? this.filteredContacts.length);
-        }
-        async testEdges() {
-            const edges = await this.getQuery().queryEdges();
-            this.verifyEdges(edges);
-        }
-        verifyEdges(edges) {
-            // TODO sad not generic enough
-            if (this.customQuery) {
-                (0, test_helpers_1.verifyUserToContactRawData)(this.user, edges, this.filteredContacts);
-            }
-            else {
-                (0, test_helpers_1.verifyUserToContactEdges)(this.user, edges, this.filteredContacts);
-            }
-        }
-        async testEnts(v) {
-            const ents = await this.getQuery(v || new viewer_1.IDViewer(this.user.id)).queryEnts();
-            this.verifyEnts(ents);
-            return ents;
-        }
-        async testEntsCache() {
-            if (!this.customQuery) {
-                return;
-            }
-            (0, logger_1.setLogLevels)(["query", "cache"]);
-            const v = new test_context_1.TestContext(new viewer_1.IDViewer(this.user.id)).getViewer();
-            const ents = await this.testEnts(v);
-            expect(ml.logs.length).toBe(1);
-            expect(ml.logs[0].query).toMatch(/SELECT (.+) FROM /);
-            await Promise.all(ents.map((ent) => index_1.FakeContact.loadX(v, ent.id)));
-            expect(ml.logs.length).toBe(this.filteredContacts.length + 1);
-            for (const log of ml.logs.slice(1)) {
-                expect(log["ent-cache-hit"]).toBeDefined();
-            }
-            // "restore" back to previous
-            (0, logger_1.setLogLevels)("query");
-        }
-        async testDataCache() {
-            if (!this.customQuery) {
-                return;
-            }
-            (0, logger_1.setLogLevels)(["query", "cache"]);
-            const v = new test_context_1.TestContext(new viewer_1.IDViewer(this.user.id)).getViewer();
-            const ents = await this.testEnts(v);
-            expect(ml.logs.length).toBe(1);
-            expect(ml.logs[0].query).toMatch(/SELECT (.+) FROM /);
-            await Promise.all(ents.map((ent) => index_1.FakeContact.loadRawData(ent.id, v.context)));
-            expect(ml.logs.length).toBe(this.filteredContacts.length + 1);
-            for (const log of ml.logs.slice(1)) {
-                expect(log["dataloader-cache-hit"]).toBeDefined();
-            }
-            // "restore" back to previous
-            (0, logger_1.setLogLevels)("query");
-        }
-        verifyEnts(ents) {
-            (0, test_helpers_1.verifyUserToContacts)(this.user, ents, this.filteredContacts);
-        }
-        async testAll(expectedCount) {
-            const query = this.getQuery(new viewer_1.IDViewer(this.user.id));
-            const [edges, count, ids, rawCount, ents] = await Promise.all([
-                query.queryEdges(),
-                query.queryCount(),
-                query.queryIDs(),
-                query.queryRawCount(),
-                query.queryEnts(),
-            ]);
-            this.verifyCount(count, expectedCount);
-            this.verifyEdges(edges);
-            this.verifyIDs(ids);
-            this.verifyRawCount(rawCount, expectedCount);
-            this.verifyEnts(ents);
-        }
-    }
-    function verifyQuery(filter, { length = 1, numQueries = 1, limit = (0, ent_1.getDefaultLimit)(), disablePaginationBump = false, orderby = opts.orderby, }) {
-        const uniqCol = isCustomQuery(filter) ? "id" : "id2";
-        expect(ml.logs.length).toBe(length);
-        for (let i = 0; i < numQueries; i++) {
-            const whereClause = getWhereClause(ml.logs[i]);
-            let expLimit = disablePaginationBump ? limit : limit + 1;
-            expect(whereClause, `${i}`).toBe(
-            // default limit
-            `${opts.clause.clause(1)} ORDER BY ${(0, query_impl_1.getOrderByPhrase)(orderby)}, ${uniqCol} ${orderby[0].direction} LIMIT ${expLimit}`);
-        }
-    }
-    function verifyCountQuery({ length = 1, numQueries = 1 }) {
-        expect(ml.logs.length).toBe(length);
-        for (let i = 0; i < numQueries; i++) {
-            const whereClause = getWhereClause(ml.logs[i]);
-            expect(whereClause).toBe(opts.clause.clause(1));
-        }
-    }
-    function verifyFirstAfterCursorQuery(filter, length = 1, limit = 3) {
-        // cache showing up in a few because of cross runs...
-        expect(ml.logs.length).toBeGreaterThanOrEqual(length);
-        const uniqCol = isCustomQuery(filter) ? "id" : "id2";
-        let parts = opts.clause.clause(1).split(" AND ");
-        const cmp = (0, clause_1.PaginationMultipleColsSubQuery)(opts.orderby[0].column, opts.orderby[0].direction === "DESC" ? "<" : ">", opts.tableName, uniqCol, "").clause(opts.clause.values().length + 1);
-        if (parts[parts.length - 1] === "deleted_at IS NULL") {
-            parts = parts
-                .slice(0, parts.length - 1)
-                .concat([cmp, "deleted_at IS NULL"]);
-        }
-        else {
-            parts.push(cmp);
-        }
-        expect(getWhereClause(ml.logs[0])).toBe(`${parts.join(" AND ")} ORDER BY ${(0, query_impl_1.getOrderByPhrase)(opts.orderby)}, ${uniqCol} ${opts.orderby[0].direction} LIMIT ${limit + 1}`);
-    }
-    function verifyLastBeforeCursorQuery(filter, { length = 1, limit = 3, orderby = opts.orderby }) {
-        // cache showing up in a few because of cross runs...
-        expect(ml.logs.length).toBeGreaterThanOrEqual(length);
-        const uniqCol = isCustomQuery(filter) ? "id" : "id2";
-        let parts = opts.clause.clause(1).split(" AND ");
-        const cmp = (0, clause_1.PaginationMultipleColsSubQuery)(orderby[0].column, orderby[0].direction === "ASC" ? ">" : "<", opts.tableName, uniqCol, "").clause(opts.clause.values().length + 1);
-        if (parts[parts.length - 1] === "deleted_at IS NULL") {
-            parts = parts
-                .slice(0, parts.length - 1)
-                .concat([cmp, "deleted_at IS NULL"]);
-        }
-        else {
-            parts.push(cmp);
-        }
-        expect(getWhereClause(ml.logs[0])).toBe(
-        // extra fetched for pagination
-        `${parts.join(" AND ")} ORDER BY ${(0, query_impl_1.getOrderByPhrase)(orderby)}, ${uniqCol} ${orderby[0].direction} LIMIT ${limit + 1}`);
-    }
-    function getViewer() {
-        return new viewer_1.LoggedOutViewer();
-    }
-    function getCursorFrom(contacts, idx) {
-        return (0, ent_1.getCursor)({
-            row: contacts[idx],
-            col: "id",
-        });
-    }
-    function getVerifyAfterEachCursor(edges, pageLength, user) {
-        let query;
-        async function verify(i, hasEdge, hasNextPage, cursor) {
-            ml.clear();
-            query = opts.newQuery(getViewer(), user);
-            const newEdges = await query.first(pageLength, cursor).queryEdges();
-            const pagination = query.paginationInfo().get(user.id);
-            if (hasEdge) {
-                expect(newEdges[0], `${i}`).toStrictEqual(edges[i]);
-                expect(newEdges.length, `${i}`).toBe(edges.length - i >= pageLength ? pageLength : edges.length - i);
-            }
-            else {
-                expect(newEdges.length, `${i}`).toBe(0);
-            }
-            if (hasNextPage) {
-                expect(pagination?.hasNextPage, `${i}`).toBe(true);
-                expect(pagination?.hasPreviousPage, `${i}`).toBe(false);
-            }
-            else {
-                expect(pagination?.hasNextPage, `${i}`).toBe(undefined);
-                expect(pagination?.hasNextPage, `${i}`).toBe(undefined);
-            }
-            if (cursor) {
-                verifyFirstAfterCursorQuery(query, 1, pageLength);
-            }
-            else {
-                verifyQuery(query, { orderby: opts.orderby, limit: pageLength });
-            }
-        }
-        function getCursor(edge) {
-            return query.getCursor(edge);
-        }
-        return { verify, getCursor };
-    }
-    function getVerifyBeforeEachCursor(edges, pageLength, user) {
-        let query;
-        async function verify(i, hasEdge, hasPreviousPage, cursor) {
-            ml.clear();
-            query = opts.newQuery(getViewer(), user);
-            const newEdges = await query.last(pageLength, cursor).queryEdges();
-            const pagination = query.paginationInfo().get(user.id);
-            if (hasEdge) {
-                expect(newEdges.length, `${i}`).toBe(i >= pageLength ? pageLength : i + 1);
-                expect(newEdges[0], `${i}`).toStrictEqual(edges[i]);
-            }
-            else {
-                expect(newEdges.length, `${i}`).toBe(0);
-            }
-            if (hasPreviousPage) {
-                expect(pagination?.hasPreviousPage, `${i}`).toBe(true);
-                expect(pagination?.hasNextPage, `${i}`).toBe(false);
-            }
-            else {
-                expect(pagination?.hasPreviousPage, `${i}`).toBe(undefined);
-                expect(pagination?.hasNextPage, `${i}`).toBe(undefined);
-            }
-            const orderby = (0, query_impl_1.reverseOrderBy)(opts.orderby);
-            if (cursor) {
-                verifyLastBeforeCursorQuery(query, {
-                    length: 1,
-                    limit: pageLength,
-                    orderby,
-                });
-            }
-            else {
-                verifyQuery(query, {
-                    orderby,
-                    limit: pageLength,
-                });
-            }
-        }
-        function getCursor(edge) {
-            return query.getCursor(edge);
-        }
-        return { verify, getCursor };
-    }
-    if (opts.globalSchema) {
-        (0, global_schema_1.setGlobalSchema)(test_edge_global_schema_1.testEdgeGlobalSchema);
-    }
-    let tdb;
-    if (opts.sqlite) {
-        (0, temp_db_1.setupSqlite)(`sqlite:///shared_test+${opts.uniqKey}.db`, () => (0, test_helpers_1.tempDBTables)(opts.globalSchema), {
-            disableDeleteAfterEachTest: true,
-        });
-    }
-    beforeAll(async () => {
-        if (opts.livePostgresDB) {
-            tdb = await (0, test_helpers_1.setupTempDB)(opts.globalSchema);
-            return;
-        }
-        await (0, test_helpers_1.createEdges)();
-    });
-    afterAll(async () => {
-        if (opts.livePostgresDB && tdb) {
-            await tdb.afterAll();
-        }
-    });
-    describe("simple queries", () => {
-        const filter = new TestQueryFilter((q) => {
-            // no filters
-            return q;
-        }, opts.newQuery, (contacts) => {
-            // nothing to do here
-            // reverse because edges are most recent first
-            if (opts.orderby[0].direction === "DESC") {
-                return contacts.reverse();
-            }
-            return contacts;
-        }, getViewer());
-        beforeEach(async () => {
-            await filter.createData();
-        });
-        test("ids", async () => {
-            await filter.testIDs();
-            verifyQuery(filter, {});
-        });
-        test("rawCount", async () => {
-            await filter.testRawCount();
-            verifyCountQuery({});
-        });
-        test("count", async () => {
-            await filter.testCount();
-            verifyQuery(filter, {});
-        });
-        test("edges", async () => {
-            await filter.testEdges();
-            verifyQuery(filter, {});
-        });
-        test("ents", async () => {
-            await filter.testEnts();
-            verifyQuery(filter, { length: opts.entsLength });
-        });
-        test("all", async () => {
-            await filter.testAll();
-        });
-        test("ents cache", async () => {
-            await filter.testEntsCache();
-        });
-        test("data cache", async () => {
-            await filter.testDataCache();
-        });
-    });
-    describe("override default limit", () => {
-        const filter = new TestQueryFilter((q) => {
-            // no filters
-            return q;
-        }, opts.newQuery, (contacts) => {
-            // nothing to do here
-            // reverse because edges are most recent first
-            if (opts.orderby[0].direction === "DESC") {
-                return contacts.reverse();
-            }
-            return contacts;
-        }, getViewer());
-        const OUR_DEFAULT_LIMIT = 10;
-        beforeAll(async () => {
-            (0, ent_1.setDefaultLimit)(OUR_DEFAULT_LIMIT);
-        });
-        afterAll(async () => {
-            //set it back to real default
-            (0, ent_1.setDefaultLimit)(1000);
-        });
-        beforeEach(async () => {
-            await filter.createData();
-        });
-        test("ids", async () => {
-            await filter.testIDs();
-            verifyQuery(filter, {
-                limit: OUR_DEFAULT_LIMIT,
-            });
-        });
-        test("rawCount", async () => {
-            await filter.testRawCount();
-            verifyCountQuery({});
-        });
-        test("count", async () => {
-            await filter.testCount();
-            verifyQuery(filter, {
-                limit: OUR_DEFAULT_LIMIT,
-            });
-        });
-        test("edges", async () => {
-            await filter.testEdges();
-            verifyQuery(filter, {
-                limit: OUR_DEFAULT_LIMIT,
-            });
-        });
-        test("ents", async () => {
-            await filter.testEnts();
-            verifyQuery(filter, {
-                length: opts.entsLength,
-                limit: OUR_DEFAULT_LIMIT,
-            });
-        });
-        test("all", async () => {
-            await filter.testAll();
-        });
-        test("ents cache", async () => {
-            await filter.testEntsCache();
-        });
-        test("data cache", async () => {
-            await filter.testDataCache();
-        });
-    });
-    describe("after delete", () => {
-        const filter = new TestQueryFilter((q) => {
-            // no filters
-            return q;
-        }, opts.newQuery, (contacts) => {
-            // nothing expected since deleted
-            return [];
-        }, getViewer());
-        beforeEach(async () => {
-            await filter.createData();
-            const action = new builder_1.SimpleAction(filter.user.viewer, index_1.FakeUserSchema, new Map(), action_1.WriteOperation.Edit, filter.user);
-            await Promise.all(filter.allContacts.map(async (contact) => {
-                action.builder.orchestrator.removeOutboundEdge(contact.id, index_1.EdgeType.UserToContacts);
-                const action2 = new builder_1.SimpleAction(filter.user.viewer, index_1.FakeContactSchema, new Map(), action_1.WriteOperation.Delete, contact);
-                await action2.save();
-            }));
-            await action.save();
-            ml.clear();
-        });
-        test("ids", async () => {
-            await filter.testIDs();
-            verifyQuery(filter, {});
-        });
-        test("rawCount", async () => {
-            await filter.testRawCount(0);
-            verifyCountQuery({});
-        });
-        test("count", async () => {
-            await filter.testCount(0);
-            verifyQuery(filter, {});
-        });
-        test("edges", async () => {
-            await filter.testEdges();
-            verifyQuery(filter, {});
-        });
-        test("ents", async () => {
-            await filter.testEnts();
-            // no ents so no subsequent query. just the edge query
-            verifyQuery(filter, { length: 1 });
-        });
-        test("all", async () => {
-            await filter.testAll(0);
-        });
-        test("raw_data", async () => {
-            if (opts.rawDataVerify) {
-                await opts.rawDataVerify(filter.user);
-            }
-        });
-        test("ents cache", async () => {
-            await filter.testEntsCache();
-        });
-        test("data cache", async () => {
-            await filter.testDataCache();
-        });
-    });
-    describe("first. no cursor", () => {
-        const N = 2;
-        const filter = new TestQueryFilter((q) => {
-            // no filters
-            return q.first(N);
-        }, opts.newQuery, (contacts) => {
-            if (opts.orderby[0].direction === "DESC") {
-                return contacts.reverse().slice(0, N);
-            }
-            return contacts.slice(0, N);
-        }, getViewer());
-        beforeEach(async () => {
-            await filter.createData();
-        });
-        test("ids", async () => {
-            await filter.testIDs();
-            verifyQuery(filter, { limit: 2 });
-        });
-        test("rawCount", async () => {
-            await filter.testRawCount();
-            verifyCountQuery({});
-        });
-        test("count", async () => {
-            await filter.testCount();
-            verifyQuery(filter, { limit: 2 });
-        });
-        test("edges", async () => {
-            await filter.testEdges();
-            verifyQuery(filter, { limit: 2 });
-        });
-        test("ents", async () => {
-            await filter.testEnts();
-            verifyQuery(filter, { limit: 2, length: opts.entsLength });
-        });
-        test("all", async () => {
-            await filter.testAll();
-        });
-        test("ents cache", async () => {
-            await filter.testEntsCache();
-        });
-        test("data cache", async () => {
-            await filter.testDataCache();
-        });
-    });
-    describe("last", () => {
-        const N = 2;
-        const filter = new TestQueryFilter((q) => {
-            // no filters
-            return q.last(N);
-        }, opts.newQuery, (contacts) => {
-            if (opts.orderby[0].direction === "DESC") {
-                return contacts.slice(0, N);
-            }
-            else {
-                return contacts.reverse().slice(0, N);
-            }
-        }, getViewer());
-        const orderby = (0, query_impl_1.reverseOrderBy)(opts.orderby);
-        beforeEach(async () => {
-            await filter.createData();
-        });
-        test("ids", async () => {
-            await filter.testIDs();
-            verifyQuery(filter, {
-                orderby,
-                limit: N,
-            });
-        });
-        test("rawCount", async () => {
-            await filter.testRawCount();
-            verifyCountQuery({});
-        });
-        test("count", async () => {
-            await filter.testCount();
-            verifyQuery(filter, { orderby, limit: N });
-        });
-        test("edges", async () => {
-            await filter.testEdges();
-            verifyQuery(filter, { orderby, limit: N });
-        });
-        test("ents", async () => {
-            await filter.testEnts();
-            verifyQuery(filter, {
-                orderby,
-                limit: N,
-                length: opts.entsLength,
-            });
-        });
-        test("all", async () => {
-            await filter.testAll();
-        });
-        test("ents cache", async () => {
-            await filter.testEntsCache();
-        });
-        test("data cache", async () => {
-            await filter.testDataCache();
-        });
-    });
-    describe("first after cursor", () => {
-        const idx = 2;
-        const N = 3;
-        const filter = new TestQueryFilter((q, user, contacts) => {
-            return q.first(N, getCursorFrom(contacts, idx));
-        }, opts.newQuery, (contacts) => {
-            if (opts.orderby[0].direction === "DESC") {
-                // < check so we shouldn't get that index
-                return contacts.reverse().slice(idx + 1, idx + N);
-            }
-            else {
-                return contacts.slice(idx + 1, idx + N);
-            }
-        }, getViewer());
-        beforeAll(async () => {
-            await filter.createData();
-        });
-        beforeEach(() => {
-            ml.clear();
-        });
-        test("ids", async () => {
-            await filter.testIDs();
-            verifyFirstAfterCursorQuery(filter);
-        });
-        test("rawCount", async () => {
-            await filter.testRawCount();
-            verifyCountQuery({});
-        });
-        test("count", async () => {
-            await filter.testCount();
-            verifyFirstAfterCursorQuery(filter);
-        });
-        test("edges", async () => {
-            await filter.testEdges();
-            verifyFirstAfterCursorQuery(filter);
-        });
-        test("ents", async () => {
-            await filter.testEnts();
-            verifyFirstAfterCursorQuery(filter, opts.entsLength);
-        });
-        test("all", async () => {
-            await filter.testAll();
-        });
-        test("ents cache", async () => {
-            await filter.testEntsCache();
-        });
-        test("data cache", async () => {
-            await filter.testDataCache();
-        });
-    });
-    test("first. after each cursor", async () => {
-        let [user] = await (0, test_helpers_1.createAllContacts)();
-        const edges = await opts.newQuery(getViewer(), user).queryEdges();
-        const { verify, getCursor } = getVerifyAfterEachCursor(edges, 1, user);
-        await verify(0, true, true, undefined);
-        await verify(1, true, true, getCursor(edges[0]));
-        await verify(2, true, true, getCursor(edges[1]));
-        await verify(3, true, true, getCursor(edges[2]));
-        await verify(4, true, false, getCursor(edges[3]));
-        await verify(5, false, false, getCursor(edges[4]));
-    });
-    describe("last. before cursor", () => {
-        const idx = 2;
-        const N = 3;
-        const filter = new TestQueryFilter((q, user, contacts) => {
-            return q.last(N, getCursorFrom(contacts, idx));
-        }, opts.newQuery, (contacts) => {
-            // > check so we don't want that index
-            if (opts.orderby[0].direction === "DESC") {
-                return contacts.reverse().slice(0, idx).reverse(); // because of order returned
-            }
-            return contacts.slice(0, idx).reverse(); // because of order returned
-        }, getViewer());
-        const orderby = (0, query_impl_1.reverseOrderBy)(opts.orderby);
-        beforeAll(async () => {
-            if (opts.livePostgresDB || opts.sqlite) {
-                await filter.createData();
-            }
-        });
-        beforeEach(async () => {
-            ml.clear();
-        });
-        test("ids", async () => {
-            await filter.testIDs();
-            verifyLastBeforeCursorQuery(filter, { orderby });
-        });
-        test("rawCount", async () => {
-            await filter.testRawCount();
-            verifyCountQuery({});
-        });
-        test("count", async () => {
-            await filter.testCount();
-            verifyLastBeforeCursorQuery(filter, { orderby });
-        });
-        test("edges", async () => {
-            await filter.testEdges();
-            verifyLastBeforeCursorQuery(filter, { orderby });
-        });
-        test("ents", async () => {
-            await filter.testEnts();
-            verifyLastBeforeCursorQuery(filter, { orderby });
-        });
-        test("all", async () => {
-            await filter.testAll();
-        });
-        test("ents cache", async () => {
-            await filter.testEntsCache();
-        });
-        test("data cache", async () => {
-            await filter.testDataCache();
-        });
-    });
-    test("last. before each cursor", async () => {
-        let [user] = await (0, test_helpers_1.createAllContacts)();
-        const edges = await opts.newQuery(getViewer(), user).queryEdges();
-        const { verify, getCursor } = getVerifyBeforeEachCursor(edges, 1, user);
-        await verify(4, true, true, undefined);
-        await verify(3, true, true, getCursor(edges[4]));
-        await verify(2, true, true, getCursor(edges[3]));
-        await verify(1, true, true, getCursor(edges[2]));
-        await verify(0, true, false, getCursor(edges[1]));
-        await verify(-1, false, false, getCursor(edges[0]));
-    });
-    describe("with conflicts", () => {
-        let user;
-        let allEdges = [];
-        beforeEach(async () => {
-            const [u, contacts] = await (0, test_helpers_1.createAllContacts)();
-            user = u;
-            const [_, contacts2] = await (0, test_helpers_1.createAllContacts)({
-                user,
-                start: contacts[contacts.length - 1].createdAt.getTime() - 100,
-            });
-            await (0, test_helpers_1.createAllContacts)({
-                user,
-                start: contacts2[contacts.length - 1].createdAt.getTime() - 100,
-            });
-            const edges = await opts.newQuery(getViewer(), user).queryEdges();
-            // confirm there are duplicates...
-            expect(edges[4].created_at).toStrictEqual(edges[5].created_at);
-            expect(edges[9].created_at).toStrictEqual(edges[10].created_at);
-            allEdges = edges;
-        });
-        test("first after each cursor", async () => {
-            const { verify, getCursor } = getVerifyAfterEachCursor(allEdges, 5, user);
-            // regular pagination
-            await verify(0, true, true, undefined);
-            await verify(5, true, true, getCursor(allEdges[4]));
-            await verify(10, true, false, getCursor(allEdges[9]));
-            await verify(15, false, false, getCursor(allEdges[14]));
-            // one without duplicates work if we were paginating at a different place...
-            await verify(6, true, true, getCursor(allEdges[5]));
-            await verify(11, true, false, getCursor(allEdges[10]));
-        });
-        test("last before each cursor", async () => {
-            const { verify, getCursor } = getVerifyBeforeEachCursor(allEdges, 5, user);
-            await verify(14, true, true, undefined);
-            await verify(13, true, true, getCursor(allEdges[14]));
-            await verify(8, true, true, getCursor(allEdges[9]));
-            await verify(9, true, true, getCursor(allEdges[10]));
-            await verify(3, true, false, getCursor(allEdges[4]));
-            await verify(4, true, false, getCursor(allEdges[5]));
-        });
-    });
-};
-exports.commonTests = commonTests;
-// TODO parse_sql group by...
-// or test it with real db...