@wopr-network/platform-ui-core 1.0.0

package/src/__tests__/tenant-context.test.tsx

@@ -0,0 +1,146 @@
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { act, renderHook } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@/lib/auth-client", () => ({
+  useSession: vi.fn(() => ({
+    data: { user: { id: "user-1", name: "Test User", image: null } },
+    isPending: false,
+  })),
+}));
+
+const mockQuery = vi.hoisted(() => vi.fn().mockResolvedValue([]));
+vi.mock("@/lib/trpc", () => ({
+  trpcVanilla: {
+    org: { listMyOrganizations: { query: mockQuery } },
+  },
+}));
+
+import { getActiveTenantId, TenantProvider, useTenant } from "@/lib/tenant-context";
+
+function createWrapper() {
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+  return ({ children }: { children: React.ReactNode }) => (
+    <QueryClientProvider client={queryClient}>
+      <TenantProvider>{children}</TenantProvider>
+    </QueryClientProvider>
+  );
+}
+
+function clearTenantCookie() {
+  // biome-ignore lint/suspicious/noDocumentCookie: test helper — mirrors production writeTenantCookie pattern
+  document.cookie = "platform_tenant_id=; path=/; max-age=0";
+}
+
+function setTenantCookie(tenantId: string) {
+  // biome-ignore lint/suspicious/noDocumentCookie: test helper — mirrors production writeTenantCookie pattern
+  document.cookie = `platform_tenant_id=${encodeURIComponent(tenantId)}; path=/`;
+}
+
+describe("useTenant", () => {
+  beforeEach(() => {
+    clearTenantCookie();
+    mockQuery.mockResolvedValue([]);
+  });
+
+  it("defaults to the user's personal account", async () => {
+    const { result } = renderHook(() => useTenant(), {
+      wrapper: createWrapper(),
+    });
+
+    await vi.waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.activeTenantId).toBe("user-1");
+    expect(result.current.tenants).toEqual([
+      { id: "user-1", name: "Test User", type: "personal", image: null },
+    ]);
+  });
+
+  it("includes orgs when listMyOrganizations returns results", async () => {
+    mockQuery.mockResolvedValue([{ id: "org-1", name: "My Team", image: null }]);
+
+    const { result } = renderHook(() => useTenant(), {
+      wrapper: createWrapper(),
+    });
+
+    await vi.waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.tenants).toHaveLength(2);
+    expect(result.current.tenants[1]).toEqual({
+      id: "org-1",
+      name: "My Team",
+      type: "org",
+      image: null,
+    });
+  });
+
+  it("persists tenant switch to cookie", async () => {
+    mockQuery.mockResolvedValue([{ id: "org-1", name: "My Team", image: null }]);
+
+    const { result } = renderHook(() => useTenant(), {
+      wrapper: createWrapper(),
+    });
+
+    await vi.waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    act(() => {
+      result.current.switchTenant("org-1");
+    });
+
+    expect(result.current.activeTenantId).toBe("org-1");
+    expect(document.cookie).toContain("platform_tenant_id=org-1");
+  });
+
+  it("falls back to personal if stored tenant is not in list", async () => {
+    setTenantCookie("org-deleted");
+    mockQuery.mockResolvedValue([]);
+
+    const { result } = renderHook(() => useTenant(), {
+      wrapper: createWrapper(),
+    });
+
+    await vi.waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.activeTenantId).toBe("user-1");
+  });
+
+  it("gracefully handles listMyOrganizations failure", async () => {
+    mockQuery.mockRejectedValue(new Error("Not implemented"));
+
+    const { result } = renderHook(() => useTenant(), {
+      wrapper: createWrapper(),
+    });
+
+    await vi.waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.tenants).toHaveLength(1);
+    expect(result.current.tenants[0].type).toBe("personal");
+  });
+});
+
+describe("getActiveTenantId", () => {
+  beforeEach(() => {
+    clearTenantCookie();
+  });
+
+  it("returns stored tenant ID from cookie", () => {
+    setTenantCookie("org-1");
+    expect(getActiveTenantId()).toBe("org-1");
+  });
+
+  it("returns empty string when nothing stored", () => {
+    expect(getActiveTenantId()).toBe("");
+  });
+});

package/src/__tests__/tenant-keys-api.test.ts

@@ -0,0 +1,114 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// Mock the fetch at the module level
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+// Must mock api-config before importing api
+vi.mock("@/lib/api-config", () => ({
+  API_BASE_URL: "http://localhost:3001/api",
+  PLATFORM_BASE_URL: "http://localhost:3001",
+}));
+
+vi.mock("@/lib/fetch-utils", () => ({
+  handleUnauthorized: vi.fn(() => {
+    throw new Error("Unauthorized");
+  }),
+  UnauthorizedError: class extends Error {
+    constructor(msg = "Session expired") {
+      super(msg);
+      this.name = "UnauthorizedError";
+    }
+  },
+}));
+
+vi.mock("@/lib/trpc", () => ({
+  trpcVanilla: {},
+}));
+
+import { deleteTenantKey, getTenantKey, listTenantKeys, storeTenantKey } from "@/lib/api";
+
+describe("tenant-keys API", () => {
+  beforeEach(() => {
+    mockFetch.mockReset();
+  });
+
+  it("listTenantKeys calls GET /api/tenant-keys", async () => {
+    const mockData = [
+      { provider: "openai", hasKey: true, maskedKey: "sk-...ab", createdAt: null, updatedAt: null },
+    ];
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockData),
+    });
+
+    const result = await listTenantKeys();
+    expect(result).toEqual(mockData);
+    expect(mockFetch).toHaveBeenCalledWith(
+      "http://localhost:3001/api/tenant-keys",
+      expect.objectContaining({ credentials: "include" }),
+    );
+  });
+
+  it("getTenantKey calls GET /api/tenant-keys/:provider", async () => {
+    const mockData = {
+      provider: "openai",
+      hasKey: true,
+      maskedKey: "sk-...ab",
+      createdAt: null,
+      updatedAt: null,
+    };
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockData),
+    });
+
+    const result = await getTenantKey("openai");
+    expect(result).toEqual(mockData);
+    expect(mockFetch).toHaveBeenCalledWith(
+      "http://localhost:3001/api/tenant-keys/openai",
+      expect.objectContaining({ credentials: "include" }),
+    );
+  });
+
+  it("storeTenantKey calls PUT /api/tenant-keys/:provider with key", async () => {
+    const mockData = {
+      provider: "openai",
+      hasKey: true,
+      maskedKey: "sk-...ab",
+      createdAt: null,
+      updatedAt: null,
+    };
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockData),
+    });
+
+    const result = await storeTenantKey("openai", "sk-real-key");
+    expect(result).toEqual(mockData);
+    expect(mockFetch).toHaveBeenCalledWith(
+      "http://localhost:3001/api/tenant-keys/openai",
+      expect.objectContaining({
+        method: "PUT",
+        body: JSON.stringify({ key: "sk-real-key" }),
+      }),
+    );
+  });
+
+  it("deleteTenantKey calls DELETE /api/tenant-keys/:provider", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 204,
+      json: () => Promise.resolve({}),
+    });
+
+    await deleteTenantKey("openai");
+    expect(mockFetch).toHaveBeenCalledWith(
+      "http://localhost:3001/api/tenant-keys/openai",
+      expect.objectContaining({ method: "DELETE" }),
+    );
+  });
+});

package/src/__tests__/tenant-table-pagination.test.tsx

@@ -0,0 +1,124 @@
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("next/navigation", () => ({
+  useRouter: () => ({ push: vi.fn() }),
+  useSearchParams: () => new URLSearchParams(),
+  usePathname: () => "/admin",
+}));
+
+vi.mock("better-auth/react", () => ({
+  createAuthClient: () => ({
+    useSession: () => ({ data: null, isPending: false, error: null }),
+    signIn: { email: vi.fn(), social: vi.fn() },
+    signUp: { email: vi.fn() },
+    signOut: vi.fn(),
+  }),
+}));
+
+vi.mock("@/lib/admin-api", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@/lib/admin-api")>();
+  return {
+    ...actual,
+    getUsersList: vi.fn(),
+    bulkGrantCredits: vi.fn(),
+    bulkSuspendTenants: vi.fn(),
+    bulkReactivateTenants: vi.fn(),
+  };
+});
+
+import { TenantTable } from "@/components/admin/tenant-table";
+import { getUsersList } from "@/lib/admin-api";
+
+const mockGetUsersList = vi.mocked(getUsersList);
+
+function makeUsers(count: number, startIndex: number) {
+  return Array.from({ length: count }, (_, i) => ({
+    id: `id-${startIndex + i}`,
+    tenant_id: `tenant-${startIndex + i}`,
+    email: `user${startIndex + i}@test.com`,
+    name: `User ${startIndex + i}`,
+    status: "active" as const,
+    role: "user",
+    credit_balance_cents: 1000,
+    agent_count: 1,
+    last_seen: null,
+    created_at: Date.now(),
+  }));
+}
+
+describe("TenantTable pagination", () => {
+  it("page 1 requests offset 0", async () => {
+    mockGetUsersList.mockResolvedValueOnce({ users: makeUsers(25, 0), total: 60 });
+    render(<TenantTable />);
+
+    await screen.findByText("user0@test.com");
+    expect(mockGetUsersList).toHaveBeenCalledWith(
+      expect.objectContaining({ offset: 0, limit: 25 }),
+    );
+  });
+
+  it("clicking Next requests offset 25 (not 50)", async () => {
+    mockGetUsersList.mockResolvedValueOnce({ users: makeUsers(25, 0), total: 60 });
+    const user = userEvent.setup();
+    render(<TenantTable />);
+
+    await screen.findByText("user0@test.com");
+
+    mockGetUsersList.mockResolvedValueOnce({ users: makeUsers(25, 25), total: 60 });
+    await user.click(screen.getByRole("button", { name: "Next" }));
+
+    await screen.findByText("user25@test.com");
+    expect(mockGetUsersList).toHaveBeenLastCalledWith(
+      expect.objectContaining({ offset: 25, limit: 25 }),
+    );
+  });
+
+  it("shows correct range text on page 2", async () => {
+    mockGetUsersList.mockResolvedValueOnce({ users: makeUsers(25, 0), total: 60 });
+    const user = userEvent.setup();
+    render(<TenantTable />);
+    await screen.findByText("user0@test.com");
+
+    mockGetUsersList.mockResolvedValueOnce({ users: makeUsers(25, 25), total: 60 });
+    await user.click(screen.getByRole("button", { name: "Next" }));
+    await screen.findByText("user25@test.com");
+
+    expect(screen.getByText(/Showing 26-50 of 60/)).toBeInTheDocument();
+  });
+
+  it("disables Next on last page", async () => {
+    mockGetUsersList.mockResolvedValueOnce({ users: makeUsers(25, 0), total: 60 });
+    const user = userEvent.setup();
+    render(<TenantTable />);
+    await screen.findByText("user0@test.com");
+
+    mockGetUsersList.mockResolvedValueOnce({ users: makeUsers(25, 25), total: 60 });
+    await user.click(screen.getByRole("button", { name: "Next" }));
+    await screen.findByText("user25@test.com");
+
+    mockGetUsersList.mockResolvedValueOnce({ users: makeUsers(10, 50), total: 60 });
+    await user.click(screen.getByRole("button", { name: "Next" }));
+    await screen.findByText("user50@test.com");
+
+    expect(screen.getByRole("button", { name: "Next" })).toBeDisabled();
+  });
+
+  it("Previous is disabled on page 1", async () => {
+    mockGetUsersList.mockResolvedValueOnce({ users: makeUsers(25, 0), total: 60 });
+    render(<TenantTable />);
+    await screen.findByText("user0@test.com");
+
+    expect(screen.getByRole("button", { name: "Previous" })).toBeDisabled();
+  });
+
+  it("hides pagination when total <= PAGE_SIZE", async () => {
+    mockGetUsersList.mockResolvedValueOnce({ users: makeUsers(10, 0), total: 10 });
+    render(<TenantTable />);
+    await screen.findByText("user0@test.com");
+
+    expect(screen.queryByRole("button", { name: "Next" })).not.toBeInTheDocument();
+    expect(screen.queryByRole("button", { name: "Previous" })).not.toBeInTheDocument();
+  });
+});

package/src/__tests__/terminal-log-cleanup.test.tsx

@@ -0,0 +1,51 @@
+import { cleanup, render } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { TerminalLog } from "@/app/(dashboard)/marketplace/[plugin]/page";
+
+const fakePlugin = {
+  id: "test-plugin",
+  name: "Test Plugin",
+  version: "1.0.0",
+  requires: [],
+  capabilities: ["test"],
+  description: "",
+  author: "",
+  category: "utility" as const,
+  icon: "",
+  installed: false,
+  installCount: 0,
+  rating: 5,
+  color: "#000000",
+  setup: [],
+  configSchema: [],
+  changelog: [],
+};
+
+describe("TerminalLog cleanup", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    cleanup();
+  });
+
+  it("should clear the onDone timeout on unmount", () => {
+    const clearTimeoutSpy = vi.spyOn(globalThis, "clearTimeout");
+    const onDone = vi.fn();
+
+    // biome-ignore lint/suspicious/noExplicitAny: test only
+    const { unmount } = render(<TerminalLog plugin={fakePlugin as any} onDone={onDone} />);
+
+    // Advance past all interval ticks + into the setTimeout territory
+    vi.advanceTimersByTime(10000);
+
+    const callsBefore = clearTimeoutSpy.mock.calls.length;
+    unmount();
+
+    // clearTimeout should be called at least once more on unmount (for the done timeout)
+    expect(clearTimeoutSpy.mock.calls.length).toBeGreaterThan(callsBefore);
+    clearTimeoutSpy.mockRestore();
+  });
+});

package/src/__tests__/terminal-sequence.test.tsx

@@ -0,0 +1,28 @@
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { TerminalSequence } from "../components/landing/terminal-sequence";
+
+describe("TerminalSequence", () => {
+  it("renders the terminal container with accessible role", () => {
+    render(<TerminalSequence />);
+    expect(screen.getByRole("img")).toBeInTheDocument();
+  });
+
+  it("has an accessible aria-label", () => {
+    render(<TerminalSequence />);
+    const container = screen.getByRole("img");
+    expect(container).toHaveAttribute("aria-label", expect.stringContaining("Terminal animation"));
+  });
+
+  it("renders hold lines in reduced-motion mode", () => {
+    render(<TerminalSequence />);
+    expect(screen.getByText("Platform.")).toBeInTheDocument();
+    expect(screen.getByText(/Ready to launch/)).toBeInTheDocument();
+  });
+
+  it("calls onComplete in reduced-motion mode", () => {
+    const onComplete = vi.fn();
+    render(<TerminalSequence onComplete={onComplete} />);
+    expect(onComplete).toHaveBeenCalledTimes(1);
+  });
+});