"use strict";

var _SchemaComposer = require("../SchemaComposer");

var _ObjectTypeComposer = require("../ObjectTypeComposer");

var _InputTypeComposer = require("../InputTypeComposer");

var _ScalarTypeComposer = require("../ScalarTypeComposer");

var _EnumTypeComposer = require("../EnumTypeComposer");

var _InterfaceTypeComposer = require("../InterfaceTypeComposer");

var _UnionTypeComposer = require("../UnionTypeComposer");

var _graphql = require("../graphql");

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

describe('SchemaComposer', () => {
  it('should implements `add` method', () => {
    const sc = new _SchemaComposer.SchemaComposer();
    const SomeTC = sc.createObjectTC({
      name: 'validType'
    });
    sc.add(SomeTC);
    expect(sc.get('validType')).toBe(SomeTC);
  });
  it('should implements `get` method', () => {
    const sc = new _SchemaComposer.SchemaComposer();
    const SomeTC = sc.createObjectTC({
      name: 'validType'
    });
    sc.add(SomeTC);
    expect(sc.get('validType')).toBe(SomeTC);
  });
  it('should implements `has` method`', () => {
    const sc = new _SchemaComposer.SchemaComposer();
    const SomeTC = sc.createObjectTC({
      name: 'validType'
    });
    sc.add(SomeTC);
    expect(sc.has('validType')).toBe(true);
    expect(sc.has('unexistedType')).toBe(false);
  });
  describe('getOrCreateOTC()', () => {
    it('should create TC if not exists', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const UserTC = sc.getOrCreateOTC('User');
      expect(UserTC).toBeInstanceOf(_ObjectTypeComposer.ObjectTypeComposer);
      expect(sc.has('User')).toBeTruthy();
      expect(sc.hasInstance('User', _ObjectTypeComposer.ObjectTypeComposer)).toBeTruthy();
      expect(sc.getOTC('User')).toBe(UserTC);
    });
    it('should create TC if not exists with onCreate', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const UserTC = sc.getOrCreateOTC('User', tc => {
        tc.setDescription('User model');
      });
      expect(UserTC.getDescription()).toBe('User model');
    });
    it('should return already created TC without onCreate', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const UserTC = sc.getOrCreateOTC('User', tc => {
        tc.setDescription('User model');
      });
      const UserTC2 = sc.getOrCreateOTC('User', tc => {
        tc.setDescription('updated description');
      });
      expect(UserTC).toBe(UserTC2);
      expect(UserTC.getDescription()).toBe('User model');
    });
  });
  describe('getOrCreateITC()', () => {
    it('should create ITC if not exists', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const UserITC = sc.getOrCreateITC('UserInput');
      expect(UserITC).toBeInstanceOf(_InputTypeComposer.InputTypeComposer);
      expect(sc.has('UserInput')).toBeTruthy();
      expect(sc.hasInstance('UserInput', _InputTypeComposer.InputTypeComposer)).toBeTruthy();
      expect(sc.getITC('UserInput')).toBe(UserITC);
    });
    it('should create ITC if not exists with onCreate', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const UserITC = sc.getOrCreateITC('UserInput', tc => {
        tc.setDescription('User input');
      });
      expect(UserITC.getDescription()).toBe('User input');
    });
    it('should return already created ITC without onCreate', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const UserITC = sc.getOrCreateITC('UserInput', tc => {
        tc.setDescription('User input');
      });
      const UserITC2 = sc.getOrCreateITC('UserInput', tc => {
        tc.setDescription('updated description');
      });
      expect(UserITC).toBe(UserITC2);
      expect(UserITC.getDescription()).toBe('User input');
    });
  });
  describe('getOrCreateSTC()', () => {
    it('should create STC if not exists', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const UIntSTC = sc.getOrCreateSTC('UInt');
      expect(UIntSTC).toBeInstanceOf(_ScalarTypeComposer.ScalarTypeComposer);
      expect(sc.has('UInt')).toBeTruthy();
      expect(sc.hasInstance('UInt', _ScalarTypeComposer.ScalarTypeComposer)).toBeTruthy();
      expect(sc.getSTC('UInt')).toBe(UIntSTC);
    });
    it('should create UTC if not exists with onCreate', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const UIntTC = sc.getOrCreateSTC('Uint', tc => {
        tc.setDescription('Unsigned int');
      });
      expect(UIntTC.getDescription()).toBe('Unsigned int');
    });
    it('should return already created STC without onCreate', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const UIntTC = sc.getOrCreateSTC('UInt', tc => {
        tc.setDescription('Positive int');
      });
      const UIntTC2 = sc.getOrCreateSTC('UInt', tc => {
        tc.setDescription('updated description');
      });
      expect(UIntTC).toBe(UIntTC2);
      expect(UIntTC.getDescription()).toBe('Positive int');
    });
  });
  describe('getOrCreateETC()', () => {
    it('should create ETC if not exists', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const UserETC = sc.getOrCreateETC('UserEnum');
      expect(UserETC).toBeInstanceOf(_EnumTypeComposer.EnumTypeComposer);
      expect(sc.has('UserEnum')).toBeTruthy();
      expect(sc.hasInstance('UserEnum', _EnumTypeComposer.EnumTypeComposer)).toBeTruthy();
      expect(sc.getETC('UserEnum')).toBe(UserETC);
    });
    it('should create ETC if not exists with onCreate', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const UserETC = sc.getOrCreateETC('UserEnum', tc => {
        tc.setDescription('User enum');
      });
      expect(UserETC.getDescription()).toBe('User enum');
    });
    it('should return already created ETC without onCreate', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const UserETC = sc.getOrCreateETC('UserEnum', tc => {
        tc.setDescription('User enum');
      });
      const UserETC2 = sc.getOrCreateETC('UserEnum', tc => {
        tc.setDescription('updated description');
      });
      expect(UserETC).toBe(UserETC2);
      expect(UserETC.getDescription()).toBe('User enum');
    });
  });
  describe('getOrCreateIFTC()', () => {
    it('should create IFTC if not exists', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const UserIFTC = sc.getOrCreateIFTC('UserInterface');
      expect(UserIFTC).toBeInstanceOf(_InterfaceTypeComposer.InterfaceTypeComposer);
      expect(sc.has('UserInterface')).toBeTruthy();
      expect(sc.hasInstance('UserInterface', _InterfaceTypeComposer.InterfaceTypeComposer)).toBeTruthy();
      expect(sc.getIFTC('UserInterface')).toBe(UserIFTC);
    });
    it('should create IFTC if not exists with onCreate', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const UserIFTC = sc.getOrCreateIFTC('UserInterface', tc => {
        tc.setDescription('User interface');
      });
      expect(UserIFTC.getDescription()).toBe('User interface');
    });
    it('should return already created IFTC without onCreate', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const UserIFTC = sc.getOrCreateIFTC('UserInterface', tc => {
        tc.setDescription('User interface');
      });
      const UserIFTC2 = sc.getOrCreateIFTC('UserInterface', tc => {
        tc.setDescription('updated description');
      });
      expect(UserIFTC).toBe(UserIFTC2);
      expect(UserIFTC.getDescription()).toBe('User interface');
    });
  });
  describe('buildSchema()', () => {
    it('should throw error, if root fields not defined', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.clear();
      expect(() => {
        sc.buildSchema();
      }).toThrowError();
    });
    it('should accept additional types', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.Query.addFields({
        time: 'Int'
      });
      const me1 = sc.createObjectTC('type Me1 { a: Int }').getType();
      const me2 = sc.createObjectTC('type Me2 { a: Int }').getType();
      const schema = sc.buildSchema({
        types: [me1, me1, me2]
      });
      expect(schema._typeMap.Me1).toEqual(me1);
      expect(schema._typeMap.Me2).toEqual(me2);
    });
    it('should provide proper Schema when provided only Query',
    /*#__PURE__*/
    _asyncToGenerator(function* () {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.Query.addFields({
        num: 'Int'
      });
      const schema = sc.buildSchema();
      expect((yield (0, _graphql.graphql)({
        schema,
        source: `
            query {
              num
            }
          `
      }))).toEqual({
        data: {
          num: null
        }
      });
    }));
    it('should throw error if only Mutation provided',
    /*#__PURE__*/
    _asyncToGenerator(function* () {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.Mutation.addFields({
        num: 'Int'
      });
      expect(() => {
        sc.buildSchema();
      }).toThrow('Must be initialized Query type');
    }));
  });
  describe('removeEmptyTypes()', () => {
    it('should remove fields with Types which have no fields', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const TypeWithoutFieldsTC = sc.getOrCreateOTC('Stub');
      TypeWithoutFieldsTC.setFields({});
      const ViewerTC = sc.getOrCreateOTC('Viewer');
      ViewerTC.setFields({
        name: 'String',
        stub: TypeWithoutFieldsTC
      });
      /* eslint-disable */

      const oldConsoleLog = console.log;
      global.console.log = jest.fn();
      sc.removeEmptyTypes(ViewerTC);
      expect(console.log).lastCalledWith("graphql-compose: Delete field 'Viewer.stub' with type 'Stub', cause it does not have fields.");
      global.console.log = oldConsoleLog;
      /* eslint-enable */

      expect(ViewerTC.hasField('stub')).toBe(false);
    });
    it('should not produce Maximum call stack size exceeded', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const UserTC = sc.getOrCreateOTC('User');
      UserTC.setField('friend', UserTC);
      sc.removeEmptyTypes(UserTC);
    });
  });
  describe('root type getters', () => {
    it('Query', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      expect(sc.Query).toBe(sc.Query);
      expect(sc.Query.getTypeName()).toBe('Query');
    });
    it('Mutation', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      expect(sc.Mutation).toBe(sc.Mutation);
      expect(sc.Mutation.getTypeName()).toBe('Mutation');
    });
    it('Subscription', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      expect(sc.Subscription).toBe(sc.Subscription);
      expect(sc.Subscription.getTypeName()).toBe('Subscription');
    });
  });
  describe('SchemaMustHaveType', () => {
    const sc = new _SchemaComposer.SchemaComposer();
    const tc = sc.createObjectTC(`type Me { name: String }`);
    sc.addSchemaMustHaveType(tc);
    expect(sc._schemaMustHaveTypes).toContain(tc);
    sc.clear();
    expect(sc._schemaMustHaveTypes).not.toContain(tc);
    sc.addSchemaMustHaveType(tc);
    sc.Query.addFields({
      time: 'String'
    });
    const schema = sc.buildSchema();
    expect(schema._typeMap.Me).toEqual(tc.getType());
  });
  describe('getOTC', () => {
    it('should return ObjectTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.createObjectTC(`
          type Author {
            name: String
          }
        `);
      expect(sc.getOTC('Author')).toBeInstanceOf(_ObjectTypeComposer.ObjectTypeComposer);
    });
    it('should return GraphQLObjectType as ObjectTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.add(new _graphql.GraphQLObjectType({
        name: 'Author',
        fields: {
          name: {
            type: _graphql.GraphQLString
          }
        }
      }));
      expect(sc.getOTC('Author')).toBeInstanceOf(_ObjectTypeComposer.ObjectTypeComposer);
    });
    it('should throw error for incorrect type', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.createInputTC(`
        input Author {
          name: String
        }
      `);
      expect(() => sc.getOTC('Author')).toThrowError('Cannot find ObjectTypeComposer with name Author');
    });
  });
  describe('getITC', () => {
    it('should return InputTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.createInputTC(`
          input Author {
            name: String
          }
        `);
      expect(sc.getITC('Author')).toBeInstanceOf(_InputTypeComposer.InputTypeComposer);
    });
    it('should return GraphQLInputObjectType as InputTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.add(new _graphql.GraphQLInputObjectType({
        name: 'Author',
        fields: {
          name: {
            type: _graphql.GraphQLString
          }
        }
      }));
      expect(sc.getITC('Author')).toBeInstanceOf(_InputTypeComposer.InputTypeComposer);
    });
    it('should throw error for incorrect type', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.createObjectTC(`
        type Author {
          name: String
        }
      `);
      expect(() => sc.getITC('Author')).toThrowError('Cannot find InputTypeComposer with name Author');
    });
  });
  describe('getSTC', () => {
    it('should return ScalarTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.createScalarTC(`scalar UInt`);
      expect(sc.getSTC('UInt')).toBeInstanceOf(_ScalarTypeComposer.ScalarTypeComposer);
    });
    it('should return GraphQLScalarType as ScalarTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.add(new _graphql.GraphQLScalarType({
        name: 'SomeInt',
        serialize: () => {}
      }));
      expect(sc.getSTC('SomeInt')).toBeInstanceOf(_ScalarTypeComposer.ScalarTypeComposer);
    });
    it('should throw error for incorrect type', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.createObjectTC(`
        type Sort {
          name: String
        }
      `);
      expect(() => sc.getSTC('Sort')).toThrowError('Cannot find ScalarTypeComposer with name Sort');
    });
  });
  describe('getETC', () => {
    it('should return EnumTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.createEnumTC(`
          enum Sort {
            ASC DESC
          }
        `);
      expect(sc.getETC('Sort')).toBeInstanceOf(_EnumTypeComposer.EnumTypeComposer);
    });
    it('should return GraphQLEnumType as EnumTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.add(new _graphql.GraphQLEnumType({
        name: 'Sort',
        values: {
          ASC: {
            value: 'ASC'
          }
        }
      }));
      expect(sc.getETC('Sort')).toBeInstanceOf(_EnumTypeComposer.EnumTypeComposer);
    });
    it('should throw error for incorrect type', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.createObjectTC(`
        type Sort {
          name: String
        }
      `);
      expect(() => sc.getETC('Sort')).toThrowError('Cannot find EnumTypeComposer with name Sort');
    });
  });
  describe('getIFTC', () => {
    it('should return InterfaceTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.createInterfaceTC(`
          interface IFace {
            name: String
          }
        `);
      expect(sc.getIFTC('IFace')).toBeInstanceOf(_InterfaceTypeComposer.InterfaceTypeComposer);
    });
    it('should return GraphQLInterfaceType as InterfaceTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.add(new _graphql.GraphQLInterfaceType({
        name: 'IFace',
        fields: {
          name: {
            type: _graphql.GraphQLString
          }
        }
      }));
      expect(sc.getIFTC('IFace')).toBeInstanceOf(_InterfaceTypeComposer.InterfaceTypeComposer);
    });
    it('should throw error for incorrect type', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.createObjectTC(`
        type IFace {
          name: String
        }
      `);
      expect(() => sc.getIFTC('IFace')).toThrowError('Cannot find InterfaceTypeComposer with name IFace');
    });
  });
  describe('getAnyTC()', () => {
    it('should return ObjectTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.createObjectTC(`type Object1 { name: String }`);
      expect(sc.getAnyTC('Object1')).toBeInstanceOf(_ObjectTypeComposer.ObjectTypeComposer);
      sc.add(new _graphql.GraphQLObjectType({
        name: 'Object2',
        fields: () => ({})
      }));
      expect(sc.getAnyTC('Object2')).toBeInstanceOf(_ObjectTypeComposer.ObjectTypeComposer);
    });
    it('should return InputTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.createInputTC(`input Input1 { name: String }`);
      expect(sc.getAnyTC('Input1')).toBeInstanceOf(_InputTypeComposer.InputTypeComposer);
      sc.add(new _graphql.GraphQLInputObjectType({
        name: 'Input2',
        fields: () => ({})
      }));
      expect(sc.getAnyTC('Input2')).toBeInstanceOf(_InputTypeComposer.InputTypeComposer);
    });
    it('should return ScalarTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.createScalarTC(`scalar Scalar1`);
      expect(sc.getAnyTC('Scalar1')).toBeInstanceOf(_ScalarTypeComposer.ScalarTypeComposer);
      sc.add(new _graphql.GraphQLScalarType({
        name: 'Scalar2',
        serialize: () => {}
      }));
      expect(sc.getAnyTC('Scalar2')).toBeInstanceOf(_ScalarTypeComposer.ScalarTypeComposer);
    });
    it('should return EnumTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.createEnumTC(`enum Enum1 { A B }`);
      expect(sc.getAnyTC('Enum1')).toBeInstanceOf(_EnumTypeComposer.EnumTypeComposer);
      sc.add(new _graphql.GraphQLEnumType({
        name: 'Enum2',
        values: {}
      }));
      expect(sc.getAnyTC('Enum2')).toBeInstanceOf(_EnumTypeComposer.EnumTypeComposer);
    });
    it('should return InterfaceTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.createInterfaceTC(`interface Iface1 { f1: Int }`);
      expect(sc.getAnyTC('Iface1')).toBeInstanceOf(_InterfaceTypeComposer.InterfaceTypeComposer);
      sc.add(new _graphql.GraphQLInterfaceType({
        name: 'Iface2',
        fields: () => ({})
      }));
      expect(sc.getAnyTC('Iface2')).toBeInstanceOf(_InterfaceTypeComposer.InterfaceTypeComposer);
    });
    it('should return UnionTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const a = sc.createObjectTC(`type A { f: Int }`);
      sc.createUnionTC(`union Union1 = A`);
      expect(sc.getAnyTC('Union1')).toBeInstanceOf(_UnionTypeComposer.UnionTypeComposer);
      sc.add(new _graphql.GraphQLUnionType({
        name: 'Union2',
        types: [a.getType()]
      }));
      expect(sc.getAnyTC('Union2')).toBeInstanceOf(_UnionTypeComposer.UnionTypeComposer);
    });
    it('should unwrap graphql List and NonNull', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const tc = sc.getAnyTC(new _graphql.GraphQLNonNull(new _graphql.GraphQLList(_graphql.GraphQLString)));
      expect(tc).toBeInstanceOf(_ScalarTypeComposer.ScalarTypeComposer);
    });
  });
  describe('add()', () => {
    it('should add ObjectTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();

      const tc = _ObjectTypeComposer.ObjectTypeComposer.createTemp('User');

      const typeName = sc.add(tc);
      expect(typeName).toBe('User');
      expect(sc.get('User')).toBe(tc);
      expect(sc.getOTC('User')).toBe(tc);
      sc.add(`type Object { a: Int }`);
      expect(sc.get('Object')).toBeInstanceOf(_ObjectTypeComposer.ObjectTypeComposer);
    });
    it('should add InputTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();

      const itc = _InputTypeComposer.InputTypeComposer.createTemp('UserInput');

      const typeName = sc.add(itc);
      expect(typeName).toBe('UserInput');
      expect(sc.get('UserInput')).toBe(itc);
      expect(sc.getITC('UserInput')).toBe(itc);
      sc.add(`input Object { a: Int }`);
      expect(sc.get('Object')).toBeInstanceOf(_InputTypeComposer.InputTypeComposer);
    });
    it('should add ScalarTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();

      const stc = _ScalarTypeComposer.ScalarTypeComposer.createTemp('UserScalar');

      const typeName = sc.add(stc);
      expect(typeName).toBe('UserScalar');
      expect(sc.get('UserScalar')).toBe(stc);
      expect(sc.getSTC('UserScalar')).toBe(stc);
      sc.add(`scalar Object`);
      expect(sc.get('Object')).toBeInstanceOf(_ScalarTypeComposer.ScalarTypeComposer);
    });
    it('should add EnumTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();

      const etc = _EnumTypeComposer.EnumTypeComposer.createTemp('UserEnum');

      const typeName = sc.add(etc);
      expect(typeName).toBe('UserEnum');
      expect(sc.get('UserEnum')).toBe(etc);
      expect(sc.getETC('UserEnum')).toBe(etc);
      sc.add(`enum Object { A }`);
      expect(sc.get('Object')).toBeInstanceOf(_EnumTypeComposer.EnumTypeComposer);
    });
    it('should add GraphQLObjectType', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const t = new _graphql.GraphQLObjectType({
        name: 'NativeType',
        fields: () => {}
      });
      const typeName = sc.add(t);
      expect(typeName).toBe('NativeType');
      expect(sc.get('NativeType')).toBe(t);
    });
    it('should add InterfaceTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();

      const iftc = _InterfaceTypeComposer.InterfaceTypeComposer.createTemp('UserInterface');

      const typeName = sc.add(iftc);
      expect(typeName).toBe('UserInterface');
      expect(sc.get('UserInterface')).toBe(iftc);
      expect(sc.getIFTC('UserInterface')).toBe(iftc);
      sc.add(`interface Object { a: Int }`);
      expect(sc.get('Object')).toBeInstanceOf(_InterfaceTypeComposer.InterfaceTypeComposer);
    });
    it('should add UnionTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();

      const utc = _UnionTypeComposer.UnionTypeComposer.createTemp('UserUnion');

      const typeName = sc.add(utc);
      expect(typeName).toBe('UserUnion');
      expect(sc.get('UserUnion')).toBe(utc);
      expect(sc.getUTC('UserUnion')).toBe(utc);
      sc.add(`type A { f: Int }`);
      sc.add(`union Object = A`);
      expect(sc.get('Object')).toBeInstanceOf(_UnionTypeComposer.UnionTypeComposer);
    });
  });
  describe('addAsComposer()', () => {
    it('should add ObjectTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.addAsComposer(`type Object1 { name: String }`);
      sc.addAsComposer(_ObjectTypeComposer.ObjectTypeComposer.createTemp(`type Object2 { name: String }`));
      sc.addAsComposer(new _graphql.GraphQLObjectType({
        name: 'Object3',
        fields: () => ({})
      }));
      expect(sc.get('Object1')).toBeInstanceOf(_ObjectTypeComposer.ObjectTypeComposer);
      expect(sc.get('Object2')).toBeInstanceOf(_ObjectTypeComposer.ObjectTypeComposer);
      expect(sc.get('Object3')).toBeInstanceOf(_ObjectTypeComposer.ObjectTypeComposer);
    });
    it('should return InputTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.addAsComposer(`input Object1 { name: String }`);
      sc.addAsComposer(_InputTypeComposer.InputTypeComposer.createTemp(`input Object2 { name: String }`));
      sc.addAsComposer(new _graphql.GraphQLInputObjectType({
        name: 'Object3',
        fields: () => ({})
      }));
      expect(sc.get('Object1')).toBeInstanceOf(_InputTypeComposer.InputTypeComposer);
      expect(sc.get('Object2')).toBeInstanceOf(_InputTypeComposer.InputTypeComposer);
      expect(sc.get('Object3')).toBeInstanceOf(_InputTypeComposer.InputTypeComposer);
    });
    it('should return ScalarTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.addAsComposer(`scalar Object1`);
      sc.addAsComposer(_ScalarTypeComposer.ScalarTypeComposer.createTemp(`scalar Object2`));
      sc.addAsComposer(new _graphql.GraphQLScalarType({
        name: 'Object3',
        serialize: () => ({})
      }));
      expect(sc.get('Object1')).toBeInstanceOf(_ScalarTypeComposer.ScalarTypeComposer);
      expect(sc.get('Object2')).toBeInstanceOf(_ScalarTypeComposer.ScalarTypeComposer);
      expect(sc.get('Object3')).toBeInstanceOf(_ScalarTypeComposer.ScalarTypeComposer);
    });
    it('should return EnumTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.addAsComposer(`enum Object1 { A B }`);
      sc.addAsComposer(_EnumTypeComposer.EnumTypeComposer.createTemp(`enum Object2 { A B }`));
      sc.addAsComposer(new _graphql.GraphQLEnumType({
        name: 'Object3',
        values: {}
      }));
      expect(sc.get('Object1')).toBeInstanceOf(_EnumTypeComposer.EnumTypeComposer);
      expect(sc.get('Object2')).toBeInstanceOf(_EnumTypeComposer.EnumTypeComposer);
      expect(sc.get('Object3')).toBeInstanceOf(_EnumTypeComposer.EnumTypeComposer);
    });
    it('should return InterfaceTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.addAsComposer(`interface Object1 { a: Int }`);
      sc.addAsComposer(_InterfaceTypeComposer.InterfaceTypeComposer.createTemp(`interface Object2 { a: Int }`));
      sc.addAsComposer(new _graphql.GraphQLInterfaceType({
        name: 'Object3',
        fields: () => ({})
      }));
      expect(sc.get('Object1')).toBeInstanceOf(_InterfaceTypeComposer.InterfaceTypeComposer);
      expect(sc.get('Object2')).toBeInstanceOf(_InterfaceTypeComposer.InterfaceTypeComposer);
      expect(sc.get('Object3')).toBeInstanceOf(_InterfaceTypeComposer.InterfaceTypeComposer);
    });
    it('should return UnionTypeComposer', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const a = sc.createObjectTC(`type A { f: Int }`);
      sc.addAsComposer(`union Object1 = A`);
      sc.addAsComposer(_UnionTypeComposer.UnionTypeComposer.createTemp(`union Object2 = A`));
      sc.addAsComposer(new _graphql.GraphQLUnionType({
        name: 'Object3',
        types: [a.getType()]
      }));
      expect(sc.get('Object1')).toBeInstanceOf(_UnionTypeComposer.UnionTypeComposer);
      expect(sc.get('Object2')).toBeInstanceOf(_UnionTypeComposer.UnionTypeComposer);
      expect(sc.get('Object3')).toBeInstanceOf(_UnionTypeComposer.UnionTypeComposer);
    });
  });
  describe('addTypeDefs', () => {
    it('should parse types from SDL', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.addTypeDefs(`
        type Author {
          name: String
          some(arg: Int): String
        }
        input AuthorInput {
          name: String
        }
        scalar MyInt
        enum Sort {
          ASC
          DESC
        }
        interface PersonI {
          name: String
        }
      `);
      expect(sc.get('Author')).toBeInstanceOf(_ObjectTypeComposer.ObjectTypeComposer);
      expect(sc.get('AuthorInput')).toBeInstanceOf(_InputTypeComposer.InputTypeComposer);
      expect(sc.get('MyInt')).toBeInstanceOf(_ScalarTypeComposer.ScalarTypeComposer);
      expect(sc.get('Sort')).toBeInstanceOf(_EnumTypeComposer.EnumTypeComposer);
      expect(sc.get('PersonI')).toBeInstanceOf(_InterfaceTypeComposer.InterfaceTypeComposer);
    });
    it('should parse cross referenced types from SDL', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.addTypeDefs(`
        type Author {
          posts: [Post]
        }
        type Post {
          author: Author
        }
      `);
      expect(sc.get('Author')).toBeInstanceOf(_ObjectTypeComposer.ObjectTypeComposer);
      expect(sc.get('Post')).toBeInstanceOf(_ObjectTypeComposer.ObjectTypeComposer); // Post type should be the same instance

      const Post = sc.getOTC('Post').getType();
      const PostInAuthor = sc.getOTC('Author').getFieldTC('posts').getType();
      expect(Post).toBe(PostInAuthor); // Author type should be the same instance

      const Author = sc.getOTC('Author').getType();
      const AuthorInPost = sc.getOTC('Post').getFieldTC('author').getType();
      expect(Author).toBe(AuthorInPost);
    });
    it('should replace existed types', () => {
      // This behavior maybe changed in future.
      // Need to gather more use cases and problems.
      const sc = new _SchemaComposer.SchemaComposer();
      sc.addTypeDefs(`
        type Author {
          name: String
          some(arg: Int): String
        }
      `);
      expect(sc.getOTC('Author').hasFieldArg('some', 'arg')).toBeTruthy();
      sc.addTypeDefs(`
        type Author {
          name: String
        }
      `);
      expect(sc.getOTC('Author').hasFieldArg('some', 'arg')).toBeFalsy();
    });
    it('should merge Root types', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.Query.addFields({
        field1: 'Int'
      });
      sc.Mutation.addFields({
        field2: 'Int'
      });
      sc.Subscription.addFields({
        field3: 'Int'
      });
      sc.addTypeDefs(`
        type Query {
          field4: Int
        }
        type Mutation {
          field5: Int
        }
        type Subscription {
          field6: Int
        }
      `);
      expect(sc.Query.getFieldNames()).toEqual(['field1', 'field4']);
      expect(sc.Mutation.getFieldNames()).toEqual(['field2', 'field5']);
      expect(sc.Subscription.getFieldNames()).toEqual(['field3', 'field6']);
    });
  });
  describe('addResolveMethods', () => {
    it('should add resolve methods to fields in graphql-tools way',
    /*#__PURE__*/
    _asyncToGenerator(function* () {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.addTypeDefs(`
        schema {
          query: Query
        }

        type Post {
          id: Int!
          title: String
          votes: Int
        }

        type Query {
          posts: [Post]
        }
      `);
      sc.addResolveMethods({
        Query: {
          posts: () => [{
            id: 1,
            title: 'Post title'
          }]
        },
        Post: {
          votes: () => 10
        }
      });
      const schema = sc.buildSchema();
      expect((yield (0, _graphql.graphql)(schema, '{ posts { id title votes } }'))).toEqual({
        data: {
          posts: [{
            id: 1,
            title: 'Post title',
            votes: 10
          }]
        }
      });
    }));
    it('should add scalar types', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.addTypeDefs(`
        scalar Date
      `);
      sc.addResolveMethods({
        Date: new _graphql.GraphQLScalarType({
          name: 'Date',

          serialize(value) {
            return new Date(value).toISOString().slice(0, 10);
          }

        })
      });
      expect(sc.get('Date')).toBeInstanceOf(_graphql.GraphQLScalarType);
      expect(Array.from(sc.types.keys())).toContain('Date');
    });
    it('should add scalar types as configs', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.addTypeDefs(`
        scalar Date
      `);
      sc.addResolveMethods({
        Date: {
          name: 'Date',

          serialize(value) {
            return new Date(value).toISOString().slice(0, 10);
          }

        }
      });
      expect(sc.get('Date')).toBeInstanceOf(_graphql.GraphQLScalarType);
      expect(Array.from(sc.types.keys())).toContain('Date');
    });
  });
  describe('createTC helper methods', () => {
    it('createObjectTC()', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const tc = sc.createObjectTC(`type A { f: Int }`);
      expect(tc).toBeInstanceOf(_ObjectTypeComposer.ObjectTypeComposer);
      expect(tc.hasField('f')).toBeTruthy();
      const tc2 = sc.createObjectTC(`type B { f: Int }`);
      expect(tc2).toBeInstanceOf(_ObjectTypeComposer.ObjectTypeComposer);
      expect(tc2.hasField('f')).toBeTruthy();
    });
    it('createInputTC()', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const tc = sc.createInputTC(`input A { f: Int }`);
      expect(tc).toBeInstanceOf(_InputTypeComposer.InputTypeComposer);
      expect(tc.hasField('f')).toBeTruthy();
    });
    it('createScalarTC()', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const tc = sc.createScalarTC(`scalar ABC`);
      expect(tc).toBeInstanceOf(_ScalarTypeComposer.ScalarTypeComposer);
      expect(tc.getTypeName()).toBe('ABC');
    });
    it('createEnumTC()', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const tc = sc.createEnumTC(`enum A { AAA BBB }`);
      expect(tc).toBeInstanceOf(_EnumTypeComposer.EnumTypeComposer);
      expect(tc.hasField('AAA')).toBeTruthy();
    });
    it('createInterfaceTC()', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const tc = sc.createInterfaceTC(`interface A { f: Int }`);
      expect(tc).toBeInstanceOf(_InterfaceTypeComposer.InterfaceTypeComposer);
      expect(tc.hasField('f')).toBeTruthy();
    });
    it('createUnionTC()', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.addTypeDefs(`
        type AA { a: Int }
        type BB { b: Int }
      `);
      const tc = sc.createUnionTC(`union A = AA | BB`);
      expect(tc).toBeInstanceOf(_UnionTypeComposer.UnionTypeComposer);
      expect(tc.hasType('AA')).toBeTruthy();
    });
  });
  describe('works with directives', () => {
    const d1 = new _graphql.GraphQLDirective({
      name: 'myDirective1',
      locations: [_graphql.DirectiveLocation.INPUT_FIELD_DEFINITION],
      args: {
        value: {
          type: _graphql.GraphQLString
        }
      }
    });
    const d2 = new _graphql.GraphQLDirective({
      name: 'myDirective2',
      locations: [_graphql.DirectiveLocation.INPUT_FIELD_DEFINITION],
      args: {
        value: {
          type: _graphql.GraphQLString
        }
      }
    });

    function removeDefaultDirectives(sc) {
      _SchemaComposer.BUILT_IN_DIRECTIVES.forEach(d => sc.removeDirective(d));
    }

    it('has default directives', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      expect(sc.hasDirective('@skip')).toBeTruthy();
      expect(sc.hasDirective('@include')).toBeTruthy();
      expect(sc.hasDirective('@deprecated')).toBeTruthy();
      expect(sc.hasDirective('@default')).toBeTruthy();
      expect(sc.getDirectives()).toHaveLength(4);
    });
    it('addDirective()', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      removeDefaultDirectives(sc);
      sc.addDirective(d1);
      expect(sc.getDirectives()).toHaveLength(1);
      sc.addDirective(d1);
      expect(sc.getDirectives()).toHaveLength(1);
      sc.addDirective(d2);
      expect(sc.getDirectives()).toHaveLength(2);
    });
    it('removeDirective()', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      removeDefaultDirectives(sc);
      sc.addDirective(d1);
      sc.addDirective(d2);
      expect(sc.getDirectives()).toHaveLength(2);
      sc.removeDirective(d1);
      expect(sc.getDirectives()).toHaveLength(1);
      sc.removeDirective(d1);
      expect(sc.getDirectives()).toHaveLength(1);
      sc.removeDirective(d2);
      expect(sc.getDirectives()).toHaveLength(0);
    });
    it('addTypeDefs() should add directives', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      removeDefaultDirectives(sc);
      expect(sc.getDirectives()).toHaveLength(0);
      sc.addTypeDefs(`
        directive @customDirective(level: Int!) on FIELD
      `);
      expect(sc.getDirectives()).toHaveLength(1);
      expect(sc.getDirectives()[0]).toBeInstanceOf(_graphql.GraphQLDirective);
    });
    it('clear() should clear directives and restore defaults', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      removeDefaultDirectives(sc);
      sc.addDirective(d1);
      expect(sc.getDirectives()).toHaveLength(1);
      expect(sc.has('String')).toBeTruthy();
      sc.clear();
      expect(sc.has('String')).toBeTruthy();
      expect(sc.has('Int')).toBeTruthy();
      expect(sc.hasDirective('@skip')).toBe(true);
      expect(sc.hasDirective('@include')).toBe(true);
      expect(sc.hasDirective('@deprecated')).toBe(true);
      expect(sc.hasDirective('@default')).toBe(true);
      expect(sc.getDirectives()).toHaveLength(4);
    });
    it('hasDirective()', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      removeDefaultDirectives(sc);
      sc.addDirective(d1);
      expect(sc.hasDirective(d1)).toBeTruthy();
      expect(sc.hasDirective('@myDirective1')).toBeTruthy();
      expect(sc.hasDirective('myDirective1')).toBeTruthy();
      expect(sc.hasDirective(d2)).toBeFalsy();
      expect(sc.hasDirective('myDirective2')).toBeFalsy();
    });
  });
  describe('createTC()', () => {
    it('should Create ObjectTC', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const tc = sc.createTC(`type MyType { a: Int }`);
      expect(tc).toBeInstanceOf(_ObjectTypeComposer.ObjectTypeComposer);
      expect(sc.has('MyType')).toBeTruthy(); // schoul return the same type composer instance

      expect(sc.get('MyType')).toBe(tc);
      expect(sc.createTC(`type MyType { a: Int }`)).toBe(tc);
    });
    it('should Create InputObjectTC', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      const tc = sc.createTC(`input MyTypeInput { a: Int }`);
      expect(tc).toBeInstanceOf(_InputTypeComposer.InputTypeComposer);
      expect(sc.has('MyTypeInput')).toBeTruthy(); // schoul return the same type composer instance

      expect(sc.get('MyTypeInput')).toBe(tc);
      expect(sc.createTC(`input MyTypeInput { a: Int }`)).toBe(tc);
    });
  });
  describe('merge()', () => {
    it('should load types from GraphQLSchema and merge with existed types', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.Query.addFields({
        existedInQuery: 'String'
      });
      sc.Mutation.addFields({
        existedInMutation: 'String'
      });
      sc.Subscription.addFields({
        existedInSubscription: 'String'
      });
      sc.createTC(`type User { age: Int }`);
      const schema = new _graphql.GraphQLSchema({
        query: new _graphql.GraphQLObjectType({
          name: 'MyQuery',
          fields: {
            user: {
              type: new _graphql.GraphQLObjectType({
                name: 'User',
                interfaces: [new _graphql.GraphQLInterfaceType({
                  name: 'IUser',
                  fields: {
                    name: {
                      type: _graphql.GraphQLString
                    }
                  }
                })],
                fields: {
                  name: {
                    type: _graphql.GraphQLString
                  }
                }
              })
            }
          }
        }),
        mutation: new _graphql.GraphQLObjectType({
          name: 'MyMutation',
          fields: {
            write: {
              type: _graphql.GraphQLString
            }
          }
        }),
        subscription: new _graphql.GraphQLObjectType({
          name: 'MySubscription',
          fields: {
            subscribe: {
              type: _graphql.GraphQLString
            }
          }
        })
      });
      sc.merge(schema); // imported schema should extend Query, Mutation and Subscription

      expect(sc.Query.getFieldNames()).toEqual(['existedInQuery', 'user']);
      expect(sc.Mutation.getFieldNames()).toEqual(['existedInMutation', 'write']);
      expect(sc.Subscription.getFieldNames()).toEqual(['existedInSubscription', 'subscribe']); // should merge object types

      expect(sc.getOTC('User').getFieldNames()).toEqual(['age', 'name']); // should import interfaces

      expect(sc.getIFTC('IUser').getFieldNames()).toEqual(['name']);
    });
    it('should load types from another SchemaComposer and merge with existed types', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.Query.addFields({
        existedInQuery: 'String'
      });
      sc.Mutation.addFields({
        existedInMutation: 'String'
      });
      sc.Subscription.addFields({
        existedInSubscription: 'String'
      });
      sc.createTC(`type User { age: Int }`);
      const sc2 = new _SchemaComposer.SchemaComposer();
      sc2.createInterfaceTC(`interface IUser { name: String }`);
      sc2.Query.addFields({
        user: sc2.createObjectTC(`type User implements IUser { name: String }`)
      });
      sc2.Mutation.addFields({
        write: 'String'
      });
      sc2.Subscription.addFields({
        subscribe: 'String'
      });
      sc.merge(sc2); // imported schema should extend Query, Mutation and Subscription

      expect(sc.Query.getFieldNames()).toEqual(['existedInQuery', 'user']);
      expect(sc.Mutation.getFieldNames()).toEqual(['existedInMutation', 'write']);
      expect(sc.Subscription.getFieldNames()).toEqual(['existedInSubscription', 'subscribe']); // should merge object types

      expect(sc.getOTC('User').getFieldNames()).toEqual(['age', 'name']); // should import interfaces

      expect(sc.getIFTC('IUser').getFieldNames()).toEqual(['name']);
    });
    it('should throw an error on merging different kind of types with the same name', () => {
      const sc = new _SchemaComposer.SchemaComposer();
      sc.createTC(`type User { name: String }`);
      const sc2 = new _SchemaComposer.SchemaComposer();
      sc2.createTC(`input User { name: String }`);
      expect(() => {
        sc.merge(sc2);
      }).toThrow(/Cannot merge InputTypeComposer.*with ObjectType/);
    });
  });
});