@wopr-network/platform-ui-core 1.0.0

package/src/__tests__/admin-api.test.ts

@@ -0,0 +1,244 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// ---- Mock tRPC client ----
+// vi.hoisted ensures these are available when vi.mock factory runs (which is hoisted to top of file)
+
+const {
+  mockAffiliateSuppressions,
+  mockAffiliateVelocity,
+  mockAffiliateFingerprintClusters,
+  mockAffiliateBlockFingerprint,
+  mockDailyCost,
+  mockPageCost,
+  mockCacheHitRate,
+  mockSessionCost,
+} = vi.hoisted(() => ({
+  mockAffiliateSuppressions: { query: vi.fn() },
+  mockAffiliateVelocity: { query: vi.fn() },
+  mockAffiliateFingerprintClusters: { query: vi.fn() },
+  mockAffiliateBlockFingerprint: { mutate: vi.fn() },
+  mockDailyCost: { query: vi.fn() },
+  mockPageCost: { query: vi.fn() },
+  mockCacheHitRate: { query: vi.fn() },
+  mockSessionCost: { query: vi.fn() },
+}));
+
+vi.mock("@/lib/trpc", () => ({
+  trpcVanilla: {
+    admin: {
+      affiliateSuppressions: mockAffiliateSuppressions,
+      affiliateVelocity: mockAffiliateVelocity,
+      affiliateFingerprintClusters: mockAffiliateFingerprintClusters,
+      affiliateBlockFingerprint: mockAffiliateBlockFingerprint,
+      inference: {
+        dailyCost: mockDailyCost,
+        pageCost: mockPageCost,
+        cacheHitRate: mockCacheHitRate,
+        sessionCost: mockSessionCost,
+      },
+    },
+  },
+  trpc: {},
+}));
+
+import {
+  blockAffiliateFingerprint,
+  getAffiliateFingerprintClusters,
+  getAffiliateSuppressions,
+  getAffiliateVelocity,
+} from "@/lib/admin-affiliate-api";
+
+import {
+  getCacheStats,
+  getDailyCost,
+  getPageCost,
+  getSessionCost,
+} from "@/lib/admin-inference-api";
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+// ---- admin-affiliate-api ----
+
+describe("admin-affiliate-api", () => {
+  describe("getAffiliateSuppressions", () => {
+    it("passes default limit and offset", async () => {
+      const data = { events: [], total: 0 };
+      mockAffiliateSuppressions.query.mockResolvedValue(data);
+
+      const result = await getAffiliateSuppressions();
+
+      expect(mockAffiliateSuppressions.query).toHaveBeenCalledWith({ limit: 50, offset: 0 });
+      expect(result).toEqual(data);
+    });
+
+    it("passes custom limit and offset", async () => {
+      const data = { events: [{ id: "s1" }], total: 1 };
+      mockAffiliateSuppressions.query.mockResolvedValue(data);
+
+      const result = await getAffiliateSuppressions(10, 5);
+
+      expect(mockAffiliateSuppressions.query).toHaveBeenCalledWith({ limit: 10, offset: 5 });
+      expect(result).toEqual(data);
+    });
+
+    it("propagates errors from the tRPC client", async () => {
+      mockAffiliateSuppressions.query.mockRejectedValue(new Error("Server error"));
+
+      await expect(getAffiliateSuppressions()).rejects.toThrow("Server error");
+    });
+  });
+
+  describe("getAffiliateVelocity", () => {
+    it("passes default caps", async () => {
+      const data = [{ referrerTenantId: "t1", payoutCount30d: 5, payoutTotal30dCents: 1000 }];
+      mockAffiliateVelocity.query.mockResolvedValue(data);
+
+      const result = await getAffiliateVelocity();
+
+      expect(mockAffiliateVelocity.query).toHaveBeenCalledWith({
+        capReferrals: 20,
+        capCredits: 20000,
+      });
+      expect(result).toEqual(data);
+    });
+
+    it("passes custom caps", async () => {
+      mockAffiliateVelocity.query.mockResolvedValue([]);
+
+      await getAffiliateVelocity(5, 500);
+
+      expect(mockAffiliateVelocity.query).toHaveBeenCalledWith({
+        capReferrals: 5,
+        capCredits: 500,
+      });
+    });
+
+    it("propagates errors", async () => {
+      mockAffiliateVelocity.query.mockRejectedValue(new Error("fail"));
+
+      await expect(getAffiliateVelocity()).rejects.toThrow("fail");
+    });
+  });
+
+  describe("getAffiliateFingerprintClusters", () => {
+    it("returns clusters", async () => {
+      const data = [{ stripeFingerprint: "fp1", tenantIds: ["t1", "t2"] }];
+      mockAffiliateFingerprintClusters.query.mockResolvedValue(data);
+
+      const result = await getAffiliateFingerprintClusters();
+
+      expect(mockAffiliateFingerprintClusters.query).toHaveBeenCalled();
+      expect(result).toEqual(data);
+    });
+
+    it("propagates errors", async () => {
+      mockAffiliateFingerprintClusters.query.mockRejectedValue(new Error("fail"));
+
+      await expect(getAffiliateFingerprintClusters()).rejects.toThrow("fail");
+    });
+  });
+
+  describe("blockAffiliateFingerprint", () => {
+    it("sends fingerprint and returns success", async () => {
+      mockAffiliateBlockFingerprint.mutate.mockResolvedValue({ success: true });
+
+      const result = await blockAffiliateFingerprint("fp_abc");
+
+      expect(mockAffiliateBlockFingerprint.mutate).toHaveBeenCalledWith({
+        fingerprint: "fp_abc",
+      });
+      expect(result).toEqual({ success: true });
+    });
+
+    it("propagates errors", async () => {
+      mockAffiliateBlockFingerprint.mutate.mockRejectedValue(new Error("forbidden"));
+
+      await expect(blockAffiliateFingerprint("fp_abc")).rejects.toThrow("forbidden");
+    });
+  });
+});
+
+// ---- admin-inference-api ----
+
+describe("admin-inference-api", () => {
+  const since = Date.now() - 7 * 86400000;
+
+  describe("getDailyCost", () => {
+    it("passes since parameter and returns data", async () => {
+      const data = [{ day: "2026-02-28", totalCostUsd: 1.5, sessionCount: 10 }];
+      mockDailyCost.query.mockResolvedValue(data);
+
+      const result = await getDailyCost(since);
+
+      expect(mockDailyCost.query).toHaveBeenCalledWith({ since });
+      expect(result).toEqual(data);
+    });
+
+    it("propagates errors", async () => {
+      mockDailyCost.query.mockRejectedValue(new Error("fail"));
+
+      await expect(getDailyCost(since)).rejects.toThrow("fail");
+    });
+  });
+
+  describe("getPageCost", () => {
+    it("passes since parameter and returns data", async () => {
+      const data = [{ page: "/dashboard", totalCostUsd: 0.5, callCount: 20, avgCostUsd: 0.025 }];
+      mockPageCost.query.mockResolvedValue(data);
+
+      const result = await getPageCost(since);
+
+      expect(mockPageCost.query).toHaveBeenCalledWith({ since });
+      expect(result).toEqual(data);
+    });
+
+    it("propagates errors", async () => {
+      mockPageCost.query.mockRejectedValue(new Error("fail"));
+
+      await expect(getPageCost(since)).rejects.toThrow("fail");
+    });
+  });
+
+  describe("getCacheStats", () => {
+    it("passes since parameter and returns cache stats", async () => {
+      const data = {
+        hitRate: 0.85,
+        cachedTokens: 1000,
+        cacheWriteTokens: 200,
+        uncachedTokens: 150,
+      };
+      mockCacheHitRate.query.mockResolvedValue(data);
+
+      const result = await getCacheStats(since);
+
+      expect(mockCacheHitRate.query).toHaveBeenCalledWith({ since });
+      expect(result).toEqual(data);
+    });
+
+    it("propagates errors", async () => {
+      mockCacheHitRate.query.mockRejectedValue(new Error("fail"));
+
+      await expect(getCacheStats(since)).rejects.toThrow("fail");
+    });
+  });
+
+  describe("getSessionCost", () => {
+    it("passes since parameter and returns session summary", async () => {
+      const data = { totalCostUsd: 10.0, totalSessions: 50, avgCostPerSession: 0.2 };
+      mockSessionCost.query.mockResolvedValue(data);
+
+      const result = await getSessionCost(since);
+
+      expect(mockSessionCost.query).toHaveBeenCalledWith({ since });
+      expect(result).toEqual(data);
+    });
+
+    it("propagates errors", async () => {
+      mockSessionCost.query.mockRejectedValue(new Error("fail"));
+
+      await expect(getSessionCost(since)).rejects.toThrow("fail");
+    });
+  });
+});

package/src/__tests__/admin-gpu-api.test.ts

@@ -0,0 +1,188 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// ---- Mock apiFetch and apiFetchRaw ----
+const { mockApiFetch, mockApiFetchRaw } = vi.hoisted(() => ({
+  mockApiFetch: vi.fn(),
+  mockApiFetchRaw: vi.fn(),
+}));
+
+vi.mock("@/lib/api", () => ({
+  apiFetch: mockApiFetch,
+  apiFetchRaw: mockApiFetchRaw,
+}));
+
+import type { GpuNode, GpuRegion, GpuSize } from "@/lib/admin-gpu-api";
+import {
+  destroyGpuNode,
+  getGpuNode,
+  listGpuNodes,
+  listGpuRegions,
+  listGpuSizes,
+  provisionGpuNode,
+  rebootGpuNode,
+} from "@/lib/admin-gpu-api";
+
+function fakeNode(overrides: Partial<GpuNode> = {}): GpuNode {
+  return {
+    id: "gpu-1",
+    name: "test-node",
+    region: "nyc3",
+    size: "gpu-h100x1",
+    status: "running",
+    ipAddress: "10.0.0.1",
+    utilization: 42,
+    memoryUsedMib: 20480,
+    memoryTotalMib: 81920,
+    temperatureCelsius: 65,
+    createdAt: "2026-01-01T00:00:00Z",
+    updatedAt: "2026-01-01T00:00:00Z",
+    ...overrides,
+  };
+}
+
+function fakeRegion(overrides: Partial<GpuRegion> = {}): GpuRegion {
+  return { slug: "nyc3", name: "New York 3", available: true, ...overrides };
+}
+
+function fakeSize(overrides: Partial<GpuSize> = {}): GpuSize {
+  return {
+    slug: "gpu-h100x1",
+    name: "H100 x1",
+    vcpus: 8,
+    memoryMib: 131072,
+    gpuCount: 1,
+    gpuModel: "H100",
+    priceMonthly: 2500,
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("listGpuNodes", () => {
+  it("calls /admin/gpu and returns nodes", async () => {
+    const nodes = [fakeNode()];
+    mockApiFetch.mockResolvedValue(nodes);
+
+    const result = await listGpuNodes();
+
+    expect(mockApiFetch).toHaveBeenCalledWith("/admin/gpu");
+    expect(result).toEqual(nodes);
+  });
+
+  it("throws when API fails", async () => {
+    mockApiFetch.mockRejectedValue(new Error("API down"));
+    await expect(listGpuNodes()).rejects.toThrow("API down");
+  });
+});
+
+describe("getGpuNode", () => {
+  it("calls /admin/gpu/:id", async () => {
+    const node = fakeNode({ id: "gpu-42" });
+    mockApiFetch.mockResolvedValue(node);
+
+    const result = await getGpuNode("gpu-42");
+
+    expect(mockApiFetch).toHaveBeenCalledWith("/admin/gpu/gpu-42");
+    expect(result).toEqual(node);
+  });
+
+  it("throws when API fails", async () => {
+    mockApiFetch.mockRejectedValue(new Error("Not found"));
+    await expect(getGpuNode("gpu-99")).rejects.toThrow("Not found");
+  });
+});
+
+describe("provisionGpuNode", () => {
+  it("POSTs to /admin/gpu and returns new node", async () => {
+    const node = fakeNode({ name: "new-node", status: "provisioning" });
+    mockApiFetch.mockResolvedValue(node);
+
+    const result = await provisionGpuNode({ name: "new-node", region: "nyc3", size: "gpu-h100x1" });
+
+    expect(mockApiFetch).toHaveBeenCalledWith("/admin/gpu", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: "new-node", region: "nyc3", size: "gpu-h100x1" }),
+    });
+    expect(result).toEqual(node);
+  });
+
+  it("throws when provisioning fails", async () => {
+    mockApiFetch.mockRejectedValue(new Error("Quota exceeded"));
+    await expect(
+      provisionGpuNode({ name: "x", region: "nyc3", size: "gpu-h100x1" }),
+    ).rejects.toThrow("Quota exceeded");
+  });
+});
+
+describe("destroyGpuNode", () => {
+  it("DELETEs /admin/gpu/:id", async () => {
+    mockApiFetchRaw.mockResolvedValue({ ok: true } as Response);
+
+    await destroyGpuNode("gpu-1");
+
+    expect(mockApiFetchRaw).toHaveBeenCalledWith("/admin/gpu/gpu-1", { method: "DELETE" });
+  });
+
+  it("throws when destroy fails", async () => {
+    mockApiFetchRaw.mockResolvedValue({
+      ok: false,
+      text: () => Promise.resolve("Destroy failed"),
+    } as unknown as Response);
+    await expect(destroyGpuNode("gpu-1")).rejects.toThrow("Destroy failed");
+  });
+});
+
+describe("rebootGpuNode", () => {
+  it("POSTs to /admin/gpu/:id/reboot", async () => {
+    const updated = fakeNode({ status: "rebooting" });
+    mockApiFetch.mockResolvedValue(updated);
+
+    const result = await rebootGpuNode("gpu-1");
+
+    expect(mockApiFetch).toHaveBeenCalledWith("/admin/gpu/gpu-1/reboot", { method: "POST" });
+    expect(result).toEqual(updated);
+  });
+
+  it("throws when reboot fails", async () => {
+    mockApiFetch.mockRejectedValue(new Error("Reboot failed"));
+    await expect(rebootGpuNode("gpu-1")).rejects.toThrow("Reboot failed");
+  });
+});
+
+describe("listGpuRegions", () => {
+  it("calls /admin/gpu/regions", async () => {
+    const regions = [fakeRegion()];
+    mockApiFetch.mockResolvedValue(regions);
+
+    const result = await listGpuRegions();
+
+    expect(mockApiFetch).toHaveBeenCalledWith("/admin/gpu/regions");
+    expect(result).toEqual(regions);
+  });
+
+  it("throws when API fails", async () => {
+    mockApiFetch.mockRejectedValue(new Error("fail"));
+    await expect(listGpuRegions()).rejects.toThrow("fail");
+  });
+});
+
+describe("listGpuSizes", () => {
+  it("calls /admin/gpu/sizes", async () => {
+    const sizes = [fakeSize()];
+    mockApiFetch.mockResolvedValue(sizes);
+
+    const result = await listGpuSizes();
+
+    expect(mockApiFetch).toHaveBeenCalledWith("/admin/gpu/sizes");
+    expect(result).toEqual(sizes);
+  });
+
+  it("throws when API fails", async () => {
+    mockApiFetch.mockRejectedValue(new Error("fail"));
+    await expect(listGpuSizes()).rejects.toThrow("fail");
+  });
+});

package/src/__tests__/admin-guard.test.tsx

@@ -0,0 +1,79 @@
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("@/lib/auth-client", () => ({
+  useSession: vi.fn(),
+}));
+
+vi.mock("next/navigation", () => ({
+  useRouter: () => ({ push: vi.fn() }),
+  redirect: vi.fn(),
+}));
+
+import { AdminGuard } from "@/components/admin/admin-guard";
+import { useSession } from "@/lib/auth-client";
+
+const mockUseSession = vi.mocked(useSession);
+
+describe("AdminGuard", () => {
+  it("renders children when user is platform_admin", () => {
+    mockUseSession.mockReturnValue({
+      data: {
+        session: {} as never,
+        user: {
+          id: "1",
+          name: "Admin",
+          email: "a@b.com",
+          role: "platform_admin",
+        },
+      },
+      isPending: false,
+      isRefetching: false,
+      error: null,
+      refetch: vi.fn(),
+    } as unknown as ReturnType<typeof useSession>);
+
+    render(
+      <AdminGuard>
+        <div>Admin Content</div>
+      </AdminGuard>,
+    );
+    expect(screen.getByText("Admin Content")).toBeInTheDocument();
+  });
+
+  it("shows access denied when user is not admin", () => {
+    mockUseSession.mockReturnValue({
+      data: {
+        session: {} as never,
+        user: { id: "2", name: "User", email: "u@b.com", role: "user" },
+      },
+      isPending: false,
+      isRefetching: false,
+      error: null,
+      refetch: vi.fn(),
+    } as unknown as ReturnType<typeof useSession>);
+
+    render(
+      <AdminGuard>
+        <div>Admin Content</div>
+      </AdminGuard>,
+    );
+    expect(screen.queryByText("Admin Content")).not.toBeInTheDocument();
+    expect(screen.getByText(/access denied/i)).toBeInTheDocument();
+  });
+
+  it("shows skeleton when session is loading", () => {
+    mockUseSession.mockReturnValue({
+      data: null,
+      isPending: true,
+      error: null,
+    } as ReturnType<typeof useSession>);
+
+    render(
+      <AdminGuard>
+        <div>Admin Content</div>
+      </AdminGuard>,
+    );
+    expect(screen.queryByText("Admin Content")).not.toBeInTheDocument();
+  });
+});

package/src/__tests__/admin-marketplace-api.test.ts

@@ -0,0 +1,179 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// ---- Mock tRPC client ----
+const { mockListPlugins, mockUpdatePlugin, mockAddPlugin } = vi.hoisted(() => ({
+  mockListPlugins: { query: vi.fn() },
+  mockUpdatePlugin: { mutate: vi.fn() },
+  mockAddPlugin: { mutate: vi.fn() },
+}));
+
+vi.mock("@/lib/trpc", () => ({
+  trpcVanilla: {
+    adminMarketplace: {
+      listPlugins: mockListPlugins,
+      updatePlugin: mockUpdatePlugin,
+      addPlugin: mockAddPlugin,
+    },
+  },
+  trpc: {},
+}));
+
+import type { AdminPlugin } from "@/lib/admin-marketplace-api";
+import {
+  addPluginByNpm,
+  getAllPlugins,
+  getDiscoveryQueue,
+  getEnabledPlugins,
+  reorderPlugins,
+  updatePlugin,
+} from "@/lib/admin-marketplace-api";
+
+function fakePlugin(overrides: Partial<AdminPlugin> = {}): AdminPlugin {
+  return {
+    id: "test-1",
+    npm_package: "@test/plugin",
+    name: "Test Plugin",
+    description: "A test plugin",
+    version: "1.0.0",
+    author: "Test",
+    category: "utility",
+    icon_url: null,
+    enabled: true,
+    featured: false,
+    sort_order: 0,
+    notes: "",
+    superpower_md: null,
+    discovered_at: 1000,
+    enabled_at: 2000,
+    reviewed: true,
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("getAllPlugins", () => {
+  it("returns plugins from tRPC", async () => {
+    const plugins = [fakePlugin()];
+    mockListPlugins.query.mockResolvedValue(plugins);
+
+    const result = await getAllPlugins();
+
+    expect(mockListPlugins.query).toHaveBeenCalledWith(undefined);
+    expect(result).toEqual(plugins);
+  });
+
+  it("throws when API fails", async () => {
+    mockListPlugins.query.mockRejectedValue(new Error("API down"));
+
+    await expect(getAllPlugins()).rejects.toThrow("API down");
+  });
+});
+
+describe("getDiscoveryQueue", () => {
+  it("returns only unreviewed plugins from tRPC", async () => {
+    const plugins = [
+      fakePlugin({ id: "a", reviewed: true }),
+      fakePlugin({ id: "b", reviewed: false }),
+    ];
+    mockListPlugins.query.mockResolvedValue(plugins);
+
+    const result = await getDiscoveryQueue();
+
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe("b");
+  });
+
+  it("throws when API fails", async () => {
+    mockListPlugins.query.mockRejectedValue(new Error("fail"));
+
+    await expect(getDiscoveryQueue()).rejects.toThrow("fail");
+  });
+});
+
+describe("getEnabledPlugins", () => {
+  it("returns enabled+reviewed plugins sorted by sort_order", async () => {
+    const plugins = [
+      fakePlugin({ id: "b", enabled: true, reviewed: true, sort_order: 2 }),
+      fakePlugin({ id: "a", enabled: true, reviewed: true, sort_order: 1 }),
+      fakePlugin({ id: "c", enabled: false, reviewed: true, sort_order: 0 }),
+      fakePlugin({ id: "d", enabled: true, reviewed: false, sort_order: 0 }),
+    ];
+    mockListPlugins.query.mockResolvedValue(plugins);
+
+    const result = await getEnabledPlugins();
+
+    expect(result).toHaveLength(2);
+    expect(result[0].id).toBe("a");
+    expect(result[1].id).toBe("b");
+  });
+
+  it("throws when API fails", async () => {
+    mockListPlugins.query.mockRejectedValue(new Error("fail"));
+
+    await expect(getEnabledPlugins()).rejects.toThrow("fail");
+  });
+});
+
+describe("updatePlugin", () => {
+  it("calls tRPC mutate and returns updated plugin", async () => {
+    const updated = fakePlugin({ id: "x", notes: "updated" });
+    mockUpdatePlugin.mutate.mockResolvedValue(updated);
+
+    const result = await updatePlugin({ id: "x", notes: "updated" });
+
+    expect(mockUpdatePlugin.mutate).toHaveBeenCalledWith({ id: "x", notes: "updated" });
+    expect(result).toEqual(updated);
+  });
+
+  it("throws when API fails", async () => {
+    mockUpdatePlugin.mutate.mockRejectedValue(new Error("fail"));
+
+    await expect(updatePlugin({ id: "x" })).rejects.toThrow("fail");
+  });
+});
+
+describe("addPluginByNpm", () => {
+  it("calls tRPC mutate and returns new plugin", async () => {
+    const newPlugin = fakePlugin({ npm_package: "@foo/bar" });
+    mockAddPlugin.mutate.mockResolvedValue(newPlugin);
+
+    const result = await addPluginByNpm({ npm_package: "@foo/bar" });
+
+    expect(mockAddPlugin.mutate).toHaveBeenCalledWith({ npm_package: "@foo/bar" });
+    expect(result).toEqual(newPlugin);
+  });
+
+  it("throws when API fails", async () => {
+    mockAddPlugin.mutate.mockRejectedValue(new Error("fail"));
+
+    await expect(addPluginByNpm({ npm_package: "@foo/bar" })).rejects.toThrow("fail");
+  });
+});
+
+describe("reorderPlugins", () => {
+  it("calls updatePlugin.mutate for each id with correct sort_order", async () => {
+    mockUpdatePlugin.mutate.mockResolvedValue({});
+
+    await reorderPlugins(["c", "a", "b"]);
+
+    expect(mockUpdatePlugin.mutate).toHaveBeenCalledTimes(3);
+    expect(mockUpdatePlugin.mutate).toHaveBeenCalledWith({ id: "c", sort_order: 0 });
+    expect(mockUpdatePlugin.mutate).toHaveBeenCalledWith({ id: "a", sort_order: 1 });
+    expect(mockUpdatePlugin.mutate).toHaveBeenCalledWith({ id: "b", sort_order: 2 });
+  });
+
+  it("handles empty array without calling mutate", async () => {
+    await reorderPlugins([]);
+
+    expect(mockUpdatePlugin.mutate).not.toHaveBeenCalled();
+  });
+
+  it("throws when API fails", async () => {
+    mockUpdatePlugin.mutate.mockRejectedValue(new Error("fail"));
+
+    await expect(reorderPlugins(["a"])).rejects.toThrow("fail");
+  });
+});