static/frontend/src/components/settings/AuthManager.test.ts

/**
 * AuthManager Component Tests
 */

import { describe, it, expect, vi, beforeEach } from "vitest";

// Define types locally to avoid module resolution issues
interface AuthFileInfo {
  name: string;
  path: string;
  size_bytes: number;
  is_active: boolean;
}

interface AuthFilesResponse {
  saved_files: AuthFileInfo[];
  active_file: string | null;
}

describe("AuthManager Logic", () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  describe("Data Fetching", () => {
    it("returns loading state structure", () => {
      const result = { data: undefined, isLoading: true, error: null };
      expect(result.isLoading).toBe(true);
    });

    it("returns auth files when loaded", () => {
      const mockData: AuthFilesResponse = {
        saved_files: [
          {
            name: "auth1.json",
            path: "/data/auth1.json",
            size_bytes: 1024,
            is_active: true,
          },
          {
            name: "auth2.json",
            path: "/data/auth2.json",
            size_bytes: 2048,
            is_active: false,
          },
        ],
        active_file: "auth1.json",
      };

      const result = { data: mockData, isLoading: false, error: null };
      expect(result.data.saved_files).toHaveLength(2);
      expect(result.data.active_file).toBe("auth1.json");
    });

    it("handles empty file list", () => {
      const mockData: AuthFilesResponse = {
        saved_files: [],
        active_file: null,
      };

      const result = { data: mockData, isLoading: false, error: null };
      expect(result.data.saved_files).toHaveLength(0);
      expect(result.data.active_file).toBeNull();
    });
  });

  describe("Mutations", () => {
    it("activateAuthFile mutation accepts filename", () => {
      const filename = "auth2.json";
      expect(typeof filename).toBe("string");
    });

    it("deactivateAuth mutation structure", () => {
      const mutation = { isPending: false };
      expect(mutation.isPending).toBe(false);
    });

    it("shows pending state during activation", () => {
      const mutation = { isPending: true };
      expect(mutation.isPending).toBe(true);
    });
  });

  describe("File List Processing", () => {
    it("extracts saved_files array correctly", () => {
      const data: AuthFilesResponse = {
        saved_files: [
          {
            name: "a.json",
            path: "/a.json",
            size_bytes: 100,
            is_active: false,
          },
        ],
        active_file: null,
      };

      const savedFiles = data.saved_files;
      expect(savedFiles).toHaveLength(1);
    });

    it("handles undefined data gracefully", () => {
      const data: AuthFilesResponse | undefined = undefined;
      const savedFiles = data?.saved_files || [];
      expect(savedFiles).toHaveLength(0);
    });

    it("identifies active file correctly", () => {
      const files = [
        { name: "auth1.json", is_active: true },
        { name: "auth2.json", is_active: false },
      ];

      const activeFile = files.find((f) => f.is_active);
      expect(activeFile?.name).toBe("auth1.json");
    });

    it("formats file size in KB", () => {
      const sizeBytes = 2048;
      const sizeKB = (sizeBytes / 1024).toFixed(1);
      expect(sizeKB).toBe("2.0");
    });

    it("handles very small files", () => {
      const sizeBytes = 100;
      const sizeKB = (sizeBytes / 1024).toFixed(1);
      expect(sizeKB).toBe("0.1");
    });
  });

  describe("Active State Logic", () => {
    it("determines if deactivate button should show", () => {
      const activeFile: string | null = "auth1.json";
      const shouldShowDeactivate = activeFile !== null;
      expect(shouldShowDeactivate).toBe(true);
    });

    it("hides deactivate button when no active file", () => {
      const activeFile: string | null = null;
      const shouldShowDeactivate = activeFile !== null;
      expect(shouldShowDeactivate).toBe(false);
    });

    it("determines if activate button should show for inactive files", () => {
      const file = { name: "auth2.json", is_active: false };
      const shouldShowActivate = !file.is_active;
      expect(shouldShowActivate).toBe(true);
    });

    it("hides activate button for active file", () => {
      const file = { name: "auth1.json", is_active: true };
      const shouldShowActivate = !file.is_active;
      expect(shouldShowActivate).toBe(false);
    });
  });
});