test.js

const gqlRequire = require('./src');
const gqlDefault = require('./src').default;
const loader = require('./loader');
const assert = require('chai').assert;

[gqlRequire, gqlDefault].forEach((gql, i) => {
  describe(`gql ${i}`, () => {
    it('parses queries', () => {
      assert.equal(gql`{ testQuery }`.kind, 'Document');
    });

    it('parses queries when called as a function', () => {
      assert.equal(gql('{ testQuery }').kind, 'Document');
    });

    it('parses queries with weird substitutions', () => {
      const obj = {};
      assert.equal(gql`{ field(input: "${obj.missing}") }`.kind, 'Document');
      assert.equal(gql`{ field(input: "${null}") }`.kind, 'Document');
      assert.equal(gql`{ field(input: "${0}") }`.kind, 'Document');
    });

    it('allows interpolation of documents generated by the webpack loader', () => {
      const sameFragment = "fragment SomeFragmentName on SomeType { someField }";

      const jsSource = loader.call(
        { cacheable() {} },
        "fragment SomeFragmentName on SomeType { someField }"
      );
      const module = { exports: undefined };
      eval(jsSource);

      const document = gql`query { ...SomeFragmentName } ${module.exports}`;
      assert.equal(document.kind, 'Document');
      assert.equal(document.definitions.length, 2);
      assert.equal(document.definitions[0].kind, 'OperationDefinition');
      assert.equal(document.definitions[1].kind, 'FragmentDefinition');
    });

    it('parses queries through webpack loader', () => {
      const jsSource = loader.call({ cacheable() {} }, '{ testQuery }');
      const module = { exports: undefined };
      eval(jsSource);
      assert.equal(module.exports.kind, 'Document');
    });

    it('correctly imports other files through the webpack loader', () => {
      const query = `#import "./fragment_definition.graphql"
        query {
          author {
            ...authorDetails
          }
        }`;
      const jsSource = loader.call({ cacheable() {} }, query);
      const oldRequire = require;
      const module = { exports: undefined };
      const require = (path) => {
        assert.equal(path, './fragment_definition.graphql');
        return gql`
          fragment authorDetails on Author {
            firstName
            lastName
          }`;
      };
      eval(jsSource);
      assert.equal(module.exports.kind, 'Document');
      const definitions = module.exports.definitions;
      assert.equal(definitions.length, 2);
      assert.equal(definitions[0].kind, 'OperationDefinition');
      assert.equal(definitions[1].kind, 'FragmentDefinition');
    });

    it('does not complain when presented with normal comments', (done) => {
      assert.doesNotThrow(() => {
        const query = `#normal comment
          query {
            author {
              ...authorDetails
            }
          }`;
        const jsSource = loader.call({ cacheable() {} }, query);
        const module = { exports: undefined };
        eval(jsSource);
        assert.equal(module.exports.kind, 'Document');
        done();
      });
    });

    it('returns the same object for the same query', () => {
      assert.isTrue(gql`{ sameQuery }` === gql`{ sameQuery }`);
    });

    it('returns the same object for the same query, even with whitespace differences', () => {
      assert.isTrue(gql`{ sameQuery }` === gql`  { sameQuery,   }`);
    });

    it('is correct for a simple query', () => {
      const ast = gql`
        {
          user(id: 5) {
            firstName
            lastName
          }
        }
      `;

      assert.equal(ast.kind, "Document");
      assert.deepEqual(ast.definitions, [
        {
          "kind": "OperationDefinition",
          "operation": "query",
          "name": null,
          "variableDefinitions": null,
          "directives": [],
          "selectionSet": {
            "kind": "SelectionSet",
            "selections": [
              {
                "kind": "Field",
                "alias": null,
                "name": {
                  "kind": "Name",
                  "value": "user"
                },
                "arguments": [
                  {
                    "kind": "Argument",
                    "name": {
                      "kind": "Name",
                      "value": "id"
                    },
                    "value": {
                      "kind": "IntValue",
                      "value": "5"
                    }
                  }
                ],
                "directives": [],
                "selectionSet": {
                  "kind": "SelectionSet",
                  "selections": [
                    {
                      "kind": "Field",
                      "alias": null,
                      "name": {
                        "kind": "Name",
                        "value": "firstName"
                      },
                      "arguments": [],
                      "directives": [],
                      "selectionSet": null
                    },
                    {
                      "kind": "Field",
                      "alias": null,
                      "name": {
                        "kind": "Name",
                        "value": "lastName"
                      },
                      "arguments": [],
                      "directives": [],
                      "selectionSet": null
                    }
                  ]
                }
              }
            ]
          }
        }
      ]);
    });

    it('returns the same object for the same fragment', () => {
      assert.isTrue(gql`fragment same on Same { sameQuery }` ===
        gql`fragment same on Same { sameQuery }`);
    });

    it('is correct for a fragment', () => {
      const ast = gql`
        fragment UserFragment on User {
          firstName
          lastName
        }
      `;

      assert.equal(ast.kind, "Document");
      assert.deepEqual(ast.definitions, [
        {
          "kind": "FragmentDefinition",
          "name": {
            "kind": "Name",
            "value": "UserFragment"
          },
          "typeCondition": {
            kind: "NamedType",
            "name": {
              "kind": "Name",
              "value": "User"
            }
          },
          "directives": [],
          "selectionSet": {
            "kind": "SelectionSet",
            "selections": [
              {
                "kind": "Field",
                "alias": null,
                "name": {
                  "kind": "Name",
                  "value": "firstName"
                },
                "arguments": [],
                "directives": [],
                "selectionSet": null
              },
              {
                "kind": "Field",
                "alias": null,
                "name": {
                  "kind": "Name",
                  "value": "lastName"
                },
                "arguments": [],
                "directives": [],
                "selectionSet": null
              }
            ]
          }
        }
      ]);
    });

    const fragmentAst = gql`
      fragment UserFragment on User {
        firstName
        lastName
      }
    `;
    it('can reference a fragment passed as a document', () => {
      const ast = gql`
        {
          user(id: 5) {
            ...UserFragment
          }
        }
        ${fragmentAst}
      `;

      assert.deepEqual(ast, gql`
        {
          user(id: 5) {
            ...UserFragment
          }
        }
        fragment UserFragment on User {
          firstName
          lastName
        }
      `);
    });

    it('returns the same object for the same document with substitution', () => {
      // We know that calling `gql` on a fragment string will always return
      // the same document, so we can reuse `fragmentAst`
      assert.isTrue(gql`{ ...UserFragment } ${fragmentAst}` ===
        gql`{ ...UserFragment } ${fragmentAst}`);
    });

    it('can reference a fragment that references as fragment', () => {
      const secondFragmentAst = gql`
        fragment SecondUserFragment on User {
          ...UserFragment
        }
        ${fragmentAst}
      `;

      const ast = gql`
        {
          user(id: 5) {
            ...SecondUserFragment
          }
        }
        ${secondFragmentAst}
      `;

      assert.deepEqual(ast, gql`
        {
          user(id: 5) {
            ...SecondUserFragment
          }
        }
        fragment SecondUserFragment on User {
          ...UserFragment
        }
        fragment UserFragment on User {
          firstName
          lastName
        }
      `);
    });

    describe('fragment warnings', () => {
      let warnings = [];
      const oldConsoleWarn = console.warn;
      beforeEach(() => {
        gqlRequire.resetCaches();
        warnings = [];
        console.warn = (w) => warnings.push(w);
      });
      afterEach(() => {
        console.warn = oldConsoleWarn;
      });

      it('warns if you use the same fragment name for different fragments', () => {
        const frag1 = gql`fragment TestSame on Bar { fieldOne }`;
        const frag2 = gql`fragment TestSame on Bar { fieldTwo }`;

        assert.isFalse(frag1 === frag2);
        assert.equal(warnings.length, 1);
      });

      it('does not warn if you use the same fragment name for the same fragment', () => {
        const frag1 = gql`fragment TestDifferent on Bar { fieldOne }`;
        const frag2 = gql`fragment TestDifferent on Bar { fieldOne }`;

        assert.isTrue(frag1 === frag2);
        assert.equal(warnings.length, 0);
      });

      it('does not warn if you use the same embedded fragment in two different queries', () => {
        const frag1 = gql`fragment TestEmbedded on Bar { field }`;
        const query1 = gql`{ bar { fieldOne ...TestEmbedded } } ${frag1}`;
        const query2 = gql`{ bar { fieldTwo ...TestEmbedded } } ${frag1}`;

        assert.isFalse(query1 === query2);
        assert.equal(warnings.length, 0);
      });

      it('does not warn if you use the same fragment name for embedded and non-embedded fragments', () => {
        const frag1 = gql`fragment TestEmbeddedTwo on Bar { field }`;
        const query1 = gql`{ bar { ...TestEmbedded } } ${frag1}`;
        const query2 = gql`{ bar { ...TestEmbedded } } fragment TestEmbeddedTwo on Bar { field }`;

        assert.equal(warnings.length, 0);
      });
    });

    describe('unique fragments', () => {
      beforeEach(() => {
        gqlRequire.resetCaches();
      });

      it('strips duplicate fragments from the document', () => {
        const frag1 = gql`fragment TestDuplicate on Bar { field }`;
        const query1 = gql`{ bar { fieldOne ...TestDuplicate } } ${frag1} ${frag1}`;
        const query2 = gql`{ bar { fieldOne ...TestDuplicate } } ${frag1}`;

        assert.equal(query1.definitions.length, 2);
        assert.equal(query1.definitions[1].kind, 'FragmentDefinition');
        // We don't test strict equality between the two queries because the source.body parsed from the
        // document is not the same, but the set of definitions should be.
        assert.deepEqual(query1.definitions, query2.definitions);
      });

      it('ignores duplicate fragments from second-level imports when using the webpack loader', () => {
        // take a require function and a query string, use the webpack loader to process it
        const load = (require, query) => {
          const jsSource = loader.call({ cacheable() {} }, query);
          const module = { exports: undefined };
          eval(jsSource);
          return module.exports;
        }

        const test_require = (path) => {
          switch (path) {
          case './friends.graphql':
            return load(test_require, [
              '#import "./person.graphql"',
              'fragment friends on Hero { friends { ...person } }',
            ].join('\n'));
          case './enemies.graphql':
            return load(test_require, [
              '#import "./person.graphql"',
              'fragment enemies on Hero { enemies { ...person } }',
            ].join('\n'));
          case './person.graphql':
            return load(test_require, 'fragment person on Person { name }\n');
          default:
            return null;
          };
        };

        const result = load(test_require, [
          '#import "./friends.graphql"',
          '#import "./enemies.graphql"',
          'query { hero { ...friends ...enemies } }',
        ].join('\n'));

        assert.equal(result.kind, 'Document');
        assert.equal(result.definitions.length, 4, 'after deduplication, only 4 fragments should remain');
        assert.equal(result.definitions[0].kind, 'OperationDefinition');

        // the rest of the definitions should be fragments and contain one of
        // each: "friends", "enemies", "person". Order does not matter
        const fragments = result.definitions.slice(1)
        assert(fragments.every(fragment => fragment.kind === 'FragmentDefinition'))
        assert(fragments.some(fragment => fragment.name.value === 'friends'))
        assert(fragments.some(fragment => fragment.name.value === 'enemies'))
        assert(fragments.some(fragment => fragment.name.value === 'person'))
      });
    });

    // How to make this work?
    // it.only('can reference a fragment passed as a document via shorthand', () => {
    //   const ast = gql`
    //     {
    //       user(id: 5) {
    //         ...${userFragmentDocument}
    //       }
    //     }
    //   `;
    //
    //   assert.deepEqual(ast, gql`
    //     {
    //       user(id: 5) {
    //         ...UserFragment
    //       }
    //     }
    //     fragment UserFragment on User {
    //       firstName
    //       lastName
    //     }
    //   `);
    // });

    describe('descriptors', function() {
      it('adds comments as descriptors', function() {
        const ast = gql`
          # This is a type descriptor
          type Foo {
            # This is a field descriptor
            bar: String
            baz: Int
          }
        `;
        assert.equal(ast.definitions[0].description, 'This is a type descriptor');
        assert.equal(ast.definitions[0].fields[0].description, 'This is a field descriptor');
        assert.equal(ast.definitions[0].fields[1].description, undefined);
      })
    })

  });
});