import { beforeEach, describe, expect, it, vi } from "vitest"; import { UPLOAD_DIR, saveImageBytes } from "@/lib/files"; import { MAX_VERSIONS } from "@/lib/history"; import { isStale, versionOf, type ConflictInfo, type SaveResult } from "@/lib/conflict"; import { makeImage } from "../helpers/fixtures"; import { describeDb, filesIn, makeBook, makeEntity, makeEvent, makeRelation, makeUser, prisma, resetAll } from "../helpers/db"; const login = vi.hoisted(() => ({ userId: "" as string })); vi.mock("@/auth", () => ({ auth: async () => (login.userId ? { user: { id: login.userId } } : null) })); vi.mock("next/cache", () => ({ revalidatePath: () => undefined })); vi.mock("next/navigation", () => ({ redirect: (to: string) => { throw new Error(`REDIRECT:${to}`); }, notFound: () => { throw new Error("NOT_FOUND"); }, })); vi.mock("@/i18n/server", async () => { const core = await import("@/i18n/core"); return { getLocale: async () => "sv", getT: async () => ({ locale: "sv", t: core.makeT(core.dictionaries.sv) }) }; }); import { saveEntity } from "@/actions/entities"; import { saveEvent } from "@/actions/events"; import { saveRelation } from "@/actions/relations"; const form = (fields: Record) => { const data = new FormData(); for (const [key, value] of Object.entries(fields)) { if (value instanceof Blob) data.append(key, value, "bild.png"); else for (const v of Array.isArray(value) ? value : [value]) data.append(key, v); } return data; }; /** Kör en sparåtgärd. Antingen omdirigerar den (sparat) eller svarar med en krock. */ async function save(run: () => Promise): Promise<{ saved: true; to: string } | { saved: false; conflict: ConflictInfo }> { try { const result = await run(); if (result?.conflict) return { saved: false, conflict: result.conflict }; throw new Error("Åtgärden svarade varken med omdirigering eller krock"); } catch (error) { const message = error instanceof Error ? error.message : ""; if (message.startsWith("REDIRECT:")) return { saved: true, to: message.slice(9) }; throw error; } } describe("isStale", () => { const now = new Date("2026-01-01T12:00:00.000Z"); it("jämför versionen som formuläret öppnades med", () => { expect(isStale(versionOf(now), now)).toBe(false); expect(isStale(versionOf(new Date(now.getTime() - 1)), now)).toBe(true); }); it("kontrollerar inget när versionen saknas", () => { expect(isStale("", now)).toBe(false); }); }); describeDb("skydd mot kolliderande ändringar", () => { let ownerId: string; let otherId: string; let bookId: string; beforeEach(async () => { await resetAll(); const owner = await makeUser("Ägare"); const other = await makeUser("Kollega", "kollega@example.com"); ownerId = owner.id; otherId = other.id; bookId = (await makeBook(ownerId)).id; await prisma.bookMember.create({ data: { bookId, userId: otherId, role: "EDITOR" } }); login.userId = ownerId; }); describe("poster", () => { const edit = (id: string, version: string, fields: Record = {}) => save(() => saveEntity(form({ bookId, id, name: "Anna", version, ...fields }))); it("sparar när versionen stämmer, och ger en ny version", async () => { const anna = await makeEntity(bookId, "CHARACTER", "Anna"); const result = await edit(anna.id, versionOf(anna.updatedAt), { summary: "Ny" }); expect(result).toMatchObject({ saved: true }); const after = await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } }); expect(after.summary).toBe("Ny"); expect(after.updatedById).toBe(ownerId); expect(versionOf(after.updatedAt)).not.toBe(versionOf(anna.updatedAt)); }); it("sparar ingenting när någon annan hunnit före, och visar vad som skiljer", async () => { const anna = await makeEntity(bookId, "CHARACTER", "Anna", { summary: "Från början", data: { nickname: "Ann" } }); const opened = versionOf(anna.updatedAt); // Kollegan sparar först login.userId = otherId; await edit(anna.id, opened, { summary: "Kollegans text", f_nickname: "Ann" }); // Sedan sparar den första med den gamla versionen login.userId = ownerId; const result = await edit(anna.id, opened, { summary: "Min text", f_nickname: "Annie" }); expect(result.saved).toBe(false); if (result.saved) return; expect(result.conflict.by).toBe("Kollega"); expect(result.conflict.changes).toEqual( expect.arrayContaining([ { label: "Sammanfattning", before: "Kollegans text", after: "Min text" }, { label: "Smeknamn", before: "Ann", after: "Annie" }, ]), ); const stored = await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } }); expect(stored.summary).toBe("Kollegans text"); expect(stored.updatedById).toBe(otherId); }); it("att spara ändå med den nya versionen skriver över, och den andras version hamnar i historiken", async () => { const anna = await makeEntity(bookId, "CHARACTER", "Anna", { summary: "Från början" }); const opened = versionOf(anna.updatedAt); login.userId = otherId; await edit(anna.id, opened, { summary: "Kollegans text" }); login.userId = ownerId; const conflict = await edit(anna.id, opened, { summary: "Min text" }); if (conflict.saved) throw new Error("Väntade en krock"); const forced = await edit(anna.id, conflict.conflict.version, { summary: "Min text" }); expect(forced.saved).toBe(true); expect((await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } })).summary).toBe("Min text"); const versions = await prisma.entityVersion.findMany({ where: { entityId: anna.id }, orderBy: { createdAt: "asc" } }); const summaries = versions.map((v) => (v.snapshot as { summary: string }).summary); expect(summaries).toEqual(["Från början", "Kollegans text"]); expect(versions[1].userId).toBe(ownerId); }); it("tre samtidiga redigerare: bara en kommer igenom med samma version", async () => { const anna = await makeEntity(bookId, "CHARACTER", "Anna"); const opened = versionOf(anna.updatedAt); const results = await Promise.all([1, 2, 3].map((n) => edit(anna.id, opened, { summary: `Text ${n}` }).catch((e) => ({ error: String(e) })))); const saved = results.filter((r) => "saved" in r && r.saved).length; const conflicts = results.filter((r) => "saved" in r && !r.saved).length; expect(saved).toBe(1); expect(conflicts).toBe(2); }); it("en ny bild läggs inte kvar som skräp när sparningen avbryts av en krock", async () => { const anna = await makeEntity(bookId, "CHARACTER", "Anna"); const opened = versionOf(anna.updatedAt); await edit(anna.id, opened, { summary: "Först" }); const before = await filesIn(UPLOAD_DIR); const png = new Blob([(await makeImage(50, 50, "png")) as BlobPart], { type: "image/png" }); const result = await save(() => saveEntity(form({ bookId, id: anna.id, name: "Anna", version: opened, image: png }))); expect(result.saved).toBe(false); expect(await filesIn(UPLOAD_DIR)).toEqual(before); }); it("en bild som byts ut tar bort den gamla först när sparningen lyckats", async () => { const old = await saveImageBytes(await makeImage(40, 40, "png")); const anna = await makeEntity(bookId, "CHARACTER", "Anna", { imageFile: old }); const png = new Blob([(await makeImage(50, 50, "png")) as BlobPart], { type: "image/png" }); const result = await edit(anna.id, versionOf(anna.updatedAt), { image: png as unknown as string }); expect(result.saved).toBe(true); const after = await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } }); expect(after.imageFile).toBeTruthy(); expect(after.imageFile).not.toBe(old); expect(await filesIn(UPLOAD_DIR)).not.toContain(old); }); it("formulär utan version sparas som förut", async () => { const anna = await makeEntity(bookId, "CHARACTER", "Anna"); expect((await save(() => saveEntity(form({ bookId, id: anna.id, name: "Anna", summary: "Utan version" })))).saved).toBe(true); }); it("nya poster behöver ingen version", async () => { const result = await save(() => saveEntity(form({ bookId, kind: "CHARACTER", name: "Ny", version: "" }))); expect(result.saved).toBe(true); expect((await prisma.entity.findFirstOrThrow({ where: { name: "Ny" } })).updatedById).toBe(ownerId); }); it("historiken håller sig inom gränsen även med många krockar", async () => { const anna = await makeEntity(bookId, "CHARACTER", "Anna"); let version = versionOf(anna.updatedAt); for (let i = 0; i < MAX_VERSIONS + 3; i++) { await edit(anna.id, version, { summary: `v${i}` }); version = versionOf((await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } })).updatedAt); } expect(await prisma.entityVersion.count({ where: { entityId: anna.id } })).toBe(MAX_VERSIONS); }); }); describe("relationer", () => { it("kan inte skriva över en relation som ändrats av någon annan", async () => { const a = await makeEntity(bookId, "CHARACTER", "A"); const b = await makeEntity(bookId, "CHARACTER", "B"); const relation = await makeRelation(bookId, a.id, b.id, "Vänner"); const opened = versionOf(relation.updatedAt); const edit = (type: string, version: string) => save(() => saveRelation(form({ bookId, id: relation.id, type, version }))); login.userId = otherId; expect((await edit("Bästa vänner", opened)).saved).toBe(true); login.userId = ownerId; const result = await edit("Ovänner", opened); expect(result.saved).toBe(false); if (result.saved) return; expect(result.conflict.by).toBe("Kollega"); expect((await prisma.relation.findUniqueOrThrow({ where: { id: relation.id } })).type).toBe("Bästa vänner"); expect((await edit("Ovänner", result.conflict.version)).saved).toBe(true); expect((await prisma.relation.findUniqueOrThrow({ where: { id: relation.id } })).type).toBe("Ovänner"); }); it("deltagarna behålls när en sparning avvisas", async () => { const a = await makeEntity(bookId, "CHARACTER", "A"); const b = await makeEntity(bookId, "CHARACTER", "B"); const c = await makeEntity(bookId, "CHARACTER", "C"); const relation = await makeRelation(bookId, a.id, b.id, "Grupp", [c.id]); const opened = versionOf(relation.updatedAt); await save(() => saveRelation(form({ bookId, id: relation.id, type: "Grupp 2", version: opened, memberIds: [c.id] }))); const result = await save(() => saveRelation(form({ bookId, id: relation.id, type: "Grupp 3", version: opened }))); expect(result.saved).toBe(false); expect(await prisma.relationMember.count({ where: { relationId: relation.id } })).toBe(1); }); }); describe("händelser", () => { it("kan inte skriva över en händelse som ändrats av någon annan", async () => { const a = await makeEntity(bookId, "CHARACTER", "A"); const event = await makeEvent(bookId, "Fest", "2000", [a.id]); const opened = versionOf(event.updatedAt); const edit = (title: string, version: string) => save(() => saveEvent(form({ bookId, id: event.id, title, date: "2000", version, participantIds: [a.id] }))); login.userId = otherId; expect((await edit("Stor fest", opened)).saved).toBe(true); login.userId = ownerId; const result = await edit("Liten fest", opened); expect(result.saved).toBe(false); expect((await prisma.storyEvent.findUniqueOrThrow({ where: { id: event.id } })).title).toBe("Stor fest"); expect(await prisma.eventParticipant.count({ where: { eventId: event.id } })).toBe(1); }); }); });