@wopr-network/platform-ui-core 1.0.0

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

@@ -0,0 +1,157 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// We test the middleware function directly by importing from the module.
+// The middleware was renamed from proxy.ts to middleware.ts by WOP-1128.
+import middleware from "../proxy";
+
+// Minimal NextRequest-compatible mock
+function mockRequest(opts: {
+  method?: string;
+  url: string;
+  headers?: Record<string, string>;
+  cookies?: Record<string, string>;
+}) {
+  const url = new URL(opts.url);
+  const headers = new Headers(opts.headers ?? {});
+  if (!headers.has("host")) {
+    headers.set("host", url.host);
+  }
+  const cookieMap = new Map(
+    Object.entries(opts.cookies ?? {}).map(([k, v]) => [k, { name: k, value: v }]),
+  );
+  return {
+    method: opts.method ?? "GET",
+    url: opts.url,
+    nextUrl: url,
+    headers,
+    cookies: {
+      get: (name: string) => cookieMap.get(name),
+      getAll: () => [...cookieMap.values()],
+      has: (name: string) => cookieMap.has(name),
+    },
+  } as unknown as Parameters<typeof middleware>[0];
+}
+
+// Mock global fetch for Better Auth session calls
+const originalFetch = globalThis.fetch;
+
+beforeEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+describe("Admin route middleware authorization", () => {
+  it("redirects non-admin users from /admin/tenants to /marketplace", async () => {
+    // Mock Better Auth get-session returning a regular user
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        session: { id: "s1" },
+        user: { id: "u1", role: "user" },
+      }),
+    });
+
+    const req = mockRequest({
+      url: "https://localhost:3000/admin/tenants",
+      cookies: { "better-auth.session_token": "valid-token" },
+    });
+
+    const res = await middleware(req);
+    // Should redirect to /marketplace
+    expect(res.status).toBe(307);
+    expect(res.headers.get("location")).toContain("/marketplace");
+  });
+
+  it("allows platform_admin users to access /admin/tenants", async () => {
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        session: { id: "s1" },
+        user: { id: "u1", role: "platform_admin" },
+      }),
+    });
+
+    const req = mockRequest({
+      url: "https://localhost:3000/admin/tenants",
+      cookies: { "better-auth.session_token": "valid-token" },
+    });
+
+    const res = await middleware(req);
+    // Should pass through (not a redirect)
+    expect(res.status).not.toBe(307);
+  });
+
+  it("redirects unauthenticated users from /admin to /login", async () => {
+    const req = mockRequest({
+      url: "https://localhost:3000/admin/tenants",
+      // No session cookie
+    });
+
+    const res = await middleware(req);
+    // Existing auth check should redirect to /login
+    expect(res.status).toBe(307);
+    expect(res.headers.get("location")).toContain("/login");
+  });
+
+  it("redirects to /marketplace when session fetch fails", async () => {
+    // Simulate network error or 500 from Better Auth
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: false,
+      status: 500,
+      json: async () => ({}),
+    });
+
+    const req = mockRequest({
+      url: "https://localhost:3000/admin/tenants",
+      cookies: { "better-auth.session_token": "valid-token" },
+    });
+
+    const res = await middleware(req);
+    // On failure, deny access (fail closed)
+    expect(res.status).toBe(307);
+    expect(res.headers.get("location")).toContain("/marketplace");
+  });
+
+  it("sets no-cache headers on admin page responses for admin users", async () => {
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        session: { id: "s1" },
+        user: { id: "u1", role: "platform_admin" },
+      }),
+    });
+
+    const req = mockRequest({
+      url: "https://localhost:3000/admin/tenants",
+      cookies: { "better-auth.session_token": "valid-token" },
+    });
+
+    const res = await middleware(req);
+    expect(res.headers.get("cache-control")).toBe("no-store, no-cache, must-revalidate");
+    expect(res.headers.get("pragma")).toBe("no-cache");
+  });
+
+  it("does not set restrictive cache headers on non-admin pages", async () => {
+    const req = mockRequest({
+      url: "https://localhost:3000/marketplace",
+      cookies: { "better-auth.session_token": "valid-token" },
+    });
+
+    const res = await middleware(req);
+    expect(res.headers.get("cache-control")).toBeNull();
+    expect(res.headers.get("pragma")).toBeNull();
+  });
+
+  it("does not call get-session for non-admin routes", async () => {
+    const fetchSpy = vi.fn();
+    globalThis.fetch = fetchSpy;
+
+    const req = mockRequest({
+      url: "https://localhost:3000/marketplace",
+      cookies: { "better-auth.session_token": "valid-token" },
+    });
+
+    await middleware(req);
+    // Should NOT have called Better Auth — not an admin route
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,95 @@
+import { render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@/lib/admin-api", () => ({
+  getUsersList: vi.fn(),
+  suspendTenant: vi.fn(),
+  reactivateTenant: vi.fn(),
+  grantCredits: vi.fn(),
+}));
+
+vi.mock("next/navigation", () => ({
+  useRouter: () => ({ push: vi.fn() }),
+  usePathname: () => "/admin/tenants",
+  redirect: vi.fn(),
+}));
+
+import { TenantTable } from "@/components/admin/tenant-table";
+import { getUsersList } from "@/lib/admin-api";
+
+const mockGetUsersList = vi.mocked(getUsersList);
+
+const fakeUsers = [
+  {
+    id: "u1",
+    email: "alice@example.com",
+    name: "Alice",
+    tenant_id: "t1",
+    status: "active",
+    role: "user",
+    credit_balance_cents: 5000,
+    agent_count: 2,
+    last_seen: Date.now(),
+    created_at: Date.now() - 86400000,
+  },
+  {
+    id: "u2",
+    email: "bob@example.com",
+    name: "Bob",
+    tenant_id: "t2",
+    status: "suspended",
+    role: "user",
+    credit_balance_cents: 0,
+    agent_count: 0,
+    last_seen: null,
+    created_at: Date.now() - 172800000,
+  },
+];
+
+describe("TenantTable", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetUsersList.mockResolvedValue({ users: fakeUsers, total: 2 });
+  });
+
+  it("renders user rows after loading", async () => {
+    render(<TenantTable />);
+    await waitFor(() => {
+      expect(screen.getByText("alice@example.com")).toBeInTheDocument();
+      expect(screen.getByText("bob@example.com")).toBeInTheDocument();
+    });
+  });
+
+  it("shows search input", () => {
+    render(<TenantTable />);
+    expect(screen.getByPlaceholderText(/search/i)).toBeInTheDocument();
+  });
+
+  it("calls getUsersList with search param on input", async () => {
+    const user = userEvent.setup();
+    render(<TenantTable />);
+    const searchInput = screen.getByPlaceholderText(/search/i);
+    await user.type(searchInput, "alice");
+    await waitFor(
+      () => {
+        expect(mockGetUsersList).toHaveBeenCalledWith(expect.objectContaining({ search: "alice" }));
+      },
+      { timeout: 2000 },
+    );
+  });
+
+  it("displays credit balance formatted as dollars", async () => {
+    render(<TenantTable />);
+    await waitFor(() => {
+      expect(screen.getByText("$50.00")).toBeInTheDocument();
+    });
+  });
+
+  it("shows status badge for suspended users", async () => {
+    render(<TenantTable />);
+    await waitFor(() => {
+      expect(screen.getByText("suspended")).toBeInTheDocument();
+    });
+  });
+});

package/src/__tests__/affiliate-dashboard.test.tsx

@@ -0,0 +1,178 @@
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { describe, expect, it, vi } from "vitest";
+import type { AffiliateReferralsResponse, AffiliateStats } from "@/lib/api";
+
+// Mock next/navigation
+vi.mock("next/navigation", () => ({
+  useRouter: () => ({ push: vi.fn() }),
+  useSearchParams: () => new URLSearchParams(),
+  usePathname: () => "/billing/referrals",
+}));
+
+// Mock better-auth/react
+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(),
+  }),
+}));
+
+const MOCK_STATS: AffiliateStats = {
+  referralCode: "t7k9x",
+  referralUrl: "https://localhost/join?ref=t7k9x",
+  totalReferred: 12,
+  totalConverted: 8,
+  totalEarnedCents: 16000,
+};
+
+const MOCK_REFERRALS: AffiliateReferralsResponse = {
+  referrals: [
+    {
+      id: "ref-1",
+      maskedEmail: "use***@example.com",
+      joinedAt: "2026-02-18T00:00:00Z",
+      status: "matched",
+      matchAmountCents: 2000,
+    },
+    {
+      id: "ref-2",
+      maskedEmail: "use***@test.com",
+      joinedAt: "2026-02-20T00:00:00Z",
+      status: "pending",
+      matchAmountCents: null,
+    },
+    {
+      id: "ref-3",
+      maskedEmail: "ano***@test.com",
+      joinedAt: "2026-02-21T00:00:00Z",
+      status: "pending",
+      matchAmountCents: null,
+    },
+  ],
+  total: 3,
+};
+
+vi.mock("@/lib/api", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@/lib/api")>();
+  return {
+    ...actual,
+    getAffiliateStats: vi.fn().mockResolvedValue(MOCK_STATS),
+    getAffiliateReferrals: vi.fn().mockResolvedValue(MOCK_REFERRALS),
+    getInferenceMode: vi.fn().mockResolvedValue("byok"),
+  };
+});
+
+describe("Affiliate Dashboard", () => {
+  it("renders Refer & Earn heading", async () => {
+    const { default: ReferralsPage } = await import("../app/(dashboard)/billing/referrals/page");
+    render(<ReferralsPage />);
+
+    expect(document.querySelector('[data-slot="skeleton"]')).toBeInTheDocument();
+    expect(await screen.findByText("Refer & Earn")).toBeInTheDocument();
+  });
+
+  it("displays the referral link", async () => {
+    const { default: ReferralsPage } = await import("../app/(dashboard)/billing/referrals/page");
+    render(<ReferralsPage />);
+
+    expect(await screen.findByText("https://localhost/join?ref=t7k9x")).toBeInTheDocument();
+  });
+
+  it("renders copy button", async () => {
+    const { default: ReferralsPage } = await import("../app/(dashboard)/billing/referrals/page");
+    render(<ReferralsPage />);
+
+    expect(await screen.findByRole("button", { name: /copy/i })).toBeInTheDocument();
+  });
+
+  it("renders share button", async () => {
+    const { default: ReferralsPage } = await import("../app/(dashboard)/billing/referrals/page");
+    render(<ReferralsPage />);
+
+    expect(await screen.findByRole("button", { name: /share/i })).toBeInTheDocument();
+  });
+
+  it("displays the value proposition", async () => {
+    const { default: ReferralsPage } = await import("../app/(dashboard)/billing/referrals/page");
+    render(<ReferralsPage />);
+
+    expect(await screen.findByText(/20% extra credits/)).toBeInTheDocument();
+    expect(screen.getByText(/matching credits/)).toBeInTheDocument();
+  });
+
+  it("renders aggregate stats", async () => {
+    const { default: ReferralsPage } = await import("../app/(dashboard)/billing/referrals/page");
+    render(<ReferralsPage />);
+
+    expect(await screen.findByText("12")).toBeInTheDocument();
+    expect(screen.getByText("8")).toBeInTheDocument();
+    expect(screen.getByText("$160.00")).toBeInTheDocument();
+    expect(screen.getByText(/friends referred/i)).toBeInTheDocument();
+    expect(screen.getByText(/converted/i)).toBeInTheDocument();
+    expect(screen.getByText(/earned/i)).toBeInTheDocument();
+  });
+
+  it("renders recent referrals with matched status", async () => {
+    const { default: ReferralsPage } = await import("../app/(dashboard)/billing/referrals/page");
+    render(<ReferralsPage />);
+
+    expect(await screen.findByText("use***@example.com")).toBeInTheDocument();
+    expect(screen.getByText("$20.00")).toBeInTheDocument();
+  });
+
+  it("renders recent referrals with pending status", async () => {
+    const { default: ReferralsPage } = await import("../app/(dashboard)/billing/referrals/page");
+    render(<ReferralsPage />);
+
+    expect(await screen.findByText("use***@test.com")).toBeInTheDocument();
+    const pendingBadges = screen.getAllByText("pending");
+    expect(pendingBadges.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it("copies referral link to clipboard on copy button click", async () => {
+    const user = userEvent.setup();
+    const writeText = vi.fn().mockResolvedValue(undefined);
+    Object.defineProperty(navigator, "clipboard", {
+      value: { writeText },
+      configurable: true,
+      writable: true,
+    });
+
+    const { default: ReferralsPage } = await import("../app/(dashboard)/billing/referrals/page");
+    render(<ReferralsPage />);
+
+    const copyBtn = await screen.findByRole("button", { name: /copy/i });
+    await user.click(copyBtn);
+
+    expect(writeText).toHaveBeenCalledWith("https://localhost/join?ref=t7k9x");
+  });
+});
+
+describe("Affiliate Dashboard error state", () => {
+  it("shows error message and retry button when API fails", async () => {
+    const api = await import("@/lib/api");
+    vi.mocked(api.getAffiliateStats).mockRejectedValueOnce(new Error("Network error"));
+
+    const { AffiliateDashboard } = await import("../components/billing/affiliate-dashboard");
+    render(<AffiliateDashboard />);
+
+    expect(await screen.findByText("Failed to load referral data.")).toBeInTheDocument();
+    expect(screen.getByRole("button", { name: /retry/i })).toBeInTheDocument();
+  });
+});
+
+describe("Billing layout with Referrals nav", () => {
+  it("renders Refer & Earn navigation link", async () => {
+    const { default: BillingLayout } = await import("../app/(dashboard)/billing/layout");
+    render(
+      <BillingLayout>
+        <div>child content</div>
+      </BillingLayout>,
+    );
+
+    expect(screen.getByText("Refer & Earn")).toBeInTheDocument();
+  });
+});

package/src/__tests__/api-401-redirect.test.ts

@@ -0,0 +1,78 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@/lib/api-config", () => ({
+  API_BASE_URL: "https://api.test/api",
+  PLATFORM_BASE_URL: "https://api.test",
+}));
+
+describe("401 redirect handling", () => {
+  const mockLocation = { href: "", pathname: "/dashboard", search: "" };
+  const mockFetch = vi.fn();
+
+  beforeEach(() => {
+    mockLocation.href = "";
+    mockLocation.pathname = "/dashboard";
+    mockLocation.search = "";
+    vi.stubGlobal("fetch", mockFetch);
+    vi.stubGlobal("window", { location: mockLocation });
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    mockFetch.mockReset();
+    vi.unstubAllGlobals();
+  });
+
+  it("handleUnauthorized redirects to /login with reason and callbackUrl", async () => {
+    const { handleUnauthorized } = await import("@/lib/fetch-utils");
+    expect(() => handleUnauthorized()).toThrow("Session expired");
+    expect(mockLocation.href).toBe("/login?reason=expired&callbackUrl=%2Fdashboard");
+  });
+
+  it("UnauthorizedError has correct name and message", async () => {
+    const { UnauthorizedError } = await import("@/lib/fetch-utils");
+    const err = new UnauthorizedError();
+    expect(err.name).toBe("UnauthorizedError");
+    expect(err.message).toBe("Session expired");
+  });
+
+  it("apiFetch redirects on 401", async () => {
+    mockFetch.mockResolvedValueOnce({ ok: false, status: 401, statusText: "Unauthorized" });
+    const { getProfile } = await import("@/lib/api");
+    await expect(getProfile()).rejects.toThrow("Session expired");
+    expect(mockLocation.href).toContain("/login?reason=expired");
+  });
+
+  it("fleetFetch redirects on 401", async () => {
+    mockFetch.mockResolvedValueOnce({ ok: false, status: 401, statusText: "Unauthorized" });
+    const { listInstances } = await import("@/lib/api");
+    await expect(listInstances()).rejects.toThrow("Session expired");
+    expect(mockLocation.href).toContain("/login?reason=expired");
+  });
+
+  it("trpcFetch redirects on 401", async () => {
+    mockFetch.mockResolvedValueOnce({ ok: false, status: 401, statusText: "Unauthorized" });
+    const { getCurrentPlan } = await import("@/lib/api");
+    await expect(getCurrentPlan()).rejects.toThrow("Session expired");
+    expect(mockLocation.href).toContain("/login?reason=expired");
+  });
+
+  it("non-401 errors still throw generic message from apiFetch", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 500,
+      statusText: "Internal Server Error",
+      json: () => Promise.resolve({}),
+    });
+    const { getProfile } = await import("@/lib/api");
+    await expect(getProfile()).rejects.toThrow("API error: 500 Internal Server Error");
+    expect(mockLocation.href).toBe("");
+  });
+
+  it("bot-settings-data apiFetch redirects on 401", async () => {
+    mockFetch.mockResolvedValueOnce({ ok: false, status: 401, statusText: "Unauthorized" });
+    const { getBotSettings } = await import("@/lib/bot-settings-data");
+    await expect(getBotSettings("bot-1")).rejects.toThrow("Session expired");
+    expect(mockLocation.href).toContain("/login?reason=expired");
+  });
+});