import { beforeEach, describe, expect, it, vi } from "vitest"; import { versionOf, versionOfOptional, type ConflictInfo } from "@/lib/conflict"; import { describeDb, makeBook, makeEntity, 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 { updateBook } from "@/actions/books"; import { createMarker, moveMarker, updateMarker } from "@/actions/maps"; import { resetTemplate, saveTemplate } from "@/actions/templates"; import { templateChanges } from "@/lib/template-diff"; const form = (fields: Record) => { const data = new FormData(); for (const [key, value] of Object.entries(fields)) data.append(key, value); return data; }; type Outcome = "saved" | { conflict: ConflictInfo }; async function outcome(run: () => Promise<{ conflict: ConflictInfo } | undefined | void>): Promise { try { const result = await run(); if (result && "conflict" in result) return result; return "saved"; } catch (error) { const message = error instanceof Error ? error.message : ""; if (message.startsWith("REDIRECT:")) return "saved"; throw error; } } const fieldsJson = (...labels: string[]) => JSON.stringify(labels.map((label, i) => ({ key: `f${i}`, label, type: "text" }))); describeDb("skydd mot kolliderande ändringar: mallar, bokinställningar och kartmarkeringar", () => { let ownerId: string; let otherId: string; let bookId: string; beforeEach(async () => { await resetAll(); ownerId = (await makeUser("Ägare")).id; otherId = (await makeUser("Kollega", "kollega@example.com")).id; bookId = (await makeBook(ownerId, "Bok")).id; await prisma.bookMember.create({ data: { bookId, userId: otherId, role: "ADMIN" } }); login.userId = ownerId; }); describe("mallar", () => { const save = (fields: string, version: string) => outcome(() => saveTemplate(form({ bookId, kind: "CHARACTER", fields, version }))); it("den första sparningen av en standardmall behöver ingen version", async () => { expect(await save(fieldsJson("A"), versionOfOptional(null))).toBe("saved"); expect(await prisma.template.count({ where: { bookId } })).toBe(1); }); it("sparar med rätt version och ger en ny", async () => { await save(fieldsJson("A"), versionOfOptional(null)); const row = await prisma.template.findFirstOrThrow({ where: { bookId } }); expect(await save(fieldsJson("A", "B"), versionOf(row.updatedAt))).toBe("saved"); const after = await prisma.template.findFirstOrThrow({ where: { bookId } }); expect(versionOf(after.updatedAt)).not.toBe(versionOf(row.updatedAt)); expect(after.updatedById).toBe(ownerId); }); it("avvisar en sparning med gammal version och visar vilka fält som skiljer", async () => { await save(fieldsJson("A"), versionOfOptional(null)); const opened = versionOf((await prisma.template.findFirstOrThrow({ where: { bookId } })).updatedAt); login.userId = otherId; await save(fieldsJson("A", "Kollegans fält"), opened); login.userId = ownerId; const result = await save(fieldsJson("A", "Mitt fält"), opened); expect(result).not.toBe("saved"); if (result === "saved") return; expect(result.conflict.by).toBe("Kollega"); expect(result.conflict.changes).toEqual([{ label: "Mitt fält", before: "Kollegans fält (text)", after: "Mitt fält (text)" }]); expect(((await prisma.template.findFirstOrThrow({ where: { bookId } })).fields as { label: string }[]).map((f) => f.label)).toEqual(["A", "Kollegans fält"]); // Spara ändå med den nya versionen expect(await save(fieldsJson("A", "Mitt fält"), (result.conflict as ConflictInfo).version)).toBe("saved"); expect(((await prisma.template.findFirstOrThrow({ where: { bookId } })).fields as { label: string }[]).map((f) => f.label)).toEqual(["A", "Mitt fält"]); }); it("någon annan skapade mallen medan du tittade på standardmallen", async () => { login.userId = otherId; await save(fieldsJson("Kollegans"), versionOfOptional(null)); login.userId = ownerId; const result = await save(fieldsJson("Min"), versionOfOptional(null)); expect(result).not.toBe("saved"); expect(await prisma.template.count({ where: { bookId } })).toBe(1); }); it("någon annan återställde mallen till standard", async () => { await save(fieldsJson("A"), versionOfOptional(null)); const opened = versionOf((await prisma.template.findFirstOrThrow({ where: { bookId } })).updatedAt); login.userId = otherId; await outcome(() => resetTemplate(form({ bookId, kind: "CHARACTER" }))); login.userId = ownerId; const result = await save(fieldsJson("B"), opened); expect(result).not.toBe("saved"); if (result === "saved") return; expect(result.conflict.version).toBe("none"); expect(await save(fieldsJson("B"), "none")).toBe("saved"); }); it("av tre samtidiga sparningar med samma version går bara en igenom", async () => { await save(fieldsJson("A"), versionOfOptional(null)); const opened = versionOf((await prisma.template.findFirstOrThrow({ where: { bookId } })).updatedAt); const results = await Promise.all([1, 2, 3].map((n) => save(fieldsJson("A", `Från ${n}`), opened))); expect(results.filter((r) => r === "saved")).toHaveLength(1); expect(results.filter((r) => r !== "saved")).toHaveLength(2); }); it("och tre som skapar mallen samtidigt", async () => { const results = await Promise.all([1, 2, 3].map((n) => save(fieldsJson(`Skapad ${n}`), "none"))); expect(results.filter((r) => r === "saved")).toHaveLength(1); expect(await prisma.template.count({ where: { bookId } })).toBe(1); }); it("ogiltig mall sparas inte och ger ett fel, inte en krock", async () => { expect(await save("[{\"key\":\"1fel\",\"label\":\"x\",\"type\":\"text\"}]", "none")).toBe("saved"); // redirect med felet expect(await prisma.template.count({ where: { bookId } })).toBe(0); }); }); describe("templateChanges", () => { it("jämför på nyckel och beskriver typ, flera val och alternativ", () => { const a = [{ key: "x", label: "Lokal", type: "reference" as const, refKind: "PREMISES" as const }, { key: "y", label: "Typ", type: "select" as const, options: ["a", "b"] }]; const b = [{ key: "x", label: "Lokal", type: "reference" as const, refKind: "PREMISES" as const, multiple: true }, { key: "z", label: "Ny", type: "text" as const }]; expect(templateChanges(a, b)).toEqual([ { label: "Lokal", before: "Lokal (reference: PREMISES)", after: "Lokal (reference, flera: PREMISES)" }, { label: "Typ", before: "Typ (select: a/b)", after: "" }, { label: "Ny", before: "", after: "Ny (text)" }, ]); expect(templateChanges(a, a)).toEqual([]); }); }); describe("bokinställningar", () => { const save = (title: string, version: string) => outcome(() => updateBook(form({ bookId, title, subtitle: "", genre: "", description: "", version }))); it("sparar med rätt version, och sparar vem som ändrade", async () => { const book = await prisma.book.findUniqueOrThrow({ where: { id: bookId } }); expect(await save("Ny titel", versionOf(book.updatedAt))).toBe("saved"); const after = await prisma.book.findUniqueOrThrow({ where: { id: bookId } }); expect(after).toMatchObject({ title: "Ny titel", updatedById: ownerId }); expect(versionOf(after.updatedAt)).not.toBe(versionOf(book.updatedAt)); }); it("avvisar en sparning med gammal version och visar skillnaderna med namn", async () => { const opened = versionOf((await prisma.book.findUniqueOrThrow({ where: { id: bookId } })).updatedAt); login.userId = otherId; await save("Kollegans titel", opened); login.userId = ownerId; const result = await save("Min titel", opened); expect(result).not.toBe("saved"); if (result === "saved") return; expect(result.conflict.by).toBe("Kollega"); expect(result.conflict.changes).toEqual([{ label: "Titel", before: "Kollegans titel", after: "Min titel" }]); expect((await prisma.book.findUniqueOrThrow({ where: { id: bookId } })).title).toBe("Kollegans titel"); expect(await save("Min titel", result.conflict.version)).toBe("saved"); expect((await prisma.book.findUniqueOrThrow({ where: { id: bookId } })).title).toBe("Min titel"); }); it("tre samtidiga sparningar: en går igenom", async () => { const opened = versionOf((await prisma.book.findUniqueOrThrow({ where: { id: bookId } })).updatedAt); const results = await Promise.all([1, 2, 3].map((n) => save(`Titel ${n}`, opened))); expect(results.filter((r) => r === "saved")).toHaveLength(1); }); }); describe("kartmarkeringar", () => { let mapId: string; let markerId: string; const input = (label: string, extra: { lat?: number; lng?: number; note?: string } = {}) => ({ label, note: extra.note ?? "", color: "blue", entityId: null, lat: extra.lat ?? 59.3, lng: extra.lng ?? 18.0 }); beforeEach(async () => { mapId = (await prisma.bookMap.create({ data: { bookId, name: "Karta", kind: "GEO" } })).id; markerId = (await prisma.marker.create({ data: { mapId, label: "Hus", lat: 59.3, lng: 18.0 } })).id; }); const version = async () => versionOf((await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).updatedAt); it("uppdatering med rätt version lyckas och ger en ny version", async () => { const result = await updateMarker(bookId, mapId, markerId, input("Villa"), await version()); expect(result).toHaveProperty("version"); const after = await prisma.marker.findUniqueOrThrow({ where: { id: markerId } }); expect(after).toMatchObject({ label: "Villa", updatedById: ownerId }); expect((result as { version: string }).version).toBe(versionOf(after.updatedAt)); }); it("en gammal version ger en krock med skillnader, och ändrar ingenting", async () => { const opened = await version(); login.userId = otherId; await updateMarker(bookId, mapId, markerId, input("Kollegans", { note: "Anteckning" }), opened); login.userId = ownerId; const result = await updateMarker(bookId, mapId, markerId, input("Mitt"), opened); expect(result).toHaveProperty("conflict"); const { conflict } = result as { conflict: ConflictInfo }; expect(conflict.by).toBe("Kollega"); expect(conflict.changes).toEqual(expect.arrayContaining([{ label: "Etikett", before: "Kollegans", after: "Mitt" }, { label: "Anteckning", before: "Anteckning", after: "" }])); expect((await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).label).toBe("Kollegans"); expect(await updateMarker(bookId, mapId, markerId, input("Mitt"), conflict.version)).toHaveProperty("version"); expect((await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).label).toBe("Mitt"); }); it("att flytta en markering som ändrats av någon annan sparar inte flytten", async () => { const opened = await version(); login.userId = otherId; await updateMarker(bookId, mapId, markerId, input("Kollegans"), opened); login.userId = ownerId; const result = await moveMarker(bookId, mapId, markerId, 60, 19, opened); expect(result).toHaveProperty("conflict"); expect(await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).toMatchObject({ lat: 59.3, lng: 18 }); }); it("en lyckad flytt ger en version som går att använda direkt efteråt", async () => { const moved = await moveMarker(bookId, mapId, markerId, 60, 19, await version()); expect(moved).toHaveProperty("version"); expect(await updateMarker(bookId, mapId, markerId, input("Efter flytt", { lat: 60, lng: 19 }), (moved as { version: string }).version)).toHaveProperty("version"); }); it("en borttagen markering ger gone", async () => { const opened = await version(); await prisma.marker.delete({ where: { id: markerId } }); expect(await updateMarker(bookId, mapId, markerId, input("Spöke"), opened)).toEqual({ gone: true }); expect(await moveMarker(bookId, mapId, markerId, 1, 1, opened)).toEqual({ gone: true }); }); it("av tre samtidiga ändringar med samma version går en igenom", async () => { const opened = await version(); const results = await Promise.all([1, 2, 3].map((n) => updateMarker(bookId, mapId, markerId, input(`Från ${n}`), opened))); expect(results.filter((r) => "version" in r)).toHaveLength(1); expect(results.filter((r) => "conflict" in r)).toHaveLength(2); }); it("utan version kontrolleras inget (som förut)", async () => { expect(await updateMarker(bookId, mapId, markerId, input("Utan version"))).toHaveProperty("version"); }); it("nya markeringar får ID och vem som skapade dem", async () => { await createMarker(bookId, mapId, input("Ny")); const created = await prisma.marker.findFirstOrThrow({ where: { label: "Ny" } }); expect(created.code).toMatch(/^PI-/); expect(created.updatedById).toBe(ownerId); }); it("en markering i en annan bok kan inte ändras", async () => { const otherBook = await makeBook(ownerId, "Annan"); const foreignMap = await prisma.bookMap.create({ data: { bookId: otherBook.id, name: "K", kind: "GEO" } }); const foreign = await prisma.marker.create({ data: { mapId: foreignMap.id, label: "Främmande", lat: 1, lng: 1 } }); expect(await updateMarker(bookId, mapId, foreign.id, input("Kapad"))).toEqual({ gone: true }); expect((await prisma.marker.findUniqueOrThrow({ where: { id: foreign.id } })).label).toBe("Främmande"); }); it("kopplingen till en post i boken behålls vid uppdatering", async () => { const entity = await makeEntity(bookId, "PREMISES", "Lokal"); await updateMarker(bookId, mapId, markerId, { ...input("Med koppling"), entityId: entity.id }); expect((await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).entityId).toBe(entity.id); }); }); });