feat: add failing test when import documents with comments

Author: dimitri

packages/import/tests/documents/import-documents.spec.ts

@@ -1,65 +1,82 @@
 import '../../../testing/to-be-similar-gql-doc';
 import { processImport, VisitedFilesMap } from '../../src';
 import { print } from 'graphql';
-import { relative } from 'path'
+import { relative } from 'path';
 
 const importDocuments = (documentPath: string) => print(processImport(documentPath, __dirname));
 
 describe('import in documents', () => {
-      it('should get documents with default imports properly', async () => {
-        const document = importDocuments('./import-test/default/a.graphql');
+  it('should get documents with default imports properly', () => {
+    const document = importDocuments('./import-test/default/a.graphql');
 
-        expect(document).toBeSimilarGqlDoc(/* GraphQL */`
-          query FooQuery {
-            foo {
-              ...FooFragment
-            }
-          }
+    expect(document).toBeSimilarGqlDoc(/* GraphQL */ `
+      query FooQuery {
+        foo {
+          ...FooFragment
+        }
+      }
 
-          fragment FooFragment on Foo {
-            bar {
-              ...BarFragment
-            }
-          }
+      fragment FooFragment on Foo {
+        bar {
+          ...BarFragment
+        }
+      }
 
-          fragment BarFragment on Bar {
-            baz
-          }
-      `);
-    });
+      fragment BarFragment on Bar {
+        baz
+      }
+    `);
+  });
 
-    it('should get documents with specific imports properly', async () => {
-      const document = importDocuments('./import-test/specific/a.graphql');
+  it('should get documents with default imports properly with comments', () => {
+    const document = importDocuments('./import-test/default/with-comments.graphql');
+    expect(document).toBeSimilarGqlDoc(
+      /* GraphQL */ `
+        # eslint-disable-next-line
+        query Foo {
+          ...BarFragment
+        }
 
-      expect(document).toBeSimilarGqlDoc(/* GraphQL */`
-        query FooQuery {
-          foo {
-            ...FooFragment
-          }
+        fragment BarFragment on Bar {
+          baz
         }
+      `,
+      { skipComments: false }
+    );
+  });
 
-        fragment FooFragment on Foo {
-          bar {
-            ...BarFragment
-          }
+  it('should get documents with specific imports properly', () => {
+    const document = importDocuments('./import-test/specific/a.graphql');
+
+    expect(document).toBeSimilarGqlDoc(/* GraphQL */ `
+      query FooQuery {
+        foo {
+          ...FooFragment
         }
+      }
 
-        fragment BarFragment on Bar {
-          baz
+      fragment FooFragment on Foo {
+        bar {
+          ...BarFragment
         }
-      `);
-    });
+      }
+
+      fragment BarFragment on Bar {
+        baz
+      }
+    `);
+  });
 
-    it('should accept a map as fourth argument for users to get visited file paths with details', () => {
-      const visitedFiles: VisitedFilesMap = new Map();
-      processImport('./import-test/default/a.graphql', __dirname, undefined, visitedFiles);
-      const relativePaths = Array.from(visitedFiles.keys())
-        .map(absPath => relative(__dirname, absPath))
-        .map(relPath => relPath.replace(/\\/g, '\/'))
-      expect(relativePaths).toStrictEqual([
-        "import-test/default/a.graphql",
-        "import-test/default/b.graphql",
-        "import-test/default/c.graphql"
-      ]);
-    })
+  it('should accept a map as fourth argument for users to get visited file paths with details', () => {
+    const visitedFiles: VisitedFilesMap = new Map();
+    processImport('./import-test/default/a.graphql', __dirname, undefined, visitedFiles);
+    const relativePaths = Array.from(visitedFiles.keys())
+      .map(absPath => relative(__dirname, absPath))
+      .map(relPath => relPath.replace(/\\/g, '\/'));
+    expect(relativePaths).toStrictEqual([
+      'import-test/default/a.graphql',
+      'import-test/default/b.graphql',
+      'import-test/default/c.graphql',
+    ]);
+  });
 });

packages/import/tests/documents/import-test/default/with-comments.graphql

@@ -0,0 +1,6 @@
+#import 'c.graphql'
+
+# eslint-disable-next-line
+query Foo {
+    ...BarFragment
+}

packages/testing/to-be-similar-gql-doc.ts

@@ -1,13 +1,14 @@
 import { ASTNode, parse, DocumentNode, DefinitionNode, print } from 'graphql';
 import { compareNodes } from '@graphql-tools/utils';
+import prettier from 'prettier';
 
 declare global {
   namespace jest {
     interface Matchers<R, T> {
       /**
        * Normalizes whitespace and performs string comparisons
        */
-      toBeSimilarGqlDoc(expected: string): R;
+      toBeSimilarGqlDoc(expected: string, { skipComments }?: { skipComments: boolean }): R;
     }
   }
 }
@@ -27,35 +28,39 @@ function sortRecursive(a: ASTNode) {
   }
 }
 
-function normalizeDocumentString(docStr: string) {
+function normalizeDocumentString(docStr: string, skipComments: boolean) {
+  if (!skipComments) {
+    return prettier.format(docStr, { parser: 'graphql' });
+  }
+
   const doc = parse(docStr, { noLocation: true }) as DocumentNode & { definitions: DefinitionNode[] };
   sortRecursive(doc);
   return print(doc);
 }
 
 expect.extend({
-  toBeSimilarGqlDoc(received: string, expected: string) {
-    const strippedReceived = normalizeDocumentString(received);
-    const strippedExpected = normalizeDocumentString(expected);
+  toBeSimilarGqlDoc(received: string, expected: string, { skipComments } = { skipComments: true }) {
+    const strippedReceived = normalizeDocumentString(received, skipComments);
+    const strippedExpected = normalizeDocumentString(expected, skipComments);
 
     if (strippedReceived.trim() === strippedExpected.trim()) {
       return {
         message: () =>
           `expected
-       ${received}
-       not to be a string containing (ignoring indents)
-       ${expected}`,
+${received}
+not to be a string containing (ignoring indents)
+${expected}`,
         pass: true,
       };
-    } else {
-      return {
-        message: () =>
-          `expected
-       ${received}
-       to be a string containing (ignoring indents)
-       ${expected}`,
-        pass: false,
-      };
     }
+
+    return {
+      message: () =>
+        `expected
+${received}
+to be a string containing (ignoring indents)
+${expected}`,
+      pass: false,
+    };
   },
 });