Files
bookmanager/tests/db/conflicts-more.test.ts
T
bobbanandClaude Sonnet 5.5 1fd1ce78cb Krockskydd för mallar, inställningar och markeringar, flera val i kopplingsfält, Word-import av scheman och kartregister, fler namn för äldre år
Mallar, bokinställningar och kartmarkeringar skickar med version och visar
en krockruta. Kopplingsfält kan ha flera val. Scheman och kartregister kan
importeras från Word, och nya ID hoppar över upptagna. Äldre födelseår får
fler namn genom två SCB-tabeller och grannår. Migrering 0008.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-08 23:23:31 +01:00

279 lines
14 KiB
TypeScript

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<string, string>) => {
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<Outcome> {
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);
});
});
});