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

package/graphql/query/shared_assoc_test.d.ts

@@ -1 +0,0 @@
-export declare function sharedAssocTests(): void;

package/graphql/query/shared_assoc_test.js

@@ -1,203 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sharedAssocTests = void 0;
-const viewer_1 = require("../../core/viewer");
-const jest_date_mock_1 = require("jest-date-mock");
-const edge_connection_1 = require("./edge_connection");
-const connection_type_1 = require("./connection_type");
-const graphql_1 = require("graphql");
-const node_1 = require("../builtins/node");
-const ent_graphql_tests_1 = require("../../testutils/ent-graphql-tests");
-const index_1 = require("../../testutils/fake_data/index");
-const test_helpers_1 = require("../../testutils/fake_data/test_helpers");
-function sharedAssocTests() {
-    // pretty sure this works for custom ents but need tests for this eventually
-    describe("not all ents visible", () => {
-        let user;
-        let event;
-        let users;
-        let conn;
-        let friendCount;
-        // let's make it big. 20 people
-        let friendsInput = [...test_helpers_1.inputs, ...test_helpers_1.inputs, ...test_helpers_1.inputs, ...test_helpers_1.inputs];
-        beforeEach(async () => {
-            friendCount = 0;
-            user = await (0, test_helpers_1.createTestUser)();
-            event = await (0, test_helpers_1.createTestEvent)(user);
-            let promises = [];
-            for (let i = 0; i < friendsInput.length; i++) {
-                (0, jest_date_mock_1.advanceBy)(100);
-                let input = friendsInput[i];
-                const builder = (0, index_1.getUserBuilder)(user.viewer, (0, test_helpers_1.getUserInput)(input));
-                if (i % 2 == 1) {
-                    builder.orchestrator.addOutboundEdge(user.id, index_1.EdgeType.UserToFriends, "User");
-                    friendCount++;
-                }
-                // invite user to events
-                builder.orchestrator.addInboundEdge(event.id, index_1.EdgeType.EventToInvited, "User", {
-                    // just to make times deterministic so that tests can consistently work
-                    time: new Date(),
-                });
-                promises.push((async function () {
-                    await builder.saveX();
-                    return builder.editedEntX();
-                })());
-            }
-            users = await Promise.all(promises);
-            // only few of the users invited as friends
-            const vc = new viewer_1.IDViewer(user.id);
-            const friendsEdge = await index_1.UserToFriendsQuery.query(vc, user.id).queryEdges();
-            expect(friendsEdge.length).toBe(friendCount);
-            // everyone  invited to event
-            const invitedEventsEdges = await index_1.EventToInvitedQuery.query(vc, event.id).queryEdges();
-            expect(invitedEventsEdges.length).toBe(friendsInput.length);
-            resetConn();
-        });
-        function resetConn() {
-            conn = new edge_connection_1.GraphQLEdgeConnection(new viewer_1.IDViewer(user.id), event, (v, event) => new index_1.EventToInvitedQuery(v, event));
-        }
-        test("totalCount", async () => {
-            const count = await conn.queryTotalCount();
-            expect(count).toBe(users.length);
-        });
-        test("nodes", async () => {
-            const nodes = await conn.queryNodes();
-            expect(nodes.length).toBe(friendCount);
-        });
-        test("edges", async () => {
-            const edges = await conn.queryEdges();
-            expect(edges.length).toBe(friendCount);
-        });
-        test("pagination", async () => {
-            const edges = await index_1.EventToInvitedQuery.query(new viewer_1.LoggedOutViewer(), event).queryEdges();
-            async function verify(first, length, hasNextpage, index) {
-                let cursor;
-                if (index) {
-                    cursor = edges[index].getCursor();
-                }
-                resetConn();
-                conn.first(first, cursor);
-                const [pagination, gqlEdges, nodes] = await Promise.all([
-                    conn.queryPageInfo(),
-                    conn.queryEdges(),
-                    conn.queryNodes(),
-                ]);
-                expect(pagination.hasNextPage, `${index}`).toBe(hasNextpage);
-                expect(pagination.hasPreviousPage, `${index}`).toBe(false);
-                expect(gqlEdges.length, `${index}`).toBe(length);
-                expect(nodes.length, `${index}`).toBe(length);
-                // TODO: not equal even though we're querying only one because the cursors are not privacy-aware
-                // TODO: fix
-            }
-            // TODO build exponential backoff into EntQuery so this isn't needed
-            // but this is how it is for now
-            await verify(1, 1, true);
-            await verify(2, 1, true);
-            await verify(2, 1, true, 0);
-            await verify(2, 1, true, 2);
-            await verify(2, 1, true, 4);
-            await verify(2, 1, true, 6);
-            await verify(2, 1, true, 8);
-            await verify(2, 1, true, 10);
-            await verify(2, 1, true, 12);
-            await verify(2, 1, true, 14);
-            await verify(2, 1, true, 16);
-            await verify(2, 1, false, 17);
-        });
-    });
-    test("custom edge fields", async () => {
-        let userType = new graphql_1.GraphQLObjectType({
-            name: "User",
-            fields: {
-                id: {
-                    type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLID),
-                },
-                firstName: {
-                    type: graphql_1.GraphQLString,
-                },
-                lastName: {
-                    type: graphql_1.GraphQLString,
-                },
-            },
-            interfaces: [node_1.GraphQLNodeInterface],
-            isTypeOf(obj, _context) {
-                return obj instanceof index_1.FakeUser;
-            },
-        });
-        let eventType = new graphql_1.GraphQLObjectType({
-            name: "Event",
-            fields: {
-                id: {
-                    type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLID),
-                },
-            },
-            interfaces: [node_1.GraphQLNodeInterface],
-            isTypeOf(obj, _context) {
-                return obj instanceof index_1.FakeEvent;
-            },
-        });
-        const conn = new connection_type_1.GraphQLConnectionType("CustomEdge", eventType);
-        const length = (m) => {
-            let count = 0;
-            for (let _ in m) {
-                count++;
-            }
-            return count;
-        };
-        const fields = conn.edgeType.getFields();
-        // default.
-        expect(length(fields)).toBe(2);
-        expect(fields["node"]).toBeDefined();
-        expect(fields["cursor"]).toBeDefined();
-        const conn2 = new connection_type_1.GraphQLConnectionType("CustomEdge", eventType, {
-            fields: () => ({
-                bar: {
-                    type: graphql_1.GraphQLString,
-                    resolve() {
-                        return "customEdgeData";
-                    },
-                },
-            }),
-        });
-        const fields2 = conn2.edgeType.getFields();
-        expect(length(fields2)).toBe(3);
-        expect(fields2["bar"]).toBeDefined();
-        expect(fields2["node"]).toBeDefined();
-        expect(fields2["cursor"]).toBeDefined();
-        const user = await (0, test_helpers_1.createTestUser)();
-        const event = await (0, test_helpers_1.createTestEvent)(user);
-        let rootQuery = new graphql_1.GraphQLObjectType({
-            name: "RootQueryType",
-            fields: {
-                conn: {
-                    type: conn2,
-                    async resolve(_source, { id }, context) {
-                        return new edge_connection_1.GraphQLEdgeConnection(new viewer_1.IDViewer(user.id), user, (v, event) => new index_1.UserToHostedEventsQuery(v, event));
-                    },
-                },
-            },
-        });
-        let schema = new graphql_1.GraphQLSchema({
-            query: rootQuery,
-            types: [userType, eventType],
-        });
-        let cfg = {
-            schema: schema,
-            root: "conn",
-            viewer: new viewer_1.IDViewer(user.id),
-            args: {},
-        };
-        await (0, ent_graphql_tests_1.expectQueryFromRoot)(cfg, [
-            "edges",
-            [
-                {
-                    node: {
-                        id: event.id,
-                    },
-                    bar: "customEdgeData",
-                },
-            ],
-        ]);
-    });
-}
-exports.sharedAssocTests = sharedAssocTests;