@khanacademy/wonder-blocks-data 13.0.11 → 14.0.0

package/src/util/__tests__/graphql-document-node-parser.test.ts

@@ -1,535 +0,0 @@
-import {jest as wsJest} from "@khanacademy/wonder-stuff-testing";
-import {graphQLDocumentNodeParser} from "../graphql-document-node-parser";
-
-describe("#graphQLDocumentNodeParser", () => {
-    describe("in production - shorter error messages", () => {
-        beforeEach(() => {
-            process.env.NODE_ENV = "production";
-        });
-
-        wsJest.afterEachRestoreEnv("NODE_ENV");
-
-        it("should throw if the document lacks the kind property", () => {
-            // Arrange
-            const documentNode: any = {};
-
-            // Act
-            const underTest = () => graphQLDocumentNodeParser(documentNode);
-
-            // Assert
-            expect(underTest).toThrowErrorMatchingInlineSnapshot(
-                `"Bad DocumentNode"`,
-            );
-        });
-
-        it("should throw if the document contains only fragments", () => {
-            // Arrange
-            const documentNode = {
-                kind: "Document",
-                definitions: [
-                    {
-                        kind: "FragmentDefinition",
-                        name: {
-                            kind: "Name",
-                            value: "fragment",
-                        },
-                        typeCondition: {
-                            kind: "NamedType",
-                            name: {
-                                kind: "Name",
-                                value: "Query",
-                            },
-                        },
-                        selectionSet: {
-                            kind: "SelectionSet",
-                            selections: [
-                                {
-                                    kind: "Field",
-                                    name: {
-                                        kind: "Name",
-                                        value: "test",
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                ],
-            } as const;
-
-            // Act
-            const underTest = () => graphQLDocumentNodeParser(documentNode);
-
-            // Assert
-            expect(underTest).toThrowErrorMatchingInlineSnapshot(
-                `"Fragment only"`,
-            );
-        });
-
-        it("should throw if the document contains subscriptions", () => {
-            // Arrange
-            const documentNode = {
-                kind: "Document",
-                definitions: [
-                    {
-                        kind: "OperationDefinition",
-                        operation: "subscription",
-                        variableDefinitions: [],
-                        name: {
-                            kind: "Name",
-                            value: "subscription",
-                        },
-                    },
-                ],
-            } as const;
-
-            // Act
-            const underTest = () => graphQLDocumentNodeParser(documentNode);
-
-            // Assert
-            expect(underTest).toThrowErrorMatchingInlineSnapshot(
-                `"No subscriptions"`,
-            );
-        });
-
-        it("should throw if the document contains more than one query", () => {
-            // Arrange
-            const documentNode = {
-                kind: "Document",
-                definitions: [
-                    {
-                        kind: "OperationDefinition",
-                        operation: "query",
-                        variableDefinitions: [],
-                        name: {
-                            kind: "Name",
-                            value: "query",
-                        },
-                    },
-                    {
-                        kind: "OperationDefinition",
-                        operation: "query",
-                        variableDefinitions: [],
-                        name: {
-                            kind: "Name",
-                            value: "query",
-                        },
-                    },
-                ],
-            } as const;
-
-            // Act
-            const underTest = () => graphQLDocumentNodeParser(documentNode);
-
-            // Assert
-            expect(underTest).toThrowErrorMatchingInlineSnapshot(
-                `"Too many ops"`,
-            );
-        });
-
-        it("should throw if the document contains more than one mutation", () => {
-            // Arrange
-            const documentNode = {
-                kind: "Document",
-                definitions: [
-                    {
-                        kind: "OperationDefinition",
-                        operation: "mutation",
-                        variableDefinitions: [],
-                        name: {
-                            kind: "Name",
-                            value: "mutation",
-                        },
-                    },
-                    {
-                        kind: "OperationDefinition",
-                        operation: "mutation",
-                        variableDefinitions: [],
-                        name: {
-                            kind: "Name",
-                            value: "mutation",
-                        },
-                    },
-                ],
-            } as const;
-
-            // Act
-            const underTest = () => graphQLDocumentNodeParser(documentNode);
-
-            // Assert
-            expect(underTest).toThrowErrorMatchingInlineSnapshot(
-                `"Too many ops"`,
-            );
-        });
-
-        it("should throw if the document is a combination of query and mutation", () => {
-            // Arrange
-            const documentNode = {
-                kind: "Document",
-                definitions: [
-                    {
-                        kind: "OperationDefinition",
-                        operation: "query",
-                        variableDefinitions: [],
-                        name: {
-                            kind: "Name",
-                            value: "query",
-                        },
-                    },
-                    {
-                        kind: "OperationDefinition",
-                        operation: "mutation",
-                        variableDefinitions: [],
-                        name: {
-                            kind: "Name",
-                            value: "mutation",
-                        },
-                    },
-                ],
-            } as const;
-
-            // Act
-            const underTest = () => graphQLDocumentNodeParser(documentNode);
-
-            // Assert
-            expect(underTest).toThrowErrorMatchingInlineSnapshot(
-                `"Too many ops"`,
-            );
-        });
-    });
-
-    describe("not in production - more informative error messages", () => {
-        it("should throw if the document lacks the kind property", () => {
-            // Arrange
-            const documentNode = {} as any;
-
-            // Act
-            const underTest = () => graphQLDocumentNodeParser(documentNode);
-
-            // Assert
-            expect(underTest).toThrowErrorMatchingInlineSnapshot(
-                `"Argument of {} passed to parser was not a valid GraphQL DocumentNode. You may need to use 'graphql-tag' or another method to convert your operation into a document"`,
-            );
-        });
-
-        it("should throw if the document contains only fragments", () => {
-            // Arrange
-            const documentNode = {
-                kind: "Document",
-                definitions: [
-                    {
-                        kind: "FragmentDefinition",
-                        name: {
-                            kind: "Name",
-                            value: "fragment",
-                        },
-                        typeCondition: {
-                            kind: "NamedType",
-                            name: {
-                                kind: "Name",
-                                value: "Query",
-                            },
-                        },
-                        selectionSet: {
-                            kind: "SelectionSet",
-                            selections: [
-                                {
-                                    kind: "Field",
-                                    name: {
-                                        kind: "Name",
-                                        value: "test",
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                ],
-            } as const;
-
-            // Act
-            const underTest = () => graphQLDocumentNodeParser(documentNode);
-
-            // Assert
-            expect(underTest).toThrowErrorMatchingInlineSnapshot(
-                `"Passing only a fragment to 'graphql' is not supported. You must include a query or mutation as well"`,
-            );
-        });
-
-        it("should throw if the document contains subscriptions", () => {
-            // Arrange
-            const documentNode = {
-                kind: "Document",
-                definitions: [
-                    {
-                        kind: "OperationDefinition",
-                        operation: "subscription",
-                        variableDefinitions: [],
-                        name: {
-                            kind: "Name",
-                            value: "subscription",
-                        },
-                    },
-                ],
-            } as const;
-
-            // Act
-            const underTest = () => graphQLDocumentNodeParser(documentNode);
-
-            // Assert
-            expect(underTest).toThrowErrorMatchingInlineSnapshot(
-                `"We do not support subscriptions. {"kind":"Document","definitions":[{"kind":"OperationDefinition","operation":"subscription","variableDefinitions":[],"name":{"kind":"Name","value":"subscription"}}]} had 1 subscriptions"`,
-            );
-        });
-
-        it("should throw if the document contains more than one query", () => {
-            // Arrange
-            const documentNode = {
-                kind: "Document",
-                definitions: [
-                    {
-                        kind: "OperationDefinition",
-                        operation: "query",
-                        variableDefinitions: [],
-                        name: {
-                            kind: "Name",
-                            value: "query",
-                        },
-                    },
-                    {
-                        kind: "OperationDefinition",
-                        operation: "query",
-                        variableDefinitions: [],
-                        name: {
-                            kind: "Name",
-                            value: "query",
-                        },
-                    },
-                ],
-            } as const;
-
-            // Act
-            const underTest = () => graphQLDocumentNodeParser(documentNode);
-
-            // Assert
-            expect(underTest).toThrowErrorMatchingInlineSnapshot(
-                `"We only support one query or mutation per component. {"kind":"Document","definitions":[{"kind":"OperationDefinition","operation":"query","variableDefinitions":[],"name":{"kind":"Name","value":"query"}},{"kind":"OperationDefinition","operation":"query","variableDefinitions":[],"name":{"kind":"Name","value":"query"}}]} had 2 queries and 0 mutations. "`,
-            );
-        });
-
-        it("should throw if the document contains more than one mutation", () => {
-            // Arrange
-            const documentNode = {
-                kind: "Document",
-                definitions: [
-                    {
-                        kind: "OperationDefinition",
-                        operation: "mutation",
-                        variableDefinitions: [],
-                        name: {
-                            kind: "Name",
-                            value: "mutation",
-                        },
-                    },
-                    {
-                        kind: "OperationDefinition",
-                        operation: "mutation",
-                        variableDefinitions: [],
-                        name: {
-                            kind: "Name",
-                            value: "mutation",
-                        },
-                    },
-                ],
-            } as const;
-
-            // Act
-            const underTest = () => graphQLDocumentNodeParser(documentNode);
-
-            // Assert
-            expect(underTest).toThrowErrorMatchingInlineSnapshot(
-                `"We only support one query or mutation per component. {"kind":"Document","definitions":[{"kind":"OperationDefinition","operation":"mutation","variableDefinitions":[],"name":{"kind":"Name","value":"mutation"}},{"kind":"OperationDefinition","operation":"mutation","variableDefinitions":[],"name":{"kind":"Name","value":"mutation"}}]} had 0 queries and 2 mutations. "`,
-            );
-        });
-
-        it("should throw if the document is a combination of query and mutation", () => {
-            // Arrange
-            const documentNode = {
-                kind: "Document",
-                definitions: [
-                    {
-                        kind: "OperationDefinition",
-                        operation: "query",
-                        variableDefinitions: [],
-                        name: {
-                            kind: "Name",
-                            value: "query",
-                        },
-                    },
-                    {
-                        kind: "OperationDefinition",
-                        operation: "mutation",
-                        variableDefinitions: [],
-                        name: {
-                            kind: "Name",
-                            value: "mutation",
-                        },
-                    },
-                ],
-            } as const;
-
-            // Act
-            const underTest = () => graphQLDocumentNodeParser(documentNode);
-
-            // Assert
-            expect(underTest).toThrowErrorMatchingInlineSnapshot(
-                `"We only support one query or mutation per component. {"kind":"Document","definitions":[{"kind":"OperationDefinition","operation":"query","variableDefinitions":[],"name":{"kind":"Name","value":"query"}},{"kind":"OperationDefinition","operation":"mutation","variableDefinitions":[],"name":{"kind":"Name","value":"mutation"}}]} had 1 queries and 1 mutations. "`,
-            );
-        });
-    });
-
-    it("should return the operation name, type, and variables for a query", () => {
-        // Arrange
-        const documentNode: any = {
-            kind: "Document",
-            definitions: [
-                {
-                    kind: "OperationDefinition",
-                    operation: "query",
-                    variableDefinitions: [
-                        {
-                            kind: "VariableDefinition",
-                            variable: {
-                                kind: "Variable",
-                                name: {
-                                    kind: "Name",
-                                    value: "variable",
-                                },
-                            },
-                            type: {
-                                kind: "NamedType",
-                                name: {
-                                    kind: "Name",
-                                    value: "String",
-                                },
-                            },
-                            defaultValue: {
-                                kind: "StringValue",
-                                value: "defaultValue",
-                            },
-                        },
-                    ],
-                    name: {
-                        kind: "Name",
-                        value: "myQuery",
-                    },
-                },
-            ],
-        };
-
-        // Act
-        const result = graphQLDocumentNodeParser(documentNode);
-
-        // Assert
-        expect(result).toEqual({
-            name: "myQuery",
-            type: "query",
-            variables: documentNode.definitions[0].variableDefinitions,
-        });
-    });
-
-    it("should return the operation name, type, and variables for a mutation", () => {
-        // Arrange
-        const documentNode: any = {
-            kind: "Document",
-            definitions: [
-                {
-                    kind: "OperationDefinition",
-                    operation: "mutation",
-                    variableDefinitions: [
-                        {
-                            kind: "VariableDefinition",
-                            variable: {
-                                kind: "Variable",
-                                name: {
-                                    kind: "Name",
-                                    value: "variable",
-                                },
-                            },
-                            type: {
-                                kind: "NamedType",
-                                name: {
-                                    kind: "Name",
-                                    value: "String",
-                                },
-                            },
-                            defaultValue: {
-                                kind: "StringValue",
-                                value: "defaultValue",
-                            },
-                        },
-                    ],
-                    name: {
-                        kind: "Name",
-                        value: "myMutation",
-                    },
-                },
-            ],
-        };
-
-        // Act
-        const result = graphQLDocumentNodeParser(documentNode);
-
-        // Assert
-        expect(result).toEqual({
-            name: "myMutation",
-            type: "mutation",
-            variables: documentNode.definitions[0].variableDefinitions,
-        });
-    });
-
-    it("should use name of data if no name in document", () => {
-        // Arrange
-        const documentNode: any = {
-            kind: "Document",
-            definitions: [
-                {
-                    kind: "OperationDefinition",
-                    operation: "query",
-                },
-            ],
-        };
-
-        // Act
-        const result = graphQLDocumentNodeParser(documentNode);
-
-        // Assert
-        expect(result).toEqual({
-            name: "data",
-            type: "query",
-            variables: [],
-        });
-    });
-
-    it("should cache the output", () => {
-        // Arrange
-        const documentNode: any = {
-            kind: "Document",
-            definitions: [
-                {
-                    kind: "OperationDefinition",
-                    operation: "query",
-                    name: {
-                        kind: "Name",
-                        value: "myQuery",
-                    },
-                },
-            ],
-        };
-
-        // Act
-        const initialResult = graphQLDocumentNodeParser(documentNode);
-        const secondResult = graphQLDocumentNodeParser(documentNode);
-
-        // Assert
-        expect(initialResult).toBe(secondResult);
-    });
-});

package/src/util/__tests__/hydration-cache-api.test.ts

@@ -1,34 +0,0 @@
-import {SsrCache} from "../ssr-cache";
-
-import {
-    initializeHydrationCache,
-    purgeHydrationCache,
-} from "../hydration-cache-api";
-
-describe("#initializeHydrationCache", () => {
-    it("should call SsrCache.Default.initialize", () => {
-        // Arrange
-        const sourceCache: Record<string, any> = {};
-        const initSpy = jest.spyOn(SsrCache.Default, "initialize");
-
-        // Act
-        initializeHydrationCache(sourceCache);
-
-        // Assert
-        expect(initSpy).toHaveBeenCalledWith(sourceCache);
-    });
-});
-
-describe("#purgeHydrationCache", () => {
-    it("should call SsrCache.Default.purgeData", () => {
-        // Arrange
-        const predicate = jest.fn();
-        const purgeDataSpy = jest.spyOn(SsrCache.Default, "purgeData");
-
-        // Act
-        purgeHydrationCache(predicate);
-
-        // Assert
-        expect(purgeDataSpy).toHaveBeenCalledWith(predicate);
-    });
-});

package/src/util/__tests__/merge-gql-context.test.ts

@@ -1,73 +0,0 @@
-import {mergeGqlContext} from "../merge-gql-context";
-
-describe("#mergeGqlContext", () => {
-    it("should combine the default context with the given overrides", () => {
-        // Arrange
-        const baseContext = {
-            foo: "bar",
-        } as const;
-
-        // Act
-        const result = mergeGqlContext<any>(baseContext, {
-            fiz: "baz",
-        });
-
-        // Assert
-        expect(result).toStrictEqual({
-            foo: "bar",
-            fiz: "baz",
-        });
-    });
-
-    it("should overwrite values in the default context with the given overrides", () => {
-        // Arrange
-        const baseContext = {
-            foo: "bar",
-        } as const;
-
-        // Act
-        const result = mergeGqlContext<any>(baseContext, {
-            foo: "boo",
-        });
-
-        // Assert
-        expect(result).toStrictEqual({
-            foo: "boo",
-        });
-    });
-
-    it("should not overwrite values in the default context with undefined values in the given overrides", () => {
-        // Arrange
-        const baseContext = {
-            foo: "bar",
-        } as const;
-
-        // Act
-        const result = mergeGqlContext<any>(baseContext, {
-            foo: undefined,
-        });
-
-        // Assert
-        expect(result).toStrictEqual({
-            foo: "bar",
-        });
-    });
-
-    it("should delete values in the default context when the value is null in the given overrides", () => {
-        // Arrange
-        const baseContext = {
-            foo: "bar",
-            fiz: "baz",
-        } as const;
-
-        // Act
-        const result = mergeGqlContext<any>(baseContext, {
-            fiz: null,
-        });
-
-        // Assert
-        expect(result).toStrictEqual({
-            foo: "bar",
-        });
-    });
-});

package/src/util/__tests__/purge-caches.test.ts

@@ -1,28 +0,0 @@
-import {SharedCache} from "../../hooks/use-shared-cache";
-import * as HydrationCacheApi from "../hydration-cache-api";
-
-import {purgeCaches} from "../purge-caches";
-
-describe("#purgeCaches", () => {
-    it("should purge the shared cache", () => {
-        // Arrange
-        const spy = jest.spyOn(SharedCache, "purgeAll");
-
-        // Act
-        purgeCaches();
-
-        // Assert
-        expect(spy).toHaveBeenCalled();
-    });
-
-    it("should purge the hydration cache", () => {
-        // Arrange
-        const spy = jest.spyOn(HydrationCacheApi, "purgeHydrationCache");
-
-        // Act
-        purgeCaches();
-
-        // Assert
-        expect(spy).toHaveBeenCalled();
-    });
-});