coverage: ignore uncovered branches caused by graphql#2203

IvanGoncharov · Jan 4, 2020 · 21c08f8 · 21c08f8
1 parent 0043a7d
commit 21c08f8
Show file tree

Hide file tree

Showing 10 changed files with 169 additions and 144 deletions.
diff --git a/src/execution/execute.js b/src/execution/execute.js
@@ -312,9 +312,12 @@ export function buildExecutionContext(
     return [new GraphQLError('Must provide an operation.')];
   }
 
+  /* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
+  const variableDefinitions = operation.variableDefinitions || [];
+
   const coercedVariableValues = getVariableValues(
     schema,
-    operation.variableDefinitions || [],
+    variableDefinitions,
     rawVariableValues || {},
     { maxErrors: 50 },
   );

diff --git a/src/execution/values.js b/src/execution/values.js
@@ -164,7 +164,10 @@ export function getArgumentValues(
   variableValues?: ?ObjMap<mixed>,
 ): { [argument: string]: mixed, ... } {
   const coercedValues = {};
-  const argNodeMap = keyMap(node.arguments || [], arg => arg.name.value);
+
+  /* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
+  const argumentNodes = node.arguments || [];
+  const argNodeMap = keyMap(argumentNodes, arg => arg.name.value);
 
   for (const argDef of def.args) {
     const name = argDef.name;

diff --git a/src/type/validate.js b/src/type/validate.js
@@ -591,6 +591,7 @@ function getAllSubNodes<T: ASTNode, K: ASTNode, L: ASTNode>(
   object: SDLDefinedObject<T, K>,
   getter: (T | K) => ?(L | $ReadOnlyArray<L>),
 ): $ReadOnlyArray<L> {
+  /* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
   return flatMap(getAllNodes(object), item => getter(item) || []);
 }
 

diff --git a/src/utilities/extendSchema.js b/src/utilities/extendSchema.js
@@ -433,10 +433,11 @@ export function extendSchemaImpl(
     // validation with validateSchema() will produce more actionable results.
     const opTypes: any = {};
     for (const node of nodes) {
-      if (node.operationTypes != null) {
-        for (const operationType of node.operationTypes) {
-          opTypes[operationType.operation] = getNamedType(operationType.type);
-        }
+      /* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
+      const operationTypesNodes = node.operationTypes || [];
+
+      for (const operationType of operationTypesNodes) {
+        opTypes[operationType.operation] = getNamedType(operationType.type);
       }
     }
     return opTypes;
@@ -487,19 +488,20 @@ export function extendSchemaImpl(
   ): GraphQLFieldConfigMap<mixed, mixed> {
     const fieldConfigMap = Object.create(null);
     for (const node of nodes) {
-      if (node.fields != null) {
-        for (const field of node.fields) {
-          fieldConfigMap[field.name.value] = {
-            // Note: While this could make assertions to get the correctly typed
-            // value, that would throw immediately while type system validation
-            // with validateSchema() will produce more actionable results.
-            type: (getWrappedType(field.type): any),
-            description: getDescription(field, options),
-            args: buildArgumentMap(field.arguments),
-            deprecationReason: getDeprecationReason(field),
-            astNode: field,
-          };
-        }
+      /* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
+      const nodeFields = node.fields || [];
+
+      for (const field of nodeFields) {
+        fieldConfigMap[field.name.value] = {
+          // Note: While this could make assertions to get the correctly typed
+          // value, that would throw immediately while type system validation
+          // with validateSchema() will produce more actionable results.
+          type: (getWrappedType(field.type): any),
+          description: getDescription(field, options),
+          args: buildArgumentMap(field.arguments),
+          deprecationReason: getDeprecationReason(field),
+          astNode: field,
+        };
       }
     }
     return fieldConfigMap;
@@ -508,21 +510,22 @@ export function extendSchemaImpl(
   function buildArgumentMap(
     args: ?$ReadOnlyArray<InputValueDefinitionNode>,
   ): GraphQLFieldConfigArgumentMap {
-    const argConfigMap = Object.create(null);
-    if (args != null) {
-      for (const arg of args) {
-        // Note: While this could make assertions to get the correctly typed
-        // value, that would throw immediately while type system validation
-        // with validateSchema() will produce more actionable results.
-        const type: any = getWrappedType(arg.type);
+    /* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
+    const argsNodes = args || [];
 
-        argConfigMap[arg.name.value] = {
-          type,
-          description: getDescription(arg, options),
-          defaultValue: valueFromAST(arg.defaultValue, type),
-          astNode: arg,
-        };
-      }
+    const argConfigMap = Object.create(null);
+    for (const arg of argsNodes) {
+      // Note: While this could make assertions to get the correctly typed
+      // value, that would throw immediately while type system validation
+      // with validateSchema() will produce more actionable results.
+      const type: any = getWrappedType(arg.type);
+
+      argConfigMap[arg.name.value] = {
+        type,
+        description: getDescription(arg, options),
+        defaultValue: valueFromAST(arg.defaultValue, type),
+        astNode: arg,
+      };
     }
     return argConfigMap;
   }
@@ -534,20 +537,21 @@ export function extendSchemaImpl(
   ): GraphQLInputFieldConfigMap {
     const inputFieldMap = Object.create(null);
     for (const node of nodes) {
-      if (node.fields != null) {
-        for (const field of node.fields) {
-          // Note: While this could make assertions to get the correctly typed
-          // value, that would throw immediately while type system validation
-          // with validateSchema() will produce more actionable results.
-          const type: any = getWrappedType(field.type);
-
-          inputFieldMap[field.name.value] = {
-            type,
-            description: getDescription(field, options),
-            defaultValue: valueFromAST(field.defaultValue, type),
-            astNode: field,
-          };
-        }
+      /* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
+      const fieldsNodes = node.fields || [];
+
+      for (const field of fieldsNodes) {
+        // Note: While this could make assertions to get the correctly typed
+        // value, that would throw immediately while type system validation
+        // with validateSchema() will produce more actionable results.
+        const type: any = getWrappedType(field.type);
+
+        inputFieldMap[field.name.value] = {
+          type,
+          description: getDescription(field, options),
+          defaultValue: valueFromAST(field.defaultValue, type),
+          astNode: field,
+        };
       }
     }
     return inputFieldMap;
@@ -558,14 +562,15 @@ export function extendSchemaImpl(
   ): GraphQLEnumValueConfigMap {
     const enumValueMap = Object.create(null);
     for (const node of nodes) {
-      if (node.values != null) {
-        for (const value of node.values) {
-          enumValueMap[value.name.value] = {
-            description: getDescription(value, options),
-            deprecationReason: getDeprecationReason(value),
-            astNode: value,
-          };
-        }
+      /* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
+      const valuesNodes = node.values || [];
+
+      for (const value of valuesNodes) {
+        enumValueMap[value.name.value] = {
+          description: getDescription(value, options),
+          deprecationReason: getDeprecationReason(value),
+          astNode: value,
+        };
       }
     }
     return enumValueMap;
@@ -581,14 +586,15 @@ export function extendSchemaImpl(
   ): Array<GraphQLInterfaceType> {
     const interfaces = [];
     for (const node of nodes) {
-      if (node.interfaces != null) {
-        for (const type of node.interfaces) {
-          // Note: While this could make assertions to get the correctly typed
-          // values below, that would throw immediately while type system
-          // validation with validateSchema() will produce more actionable
-          // results.
-          interfaces.push((getNamedType(type): any));
-        }
+      /* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
+      const interfacesNodes = node.interfaces || [];
+
+      for (const type of interfacesNodes) {
+        // Note: While this could make assertions to get the correctly typed
+        // values below, that would throw immediately while type system
+        // validation with validateSchema() will produce more actionable
+        // results.
+        interfaces.push((getNamedType(type): any));
       }
     }
     return interfaces;
@@ -599,14 +605,15 @@ export function extendSchemaImpl(
   ): Array<GraphQLObjectType> {
     const types = [];
     for (const node of nodes) {
-      if (node.types != null) {
-        for (const type of node.types) {
-          // Note: While this could make assertions to get the correctly typed
-          // values below, that would throw immediately while type system
-          // validation with validateSchema() will produce more actionable
-          // results.
-          types.push((getNamedType(type): any));
-        }
+      /* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
+      const typeNodes = node.types || [];
+
+      for (const type of typeNodes) {
+        // Note: While this could make assertions to get the correctly typed
+        // values below, that would throw immediately while type system
+        // validation with validateSchema() will produce more actionable
+        // results.
+        types.push((getNamedType(type): any));
       }
     }
     return types;

diff --git a/src/validation/rules/KnownArgumentNames.js b/src/validation/rules/KnownArgumentNames.js
@@ -64,9 +64,10 @@ export function KnownArgumentNamesOnDirectives(
   const astDefinitions = context.getDocument().definitions;
   for (const def of astDefinitions) {
     if (def.kind === Kind.DIRECTIVE_DEFINITION) {
-      directiveArgs[def.name.value] = def.arguments
-        ? def.arguments.map(arg => arg.name.value)
-        : [];
+      /* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
+      const argsNodes = def.arguments || [];
+
+      directiveArgs[def.name.value] = argsNodes.map(arg => arg.name.value);
     }
   }
 

diff --git a/src/validation/rules/OverlappingFieldsCanBeMerged.js b/src/validation/rules/OverlappingFieldsCanBeMerged.js
@@ -589,8 +589,12 @@ function findConflict(
       ];
     }
 
+    /* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
+    const args1 = node1.arguments || [];
+    /* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
+    const args2 = node2.arguments || [];
     // Two field calls must have the same arguments.
-    if (!sameArguments(node1.arguments || [], node2.arguments || [])) {
+    if (!sameArguments(args1, args2)) {
       return [
         [responseName, 'they have differing arguments'],
         [node1],

diff --git a/src/validation/rules/ProvidedRequiredArguments.js b/src/validation/rules/ProvidedRequiredArguments.js
@@ -35,8 +35,9 @@ export function ProvidedRequiredArguments(
         if (!fieldDef) {
           return false;
         }
-        const argNodes = fieldNode.arguments || [];
 
+        /* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
+        const argNodes = fieldNode.arguments || [];
         const argNodeMap = keyMap(argNodes, arg => arg.name.value);
         for (const argDef of fieldDef.args) {
           const argNode = argNodeMap[argDef.name];
@@ -77,8 +78,11 @@ export function ProvidedRequiredArgumentsOnDirectives(
   const astDefinitions = context.getDocument().definitions;
   for (const def of astDefinitions) {
     if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+      /* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
+      const argNodes = def.arguments || [];
+
       requiredArgsMap[def.name.value] = keyMap(
-        def.arguments ? def.arguments.filter(isRequiredArgumentNode) : [],
+        argNodes.filter(isRequiredArgumentNode),
         arg => arg.name.value,
       );
     }
@@ -91,6 +95,7 @@ export function ProvidedRequiredArgumentsOnDirectives(
         const directiveName = directiveNode.name.value;
         const requiredArgs = requiredArgsMap[directiveName];
         if (requiredArgs) {
+          /* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
           const argNodes = directiveNode.arguments || [];
           const argNodeMap = keyMap(argNodes, arg => arg.name.value);
           for (const argName of Object.keys(requiredArgs)) {

diff --git a/src/validation/rules/UniqueEnumValueNames.js b/src/validation/rules/UniqueEnumValueNames.js
@@ -30,30 +30,30 @@ export function UniqueEnumValueNames(
       knownValueNames[typeName] = Object.create(null);
     }
 
-    if (node.values) {
-      const valueNames = knownValueNames[typeName];
-
-      for (const valueDef of node.values) {
-        const valueName = valueDef.name.value;
-
-        const existingType = existingTypeMap[typeName];
-        if (isEnumType(existingType) && existingType.getValue(valueName)) {
-          context.reportError(
-            new GraphQLError(
-              `Enum value "${typeName}.${valueName}" already exists in the schema. It cannot also be defined in this type extension.`,
-              valueDef.name,
-            ),
-          );
-        } else if (valueNames[valueName]) {
-          context.reportError(
-            new GraphQLError(
-              `Enum value "${typeName}.${valueName}" can only be defined once.`,
-              [valueNames[valueName], valueDef.name],
-            ),
-          );
-        } else {
-          valueNames[valueName] = valueDef.name;
-        }
+    /* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
+    const valueNodes = node.values || [];
+    const valueNames = knownValueNames[typeName];
+
+    for (const valueDef of valueNodes) {
+      const valueName = valueDef.name.value;
+
+      const existingType = existingTypeMap[typeName];
+      if (isEnumType(existingType) && existingType.getValue(valueName)) {
+        context.reportError(
+          new GraphQLError(
+            `Enum value "${typeName}.${valueName}" already exists in the schema. It cannot also be defined in this type extension.`,
+            valueDef.name,
+          ),
+        );
+      } else if (valueNames[valueName]) {
+        context.reportError(
+          new GraphQLError(
+            `Enum value "${typeName}.${valueName}" can only be defined once.`,
+            [valueNames[valueName], valueDef.name],
+          ),
+        );
+      } else {
+        valueNames[valueName] = valueDef.name;
       }
     }
 

diff --git a/src/validation/rules/UniqueFieldDefinitionNames.js b/src/validation/rules/UniqueFieldDefinitionNames.js
@@ -38,29 +38,29 @@ export function UniqueFieldDefinitionNames(
       knownFieldNames[typeName] = Object.create(null);
     }
 
-    if (node.fields) {
-      const fieldNames = knownFieldNames[typeName];
+    /* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
+    const fieldNodes = node.fields || [];
+    const fieldNames = knownFieldNames[typeName];
 
-      for (const fieldDef of node.fields) {
-        const fieldName = fieldDef.name.value;
+    for (const fieldDef of fieldNodes) {
+      const fieldName = fieldDef.name.value;
 
-        if (hasField(existingTypeMap[typeName], fieldName)) {
-          context.reportError(
-            new GraphQLError(
-              `Field "${typeName}.${fieldName}" already exists in the schema. It cannot also be defined in this type extension.`,
-              fieldDef.name,
-            ),
-          );
-        } else if (fieldNames[fieldName]) {
-          context.reportError(
-            new GraphQLError(
-              `Field "${typeName}.${fieldName}" can only be defined once.`,
-              [fieldNames[fieldName], fieldDef.name],
-            ),
-          );
-        } else {
-          fieldNames[fieldName] = fieldDef.name;
-        }
+      if (hasField(existingTypeMap[typeName], fieldName)) {
+        context.reportError(
+          new GraphQLError(
+            `Field "${typeName}.${fieldName}" already exists in the schema. It cannot also be defined in this type extension.`,
+            fieldDef.name,
+          ),
+        );
+      } else if (fieldNames[fieldName]) {
+        context.reportError(
+          new GraphQLError(
+            `Field "${typeName}.${fieldName}" can only be defined once.`,
+            [fieldNames[fieldName], fieldDef.name],
+          ),
+        );
+      } else {
+        fieldNames[fieldName] = fieldDef.name;
       }
     }