add tests

Author: s1gr1d

packages/core/test/lib/instrument/console-lambda.test.ts

@@ -0,0 +1,143 @@
+// Set LAMBDA_TASK_ROOT before any imports so instrumentConsole uses patchWithDefineProperty
+process.env.LAMBDA_TASK_ROOT = '/var/task';
+
+import { afterAll, describe, expect, it, vi } from 'vitest';
+import { addConsoleInstrumentationHandler } from '../../../src/instrument/console';
+import type { WrappedFunction } from '../../../src/types-hoist/wrappedfunction';
+import { consoleSandbox, originalConsoleMethods } from '../../../src/utils/debug-logger';
+import { markFunctionWrapped } from '../../../src/utils/object';
+import { GLOBAL_OBJ } from '../../../src/utils/worldwide';
+
+afterAll(() => {
+  delete process.env.LAMBDA_TASK_ROOT;
+});
+
+describe('addConsoleInstrumentationHandler in Lambda (patchWithDefineProperty)', () => {
+  it('calls registered handler when console.log is called', () => {
+    const handler = vi.fn();
+    addConsoleInstrumentationHandler(handler);
+
+    GLOBAL_OBJ.console.log('test');
+
+    expect(handler).toHaveBeenCalledWith(expect.objectContaining({ args: ['test'], level: 'log' }));
+  });
+
+  describe('external replacement (e.g. Lambda runtime overwriting console)', () => {
+    it('keeps firing the handler after console.log is replaced externally', () => {
+      const handler = vi.fn();
+      addConsoleInstrumentationHandler(handler);
+
+      GLOBAL_OBJ.console.log = vi.fn();
+      handler.mockClear();
+
+      GLOBAL_OBJ.console.log('after replacement');
+
+      expect(handler).toHaveBeenCalledWith(expect.objectContaining({ args: ['after replacement'], level: 'log' }));
+    });
+
+    it('calls the external replacement as the underlying method', () => {
+      addConsoleInstrumentationHandler(vi.fn());
+
+      const lambdaLogger = vi.fn();
+      GLOBAL_OBJ.console.log = lambdaLogger;
+
+      GLOBAL_OBJ.console.log('hello');
+
+      expect(lambdaLogger).toHaveBeenCalledWith('hello');
+    });
+
+    it('always delegates to the latest replacement', () => {
+      addConsoleInstrumentationHandler(vi.fn());
+
+      const first = vi.fn();
+      const second = vi.fn();
+
+      GLOBAL_OBJ.console.log = first;
+      GLOBAL_OBJ.console.log = second;
+
+      GLOBAL_OBJ.console.log('latest');
+
+      expect(first).not.toHaveBeenCalled();
+      expect(second).toHaveBeenCalledWith('latest');
+    });
+
+    it('updates originalConsoleMethods to point to the replacement', () => {
+      addConsoleInstrumentationHandler(vi.fn());
+
+      const lambdaLogger = vi.fn();
+      GLOBAL_OBJ.console.log = lambdaLogger;
+
+      expect(originalConsoleMethods.log).toBe(lambdaLogger);
+    });
+  });
+
+  describe('__sentry_original__ detection', () => {
+    it('accepts a function with __sentry_original__ without re-wrapping', () => {
+      const handler = vi.fn();
+      addConsoleInstrumentationHandler(handler);
+
+      const otherWrapper = vi.fn();
+      markFunctionWrapped(otherWrapper as unknown as WrappedFunction, vi.fn() as unknown as WrappedFunction);
+
+      GLOBAL_OBJ.console.log = otherWrapper;
+
+      expect(GLOBAL_OBJ.console.log).toBe(otherWrapper);
+    });
+
+    it('does not fire our handler when a __sentry_original__ wrapper is installed', () => {
+      const handler = vi.fn();
+      addConsoleInstrumentationHandler(handler);
+
+      const otherWrapper = vi.fn();
+      markFunctionWrapped(otherWrapper as unknown as WrappedFunction, vi.fn() as unknown as WrappedFunction);
+
+      GLOBAL_OBJ.console.log = otherWrapper;
+      handler.mockClear();
+
+      GLOBAL_OBJ.console.log('via other wrapper');
+
+      expect(handler).not.toHaveBeenCalled();
+      expect(otherWrapper).toHaveBeenCalledWith('via other wrapper');
+    });
+
+    it('re-wraps a plain function without __sentry_original__', () => {
+      const handler = vi.fn();
+      addConsoleInstrumentationHandler(handler);
+
+      GLOBAL_OBJ.console.log = vi.fn();
+      handler.mockClear();
+
+      GLOBAL_OBJ.console.log('plain');
+
+      expect(handler).toHaveBeenCalledWith(expect.objectContaining({ args: ['plain'], level: 'log' }));
+    });
+  });
+
+  describe('consoleSandbox interaction', () => {
+    it('does not fire the handler inside consoleSandbox', () => {
+      const handler = vi.fn();
+      addConsoleInstrumentationHandler(handler);
+      handler.mockClear();
+
+      consoleSandbox(() => {
+        GLOBAL_OBJ.console.log('sandbox message');
+      });
+
+      expect(handler).not.toHaveBeenCalled();
+    });
+
+    it('resumes firing the handler after consoleSandbox returns', () => {
+      const handler = vi.fn();
+      addConsoleInstrumentationHandler(handler);
+
+      consoleSandbox(() => {
+        GLOBAL_OBJ.console.log('inside sandbox');
+      });
+      handler.mockClear();
+
+      GLOBAL_OBJ.console.log('after sandbox');
+
+      expect(handler).toHaveBeenCalledWith(expect.objectContaining({ args: ['after sandbox'], level: 'log' }));
+    });
+  });
+});

packages/core/test/lib/instrument/console.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it, vi } from 'vitest';
+import { addConsoleInstrumentationHandler } from '../../../src/instrument/console';
+import { GLOBAL_OBJ } from '../../../src/utils/worldwide';
+
+describe('addConsoleInstrumentationHandler', () => {
+  it.each(['log', 'warn', 'error', 'debug', 'info'] as const)(
+    'calls registered handler when console.%s is called',
+    level => {
+      const handler = vi.fn();
+      addConsoleInstrumentationHandler(handler);
+
+      GLOBAL_OBJ.console[level]('test message');
+
+      expect(handler).toHaveBeenCalledWith(expect.objectContaining({ args: ['test message'], level }));
+    },
+  );
+
+  it('calls through to the underlying console method without throwing', () => {
+    addConsoleInstrumentationHandler(vi.fn());
+    expect(() => GLOBAL_OBJ.console.log('hello')).not.toThrow();
+  });
+});