automaker/apps/server/tests/unit/lib/error-handler.test.ts

import { describe, it, expect } from "vitest";
import {
  isAbortError,
  isAuthenticationError,
  isCancellationError,
  classifyError,
  getUserFriendlyErrorMessage,
  type ErrorType,
} from "@automaker/utils";

describe("error-handler.ts", () => {
  describe("isAbortError", () => {
    it("should detect AbortError by error name", () => {
      const error = new Error("Operation cancelled");
      error.name = "AbortError";
      expect(isAbortError(error)).toBe(true);
    });

    it("should detect abort error by message content", () => {
      const error = new Error("Request was aborted");
      expect(isAbortError(error)).toBe(true);
    });

    it("should return false for non-abort errors", () => {
      const error = new Error("Something else went wrong");
      expect(isAbortError(error)).toBe(false);
    });

    it("should return false for non-Error objects", () => {
      expect(isAbortError("not an error")).toBe(false);
      expect(isAbortError(null)).toBe(false);
      expect(isAbortError(undefined)).toBe(false);
    });
  });

  describe("isCancellationError", () => {
    it("should detect 'cancelled' message", () => {
      expect(isCancellationError("Operation was cancelled")).toBe(true);
    });

    it("should detect 'canceled' message", () => {
      expect(isCancellationError("Request was canceled")).toBe(true);
    });

    it("should detect 'stopped' message", () => {
      expect(isCancellationError("Process was stopped")).toBe(true);
    });

    it("should detect 'aborted' message", () => {
      expect(isCancellationError("Task was aborted")).toBe(true);
    });

    it("should be case insensitive", () => {
      expect(isCancellationError("CANCELLED")).toBe(true);
      expect(isCancellationError("Canceled")).toBe(true);
    });

    it("should return false for non-cancellation errors", () => {
      expect(isCancellationError("File not found")).toBe(false);
      expect(isCancellationError("Network error")).toBe(false);
    });
  });

  describe("isAuthenticationError", () => {
    it("should detect 'Authentication failed' message", () => {
      expect(isAuthenticationError("Authentication failed")).toBe(true);
    });

    it("should detect 'Invalid API key' message", () => {
      expect(isAuthenticationError("Invalid API key provided")).toBe(true);
    });

    it("should detect 'authentication_failed' message", () => {
      expect(isAuthenticationError("authentication_failed")).toBe(true);
    });

    it("should detect 'Fix external API key' message", () => {
      expect(isAuthenticationError("Fix external API key configuration")).toBe(true);
    });

    it("should return false for non-authentication errors", () => {
      expect(isAuthenticationError("Network connection error")).toBe(false);
      expect(isAuthenticationError("File not found")).toBe(false);
    });

    it("should be case sensitive", () => {
      expect(isAuthenticationError("authentication Failed")).toBe(false);
    });
  });

  describe("classifyError", () => {
    it("should classify authentication errors", () => {
      const error = new Error("Authentication failed");
      const result = classifyError(error);

      expect(result.type).toBe("authentication");
      expect(result.isAuth).toBe(true);
      expect(result.isAbort).toBe(false);
      expect(result.message).toBe("Authentication failed");
      expect(result.originalError).toBe(error);
    });

    it("should classify abort errors", () => {
      const error = new Error("Operation aborted");
      error.name = "AbortError";
      const result = classifyError(error);

      expect(result.type).toBe("abort");
      expect(result.isAbort).toBe(true);
      expect(result.isAuth).toBe(false);
      expect(result.message).toBe("Operation aborted");
    });

    it("should prioritize auth over abort if both match", () => {
      const error = new Error("Authentication failed and aborted");
      const result = classifyError(error);

      expect(result.type).toBe("authentication");
      expect(result.isAuth).toBe(true);
      expect(result.isAbort).toBe(true); // Still detected as abort too
    });

    it("should classify cancellation errors", () => {
      const error = new Error("Operation was cancelled");
      const result = classifyError(error);

      expect(result.type).toBe("cancellation");
      expect(result.isCancellation).toBe(true);
      expect(result.isAbort).toBe(false);
      expect(result.isAuth).toBe(false);
    });

    it("should prioritize abort over cancellation if both match", () => {
      const error = new Error("Operation aborted");
      error.name = "AbortError";
      const result = classifyError(error);

      expect(result.type).toBe("abort");
      expect(result.isAbort).toBe(true);
      expect(result.isCancellation).toBe(true); // Still detected as cancellation too
    });

    it("should classify cancellation errors with 'canceled' spelling", () => {
      const error = new Error("Request was canceled");
      const result = classifyError(error);

      expect(result.type).toBe("cancellation");
      expect(result.isCancellation).toBe(true);
    });

    it("should classify cancellation errors with 'stopped' message", () => {
      const error = new Error("Process was stopped");
      const result = classifyError(error);

      expect(result.type).toBe("cancellation");
      expect(result.isCancellation).toBe(true);
    });

    it("should classify generic Error as execution error", () => {
      const error = new Error("Something went wrong");
      const result = classifyError(error);

      expect(result.type).toBe("execution");
      expect(result.isAuth).toBe(false);
      expect(result.isAbort).toBe(false);
    });

    it("should classify non-Error objects as unknown", () => {
      const error = "string error";
      const result = classifyError(error);

      expect(result.type).toBe("unknown");
      expect(result.message).toBe("string error");
    });

    it("should handle null and undefined", () => {
      const nullResult = classifyError(null);
      expect(nullResult.type).toBe("unknown");
      expect(nullResult.message).toBe("Unknown error");

      const undefinedResult = classifyError(undefined);
      expect(undefinedResult.type).toBe("unknown");
      expect(undefinedResult.message).toBe("Unknown error");
    });
  });

  describe("getUserFriendlyErrorMessage", () => {
    it("should return friendly message for abort errors", () => {
      const error = new Error("abort");
      const result = getUserFriendlyErrorMessage(error);
      expect(result).toBe("Operation was cancelled");
    });

    it("should return friendly message for authentication errors", () => {
      const error = new Error("Authentication failed");
      const result = getUserFriendlyErrorMessage(error);
      expect(result).toBe("Authentication failed. Please check your API key.");
    });

    it("should return original message for other errors", () => {
      const error = new Error("File not found");
      const result = getUserFriendlyErrorMessage(error);
      expect(result).toBe("File not found");
    });

    it("should handle non-Error objects", () => {
      const result = getUserFriendlyErrorMessage("Custom error");
      expect(result).toBe("Custom error");
    });
  });
});