import { describe, it, expect } from "vitest";
import { isProgrammingError, isNetworkError, isAuthError, isDatabaseError } from "../errors.js";

describe("isProgrammingError", () => {
  it("returns true for TypeError", () => {
    expect(isProgrammingError(new TypeError("x is not a function"))).toBe(true);
  });

  it("returns true for ReferenceError", () => {
    expect(isProgrammingError(new ReferenceError("x is not defined"))).toBe(true);
  });

  it("returns true for SyntaxError", () => {
    expect(isProgrammingError(new SyntaxError("unexpected token"))).toBe(true);
  });

  it("returns false for generic Error", () => {
    expect(isProgrammingError(new Error("something failed"))).toBe(false);
  });

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

describe("isNetworkError", () => {
  it("returns true for fetch failed", () => {
    expect(isNetworkError(new Error("fetch failed"))).toBe(true);
  });

  it("returns true for ECONNREFUSED", () => {
    expect(isNetworkError(new Error("ECONNREFUSED"))).toBe(true);
  });

  it("returns true for timeout", () => {
    expect(isNetworkError(new Error("request timeout"))).toBe(true);
  });

  it("returns true for ETIMEDOUT", () => {
    expect(isNetworkError(new Error("ETIMEDOUT"))).toBe(true);
  });

  it("returns false for generic Error", () => {
    expect(isNetworkError(new Error("something else"))).toBe(false);
  });

  it("returns false for non-Error values", () => {
    expect(isNetworkError("string")).toBe(false);
  });
});

describe("isAuthError", () => {
  it("returns true for invalid credentials", () => {
    expect(isAuthError(new Error("Invalid identifier or password"))).toBe(true);
  });

  it("returns true for authentication failed", () => {
    expect(isAuthError(new Error("Authentication failed"))).toBe(true);
  });

  it("returns true for unauthorized", () => {
    expect(isAuthError(new Error("Unauthorized"))).toBe(true);
  });

  it("returns false for network errors", () => {
    expect(isAuthError(new Error("fetch failed"))).toBe(false);
  });

  it("returns false for non-Error values", () => {
    expect(isAuthError("string")).toBe(false);
  });
});

describe("isDatabaseError", () => {
  it("returns true for pool errors", () => {
    expect(isDatabaseError(new Error("pool exhausted"))).toBe(true);
  });

  it("returns true for postgres errors", () => {
    expect(isDatabaseError(new Error("postgres connection lost"))).toBe(true);
  });

  it("returns false for generic errors", () => {
    expect(isDatabaseError(new Error("something else"))).toBe(false);
  });
});