@littlebearapps/platform-admin-sdk 1.5.0 → 2.0.0

package/templates/standard/tests/unit/error-collector/capture.test.ts

@@ -0,0 +1,106 @@
+/**
+ * Unit Tests for Error Capture Logic
+ *
+ * Covers:
+ * - shouldCapture() filtering logic
+ * - Outcome handling for all 7 non-OK outcomes
+ * - Deduplication via KV fingerprint keys
+ */
+
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { createMockKV } from '../../../tests/helpers/mock-kv';
+import { MockD1Database } from '../../../tests/helpers/mock-d1';
+
+vi.mock('@littlebearapps/platform-consumer-sdk', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    createLoggerFromEnv: () => ({
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+    }),
+  };
+});
+
+import { shouldCapture } from '../../../workers/lib/error-collector/capture';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function createTailEvent(overrides: Record<string, unknown> = {}) {
+  return {
+    scriptName: 'test-worker',
+    outcome: 'exception',
+    exceptions: [{ name: 'Error', message: 'Test error' }],
+    logs: [],
+    eventTimestamp: Date.now(),
+    ...overrides,
+  };
+}
+
+// ===========================================================================
+// shouldCapture
+// ===========================================================================
+
+describe('shouldCapture', () => {
+  it('captures exception outcomes', () => {
+    const event = createTailEvent({ outcome: 'exception' });
+    expect(shouldCapture(event as never)).toBe(true);
+  });
+
+  it('captures exceededCpu outcomes', () => {
+    const event = createTailEvent({ outcome: 'exceededCpu' });
+    expect(shouldCapture(event as never)).toBe(true);
+  });
+
+  it('captures exceededMemory outcomes', () => {
+    const event = createTailEvent({ outcome: 'exceededMemory' });
+    expect(shouldCapture(event as never)).toBe(true);
+  });
+
+  it('captures canceled outcomes', () => {
+    const event = createTailEvent({ outcome: 'canceled' });
+    expect(shouldCapture(event as never)).toBe(true);
+  });
+
+  it('captures responseStreamDisconnected outcomes', () => {
+    const event = createTailEvent({ outcome: 'responseStreamDisconnected' });
+    expect(shouldCapture(event as never)).toBe(true);
+  });
+
+  it('captures scriptNotFound outcomes', () => {
+    const event = createTailEvent({ outcome: 'scriptNotFound' });
+    expect(shouldCapture(event as never)).toBe(true);
+  });
+
+  it('does not capture ok outcomes without error logs', () => {
+    const event = createTailEvent({ outcome: 'ok', exceptions: [], logs: [] });
+    expect(shouldCapture(event as never)).toBe(false);
+  });
+
+  it('captures ok outcomes with error-level logs (soft errors)', () => {
+    const event = createTailEvent({
+      outcome: 'ok',
+      exceptions: [],
+      logs: [{ level: 'error', message: ['Something failed'], timestamp: Date.now() }],
+    });
+    expect(shouldCapture(event as never)).toBe(true);
+  });
+
+  it('captures ok outcomes with warning-level logs', () => {
+    const event = createTailEvent({
+      outcome: 'ok',
+      exceptions: [],
+      logs: [{ level: 'warn', message: ['Deprecation warning'], timestamp: Date.now() }],
+    });
+    expect(shouldCapture(event as never)).toBe(true);
+  });
+
+  it('ignores events without scriptName', () => {
+    const event = createTailEvent({ scriptName: undefined, outcome: 'exception' });
+    expect(shouldCapture(event as never)).toBe(false);
+  });
+});

package/templates/standard/tests/unit/error-collector/fingerprint.test.ts

@@ -0,0 +1,155 @@
+/**
+ * Unit Tests for Error Fingerprinting
+ *
+ * Covers:
+ * - Error classification by outcome type
+ * - Transient error detection (quota, rate-limit, timeout)
+ * - Message normalisation (variable stripping)
+ * - Fingerprint stability (same error = same fingerprint)
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+
+vi.mock('@littlebearapps/platform-consumer-sdk', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    createLoggerFromEnv: () => ({
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+    }),
+  };
+});
+
+import {
+  classifyError,
+  generateFingerprint,
+  normalizeMessage,
+  isTransientError,
+} from '../../../workers/lib/error-collector/fingerprint';
+
+// ===========================================================================
+// Classification
+// ===========================================================================
+
+describe('classifyError', () => {
+  it('classifies exception as P0-P2 based on severity', () => {
+    const result = classifyError({
+      outcome: 'exception',
+      scriptName: 'test-worker',
+      message: 'Uncaught ReferenceError: foo is not defined',
+      logs: [],
+    } as never);
+
+    expect(result).toBeDefined();
+    expect(['P0', 'P1', 'P2']).toContain(result.priority);
+  });
+
+  it('classifies exceededCpu as P0', () => {
+    const result = classifyError({
+      outcome: 'exceededCpu',
+      scriptName: 'test-worker',
+      message: 'Worker exceeded CPU time limit',
+      logs: [],
+    } as never);
+
+    expect(result.priority).toBe('P0');
+  });
+
+  it('classifies canceled as P2', () => {
+    const result = classifyError({
+      outcome: 'canceled',
+      scriptName: 'test-worker',
+      message: 'Request was canceled',
+      logs: [],
+    } as never);
+
+    expect(result.priority).toBe('P2');
+  });
+
+  it('classifies soft_error from logs as P2-P3', () => {
+    const result = classifyError({
+      outcome: 'ok',
+      scriptName: 'test-worker',
+      message: 'Soft error captured via console.error',
+      logs: [{ level: 'error', message: ['Something failed'] }],
+    } as never);
+
+    expect(['P2', 'P3']).toContain(result.priority);
+  });
+});
+
+// ===========================================================================
+// Transient Detection
+// ===========================================================================
+
+describe('isTransientError', () => {
+  it('detects quota-exhausted as transient', () => {
+    expect(isTransientError('D1_ERROR: too many requests (quota exhausted)')).toBe(true);
+  });
+
+  it('detects rate-limited as transient', () => {
+    expect(isTransientError('Rate limited: try again in 30 seconds')).toBe(true);
+  });
+
+  it('detects timeout as transient', () => {
+    expect(isTransientError('Network request timed out after 30000ms')).toBe(true);
+  });
+
+  it('does not flag regular errors as transient', () => {
+    expect(isTransientError('TypeError: Cannot read property of null')).toBe(false);
+  });
+});
+
+// ===========================================================================
+// Message Normalisation
+// ===========================================================================
+
+describe('normalizeMessage', () => {
+  it('strips UUIDs from messages', () => {
+    const result = normalizeMessage('Error for user a1b2c3d4-e5f6-7890-abcd-ef1234567890');
+    expect(result).not.toContain('a1b2c3d4');
+    expect(result).toContain('<UUID>');
+  });
+
+  it('strips numeric IDs from messages', () => {
+    const result = normalizeMessage('Failed to process request 1234567890');
+    expect(result).not.toContain('1234567890');
+  });
+
+  it('strips timestamps from messages', () => {
+    const result = normalizeMessage('Error at 2026-03-05T12:00:00Z in handler');
+    expect(result).not.toContain('2026-03-05');
+  });
+
+  it('preserves error type prefixes', () => {
+    const result = normalizeMessage('TypeError: Cannot read property of null');
+    expect(result).toContain('TypeError');
+  });
+});
+
+// ===========================================================================
+// Fingerprint Stability
+// ===========================================================================
+
+describe('generateFingerprint', () => {
+  it('produces consistent fingerprint for same error', () => {
+    const fp1 = generateFingerprint('test-worker', 'TypeError: Cannot read property of null');
+    const fp2 = generateFingerprint('test-worker', 'TypeError: Cannot read property of null');
+    expect(fp1).toBe(fp2);
+  });
+
+  it('produces different fingerprints for different errors', () => {
+    const fp1 = generateFingerprint('test-worker', 'TypeError: Cannot read property of null');
+    const fp2 = generateFingerprint('test-worker', 'RangeError: Maximum call stack exceeded');
+    expect(fp1).not.toBe(fp2);
+  });
+
+  it('produces different fingerprints for different workers', () => {
+    const fp1 = generateFingerprint('worker-a', 'Error: timeout');
+    const fp2 = generateFingerprint('worker-b', 'Error: timeout');
+    expect(fp1).not.toBe(fp2);
+  });
+});