move semantic nullability tests to their own file

Author: twof

src/execution/__tests__/executor-test.ts

@@ -16,16 +16,12 @@ import {
   GraphQLNonNull,
   GraphQLObjectType,
   GraphQLScalarType,
-  GraphQLSemanticNonNull,
-  GraphQLSemanticNullable,
   GraphQLUnionType,
 } from '../../type/definition';
 import { GraphQLBoolean, GraphQLInt, GraphQLString } from '../../type/scalars';
 import { GraphQLSchema } from '../../type/schema';
 
 import { execute, executeSync } from '../execute';
-import { GraphQLError } from '../../error';
-import { ExecutableDefinitionNode, FieldNode, SelectionSetNode } from '../../language';
 
 describe('Execute: Handles basic execution tasks', () => {
   it('throws if no document is provided', () => {
@@ -1328,198 +1324,3 @@ describe('Execute: Handles basic execution tasks', () => {
   });
 });
 
-describe('Execute: Handles Semantic Nullability', () => {
-  const DeepDataType = new GraphQLObjectType({
-    name: 'DeepDataType',
-    fields: {
-      f: { type: new GraphQLNonNull(GraphQLString) }
-    },
-  });
-
-  const DataType: GraphQLObjectType = new GraphQLObjectType({
-    name: 'DataType',
-    fields: () => ({
-      a: { type: new GraphQLSemanticNullable(GraphQLString) },
-      b: { type: new GraphQLSemanticNonNull(GraphQLString) },
-      c: { type: new GraphQLNonNull(GraphQLString) },
-      d: { type: new GraphQLSemanticNonNull(DeepDataType) }
-    }),
-  });
-
-  it('SemanticNonNull throws error on null without error', async () => {
-    const data = {
-      a: () => 'Apple',
-      b: () => null,
-      c: () => 'Cookie'
-    };
-  
-    const document = parse(`
-      query {
-        b
-      }
-    `);
-
-    const result = await execute({
-      schema: new GraphQLSchema({ query: DataType }),
-      document,
-      rootValue: data,
-    });
-
-    let executable = document.definitions?.values().next().value as ExecutableDefinitionNode;
-    let selectionSet = executable.selectionSet.selections.values().next().value;
-
-    expect(result).to.deep.equal({
-      data: {
-        b: null
-      },
-      errors: [
-        new GraphQLError(
-          'Cannot return null for semantic-non-nullable field DataType.b.',
-          {
-            nodes: selectionSet,
-            path: ['b']
-          }
-        )
-      ]
-    });
-  });
-
-  it('SemanticNonNull succeeds on null with error', async () => {
-    const data = {
-      a: () => 'Apple',
-      b: () => { throw new Error(
-        `Something went wrong`,
-      ); },
-      c: () => 'Cookie'
-    };
-  
-    const document = parse(`
-      query {
-        b
-      }
-    `);
-
-    let executable = document.definitions?.values().next().value as ExecutableDefinitionNode;
-    let selectionSet = executable.selectionSet.selections.values().next().value;
-
-    const result = await execute({
-      schema: new GraphQLSchema({ query: DataType }),
-      document,
-      rootValue: data,
-    });
-
-    expect(result).to.deep.equal({
-      data: {
-        b: null
-      },
-      errors: [
-        new GraphQLError(
-          'Something went wrong',
-          {
-            nodes: selectionSet,
-            path: ['b']
-          }
-        )
-      ]
-    });
-  });
-
-  it('SemanticNonNull halts null propagation', async () => {
-    const deepData = {
-      f: () => null
-    };
-
-    const data = {
-      a: () => 'Apple',
-      b: () => null,
-      c: () => 'Cookie',
-      d: () => deepData
-    };
-    
-  
-    const document = parse(`
-      query {
-        d {
-          f
-        }
-      }
-    `);
-
-    const result = await execute({
-      schema: new GraphQLSchema({ query: DataType }),
-      document,
-      rootValue: data,
-    });
-
-    let executable = document.definitions?.values().next().value as ExecutableDefinitionNode;
-    let dSelectionSet = executable.selectionSet.selections.values().next().value as FieldNode;
-    let fSelectionSet = dSelectionSet.selectionSet?.selections.values().next().value;
-
-    expect(result).to.deep.equal({
-      data: {
-        d: null
-      },
-      errors: [
-        new GraphQLError(
-          'Cannot return null for non-nullable field DeepDataType.f.',
-          {
-            nodes: fSelectionSet,
-            path: ['d', 'f']
-          }
-        )
-      ]
-    });
-  });
-
-  it('SemanticNullable allows null values', async () => {
-    const data = {
-      a: () => null,
-      b: () => null,
-      c: () => 'Cookie'
-    };
-  
-    const document = parse(`
-      query {
-        a
-      }
-    `);
-
-    const result = await execute({
-      schema: new GraphQLSchema({ query: DataType }),
-      document,
-      rootValue: data,
-    });
-
-    expect(result).to.deep.equal({
-      data: {
-        a: null
-      }
-    });
-  });
-
-  it('SemanticNullable allows non-null values', async () => {
-    const data = {
-      a: () => 'Apple',
-      b: () => null,
-      c: () => 'Cookie'
-    };
-  
-    const document = parse(`
-      query {
-        a
-      }
-    `);
-
-    const result = await execute({
-      schema: new GraphQLSchema({ query: DataType }),
-      document,
-      rootValue: data,
-    });
-
-    expect(result).to.deep.equal({
-      data: {
-        a: 'Apple'
-      }
-    });
-  });
-});