rename test files

also combine execute/subscribe

Author: yaacovCR

src/execution/__tests__/subscribe-diagnostics-test.ts

@@ -7,6 +7,7 @@ import {
 } from '../../__testUtils__/diagnosticsTestUtils.js';
 
 import { isAsyncIterable } from '../../jsutils/isAsyncIterable.js';
+import { isPromise } from '../../jsutils/isPromise.js';
 
 import { parse } from '../../language/parser.js';
 
@@ -23,18 +24,22 @@ const schema = buildSchema(`
   type Query {
     sync: String
     async: String
+    dummy: String
   }
-`);
-
-const rootValue = {
-  sync: () => 'hello',
-  async: () => Promise.resolve('hello-async'),
-};
 
-const executeChannel = getTracingChannel('graphql:execute');
+  type Subscription {
+    tick: String
+  }
+`);
 
 describe('execute diagnostics channel', () => {
   let active: ReturnType<typeof collectEvents> | undefined;
+  const executeChannel = getTracingChannel('graphql:execute');
+
+  const rootValue = {
+    sync: () => 'hello',
+    async: () => Promise.resolve('hello-async'),
+  };
 
   afterEach(() => {
     active?.unsubscribe();
@@ -110,16 +115,6 @@ describe('execute diagnostics channel', () => {
   });
 
   it('emits for each subscription event with resolved operation ctx', async () => {
-    const subscriptionSchema = buildSchema(`
-      type Query {
-        dummy: String
-      }
-
-      type Subscription {
-        tick: String
-      }
-    `);
-
     async function* tickGenerator() {
       await Promise.resolve();
       yield { tick: 'one' };
@@ -131,7 +126,7 @@ describe('execute diagnostics channel', () => {
     active = collectEvents(executeChannel);
 
     const subscription = await subscribe({
-      schema: subscriptionSchema,
+      schema,
       document,
       rootValue: { tick: tickGenerator },
     });
@@ -152,7 +147,7 @@ describe('execute diagnostics channel', () => {
       expect(ev.ctx.operationType).to.equal('subscription');
       expect(ev.ctx.operationName).to.equal('S');
       expect(ev.ctx.operation).to.equal(document.definitions[0]);
-      expect(ev.ctx.schema).to.equal(subscriptionSchema);
+      expect(ev.ctx.schema).to.equal(schema);
     }
   });
 
@@ -162,3 +157,91 @@ describe('execute diagnostics channel', () => {
     expect(result).to.deep.equal({ data: { sync: 'hello' } });
   });
 });
+
+describe('subscribe diagnostics channel', () => {
+  let active: ReturnType<typeof collectEvents> | undefined;
+  const subscribeChannel = getTracingChannel('graphql:subscribe');
+
+  async function* twoTicks(): AsyncIterable<{ tick: string }> {
+    await Promise.resolve();
+    yield { tick: 'one' };
+    yield { tick: 'two' };
+  }
+
+  afterEach(() => {
+    active?.unsubscribe();
+    active = undefined;
+  });
+
+  it('emits start and end for a synchronous subscription setup', async () => {
+    active = collectEvents(subscribeChannel);
+
+    const document = parse('subscription S { tick }');
+
+    const result = subscribe({
+      schema,
+      document,
+      rootValue: { tick: twoTicks },
+    });
+    const resolved = isPromise(result) ? await result : result;
+    assert(isAsyncIterable(resolved));
+    await resolved.return?.();
+
+    expect(active.events.map((e) => e.kind)).to.deep.equal(['start', 'end']);
+    expect(active.events[0].ctx.operationType).to.equal('subscription');
+    expect(active.events[0].ctx.operationName).to.equal('S');
+    expect(active.events[0].ctx.document).to.equal(document);
+    expect(active.events[0].ctx.schema).to.equal(schema);
+  });
+
+  it('emits the full async lifecycle when subscribe resolver returns a promise', async () => {
+    active = collectEvents(subscribeChannel);
+
+    const document = parse('subscription { tick }');
+
+    const result = subscribe({
+      schema,
+      document,
+      rootValue: {
+        tick: (): Promise<AsyncIterable<{ tick: string }>> =>
+          Promise.resolve(twoTicks()),
+      },
+    });
+    const resolved = isPromise(result) ? await result : result;
+    assert(isAsyncIterable(resolved));
+    await resolved.return?.();
+
+    expect(active.events.map((e) => e.kind)).to.deep.equal([
+      'start',
+      'end',
+      'asyncStart',
+      'asyncEnd',
+    ]);
+  });
+
+  it('emits only start and end for a synchronous validation failure', () => {
+    active = collectEvents(subscribeChannel);
+
+    // Invalid: no operation.
+    const document = parse('fragment F on Subscription { tick }');
+
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    subscribe({ schema, document, rootValue: { tick: twoTicks } });
+
+    expect(active.events.map((e) => e.kind)).to.deep.equal(['start', 'end']);
+  });
+
+  it('does nothing when no subscribers are attached', async () => {
+    const document = parse('subscription { tick }');
+
+    const result = subscribe({
+      schema,
+      document,
+      rootValue: { tick: twoTicks },
+    });
+    const resolved = isPromise(result) ? await result : result;
+    if (isAsyncIterable(resolved)) {
+      await resolved.return?.();
+    }
+  });
+});