import "@testing-library/jest-dom"; import { render, screen } from "@testing-library/react"; import { MemoryRouter, useLoaderData } from "react-router"; import { beforeEach, describe, expect, it, vi } from "vitest"; import { consumeMagicLinkToken } from "~/services/auth/magic-link.server"; import { getUser } from "~/utils/db/users.db.server"; import { createUserSession, getUserInfo, setLoggedUser } from "~/utils/session.server"; import { beginAlternativeLoginMfa } from "~/services/auth/alternative-login-mfa.server"; import { loadRequiredWebConfig } from "@hivegrid/config"; import { AdminFallbackLoginRejected, assertAdminFallbackLoginAllowedForIdentity, } from "~/services/auth/admin-fallback.server"; import { writeAdminSsoAuditEvent } from "~/modules/admin-sso/audit.server"; import * as MagicLinkRoute from "./auth.magic-link"; vi.mock("react-router", async () => { const actual = await vi.importActual("react-router"); return { ...actual, useLoaderData: vi.fn(), }; }); vi.mock("react-i18next", () => ({ useTranslation: () => ({ t: (key: string) => translations[key] ?? key, }), })); vi.mock("~/services/auth/magic-link.server", () => ({ consumeMagicLinkToken: vi.fn(), })); vi.mock("~/utils/db/users.db.server", () => ({ getUser: vi.fn(), })); vi.mock("~/utils/session.server", () => ({ createUserSession: vi.fn(), getUserInfo: vi.fn(), setLoggedUser: vi.fn(), })); vi.mock("~/services/auth/alternative-login-mfa.server", () => ({ beginAlternativeLoginMfa: vi.fn(), LOGIN_MFA_CHALLENGE_PATH: "/login-mfa", })); vi.mock("@hivegrid/config", () => ({ loadRequiredWebConfig: vi.fn(), })); vi.mock("~/services/auth/admin-fallback.server", async () => { const actual = await vi.importActual("~/services/auth/admin-fallback.server"); return { ...actual, assertAdminFallbackLoginAllowedForIdentity: vi.fn(), }; }); vi.mock("~/modules/admin-sso/audit.server", () => ({ writeAdminSsoAuditEvent: vi.fn(), })); const translations: Record = { "auth:magicLink.invalid.title": "Sign-in link is invalid", "auth:magicLink.invalid.description": "This link could not be verified. Request a new one.", "auth:magicLink.expired.title": "Sign-in link has expired", "auth:magicLink.expired.description": "Magic links are valid for 15 minutes. Request a new one and use it right away.", "auth:magicLink.replayed.title": "Sign-in link already used", "auth:magicLink.replayed.description": "Each magic link works only once. Request a new one to sign in.", "auth:magicLink.purposeMismatch.title": "Sign-in link is invalid", "auth:magicLink.purposeMismatch.description": "This link cannot be used for sign-in. Request a new one.", "auth:magicLink.requestNewLink": "Request a new sign-in link", // D-D0a — Davids Invalid-Link-Screen nutzt die account.login.* Aktions-Labels. "account.login.magicLinkRequestNew": "Request new link", "account.login.backToLogin": "Back to sign in", }; const consumeMagicLinkTokenMock = vi.mocked(consumeMagicLinkToken); const getUserMock = vi.mocked(getUser); const getUserInfoMock = vi.mocked(getUserInfo); const setLoggedUserMock = vi.mocked(setLoggedUser); const createUserSessionMock = vi.mocked(createUserSession); const beginAlternativeLoginMfaMock = vi.mocked(beginAlternativeLoginMfa); const loadRequiredWebConfigMock = vi.mocked(loadRequiredWebConfig); const assertAdminFallbackLoginAllowedForIdentityMock = vi.mocked(assertAdminFallbackLoginAllowedForIdentity); const writeAdminSsoAuditEventMock = vi.mocked(writeAdminSsoAuditEvent); function renderMagicLinkStatus(status: "invalid" | "expired" | "replayed" | "not-found" | "purpose-mismatch") { vi.mocked(useLoaderData).mockReturnValue({ status }); return render( ); } function callLoader(url: string, init?: RequestInit) { return MagicLinkRoute.loader({ request: new Request(url, init), params: {}, context: {}, }); } describe("auth magic-link route", () => { beforeEach(() => { vi.clearAllMocks(); loadRequiredWebConfigMock.mockReturnValue({ magicLink: { enabled: true } } as ReturnType); getUserInfoMock.mockResolvedValue({ lng: "en", userId: "existing-user" } as Awaited>); setLoggedUserMock.mockResolvedValue({ userId: "user_1" } as Awaited>); createUserSessionMock.mockResolvedValue(new Response(null, { status: 302, headers: { Location: "/" } }) as Awaited>); beginAlternativeLoginMfaMock.mockResolvedValue({ required: false }); }); it.each([ ["invalid", "Sign-in link is invalid", "This link could not be verified. Request a new one."], ["expired", "Sign-in link has expired", "Magic links are valid for 15 minutes. Request a new one and use it right away."], ["replayed", "Sign-in link already used", "Each magic link works only once. Request a new one to sign in."], ["not-found", "Sign-in link is invalid", "This link could not be verified. Request a new one."], ["purpose-mismatch", "Sign-in link is invalid", "This link cannot be used for sign-in. Request a new one."], ] as const)("renders translated copy for %s magic-link failures", (status, title, description) => { renderMagicLinkStatus(status); expect(screen.getByRole("heading", { name: title })).toBeInTheDocument(); expect(screen.getByText(description)).toBeInTheDocument(); // D-D0a — Davids "Invalid Link"-Screen: "Neuen Link anfordern" + "Zurueck zur Anmeldung" (Buttons -> /login, // dort liegt der Magic-Link-Request). Keine Forgot-Password-Verlinkung mehr. expect(screen.getByRole("button", { name: "Request new link" })).toBeInTheDocument(); expect(screen.getByRole("button", { name: "Back to sign in" })).toBeInTheDocument(); expect(screen.queryByText(/^auth[.:]magicLink/u)).not.toBeInTheDocument(); }); it("rejects missing tokens without consuming tokens or creating sessions", async () => { await expect(callLoader("https://example.test/auth/magic-link")).resolves.toEqual({ status: "invalid" }); expect(consumeMagicLinkTokenMock).not.toHaveBeenCalled(); expect(getUserMock).not.toHaveBeenCalled(); expect(getUserInfoMock).not.toHaveBeenCalled(); expect(setLoggedUserMock).not.toHaveBeenCalled(); expect(createUserSessionMock).not.toHaveBeenCalled(); }); it("does not consume tokens while magic-link authentication is disabled", async () => { loadRequiredWebConfigMock.mockReturnValue({ magicLink: { enabled: false } } as ReturnType); await expect(callLoader("https://example.test/auth/magic-link?token=still-valid")).resolves.toEqual({ status: "invalid" }); expect(consumeMagicLinkTokenMock).not.toHaveBeenCalled(); expect(getUserMock).not.toHaveBeenCalled(); expect(createUserSessionMock).not.toHaveBeenCalled(); }); it.each(["invalid", "expired", "replayed", "not-found", "purpose-mismatch"] as const)( "returns a generic failure state for %s tokens without creating a session", async (reason) => { consumeMagicLinkTokenMock.mockResolvedValue({ ok: false, reason }); await expect(callLoader("https://example.test/auth/magic-link?token=bad-token")).resolves.toEqual({ status: reason }); expect(consumeMagicLinkTokenMock).toHaveBeenCalledWith("bad-token", { expectedPurpose: "login" }); expect(getUserMock).not.toHaveBeenCalled(); expect(getUserInfoMock).not.toHaveBeenCalled(); expect(setLoggedUserMock).not.toHaveBeenCalled(); expect(createUserSessionMock).not.toHaveBeenCalled(); } ); it("does not create a session when the consumed token points at a missing user", async () => { consumeMagicLinkTokenMock.mockResolvedValue({ ok: true, userId: "missing-user", tokenId: "token_1", purpose: "login" }); getUserMock.mockResolvedValue(null); await expect(callLoader("https://example.test/auth/magic-link?token=valid-token")).resolves.toEqual({ status: "not-found" }); expect(getUserMock).toHaveBeenCalledWith("missing-user"); expect(getUserInfoMock).not.toHaveBeenCalled(); expect(setLoggedUserMock).not.toHaveBeenCalled(); expect(createUserSessionMock).not.toHaveBeenCalled(); }); it("rejects a resolved AdminUser before MFA or session creation when fallback is disabled", async () => { consumeMagicLinkTokenMock.mockResolvedValue({ ok: true, userId: "admin_user_1", tokenId: "token_1", purpose: "login" }); getUserMock.mockResolvedValue({ id: "admin_user_1", email: "admin@example.test", defaultTenantId: null, locale: "de", admin: { userId: "admin_user_1" }, } as never); assertAdminFallbackLoginAllowedForIdentityMock.mockImplementationOnce(() => { throw new AdminFallbackLoginRejected("disabled"); }); await expect(callLoader("https://example.test/auth/magic-link?token=valid-admin-token")).resolves.toEqual({ status: "invalid" }); expect(beginAlternativeLoginMfaMock).not.toHaveBeenCalled(); expect(setLoggedUserMock).not.toHaveBeenCalled(); expect(createUserSessionMock).not.toHaveBeenCalled(); expect(writeAdminSsoAuditEventMock).toHaveBeenCalledWith( expect.objectContaining({ action: "admin.login.fallback.failure", actorAdminUserId: "admin_user_1", meta: expect.objectContaining({ method: "magic-link", stage: "consume", reason: "disabled" }), }) ); }); it("creates a fresh session only after a valid login-purpose token resolves to a user", async () => { consumeMagicLinkTokenMock.mockResolvedValue({ ok: true, userId: "user_1", tokenId: "token_1", purpose: "login" }); getUserMock.mockResolvedValue({ id: "user_1", email: "ada@example.test", defaultTenantId: "tenant_1", locale: "de" } as Awaited>); const response = await callLoader("https://example.test/auth/magic-link?token=valid-token"); expect(response).toBeInstanceOf(Response); expect((response as Response).status).toBe(302); expect(consumeMagicLinkTokenMock).toHaveBeenCalledWith("valid-token", { expectedPurpose: "login" }); expect(setLoggedUserMock).toHaveBeenCalledWith({ id: "user_1", email: "ada@example.test", defaultTenantId: "tenant_1", }); expect(createUserSessionMock).toHaveBeenCalledWith( { lng: "de", userId: "user_1", }, "/", { request: expect.any(Request), rotate: true }, ); }); it("transitions a TOTP user to pending MFA without issuing a full session", async () => { consumeMagicLinkTokenMock.mockResolvedValue({ ok: true, userId: "user_1", tokenId: "token_1", purpose: "login" }); getUserMock.mockResolvedValue({ id: "user_1", email: "ada@example.test", defaultTenantId: "tenant_1", locale: "de" } as never); beginAlternativeLoginMfaMock.mockResolvedValue({ required: true, setCookie: "hivegrid_session=pending; HttpOnly" }); const requestUrl = "https://example.test/auth/magic-link?token=valid-token"; const response = await callLoader(requestUrl); expect(response).toBeInstanceOf(Response); expect((response as Response).status).toBe(302); expect((response as Response).headers.get("Location")).toBe("/login-mfa"); expect((response as Response).headers.get("Set-Cookie")).toContain("hivegrid_session=pending"); expect(beginAlternativeLoginMfaMock).toHaveBeenCalledWith({ request: expect.any(Request), userId: "user_1", redirectTo: "/", primaryMethod: "magic-link", }); expect(getUserInfoMock).not.toHaveBeenCalled(); expect(setLoggedUserMock).not.toHaveBeenCalled(); expect(createUserSessionMock).not.toHaveBeenCalled(); }); it("has no action export, so unsafe HTTP methods stay outside the route module", () => { expect("action" in MagicLinkRoute).toBe(false); }); it("marks token responses as non-cacheable and strips referrers", () => { expect(MagicLinkRoute.headers()).toEqual({ "Cache-Control": "no-store", "Referrer-Policy": "no-referrer", }); }); });