import { beforeEach, describe, expect, it, vi } from "vitest"; import { getRlsExecutionContext } from "@hivegrid/db/rls-context.server"; const findUnique = vi.fn(); const update = vi.fn(); const verifySequenceToken = vi.fn(); const verifyMarketingToken = vi.fn(); const getMarketingStatus = vi.fn(); const unsubscribeKontakt = vi.fn(); const validateCSRFToken = vi.fn(); vi.mock("~/utils/db.server", () => ({ db: { emailSequenceRun: { findUnique, update } }, })); vi.mock("~/utils/email/unsubscribeToken.server", () => ({ verifyUnsubscribeToken: verifySequenceToken, })); vi.mock("~/utils/email/marketingToken.server", () => ({ verifyMarketingToken, })); vi.mock("~/modules/emailMarketing/services/ConsentService.server", () => ({ getMarketingUnsubscribeConfirmationStatus: getMarketingStatus, unsubscribeKontakt, })); vi.mock("~/utils/session.server", () => ({ validateCSRFToken, })); vi.mock("~/utils/logger.server", () => ({ createScopedLogger: () => ({ info: () => undefined, warn: () => undefined, error: () => undefined, }), })); function sequencePayload() { return { runId: "run_1", leadId: "lead_1", tenantId: "tenant_1", iat: 0 }; } beforeEach(() => { vi.clearAllMocks(); getMarketingStatus.mockResolvedValue("invalid"); verifyMarketingToken.mockReturnValue(null); validateCSRFToken.mockResolvedValue(undefined); }); describe("unsubscribe.$token loader", () => { it("keeps GET read-only and asks for confirmation for an active sequence", async () => { verifySequenceToken.mockReturnValueOnce(sequencePayload()); findUnique.mockImplementationOnce(async () => { expect(getRlsExecutionContext()).toMatchObject({ tenantId: "tenant_1" }); return { status: "running" }; }); const route = await import("./unsubscribe.$token.tsx"); const result = await route.loader({ params: { token: "ok" }, request: new Request("http://x/unsubscribe/ok"), context: {}, } as unknown as Parameters[0]); expect(result).toEqual({ status: "confirm" }); expect(findUnique).toHaveBeenCalledWith({ where: { id: "run_1" }, select: { status: true } }); expect(update).not.toHaveBeenCalled(); expect(unsubscribeKontakt).not.toHaveBeenCalled(); }, 60000); it("keeps marketing-token GET requests read-only", async () => { getMarketingStatus.mockResolvedValueOnce("confirm"); const route = await import("./unsubscribe.$token.tsx"); const result = await route.loader({ params: { token: "marketing-token" }, request: new Request("http://x/unsubscribe/marketing-token"), context: {}, } as unknown as Parameters[0]); expect(result).toEqual({ status: "confirm" }); expect(verifySequenceToken).not.toHaveBeenCalled(); expect(unsubscribeKontakt).not.toHaveBeenCalled(); }); it("returns invalid when neither token format verifies", async () => { verifySequenceToken.mockReturnValueOnce(null); const route = await import("./unsubscribe.$token.tsx"); const result = await route.loader({ params: { token: "bad" }, request: new Request("http://x/unsubscribe/bad"), context: {}, } as unknown as Parameters[0]); expect(result).toEqual({ status: "invalid" }); expect(update).not.toHaveBeenCalled(); }); it("does not query a sequence when the signed token has no tenant scope", async () => { verifySequenceToken.mockReturnValueOnce({ ...sequencePayload(), tenantId: null }); const route = await import("./unsubscribe.$token.tsx"); await expect( route.loader({ params: { token: "legacy-global" }, request: new Request("http://x/unsubscribe/legacy-global"), context: {}, } as unknown as Parameters[0]) ).resolves.toEqual({ status: "run_not_found" }); expect(findUnique).not.toHaveBeenCalled(); }); it("reports missing and already-unsubscribed sequence rows without writes", async () => { verifySequenceToken.mockReturnValue(sequencePayload()); findUnique.mockResolvedValueOnce(null).mockResolvedValueOnce({ status: "unsubscribed" }); const route = await import("./unsubscribe.$token.tsx"); const args = { params: { token: "ok" }, request: new Request("http://x/unsubscribe/ok"), context: {}, } as unknown as Parameters[0]; await expect(route.loader(args)).resolves.toEqual({ status: "run_not_found" }); await expect(route.loader(args)).resolves.toEqual({ status: "already_unsubscribed" }); expect(update).not.toHaveBeenCalled(); }); it("prevents caching and referrer leakage for capability URLs", async () => { const route = await import("./unsubscribe.$token.tsx"); expect(route.headers()).toEqual({ "Cache-Control": "no-store", "Referrer-Policy": "no-referrer" }); }); }); describe("unsubscribe.$token action", () => { it("requires CSRF for a browser form before applying the mutation", async () => { verifySequenceToken.mockReturnValueOnce(sequencePayload()); findUnique.mockResolvedValueOnce({ status: "running" }); update.mockResolvedValueOnce({}); const route = await import("./unsubscribe.$token.tsx"); const request = new Request("http://x/unsubscribe/ok", { method: "POST", body: new URLSearchParams({ csrf: "csrf-token" }), }); const result = await route.action({ params: { token: "ok" }, request, context: {} } as unknown as Parameters[0]); expect(result).toEqual({ status: "ok" }); expect(validateCSRFToken).toHaveBeenCalledTimes(1); expect(validateCSRFToken.mock.calls[0]?.[0]).toBe(request); expect((validateCSRFToken.mock.calls[0]?.[1] as { formData: FormData }).formData.get("csrf")).toBe("csrf-token"); expect(update).toHaveBeenCalledWith({ where: { id: "run_1" }, data: expect.objectContaining({ status: "unsubscribed" }), }); }); it("accepts only the exact RFC-8058 one-click body as a token-capability POST", async () => { verifySequenceToken.mockReturnValueOnce(sequencePayload()); findUnique.mockResolvedValueOnce({ status: "running" }); update.mockResolvedValueOnce({}); const route = await import("./unsubscribe.$token.tsx"); const request = new Request("http://x/unsubscribe/ok", { method: "POST", body: new URLSearchParams({ "List-Unsubscribe": "One-Click" }), }); await expect(route.action({ params: { token: "ok" }, request, context: {} } as unknown as Parameters[0])).resolves.toEqual({ status: "ok", }); expect(validateCSRFToken).not.toHaveBeenCalled(); expect(update).toHaveBeenCalledTimes(1); }); it("does not mutate when browser CSRF validation fails", async () => { validateCSRFToken.mockRejectedValueOnce(new Error("invalid csrf")); const route = await import("./unsubscribe.$token.tsx"); const request = new Request("http://x/unsubscribe/ok", { method: "POST", body: new URLSearchParams({ csrf: "bad" }), }); await expect(route.action({ params: { token: "ok" }, request, context: {} } as unknown as Parameters[0])).rejects.toThrow( "invalid csrf" ); expect(verifySequenceToken).not.toHaveBeenCalled(); expect(update).not.toHaveBeenCalled(); }); it("is idempotent on replay", async () => { verifySequenceToken.mockReturnValue(sequencePayload()); findUnique.mockResolvedValueOnce({ status: "running" }).mockResolvedValueOnce({ status: "unsubscribed" }); update.mockResolvedValueOnce({}); const route = await import("./unsubscribe.$token.tsx"); const makeRequest = () => new Request("http://x/unsubscribe/ok", { method: "POST", body: new URLSearchParams({ "List-Unsubscribe": "One-Click" }), }); await expect( route.action({ params: { token: "ok" }, request: makeRequest(), context: {} } as unknown as Parameters[0]) ).resolves.toEqual({ status: "ok" }); await expect( route.action({ params: { token: "ok" }, request: makeRequest(), context: {} } as unknown as Parameters[0]) ).resolves.toEqual({ status: "already_unsubscribed", }); expect(update).toHaveBeenCalledTimes(1); }); });