@ontrails/core 1.0.0-beta.14 → 1.0.0-beta.16

package/src/__tests__/errors.test.ts

@@ -1,309 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import {
-  TrailsError,
-  ValidationError,
-  AmbiguousError,
-  AssertionError,
-  NotFoundError,
-  AlreadyExistsError,
-  ConflictError,
-  PermissionError,
-  TimeoutError,
-  RateLimitError,
-  NetworkError,
-  InternalError,
-  AuthError,
-  CancelledError,
-  exitCodeMap,
-  statusCodeMap,
-  jsonRpcCodeMap,
-  retryableMap,
-  isRetryable,
-  isTrailsError,
-} from '../errors.js';
-import type { ErrorCategory } from '../errors.js';
-
-// ---------------------------------------------------------------------------
-// Error class matrix
-// ---------------------------------------------------------------------------
-
-const errorMatrix: readonly {
-  Class: new (
-    message: string,
-    options?: { cause?: Error; context?: Record<string, unknown> }
-  ) => TrailsError;
-  category: ErrorCategory;
-  retryable: boolean;
-  name: string;
-}[] = [
-  {
-    Class: ValidationError,
-    category: 'validation',
-    name: 'ValidationError',
-    retryable: false,
-  },
-  {
-    Class: AmbiguousError,
-    category: 'validation',
-    name: 'AmbiguousError',
-    retryable: false,
-  },
-  {
-    Class: AssertionError,
-    category: 'internal',
-    name: 'AssertionError',
-    retryable: false,
-  },
-  {
-    Class: NotFoundError,
-    category: 'not_found',
-    name: 'NotFoundError',
-    retryable: false,
-  },
-  {
-    Class: AlreadyExistsError,
-    category: 'conflict',
-    name: 'AlreadyExistsError',
-    retryable: false,
-  },
-  {
-    Class: ConflictError,
-    category: 'conflict',
-    name: 'ConflictError',
-    retryable: false,
-  },
-  {
-    Class: PermissionError,
-    category: 'permission',
-    name: 'PermissionError',
-    retryable: false,
-  },
-  {
-    Class: TimeoutError,
-    category: 'timeout',
-    name: 'TimeoutError',
-    retryable: true,
-  },
-  {
-    Class: RateLimitError,
-    category: 'rate_limit',
-    name: 'RateLimitError',
-    retryable: true,
-  },
-  {
-    Class: NetworkError,
-    category: 'network',
-    name: 'NetworkError',
-    retryable: true,
-  },
-  {
-    Class: InternalError,
-    category: 'internal',
-    name: 'InternalError',
-    retryable: false,
-  },
-  { Class: AuthError, category: 'auth', name: 'AuthError', retryable: false },
-  {
-    Class: CancelledError,
-    category: 'cancelled',
-    name: 'CancelledError',
-    retryable: false,
-  },
-];
-
-describe('error classes', () => {
-  // oxlint-disable-next-line prefer-each -- describe.each loses type safety on heterogeneous class matrix
-  for (const { Class, category, retryable, name } of errorMatrix) {
-    describe(name, () => {
-      test('sets correct category', () => {
-        const err = new Class('test');
-        expect(err.category).toBe(category);
-      });
-
-      test('sets correct retryable', () => {
-        const err = new Class('test');
-        expect(err.retryable).toBe(retryable);
-      });
-
-      test('sets message', () => {
-        const err = new Class('something went wrong');
-        expect(err.message).toBe('something went wrong');
-      });
-
-      test('sets name to constructor name', () => {
-        const err = new Class('test');
-        expect(err.name).toBe(name);
-      });
-
-      test('sets cause when provided', () => {
-        const cause = new Error('root cause');
-        const err = new Class('test', { cause });
-        expect(err.cause).toBe(cause);
-      });
-
-      test('sets context when provided', () => {
-        const ctx = { action: 'delete', userId: 'u_123' };
-        const err = new Class('test', { context: ctx });
-        expect(err.context).toEqual(ctx);
-      });
-
-      test('context is undefined when not provided', () => {
-        const err = new Class('test');
-        expect(err.context).toBeUndefined();
-      });
-
-      test('is instanceof TrailsError', () => {
-        const err = new Class('test');
-        expect(err).toBeInstanceOf(TrailsError);
-      });
-
-      test('is instanceof Error', () => {
-        const err = new Class('test');
-        expect(err).toBeInstanceOf(Error);
-      });
-
-      test('is instanceof its own class', () => {
-        const err = new Class('test');
-        expect(err).toBeInstanceOf(Class);
-      });
-    });
-  }
-});
-
-// ---------------------------------------------------------------------------
-// RateLimitError.retryAfter
-// ---------------------------------------------------------------------------
-
-describe('RateLimitError.retryAfter', () => {
-  test('stores retryAfter when provided', () => {
-    const err = new RateLimitError('slow down', { retryAfter: 30 });
-    expect(err.retryAfter).toBe(30);
-  });
-
-  test('retryAfter is undefined when not provided', () => {
-    const err = new RateLimitError('slow down');
-    expect(err.retryAfter).toBeUndefined();
-  });
-
-  test('retryAfter coexists with cause and context', () => {
-    const cause = new Error('upstream');
-    const err = new RateLimitError('slow down', {
-      cause,
-      context: { endpoint: '/api' },
-      retryAfter: 60,
-    });
-    expect(err.retryAfter).toBe(60);
-    expect(err.cause).toBe(cause);
-    expect(err.context).toEqual({ endpoint: '/api' });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Taxonomy maps
-// ---------------------------------------------------------------------------
-
-describe('exitCodeMap', () => {
-  test('maps all categories to expected exit codes', () => {
-    expect(exitCodeMap.validation).toBe(1);
-    expect(exitCodeMap.not_found).toBe(2);
-    expect(exitCodeMap.conflict).toBe(3);
-    expect(exitCodeMap.permission).toBe(4);
-    expect(exitCodeMap.timeout).toBe(5);
-    expect(exitCodeMap.rate_limit).toBe(6);
-    expect(exitCodeMap.network).toBe(7);
-    expect(exitCodeMap.internal).toBe(8);
-    expect(exitCodeMap.auth).toBe(9);
-    expect(exitCodeMap.cancelled).toBe(130);
-  });
-});
-
-describe('statusCodeMap', () => {
-  test('maps all categories to expected HTTP status codes', () => {
-    expect(statusCodeMap.validation).toBe(400);
-    expect(statusCodeMap.not_found).toBe(404);
-    expect(statusCodeMap.conflict).toBe(409);
-    expect(statusCodeMap.permission).toBe(403);
-    expect(statusCodeMap.timeout).toBe(504);
-    expect(statusCodeMap.rate_limit).toBe(429);
-    expect(statusCodeMap.network).toBe(502);
-    expect(statusCodeMap.internal).toBe(500);
-    expect(statusCodeMap.auth).toBe(401);
-    expect(statusCodeMap.cancelled).toBe(499);
-  });
-});
-
-describe('jsonRpcCodeMap', () => {
-  test('maps all categories to expected JSON-RPC codes', () => {
-    expect(jsonRpcCodeMap.validation).toBe(-32_602);
-    expect(jsonRpcCodeMap.not_found).toBe(-32_601);
-    expect(jsonRpcCodeMap.conflict).toBe(-32_603);
-    expect(jsonRpcCodeMap.permission).toBe(-32_600);
-    expect(jsonRpcCodeMap.timeout).toBe(-32_603);
-    expect(jsonRpcCodeMap.rate_limit).toBe(-32_603);
-    expect(jsonRpcCodeMap.network).toBe(-32_603);
-    expect(jsonRpcCodeMap.internal).toBe(-32_603);
-    expect(jsonRpcCodeMap.auth).toBe(-32_600);
-    expect(jsonRpcCodeMap.cancelled).toBe(-32_603);
-  });
-});
-
-describe('retryableMap', () => {
-  test('only timeout, rate_limit, and network are retryable', () => {
-    expect(retryableMap.timeout).toBe(true);
-    expect(retryableMap.rate_limit).toBe(true);
-    expect(retryableMap.network).toBe(true);
-
-    expect(retryableMap.validation).toBe(false);
-    expect(retryableMap.not_found).toBe(false);
-    expect(retryableMap.conflict).toBe(false);
-    expect(retryableMap.permission).toBe(false);
-    expect(retryableMap.internal).toBe(false);
-    expect(retryableMap.auth).toBe(false);
-    expect(retryableMap.cancelled).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Helper functions
-// ---------------------------------------------------------------------------
-
-describe('isRetryable', () => {
-  test('returns true for retryable errors', () => {
-    expect(isRetryable(new TimeoutError('timed out'))).toBe(true);
-    expect(isRetryable(new RateLimitError('too fast'))).toBe(true);
-    expect(isRetryable(new NetworkError('disconnected'))).toBe(true);
-  });
-
-  test('returns false for non-retryable errors', () => {
-    expect(isRetryable(new ValidationError('bad input'))).toBe(false);
-    expect(isRetryable(new NotFoundError('missing'))).toBe(false);
-    expect(isRetryable(new AuthError('unauthorized'))).toBe(false);
-    expect(isRetryable(new InternalError('oops'))).toBe(false);
-    expect(isRetryable(new CancelledError('aborted'))).toBe(false);
-  });
-
-  test('returns false for plain Error', () => {
-    expect(isRetryable(new Error('generic'))).toBe(false);
-  });
-});
-
-describe('isTrailsError', () => {
-  test('returns true for TrailsError subclasses', () => {
-    expect(isTrailsError(new ValidationError('bad'))).toBe(true);
-    expect(isTrailsError(new NetworkError('down'))).toBe(true);
-    expect(isTrailsError(new CancelledError('stop'))).toBe(true);
-  });
-
-  test('returns false for plain Error', () => {
-    expect(isTrailsError(new Error('nope'))).toBe(false);
-  });
-
-  test('returns false for non-error values', () => {
-    expect(isTrailsError(null)).toBe(false);
-    expect(isTrailsError()).toBe(false);
-    expect(isTrailsError('string')).toBe(false);
-    expect(isTrailsError(42)).toBe(false);
-    expect(isTrailsError({})).toBe(false);
-  });
-});