Bring coverage to 100% 🎉 (#2358)

Author: IvanGoncharov

src/language/__tests__/visitor-test.js

@@ -253,6 +253,19 @@ describe('Visitor', () => {
     );
   });
 
+  it('ignores false returned on leave', () => {
+    const ast = parse('{ a, b, c { a, b, c } }', { noLocation: true });
+    const returnedAST = visit(ast, {
+      leave() {
+        return false;
+      },
+    });
+
+    expect(returnedAST).to.deep.equal(
+      parse('{ a, b, c { a, b, c } }', { noLocation: true }),
+    );
+  });
+
   it('visits edited node', () => {
     const addedField = {
       kind: 'Field',

src/subscription/__tests__/subscribe-test.js

@@ -164,6 +164,7 @@ describe('Subscription Initialization Phase', () => {
     });
 
     // $FlowFixMe
+    ai.next();
     ai.return();
   });
 

src/type/__tests__/schema-test.js

@@ -175,6 +175,9 @@ describe('Type System: Schema', () => {
 
       expect(schema.getType('SomeInterface')).to.equal(SomeInterface);
       expect(schema.getType('SomeSubtype')).to.equal(SomeSubtype);
+
+      expect(schema.isSubType(SomeInterface, SomeSubtype)).to.equal(true);
+      expect(schema.isPossibleType(SomeInterface, SomeSubtype)).to.equal(true);
     });
 
     it("includes interface's thunk subtypes in the type map", () => {

src/type/schema.js

@@ -232,7 +232,6 @@ export class GraphQLSchema {
     abstractType: GraphQLAbstractType,
     possibleType: GraphQLObjectType,
   ): boolean {
-    /* istanbul ignore next */
     return this.isSubType(abstractType, possibleType);
   }
 

src/validation/__tests__/validation-test.js

@@ -3,8 +3,12 @@
 import { expect } from 'chai';
 import { describe, it } from 'mocha';
 
+import { GraphQLError } from '../../error/GraphQLError';
+
 import { parse } from '../../language/parser';
+
 import { TypeInfo } from '../../utilities/TypeInfo';
+import { buildSchema } from '../../utilities/buildASTSchema';
 
 import { validate } from '../validate';
 
@@ -78,6 +82,43 @@ describe('Validate: Supports full validation', () => {
       'Cannot query field "isHouseTrained" on type "Dog". Did you mean "isHouseTrained"?',
     ]);
   });
+
+  it('validates using a custom rule', () => {
+    const schema = buildSchema(`
+      directive @custom(arg: String) on FIELD
+
+      type Query {
+        foo: String
+      }
+    `);
+
+    const doc = parse(`
+      query {
+        name @custom
+      }
+    `);
+
+    function customRule(context) {
+      return {
+        Directive(node) {
+          const directiveDef = context.getDirective();
+          const error = new GraphQLError(
+            'Reporting directive: ' + String(directiveDef),
+            node,
+          );
+          context.reportError(error);
+        },
+      };
+    }
+
+    const errors = validate(schema, doc, [customRule]);
+    expect(errors).to.deep.equal([
+      {
+        message: 'Reporting directive: @custom',
+        locations: [{ line: 3, column: 14 }],
+      },
+    ]);
+  });
 });
 
 describe('Validate: Limit maximum number of validation errors', () => {