test(catcher): Catcher beforeSend feature tests unified

Author: Reversean

packages/javascript/tests/before-send.test.ts

@@ -0,0 +1,150 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createCatcher, createTransport, wait, getLastPayload } from './catcher.helpers';
+
+describe('Catcher', () => {
+  it('should send event as-is when beforeSend returns it unchanged', async () => {
+    const { sendSpy, transport } = createTransport();
+    const hawk = createCatcher(transport, { beforeSend: (event) => event });
+
+    hawk.send(new Error('hello'));
+    await wait();
+
+    expect(sendSpy).toHaveBeenCalledOnce();
+    expect(getLastPayload(sendSpy).title).toBe('hello');
+  });
+
+  it('should send modified event when beforeSend mutates and returns it', async () => {
+    const { sendSpy, transport } = createTransport();
+    const hawk = createCatcher(transport, {
+      beforeSend: (event) => {
+        event.context = { sanitized: true };
+
+        return event;
+      },
+    });
+
+    hawk.send(new Error('modify'));
+    await wait();
+
+    expect(sendSpy).toHaveBeenCalledOnce();
+    expect(getLastPayload(sendSpy).context).toEqual({ sanitized: true });
+  });
+
+  it('should not send event when beforeSend returns false', async () => {
+    const { sendSpy, transport } = createTransport();
+    const hawk = createCatcher(transport, { beforeSend: () => false });
+
+    hawk.send(new Error('drop'));
+    await wait();
+
+    expect(sendSpy).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    { label: 'undefined', value: undefined },
+    { label: 'null', value: null },
+    { label: 'number (42)', value: 42 },
+    { label: 'string ("oops")', value: 'oops' },
+    { label: 'true', value: true },
+  ])('should send original event when beforeSend returns $label', async ({ value }) => {
+    const { sendSpy, transport } = createTransport();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const hawk = createCatcher(transport, { beforeSend: () => value as any });
+
+    hawk.send(new Error('invalid'));
+    await wait();
+
+    expect(sendSpy).toHaveBeenCalledOnce();
+    expect(getLastPayload(sendSpy).title).toBe('invalid');
+  });
+
+  it('should send original event when beforeSend deletes required field (title)', async () => {
+    const { sendSpy, transport } = createTransport();
+    const hawk = createCatcher(transport, {
+      beforeSend: (event) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        delete (event as any).title;
+
+        return event;
+      },
+    });
+
+    hawk.send(new Error('required-field'));
+    await wait();
+
+    expect(sendSpy).toHaveBeenCalledOnce();
+    expect(getLastPayload(sendSpy).title).toBe('required-field');
+  });
+
+  it('should still send event when structuredClone throws (non-cloneable payload)', async () => {
+    const { sendSpy, transport } = createTransport();
+    const hawk = createCatcher(transport, { beforeSend: (event) => event });
+    const cloneSpy = vi.spyOn(globalThis, 'structuredClone').mockImplementation(() => {
+      throw new DOMException('could not be cloned', 'DataCloneError');
+    });
+
+    hawk.send(new Error('non-cloneable'));
+    await wait();
+
+    expect(sendSpy).toHaveBeenCalledOnce();
+    expect(getLastPayload(sendSpy).title).toBe('non-cloneable');
+
+    cloneSpy.mockRestore();
+  });
+
+  it('should send event without deleted optional fields', async () => {
+    const { sendSpy, transport } = createTransport();
+    const hawk = createCatcher(transport, {
+      beforeSend: (event) => {
+        delete event.release;
+
+        return event;
+      },
+    });
+
+    hawk.send(new Error('optional'));
+    await wait();
+
+    expect(sendSpy).toHaveBeenCalledOnce();
+    expect(getLastPayload(sendSpy).release).toBeUndefined();
+  });
+
+  it('should not throw when beforeSend throws unexpectedly', async () => {
+    const { transport } = createTransport();
+
+    const act = async () => {
+      createCatcher(transport, {
+        beforeSend: () => { throw new Error('beforeSend crashed'); },
+      } as never).send(new Error('e'));
+      await wait();
+    };
+
+    await expect(act()).resolves.toBeUndefined();
+  });
+
+  it('should send original event unchanged when beforeSend mutates clone and returns undefined', async () => {
+    const { sendSpy, transport } = createTransport();
+    const hawk = createCatcher(transport, {
+      beforeSend: (event) => { (event as any).title = 'mutated'; return undefined as any; },
+    });
+
+    hawk.send(new Error('original'));
+    await wait();
+
+    expect(sendSpy).toHaveBeenCalledOnce();
+    expect(getLastPayload(sendSpy).title).toBe('original');
+  });
+
+  it('should send new event object when beforeSend returns a brand-new object', async () => {
+    const { sendSpy, transport } = createTransport();
+    const hawk = createCatcher(transport, {
+      beforeSend: (event) => ({ ...event, title: 'brand new title' }),
+    });
+
+    hawk.send(new Error('original'));
+    await wait();
+
+    expect(sendSpy).toHaveBeenCalledOnce();
+    expect(getLastPayload(sendSpy).title).toBe('brand new title');
+  });
+});

packages/javascript/tests/catcher.before-send.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { BreadcrumbManager } from '../src/addons/breadcrumbs';
 import type { Transport } from '../src';
-import { wait, createTransport, createCatcher } from './catcher.helpers';
+import { wait, createCatcher, createTransport } from './catcher.helpers';
 
 const mockParse = vi.hoisted(() => vi.fn().mockResolvedValue([]));
 vi.mock('../src/modules/stackParser', () => ({
@@ -15,7 +15,6 @@ describe('Catcher', () => {
     (BreadcrumbManager as any).instance = null;
   });
 
-  // ── Transport failure ─────────────────────────────────────────────────────
   describe('transport failure', () => {
     it('should not throw when transport.send rejects', async () => {
       const transport: Transport = {
@@ -29,18 +28,5 @@ describe('Catcher', () => {
 
       await expect(act()).resolves.toBeUndefined();
     });
-
-    it('should not throw when beforeSend throws unexpectedly', async () => {
-      const { transport } = createTransport();
-
-      const act = async () => {
-        createCatcher(transport, {
-          beforeSend: () => { throw new Error('beforeSend crashed'); },
-        } as never).send(new Error('e'));
-        await wait();
-      };
-
-      await expect(act()).resolves.toBeUndefined();
-    });
   });
 });