309 lines
9.8 KiB
TypeScript
309 lines
9.8 KiB
TypeScript
import { readFileSync } from "node:fs";
|
|
import { resolve } from "node:path";
|
|
import { createElement, type ReactNode } from "react";
|
|
import { renderToStaticMarkup } from "react-dom/server";
|
|
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
import { PERMS } from "@/lib/permission-slugs";
|
|
import type { HousekeepingCapabilityContext } from "./contracts";
|
|
|
|
const routeMocks = vi.hoisted(() => {
|
|
const messages: Record<string, string> = {
|
|
"preview.badge": "Localized preview",
|
|
"preview.commandDisabled": "Localized disabled command",
|
|
"preview.backToSite": "Localized back to site",
|
|
"navigation.skipToContent": "Localized skip to content",
|
|
"navigation.primary": "Localized primary navigation",
|
|
"navigation.contextual": "Localized contextual navigation",
|
|
"domains.people.title": "Localized People",
|
|
"domains.people.description": "Localized People description",
|
|
"domains.economy.title": "Localized Economy",
|
|
"domains.economy.description": "Localized Economy description",
|
|
"states.empty.title": "Localized empty title",
|
|
"states.empty.description": "Localized empty description",
|
|
};
|
|
const translate = vi.fn((key: string) => {
|
|
const message = messages[key];
|
|
if (message === undefined)
|
|
throw new Error(`Unexpected translation: ${key}`);
|
|
return message;
|
|
});
|
|
|
|
return {
|
|
env: {
|
|
NODE_ENV: "test" as "development" | "test" | "production",
|
|
HOUSEKEEPING_NEXT_PREVIEW_ENABLED: true,
|
|
},
|
|
getHousekeepingCapabilityContext: vi.fn(),
|
|
getTranslations: vi.fn(async (namespace: string) => {
|
|
if (namespace !== "pages.housekeeping") {
|
|
throw new Error(`Unexpected namespace: ${namespace}`);
|
|
}
|
|
return translate;
|
|
}),
|
|
notFound: vi.fn((): never => {
|
|
throw new Error("NEXT_NOT_FOUND");
|
|
}),
|
|
redirect: vi.fn((href: string): never => {
|
|
throw new Error(`NEXT_REDIRECT:${href}`);
|
|
}),
|
|
translate,
|
|
};
|
|
});
|
|
|
|
vi.mock("@/env", () => ({ env: routeMocks.env }));
|
|
vi.mock("next/navigation", () => ({
|
|
notFound: routeMocks.notFound,
|
|
redirect: routeMocks.redirect,
|
|
}));
|
|
vi.mock("next-intl/server", () => ({
|
|
getTranslations: routeMocks.getTranslations,
|
|
}));
|
|
vi.mock("@/features/housekeeping/foundation/server-capability-context", () => ({
|
|
getHousekeepingCapabilityContext: routeMocks.getHousekeepingCapabilityContext,
|
|
}));
|
|
vi.mock("@/lib/db", () => {
|
|
throw new Error("preview routes must not import the database");
|
|
});
|
|
vi.mock("@/lib/auth", () => {
|
|
throw new Error("preview routes must not call auth directly");
|
|
});
|
|
vi.mock("@/lib/permissions", () => {
|
|
throw new Error("preview routes must not reload permissions directly");
|
|
});
|
|
vi.mock("@/actions", () => {
|
|
throw new Error("preview routes must not import actions");
|
|
});
|
|
vi.mock("@/app/actions", () => {
|
|
throw new Error("preview routes must not import actions");
|
|
});
|
|
|
|
import AdminNextDomainLayout from "@/app/admin-next/[domain]/layout";
|
|
import AdminNextDomainPage from "@/app/admin-next/[domain]/page";
|
|
import AdminNextLayout from "@/app/admin-next/layout";
|
|
import AdminNextPage from "@/app/admin-next/page";
|
|
|
|
const routeFiles = [
|
|
"src/app/admin-next/layout.tsx",
|
|
"src/app/admin-next/page.tsx",
|
|
"src/app/admin-next/[domain]/layout.tsx",
|
|
"src/app/admin-next/[domain]/page.tsx",
|
|
] as const;
|
|
|
|
function capabilityContext(
|
|
granted: readonly string[],
|
|
actor = { id: 42, username: "refreshed-moderator", rank: 3 },
|
|
): HousekeepingCapabilityContext {
|
|
const capabilities = new Set(granted);
|
|
|
|
return {
|
|
actor,
|
|
isSuperAdmin: false,
|
|
has: (slug) => capabilities.has(slug),
|
|
hasAny: (...slugs) => slugs.some((slug) => capabilities.has(slug)),
|
|
hasAll: (...slugs) => slugs.every((slug) => capabilities.has(slug)),
|
|
};
|
|
}
|
|
|
|
async function renderRoute(route: ReactNode | Promise<ReactNode>) {
|
|
return renderToStaticMarkup(await route);
|
|
}
|
|
|
|
describe("/admin-next preview gate", () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
routeMocks.env.NODE_ENV = "test";
|
|
routeMocks.env.HOUSEKEEPING_NEXT_PREVIEW_ENABLED = true;
|
|
});
|
|
|
|
it.each([
|
|
["production", true],
|
|
["production", false],
|
|
["development", false],
|
|
] as const)("returns 404 for NODE_ENV=%s flag=%s", async (nodeEnv, flag) => {
|
|
routeMocks.env.NODE_ENV = nodeEnv;
|
|
routeMocks.env.HOUSEKEEPING_NEXT_PREVIEW_ENABLED = flag;
|
|
|
|
await expect(async () =>
|
|
renderRoute(
|
|
AdminNextLayout({
|
|
children: createElement("p", null, "Preview child"),
|
|
}),
|
|
),
|
|
).rejects.toThrow("NEXT_NOT_FOUND");
|
|
expect(routeMocks.notFound).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it.each(["development", "test"] as const)(
|
|
"renders children in %s when explicitly enabled",
|
|
async (nodeEnv) => {
|
|
routeMocks.env.NODE_ENV = nodeEnv;
|
|
|
|
const html = await renderRoute(
|
|
AdminNextLayout({
|
|
children: createElement("p", null, "Preview child"),
|
|
}),
|
|
);
|
|
|
|
expect(html).toContain("Preview child");
|
|
expect(routeMocks.notFound).not.toHaveBeenCalled();
|
|
},
|
|
);
|
|
});
|
|
|
|
describe("/admin-next first visible domain", () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
});
|
|
|
|
it("redirects an administrator to Operations in locked registry order", async () => {
|
|
routeMocks.getHousekeepingCapabilityContext.mockResolvedValue(
|
|
capabilityContext([PERMS.ADMIN_DASHBOARD, PERMS.USERS_VIEW]),
|
|
);
|
|
|
|
await expect(AdminNextPage()).rejects.toThrow(
|
|
"NEXT_REDIRECT:/admin-next/operations",
|
|
);
|
|
expect(routeMocks.redirect).toHaveBeenCalledWith("/admin-next/operations");
|
|
expect(routeMocks.getHousekeepingCapabilityContext).toHaveBeenCalledTimes(
|
|
1,
|
|
);
|
|
expect(routeMocks.getTranslations).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("redirects a moderator with only an approved mod view capability to People", async () => {
|
|
routeMocks.getHousekeepingCapabilityContext.mockResolvedValue(
|
|
capabilityContext([PERMS.MOD_CFH_VIEW]),
|
|
);
|
|
|
|
await expect(AdminNextPage()).rejects.toThrow(
|
|
"NEXT_REDIRECT:/admin-next/people",
|
|
);
|
|
expect(routeMocks.redirect).toHaveBeenCalledWith("/admin-next/people");
|
|
expect(routeMocks.getHousekeepingCapabilityContext).toHaveBeenCalledTimes(
|
|
1,
|
|
);
|
|
});
|
|
|
|
it("returns 404 when the operator has no visible domain", async () => {
|
|
routeMocks.getHousekeepingCapabilityContext.mockResolvedValue(
|
|
capabilityContext([]),
|
|
);
|
|
|
|
await expect(AdminNextPage()).rejects.toThrow("NEXT_NOT_FOUND");
|
|
expect(routeMocks.notFound).toHaveBeenCalledTimes(1);
|
|
expect(routeMocks.redirect).not.toHaveBeenCalled();
|
|
expect(routeMocks.getHousekeepingCapabilityContext).toHaveBeenCalledTimes(
|
|
1,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("/admin-next/[domain] layout", () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
});
|
|
|
|
it("rejects an unknown domain before loading capability context", async () => {
|
|
await expect(
|
|
AdminNextDomainLayout({
|
|
children: createElement("p", null, "Unknown body"),
|
|
params: Promise.resolve({ domain: "unknown" }),
|
|
}),
|
|
).rejects.toThrow("NEXT_NOT_FOUND");
|
|
expect(routeMocks.getHousekeepingCapabilityContext).not.toHaveBeenCalled();
|
|
expect(routeMocks.getTranslations).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("rejects a known domain that the operator cannot access", async () => {
|
|
routeMocks.getHousekeepingCapabilityContext.mockResolvedValue(
|
|
capabilityContext([PERMS.MOD_CFH_VIEW]),
|
|
);
|
|
|
|
await expect(
|
|
AdminNextDomainLayout({
|
|
children: createElement("p", null, "Economy body"),
|
|
params: Promise.resolve({ domain: "economy" }),
|
|
}),
|
|
).rejects.toThrow("NEXT_NOT_FOUND");
|
|
expect(routeMocks.getHousekeepingCapabilityContext).toHaveBeenCalledTimes(
|
|
1,
|
|
);
|
|
expect(routeMocks.getTranslations).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("renders localized People shell from one refreshed capability context", async () => {
|
|
routeMocks.getHousekeepingCapabilityContext.mockResolvedValue(
|
|
capabilityContext([PERMS.MOD_CFH_VIEW]),
|
|
);
|
|
|
|
const html = await renderRoute(
|
|
AdminNextDomainLayout({
|
|
children: createElement("p", null, "People body"),
|
|
params: Promise.resolve({ domain: "people" }),
|
|
}),
|
|
);
|
|
|
|
expect(html).toContain("refreshed-moderator");
|
|
expect(html).toContain("Localized preview");
|
|
expect(html).toContain("Localized primary navigation");
|
|
expect(html).toContain("Localized People");
|
|
expect(html).toContain("People body");
|
|
expect(html).not.toContain("Localized Economy");
|
|
expect(routeMocks.translate).not.toHaveBeenCalledWith(
|
|
"domains.economy.title",
|
|
);
|
|
expect(routeMocks.getHousekeepingCapabilityContext).toHaveBeenCalledTimes(
|
|
1,
|
|
);
|
|
expect(routeMocks.getTranslations).toHaveBeenCalledTimes(1);
|
|
});
|
|
});
|
|
|
|
describe("/admin-next/[domain] page", () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
});
|
|
|
|
it("renders the real localized manifest and empty state without reloading access", async () => {
|
|
const html = await renderRoute(
|
|
AdminNextDomainPage({
|
|
params: Promise.resolve({ domain: "people" }),
|
|
}),
|
|
);
|
|
|
|
expect(html).toContain("Localized People");
|
|
expect(html).toContain("Localized People description");
|
|
expect(html).toContain("Localized empty title");
|
|
expect(html).toContain("Localized empty description");
|
|
expect(routeMocks.getHousekeepingCapabilityContext).not.toHaveBeenCalled();
|
|
expect(routeMocks.getTranslations).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it("rejects an unknown domain before translating", async () => {
|
|
await expect(
|
|
AdminNextDomainPage({
|
|
params: Promise.resolve({ domain: "unknown" }),
|
|
}),
|
|
).rejects.toThrow("NEXT_NOT_FOUND");
|
|
expect(routeMocks.getHousekeepingCapabilityContext).not.toHaveBeenCalled();
|
|
expect(routeMocks.getTranslations).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe("preview route import boundary", () => {
|
|
it("rejects data, actions, direct auth, old chrome, and legacy route imports", () => {
|
|
for (const path of routeFiles) {
|
|
const source = readFileSync(resolve(process.cwd(), path), "utf8");
|
|
|
|
expect(source, path).not.toMatch(
|
|
/@\/lib\/db|@\/(?:app\/)?actions(?:\/|["'])/,
|
|
);
|
|
expect(source, path).not.toMatch(/AdminSidebarNav|AdminHubChrome/);
|
|
expect(source, path).not.toMatch(/@\/lib\/(?:auth|permissions)/);
|
|
expect(source, path).not.toMatch(
|
|
/(?:@\/app\/(?:admin|mod)|\.\.\/+(?:admin|mod))(?:\/|["'])/,
|
|
);
|
|
}
|
|
});
|
|
});
|