Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/meet.manage.$token.test.tsx
T

208 lines
5.8 KiB
TypeScript

import { beforeEach, describe, expect, it, vi } from "vitest";
const manage = vi.hoisted(() => ({
cancel: vi.fn(),
isHost: vi.fn(),
issueToken: vi.fn(),
load: vi.fn(),
reschedule: vi.fn(),
verifyToken: vi.fn(),
}));
vi.mock("~/services/admin/admin-booking-manage-token.server", () => ({
issueAdminBookingManageToken: manage.issueToken,
verifyAdminBookingManageToken: manage.verifyToken,
}));
vi.mock("~/services/admin/admin-public-booking-manage.server", () => ({
AdminPublicBookingManageError: class extends Error {
constructor(readonly code: string) {
super(code);
}
},
cancelAdminManagedBooking: manage.cancel,
loadAdminManagedBooking: manage.load,
rescheduleAdminManagedBooking: manage.reschedule,
}));
vi.mock("~/services/admin/admin-public-booking.server", () => ({
isAdminPublicBookingHost: manage.isHost,
}));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({ locale: "de-DE" })),
}));
import { action, loader } from "./meet.manage.$token";
const claims = {
bookingId: "booking_1",
adminUserId: "admin_1",
version: 1,
expiresAt: new Date("2026-09-01T10:00:00.000Z"),
nonce: "abcdefghijklmnopqrstuvwxyz_123456",
};
describe("meet.manage.$token public booking management route", () => {
beforeEach(() => {
vi.clearAllMocks();
process.env.SESSION_SECRET = "s".repeat(32);
manage.isHost.mockReturnValue(true);
manage.verifyToken.mockReturnValue(claims);
manage.issueToken.mockReturnValue("replacement_token");
manage.load.mockResolvedValue({
booking: {
startsAt: new Date("2026-08-01T10:00:00.000Z"),
bookingPage: { title: "Demo buchen" },
meetingType: { name: "Demo" },
},
page: {
slots: [
{
startsAt: new Date("2026-08-02T10:00:00.000Z"),
endsAt: new Date("2026-08-02T10:30:00.000Z"),
},
],
},
});
});
it("loads a token-scoped management VM", async () => {
const result = await loader({
request: new Request(
"http://meet.localhost:3000/manage/token_1?date=2026-08-02&tz=Europe%2FBerlin"
),
params: { token: "token_1" },
context: {},
unstable_pattern: "/meet/manage/:token",
});
expect(result.vm).toEqual(
expect.objectContaining({
title: "Demo buchen",
meetingTypeName: "Demo",
date: "2026-08-02",
timeZone: "Europe/Berlin",
})
);
expect(manage.verifyToken).toHaveBeenCalledWith({
token: "token_1",
secret: "s".repeat(32),
});
});
it("cancels only through a same-origin token-scoped action", async () => {
const form = new URLSearchParams({
intent: "cancel",
reason: "Termin passt nicht mehr",
});
const response = await action({
request: new Request("http://meet.localhost:3000/manage/token_1", {
method: "POST",
headers: {
origin: "http://meet.localhost:3000",
"sec-fetch-site": "same-origin",
},
body: form,
}),
params: { token: "token_1" },
context: {},
unstable_pattern: "/meet/manage/:token",
});
await expect((response as Response).json()).resolves.toEqual({
result: "cancelled",
replacementManageUrl: null,
errorCode: null,
});
expect(manage.cancel).toHaveBeenCalledWith({
claims,
reason: "Termin passt nicht mehr",
});
});
it("returns a fresh management link after rescheduling", async () => {
manage.reschedule.mockResolvedValue({
booking: {
id: "booking_2",
adminUserId: "admin_1",
manageTokenVersion: 1,
manageTokenExpiresAt: new Date("2026-09-02T10:00:00.000Z"),
},
});
const form = new URLSearchParams({
intent: "reschedule",
date: "2026-08-02",
slot:
"2026-08-02T10:00:00.000Z|2026-08-02T10:30:00.000Z",
});
const response = await action({
request: new Request("http://meet.localhost:3000/manage/token_1", {
method: "POST",
headers: {
origin: "http://meet.localhost:3000",
"sec-fetch-site": "same-origin",
},
body: form,
}),
params: { token: "token_1" },
context: {},
unstable_pattern: "/meet/manage/:token",
});
await expect((response as Response).json()).resolves.toEqual({
result: "rescheduled",
replacementManageUrl:
"http://meet.localhost:3000/manage/replacement_token",
errorCode: null,
});
expect(manage.reschedule).toHaveBeenCalledWith(
expect.objectContaining({
claims,
date: "2026-08-02",
})
);
});
it("hides invalid hosts, invalid tokens and cross-origin writes", async () => {
manage.isHost.mockReturnValueOnce(false);
await expect(
loader({
request: new Request(
"http://admin.localhost:3000/manage/token_1"
),
params: { token: "token_1" },
context: {},
unstable_pattern: "/meet/manage/:token",
})
).rejects.toMatchObject({ status: 404 });
manage.verifyToken.mockImplementationOnce(() => {
throw new Error("invalid token");
});
await expect(
loader({
request: new Request(
"http://meet.localhost:3000/manage/tampered"
),
params: { token: "tampered" },
context: {},
unstable_pattern: "/meet/manage/:token",
})
).rejects.toMatchObject({ status: 404 });
await expect(
action({
request: new Request(
"http://meet.localhost:3000/manage/token_1",
{
method: "POST",
headers: { origin: "https://attacker.invalid" },
body: new FormData(),
}
),
params: { token: "token_1" },
context: {},
unstable_pattern: "/meet/manage/:token",
})
).rejects.toMatchObject({ status: 404 });
});
});