claude-code/src/utils/__tests__/errors.test.ts

import { describe, expect, test } from "bun:test";
import {
  AbortError,
  ClaudeError,
  MalformedCommandError,
  ConfigParseError,
  ShellError,
  TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
  isAbortError,
  hasExactErrorMessage,
  toError,
  errorMessage,
  getErrnoCode,
  isENOENT,
  getErrnoPath,
  shortErrorStack,
  isFsInaccessible,
  classifyAxiosError,
} from "../errors";

// ─── Error classes ──────────────────────────────────────────────────────

describe("ClaudeError", () => {
  test("sets name to constructor name", () => {
    const e = new ClaudeError("test");
    expect(e.name).toBe("ClaudeError");
    expect(e.message).toBe("test");
  });
});

describe("AbortError", () => {
  test("sets name to AbortError", () => {
    const e = new AbortError("cancelled");
    expect(e.name).toBe("AbortError");
  });
});

describe("ConfigParseError", () => {
  test("stores filePath and defaultConfig", () => {
    const e = new ConfigParseError("bad", "/tmp/cfg", { x: 1 });
    expect(e.filePath).toBe("/tmp/cfg");
    expect(e.defaultConfig).toEqual({ x: 1 });
  });
});

describe("ShellError", () => {
  test("stores stdout, stderr, code, interrupted", () => {
    const e = new ShellError("out", "err", 1, false);
    expect(e.stdout).toBe("out");
    expect(e.stderr).toBe("err");
    expect(e.code).toBe(1);
    expect(e.interrupted).toBe(false);
  });
});

describe("TelemetrySafeError", () => {
  test("uses message as telemetryMessage by default", () => {
    const e =
      new TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS("msg");
    expect(e.telemetryMessage).toBe("msg");
  });

  test("uses separate telemetryMessage when provided", () => {
    const e =
      new TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS(
        "full msg",
        "safe msg"
      );
    expect(e.message).toBe("full msg");
    expect(e.telemetryMessage).toBe("safe msg");
  });
});

// ─── isAbortError ───────────────────────────────────────────────────────

describe("isAbortError", () => {
  test("returns true for AbortError instance", () => {
    expect(isAbortError(new AbortError())).toBe(true);
  });

  test("returns true for DOMException-style abort", () => {
    const e = new Error("aborted");
    e.name = "AbortError";
    expect(isAbortError(e)).toBe(true);
  });

  test("returns false for regular error", () => {
    expect(isAbortError(new Error("nope"))).toBe(false);
  });

  test("returns false for non-error", () => {
    expect(isAbortError("string")).toBe(false);
    expect(isAbortError(null)).toBe(false);
  });
});

// ─── hasExactErrorMessage ───────────────────────────────────────────────

describe("hasExactErrorMessage", () => {
  test("returns true for matching message", () => {
    expect(hasExactErrorMessage(new Error("test"), "test")).toBe(true);
  });

  test("returns false for different message", () => {
    expect(hasExactErrorMessage(new Error("a"), "b")).toBe(false);
  });

  test("returns false for non-Error", () => {
    expect(hasExactErrorMessage("string", "string")).toBe(false);
  });
});

// ─── toError ────────────────────────────────────────────────────────────

describe("toError", () => {
  test("returns Error as-is", () => {
    const e = new Error("test");
    expect(toError(e)).toBe(e);
  });

  test("wraps string in Error", () => {
    const e = toError("oops");
    expect(e).toBeInstanceOf(Error);
    expect(e.message).toBe("oops");
  });

  test("wraps number in Error", () => {
    expect(toError(42).message).toBe("42");
  });
});

// ─── errorMessage ───────────────────────────────────────────────────────

describe("errorMessage", () => {
  test("extracts message from Error", () => {
    expect(errorMessage(new Error("hello"))).toBe("hello");
  });

  test("stringifies non-Error", () => {
    expect(errorMessage(42)).toBe("42");
    expect(errorMessage(null)).toBe("null");
  });
});

// ─── getErrnoCode / isENOENT / getErrnoPath ────────────────────────────

describe("getErrnoCode", () => {
  test("extracts code from errno-like error", () => {
    const e = Object.assign(new Error(), { code: "ENOENT" });
    expect(getErrnoCode(e)).toBe("ENOENT");
  });

  test("returns undefined for no code", () => {
    expect(getErrnoCode(new Error())).toBeUndefined();
  });

  test("returns undefined for non-string code", () => {
    expect(getErrnoCode({ code: 123 })).toBeUndefined();
  });

  test("returns undefined for non-object", () => {
    expect(getErrnoCode(null)).toBeUndefined();
    expect(getErrnoCode("string")).toBeUndefined();
  });
});

describe("isENOENT", () => {
  test("returns true for ENOENT", () => {
    expect(isENOENT(Object.assign(new Error(), { code: "ENOENT" }))).toBe(true);
  });

  test("returns false for other codes", () => {
    expect(isENOENT(Object.assign(new Error(), { code: "EACCES" }))).toBe(
      false
    );
  });
});

describe("getErrnoPath", () => {
  test("extracts path from errno error", () => {
    const e = Object.assign(new Error(), { path: "/tmp/file" });
    expect(getErrnoPath(e)).toBe("/tmp/file");
  });

  test("returns undefined when no path", () => {
    expect(getErrnoPath(new Error())).toBeUndefined();
  });
});

// ─── shortErrorStack ────────────────────────────────────────────────────

describe("shortErrorStack", () => {
  test("returns string for non-Error", () => {
    expect(shortErrorStack("oops")).toBe("oops");
  });

  test("returns message when no stack", () => {
    const e = new Error("test");
    e.stack = undefined;
    expect(shortErrorStack(e)).toBe("test");
  });

  test("truncates long stacks", () => {
    const e = new Error("test");
    const frames = Array.from({ length: 20 }, (_, i) => `    at frame${i}`);
    e.stack = `Error: test\n${frames.join("\n")}`;
    const result = shortErrorStack(e, 3);
    const lines = result.split("\n");
    expect(lines).toHaveLength(4); // header + 3 frames
  });

  test("preserves short stacks", () => {
    const e = new Error("test");
    e.stack = "Error: test\n    at frame1\n    at frame2";
    expect(shortErrorStack(e, 5)).toBe(e.stack);
  });
});

// ─── isFsInaccessible ──────────────────────────────────────────────────

describe("isFsInaccessible", () => {
  test("returns true for ENOENT", () => {
    expect(isFsInaccessible(Object.assign(new Error(), { code: "ENOENT" }))).toBe(true);
  });

  test("returns true for EACCES", () => {
    expect(isFsInaccessible(Object.assign(new Error(), { code: "EACCES" }))).toBe(true);
  });

  test("returns true for EPERM", () => {
    expect(isFsInaccessible(Object.assign(new Error(), { code: "EPERM" }))).toBe(true);
  });

  test("returns true for ENOTDIR", () => {
    expect(isFsInaccessible(Object.assign(new Error(), { code: "ENOTDIR" }))).toBe(true);
  });

  test("returns true for ELOOP", () => {
    expect(isFsInaccessible(Object.assign(new Error(), { code: "ELOOP" }))).toBe(true);
  });

  test("returns false for other codes", () => {
    expect(isFsInaccessible(Object.assign(new Error(), { code: "EEXIST" }))).toBe(false);
  });
});

// ─── classifyAxiosError ─────────────────────────────────────────────────

describe("classifyAxiosError", () => {
  test("returns 'other' for non-axios error", () => {
    expect(classifyAxiosError(new Error("test")).kind).toBe("other");
  });

  test("returns 'auth' for 401", () => {
    const e = { isAxiosError: true, response: { status: 401 }, message: "unauth" };
    expect(classifyAxiosError(e).kind).toBe("auth");
  });

  test("returns 'auth' for 403", () => {
    const e = { isAxiosError: true, response: { status: 403 }, message: "forbidden" };
    expect(classifyAxiosError(e).kind).toBe("auth");
  });

  test("returns 'timeout' for ECONNABORTED", () => {
    const e = { isAxiosError: true, code: "ECONNABORTED", message: "timeout" };
    expect(classifyAxiosError(e).kind).toBe("timeout");
  });

  test("returns 'network' for ECONNREFUSED", () => {
    const e = { isAxiosError: true, code: "ECONNREFUSED", message: "refused" };
    expect(classifyAxiosError(e).kind).toBe("network");
  });

  test("returns 'network' for ENOTFOUND", () => {
    const e = { isAxiosError: true, code: "ENOTFOUND", message: "nope" };
    expect(classifyAxiosError(e).kind).toBe("network");
  });

  test("returns 'http' for other axios errors", () => {
    const e = { isAxiosError: true, response: { status: 500 }, message: "err" };
    const result = classifyAxiosError(e);
    expect(result.kind).toBe("http");
    expect(result.status).toBe(500);
  });

  test("returns 'other' for null", () => {
    expect(classifyAxiosError(null).kind).toBe("other");
  });
});