msw 2.14.7 → 3.0.0

package/src/{core/handlers/GraphQLHandler.test.ts → graphql/graphql-handler.test.ts}

@@ -1,13 +1,14 @@
 // @vitest-environment jsdom
 import { createRequestId, encodeBuffer } from '@mswjs/interceptors'
 import { OperationTypeNode, parse } from 'graphql'
-import type {
-  GraphQLRequestBody,
-  GraphQLResolverExtras,
-} from './GraphQLHandler'
-import { GraphQLHandler, isDocumentNode } from './GraphQLHandler'
-import { HttpResponse } from '../HttpResponse'
-import type { ResponseResolver } from './RequestHandler'
+import {
+  isDocumentNode,
+  GraphQLHandler,
+  type GraphQLRequestBody,
+  type GraphQLResolverExtras,
+} from './graphql-handler'
+import { HttpResponse } from '#http/http-response'
+import type { ResponseResolver } from '../core/handlers/request-handler'
 
 const resolver: ResponseResolver<GraphQLResolverExtras<{ userId: string }>> = ({
   variables,
@@ -59,7 +60,7 @@ const LOGIN = `
 `
 
 describe('info', () => {
-  it('exposes request handler information for query', () => {
+  test('exposes request handler information for query', () => {
     const handler = new GraphQLHandler(
       OperationTypeNode.QUERY,
       'GetUser',
@@ -72,7 +73,7 @@ describe('info', () => {
     expect(handler.info.operationName).toEqual('GetUser')
   })
 
-  it('exposes request handler information for mutation', () => {
+  test('exposes request handler information for mutation', () => {
     const handler = new GraphQLHandler(
       OperationTypeNode.MUTATION,
       'Login',
@@ -85,7 +86,7 @@ describe('info', () => {
     expect(handler.info.operationName).toEqual('Login')
   })
 
-  it('parses a query operation name from a given DocumentNode', () => {
+  test('parses a query operation name from a given DocumentNode', () => {
     const node = parse(`
       query GetUser {
         user {
@@ -106,7 +107,7 @@ describe('info', () => {
     expect(handler.info).toHaveProperty('operationName', 'GetUser')
   })
 
-  it('parses a mutation operation name from a given DocumentNode', () => {
+  test('parses a mutation operation name from a given DocumentNode', () => {
     const node = parse(`
       mutation Login {
         user {
@@ -126,7 +127,7 @@ describe('info', () => {
     expect(handler.info).toHaveProperty('operationName', 'Login')
   })
 
-  it('throws an exception given a DocumentNode with a mismatched operation type', () => {
+  test('throws an exception given a DocumentNode with a mismatched operation type', () => {
     const node = parse(`
       mutation CreateUser {
         user {
@@ -145,7 +146,7 @@ describe('info', () => {
 
 describe('parse', () => {
   describe('query', () => {
-    it('parses a query without variables (GET)', async () => {
+    test('parses a query without variables (GET)', async () => {
       const handler = new GraphQLHandler(
         OperationTypeNode.QUERY,
         'GetUser',
@@ -171,7 +172,7 @@ describe('parse', () => {
       })
     })
 
-    it('parses a query with variables (GET)', async () => {
+    test('parses a query with variables (GET)', async () => {
       const handler = new GraphQLHandler(
         OperationTypeNode.QUERY,
         'GetUser',
@@ -202,7 +203,7 @@ describe('parse', () => {
       })
     })
 
-    it('parses a query without variables (POST)', async () => {
+    test('parses a query without variables (POST)', async () => {
       const handler = new GraphQLHandler(
         OperationTypeNode.QUERY,
         'GetUser',
@@ -228,7 +229,7 @@ describe('parse', () => {
       })
     })
 
-    it('parses a query with variables (POST)', async () => {
+    test('parses a query with variables (POST)', async () => {
       const handler = new GraphQLHandler(
         OperationTypeNode.QUERY,
         'GetUser',
@@ -261,7 +262,7 @@ describe('parse', () => {
   })
 
   describe('mutation', () => {
-    it('parses a mutation without variables (GET)', async () => {
+    test('parses a mutation without variables (GET)', async () => {
       const handler = new GraphQLHandler(
         OperationTypeNode.MUTATION,
         'GetUser',
@@ -287,7 +288,7 @@ describe('parse', () => {
       })
     })
 
-    it('parses a mutation with variables (GET)', async () => {
+    test('parses a mutation with variables (GET)', async () => {
       const handler = new GraphQLHandler(
         OperationTypeNode.MUTATION,
         'GetUser',
@@ -318,7 +319,7 @@ describe('parse', () => {
       })
     })
 
-    it('parses a mutation without variables (POST)', async () => {
+    test('parses a mutation without variables (POST)', async () => {
       const handler = new GraphQLHandler(
         OperationTypeNode.MUTATION,
         'GetUser',
@@ -344,7 +345,7 @@ describe('parse', () => {
       })
     })
 
-    it('parses a mutation with variables (POST)', async () => {
+    test('parses a mutation with variables (POST)', async () => {
       const handler = new GraphQLHandler(
         OperationTypeNode.MUTATION,
         'GetUser',
@@ -377,7 +378,7 @@ describe('parse', () => {
   })
 
   describe('with endpoint configuration', () => {
-    it('parses the request and parses grapqhl properties from it when the graphql.link endpoint matches', async () => {
+    test('parses the request and parses grapqhl properties from it when the graphql.link endpoint matches', async () => {
       const handler = new GraphQLHandler(
         OperationTypeNode.QUERY,
         'GetUser',
@@ -438,7 +439,7 @@ describe('parse', () => {
       })
     })
 
-    it('parses a request but does not parse graphql properties from it graphql.link hostname does not match', async () => {
+    test('parses a request but does not parse graphql properties from it graphql.link hostname does not match', async () => {
       const handler = new GraphQLHandler(
         OperationTypeNode.QUERY,
         'GetUser',
@@ -487,7 +488,7 @@ describe('parse', () => {
       })
     })
 
-    it('parses a request but does not parse graphql properties from it graphql.link pathname does not match', async () => {
+    test('parses a request but does not parse graphql properties from it graphql.link pathname does not match', async () => {
       const handler = new GraphQLHandler(
         OperationTypeNode.QUERY,
         'GetUser',
@@ -539,7 +540,7 @@ describe('parse', () => {
 })
 
 describe('predicate', () => {
-  it('respects operation type', async () => {
+  test('respects operation type', async () => {
     const handler = new GraphQLHandler(
       OperationTypeNode.QUERY,
       'GetUser',
@@ -567,7 +568,7 @@ describe('predicate', () => {
     ).toBe(false)
   })
 
-  it('respects operation name', async () => {
+  test('respects operation name', async () => {
     const handler = new GraphQLHandler(
       OperationTypeNode.QUERY,
       'GetUser',
@@ -601,7 +602,7 @@ describe('predicate', () => {
     ).resolves.toBe(false)
   })
 
-  it('allows anonymous GraphQL operations when using "all" expected operation type', async () => {
+  test('allows anonymous GraphQL operations when using "all" expected operation type', async () => {
     const handler = new GraphQLHandler('all', new RegExp('.*'), '*', resolver)
     const request = createPostGraphQLRequest({
       query: `
@@ -622,7 +623,7 @@ describe('predicate', () => {
     ).resolves.toBe(true)
   })
 
-  it('respects custom endpoint', async () => {
+  test('respects custom endpoint', async () => {
     const handler = new GraphQLHandler(
       OperationTypeNode.QUERY,
       'GetUser',
@@ -653,7 +654,7 @@ describe('predicate', () => {
     ).resolves.toBe(false)
   })
 
-  it('supports custom predicate function', async () => {
+  test('supports custom predicate function', async () => {
     const handler = new GraphQLHandler(
       OperationTypeNode.QUERY,
       ({ query }) => {
@@ -692,7 +693,7 @@ describe('predicate', () => {
 })
 
 describe('test', () => {
-  it('respects operation type', async () => {
+  test('respects operation type', async () => {
     const handler = new GraphQLHandler(
       OperationTypeNode.QUERY,
       'GetUser',
@@ -710,7 +711,7 @@ describe('test', () => {
     expect(await handler.test({ request: alienRequest })).toBe(false)
   })
 
-  it('respects operation name', async () => {
+  test('respects operation name', async () => {
     const handler = new GraphQLHandler(
       OperationTypeNode.QUERY,
       'GetUser',
@@ -734,7 +735,7 @@ describe('test', () => {
     await expect(handler.test({ request: alienRequest })).resolves.toBe(false)
   })
 
-  it('respects custom endpoint', async () => {
+  test('respects custom endpoint', async () => {
     const handler = new GraphQLHandler(
       OperationTypeNode.QUERY,
       'GetUser',
@@ -757,7 +758,7 @@ describe('test', () => {
 })
 
 describe('run', () => {
-  it('returns a mocked response given a matching query', async () => {
+  test('returns a mocked response given a matching query', async () => {
     const handler = new GraphQLHandler(
       OperationTypeNode.QUERY,
       'GetUser',
@@ -802,7 +803,7 @@ describe('run', () => {
     })
   })
 
-  it('returns null given a non-matching query', async () => {
+  test('returns null given a non-matching query', async () => {
     const handler = new GraphQLHandler(
       OperationTypeNode.QUERY,
       'GetUser',
@@ -820,7 +821,7 @@ describe('run', () => {
 })
 
 describe('isDocumentNode', () => {
-  it('returns true given a valid DocumentNode', () => {
+  test('returns true given a valid DocumentNode', () => {
     const node = parse(`
       query GetUser {
         user {
@@ -832,7 +833,7 @@ describe('isDocumentNode', () => {
     expect(isDocumentNode(node)).toEqual(true)
   })
 
-  it('returns false given an arbitrary input', () => {
+  test('returns false given an arbitrary input', () => {
     expect(isDocumentNode(null)).toEqual(false)
     expect(isDocumentNode(undefined)).toEqual(false)
     expect(isDocumentNode('')).toEqual(false)
@@ -842,7 +843,7 @@ describe('isDocumentNode', () => {
 })
 
 describe('request', () => {
-  it('has parsed operationName', async () => {
+  test('has parsed operationName', async () => {
     const matchAllResolver = vi.fn()
     const handler = new GraphQLHandler(
       OperationTypeNode.QUERY,

package/src/{core/handlers/GraphQLHandler.ts → graphql/graphql-handler.ts}

@@ -12,29 +12,30 @@ import {
   type RequestHandlerExecutionResult,
   type RequestHandlerOptions,
   type ResponseResolver,
-} from './RequestHandler'
-import { getTimestamp } from '../utils/logging/getTimestamp'
-import { getStatusCodeColor } from '../utils/logging/getStatusCodeColor'
-import { serializeRequest } from '../utils/logging/serializeRequest'
-import { serializeResponse } from '../utils/logging/serializeResponse'
+} from '#core/handlers/request-handler'
+import { getTimestamp } from '#core/utils/logging/get-timestamp'
+import { getStatusCodeColor } from '#core/utils/logging/get-status-code-color'
+import { serializeRequest } from '#core/utils/logging/serialize-request'
+import { serializeResponse } from '#core/utils/logging/serialize-response'
 import {
-  type Match,
   matchRequestUrl,
+  type Match,
   type Path,
-} from '../utils/matching/matchRequestUrl'
+} from '#core/utils/matching/match-request-url'
 import {
-  type ParsedGraphQLRequest,
-  type GraphQLMultipartRequestBody,
   parseGraphQLRequest,
   parseDocumentNode,
+  type ParsedGraphQLRequest,
+  type GraphQLMultipartRequestBody,
   type ParsedGraphQLQuery,
-} from '../utils/internal/parseGraphQLRequest'
-import { toPublicUrl } from '../utils/request/toPublicUrl'
-import { devUtils } from '../utils/internal/devUtils'
-import { getAllRequestCookies } from '../utils/request/getRequestCookies'
-import { type ResponseResolutionContext } from '../utils/executeHandlers'
-import { kDefaultContentType, type StrictRequest } from '../HttpResponse'
-import { getAllAcceptedMimeTypes } from '../utils/request/getAllAcceptedMimeTypes'
+} from './parse-graphql-request'
+import { toPublicUrl } from '#core/utils/request/to-public-url'
+import { devUtils } from '#core/utils/internal/dev-utils'
+import { getAllRequestCookies } from '#core/utils/request/get-request-cookies'
+import { kDefaultContentType } from '#http/symbols'
+import type { StrictRequest } from '#http/http-response'
+import { getAllAcceptedMimeTypes } from '#core/utils/request/get-all-accepted-mime-types'
+import type { ResponseResolutionContext } from '#core/utils/execute-handlers'
 
 export interface DocumentTypeDecoration<
   Result = { [key: string]: any },
@@ -110,7 +111,7 @@ export type GraphQLCustomPredicate = (args: {
   cookies: Record<string, string>
 }) => GraphQLCustomPredicateResult | Promise<GraphQLCustomPredicateResult>
 
-export type GraphQLCustomPredicateResult = boolean | { matches: boolean }
+type GraphQLCustomPredicateResult = boolean | { matches: boolean }
 
 export type GraphQLPredicate<Query = any, Variables = any> =
   | GraphQLHandlerNameSelector
@@ -184,35 +185,49 @@ export class GraphQLHandler extends RequestHandler<
     return predicate
   }
 
-  constructor(
-    operationType: GraphQLOperationType,
-    predicate: GraphQLPredicate,
-    endpoint: Path,
-    resolver: ResponseResolver<GraphQLResolverExtras<any>, any, any>,
-    options?: RequestHandlerOptions,
-  ) {
+  /**
+   * Creates a GraphQL handler information object from the given
+   * operation predicate. Normalizes `DocumentNode` and typed document
+   * string predicates to plain operation names.
+   */
+  static parseGraphQLRequestInfo(args: {
+    operationType: GraphQLOperationType
+    predicate: GraphQLPredicate
+    url: Path
+  }): GraphQLHandlerInfo {
     const operationName = GraphQLHandler.#parseOperationName(
-      predicate,
-      operationType,
+      args.predicate,
+      args.operationType,
     )
 
     const displayOperationName =
       typeof operationName === 'function' ? '[custom predicate]' : operationName
 
     const header =
-      operationType === 'all'
-        ? `${operationType} (origin: ${endpoint.toString()})`
-        : `${operationType}${displayOperationName ? ` ${displayOperationName}` : ''} (origin: ${endpoint.toString()})`
+      args.operationType === 'all'
+        ? `${args.operationType} (origin: ${args.url.toString()})`
+        : `${args.operationType}${displayOperationName ? ` ${displayOperationName}` : ''} (origin: ${args.url.toString()})`
 
+    return {
+      header,
+      operationType: args.operationType,
+      operationName,
+    }
+  }
+
+  constructor(
+    operationType: GraphQLOperationType,
+    predicate: GraphQLPredicate,
+    endpoint: Path,
+    resolver: ResponseResolver<GraphQLResolverExtras<any>, any, any>,
+    options?: RequestHandlerOptions,
+  ) {
     super({
-      info: {
-        header,
+      info: GraphQLHandler.parseGraphQLRequestInfo({
         operationType,
-        operationName: GraphQLHandler.#parseOperationName(
-          predicate,
-          operationType,
-        ),
-      },
+        predicate,
+        url: endpoint,
+      }),
       resolver,
       options,
     })
@@ -242,10 +257,8 @@ export class GraphQLHandler extends RequestHandler<
   }
 
   async parse(args: { request: Request }): Promise<GraphQLRequestParsedResult> {
-    /**
-     * If the request doesn't match a specified endpoint, there's no
-     * need to parse it since there's no case where we would handle this
-     */
+    // If the request doesn't match a specified endpoint, there's no
+    // need to parse it since there's no case where we would handle this
     const match = matchRequestUrl(new URL(args.request.url), this.endpoint)
     const cookies = getAllRequestCookies(args.request)
 
@@ -291,7 +304,7 @@ export class GraphQLHandler extends RequestHandler<
       devUtils.warn(`\
 Failed to intercept a GraphQL request at "${args.request.method} ${publicUrl}": anonymous GraphQL operations are not supported.
 
-Consider naming this operation or using "graphql.operation()" request handler to intercept GraphQL requests regardless of their operation name/type. Read more: https://mswjs.io/docs/api/graphql/#graphqloperationresolver`)
+Consider naming this operation or using the "operation()" request handler of "graphql.link()" to intercept GraphQL requests regardless of their operation name/type. Read more: https://mswjs.io/docs/api/graphql/#graphqloperationresolver`)
       return false
     }
 

package/src/graphql/graphql-subscription-event.ts

@@ -0,0 +1,39 @@
+import { TypedEvent } from 'rettime'
+
+export interface GraphQLSubscriptionEventInit {
+  operationName: string
+  query: string
+  variables: Record<string, unknown>
+  request: Request
+}
+
+/**
+ * Emitted when a GraphQL subscription is established over an
+ * intercepted WebSocket connection (i.e. matched by a subscription
+ * handler and resolved).
+ *
+ * @note The event is referenced by the WebSocket frame event map so
+ * the life-cycle event emitters derived from it (e.g. `server.events`)
+ * are typed correctly. It lives in its own module so the emitting
+ * `msw/graphql` module doesn't pull the entire frame graph, and the
+ * core stays free of the `graphql` dependency (the event carries
+ * plain data only).
+ */
+export class GraphQLSubscriptionEvent extends TypedEvent<
+  void,
+  void,
+  'graphql:subscription'
+> {
+  public readonly operationName: string
+  public readonly query: string
+  public readonly variables: Record<string, unknown>
+  public readonly request: Request
+
+  constructor(init: GraphQLSubscriptionEventInit) {
+    super('graphql:subscription')
+    this.operationName = init.operationName
+    this.query = init.query
+    this.variables = init.variables
+    this.request = init.request
+  }
+}

package/src/graphql/graphql-subscription.test.ts

@@ -0,0 +1,208 @@
+// @vitest-environment node
+import { invariant } from 'outvariant'
+import { OperationTypeNode, parse } from 'graphql'
+import { getSiblingHandlers } from '#core/utils/internal/attach-sibling-handlers'
+import { HttpHandler } from '#http/http-handler'
+import { WebSocketHandler } from '#ws/websocket-handler'
+import { WebSocketNetworkFrame } from '#core/experimental/frames/websocket-frame'
+import { InMemoryHandlersController } from '#core/experimental/handlers-controller'
+import { createTestWebSocketConnection } from '../../test/support/ws-test-utils'
+import type { GraphQLHandlerInfo } from './graphql-handler'
+import { graphql } from './graphql'
+import {
+  createGraphQLSubscriptionHandler,
+  GraphQLSubscriptionTransportHandler,
+} from './graphql-subscription'
+
+const subscription = createGraphQLSubscriptionHandler(
+  'http://localhost:4000/graphql',
+)
+
+describe('info', () => {
+  test('resolves handler info for a string operation name', () => {
+    expect(
+      subscription('OnCommentAdded', () => {}).info,
+    ).toEqual<GraphQLHandlerInfo>({
+      header:
+        'subscription OnCommentAdded (origin: ws://localhost:4000/graphql)',
+      operationName: 'OnCommentAdded',
+      operationType: OperationTypeNode.SUBSCRIPTION,
+    })
+  })
+
+  test('resolves handler info for a RegExp operation name', () => {
+    expect(subscription(/Comment/, () => {}).info).toEqual<GraphQLHandlerInfo>({
+      header: 'subscription /Comment/ (origin: ws://localhost:4000/graphql)',
+      operationName: /Comment/,
+      operationType: OperationTypeNode.SUBSCRIPTION,
+    })
+  })
+
+  test('resolves handler info for a DocumentNode operation name', () => {
+    const node = parse(`
+      subscription OnCommentAdded {
+        comment {
+          id
+        }
+      }
+    `)
+
+    expect(subscription(node, () => {}).info).toEqual<GraphQLHandlerInfo>({
+      header:
+        'subscription OnCommentAdded (origin: ws://localhost:4000/graphql)',
+      operationName: 'OnCommentAdded',
+      operationType: OperationTypeNode.SUBSCRIPTION,
+    })
+  })
+})
+
+describe('predicate', () => {
+  test('returns true for a matching WebSocket connection url', () => {
+    const handler = subscription('OnCommentAdded', () => {})
+    const url = 'ws://localhost:4000/graphql'
+    const parsedResult = handler.parse({ url })
+
+    expect(handler.predicate({ url, parsedResult })).toBe(true)
+  })
+
+  test('returns false for a non-matching WebSocket connection url', () => {
+    const handler = subscription('OnCommentAdded', () => {})
+    const url = 'ws://example.com/chat'
+    const parsedResult = handler.parse({ url })
+
+    expect(handler.predicate({ url, parsedResult })).toBe(false)
+  })
+})
+
+describe('protocol discrimination', () => {
+  class TestWebSocketFrame extends WebSocketNetworkFrame {
+    public passthrough = vi.fn()
+    public errorWith = vi.fn()
+  }
+
+  function getWebSocketHandlers(
+    controller: InMemoryHandlersController,
+  ): Array<WebSocketHandler> {
+    return controller
+      .getHandlersByKind('websocket')
+      .filter((handler) => handler instanceof WebSocketHandler)
+  }
+
+  test('does not claim connections that lack the "graphql-transport-ws" protocol', async () => {
+    const api = graphql.link('*')
+    const controller = new InMemoryHandlersController([
+      api.subscription('OnCommentAdded', vi.fn()),
+      api.operation(vi.fn()),
+    ])
+
+    // A non-GraphQL WebSocket connection (e.g. HMR, chat) that happens
+    // to match the wildcard endpoint. It must stay unhandled so it
+    // performs the connection as-is.
+    const connection = createTestWebSocketConnection('ws://localhost/socket')
+    const frame = new TestWebSocketFrame({ connection })
+    const unhandledFrameCallback = vi.fn()
+
+    const matches = await frame.resolve(
+      getWebSocketHandlers(controller),
+      unhandledFrameCallback,
+      { quiet: true },
+    )
+
+    expect.soft(matches).toBe(false)
+    expect.soft(frame.passthrough).toHaveBeenCalledOnce()
+    expect.soft(frame.errorWith).not.toHaveBeenCalled()
+    expect
+      .soft(unhandledFrameCallback)
+      .toHaveBeenCalledExactlyOnceWith(expect.objectContaining({ frame }))
+  })
+
+  test('claims connections that request the "graphql-transport-ws" protocol', async () => {
+    const api = graphql.link('*')
+    const controller = new InMemoryHandlersController([
+      api.subscription('OnCommentAdded', vi.fn()),
+    ])
+
+    const connection = createTestWebSocketConnection('ws://localhost/graphql', {
+      protocols: ['graphql-transport-ws'],
+    })
+    const frame = new TestWebSocketFrame({ connection })
+    const unhandledFrameCallback = vi.fn()
+
+    const matches = await frame.resolve(
+      getWebSocketHandlers(controller),
+      unhandledFrameCallback,
+      { quiet: true },
+    )
+
+    expect.soft(matches).toBe(true)
+    expect.soft(frame.passthrough).not.toHaveBeenCalled()
+    expect.soft(frame.errorWith).not.toHaveBeenCalled()
+    expect.soft(unhandledFrameCallback).not.toHaveBeenCalled()
+  })
+
+  test('ignores upgrade requests that lack the "graphql-transport-ws" protocol', async () => {
+    const handler = subscription('OnCommentAdded', () => {})
+    const [, upgradeHandler] = getSiblingHandlers(handler)
+
+    invariant(
+      upgradeHandler instanceof HttpHandler,
+      'Expected the second sibling to be the upgrade request handler',
+    )
+
+    await expect(
+      upgradeHandler.run({
+        request: new Request('http://localhost:4000/graphql', {
+          headers: {
+            upgrade: 'websocket',
+            'sec-websocket-key': 'dGhlIHNhbXBsZSBub25jZQ==',
+          },
+        }),
+        requestId: 'upgrade-plain',
+      }),
+    ).resolves.toBeNull()
+  })
+
+  test('confirms the protocol for matching upgrade requests', async () => {
+    const handler = subscription('OnCommentAdded', () => {})
+    const [, upgradeHandler] = getSiblingHandlers(handler)
+
+    invariant(
+      upgradeHandler instanceof HttpHandler,
+      'Expected the second sibling to be the upgrade request handler',
+    )
+
+    const result = await upgradeHandler.run({
+      request: new Request('http://localhost:4000/graphql', {
+        headers: {
+          upgrade: 'websocket',
+          'sec-websocket-key': 'dGhlIHNhbXBsZSBub25jZQ==',
+          'sec-websocket-protocol': 'graphql-transport-ws',
+        },
+      }),
+      requestId: 'upgrade-graphql',
+    })
+
+    expect(result?.response?.status).toBe(101)
+    expect(result?.response?.headers.get('sec-websocket-protocol')).toBe(
+      'graphql-transport-ws',
+    )
+  })
+})
+
+describe('sibling handlers', () => {
+  test('shares the transport and upgrade handlers between subscription handlers', () => {
+    const firstHandler = subscription('OnCommentAdded', () => {})
+    const secondHandler = subscription('OnPostAdded', () => {})
+
+    const firstSiblings = getSiblingHandlers(firstHandler)
+    const secondSiblings = getSiblingHandlers(secondHandler)
+
+    expect(firstSiblings).toHaveLength(2)
+    expect(firstSiblings[0]).toBeInstanceOf(GraphQLSubscriptionTransportHandler)
+
+    // The transport and the upgrade handlers must be shared by reference
+    // so the handlers controller dedupes them across subscription handlers.
+    expect(secondSiblings[0]).toBe(firstSiblings[0])
+    expect(secondSiblings[1]).toBe(firstSiblings[1])
+  })
+})