Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/customer-portal/auth.test.tsx
T

281 lines
11 KiB
TypeScript

import { beforeEach, describe, expect, it, vi } from "vitest";
function portalRequest(input: string | URL, init: RequestInit = {}): Request {
const url = input instanceof URL ? input : new URL(input);
const headers = new Headers(init.headers);
headers.set("x-hivegrid-portal-tenant", "acme");
headers.set("x-hivegrid-portal-origin", url.origin);
return new Request(url, { ...init, headers });
}
const mocks = vi.hoisted(() => ({
requirePortalTenantFromRequest: vi.fn(async () => ({
tenantId: "tenant_1",
portalId: "portal_1",
tenantSlug: "acme",
tenantName: "Acme GmbH",
portalTitle: "Acme Portal",
tenantActive: true,
tenantFrozen: false,
imprintUrl: "https://acme.example.test/imprint",
privacyUrl: "https://acme.example.test/privacy",
termsUrl: null,
})),
consumePortalCapability: vi.fn(),
requestPortalSignInLink: vi.fn(),
signInPortalWithPassword: vi.fn(),
validatePortalCsrfToken: vi.fn(),
serializePortalSessionCookie: vi.fn(),
}));
vi.mock("@hivegrid/config", () => ({
loadRequiredWebConfig: () => ({
supportEmail: "support@example.test",
captcha: {
provider: "mcaptcha",
instanceUrl: "https://captcha.example.test",
loginSiteKey: "site-key",
},
}),
}));
vi.mock("~/components/captcha/Captcha", () => ({ default: () => null }));
vi.mock("~/components/screens/customer-portal/CustomerPortalInterimPages", () => ({
CustomerPortalAuthPage: () => null,
}));
vi.mock("~/services/customer-portal/portal-auth-flow.server", () => ({
consumePortalCapability: (...args: unknown[]) => mocks.consumePortalCapability(...args),
requestPortalPasswordReset: vi.fn(),
requestPortalSignInLink: (...args: unknown[]) => mocks.requestPortalSignInLink(...args),
signInPortalWithPassword: (...args: unknown[]) => mocks.signInPortalWithPassword(...args),
}));
vi.mock("~/services/customer-portal/portal-csrf.server", () => ({
validatePortalCsrfToken: (...args: unknown[]) => mocks.validatePortalCsrfToken(...args),
}));
vi.mock("~/services/customer-portal/portal-data.server", () => ({
portalNotFound: () => new Response(null, { status: 404 }),
requirePortalTenantFromRequest: mocks.requirePortalTenantFromRequest,
}));
vi.mock("~/services/customer-portal/portal-session-cookie.server", () => ({
serializePortalSessionCookie: (...args: unknown[]) => mocks.serializePortalSessionCookie(...args),
}));
import { resolvePortalCapabilityContinuePath } from "~/services/customer-portal/portal-capability-continue.server";
import { action, loader } from "./auth";
beforeEach(() => {
vi.clearAllMocks();
});
describe("customer portal auth loader", () => {
it("never serializes a raw capability token into hydration data", async () => {
const rawToken = "t".repeat(43);
const response = await loader({
request: portalRequest(`https://portal.example.test/__portal/acme/reset-password/${rawToken}`),
params: { tenant: "acme", "*": `reset-password/${rawToken}` },
context: {},
} as never);
const payload = await response.json();
expect(JSON.stringify(payload)).not.toContain(rawToken);
expect(payload.vm.status).toBe("ready");
expect(payload.vm.data).not.toHaveProperty("formAction");
expect(payload.vm.data.legalLinks).toEqual({
imprintUrl: "https://acme.example.test/imprint",
privacyUrl: "https://acme.example.test/privacy",
termsUrl: null,
});
expect(response.headers.get("Referrer-Policy")).toBe("no-referrer");
});
it("leaves ordinary login pages on the server's safe default policy", async () => {
const response = await loader({
request: portalRequest("https://portal.example.test/__portal/acme/login"),
params: { tenant: "acme", "*": "login" },
context: {},
} as never);
expect(response.headers.get("Referrer-Policy")).toBeNull();
});
it("parses a slugless custom-host data request as the same login route", async () => {
const request = portalRequest("https://kunden.example.org/login.data");
request.headers.set("x-hivegrid-portal-custom-host", "kunden.example.org");
const response = await loader({ request, params: {}, context: {} } as never);
const payload = await response.json();
expect(payload.vm.status).toBe("ready");
expect(payload.vm.data.mode).toBe("login");
expect(payload.vm.data.tenantSlug).toBe("acme");
expect(payload.vm.data.loginHref).toBe("/login");
expect(payload.vm.data.passwordHref).toBe("/forgot-password");
});
});
describe("customer portal capability continuation", () => {
it("accepts only an exact same-tenant project-detail path", () => {
const valid = portalRequest("https://portal.example.test/__portal/acme/login/magic/token?continue=%2Facme%2Fprojects%2Fproject_123");
expect(resolvePortalCapabilityContinuePath(valid, "acme")).toBe("/acme/projects/project_123");
});
it.each([
"https://evil.example/projects/project_123",
"//evil.example/projects/project_123",
"/other/projects/project_123",
"/acme/projects/project_123/extra",
"/acme/projects/../settings",
"%2Facme%2Fprojects%2Fproject_123",
])("falls back to the dashboard for rejected continue value %s", (continueValue) => {
const url = new URL("https://portal.example.test/__portal/acme/login/magic/token");
url.searchParams.set("continue", continueValue);
expect(resolvePortalCapabilityContinuePath(portalRequest(url), "acme")).toBe("/acme");
});
it("rejects ambiguous repeated continuation parameters", () => {
const request = portalRequest(
"https://portal.example.test/__portal/acme/login/magic/token?continue=%2Facme%2Fprojects%2Fone&continue=%2Facme%2Fprojects%2Ftwo"
);
expect(resolvePortalCapabilityContinuePath(request, "acme")).toBe("/acme");
});
it("redirects a successfully consumed magic capability to its validated project", async () => {
const rawToken = "t".repeat(43);
mocks.consumePortalCapability.mockResolvedValueOnce({
ok: true,
kind: "session",
rawSessionToken: "opaque-session",
expiresAt: new Date("2026-08-15T10:00:00.000Z"),
});
mocks.serializePortalSessionCookie.mockResolvedValueOnce("__Host-hivegrid_portal_session=signed");
const request = portalRequest(`https://portal.example.test/__portal/acme/login/magic/${rawToken}?continue=%2Facme%2Fprojects%2Fproject_123`, {
method: "POST",
body: new URLSearchParams({ csrf: "csrf", captchaToken: "captcha" }),
});
let response: Response | undefined;
try {
await action({
request,
params: { tenant: "acme", "*": `login/magic/${rawToken}` },
context: {},
} as never);
} catch (error) {
response = error as Response;
}
expect(response?.status).toBe(302);
expect(response?.headers.get("Location")).toBe("/acme/projects/project_123");
expect(response?.headers.get("Set-Cookie")).toBe("__Host-hivegrid_portal_session=signed");
});
it("carries a validated project continuation through regular magic-link request and magic-sent", async () => {
mocks.requestPortalSignInLink.mockResolvedValueOnce({ ok: true, kind: "sent" });
const request = portalRequest("https://portal.example.test/__portal/acme/login?continue=%2Facme%2Fprojects%2Fproject_123", {
method: "POST",
body: new URLSearchParams({ csrf: "csrf", captchaToken: "captcha", intent: "magic_link", email: "customer@example.test" }),
});
let response: Response | undefined;
try {
await action({ request, params: { tenant: "acme", "*": "login" }, context: {} } as never);
} catch (error) {
response = error as Response;
}
expect(mocks.requestPortalSignInLink).toHaveBeenCalledWith(
expect.objectContaining({ email: "customer@example.test", continuePath: "/acme/projects/project_123" })
);
expect(response?.status).toBe(302);
expect(response?.headers.get("Location")).toBe("/acme/login/magic-sent?continue=%2Facme%2Fprojects%2Fproject_123");
});
it("redirects regular password login to the same validated project continuation", async () => {
mocks.signInPortalWithPassword.mockResolvedValueOnce({
ok: true,
kind: "session",
rawSessionToken: "opaque-session",
expiresAt: new Date("2026-08-15T10:00:00.000Z"),
});
mocks.serializePortalSessionCookie.mockResolvedValueOnce("__Host-hivegrid_portal_session=signed");
const request = portalRequest("https://portal.example.test/__portal/acme/login?continue=%2Facme%2Fprojects%2Fproject_123", {
method: "POST",
body: new URLSearchParams({ csrf: "csrf", captchaToken: "captcha", intent: "password", email: "customer@example.test", password: "secret" }),
});
let response: Response | undefined;
try {
await action({ request, params: { tenant: "acme", "*": "login" }, context: {} } as never);
} catch (error) {
response = error as Response;
}
expect(response?.status).toBe(302);
expect(response?.headers.get("Location")).toBe("/acme/projects/project_123");
});
it.each(["/other/projects/project_123", "//evil.example/projects/project_123", "https://evil.example/projects/project_123"])(
"drops manipulated or foreign-tenant continuation from regular auth: %s",
async (continueValue) => {
mocks.signInPortalWithPassword.mockResolvedValueOnce({
ok: true,
kind: "session",
rawSessionToken: "opaque-session",
expiresAt: new Date("2026-08-15T10:00:00.000Z"),
});
mocks.serializePortalSessionCookie.mockResolvedValueOnce("__Host-hivegrid_portal_session=signed");
const url = new URL("https://portal.example.test/__portal/acme/login");
url.searchParams.set("continue", continueValue);
const request = portalRequest(url, {
method: "POST",
body: new URLSearchParams({ csrf: "csrf", captchaToken: "captcha", intent: "password", email: "customer@example.test", password: "secret" }),
});
let response: Response | undefined;
try {
await action({ request, params: { tenant: "acme", "*": "login" }, context: {} } as never);
} catch (error) {
response = error as Response;
}
expect(response?.headers.get("Location")).toBe("/acme");
}
);
it("passes an omitted password through first-time setup without inventing credentials", async () => {
const rawToken = "t".repeat(43);
mocks.consumePortalCapability.mockResolvedValueOnce({
ok: true,
kind: "session",
rawSessionToken: "opaque-session",
expiresAt: new Date("2026-08-15T10:00:00.000Z"),
});
mocks.serializePortalSessionCookie.mockResolvedValueOnce("__Host-hivegrid_portal_session=signed");
const request = portalRequest(`https://portal.example.test/__portal/acme/setup/${rawToken}`, {
method: "POST",
body: new URLSearchParams({
csrf: "csrf",
captchaToken: "captcha",
privacyNoticeAcknowledged: "true",
privacyNoticeUrl: "https://acme.example.test/privacy",
}),
});
try {
await action({ request, params: { tenant: "acme", "*": `setup/${rawToken}` }, context: {} } as never);
} catch (error) {
expect((error as Response).status).toBe(302);
}
expect(mocks.consumePortalCapability).toHaveBeenCalledWith(
expect.objectContaining({
rawToken,
purpose: "setup",
password: undefined,
passwordConfirmation: undefined,
privacyNoticeAcknowledged: true,
privacyNoticeUrl: "https://acme.example.test/privacy",
})
);
});
});