@planet-matrix/mobius-model 0.5.0 → 0.9.0

package/tests/unit/exception/browser.spec.ts

@@ -0,0 +1,213 @@
+import { afterEach, expect, test, vi } from "vitest"
+
+import {
+  observeBrowserExceptions,
+  onBrowserGlobalError,
+  onBrowserUnhandledRejection,
+  onBrowserWindowOnError,
+} from "#Source/exception/index.ts"
+
+class WindowMock extends EventTarget {
+  onerror: OnErrorEventHandler | null = null
+  document = {}
+}
+
+const createBrowserErrorEvent = (options: {
+  message: string
+  filename?: string | undefined
+  lineno?: number | undefined
+  colno?: number | undefined
+  error?: unknown
+}): Event => {
+  const event = new Event("error")
+  Object.defineProperties(event, {
+    message: { value: options.message, configurable: true },
+    filename: { value: options.filename, configurable: true },
+    lineno: { value: options.lineno, configurable: true },
+    colno: { value: options.colno, configurable: true },
+    error: { value: options.error, configurable: true },
+  })
+  return event
+}
+
+const createBrowserUnhandledRejectionEvent = (options: {
+  reason: unknown
+  promise: Promise<unknown>
+}): Event => {
+  const event = new Event("unhandledrejection")
+  Object.defineProperties(event, {
+    reason: { value: options.reason, configurable: true },
+    promise: { value: options.promise, configurable: true },
+  })
+  return event
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+  vi.restoreAllMocks()
+})
+
+test("onBrowserGlobalError listens and cleans up window error events", () => {
+  const browserWindow = new WindowMock()
+  const listener = vi.fn()
+  vi.stubGlobal("window", browserWindow)
+  vi.stubGlobal("self", browserWindow)
+  vi.stubGlobal("document", browserWindow.document)
+
+  const cleanup = onBrowserGlobalError(listener)
+  const event = createBrowserErrorEvent({
+    message: "boom",
+    filename: "app.ts",
+    lineno: 8,
+    colno: 9,
+    error: new Error("boom"),
+  })
+  browserWindow.dispatchEvent(event)
+
+  expect(listener).toHaveBeenCalledTimes(1)
+  expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+    runtime: "browser",
+    source: "browser.global-error",
+    message: "boom",
+    filename: "app.ts",
+    lineno: 8,
+    colno: 9,
+  }))
+
+  cleanup()
+  browserWindow.dispatchEvent(event)
+  expect(listener).toHaveBeenCalledTimes(1)
+})
+
+test("onBrowserWindowOnError composes listeners and restores window.onerror after the last cleanup", () => {
+  const browserWindow = new WindowMock()
+  const previousOnError = vi.fn(() => false)
+  const listener1 = vi.fn()
+  const listener2 = vi.fn()
+  // oxlint-disable-next-line prefer-add-event-listener
+  browserWindow.onerror = previousOnError
+  vi.stubGlobal("window", browserWindow)
+  vi.stubGlobal("self", browserWindow)
+  vi.stubGlobal("document", browserWindow.document)
+
+  const cleanup1 = onBrowserWindowOnError(listener1)
+  const cleanup2 = onBrowserWindowOnError(listener2)
+  browserWindow.onerror?.("boom", "app.ts", 3, 5, new Error("boom"))
+
+  expect(listener1).toHaveBeenCalledTimes(1)
+  expect(listener1).toHaveBeenCalledWith(expect.objectContaining({
+    runtime: "browser",
+    source: "browser.window-onerror",
+    filename: "app.ts",
+    lineno: 3,
+    colno: 5,
+  }))
+  expect(listener2).toHaveBeenCalledTimes(1)
+  expect(listener2).toHaveBeenCalledWith(expect.objectContaining({
+    runtime: "browser",
+    source: "browser.window-onerror",
+    filename: "app.ts",
+    lineno: 3,
+    colno: 5,
+  }))
+  expect(previousOnError).toHaveBeenCalledTimes(1)
+
+  cleanup1()
+  browserWindow.onerror?.("again", "next.ts", 7, 11, new Error("again"))
+
+  expect(listener1).toHaveBeenCalledTimes(1)
+  expect(listener2).toHaveBeenCalledTimes(2)
+  expect(previousOnError).toHaveBeenCalledTimes(2)
+
+  cleanup2()
+  expect(browserWindow.onerror).toBe(previousOnError)
+})
+
+test("onBrowserUnhandledRejection listens and cleans up promise rejection events", () => {
+  const browserWindow = new WindowMock()
+  const listener = vi.fn()
+  vi.stubGlobal("window", browserWindow)
+  vi.stubGlobal("self", browserWindow)
+  vi.stubGlobal("document", browserWindow.document)
+
+  const cleanup = onBrowserUnhandledRejection(listener)
+  const promise = Promise.resolve("ok")
+  const rejectionEvent = createBrowserUnhandledRejectionEvent({
+    promise,
+    reason: new Error("reject"),
+  })
+  browserWindow.dispatchEvent(rejectionEvent)
+
+  expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+    runtime: "browser",
+    source: "browser.unhandled-rejection",
+    message: "reject",
+  }))
+
+  cleanup()
+  browserWindow.dispatchEvent(rejectionEvent)
+  expect(listener).toHaveBeenCalledTimes(1)
+})
+
+test("observeBrowserExceptions listens to all browser sources by default and supports explicit opt-out", () => {
+  const browserWindow = new WindowMock()
+  const listener = vi.fn()
+  vi.stubGlobal("window", browserWindow)
+  vi.stubGlobal("self", browserWindow)
+  vi.stubGlobal("document", browserWindow.document)
+
+  const cleanup1 = observeBrowserExceptions(listener, {
+    captureTimestamp: () => 777,
+  })
+  const promise = Promise.resolve("ok")
+
+  browserWindow.dispatchEvent(createBrowserErrorEvent({
+    message: "again",
+    error: new Error("again"),
+  }))
+  browserWindow.onerror?.("window boom", "page.ts", 1, 2, new Error("window boom"))
+  browserWindow.dispatchEvent(createBrowserUnhandledRejectionEvent({
+    promise,
+    reason: "reason-text",
+  }))
+
+  expect(listener).toHaveBeenCalledTimes(3)
+  expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+    source: "browser.global-error",
+    timestamp: 777,
+  }))
+  expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+    source: "browser.window-onerror",
+    timestamp: 777,
+    filename: "page.ts",
+  }))
+  expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+    source: "browser.unhandled-rejection",
+    timestamp: 777,
+    message: "reason-text",
+  }))
+
+  cleanup1()
+
+  listener.mockClear()
+
+  const cleanup2 = observeBrowserExceptions(listener, {
+    includeWindowOnError: false,
+  })
+  browserWindow.dispatchEvent(createBrowserErrorEvent({
+    message: "still-on",
+    error: new Error("still-on"),
+  }))
+  browserWindow.onerror?.("ignored", "page.ts", 1, 2, new Error("ignored"))
+  browserWindow.dispatchEvent(createBrowserUnhandledRejectionEvent({
+    promise,
+    reason: "still-on",
+  }))
+
+  expect(listener).toHaveBeenCalledTimes(2)
+  expect(listener).not.toHaveBeenCalledWith(expect.objectContaining({
+    source: "browser.window-onerror",
+  }))
+
+  cleanup2()
+})

package/tests/unit/exception/nodejs.spec.ts

@@ -0,0 +1,144 @@
+import { afterEach, expect, test, vi } from "vitest"
+
+import {
+  observeNodejsExceptions,
+  onNodejsUncaughtException,
+  onNodejsUncaughtExceptionMonitor,
+  onNodejsUnhandledRejection,
+} from "#Source/exception/index.ts"
+
+class ProcessMock {
+  protected listeners = new Map<string, Set<(...args: unknown[]) => void>>()
+  versions = { node: "20.0.0" }
+
+  on(eventName: string, listener: (...args: unknown[]) => void): this {
+    const eventListeners = this.listeners.get(eventName) ?? new Set()
+    eventListeners.add(listener)
+    this.listeners.set(eventName, eventListeners)
+    return this
+  }
+
+  off(eventName: string, listener: (...args: unknown[]) => void): this {
+    this.listeners.get(eventName)?.delete(listener)
+    return this
+  }
+
+  emit(eventName: string, ...args: unknown[]): void {
+    for (const listener of this.listeners.get(eventName) ?? []) {
+      listener(...args)
+    }
+  }
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+  vi.restoreAllMocks()
+})
+
+test("onNodejsUncaughtExceptionMonitor listens and cleans up monitor events", () => {
+  const mockedProcess = new ProcessMock()
+  const listener = vi.fn()
+  vi.stubGlobal("process", mockedProcess)
+
+  const cleanup = onNodejsUncaughtExceptionMonitor(listener)
+  mockedProcess.emit("uncaughtExceptionMonitor", new Error("boom"), "uncaughtException")
+
+  expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+    runtime: "nodejs",
+    source: "nodejs.uncaught-exception-monitor",
+    message: "boom",
+    origin: "uncaughtException",
+  }))
+
+  cleanup()
+  mockedProcess.emit("uncaughtExceptionMonitor", new Error("boom"), "uncaughtException")
+  expect(listener).toHaveBeenCalledTimes(1)
+})
+
+test("onNodejsUncaughtException normalizes records and cleans up listeners", () => {
+  const mockedProcess = new ProcessMock()
+  const listener = vi.fn()
+  vi.stubGlobal("process", mockedProcess)
+
+  const cleanup = onNodejsUncaughtException(listener)
+
+  mockedProcess.emit("uncaughtException", new Error("broken"), "uncaughtException")
+
+  expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+    source: "nodejs.uncaught-exception",
+    message: "broken",
+    origin: "uncaughtException",
+  }))
+
+  cleanup()
+  mockedProcess.emit("uncaughtException", new Error("ignored"), "uncaughtException")
+  expect(listener).toHaveBeenCalledTimes(1)
+})
+
+test("onNodejsUnhandledRejection normalizes records and cleans up listeners", () => {
+  const mockedProcess = new ProcessMock()
+  const listener = vi.fn()
+  vi.stubGlobal("process", mockedProcess)
+
+  const cleanup = onNodejsUnhandledRejection(listener)
+  const promise = Promise.resolve("ok")
+
+  mockedProcess.emit("unhandledRejection", "reason-text", promise)
+
+  expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+    source: "nodejs.unhandled-rejection",
+    message: "reason-text",
+    promise,
+  }))
+
+  cleanup()
+  mockedProcess.emit("unhandledRejection", "ignored", promise)
+  expect(listener).toHaveBeenCalledTimes(1)
+})
+
+test("observeNodejsExceptions listens to all Node.js sources by default and supports explicit opt-out", () => {
+  const mockedProcess = new ProcessMock()
+  const listener = vi.fn()
+  vi.stubGlobal("process", mockedProcess)
+
+  const cleanup1 = observeNodejsExceptions(listener, {
+    captureTimestamp: () => 456,
+  })
+
+  const promise = Promise.resolve("ok")
+  mockedProcess.emit("uncaughtExceptionMonitor", new Error("watch"), "uncaughtException")
+  mockedProcess.emit("uncaughtException", new Error("boom"), "uncaughtException")
+  mockedProcess.emit("unhandledRejection", new Error("reject"), promise)
+
+  expect(listener).toHaveBeenCalledTimes(3)
+  expect(listener).toHaveBeenNthCalledWith(1, expect.objectContaining({
+    source: "nodejs.uncaught-exception-monitor",
+    timestamp: 456,
+  }))
+  expect(listener).toHaveBeenNthCalledWith(2, expect.objectContaining({
+    source: "nodejs.uncaught-exception",
+    timestamp: 456,
+  }))
+  expect(listener).toHaveBeenNthCalledWith(3, expect.objectContaining({
+    source: "nodejs.unhandled-rejection",
+    timestamp: 456,
+  }))
+
+  cleanup1()
+
+  listener.mockClear()
+
+  const cleanup2 = observeNodejsExceptions(listener, {
+    includeUncaughtExceptionMonitor: false,
+  })
+  mockedProcess.emit("uncaughtExceptionMonitor", new Error("ignored"), "uncaughtException")
+  mockedProcess.emit("uncaughtException", new Error("kept"), "uncaughtException")
+  mockedProcess.emit("unhandledRejection", "kept", promise)
+
+  expect(listener).toHaveBeenCalledTimes(2)
+  expect(listener).not.toHaveBeenCalledWith(expect.objectContaining({
+    source: "nodejs.uncaught-exception-monitor",
+  }))
+
+  cleanup2()
+})

package/tests/unit/exception/normalize.spec.ts

@@ -0,0 +1,57 @@
+import { expect, test, vi } from "vitest"
+
+import {
+  normalizeBrowserExceptionRecord,
+  normalizeExceptionRecord,
+  normalizeNodejsExceptionRecord,
+} from "#Source/exception/index.ts"
+
+test("normalizeExceptionRecord infers message and timestamp", () => {
+  vi.spyOn(Date, "now").mockReturnValue(123)
+
+  const example1 = normalizeExceptionRecord({
+    runtime: "unknown",
+    source: "custom",
+    exception: new Error("boom"),
+  })
+  const example2 = normalizeExceptionRecord({
+    runtime: "unknown",
+    source: "custom",
+    exception: "text-error",
+  })
+
+  expect(example1.message).toBe("boom")
+  expect(example1.timestamp).toBe(123)
+  expect(example2.message).toBe("text-error")
+})
+
+test("normalizeBrowserExceptionRecord preserves browser-specific fields", () => {
+  const example1 = normalizeBrowserExceptionRecord({
+    source: "browser.global-error",
+    exception: new Error("boom"),
+    filename: "app.ts",
+    lineno: 8,
+    colno: 13,
+    timestamp: 10,
+  })
+
+  expect(example1.runtime).toBe("browser")
+  expect(example1.filename).toBe("app.ts")
+  expect(example1.lineno).toBe(8)
+  expect(example1.colno).toBe(13)
+})
+
+test("normalizeNodejsExceptionRecord preserves nodejs-specific fields", () => {
+  const promise = Promise.resolve("ok")
+  const example1 = normalizeNodejsExceptionRecord({
+    source: "nodejs.unhandled-rejection",
+    exception: new Error("boom"),
+    origin: "unhandledRejection",
+    promise,
+    timestamp: 11,
+  })
+
+  expect(example1.runtime).toBe("nodejs")
+  expect(example1.origin).toBe("unhandledRejection")
+  expect(example1.promise).toBe(promise)
+})