@snowtop/ent 0.1.0-alpha160-test6 → 0.1.0-alpha160

package/core/query/shared_test.js

@@ -0,0 +1,736 @@
+"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...