validation.js

/**
 *  Copyright (c) 2015, Facebook, Inc.
 *  All rights reserved.
 *
 *  This source code is licensed under the BSD-style license found in the
 *  LICENSE file in the root directory of this source tree. An additional grant
 *  of patent rights can be found in the PATENTS file in the same directory.
 */

// 80+ char lines are useful in describe/it, so ignore in this file.
/* eslint-disable max-len */

import { describe, it } from 'mocha';
import { expect } from 'chai';
import {
  GraphQLSchema,
  GraphQLScalarType,
  GraphQLObjectType,
  GraphQLInterfaceType,
  GraphQLUnionType,
  GraphQLEnumType,
  GraphQLInputObjectType,
  GraphQLList,
  GraphQLNonNull,
  GraphQLString,
} from '../../';


var SomeScalarType = new GraphQLScalarType({
  name: 'SomeScalar',
  serialize() {},
  parseValue() {},
  parseLiteral() {}
});

var SomeObjectType = new GraphQLObjectType({
  name: 'SomeObject',
  fields: { f: { type: GraphQLString } }
});

var ObjectWithIsTypeOf = new GraphQLObjectType({
  name: 'ObjectWithIsTypeOf',
  isTypeOf: () => true,
  fields: { f: { type: GraphQLString} }
});

var SomeUnionType = new GraphQLUnionType({
  name: 'SomeUnion',
  resolveType: () => null,
  types: [ SomeObjectType ]
});

var SomeInterfaceType = new GraphQLInterfaceType({
  name: 'SomeInterface',
  resolveType: () => null,
  fields: { f: { type: GraphQLString } }
});

var SomeEnumType = new GraphQLEnumType({
  name: 'SomeEnum',
  values: {
    ONLY: {}
  }
});

var SomeInputObjectType = new GraphQLInputObjectType({
  name: 'SomeInputObject',
  fields: {
    val: { type: GraphQLString, defaultValue: 'hello' }
  }
});

function withModifiers(types) {
  return types
    .concat(types.map(type => new GraphQLList(type)))
    .concat(types.map(type => new GraphQLNonNull(type)))
    .concat(types.map(type => new GraphQLNonNull(new GraphQLList(type))));
}

var outputTypes = withModifiers([
  GraphQLString,
  SomeScalarType,
  SomeEnumType,
  SomeObjectType,
  SomeUnionType,
  SomeInterfaceType,
]);

var notOutputTypes = withModifiers([
  SomeInputObjectType,
]).concat(String);

var inputTypes = withModifiers([
  GraphQLString,
  SomeScalarType,
  SomeEnumType,
  SomeInputObjectType,
]);

var notInputTypes = withModifiers([
  SomeObjectType,
  SomeUnionType,
  SomeInterfaceType,
]).concat(String);

function schemaWithFieldType(type) {
  return new GraphQLSchema({
    query: new GraphQLObjectType({
      name: 'Query',
      fields: { f: { type } }
    })
  });
}


describe('Type System: A Schema must have Object root types', () => {

  it('accepts a Schema whose query type is an object type', () => {
    expect(
      () => new GraphQLSchema({
        query: SomeObjectType
      })
    ).not.to.throw();
  });

  it('accepts a Schema whose query and mutation types are object types', () => {
    expect(() => {
      var MutationType = new GraphQLObjectType({
        name: 'Mutation',
        fields: { edit: { type: GraphQLString } }
      });

      return new GraphQLSchema({
        query: SomeObjectType,
        mutation: MutationType
      });
    }).not.to.throw();
  });

  it('rejects a Schema without a query type', () => {
    expect(
      () => new GraphQLSchema({ })
    ).to.throw(
      'Schema query must be Object Type but got: undefined.'
    );
  });

  it('rejects a Schema whose query type is an input type', () => {
    expect(
      () => new GraphQLSchema({ query: SomeInputObjectType })
    ).to.throw(
      'Schema query must be Object Type but got: SomeInputObject.'
    );
  });

  it('rejects a Schema whose mutation type is an input type', () => {
    expect(
      () => new GraphQLSchema({
        query: SomeObjectType,
        mutation: SomeInputObjectType
      })
    ).to.throw(
      'Schema mutation must be Object Type if provided but got: SomeInputObject.'
    );
  });

});

describe('Type System: A Schema must contain uniquely named types', () => {

  it('rejects a Schema which redefines a built-in type', () => {
    expect(() => {
      var FakeString = new GraphQLScalarType({
        name: 'String',
        serialize: () => null,
      });

      var QueryType = new GraphQLObjectType({
        name: 'Query',
        fields: {
          normal: { type: GraphQLString },
          fake: { type: FakeString },
        }
      });

      return new GraphQLSchema({ query: QueryType });
    }).to.throw(
      'Schema must contain unique named types but contains multiple types ' +
      'named "String".'
    );
  });

  it('rejects a Schema which defines an object type twice', () => {
    expect(() => {
      var A = new GraphQLObjectType({
        name: 'SameName',
        fields: { f: { type: GraphQLString } },
      });

      var B = new GraphQLObjectType({
        name: 'SameName',
        fields: { f: { type: GraphQLString } },
      });

      var QueryType = new GraphQLObjectType({
        name: 'Query',
        fields: {
          a: { type: A },
          b: { type: B }
        }
      });

      return new GraphQLSchema({ query: QueryType });
    }).to.throw(
      'Schema must contain unique named types but contains multiple types ' +
      'named "SameName".'
    );
  });

  it('rejects a Schema which have same named objects implementing an interface', () => {
    expect(() => {
      var AnotherInterface = new GraphQLInterfaceType({
        name: 'AnotherInterface',
        resolveType: () => null,
        fields: { f: { type: GraphQLString } },
      });

      /* eslint-disable no-unused-vars */

      // Automatically included in Interface
      var FirstBadObject = new GraphQLObjectType({
        name: 'BadObject',
        interfaces: [ AnotherInterface ],
        fields: { f: { type: GraphQLString } },
      });

      // Automatically included in Interface
      var SecondBadObject = new GraphQLObjectType({
        name: 'BadObject',
        interfaces: [ AnotherInterface ],
        fields: { f: { type: GraphQLString } },
      });

      /* eslint-enable no-unused-vars */

      var QueryType = new GraphQLObjectType({
        name: 'Query',
        fields: {
          iface: { type: AnotherInterface },
        }
      });

      return new GraphQLSchema({ query: QueryType });
    }).to.throw(
      'Schema must contain unique named types but contains multiple types ' +
      'named "BadObject".'
    );
  });

});

describe('Type System: Objects must have fields', () => {

  it('accepts an Object type with fields object', () => {
    expect(
      () => schemaWithFieldType(new GraphQLObjectType({
        name: 'SomeObject',
        fields: {
          f: { type: GraphQLString }
        }
      }))
    ).not.to.throw();
  });

  it('accepts an Object type with a field function', () => {
    expect(
      () => schemaWithFieldType(new GraphQLObjectType({
        name: 'SomeObject',
        fields() {
          return {
            f: { type: GraphQLString }
          };
        }
      }))
    ).not.to.throw();
  });

  it('rejects an Object type with missing fields', () => {
    expect(
      () => schemaWithFieldType(new GraphQLObjectType({
        name: 'SomeObject',
      }))
    ).to.throw(
      'SomeObject fields must be an object with field names as keys or a ' +
      'function which returns such an object.'
    );
  });

  it('rejects an Object type with incorrectly typed fields', () => {
    expect(
      () => schemaWithFieldType(new GraphQLObjectType({
        name: 'SomeObject',
        fields: [
          { field: GraphQLString }
        ]
      }))
    ).to.throw(
      'SomeObject fields must be an object with field names as keys or a ' +
      'function which returns such an object.'
    );
  });

  it('rejects an Object type with empty fields', () => {
    expect(
      () => schemaWithFieldType(new GraphQLObjectType({
        name: 'SomeObject',
        fields: {}
      }))
    ).to.throw(
      'SomeObject fields must be an object with field names as keys or a ' +
      'function which returns such an object.'
    );
  });

  it('rejects an Object type with a field function that returns nothing', () => {
    expect(
      () => schemaWithFieldType(new GraphQLObjectType({
        name: 'SomeObject',
        fields() {
          return;
        }
      }))
    ).to.throw(
      'SomeObject fields must be an object with field names as keys or a ' +
      'function which returns such an object.'
    );
  });

  it('rejects an Object type with a field function that returns empty', () => {
    expect(
      () => schemaWithFieldType(new GraphQLObjectType({
        name: 'SomeObject',
        fields() {
          return {};
        }
      }))
    ).to.throw(
      'SomeObject fields must be an object with field names as keys or a ' +
      'function which returns such an object.'
    );
  });

});


describe('Type System: Fields args must be objects', () => {

  it('accepts an Object type with field args', () => {
    expect(
      () => schemaWithFieldType(new GraphQLObjectType({
        name: 'SomeObject',
        fields: {
          goodField: {
            type: GraphQLString,
            args: {
              goodArg: { type: GraphQLString }
            }
          }
        }
      }))
    ).not.to.throw();
  });

  it('rejects an Object type with incorrectly typed field args', () => {
    expect(
      () => schemaWithFieldType(new GraphQLObjectType({
        name: 'SomeObject',
        fields: {
          badField: {
            type: GraphQLString,
            args: [
              { badArg: GraphQLString }
            ]
          }
        }
      }))
    ).to.throw(
      'SomeObject.badField args must be an object with argument names as keys.'
    );
  });

});


describe('Type System: Object interfaces must be array', () => {

  it('accepts an Object type with array interfaces', () => {
    expect(() => {
      var AnotherInterfaceType = new GraphQLInterfaceType({
        name: 'AnotherInterface',
        resolveType: () => null,
        fields: { f: { type: GraphQLString } }
      });

      schemaWithFieldType(new GraphQLObjectType({
        name: 'SomeObject',
        interfaces: [ AnotherInterfaceType ],
        fields: { f: { type: GraphQLString } }
      }));
    }).not.to.throw();
  });

  it('accepts an Object type with interfaces as a function returning an array', () => {
    expect(() => {
      var AnotherInterfaceType = new GraphQLInterfaceType({
        name: 'AnotherInterface',
        resolveType: () => null,
        fields: { f: { type: GraphQLString } }
      });

      schemaWithFieldType(new GraphQLObjectType({
        name: 'SomeObject',
        interfaces() {
          return [ AnotherInterfaceType ];
        },
        fields: { f: { type: GraphQLString } }
      }));
    }).not.to.throw();
  });

  it('rejects an Object type with incorrectly typed interfaces', () => {
    expect(
      () => schemaWithFieldType(new GraphQLObjectType({
        name: 'SomeObject',
        interfaces: {},
        fields: { f: { type: GraphQLString } }
      }))
    ).to.throw(
      'SomeObject interfaces must be an Array or a function which returns an Array.'
    );
  });

  it('rejects an Object type with interfaces as a function returning an incorrect type', () => {
    expect(
      () => schemaWithFieldType(new GraphQLObjectType({
        name: 'SomeObject',
        interfaces() {
          return {};
        },
        fields: { f: { type: GraphQLString } }
      }))
    ).to.throw(
      'SomeObject interfaces must be an Array or a function which returns an Array.'
    );
  });
});


describe('Type System: Union types must be array', () => {

  it('accepts a Union type with array types', () => {
    expect(
      () => schemaWithFieldType(new GraphQLUnionType({
        name: 'SomeUnion',
        resolveType: () => null,
        types: [ SomeObjectType ],
      }))
    ).not.to.throw();
  });

  it('rejects a Union type without types', () => {
    expect(
      () => schemaWithFieldType(new GraphQLUnionType({
        name: 'SomeUnion',
        resolveType: () => null,
      }))
    ).to.throw(
      'Must provide Array of types for Union SomeUnion.'
    );
  });

  it('rejects a Union type with empty types', () => {
    expect(
      () => schemaWithFieldType(new GraphQLUnionType({
        name: 'SomeUnion',
        resolveType: () => null,
        types: []
      }))
    ).to.throw(
      'Must provide Array of types for Union SomeUnion.'
    );
  });

  it('rejects a Union type with incorrectly typed types', () => {
    expect(
      () => schemaWithFieldType(new GraphQLUnionType({
        name: 'SomeUnion',
        resolveType: () => null,
        types: {
          SomeObjectType
        },
      }))
    ).to.throw(
      'Must provide Array of types for Union SomeUnion.'
    );
  });

});


describe('Type System: Input Objects must have fields', () => {

  function schemaWithInputObject(inputObjectType) {
    return new GraphQLSchema({
      query: new GraphQLObjectType({
        name: 'Query',
        fields: {
          f: {
            type: GraphQLString,
            args: {
              badArg: { type: inputObjectType }
            }
          }
        }
      })
    });
  }

  it('accepts an Input Object type with fields', () => {
    expect(
      () => schemaWithInputObject(new GraphQLInputObjectType({
        name: 'SomeInputObject',
        fields: {
          f: { type: GraphQLString }
        }
      }))
    ).not.to.throw();
  });

  it('accepts an Input Object type with a field function', () => {
    expect(
      () => schemaWithInputObject(new GraphQLInputObjectType({
        name: 'SomeInputObject',
        fields() {
          return {
            f: { type: GraphQLString }
          };
        }
      }))
    ).not.to.throw();
  });

  it('rejects an Input Object type with missing fields', () => {
    expect(
      () => schemaWithInputObject(new GraphQLInputObjectType({
        name: 'SomeInputObject',
      }))
    ).to.throw(
      'SomeInputObject fields must be an object with field names as keys or a ' +
      'function which returns such an object.'
    );
  });

  it('rejects an Input Object type with incorrectly typed fields', () => {
    expect(
      () => schemaWithInputObject(new GraphQLInputObjectType({
        name: 'SomeInputObject',
        fields: [
          { field: GraphQLString }
        ]
      }))
    ).to.throw(
      'SomeInputObject fields must be an object with field names as keys or a ' +
      'function which returns such an object.'
    );
  });

  it('rejects an Input Object type with empty fields', () => {
    expect(
      () => schemaWithInputObject(new GraphQLInputObjectType({
        name: 'SomeInputObject',
        fields: {}
      }))
    ).to.throw(
      'SomeInputObject fields must be an object with field names as keys or a ' +
      'function which returns such an object.'
    );
  });

  it('rejects an Input Object type with a field function that returns nothing', () => {
    expect(
      () => schemaWithInputObject(new GraphQLInputObjectType({
        name: 'SomeInputObject',
        fields() {
          return;
        }
      }))
    ).to.throw(
      'SomeInputObject fields must be an object with field names as keys or a ' +
      'function which returns such an object.'
    );
  });

  it('rejects an Input Object type with a field function that returns empty', () => {
    expect(
      () => schemaWithInputObject(new GraphQLInputObjectType({
        name: 'SomeInputObject',
        fields() {
          return {};
        }
      }))
    ).to.throw(
      'SomeInputObject fields must be an object with field names as keys or a ' +
      'function which returns such an object.'
    );
  });

});


describe('Type System: Interface types must be resolvable', () => {

  it('accepts an Interface type defining resolveType', () => {
    expect(() => {
      var AnotherInterfaceType = new GraphQLInterfaceType({
        name: 'AnotherInterface',
        resolveType: () => null,
        fields: { f: { type: GraphQLString } }
      });

      schemaWithFieldType(new GraphQLObjectType({
        name: 'SomeObject',
        interfaces: [ AnotherInterfaceType ],
        fields: { f: { type: GraphQLString } }
      }));
    }).not.to.throw();
  });

  it('accepts an Interface with implementing type defining isTypeOf', () => {
    expect(() => {
      var InterfaceTypeWithoutResolveType = new GraphQLInterfaceType({
        name: 'InterfaceTypeWithoutResolveType',
        fields: { f: { type: GraphQLString } }
      });

      schemaWithFieldType(new GraphQLObjectType({
        name: 'SomeObject',
        isTypeOf: () => true,
        interfaces: [ InterfaceTypeWithoutResolveType ],
        fields: { f: { type: GraphQLString } }
      }));
    }).not.to.throw();
  });

  it('accepts an Interface type defining resolveType with implementing type defining isTypeOf', () => {
    expect(() => {
      var AnotherInterfaceType = new GraphQLInterfaceType({
        name: 'AnotherInterface',
        resolveType: () => null,
        fields: { f: { type: GraphQLString } }
      });

      schemaWithFieldType(new GraphQLObjectType({
        name: 'SomeObject',
        isTypeOf: () => true,
        interfaces: [ AnotherInterfaceType ],
        fields: { f: { type: GraphQLString } }
      }));
    }).not.to.throw();
  });

  it('rejects an Interface type not defining resolveType with implementing type not defining isTypeOf', () => {
    expect(() => {
      var InterfaceTypeWithoutResolveType = new GraphQLInterfaceType({
        name: 'InterfaceTypeWithoutResolveType',
        fields: { f: { type: GraphQLString } }
      });

      schemaWithFieldType(new GraphQLObjectType({
        name: 'SomeObject',
        interfaces: [ InterfaceTypeWithoutResolveType ],
        fields: { f: { type: GraphQLString } }
      }));
    }).to.throw(
      'Interface Type InterfaceTypeWithoutResolveType does not provide a ' +
      '"resolveType" function and implementing Type SomeObject does not ' +
      'provide a "isTypeOf" function. ' +
      'There is no way to resolve this implementing type during execution.'
    );
  });

});


describe('Type System: Union types must be resolvable', () => {

  it('accepts a Union type defining resolveType', () => {
    expect(() =>
      schemaWithFieldType(new GraphQLUnionType({
        name: 'SomeUnion',
        resolveType: () => null,
        types: [ SomeObjectType ],
      }))
    ).not.to.throw();
  });

  it('accepts a Union of Object types defining isTypeOf', () => {
    expect(() =>
      schemaWithFieldType(new GraphQLUnionType({
        name: 'SomeUnion',
        types: [ ObjectWithIsTypeOf ],
      }))
    ).not.to.throw();
  });

  it('accepts a Union type defining resolveType of Object types defining isTypeOf', () => {
    expect(() =>
      schemaWithFieldType(new GraphQLUnionType({
        name: 'SomeUnion',
        resolveType: () => null,
        types: [ ObjectWithIsTypeOf ],
      }))
    ).not.to.throw();
  });

  it('rejects a Union type not defining resolveType of Object types not defining isTypeOf', () => {
    expect(() =>
      schemaWithFieldType(new GraphQLUnionType({
        name: 'SomeUnion',
        types: [ SomeObjectType ],
      }))
    ).to.throw(
      'Union Type SomeUnion does not provide a "resolveType" function and ' +
      'possible Type SomeObject does not provide a "isTypeOf" function. ' +
      'There is no way to resolve this possible type during execution.'
    );
  });

});


describe('Type System: Scalar types must be serializable', () => {

  it('accepts a Scalar type defining serialize', () => {
    expect(() =>
      schemaWithFieldType(new GraphQLScalarType({
        name: 'SomeScalar',
        serialize: () => null,
      }))
    ).not.to.throw();
  });

  it('rejects a Scalar type not defining serialize', () => {
    expect(() =>
      schemaWithFieldType(new GraphQLScalarType({
        name: 'SomeScalar',
      }))
    ).to.throw(
      'SomeScalar must provide "serialize" function. If this custom Scalar ' +
      'is also used as an input type, ensure "parseValue" and "parseLiteral" ' +
      'functions are also provided.'
    );
  });

  it('rejects a Scalar type defining serialize with an incorrect type', () => {
    expect(() =>
      schemaWithFieldType(new GraphQLScalarType({
        name: 'SomeScalar',
        serialize: {}
      }))
    ).to.throw(
      'SomeScalar must provide "serialize" function. If this custom Scalar ' +
      'is also used as an input type, ensure "parseValue" and "parseLiteral" ' +
      'functions are also provided.'
    );
  });

  it('accepts a Scalar type defining parseValue and parseLiteral', () => {
    expect(() =>
      schemaWithFieldType(new GraphQLScalarType({
        name: 'SomeScalar',
        serialize: () => null,
        parseValue: () => null,
        parseLiteral: () => null,
      }))
    ).not.to.throw();
  });

  it('rejects a Scalar type defining parseValue but not parseLiteral', () => {
    expect(() =>
      schemaWithFieldType(new GraphQLScalarType({
        name: 'SomeScalar',
        serialize: () => null,
        parseValue: () => null,
      }))
    ).to.throw(
      'SomeScalar must provide both "parseValue" and "parseLiteral" functions.'
    );
  });

  it('rejects a Scalar type defining parseLiteral but not parseValue', () => {
    expect(() =>
      schemaWithFieldType(new GraphQLScalarType({
        name: 'SomeScalar',
        serialize: () => null,
        parseLiteral: () => null,
      }))
    ).to.throw(
      'SomeScalar must provide both "parseValue" and "parseLiteral" functions.'
    );
  });

  it('rejects a Scalar type defining parseValue and parseLiteral with an incorrect type', () => {
    expect(() =>
      schemaWithFieldType(new GraphQLScalarType({
        name: 'SomeScalar',
        serialize: () => null,
        parseValue: {},
        parseLiteral: {},
      }))
    ).to.throw(
      'SomeScalar must provide both "parseValue" and "parseLiteral" functions.'
    );
  });

});


describe('Type System: Object fields must have output types', () => {

  function schemaWithObjectFieldOfType(fieldType) {
    var BadObjectType = new GraphQLObjectType({
      name: 'BadObject',
      fields: {
        badField: { type: fieldType }
      }
    });

    return new GraphQLSchema({
      query: new GraphQLObjectType({
        name: 'Query',
        fields: {
          f: { type: BadObjectType }
        }
      })
    });
  }

  outputTypes.forEach(type => {
    it(`accepts an output type as an Object field type: ${type}`, () => {
      expect(() => schemaWithObjectFieldOfType(type)).not.to.throw();
    });
  });

  it('rejects an empty Object field type', () => {
    expect(() => schemaWithObjectFieldOfType(undefined)).to.throw(
      'BadObject.badField field type must be Output Type but got: undefined.'
    );
  });

  notOutputTypes.forEach(type => {
    it(`rejects a non-output type as an Object field type: ${type}`, () => {
      expect(() => schemaWithObjectFieldOfType(type)).to.throw(
        `BadObject.badField field type must be Output Type but got: ${type}.`
      );
    });
  });

});


describe('Type System: Objects can only implement interfaces', () => {

  function schemaWithObjectImplementingType(implementedType) {
    var BadObjectType = new GraphQLObjectType({
      name: 'BadObject',
      interfaces: [ implementedType ],
      fields: { f: { type: GraphQLString } }
    });

    return new GraphQLSchema({
      query: new GraphQLObjectType({
        name: 'Query',
        fields: {
          f: { type: BadObjectType }
        }
      })
    });
  }

  it('accepts an Object implementing an Interface', () => {
    expect(() => {
      var AnotherInterfaceType = new GraphQLInterfaceType({
        name: 'AnotherInterface',
        resolveType: () => null,
        fields: { f: { type: GraphQLString } }
      });

      schemaWithObjectImplementingType(AnotherInterfaceType);
    }).not.to.throw();
  });

  var notInterfaceTypes = withModifiers([
    SomeScalarType,
    SomeEnumType,
    SomeObjectType,
    SomeUnionType,
    SomeInputObjectType,
  ]);

  notInterfaceTypes.forEach(type => {
    it(`rejects an Object implementing a non-Interface type: ${type}`, () => {
      expect(() => schemaWithObjectImplementingType(type)).to.throw(
        `BadObject may only implement Interface types, it cannot implement: ${type}.`
      );
    });
  });

});


describe('Type System: Unions must represent Object types', () => {

  function schemaWithUnionOfType(type) {
    var BadUnionType = new GraphQLUnionType({
      name: 'BadUnion',
      resolveType: () => null,
      types: [ type ],
    });

    return new GraphQLSchema({
      query: new GraphQLObjectType({
        name: 'Query',
        fields: {
          f: { type: BadUnionType }
        }
      })
    });
  }

  it('accepts a Union of an Object Type', () => {
    expect(() =>
      schemaWithUnionOfType(SomeObjectType)
    ).not.to.throw();
  });

  var notObjectTypes = withModifiers([
    SomeScalarType,
    SomeEnumType,
    SomeInterfaceType,
    SomeUnionType,
    SomeInputObjectType,
  ]);

  notObjectTypes.forEach(type => {
    it(`rejects a Union of a non-Object type: ${type}`, () => {
      expect(() => schemaWithUnionOfType(type)).to.throw(
        `BadUnion may only contain Object types, it cannot contain: ${type}.`
      );
    });
  });

});


describe('Type System: Interface fields must have output types', () => {

  function schemaWithInterfaceFieldOfType(fieldType) {
    var BadInterfaceType = new GraphQLInterfaceType({
      name: 'BadInterface',
      fields: {
        badField: { type: fieldType }
      }
    });

    return new GraphQLSchema({
      query: new GraphQLObjectType({
        name: 'Query',
        fields: {
          f: { type: BadInterfaceType }
        }
      })
    });
  }

  outputTypes.forEach(type => {
    it(`accepts an output type as an Interface field type: ${type}`, () => {
      expect(() => schemaWithInterfaceFieldOfType(type)).not.to.throw();
    });
  });

  it('rejects an empty Interface field type', () => {
    expect(() => schemaWithInterfaceFieldOfType(undefined)).to.throw(
      'BadInterface.badField field type must be Output Type but got: undefined.'
    );
  });

  notOutputTypes.forEach(type => {
    it(`rejects a non-output type as an Interface field type: ${type}`, () => {
      expect(() => schemaWithInterfaceFieldOfType(type)).to.throw(
        `BadInterface.badField field type must be Output Type but got: ${type}.`
      );
    });
  });

});


describe('Type System: Field arguments must have input types', () => {

  function schemaWithArgOfType(argType) {
    var BadObjectType = new GraphQLObjectType({
      name: 'BadObject',
      fields: {
        badField: {
          type: GraphQLString,
          args: {
            badArg: { type: argType }
          }
        }
      }
    });

    return new GraphQLSchema({
      query: new GraphQLObjectType({
        name: 'Query',
        fields: {
          f: { type: BadObjectType }
        }
      })
    });
  }

  inputTypes.forEach(type => {
    it(`accepts an input type as a field arg type: ${type}`, () => {
      expect(() => schemaWithArgOfType(type)).not.to.throw();
    });
  });

  it('rejects an empty field arg type', () => {
    expect(() => schemaWithArgOfType(undefined)).to.throw(
      'BadObject.badField(badArg:) argument type must be Input Type but got: undefined.'
    );
  });

  notInputTypes.forEach(type => {
    it(`rejects a non-input type as a field arg type: ${type}`, () => {
      expect(() => schemaWithArgOfType(type)).to.throw(
        `BadObject.badField(badArg:) argument type must be Input Type but got: ${type}.`
      );
    });
  });

});


describe('Type System: Input Object fields must have input types', () => {

  function schemaWithInputFieldOfType(inputFieldType) {
    var BadInputObjectType = new GraphQLInputObjectType({
      name: 'BadInputObject',
      fields: {
        badField: { type: inputFieldType }
      }
    });

    return new GraphQLSchema({
      query: new GraphQLObjectType({
        name: 'Query',
        fields: {
          f: {
            type: GraphQLString,
            args: {
              badArg: { type: BadInputObjectType }
            }
          }
        }
      })
    });
  }

  inputTypes.forEach(type => {
    it(`accepts an input type as an input field type: ${type}`, () => {
      expect(() => schemaWithInputFieldOfType(type)).not.to.throw();
    });
  });

  it('rejects an empty input field type', () => {
    expect(() => schemaWithInputFieldOfType(undefined)).to.throw(
      'BadInputObject.badField field type must be Input Type but got: undefined.'
    );
  });

  notInputTypes.forEach(type => {
    it(`rejects a non-input type as an input field type: ${type}`, () => {
      expect(() => schemaWithInputFieldOfType(type)).to.throw(
        `BadInputObject.badField field type must be Input Type but got: ${type}.`
      );
    });
  });

});


describe('Type System: List must accept GraphQL types', () => {

  var types = withModifiers([
    GraphQLString,
    SomeScalarType,
    SomeObjectType,
    SomeUnionType,
    SomeInterfaceType,
    SomeEnumType,
    SomeInputObjectType,
  ]);

  var notTypes = [
    {},
    String,
    undefined,
    null,
  ];

  types.forEach(type => {
    it(`accepts an type as item type of list: ${type}`, () => {
      expect(() => new GraphQLList(type)).not.to.throw();
    });
  });

  notTypes.forEach(type => {
    it(`rejects a non-type as item type of list: ${type}`, () => {
      expect(() => new GraphQLList(type)).to.throw(
        `Can only create List of a GraphQLType but got: ${type}.`
      );
    });
  });

});


describe('Type System: NonNull must accept GraphQL types', () => {

  var nullableTypes = [
    GraphQLString,
    SomeScalarType,
    SomeObjectType,
    SomeUnionType,
    SomeInterfaceType,
    SomeEnumType,
    SomeInputObjectType,
    new GraphQLList(GraphQLString),
    new GraphQLList(new GraphQLNonNull(GraphQLString)),
  ];

  var notNullableTypes = [
    new GraphQLNonNull(GraphQLString),
    {},
    String,
    undefined,
    null,
  ];

  nullableTypes.forEach(type => {
    it(`accepts an type as nullable type of non-null: ${type}`, () => {
      expect(() => new GraphQLNonNull(type)).not.to.throw();
    });
  });

  notNullableTypes.forEach(type => {
    it(`rejects a non-type as nullable type of non-null: ${type}`, () => {
      expect(() => new GraphQLNonNull(type)).to.throw(
        `Can only create NonNull of a Nullable GraphQLType but got: ${type}.`
      );
    });
  });

});


describe('Objects must adhere to Interface they implement', () => {

  it('accepts an Object which implements an Interface', () => {
    expect(() => {
      var AnotherInterface = new GraphQLInterfaceType({
        name: 'AnotherInterface',
        resolveType: () => null,
        fields: {
          field: {
            type: GraphQLString,
            args: {
              input: { type: GraphQLString }
            }
          }
        }
      });

      var AnotherObject = new GraphQLObjectType({
        name: 'AnotherObject',
        interfaces: [ AnotherInterface ],
        fields: {
          field: {
            type: GraphQLString,
            args: {
              input: { type: GraphQLString }
            }
          }
        }
      });

      return schemaWithFieldType(AnotherObject);
    }).not.to.throw();
  });

  it('accepts an Object which implements an Interface along with more fields', () => {
    expect(() => {
      var AnotherInterface = new GraphQLInterfaceType({
        name: 'AnotherInterface',
        resolveType: () => null,
        fields: {
          field: {
            type: GraphQLString,
            args: {
              input: { type: GraphQLString },
            }
          }
        }
      });

      var AnotherObject = new GraphQLObjectType({
        name: 'AnotherObject',
        interfaces: [ AnotherInterface ],
        fields: {
          field: {
            type: GraphQLString,
            args: {
              input: { type: GraphQLString },
            }
          },
          anotherfield: { type: GraphQLString }
        }
      });

      return schemaWithFieldType(AnotherObject);
    }).not.to.throw();
  });

  it('rejects an Object which implements an Interface field along with more arguments', () => {
    expect(() => {
      var AnotherInterface = new GraphQLInterfaceType({
        name: 'AnotherInterface',
        resolveType: () => null,
        fields: {
          field: {
            type: GraphQLString,
            args: {
              input: { type: GraphQLString },
            }
          }
        }
      });

      var AnotherObject = new GraphQLObjectType({
        name: 'AnotherObject',
        interfaces: [ AnotherInterface ],
        fields: {
          field: {
            type: GraphQLString,
            args: {
              input: { type: GraphQLString },
              anotherInput: { type: GraphQLString },
            }
          }
        }
      });

      return schemaWithFieldType(AnotherObject);
    }).to.throw(
      'AnotherInterface.field does not define argument "anotherInput" but ' +
      'AnotherObject.field provides it.'
    );
  });

  it('rejects an Object missing an Interface field', () => {
    expect(() => {
      var AnotherInterface = new GraphQLInterfaceType({
        name: 'AnotherInterface',
        resolveType: () => null,
        fields: {
          field: {
            type: GraphQLString,
            args: {
              input: { type: GraphQLString },
            }
          }
        }
      });

      var AnotherObject = new GraphQLObjectType({
        name: 'AnotherObject',
        interfaces: [ AnotherInterface ],
        fields: {
          anotherfield: { type: GraphQLString }
        }
      });

      return schemaWithFieldType(AnotherObject);
    }).to.throw(
      '"AnotherInterface" expects field "field" but ' +
      '"AnotherObject" does not provide it.'
    );
  });

  it('rejects an Object with an incorrectly typed Interface field', () => {
    expect(() => {
      var AnotherInterface = new GraphQLInterfaceType({
        name: 'AnotherInterface',
        resolveType: () => null,
        fields: {
          field: {
            type: GraphQLString,
            args: {
              input: { type: GraphQLString },
            }
          }
        }
      });

      var AnotherObject = new GraphQLObjectType({
        name: 'AnotherObject',
        interfaces: [ AnotherInterface ],
        fields: {
          field: {
            type: SomeScalarType,
            args: {
              input: { type: GraphQLString },
            }
          }
        }
      });

      return schemaWithFieldType(AnotherObject);
    }).to.throw(
      'AnotherInterface.field expects type "String" but ' +
      'AnotherObject.field provides type "SomeScalar".'
    );
  });

  it('rejects an Object missing an Interface argument', () => {
    expect(() => {
      var AnotherInterface = new GraphQLInterfaceType({
        name: 'AnotherInterface',
        resolveType: () => null,
        fields: {
          field: {
            type: GraphQLString,
            args: {
              input: { type: GraphQLString },
            }
          }
        }
      });

      var AnotherObject = new GraphQLObjectType({
        name: 'AnotherObject',
        interfaces: [ AnotherInterface ],
        fields: {
          field: {
            type: GraphQLString,
          }
        }
      });

      return schemaWithFieldType(AnotherObject);
    }).to.throw(
      'AnotherInterface.field expects argument "input" but ' +
      'AnotherObject.field does not provide it.'
    );
  });

  it('rejects an Object with an incorrectly typed Interface argument', () => {
    expect(() => {
      var AnotherInterface = new GraphQLInterfaceType({
        name: 'AnotherInterface',
        resolveType: () => null,
        fields: {
          field: {
            type: GraphQLString,
            args: {
              input: { type: GraphQLString },
            }
          }
        }
      });

      var AnotherObject = new GraphQLObjectType({
        name: 'AnotherObject',
        interfaces: [ AnotherInterface ],
        fields: {
          field: {
            type: GraphQLString,
            args: {
              input: { type: SomeScalarType },
            }
          }
        }
      });

      return schemaWithFieldType(AnotherObject);
    }).to.throw(
      'AnotherInterface.field(input:) expects type "String" but ' +
      'AnotherObject.field(input:) provides type "SomeScalar".'
    );
  });

  it('accepts an Object with an equivalently modified Interface field type', () => {
    expect(() => {
      var AnotherInterface = new GraphQLInterfaceType({
        name: 'AnotherInterface',
        resolveType: () => null,
        fields: {
          field: { type: new GraphQLNonNull(new GraphQLList(GraphQLString)) }
        }
      });

      var AnotherObject = new GraphQLObjectType({
        name: 'AnotherObject',
        interfaces: [ AnotherInterface ],
        fields: {
          field: { type: new GraphQLNonNull(new GraphQLList(GraphQLString)) }
        }
      });

      return schemaWithFieldType(AnotherObject);
    }).not.to.throw();
  });

  it('rejects an Object with a differently modified Interface field type', () => {
    expect(() => {
      var AnotherInterface = new GraphQLInterfaceType({
        name: 'AnotherInterface',
        resolveType: () => null,
        fields: {
          field: { type: GraphQLString }
        }
      });

      var AnotherObject = new GraphQLObjectType({
        name: 'AnotherObject',
        interfaces: [ AnotherInterface ],
        fields: {
          field: { type: new GraphQLNonNull(GraphQLString) }
        }
      });

      return schemaWithFieldType(AnotherObject);
    }).to.throw(
      'AnotherInterface.field expects type "String" but ' +
      'AnotherObject.field provides type "String!".'
    );
  });

});