Add tests

Author: JoviDeCroock

src/graphql.ts

@@ -61,6 +61,7 @@ import type { ExecutionResult } from './execution/types.js';
 export interface GraphQLArgs {
   schema: GraphQLSchema;
   source: string | Source;
+  shouldProvideSuggestions?: boolean;
   rootValue?: unknown;
   contextValue?: unknown;
   variableValues?: Maybe<{ readonly [variable: string]: unknown }>;
@@ -101,6 +102,7 @@ function graphqlImpl(args: GraphQLArgs): PromiseOrValue<ExecutionResult> {
     operationName,
     fieldResolver,
     typeResolver,
+    shouldProvideSuggestions,
   } = args;
 
   // Validate Schema
@@ -118,7 +120,9 @@ function graphqlImpl(args: GraphQLArgs): PromiseOrValue<ExecutionResult> {
   }
 
   // Validate
-  const validationErrors = validate(schema, document);
+  const validationErrors = validate(schema, document, undefined, {
+    shouldProvideSuggestions: shouldProvideSuggestions ?? true,
+  });
   if (validationErrors.length > 0) {
     return { errors: validationErrors };
   }
@@ -133,5 +137,6 @@ function graphqlImpl(args: GraphQLArgs): PromiseOrValue<ExecutionResult> {
     operationName,
     fieldResolver,
     typeResolver,
+    shouldProvideSuggestions,
   });
 }

src/type/__tests__/enumType-test.ts

@@ -135,8 +135,14 @@ const schema = new GraphQLSchema({
 function executeQuery(
   source: string,
   variableValues?: { readonly [variable: string]: unknown },
+  shouldProvideSuggestions = true,
 ) {
-  return graphqlSync({ schema, source, variableValues });
+  return graphqlSync({
+    schema,
+    source,
+    variableValues,
+    shouldProvideSuggestions,
+  });
 }
 
 describe('Type System: Enum Values', () => {
@@ -192,6 +198,23 @@ describe('Type System: Enum Values', () => {
     });
   });
 
+  it('does not accept values not in the enum (no suggestions)', () => {
+    const result = executeQuery(
+      '{ colorEnum(fromEnum: GREENISH) }',
+      undefined,
+      false,
+    );
+
+    expectJSON(result).toDeepEqual({
+      errors: [
+        {
+          message: 'Value "GREENISH" does not exist in "Color" enum.',
+          locations: [{ line: 1, column: 23 }],
+        },
+      ],
+    });
+  });
+
   it('does not accept values with incorrect casing', () => {
     const result = executeQuery('{ colorEnum(fromEnum: green) }');
 

src/utilities/__tests__/coerceInputValue-test.ts

@@ -50,12 +50,13 @@ interface CoerceError {
 function coerceValue(
   inputValue: unknown,
   type: GraphQLInputType,
+  shouldProvideSuggestions: boolean = true,
 ): CoerceResult {
   const errors: Array<CoerceError> = [];
   const value = coerceInputValue(
     inputValue,
     type,
-    true,
+    shouldProvideSuggestions,
     (path, invalidValue, error) => {
       errors.push({ path, value: invalidValue, error: error.message });
     },
@@ -184,6 +185,18 @@ describe('coerceInputValue', () => {
       ]);
     });
 
+    it('returns an error for misspelled enum value (no suggestions)', () => {
+      const result = coerceValue('foo', TestEnum, false);
+      expectErrors(result).to.deep.equal([
+        {
+          error:
+            'Value "foo" does not exist in "TestEnum" enum.',
+          path: [],
+          value: 'foo',
+        },
+      ]);
+    });
+
     it('returns an error for incorrect value type', () => {
       const result1 = coerceValue(123, TestEnum);
       expectErrors(result1).to.deep.equal([
@@ -204,6 +217,27 @@ describe('coerceInputValue', () => {
         },
       ]);
     });
+
+    it('returns an error for incorrect value type (no suggestions)', () => {
+      const result1 = coerceValue(123, TestEnum, false);
+      expectErrors(result1).to.deep.equal([
+        {
+          error: 'Enum "TestEnum" cannot represent non-string value: 123.',
+          path: [],
+          value: 123,
+        },
+      ]);
+
+      const result2 = coerceValue({ field: 'value' }, TestEnum, false);
+      expectErrors(result2).to.deep.equal([
+        {
+          error:
+            'Enum "TestEnum" cannot represent non-string value: { field: "value" }.',
+          path: [],
+          value: { field: 'value' },
+        },
+      ]);
+    });
   });
 
   describe('for GraphQLInputObject', () => {
@@ -401,6 +435,23 @@ describe('coerceInputValue', () => {
         },
       ]);
     });
+
+    it('returns error for a misspelled field without suggestions', () => {
+      const result = coerceValue({ bart: 123 }, TestInputObject, false);
+      expectErrors(result).to.deep.equal([
+        {
+          error: 'Field "bart" is not defined by type "TestInputObject".',
+          path: [],
+          value: { bart: 123 },
+        },
+        {
+          error:
+            'Exactly one key must be specified for OneOf type "TestInputObject".',
+          path: [],
+          value: { bart: 123 },
+        },
+      ]);
+    });
   });
 
   describe('for GraphQLInputObject with default value', () => {

src/utilities/extendSchema.ts

@@ -717,7 +717,7 @@ function getDeprecationReason(
     | FieldDefinitionNode
     | InputValueDefinitionNode,
 ): Maybe<string> {
-  const deprecated = getDirectiveValues(GraphQLDeprecatedDirective, node);
+  const deprecated = getDirectiveValues(GraphQLDeprecatedDirective, node, true);
   // @ts-expect-error validated by `getDirectiveValues`
   return deprecated?.reason;
 }
@@ -728,7 +728,7 @@ function getDeprecationReason(
 function getSpecifiedByURL(
   node: ScalarTypeDefinitionNode | ScalarTypeExtensionNode,
 ): Maybe<string> {
-  const specifiedBy = getDirectiveValues(GraphQLSpecifiedByDirective, node);
+  const specifiedBy = getDirectiveValues(GraphQLSpecifiedByDirective, node, true);
   // @ts-expect-error validated by `getDirectiveValues`
   return specifiedBy?.url;
 }
@@ -737,5 +737,5 @@ function getSpecifiedByURL(
  * Given an input object node, returns if the node should be OneOf.
  */
 function isOneOf(node: InputObjectTypeDefinitionNode): boolean {
-  return Boolean(getDirectiveValues(GraphQLOneOfDirective, node));
+  return Boolean(getDirectiveValues(GraphQLOneOfDirective, node, true));
 }

src/utilities/valueFromAST.ts

@@ -148,7 +148,7 @@ export function valueFromAST(
     // no value is returned.
     let result;
     try {
-      result = type.parseLiteral(valueNode, variables);
+      result = type.parseLiteral(valueNode, variables, true);
     } catch (_error) {
       return; // Invalid: intentionally return no value.
     }

src/validation/__tests__/FieldsOnCorrectTypeRule-test.ts

@@ -12,11 +12,12 @@ import { validate } from '../validate.js';
 
 import { expectValidationErrorsWithSchema } from './harness.js';
 
-function expectErrors(queryStr: string) {
+function expectErrors(queryStr: string, shouldProvideSuggestions = true) {
   return expectValidationErrorsWithSchema(
     testSchema,
     FieldsOnCorrectTypeRule,
     queryStr,
+    shouldProvideSuggestions,
   );
 }
 
@@ -140,6 +141,22 @@ describe('Validate: Fields on correct type', () => {
     ]);
   });
 
+  it('Field not defined on fragment (no suggestions)', () => {
+    expectErrors(
+      `
+      fragment fieldNotDefined on Dog {
+        meowVolume
+      }
+    `,
+      false,
+    ).toDeepEqual([
+      {
+        message: 'Cannot query field "meowVolume" on type "Dog".',
+        locations: [{ line: 3, column: 9 }],
+      },
+    ]);
+  });
+
   it('Ignores deeply unknown field', () => {
     expectErrors(`
       fragment deepFieldNotDefined on Dog {

src/validation/__tests__/KnownArgumentNamesRule-test.ts

@@ -14,8 +14,12 @@ import {
   expectValidationErrors,
 } from './harness.js';
 
-function expectErrors(queryStr: string) {
-  return expectValidationErrors(KnownArgumentNamesRule, queryStr);
+function expectErrors(queryStr: string, shouldProvideSuggestions = true) {
+  return expectValidationErrors(
+    KnownArgumentNamesRule,
+    queryStr,
+    shouldProvideSuggestions,
+  );
 }
 
 function expectValid(queryStr: string) {
@@ -161,6 +165,22 @@ describe('Validate: Known argument names', () => {
     ]);
   });
 
+  it('misspelled directive args are reported (no suggestions)', () => {
+    expectErrors(
+      `
+      {
+        dog @skip(iff: true)
+      }
+    `,
+      false,
+    ).toDeepEqual([
+      {
+        message: 'Unknown argument "iff" on directive "@skip".',
+        locations: [{ line: 3, column: 19 }],
+      },
+    ]);
+  });
+
   it('arg passed to fragment without arg is reported', () => {
     expectErrors(`
       {
@@ -198,6 +218,27 @@ describe('Validate: Known argument names', () => {
     ]);
   });
 
+  it('misspelled fragment args are reported (no suggestions)', () => {
+    expectErrors(
+      `
+      {
+        dog {
+          ...withArg(command: SIT)
+        }
+      }
+      fragment withArg($dogCommand: DogCommand) on Dog {
+        doesKnowCommand(dogCommand: $dogCommand)
+      }
+    `,
+      false,
+    ).toDeepEqual([
+      {
+        message: 'Unknown argument "command" on fragment "withArg".',
+        locations: [{ line: 4, column: 22 }],
+      },
+    ]);
+  });
+
   it('invalid arg name', () => {
     expectErrors(`
       fragment invalidArgName on Dog {
@@ -225,6 +266,23 @@ describe('Validate: Known argument names', () => {
     ]);
   });
 
+  it('misspelled arg name is reported (no suggestions)', () => {
+    expectErrors(
+      `
+      fragment invalidArgName on Dog {
+        doesKnowCommand(DogCommand: true)
+      }
+    `,
+      false,
+    ).toDeepEqual([
+      {
+        message:
+          'Unknown argument "DogCommand" on field "Dog.doesKnowCommand".',
+        locations: [{ line: 3, column: 25 }],
+      },
+    ]);
+  });
+
   it('unknown args amongst known args', () => {
     expectErrors(`
       fragment oneGoodArgOneInvalidArg on Dog {

src/validation/__tests__/KnownTypeNamesRule-test.ts

@@ -12,8 +12,12 @@ import {
   expectValidationErrorsWithSchema,
 } from './harness.js';
 
-function expectErrors(queryStr: string) {
-  return expectValidationErrors(KnownTypeNamesRule, queryStr);
+function expectErrors(queryStr: string, shouldProvideSuggestions = true) {
+  return expectValidationErrors(
+    KnownTypeNamesRule,
+    queryStr,
+    shouldProvideSuggestions,
+  );
 }
 
 function expectErrorsWithSchema(schema: GraphQLSchema, queryStr: string) {
@@ -78,6 +82,36 @@ describe('Validate: Known type names', () => {
     ]);
   });
 
+  it('unknown type names are invalid (no suggestions)', () => {
+    expectErrors(
+      `
+      query Foo($var: [JumbledUpLetters!]!) {
+        user(id: 4) {
+          name
+          pets { ... on Badger { name }, ...PetFields }
+        }
+      }
+      fragment PetFields on Peat {
+        name
+      }
+    `,
+      false,
+    ).toDeepEqual([
+      {
+        message: 'Unknown type "JumbledUpLetters".',
+        locations: [{ line: 2, column: 24 }],
+      },
+      {
+        message: 'Unknown type "Badger".',
+        locations: [{ line: 5, column: 25 }],
+      },
+      {
+        message: 'Unknown type "Peat".',
+        locations: [{ line: 8, column: 29 }],
+      },
+    ]);
+  });
+
   it('references to standard scalars that are missing in schema', () => {
     const schema = buildSchema('type Query { foo: String }');
     const query = `