@wopr-network/platform-ui-core 1.0.0

package/src/__tests__/degraded-state-banner.test.tsx

@@ -0,0 +1,130 @@
+import { render, screen, waitFor } 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: () => "/",
+}));
+
+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/api", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@/lib/api")>();
+  return {
+    ...actual,
+    getAccountStatus: vi.fn().mockResolvedValue(null),
+  };
+});
+
+describe("DegradedStateBanner", () => {
+  it("renders nothing when account status is active", async () => {
+    const { getAccountStatus } = await import("@/lib/api");
+    vi.mocked(getAccountStatus).mockResolvedValueOnce({
+      status: "active",
+      statusReason: null,
+      graceDeadline: null,
+    });
+
+    const { DegradedStateBanner } = await import("@/components/billing/degraded-state-banner");
+    const { container } = render(<DegradedStateBanner />);
+
+    await waitFor(() => {
+      expect(container.innerHTML).toBe("");
+    });
+  });
+
+  it("renders nothing when API returns null (endpoint missing)", async () => {
+    const { getAccountStatus } = await import("@/lib/api");
+    vi.mocked(getAccountStatus).mockResolvedValueOnce(null);
+
+    const { DegradedStateBanner } = await import("@/components/billing/degraded-state-banner");
+    const { container } = render(<DegradedStateBanner />);
+
+    await waitFor(() => {
+      expect(container.innerHTML).toBe("");
+    });
+  });
+
+  it("shows grace period warning with deadline", async () => {
+    const { getAccountStatus } = await import("@/lib/api");
+    const deadline = new Date(Date.now() + 2 * 86400000).toISOString();
+    vi.mocked(getAccountStatus).mockResolvedValueOnce({
+      status: "grace_period",
+      statusReason: null,
+      graceDeadline: deadline,
+    });
+
+    const { DegradedStateBanner } = await import("@/components/billing/degraded-state-banner");
+    render(<DegradedStateBanner />);
+
+    await waitFor(() => {
+      expect(screen.getByText(/ACTION REQUIRED/)).toBeInTheDocument();
+      expect(screen.getByText(/Update payment method/i)).toBeInTheDocument();
+    });
+  });
+
+  it("shows suspended banner with CTA", async () => {
+    const { getAccountStatus } = await import("@/lib/api");
+    vi.mocked(getAccountStatus).mockResolvedValueOnce({
+      status: "suspended",
+      statusReason: "Grace period expired",
+      graceDeadline: null,
+    });
+
+    const { DegradedStateBanner } = await import("@/components/billing/degraded-state-banner");
+    render(<DegradedStateBanner />);
+
+    await waitFor(() => {
+      expect(screen.getByText(/ACCOUNT SUSPENDED/)).toBeInTheDocument();
+      expect(screen.getByText(/Contact support/i)).toBeInTheDocument();
+    });
+  });
+
+  it("shows banned banner with no dismiss button", async () => {
+    const { getAccountStatus } = await import("@/lib/api");
+    vi.mocked(getAccountStatus).mockResolvedValueOnce({
+      status: "banned",
+      statusReason: "TOS violation",
+      graceDeadline: null,
+    });
+
+    const { DegradedStateBanner } = await import("@/components/billing/degraded-state-banner");
+    render(<DegradedStateBanner />);
+
+    await waitFor(() => {
+      expect(screen.getByText(/ACCOUNT TERMINATED/)).toBeInTheDocument();
+      expect(screen.queryByRole("button", { name: /dismiss/i })).not.toBeInTheDocument();
+    });
+  });
+
+  it("can be dismissed", async () => {
+    const user = userEvent.setup();
+    const { getAccountStatus } = await import("@/lib/api");
+    vi.mocked(getAccountStatus).mockResolvedValueOnce({
+      status: "grace_period",
+      statusReason: null,
+      graceDeadline: new Date(Date.now() + 86400000).toISOString(),
+    });
+
+    const { DegradedStateBanner } = await import("@/components/billing/degraded-state-banner");
+    render(<DegradedStateBanner />);
+
+    await waitFor(() => {
+      expect(screen.getByText(/ACTION REQUIRED/)).toBeInTheDocument();
+    });
+
+    const dismissBtn = screen.getByRole("button", { name: /dismiss/i });
+    await user.click(dismissBtn);
+
+    expect(screen.queryByText(/ACTION REQUIRED/)).not.toBeInTheDocument();
+  });
+});

package/src/__tests__/dividend-calculator.test.tsx

@@ -0,0 +1,20 @@
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+
+describe("DividendCalculator", () => {
+  it("renders the math breakdown", async () => {
+    const { DividendCalculator } = await import("@/components/pricing/dividend-calculator");
+    render(<DividendCalculator />);
+
+    expect(screen.getByText(/100K active users/i)).toBeInTheDocument();
+    expect(screen.getByText(/\$20\/month average spend/i)).toBeInTheDocument();
+    expect(screen.getByTestId("net-cost")).toBeInTheDocument();
+  });
+
+  it("shows the early adopter callout", async () => {
+    const { DividendCalculator } = await import("@/components/pricing/dividend-calculator");
+    render(<DividendCalculator />);
+
+    expect(screen.getByText(/the earlier you join/i)).toBeInTheDocument();
+  });
+});

package/src/__tests__/dividend-stats.test.tsx

@@ -0,0 +1,64 @@
+import { render, screen } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// Stub fetch globally before any module imports
+const mockFetch = vi.fn();
+vi.stubGlobal("fetch", mockFetch);
+
+vi.mock("@/lib/api-config", () => ({
+  API_BASE_URL: "http://test:3001/api",
+  PLATFORM_BASE_URL: "http://test:3001",
+}));
+
+describe("DividendStats", () => {
+  beforeEach(() => {
+    mockFetch.mockReset();
+  });
+
+  it("renders fallback values when API returns null", async () => {
+    mockFetch.mockResolvedValue({
+      ok: false,
+      status: 500,
+      statusText: "Internal Server Error",
+      json: () => Promise.resolve({}),
+    });
+
+    const { DividendStats } = await import("@/components/pricing/dividend-stats");
+    render(<DividendStats />);
+
+    expect(screen.getByTestId("pool-amount")).toBeInTheDocument();
+    expect(screen.getByTestId("active-users")).toBeInTheDocument();
+    expect(screen.getByTestId("projected-dividend")).toBeInTheDocument();
+  });
+
+  it("renders live data when API succeeds", async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          poolAmountDollars: 2500.0,
+          activeUsers: 8000,
+          projectedDailyDividend: 0.31,
+        }),
+    });
+
+    const { DividendStats } = await import("@/components/pricing/dividend-stats");
+    render(<DividendStats />);
+
+    expect(screen.getByTestId("pool-amount")).toBeInTheDocument();
+    expect(screen.getByTestId("active-users")).toBeInTheDocument();
+    expect(screen.getByTestId("projected-dividend")).toBeInTheDocument();
+  });
+
+  it("renders fallback dashes when fetch rejects (network error)", async () => {
+    mockFetch.mockRejectedValue(new Error("Network failure"));
+
+    const { DividendStats } = await import("@/components/pricing/dividend-stats");
+    render(<DividendStats />);
+
+    // fetchDividendStats catches network errors and returns null — component shows "--"
+    expect(screen.getByTestId("pool-amount")).toBeInTheDocument();
+    expect(screen.getByTestId("active-users")).toBeInTheDocument();
+    expect(screen.getByTestId("projected-dividend")).toBeInTheDocument();
+  });
+});

package/src/__tests__/dividend.test.tsx

@@ -0,0 +1,169 @@
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("next/navigation", () => ({
+  useRouter: () => ({ push: vi.fn() }),
+  useSearchParams: () => new URLSearchParams(),
+  usePathname: () => "/billing/credits",
+}));
+
+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(),
+  }),
+}));
+
+// --- Dividend API types ---
+
+describe("Dividend API types", () => {
+  it("exports getDividendStats function", async () => {
+    const api = await import("@/lib/api");
+    expect(typeof api.getDividendStats).toBe("function");
+  });
+
+  it("exports getDividendHistory function", async () => {
+    const api = await import("@/lib/api");
+    expect(typeof api.getDividendHistory).toBe("function");
+  });
+
+  it("exports getDividendLifetime function", async () => {
+    const api = await import("@/lib/api");
+    expect(typeof api.getDividendLifetime).toBe("function");
+  });
+
+  it("includes community_dividend in CreditTransactionType", async () => {
+    // The type union includes community_dividend - verify a community_dividend typed object is assignable
+    const tx: import("@/lib/api").CreditTransactionType = "community_dividend";
+    expect(tx).toBe("community_dividend");
+  });
+});
+
+// --- DividendBanner ---
+
+const MOCK_STATS = {
+  poolCents: 6885,
+  activeUsers: 847,
+  perUserCents: 8,
+  nextDistributionAt: "2026-02-22T00:00:00Z",
+  userEligible: true,
+  userLastPurchaseAt: "2026-02-20T14:23:00Z",
+  userWindowExpiresAt: "2026-02-27T14:23:00Z",
+};
+
+describe("DividendBanner", () => {
+  it("renders the dividend amount when user received a dividend today", async () => {
+    const { DividendBanner } = await import("@/components/billing/dividend-banner");
+    render(<DividendBanner todayAmountCents={8} stats={MOCK_STATS} />);
+
+    expect(screen.getByText(/Platform paid you/)).toBeInTheDocument();
+  });
+
+  it("renders projected message when no dividend yet today", async () => {
+    const { DividendBanner } = await import("@/components/billing/dividend-banner");
+    render(<DividendBanner todayAmountCents={0} stats={MOCK_STATS} />);
+
+    expect(screen.getByText(/projected share/i)).toBeInTheDocument();
+  });
+
+  it("renders not eligible message when user is not in the pool", async () => {
+    const { DividendBanner } = await import("@/components/billing/dividend-banner");
+    const ineligibleStats = { ...MOCK_STATS, userEligible: false, userWindowExpiresAt: null };
+    render(<DividendBanner todayAmountCents={0} stats={ineligibleStats} />);
+
+    expect(screen.getByText(/purchase credits to join/i)).toBeInTheDocument();
+  });
+});
+
+// --- DividendEligibility ---
+
+describe("DividendEligibility", () => {
+  it("renders days remaining in pool", async () => {
+    const { DividendEligibility } = await import("@/components/billing/dividend-eligibility");
+    const expiresAt = new Date(Date.now() + 5 * 86400000).toISOString();
+    render(<DividendEligibility windowExpiresAt={expiresAt} eligible={true} />);
+
+    expect(screen.getByText(/in the pool for/i)).toBeInTheDocument();
+    expect(screen.getByText("5")).toBeInTheDocument();
+    expect(screen.getByRole("progressbar")).toBeInTheDocument();
+  });
+
+  it("renders not eligible state", async () => {
+    const { DividendEligibility } = await import("@/components/billing/dividend-eligibility");
+    render(<DividendEligibility windowExpiresAt={null} eligible={false} />);
+
+    expect(screen.getByText(/not in the pool/i)).toBeInTheDocument();
+  });
+
+  it("renders expiring soon warning when <= 2 days remain", async () => {
+    const { DividendEligibility } = await import("@/components/billing/dividend-eligibility");
+    const expiresAt = new Date(Date.now() + 1 * 86400000).toISOString();
+    render(<DividendEligibility windowExpiresAt={expiresAt} eligible={true} />);
+
+    expect(screen.getByText("1")).toBeInTheDocument();
+    expect(screen.getByText(/reset your 7-day window/i)).toBeInTheDocument();
+  });
+});
+
+// --- DividendPoolStats ---
+
+describe("DividendPoolStats", () => {
+  it("renders pool size and user count", async () => {
+    const { DividendPoolStats } = await import("@/components/billing/dividend-pool-stats");
+    render(<DividendPoolStats poolCents={6885} activeUsers={847} perUserCents={8} />);
+
+    expect(screen.getByText("$68.85")).toBeInTheDocument();
+    expect(screen.getByText("847")).toBeInTheDocument();
+    expect(screen.getByText("$0.08/day")).toBeInTheDocument();
+  });
+
+  it("renders zero state when pool is empty", async () => {
+    const { DividendPoolStats } = await import("@/components/billing/dividend-pool-stats");
+    render(<DividendPoolStats poolCents={0} activeUsers={0} perUserCents={0} />);
+
+    expect(screen.getByText(/pool building/i)).toBeInTheDocument();
+  });
+});
+
+// --- FirstDividendDialog ---
+
+describe("FirstDividendDialog", () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it("renders celebration when dividend > 0 and not seen before", async () => {
+    const { FirstDividendDialog } = await import("@/components/billing/first-dividend-dialog");
+    render(<FirstDividendDialog todayAmountCents={8} />);
+
+    expect(screen.getByText(/Platform just paid you/i)).toBeInTheDocument();
+  });
+
+  it("does not render dialog when already seen", async () => {
+    localStorage.setItem("platform-first_dividend_seen", "true");
+    const { FirstDividendDialog } = await import("@/components/billing/first-dividend-dialog");
+    render(<FirstDividendDialog todayAmountCents={8} />);
+
+    expect(screen.queryByText(/Platform just paid you/i)).not.toBeInTheDocument();
+  });
+
+  it("does not render when amount is 0", async () => {
+    const { FirstDividendDialog } = await import("@/components/billing/first-dividend-dialog");
+    render(<FirstDividendDialog todayAmountCents={0} />);
+
+    expect(screen.queryByText(/Platform just paid you/i)).not.toBeInTheDocument();
+  });
+
+  it("sets localStorage flag when dismissed", async () => {
+    const { FirstDividendDialog } = await import("@/components/billing/first-dividend-dialog");
+    render(<FirstDividendDialog todayAmountCents={8} />);
+
+    const button = screen.getByRole("button", { name: /nice/i });
+    await userEvent.click(button);
+
+    expect(localStorage.getItem("platform-first_dividend_seen")).toBe("true");
+  });
+});

package/src/__tests__/dockerfile.test.ts

@@ -0,0 +1,110 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { describe, expect, it } from "vitest";
+
+const root = resolve(__dirname, "../..");
+
+describe("Dockerfile", () => {
+  const dockerfile = readFileSync(resolve(root, "Dockerfile"), "utf-8");
+
+  it("exists and is non-empty", () => {
+    expect(dockerfile.length).toBeGreaterThan(0);
+  });
+
+  it("uses node:20-alpine base image", () => {
+    expect(dockerfile).toContain("FROM node:20-alpine");
+  });
+
+  it("uses multi-stage build with deps, build, and runtime stages", () => {
+    expect(dockerfile).toMatch(/FROM .+ AS deps/);
+    expect(dockerfile).toMatch(/FROM .+ AS build/);
+    expect(dockerfile).toMatch(/FROM .+ AS runtime/);
+  });
+
+  it("installs dependencies with pnpm", () => {
+    expect(dockerfile).toContain("pnpm install --frozen-lockfile");
+  });
+
+  it("builds with pnpm", () => {
+    expect(dockerfile).toContain("pnpm build");
+  });
+
+  it("copies standalone output in runtime stage", () => {
+    expect(dockerfile).toContain(".next/standalone");
+    expect(dockerfile).toContain(".next/static");
+    expect(dockerfile).toContain("public");
+  });
+
+  it("runs as non-root user", () => {
+    expect(dockerfile).toContain("USER wopr");
+  });
+
+  it("exposes port 3000", () => {
+    expect(dockerfile).toContain("EXPOSE 3000");
+  });
+
+  it("runs node server.js as entrypoint", () => {
+    expect(dockerfile).toContain('CMD ["node", "server.js"]');
+  });
+
+  it("includes a healthcheck", () => {
+    expect(dockerfile).toContain("HEALTHCHECK");
+  });
+
+  it("accepts NEXT_PUBLIC_API_URL as build arg", () => {
+    expect(dockerfile).toContain("ARG NEXT_PUBLIC_API_URL");
+  });
+});
+
+describe(".dockerignore", () => {
+  const dockerignore = readFileSync(resolve(root, ".dockerignore"), "utf-8");
+
+  it("exists and is non-empty", () => {
+    expect(dockerignore.length).toBeGreaterThan(0);
+  });
+
+  it("excludes node_modules", () => {
+    expect(dockerignore).toContain("node_modules");
+  });
+
+  it("excludes .next build output", () => {
+    expect(dockerignore).toContain(".next");
+  });
+
+  it("excludes .git directory", () => {
+    expect(dockerignore).toContain(".git");
+  });
+
+  it("excludes .env files", () => {
+    expect(dockerignore).toContain(".env");
+  });
+});
+
+describe("docker-compose.yml", () => {
+  const compose = readFileSync(resolve(root, "docker-compose.yml"), "utf-8");
+
+  it("exists and is non-empty", () => {
+    expect(compose.length).toBeGreaterThan(0);
+  });
+
+  it("defines platform-ui service", () => {
+    expect(compose).toContain("platform-ui:");
+  });
+
+  it("defines platform-api service", () => {
+    expect(compose).toContain("platform-api:");
+  });
+
+  it("maps port 3000 for platform-ui", () => {
+    expect(compose).toContain("3000:3000");
+  });
+
+  it("maps port 3001 for platform-api", () => {
+    expect(compose).toContain("3001:3001");
+  });
+
+  it("uses a shared network", () => {
+    expect(compose).toContain("networks:");
+    expect(compose).toContain("wopr:");
+  });
+});

package/src/__tests__/email-verification-banner.test.tsx

@@ -0,0 +1,64 @@
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+
+let mockSession: {
+  data: { user: { email: string; emailVerified: boolean } } | null;
+  isPending: boolean;
+};
+
+vi.mock("better-auth/react", () => ({
+  createAuthClient: () => ({
+    useSession: () => mockSession,
+    signIn: { email: vi.fn(), social: vi.fn() },
+    signUp: { email: vi.fn() },
+    signOut: vi.fn(),
+    sendVerificationEmail: vi.fn().mockResolvedValue({ data: {}, error: null }),
+  }),
+}));
+
+vi.mock("framer-motion", () => ({
+  motion: {
+    div: ({ children, ...props }: React.PropsWithChildren<Record<string, unknown>>) => (
+      <div {...props}>{children}</div>
+    ),
+    p: ({ children, ...props }: React.PropsWithChildren<Record<string, unknown>>) => (
+      <p {...props}>{children}</p>
+    ),
+  },
+}));
+
+describe("EmailVerificationBanner", () => {
+  it("renders banner for unverified user", async () => {
+    mockSession = {
+      data: { user: { email: "a@b.com", emailVerified: false } },
+      isPending: false,
+    };
+    const { EmailVerificationBanner } = await import("@/components/auth/email-verification-banner");
+    render(<EmailVerificationBanner />);
+
+    expect(screen.getByText("Verify your email to unlock bot creation")).toBeInTheDocument();
+    expect(screen.getByRole("button", { name: /Resend verification email/ })).toBeInTheDocument();
+  });
+
+  it("does not render banner for verified user", async () => {
+    mockSession = {
+      data: { user: { email: "a@b.com", emailVerified: true } },
+      isPending: false,
+    };
+    const { EmailVerificationBanner } = await import("@/components/auth/email-verification-banner");
+    const { container } = render(<EmailVerificationBanner />);
+
+    expect(container.innerHTML).toBe("");
+  });
+
+  it("does not render banner while loading", async () => {
+    mockSession = {
+      data: null,
+      isPending: true,
+    };
+    const { EmailVerificationBanner } = await import("@/components/auth/email-verification-banner");
+    const { container } = render(<EmailVerificationBanner />);
+
+    expect(container.innerHTML).toBe("");
+  });
+});

package/src/__tests__/env-example.test.ts

@@ -0,0 +1,25 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { describe, expect, it } from "vitest";
+
+const root = resolve(__dirname, "../..");
+
+describe(".env.example", () => {
+  const envExample = readFileSync(resolve(root, ".env.example"), "utf-8");
+
+  it("exists and is non-empty", () => {
+    expect(envExample.length).toBeGreaterThan(0);
+  });
+
+  it("documents NEXT_PUBLIC_API_URL", () => {
+    expect(envExample).toContain("NEXT_PUBLIC_API_URL");
+  });
+
+  it("provides a default localhost value", () => {
+    expect(envExample).toMatch(/NEXT_PUBLIC_API_URL=http:\/\/localhost:3001/);
+  });
+
+  it("warns about production requiring a public HTTPS URL", () => {
+    expect(envExample).toMatch(/production.*https/i);
+  });
+});

package/src/__tests__/error-boundaries.test.tsx

@@ -0,0 +1,64 @@
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import BillingError from "@/app/(dashboard)/billing/error";
+import DashboardError from "@/app/(dashboard)/error";
+import SettingsError from "@/app/(dashboard)/settings/error";
+import ChannelsError from "@/app/channels/error";
+import GlobalError from "@/app/error";
+import FleetError from "@/app/fleet/error";
+import InstancesError from "@/app/instances/error";
+import PluginsError from "@/app/plugins/error";
+
+const boundaries = [
+  { name: "GlobalError (root)", Component: GlobalError, title: "Something went wrong" },
+  { name: "DashboardError", Component: DashboardError, title: "Dashboard Error" },
+  { name: "BillingError", Component: BillingError, title: "Billing Error" },
+  { name: "SettingsError", Component: SettingsError, title: "Settings Error" },
+  { name: "FleetError", Component: FleetError, title: "Fleet Error" },
+  { name: "InstancesError", Component: InstancesError, title: "Fleet Management Error" },
+  { name: "PluginsError", Component: PluginsError, title: "Plugins Error" },
+  { name: "ChannelsError", Component: ChannelsError, title: "Channels Error" },
+] as const;
+
+let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+beforeEach(() => {
+  // biome-ignore lint/suspicious/noEmptyBlockStatements: intentional suppression of console.error in tests
+  consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+});
+
+afterEach(() => {
+  consoleErrorSpy.mockRestore();
+});
+
+describe("error.tsx boundaries render fallback UI", () => {
+  const testError = Object.assign(new Error("Test explosion"), { digest: "abc123" });
+
+  for (const { name, Component, title } of boundaries) {
+    describe(name, () => {
+      it("renders the error title", () => {
+        const reset = vi.fn();
+        render(<Component error={testError} reset={reset} />);
+        expect(screen.getByText(title)).toBeInTheDocument();
+      });
+
+      it("renders a Try Again button that calls reset", async () => {
+        const reset = vi.fn();
+        render(<Component error={testError} reset={reset} />);
+        const btn = screen.getByRole("button", { name: /try again/i });
+        expect(btn).toBeInTheDocument();
+        await userEvent.click(btn);
+        expect(reset).toHaveBeenCalledOnce();
+      });
+
+      it("renders a Dashboard link", () => {
+        const reset = vi.fn();
+        render(<Component error={testError} reset={reset} />);
+        const link = screen.getByRole("link", { name: /dashboard/i });
+        expect(link).toBeInTheDocument();
+        expect(link).toHaveAttribute("href", expect.stringMatching(/^\//));
+      });
+    });
+  }
+});