revamp diagnostics tests with full subscription data

Author: yaacovCR

src/__testUtils__/__tests__/catchThrownError-test.ts

@@ -0,0 +1,22 @@
+import { expect } from 'chai';
+import { describe, it } from 'mocha';
+
+import { catchThrownError } from '../catchThrownError.js';
+
+describe('catchThrownError', () => {
+  it('returns the thrown value', () => {
+    const error = new Error('boom');
+
+    expect(
+      catchThrownError(() => {
+        throw error;
+      }),
+    ).to.equal(error);
+  });
+
+  it('throws when the function does not throw', () => {
+    expect(() => catchThrownError(() => undefined)).to.throw(
+      'Expected function to throw.',
+    );
+  });
+});

src/__testUtils__/__tests__/expectEvents-test.ts

@@ -0,0 +1,128 @@
+import { expect } from 'chai';
+import { describe, it } from 'mocha';
+
+import { expectEvents } from '../expectEvents.js';
+import { expectPromise } from '../expectPromise.js';
+
+type TestTracingChannel = Parameters<typeof expectEvents>[0];
+
+function createFakeTracingChannel(): TestTracingChannel {
+  let handler:
+    | {
+        start: (context: unknown) => void;
+        end: (context: unknown) => void;
+        asyncStart: (context: unknown) => void;
+        asyncEnd: (context: unknown) => void;
+        error: (context: unknown) => void;
+      }
+    | undefined;
+
+  function runStores<T>(
+    context: object,
+    fn: (this: object, ...args: Array<unknown>) => T,
+    thisArg?: unknown,
+    ...args: Array<unknown>
+  ): T {
+    return fn.apply((thisArg as object | undefined) ?? context, args);
+  }
+
+  return {
+    hasSubscribers: false,
+    subscribe(nextHandler) {
+      handler = nextHandler;
+    },
+    unsubscribe(nextHandler) {
+      expect(handler).to.equal(nextHandler);
+      handler = undefined;
+    },
+    traceSync(fn, _context, thisArg, ...args) {
+      return fn.apply(thisArg, args);
+    },
+    start: {
+      publish(context) {
+        handler?.start(context);
+      },
+      runStores,
+    },
+    end: {
+      publish(context) {
+        handler?.end(context);
+      },
+      runStores,
+    },
+    asyncStart: {
+      publish(context) {
+        handler?.asyncStart(context);
+      },
+      runStores,
+    },
+    asyncEnd: {
+      publish(context) {
+        handler?.asyncEnd(context);
+      },
+      runStores,
+    },
+    error: {
+      publish(context) {
+        handler?.error(context);
+      },
+      runStores,
+    },
+  };
+}
+
+describe('expectEvents', () => {
+  it('collects events and snapshots each published context', async () => {
+    const channel = createFakeTracingChannel();
+    const context = { value: 1 };
+
+    await expectEvents(
+      channel,
+      () => {
+        channel.start.publish(context);
+        context.value = 2;
+        channel.end.publish(context);
+        return 'done';
+      },
+      (_result) => [
+        {
+          channel: 'start',
+          context: { value: 1 },
+        },
+        {
+          channel: 'end',
+          context: { value: 2 },
+        },
+      ],
+    );
+  });
+
+  it('unsubscribes when the callback rejects', async () => {
+    let activeHandler: object | undefined;
+    const error = new Error('boom');
+    const channel = createFakeTracingChannel();
+    const originalSubscribe = channel.subscribe;
+    const originalUnsubscribe = channel.unsubscribe;
+
+    channel.subscribe = (handler) => {
+      activeHandler = handler;
+      originalSubscribe.call(channel, handler);
+    };
+    channel.unsubscribe = (handler) => {
+      expect(handler).to.equal(activeHandler);
+      activeHandler = undefined;
+      originalUnsubscribe.call(channel, handler);
+    };
+
+    expect(
+      await expectPromise(
+        expectEvents(
+          channel,
+          () => Promise.reject(error),
+          () => [],
+        ),
+      ).toReject(),
+    ).to.equal(error);
+    expect(activeHandler).to.equal(undefined);
+  });
+});

src/__testUtils__/__tests__/expectNoTracingActivity-test.ts

@@ -0,0 +1,78 @@
+import { expect } from 'chai';
+import { describe, it } from 'mocha';
+
+import { expectNoTracingActivity } from '../expectNoTracingActivity.js';
+import { expectPromise } from '../expectPromise.js';
+
+type TestTracingChannel = Parameters<typeof expectNoTracingActivity>[0];
+
+function createFakeTracingChannel(): TestTracingChannel {
+  function runStores<T>(
+    context: object,
+    fn: (this: object, ...args: Array<unknown>) => T,
+    thisArg?: unknown,
+    ...args: Array<unknown>
+  ): T {
+    return fn.apply((thisArg as object | undefined) ?? context, args);
+  }
+
+  return {
+    hasSubscribers: false,
+    traceSync(fn, context, thisArg, ...args) {
+      return runStores(context, fn, thisArg, ...args);
+    },
+    start: {
+      publish(_context) {
+        return undefined;
+      },
+      runStores,
+    },
+    end: {
+      publish(_context) {
+        return undefined;
+      },
+      runStores,
+    },
+    asyncStart: {
+      publish(_context) {
+        return undefined;
+      },
+      runStores,
+    },
+    asyncEnd: {
+      publish(_context) {
+        return undefined;
+      },
+      runStores,
+    },
+    error: {
+      publish(_context) {
+        return undefined;
+      },
+      runStores,
+    },
+  };
+}
+
+describe('expectNoTracingActivity', () => {
+  it('returns the callback result when no tracing methods are touched', async () => {
+    const channel = createFakeTracingChannel();
+
+    expect(
+      await expectNoTracingActivity(channel, () => ({ value: 'ok' })),
+    ).to.deep.equal({ value: 'ok' });
+  });
+
+  it('fails and restores methods when tracing activity occurs', async () => {
+    const channel = createFakeTracingChannel();
+    const originalPublish = channel.start.publish;
+
+    await expectPromise(
+      expectNoTracingActivity(channel, () => {
+        channel.start.publish({ value: 1 });
+      }),
+    ).toRejectWith("expected [ 'start.publish' ] to deeply equal []");
+
+    expect(channel.start.publish).to.equal(originalPublish);
+  });
+});

src/__testUtils__/__tests__/interceptMethod-test.ts

@@ -0,0 +1,52 @@
+import { expect } from 'chai';
+import { describe, it } from 'mocha';
+
+import { interceptMethod } from '../interceptMethod.js';
+
+describe('interceptMethod', () => {
+  it('wraps a method and preserves this binding', () => {
+    const calls: Array<number> = [];
+    const target = {
+      value: 3,
+      add(delta: number): number {
+        return this.value + delta;
+      },
+    };
+
+    const restore = interceptMethod(
+      target,
+      'add',
+      (original) =>
+        function interceptedAdd(this: unknown, ...args: Array<unknown>) {
+          const [delta] = args as [number];
+          calls.push(delta);
+          return original.call(this, delta * 2);
+        },
+    );
+
+    expect(target.add(4)).to.equal(11);
+    expect(calls).to.deep.equal([4]);
+
+    restore();
+
+    expect(target.add(4)).to.equal(7);
+  });
+
+  it('restores the original method', () => {
+    const target = {
+      value(): string {
+        return 'original';
+      },
+    };
+    const original = target.value;
+
+    const restore = interceptMethod(target, 'value', () => () => 'wrapped');
+
+    expect(target.value()).to.equal('wrapped');
+
+    restore();
+
+    expect(target.value).to.equal(original);
+    expect(target.value()).to.equal('original');
+  });
+});

src/__testUtils__/catchThrownError.ts

@@ -0,0 +1,9 @@
+export function catchThrownError(fn: () => unknown): unknown {
+  try {
+    fn();
+  } catch (error) {
+    return error;
+  }
+
+  throw new Error('Expected function to throw.');
+}