test no tracing activity

Author: yaacovCR

src/__testUtils__/diagnosticsTestUtils.ts

@@ -1,6 +1,8 @@
 /* eslint-disable n/no-unsupported-features/node-builtins, import/no-nodejs-modules */
 import dc from 'node:diagnostics_channel';
 
+import { expect } from 'chai';
+
 import type { MinimalTracingChannel } from '../diagnostics.js';
 
 export interface CollectedEvent {
@@ -52,3 +54,68 @@ export function collectEvents(channel: MinimalTracingChannel): {
 export function getTracingChannel(name: string): MinimalTracingChannel {
   return dc.tracingChannel(name) as unknown as MinimalTracingChannel;
 }
+
+/**
+ * Assert that a graphql tracing channel stays on its zero-subscriber fast path.
+ * The test installs wrappers around the real tracing methods and verifies none
+ * of them were touched while `fn` ran.
+ */
+export async function expectNoTracingActivity<T>(
+  channel: MinimalTracingChannel,
+  fn: () => T | Promise<T>,
+): Promise<Awaited<T>> {
+  expect(channel.hasSubscribers).to.equal(false);
+  expect(channel.start.hasSubscribers).to.equal(false);
+  expect(channel.end.hasSubscribers).to.equal(false);
+  expect(channel.asyncStart.hasSubscribers).to.equal(false);
+  expect(channel.asyncEnd.hasSubscribers).to.equal(false);
+  expect(channel.error.hasSubscribers).to.equal(false);
+
+  const calls: Array<string> = [];
+  const restore: Array<() => void> = [];
+
+  function interceptMethod(
+    target: { [key: string]: unknown },
+    key: string,
+    name: string,
+  ): void {
+    const original = target[key] as (...args: Array<unknown>) => unknown;
+    target[key] = function interceptedMethod(
+      this: unknown,
+      ...args: Array<unknown>
+    ) {
+      calls.push(name);
+      return original.apply(this, args);
+    };
+    restore.push(() => {
+      target[key] = original;
+    });
+  }
+
+  interceptMethod(
+    channel as unknown as { [key: string]: unknown },
+    'traceSync',
+    'traceSync',
+  );
+
+  for (const phase of ['start', 'end', 'asyncStart', 'asyncEnd', 'error']) {
+    const subChannel = channel[
+      phase as keyof Pick<
+        MinimalTracingChannel,
+        'start' | 'end' | 'asyncStart' | 'asyncEnd' | 'error'
+      >
+    ] as unknown as { [key: string]: unknown };
+    interceptMethod(subChannel, 'publish', `${phase}.publish`);
+    interceptMethod(subChannel, 'runStores', `${phase}.runStores`);
+  }
+
+  try {
+    const result = await fn();
+    expect(calls).to.deep.equal([]);
+    return result;
+  } finally {
+    while (restore.length > 0) {
+      restore.pop()?.();
+    }
+  }
+}

src/execution/__tests__/tracing-test.ts

@@ -3,6 +3,7 @@ import { afterEach, describe, it } from 'mocha';
 
 import {
   collectEvents,
+  expectNoTracingActivity,
   getTracingChannel,
 } from '../../__testUtils__/diagnosticsTestUtils.js';
 
@@ -173,13 +174,15 @@ describe('execute diagnostics channel', () => {
     }
   });
 
-  it('does nothing when no subscribers are attached', () => {
+  it('does not call tracing methods when no subscribers are attached', async () => {
     const document = parse('{ sync }');
-    const result = execute({
-      schema,
-      document,
-      rootValue: { sync: () => 'hello' },
-    });
+    const result = await expectNoTracingActivity(executeChannel, () =>
+      execute({
+        schema,
+        document,
+        rootValue: { sync: () => 'hello' },
+      }),
+    );
     expect(result).to.deep.equal({ data: { sync: 'hello' } });
   });
 });
@@ -257,18 +260,19 @@ describe('subscribe diagnostics channel', () => {
     expect(active.events.map((e) => e.kind)).to.deep.equal(['start', 'end']);
   });
 
-  it('does nothing when no subscribers are attached', async () => {
+  it('does not call tracing methods 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 expectNoTracingActivity(subscribeChannel, async () => {
+      const result = subscribe({
+        schema,
+        document,
+        rootValue: { tick: twoTicks },
+      });
+      const resolved = isPromise(result) ? await result : result;
+      assert(isAsyncIterable(resolved));
       await resolved.return?.();
-    }
+    });
   });
 });
 
@@ -449,14 +453,14 @@ describe('resolve diagnostics channel', () => {
     ]);
   });
 
-  it('does nothing when no subscribers are attached', () => {
-    const result = execute({
-      schema,
-      document: parse('{ sync }'),
-      rootValue: { sync: () => 'hello' },
-    });
-    if (isPromise(result)) {
-      throw new Error('expected sync');
-    }
+  it('does not call tracing methods when no subscribers are attached', async () => {
+    const result = await expectNoTracingActivity(resolveChannel, () =>
+      execute({
+        schema,
+        document: parse('{ sync }'),
+        rootValue: { sync: () => 'hello' },
+      }),
+    );
+    expect(result).to.deep.equal({ data: { sync: 'hello' } });
   });
 });

src/language/__tests__/tracing-test.ts

@@ -3,6 +3,7 @@ import { afterEach, describe, it } from 'mocha';
 
 import {
   collectEvents,
+  expectNoTracingActivity,
   getTracingChannel,
 } from '../../__testUtils__/diagnosticsTestUtils.js';
 
@@ -39,8 +40,10 @@ describe('parse diagnostics channel', () => {
     expect(active.events[1].ctx.error).to.be.instanceOf(Error);
   });
 
-  it('does nothing when no subscribers are attached', () => {
-    const doc = parse('{ field }');
+  it('does not call tracing methods when no subscribers are attached', async () => {
+    const doc = await expectNoTracingActivity(parseChannel, () =>
+      parse('{ field }'),
+    );
     expect(doc.kind).to.equal('Document');
   });
 });

src/validation/__tests__/tracing-test.ts

@@ -3,6 +3,7 @@ import { afterEach, describe, it } from 'mocha';
 
 import {
   collectEvents,
+  expectNoTracingActivity,
   getTracingChannel,
 } from '../../__testUtils__/diagnosticsTestUtils.js';
 
@@ -64,8 +65,10 @@ describe('validate diagnostics channel', () => {
     expect(active.events[1].ctx.error).to.be.instanceOf(Error);
   });
 
-  it('does nothing when no subscribers are attached', () => {
-    const errors = validate(schema, parse('{ field }'));
+  it('does not call tracing methods when no subscribers are attached', async () => {
+    const errors = await expectNoTracingActivity(validateChannel, () =>
+      validate(schema, parse('{ field }')),
+    );
     expect(errors).to.deep.equal([]);
   });
 });