@luvio/graphql-parser 0.126.0 → 0.126.2

package/src/__tests__/gql.spec.ts

@@ -1,665 +0,0 @@
-import { gql, docMap, astResolver, processSubstitutions, stripLocation } from '../gql';
-import ast from './ast.json';
-import astNoLoc from './astNoLoc.json';
-
-var mockParse;
-
-jest.mock('graphql/language', () => {
-    const originalModule = jest.requireActual('graphql/language');
-    // we keep the original behavior, just wrapping it with a mock so we can spy
-    mockParse = jest.fn().mockImplementation((source, options) => {
-        return originalModule.parse(source, options);
-    });
-
-    return {
-        __esModule: true,
-        ...originalModule,
-        parse: mockParse,
-    };
-});
-
-const testProcessSubstitution = (literals: any, ...args: any[]) => {
-    return processSubstitutions(literals, args);
-};
-
-beforeEach(() => {
-    jest.clearAllMocks();
-    docMap.clear();
-});
-
-const mockFragment1 = `fragment fragmentName1 on SomeType1 { someField1 }`;
-const mockFragment2 = `fragment fragmentName2 on SomeType2 { someField2 }`;
-const mockTwoFragments = `${mockFragment1} ${mockFragment2}`;
-
-describe('processSubstitutions', () => {
-    it('should return correct operation string when no substitution is present', () => {
-        const result = testProcessSubstitution/* GraphQL */ `
-            query accounts {
-                uiapi {
-                    query {
-                        Account {
-                            edges {
-                                node {
-                                    Id
-                                    Name {
-                                        value
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `;
-
-        expect(result.operationString.trim()).toBe(
-            /* GraphQL */ `
-            query accounts {
-                uiapi {
-                    query {
-                        Account {
-                            edges {
-                                node {
-                                    Id
-                                    Name {
-                                        value
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `.trim()
-        );
-        expect(result.fragments).toStrictEqual([]);
-    });
-
-    it('should substitute strings correctly in the operation string', () => {
-        const field = `Contact`;
-        const subField = `displayName`;
-        const result = testProcessSubstitution/* GraphQL */ `
-            query accounts {
-                uiapi {
-                    query {
-                        Account {
-                            edges {
-                                node {
-                                    Id
-                                    Name {
-                                        value
-                                        ${subField}
-                                    }
-                                    ${field}
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `;
-
-        expect(result.operationString.trim()).toBe(
-            /* GraphQL */ `
-            query accounts {
-                uiapi {
-                    query {
-                        Account {
-                            edges {
-                                node {
-                                    Id
-                                    Name {
-                                        value
-                                        displayName
-                                    }
-                                    Contact
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `.trim()
-        );
-        expect(result.fragments).toStrictEqual([]);
-    });
-
-    it('should return correct operation string and fragments', () => {
-        const fragment = gql(mockFragment1);
-        const result = testProcessSubstitution/* GraphQL */ `
-            query accounts {
-                uiapi {
-                    query {
-                        Account {
-                            edges {
-                                node {
-                                    Id
-                                    Name {
-                                        value
-                                    }
-                                    ...fragmentName1
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            ${fragment}
-        `;
-
-        expect(result.operationString.trim()).toBe(
-            /* GraphQL */ `
-            query accounts {
-                uiapi {
-                    query {
-                        Account {
-                            edges {
-                                node {
-                                    Id
-                                    Name {
-                                        value
-                                    }
-                                    ...fragmentName1
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `.trim()
-        );
-
-        expect(result.fragments.length).toBe(1);
-        expect(result.fragments[0].kind).toBe('FragmentDefinition');
-    });
-
-    it('should return correct operation string and fragments when has multiple fragments in one substitute', () => {
-        const fragment = gql(mockTwoFragments);
-        const result = testProcessSubstitution/* GraphQL */ `
-            query accounts {
-                uiapi {
-                    query {
-                        Account {
-                            edges {
-                                node {
-                                    Id
-                                    Name {
-                                        value
-                                    }
-                                    ...fragmentName1
-                                    ...fragmentName2
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            ${fragment}
-        `;
-
-        expect(result.operationString.trim()).toBe(
-            /* GraphQL */ `
-            query accounts {
-                uiapi {
-                    query {
-                        Account {
-                            edges {
-                                node {
-                                    Id
-                                    Name {
-                                        value
-                                    }
-                                    ...fragmentName1
-                                    ...fragmentName2
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `.trim()
-        );
-
-        expect(result.fragments.length).toBe(2);
-        expect(result.fragments[0].kind).toBe('FragmentDefinition');
-        expect(result.fragments[0].name.value).toBe('fragmentName1');
-        expect(result.fragments[1].kind).toBe('FragmentDefinition');
-        expect(result.fragments[1].name.value).toBe('fragmentName2');
-    });
-
-    it('should return correct operation string and fragments when both type of substitutions are present', () => {
-        const field = `Contact`;
-        const subField = `displayValue`;
-        const fragment1 = gql(mockFragment1);
-        const fragment2 = gql(mockFragment2);
-
-        const result = testProcessSubstitution/* GraphQL */ `
-            query accounts {
-                uiapi {
-                    query {
-                        Account {
-                            edges {
-                                node {
-                                    Id
-                                    Name {
-                                        value
-                                        ${subField}
-                                    }
-                                    ${field}
-                                    ...fragmentName1
-                                    ...fragmentName2
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            ${fragment1}
-            ${fragment2}
-        `;
-
-        expect(result.operationString.trim()).toBe(
-            /* GraphQL */ `
-            query accounts {
-                uiapi {
-                    query {
-                        Account {
-                            edges {
-                                node {
-                                    Id
-                                    Name {
-                                        value
-                                        displayValue
-                                    }
-                                    Contact
-                                    ...fragmentName1
-                                    ...fragmentName2
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `.trim()
-        );
-        expect(result.fragments.length).toBe(2);
-        expect(result.fragments[0].kind).toBe('FragmentDefinition');
-        expect(result.fragments[1].kind).toBe('FragmentDefinition');
-    });
-
-    it('should throw if the fragment document is not found', () => {
-        expect(() => {
-            return testProcessSubstitution/* GraphQL */ `
-                query accounts {
-                    uiapi {
-                        query {
-                            Account {
-                                edges {
-                                    node {
-                                        Id
-                                        Name {
-                                            value
-                                        }
-                                        ...fragmentName1
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                ${{}}
-            `;
-        }).toThrowError('Invalid substitution fragment');
-    });
-
-    it('should throw if an unsupported substitution is found', () => {
-        expect(() => {
-            return testProcessSubstitution/* GraphQL */ `
-                query accounts {
-                    uiapi {
-                        query {
-                            Account {
-                                edges {
-                                    node {
-                                        Id
-                                        Name {
-                                            value
-                                        }
-                                        ...fragmentName1
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                ${true}
-            `;
-        }).toThrowError('Unsupported substitution type');
-    });
-});
-
-describe('gql', () => {
-    it(`should call the parsing api when response isn't cached`, () => {
-        const ref = gql`
-            query accounts {
-                uiapi {
-                    query {
-                        Account {
-                            edges {
-                                node {
-                                    Id
-                                    Name {
-                                        value
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `;
-        const doc = astResolver(ref);
-
-        expect(mockParse).toHaveBeenCalledTimes(1);
-        expect(doc.kind).toEqual('Document');
-    });
-
-    it(`should call the parsing api when query is passed as an argument and isn't cached`, () => {
-        const ref = gql(/* GraphQL */ `
-            query accounts {
-                uiapi {
-                    query {
-                        Account {
-                            edges {
-                                node {
-                                    Id
-                                    Name {
-                                        value
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `);
-        const doc = astResolver(ref);
-
-        expect(mockParse).toHaveBeenCalledTimes(1);
-        expect(doc.kind).toEqual('Document');
-    });
-
-    it('should get the document from cache when same query is passed again', () => {
-        // Populate doc map cache
-        const ref1 = gql`
-            query accounts {
-                uiapi {
-                    query {
-                        Account {
-                            edges {
-                                node {
-                                    Id
-                                    Name {
-                                        value
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `;
-
-        const ref2 = gql`
-            query accounts {
-                uiapi {
-                    query {
-                        Account {
-                            edges {
-                                node {
-                                    Id
-                                    Name {
-                                        value
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `;
-        const doc1 = astResolver(ref1);
-        const doc2 = astResolver(ref2);
-
-        expect(mockParse).toHaveBeenCalledTimes(1);
-        expect(doc2.kind).toEqual('Document');
-        expect(doc1).toBe(doc2);
-    });
-
-    it('should get the document from cache when we get a semantically similar query again', () => {
-        // Populate doc map cache
-        const ref1 = gql`
-            query accounts {
-                uiapi {
-                    query {
-                        Account {
-                            edges {
-                                node {
-                                    Id
-                                    Name {
-                                        value
-                                        displayValue
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `;
-
-        const ref2 = gql`
-            query accounts {
-                uiapi {
-                    query {
-                        Account {
-                            edges {
-                                node {
-                                    # This is a comment
-                                    Id
-
-                                    Name {
-                                        value
-                                        displayValue
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `;
-        const doc1 = astResolver(ref1);
-        const doc2 = astResolver(ref2);
-
-        expect(mockParse).toHaveBeenCalledTimes(1);
-        expect(doc2.kind).toEqual('Document');
-        expect(doc1).toBe(doc2);
-    });
-
-    it('should return the document with appended substitutions', () => {
-        const field = `Contact`;
-        const fragment = gql(mockFragment1);
-        const ref = gql`
-            query accounts {
-                uiapi {
-                    query {
-                        Account {
-                            edges {
-                                node {
-                                    Id
-                                    Name {
-                                        value
-                                    }
-                                    ${field}
-                                    ...ReusableFragment1
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            ${fragment}
-        `;
-        const doc = astResolver(ref);
-        const fragmentDoc = astResolver(fragment);
-
-        expect(mockParse).toHaveBeenCalledTimes(2);
-        expect(fragmentDoc.kind).toBe('Document');
-        expect(fragmentDoc.definitions.length).toBe(1);
-        expect(doc.kind).toBe('Document');
-        expect(doc.definitions.length).toBe(2);
-        expect(doc.definitions[0].kind).toBe('OperationDefinition');
-        expect(doc.definitions[1].kind).toBe('FragmentDefinition');
-    });
-
-    describe('invalid queries', () => {
-        it('should return null in case of an invalid query - in prod', () => {
-            process.env.NODE_ENV = 'production';
-            try {
-                expect(gql(undefined)).toEqual(null);
-                expect(mockParse).not.toHaveBeenCalled();
-            } finally {
-                process.env.NODE_ENV = 'test';
-            }
-        });
-
-        it('should throw in case of an undefined query', () => {
-            // eslint-disable-next-line no-unused-expressions
-            expect(() => gql(undefined)).toThrowError('Invalid query');
-            expect(mockParse).not.toHaveBeenCalled();
-        });
-
-        it('should throw in case of an invalid query', () => {
-            // eslint-disable-next-line no-unused-expressions
-            expect(() => gql``).toThrowError('Invalid query');
-            expect(mockParse).not.toHaveBeenCalled();
-        });
-
-        it('should return null in case of an invalid query - prod', () => {
-            process.env.NODE_ENV = 'production';
-            try {
-                expect(gql``).toBe(null);
-                expect(mockParse).not.toHaveBeenCalled();
-            } finally {
-                process.env.NODE_ENV = 'test';
-            }
-        });
-
-        it('should throw in case a substitution reference is invalid', () => {
-            const sub = '';
-            expect(
-                () => gql`
-                query accounts {
-                    uiapi {
-                        query {
-                            Account {
-                                edges {
-                                    node {
-                                        Id
-                                        Name {
-                                            value
-                                        }
-                                        ${sub}
-                                        ...someFragment
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            ${{}}
-            `
-            ).toThrow(`Invalid substitution fragment`);
-            expect(mockParse).not.toHaveBeenCalled();
-        });
-
-        it('should return null when in production environment and passed an invalid reference', () => {
-            process.env.NODE_ENV = 'production';
-            try {
-                const ref = gql`
-                    query accounts {
-                        uiapi {
-                            query {
-                                Account {
-                                    edges {
-                                        node {
-                                            Id
-                                            Name {
-                                                value
-                                            }
-                                            ...someFragment
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    ${{}}
-                `;
-
-                expect(ref).toBe(null);
-            } finally {
-                process.env.NODE_ENV = 'test';
-            }
-        });
-
-        it('should return null when in production environment and parsed document is invalid', () => {
-            process.env.NODE_ENV = 'production';
-            try {
-                mockParse.mockImplementation(() => ({}));
-                const ref = gql`
-                    query accounts {
-                        uiapi {
-                            query {
-                                Account {
-                                    edges {
-                                        node {
-                                            Id
-                                            Name {
-                                                value
-                                            }
-                                            ...someFragment
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                `;
-                expect(ref).toBe(null);
-            } finally {
-                process.env.NODE_ENV = 'test';
-            }
-        });
-    });
-});
-
-describe('stripLocation', () => {
-    it('should remove all loc references from the doc', () => {
-        const doc = stripLocation({
-            loc: 1,
-            arr: [{ loc: 2, a: 3 }],
-            obj: { b: 4, loc: {} },
-            noLoc: 5,
-        });
-
-        expect(doc).toStrictEqual({ arr: [{ a: 3 }], obj: { b: 4 }, noLoc: 5 });
-    });
-
-    it('should remove all loc references from the doc and deeply nested objects', () => {
-        const doc = stripLocation(ast);
-
-        expect(doc).toStrictEqual(astNoLoc);
-    });
-});