subscribe-test: extract subscribeWithBadFn function (graphql#3630)

Two test groups use essentially the same logic to set up a subscription with an improper subscribeFn, testing both `subscribe` and `createSourceEventStream`. This PR extracts the duplicated logic into a single common `subscribeWithBadFn` function. For convenience, the common function is typed to appropriately return a `Promise<ExecutionResult>` rather than a `Promise<ExecutionResult | AsyncGenerator<...>>`). Because the `subscribeFn` is expected to be "bad," an `AsyncGenerator` should never be returned. If a valid `subscribeFn` is mistakenly passed, an assertion failure is triggered. extracted from graphql#3620

Author: yaacovCR

src/execution/__tests__/subscribe-test.ts

@@ -12,6 +12,7 @@ import { GraphQLList, GraphQLObjectType } from '../../type/definition';
 import { GraphQLBoolean, GraphQLInt, GraphQLString } from '../../type/scalars';
 import { GraphQLSchema } from '../../type/schema';
 
+import type { ExecutionResult } from '../execute';
 import { createSourceEventStream, subscribe } from '../subscribe';
 
 import { SimplePubSub } from './simplePubSub';
@@ -151,6 +152,28 @@ const DummyQueryType = new GraphQLObjectType({
  },
 });
 
+async function subscribeWithBadFn(
+ subscribeFn: () => unknown,
+): Promise<ExecutionResult> {
+ const schema = new GraphQLSchema({
+ query: DummyQueryType,
+ subscription: new GraphQLObjectType({
+ name: 'Subscription',
+ fields: {
+ foo: { type: GraphQLString, subscribe: subscribeFn },
+ },
+ }),
+ });
+ const document = parse('subscription { foo }');
+ const result = await subscribe({ schema, document });
+
+ assert(!isAsyncIterable(result));
+ expectJSON(await createSourceEventStream(schema, document)).toDeepEqual(
+ result,
+ );
+ return result;
+}
+
 /* eslint-disable @typescript-eslint/require-await */
 // Check all error cases when initializing the subscription.
 describe('Subscription Initialization Phase', () => {
@@ -490,46 +513,12 @@ describe('Subscription Initialization Phase', () => {
  });
 
  it('throws an error if subscribe does not return an iterator', async () => {
- const schema = new GraphQLSchema({
- query: DummyQueryType,
- subscription: new GraphQLObjectType({
- name: 'Subscription',
- fields: {
- foo: {
- type: GraphQLString,
- subscribe: () => 'test',
- },
- },
- }),
- });
-
- const document = parse('subscription { foo }');
-
- (await expectPromise(subscribe({ schema, document }))).toRejectWith(
+ (await expectPromise(subscribeWithBadFn(() => 'test'))).toRejectWith(
  'Subscription field must return Async Iterable. Received: "test".',
  );
  });
 
  it('resolves to an error for subscription resolver errors', async () => {
- async function subscribeWithFn(subscribeFn: () => unknown) {
- const schema = new GraphQLSchema({
- query: DummyQueryType,
- subscription: new GraphQLObjectType({
- name: 'Subscription',
- fields: {
- foo: { type: GraphQLString, subscribe: subscribeFn },
- },
- }),
- });
- const document = parse('subscription { foo }');
- const result = await subscribe({ schema, document });
-
- expectJSON(await createSourceEventStream(schema, document)).toDeepEqual(
- result,
- );
- return result;
- }
-
  const expectedResult = {
  errors: [
  {
@@ -542,24 +531,24 @@ describe('Subscription Initialization Phase', () => {
 
  expectJSON(
  // Returning an error
- await subscribeWithFn(() => new Error('test error')),
+ await subscribeWithBadFn(() => new Error('test error')),
  ).toDeepEqual(expectedResult);
 
  expectJSON(
  // Throwing an error
- await subscribeWithFn(() => {
+ await subscribeWithBadFn(() => {
  throw new Error('test error');
  }),
  ).toDeepEqual(expectedResult);
 
  expectJSON(
  // Resolving to an error
- await subscribeWithFn(() => Promise.resolve(new Error('test error'))),
+ await subscribeWithBadFn(() => Promise.resolve(new Error('test error'))),
  ).toDeepEqual(expectedResult);
 
  expectJSON(
  // Rejecting with an error
- await subscribeWithFn(() => Promise.reject(new Error('test error'))),
+ await subscribeWithBadFn(() => Promise.reject(new Error('test error'))),
  ).toDeepEqual(expectedResult);
  });