theo-agent-dashboard

api.test.ts (10386B)

---

 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { api, ApiError, uploadAttachment } from "./api";
 
 beforeEach(() => {
   vi.restoreAllMocks();
   vi.stubGlobal(
     "fetch",
     vi.fn().mockResolvedValue({
       ok: true,
       json: async () => ({}),
     }),
   );
 });
 
 describe("api client", () => {
   it("sends correct headers with credentials", async () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: true,
       json: async () => ({ data: 1 }),
     });
     vi.stubGlobal("fetch", mockFetch);
 
     await api.get("/test");
 
     expect(mockFetch).toHaveBeenCalledWith(
       "/api/test",
       expect.objectContaining({
         credentials: "include",
         headers: expect.objectContaining({
           "Content-Type": "application/json",
         }),
       }),
     );
   });
 
   it("handles 401 by redirecting to /login", async () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: false,
       status: 401,
       json: async () => ({ error: "unauthorized" }),
     });
     vi.stubGlobal("fetch", mockFetch);
 
     const assignSpy = vi.fn();
     const originalLocation = window.location;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     delete (window as any).location;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     (window as any).location = { ...originalLocation, assign: assignSpy };
 
     await expect(api.get("/protected")).rejects.toThrow();
     expect(assignSpy).toHaveBeenCalledWith("/login");
 
     // Restore
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     (window as any).location = originalLocation;
   });
 
   it("handles network errors", async () => {
     vi.stubGlobal(
       "fetch",
       vi.fn().mockRejectedValue(new TypeError("Failed to fetch")),
     );
 
     await expect(api.get("/test")).rejects.toThrow("Failed to fetch");
   });
 
   it("passes JSON body correctly for POST", async () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: true,
       json: async () => ({ created: true }),
     });
     vi.stubGlobal("fetch", mockFetch);
 
     await api.post("/create", { name: "test" });
 
     expect(mockFetch).toHaveBeenCalledWith(
       "/api/create",
       expect.objectContaining({
         method: "POST",
         body: JSON.stringify({ name: "test" }),
       }),
     );
   });
 
   it("throws ApiError on non-ok response", async () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: false,
       status: 500,
       json: async () => ({ error: "server error" }),
     });
     vi.stubGlobal("fetch", mockFetch);
 
     await expect(api.get("/error")).rejects.toThrow(ApiError);
   });
 
   it("ApiError contains status code", async () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: false,
       status: 500,
       json: async () => ({ error: "server error" }),
     });
     vi.stubGlobal("fetch", mockFetch);
 
     try {
       await api.get("/error");
       expect.fail("should have thrown");
     } catch (e) {
       expect(e).toBeInstanceOf(ApiError);
       expect((e as ApiError).status).toBe(500);
     }
   });
 
   it("ApiError name is 'ApiError'", async () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: false,
       status: 403,
       json: async () => ({ error: "forbidden" }),
     });
     vi.stubGlobal("fetch", mockFetch);
 
     try {
       await api.get("/forbidden");
       expect.fail("should have thrown");
     } catch (e) {
       expect((e as ApiError).name).toBe("ApiError");
     }
   });
 
   it("passes body for PATCH", async () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: true,
       json: async () => ({}),
     });
     vi.stubGlobal("fetch", mockFetch);
 
     await api.patch("/update", { value: 42 });
 
     expect(mockFetch).toHaveBeenCalledWith(
       "/api/update",
       expect.objectContaining({
         method: "PATCH",
         body: JSON.stringify({ value: 42 }),
       }),
     );
   });
 
   it("sends DELETE request", async () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: true,
       json: async () => ({}),
     });
     vi.stubGlobal("fetch", mockFetch);
 
     await api.delete("/item/1");
 
     expect(mockFetch).toHaveBeenCalledWith(
       "/api/item/1",
       expect.objectContaining({
         method: "DELETE",
       }),
     );
   });
 
   it("GET uses correct method", async () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: true,
       json: async () => ({ data: 1 }),
     });
     vi.stubGlobal("fetch", mockFetch);
 
     await api.get("/data");
 
     expect(mockFetch).toHaveBeenCalledWith(
       "/api/data",
       expect.objectContaining({ method: "GET" }),
     );
   });
 
   it("non-401 error response includes error message from server", async () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: false,
       status: 422,
       json: async () => ({ error: "Validation failed" }),
     });
     vi.stubGlobal("fetch", mockFetch);
 
     try {
       await api.get("/validate");
       expect.fail("should have thrown");
     } catch (e) {
       expect(e).toBeInstanceOf(ApiError);
       expect((e as ApiError).status).toBe(422);
       expect((e as ApiError).message).toBe("Validation failed");
     }
   });
 
   it("non-401 error with no error field uses 'Request failed'", async () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: false,
       status: 502,
       json: async () => ({}),
     });
     vi.stubGlobal("fetch", mockFetch);
 
     try {
       await api.get("/bad-gateway");
       expect.fail("should have thrown");
     } catch (e) {
       expect((e as ApiError).message).toBe("Request failed");
     }
   });
 
   it("non-401 error handles json parse failure", async () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: false,
       status: 500,
       json: async () => { throw new Error("invalid json"); },
     });
     vi.stubGlobal("fetch", mockFetch);
 
     try {
       await api.get("/error");
       expect.fail("should have thrown");
     } catch (e) {
       expect(e).toBeInstanceOf(ApiError);
       expect((e as ApiError).message).toBe("Unknown error");
     }
   });
 
   it("POST without body does not include body in request", async () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: true,
       json: async () => ({}),
     });
     vi.stubGlobal("fetch", mockFetch);
 
     await api.post("/action");
 
     const callArgs = mockFetch.mock.calls[0][1];
     expect(callArgs.body).toBeUndefined();
   });
 
   it("PATCH without body does not include body in request", async () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: true,
       json: async () => ({}),
     });
     vi.stubGlobal("fetch", mockFetch);
 
     await api.patch("/action");
 
     const callArgs = mockFetch.mock.calls[0][1];
     expect(callArgs.body).toBeUndefined();
   });
 
   it("returns parsed JSON on success", async () => {
     const mockFetch = vi.fn().mockResolvedValue({
       ok: true,
       json: async () => ({ result: "success" }),
     });
     vi.stubGlobal("fetch", mockFetch);
 
     const result = await api.get<{ result: string }>("/test");
     expect(result).toEqual({ result: "success" });
   });
 });
 
 describe("uploadAttachment", () => {
   let originalXMLHttpRequest: typeof XMLHttpRequest;
 
   beforeEach(() => {
     originalXMLHttpRequest = global.XMLHttpRequest;
   });
 
   afterEach(() => {
     global.XMLHttpRequest = originalXMLHttpRequest;
   });
 
   it("rejects on non-2xx status", async () => {
     const mockXhr = {
       open: vi.fn(),
       send: vi.fn(),
       setRequestHeader: vi.fn(),
       addEventListener: vi.fn((event: string, cb: () => void) => {
         if (event === "load") {
           // Store the callback to call later
           (mockXhr as any)._loadCb = cb;
         }
       }),
       upload: {
         addEventListener: vi.fn(),
       },
       status: 400,
       responseText: '{"error":"bad"}',
       withCredentials: false,
     };
     global.XMLHttpRequest = vi.fn(() => mockXhr) as unknown as typeof XMLHttpRequest;
 
     const file = new File(["test"], "test.txt", { type: "text/plain" });
     const promise = uploadAttachment(file, "session-1");
 
     // Trigger load event
     (mockXhr as any)._loadCb();
 
     await expect(promise).rejects.toThrow(ApiError);
   });
 
   it("rejects on network error", async () => {
     const mockXhr = {
       open: vi.fn(),
       send: vi.fn(),
       setRequestHeader: vi.fn(),
       addEventListener: vi.fn((event: string, cb: () => void) => {
         if (event === "error") {
           (mockXhr as any)._errorCb = cb;
         }
       }),
       upload: {
         addEventListener: vi.fn(),
       },
       withCredentials: false,
     };
     global.XMLHttpRequest = vi.fn(() => mockXhr) as unknown as typeof XMLHttpRequest;
 
     const file = new File(["test"], "test.txt", { type: "text/plain" });
     const promise = uploadAttachment(file, "session-1");
 
     (mockXhr as any)._errorCb();
 
     await expect(promise).rejects.toThrow("Network error during upload");
   });
 
   it("calls onProgress during upload", async () => {
     let progressCb: ((e: ProgressEvent) => void) | undefined;
     const mockXhr = {
       open: vi.fn(),
       send: vi.fn(),
       setRequestHeader: vi.fn(),
       addEventListener: vi.fn(),
       upload: {
         addEventListener: vi.fn((event: string, cb: (e: ProgressEvent) => void) => {
           if (event === "progress") progressCb = cb;
         }),
       },
       withCredentials: false,
     };
     global.XMLHttpRequest = vi.fn(() => mockXhr) as unknown as typeof XMLHttpRequest;
 
     const onProgress = vi.fn();
     const file = new File(["test"], "test.txt", { type: "text/plain" });
     uploadAttachment(file, "session-1", onProgress);
 
     // Simulate progress event
     progressCb!({ lengthComputable: true, loaded: 50, total: 100 } as ProgressEvent);
 
     expect(onProgress).toHaveBeenCalledWith(50);
   });
 
   it("sets withCredentials to true", async () => {
     const mockXhr = {
       open: vi.fn(),
       send: vi.fn(),
       setRequestHeader: vi.fn(),
       addEventListener: vi.fn(),
       upload: { addEventListener: vi.fn() },
       withCredentials: false,
     };
     global.XMLHttpRequest = vi.fn(() => mockXhr) as unknown as typeof XMLHttpRequest;
 
     const file = new File(["test"], "test.txt", { type: "text/plain" });
     uploadAttachment(file, "session-1");
 
     expect(mockXhr.withCredentials).toBe(true);
   });
 });
 
 import { afterEach } from "vitest";