Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/app.$tenant/forms.$id.action.test.ts
T

199 lines
6.4 KiB
TypeScript

import { beforeEach, describe, expect, it, vi } from "vitest";
import { getRlsExecutionContext } from "@hivegrid/db/rls-context.server";
import { action } from "./forms.$id";
import { db } from "~/utils/db.server";
import { validateCSRFToken } from "~/utils/session.server";
import { loadFormsContext, requireFormsPermission } from "~/modules/forms/routes/formsAccess.server";
vi.mock("~/utils/db.server", () => {
const tx = {
form: { update: vi.fn() },
formField: { deleteMany: vi.fn(), createMany: vi.fn() },
formAction: { deleteMany: vi.fn(), createMany: vi.fn() },
};
return {
db: {
form: {
findFirst: vi.fn(),
update: tx.form.update,
},
formField: {
deleteMany: tx.formField.deleteMany,
createMany: tx.formField.createMany,
},
formAction: {
deleteMany: tx.formAction.deleteMany,
createMany: tx.formAction.createMany,
},
formSubmission: {
findMany: vi.fn(),
},
$transaction: vi.fn(async (fn: (txArg: typeof tx) => Promise<unknown>) => fn(tx)),
},
};
});
vi.mock("~/utils/session.server", () => ({
validateCSRFToken: vi.fn(),
}));
vi.mock("~/modules/forms/routes/formsAccess.server", () => ({
loadFormsContext: vi.fn(async () => ({
tenantId: "tenant_1",
userId: "user_1",
permissions: ["forms.basic", "forms.builder"],
hasModule: true,
})),
requireFormsPermission: vi.fn(),
formsOwnerWhere: vi.fn(() => ({ createdByUserId: "user_1" })),
}));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({
t: (key: string, fallbackOrOptions?: string | Record<string, unknown>) =>
({
"settings.forms.admin.defaults.submitLabel": "Absenden",
"settings.forms.admin.defaults.successMessage": "Danke. Wir haben deine Einsendung erhalten.",
"settings.forms.admin.errors.formNotFound": "Form not found.",
"settings.forms.admin.errors.invalidWebhookUrl": "Webhook URL is invalid.",
"settings.forms.admin.messages.saved": "Saved.",
})[key] ?? (typeof fallbackOrOptions === "string" ? fallbackOrOptions : key),
})),
}));
function postRequest(form: FormData) {
const body = new URLSearchParams();
for (const [key, value] of form.entries()) {
body.set(key, String(value));
}
return new Request("https://app.example.test/acme/forms/form_1", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: body.toString(),
});
}
function validSaveForm(overrides: Record<string, string> = {}) {
const form = new FormData();
form.set("op", "save");
form.set("name", "Contact");
form.set(
"definition",
JSON.stringify({
title: "Kontakt",
fields: [{ key: "email", type: "email", label: "E-Mail", required: true }],
})
);
form.set("theme", "{}");
form.set("fieldMapping", "{}");
form.set("targetType", "generic");
form.set("actions", "[]");
for (const [key, value] of Object.entries(overrides)) {
form.set(key, value);
}
return form;
}
describe("form detail action", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(validateCSRFToken).mockResolvedValue(undefined as never);
vi.mocked(db.form.findFirst).mockResolvedValue({ id: "form_1" } as never);
vi.mocked(db.form.update).mockResolvedValue({ id: "form_1" } as never);
});
it("persists localized definition defaults during save", async () => {
vi.mocked(db.form.findFirst).mockImplementationOnce(async () => {
expect(getRlsExecutionContext()).toMatchObject({
tenantId: "tenant_1",
userId: "user_1",
});
return { id: "form_1" } as never;
});
const result = await action({
request: postRequest(validSaveForm({ targetType: "unsupported-target" })),
params: { tenant: "acme", id: "form_1" },
context: {},
unstable_pattern: "app.$tenant/forms.$id",
});
expect(result).toEqual({ success: "Saved." });
expect(loadFormsContext).toHaveBeenCalledWith({ request: expect.any(Request), params: { tenant: "acme", id: "form_1" }, requireModule: true });
expect(requireFormsPermission).toHaveBeenCalledWith(expect.objectContaining({ tenantId: "tenant_1" }), "forms.builder");
expect(validateCSRFToken).toHaveBeenCalledOnce();
expect(db.form.update).toHaveBeenCalledWith({
where: { id: "form_1" },
data: expect.objectContaining({
name: "Contact",
targetType: "generic",
definition: expect.objectContaining({
title: "Kontakt",
submitLabel: "Absenden",
successMessage: "Danke. Wir haben deine Einsendung erhalten.",
}),
theme: {},
fieldMapping: {},
}),
});
expect(db.formField.createMany).toHaveBeenCalledWith({
data: [
expect.objectContaining({
formId: "form_1",
tenantId: "tenant_1",
fieldKey: "email",
fieldType: "email",
position: 0,
}),
],
});
});
it("returns localized invalid-webhook errors without updating the form", async () => {
const result = await action({
request: postRequest(validSaveForm({ webhookUrl: "http://localhost:3000/hook" })),
params: { tenant: "acme", id: "form_1" },
context: {},
unstable_pattern: "app.$tenant/forms.$id",
});
expect(result).toEqual({ error: "Webhook URL is invalid." });
expect(db.form.update).not.toHaveBeenCalled();
});
it("persists start-double-opt-in post-submit actions", async () => {
const result = await action({
request: postRequest(
validSaveForm({
actions: JSON.stringify([
{
actionType: "start_double_opt_in",
name: "Double opt-in",
enabled: true,
fieldMapping: { email: "email" },
actionConfig: { subject: "Bitte bestätigen" },
},
]),
})
),
params: { tenant: "acme", id: "form_1" },
context: {},
unstable_pattern: "app.$tenant/forms.$id",
});
expect(result).toEqual({ success: "Saved." });
expect(db.formAction.createMany).toHaveBeenCalledWith({
data: [
expect.objectContaining({
formId: "form_1",
tenantId: "tenant_1",
actionType: "start_double_opt_in",
name: "Double opt-in",
fieldMapping: { email: "email" },
actionConfig: { subject: "Bitte bestätigen" },
}),
],
});
});
});