import { beforeEach, describe, expect, it, vi } from "vitest"; import { ImportError, buildExport, importBook, parseExport, readImportFile } from "@/lib/book-transfer"; import { collectFieldData } from "@/lib/field-values"; import { restoreBook, restoreEntity, trashBook, trashEntity } from "@/lib/trash"; import { loadTimeline } from "@/lib/timeline"; import { getTemplate } from "@/lib/templates"; import { strToU8, zipSync } from "fflate"; import { relationRow, validExport, entityRow } from "../helpers/fixtures"; import { describeDb, makeBook, makeEntity, makeEvent, makeRelation, makeUser, prisma, resetAll } from "../helpers/db"; // Åtgärderna (server actions) körs här utan webbserver: inloggning, cache och omdirigering ersätts const session = vi.hoisted(() => ({ bookId: "", ownerId: "" })); vi.mock("@/lib/session", () => ({ requireBook: async (id: string) => { if (id !== session.bookId) throw new Error("Not your book"); return { id: session.bookId, ownerId: session.ownerId }; }, })); vi.mock("next/cache", () => ({ revalidatePath: () => undefined })); vi.mock("next/navigation", () => ({ redirect: (to: string) => { throw new Error(`REDIRECT:${to}`); }, })); 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 { addEvent, deleteEvent, saveEvent } from "@/actions/events"; import { addRelation, saveRelation } from "@/actions/relations"; const form = (fields: Record) => { const data = new FormData(); for (const [key, value] of Object.entries(fields)) for (const v of Array.isArray(value) ? value : [value]) data.append(key, v); return data; }; /** Kör en åtgärd och returnerar vart den omdirigerade (eller null om den inte gjorde det). */ async function redirectedTo(run: () => Promise): Promise { try { await run(); return null; } catch (error) { const message = error instanceof Error ? error.message : ""; if (message.startsWith("REDIRECT:")) return message.slice(9); throw error; } } describeDb("släktband, perioder och händelser", () => { let ownerId: string; let bookId: string; let anna: { id: string }; let erik: { id: string }; let lisa: { id: string }; beforeEach(async () => { await resetAll(); ownerId = (await makeUser()).id; bookId = (await makeBook(ownerId)).id; session.bookId = bookId; session.ownerId = ownerId; anna = await makeEntity(bookId, "CHARACTER", "Anna", { data: { birthDate: "1960-05-10", deathDate: "2020" } }); erik = await makeEntity(bookId, "CHARACTER", "Erik", { data: { birthDate: "1990" } }); lisa = await makeEntity(bookId, "CHARACTER", "Lisa"); }); describe("relationer", () => { it("sparar släktband och period, och normaliserar datumen", async () => { await addRelation(form({ bookId, fromId: anna.id, toId: erik.id, type: "Mor till", bond: "PARENT", startDate: "1990-6-2", endDate: "2020" })); const relation = await prisma.relation.findFirstOrThrow({ where: { bookId } }); expect(relation).toMatchObject({ type: "Mor till", bond: "PARENT", startDate: "1990-06-02", endDate: "2020" }); }); it("tom relationstext får släktbandets namn", async () => { await addRelation(form({ bookId, fromId: anna.id, toId: erik.id, type: "", bond: "PARTNER" })); expect((await prisma.relation.findFirstOrThrow({ where: { bookId } })).type).toBe("Partner till"); }); it("kräver text eller släktband", async () => { await addRelation(form({ bookId, fromId: anna.id, toId: erik.id, type: "" })); expect(await prisma.relation.count()).toBe(0); }); it("sparar inte en relation med ogiltigt datum eller okänt släktband som släktband", async () => { await addRelation(form({ bookId, fromId: anna.id, toId: erik.id, type: "Vänner", startDate: "förra året" })); expect(await prisma.relation.count()).toBe(0); await addRelation(form({ bookId, fromId: anna.id, toId: erik.id, type: "Vänner", bond: "FIENDE" })); expect((await prisma.relation.findFirstOrThrow()).bond).toBeNull(); }); it("kan ändra och ta bort släktband och period", async () => { const relation = await makeRelation(bookId, anna.id, erik.id, "Mor till", [], { bond: "PARENT", startDate: "1990" }); const to = await redirectedTo(() => saveRelation(form({ bookId, id: relation.id, type: "Mor till", bond: "", startDate: "", endDate: "2000-01" }))); expect(to).toContain(`/relations/${relation.id}`); expect(await prisma.relation.findUniqueOrThrow({ where: { id: relation.id } })).toMatchObject({ bond: null, startDate: null, endDate: "2000-01" }); }); it("ett ogiltigt datum vid ändring sparar ingenting", async () => { const relation = await makeRelation(bookId, anna.id, erik.id, "Gift", [], { startDate: "2000" }); await saveRelation(form({ bookId, id: relation.id, type: "Skild", startDate: "2000", endDate: "snart" })); expect((await prisma.relation.findUniqueOrThrow({ where: { id: relation.id } })).type).toBe("Gift"); }); }); describe("händelser", () => { it("skapar en händelse med deltagare från boken", async () => { const other = await makeBook((await makeUser("Annan")).id, "Annan bok"); const stranger = await makeEntity(other.id, "CHARACTER", "Främling"); const to = await redirectedTo(() => addEvent(form({ bookId, title: "Bröllop", date: "1985-8-1", endDate: "1985-08-03", description: "Vid sjön", participantIds: [anna.id, erik.id, stranger.id, anna.id] })), ); expect(to).toBe(`/books/${bookId}/timeline`); const event = await prisma.storyEvent.findFirstOrThrow({ include: { participants: true } }); expect(event).toMatchObject({ title: "Bröllop", date: "1985-08-01", endDate: "1985-08-03", description: "Vid sjön" }); // Bara poster i den här boken, och ingen dubblett expect(event.participants.map((p) => p.entityId).sort()).toEqual([anna.id, erik.id].sort()); }); it("ogiltigt datum skapar ingen händelse och visar ett fel", async () => { const to = await redirectedTo(() => addEvent(form({ bookId, title: "Fel", date: "i går" }))); expect(to).toBe(`/books/${bookId}/timeline?error=date`); expect(await prisma.storyEvent.count()).toBe(0); }); it("ett slutdatum före startdatumet ignoreras", async () => { await redirectedTo(() => addEvent(form({ bookId, title: "Baklänges", date: "2000", endDate: "1990" }))); expect((await prisma.storyEvent.findFirstOrThrow()).endDate).toBeNull(); }); it("kräver en rubrik", async () => { await addEvent(form({ bookId, title: "", date: "2000" })); expect(await prisma.storyEvent.count()).toBe(0); }); it("kan ändras och byta deltagare", async () => { const event = await makeEvent(bookId, "Flytt", "2000", [anna.id]); const to = await redirectedTo(() => saveEvent(form({ bookId, id: event.id, title: "Flytt till Lund", date: "2001-05", participantIds: [erik.id] }))); expect(to).toBe(`/books/${bookId}/timeline/${event.id}?saved=1`); const saved = await prisma.storyEvent.findUniqueOrThrow({ where: { id: event.id }, include: { participants: true } }); expect(saved).toMatchObject({ title: "Flytt till Lund", date: "2001-05" }); expect(saved.participants.map((p) => p.entityId)).toEqual([erik.id]); }); it("kan tas bort, men bara i den egna boken", async () => { const event = await makeEvent(bookId, "Flytt", "2000", [anna.id]); await redirectedTo(() => deleteEvent(form({ bookId, id: event.id }))); expect(await prisma.storyEvent.count()).toBe(0); expect(await prisma.eventParticipant.count()).toBe(0); const otherBook = await makeBook(ownerId, "Bok två"); const foreign = await makeEvent(otherBook.id, "Annans", "2000"); await redirectedTo(() => deleteEvent(form({ bookId, id: foreign.id }))); expect(await prisma.storyEvent.count()).toBe(1); }); it("kan inte ändra en annan boks händelse", async () => { const otherBook = await makeBook(ownerId, "Bok två"); const foreign = await makeEvent(otherBook.id, "Annans", "2000"); await expect(saveEvent(form({ bookId, id: foreign.id, title: "Kapad", date: "2000" }))).rejects.toThrow("Event not found"); }); it("tas bort tillsammans med deltagaren eller boken", async () => { const event = await makeEvent(bookId, "Fest", "2000", [anna.id, erik.id]); await prisma.entity.delete({ where: { id: anna.id } }); expect(await prisma.eventParticipant.count({ where: { eventId: event.id } })).toBe(1); await prisma.book.delete({ where: { id: bookId } }); expect(await prisma.storyEvent.count()).toBe(0); }); }); describe("export och import", () => { it("släktband, perioder och händelser följer med och pekar på de nya posterna", async () => { await makeRelation(bookId, anna.id, erik.id, "Mor till", [lisa.id], { bond: "PARENT", startDate: "1990", endDate: "2020-01-02" }); await makeEvent(bookId, "Begravning", "2020-01-10", [erik.id, lisa.id], { endDate: "2020-01-11", description: "Kyrkan" }); const exported = await buildExport(bookId, false); const entries = { "book.json": strToU8(JSON.stringify(exported.data)) }; const { data, files } = readImportFile(zipSync(entries)); const result = await importBook(ownerId, data, files); expect(result).toMatchObject({ relations: 1, events: 1 }); const copy = await prisma.book.findUniqueOrThrow({ where: { id: result.bookId }, include: { entities: true, relations: true, events: { include: { participants: true } } }, }); const byName = Object.fromEntries(copy.entities.map((e) => [e.name, e.id])); expect(copy.relations[0]).toMatchObject({ bond: "PARENT", startDate: "1990", endDate: "2020-01-02" }); expect(copy.events[0]).toMatchObject({ title: "Begravning", date: "2020-01-10", endDate: "2020-01-11", description: "Kyrkan" }); expect(copy.events[0].participants.map((p) => p.entityId).sort()).toEqual([byName.Erik, byName.Lisa].sort()); // Datumfälten i mallfälten följer med som vanligt expect((copy.entities.find((e) => e.name === "Anna")!.data as Record).birthDate).toBe("1960-05-10"); }); it("äldre exportfiler utan släktband och händelser går att läsa", () => { const old = validExport() as Record; delete old.events; old.relations = [{ id: "r", fromId: "a", toId: "b", type: "Vänner" }]; const parsed = parseExport(JSON.parse(JSON.stringify(old))); expect(parsed.events).toEqual([]); expect(parsed.relations[0]).toMatchObject({ bond: null, startDate: null, endDate: null }); }); it("ogiltigt släktband eller datum på en relation blir tomt, men en händelse utan giltigt datum avvisar filen", () => { const parsed = parseExport({ ...validExport(), relations: [{ id: "r", fromId: "a", toId: "b", type: "X", bond: "FIENDE", startDate: "nej", endDate: "2000-2-3" }] }); expect(parsed.relations[0]).toMatchObject({ bond: null, startDate: null, endDate: "2000-02-03" }); expect(() => parseExport({ ...validExport(), events: [{ title: "Fel", date: "nej" }] })).toThrow(ImportError); expect(() => parseExport({ ...validExport(), events: [{ title: "", date: "2000" }] })).toThrow(ImportError); }); it("deltagare som inte finns i filen hoppas över", async () => { const data = validExport({ entities: [entityRow("a", "CHARACTER", "Anna")], relations: [relationRow("r", "a", "a", "x")], events: [{ title: "Möte", date: "2001", endDate: null, description: null, participants: ["a", "finns-inte", "a"] }], }); const result = await importBook(ownerId, data, new Map()); const event = await prisma.storyEvent.findFirstOrThrow({ where: { bookId: result.bookId }, include: { participants: true } }); expect(event.participants).toHaveLength(1); }); it("en bok som läggs i papperskorgen och återställs behåller släktband och händelser", async () => { await makeRelation(bookId, anna.id, erik.id, "Mor till", [], { bond: "PARENT", startDate: "1990" }); await makeEvent(bookId, "Fest", "2000", [anna.id]); await trashBook(ownerId, bookId); expect(await prisma.storyEvent.count()).toBe(0); const item = await prisma.trashItem.findFirstOrThrow({ where: { kind: "book" } }); const restored = await restoreBook(ownerId, item.id); const copy = await prisma.book.findUniqueOrThrow({ where: { id: restored! }, include: { relations: true, events: { include: { participants: { include: { entity: true } } } } }, }); expect(copy.relations[0]).toMatchObject({ bond: "PARENT", startDate: "1990" }); expect(copy.events[0].title).toBe("Fest"); expect(copy.events[0].participants.map((p) => p.entity.name)).toEqual(["Anna"]); }); }); describe("papperskorgen", () => { it("återställer släktband, period och deltagande i händelser", async () => { const relation = await makeRelation(bookId, anna.id, erik.id, "Mor till", [], { bond: "PARENT", startDate: "1990", endDate: "2020" }); const event = await makeEvent(bookId, "Fest", "2000", [anna.id, erik.id]); await trashEntity(ownerId, bookId, anna.id); expect(await prisma.eventParticipant.count({ where: { eventId: event.id } })).toBe(1); const [item] = await prisma.trashItem.findMany(); await restoreEntity(ownerId, item.id); expect(await prisma.relation.findUniqueOrThrow({ where: { id: relation.id } })).toMatchObject({ bond: "PARENT", startDate: "1990", endDate: "2020" }); const participants = await prisma.eventParticipant.findMany({ where: { eventId: event.id } }); expect(participants.map((p) => p.entityId).sort()).toEqual([anna.id, erik.id].sort()); }); it("klarar ögonblicksbilder från före släktträdet", async () => { const relation = await makeRelation(bookId, anna.id, erik.id, "Vänner"); await trashEntity(ownerId, bookId, anna.id); const [item] = await prisma.trashItem.findMany(); // En gammal bild saknar bond, datum och eventIds const snapshot = item.payload as { relations: Record[]; eventIds?: string[] }; for (const r of snapshot.relations) { delete r.bond; delete r.startDate; delete r.endDate; } delete snapshot.eventIds; await prisma.trashItem.update({ where: { id: item.id }, data: { payload: snapshot as object } }); expect(await restoreEntity(ownerId, item.id)).not.toBeNull(); expect(await prisma.relation.findUniqueOrThrow({ where: { id: relation.id } })).toMatchObject({ bond: null, startDate: null, endDate: null }); }); }); describe("fältvärden", () => { it("datumfält sparas i fast form och ogiltiga datum ändrar ingenting", async () => { const { fields } = await getTemplate(bookId, "CHARACTER", "sv"); expect(fields.find((f) => f.key === "deathDate")?.type).toBe("date"); const saved = await collectFieldData(bookId, fields, form({ f_birthDate: "1960-5-1", f_deathDate: "snart" }), { deathDate: "2020" }); expect(saved.birthDate).toBe("1960-05-01"); expect(saved.deathDate).toBe("2020"); const cleared = await collectFieldData(bookId, fields, form({ f_birthDate: "" }), { birthDate: "1960" }); expect(cleared.birthDate).toBeUndefined(); }); it("scenariomallen har ett datumfält", async () => { const { fields } = await getTemplate(bookId, "SCENARIO", "sv"); expect(fields.find((f) => f.key === "date")?.type).toBe("date"); }); }); describe("tidslinjen", () => { it("samlar datum från hela boken", async () => { const olyckan = await makeEntity(bookId, "SCENARIO", "Olyckan", { data: { date: "1999-07-01", scenarioType: "Olycka", linkedEntity: lisa.id } }); const rymmen = await makeEntity(bookId, "SCENARIO", "Rymmen", { data: { when: "Någon gång" } }); await makeRelation(bookId, anna.id, olyckan.id, "Involverad i"); await makeRelation(bookId, erik.id, lisa.id, "Gift", [], { startDate: "2010", endDate: "2015" }); await makeEvent(bookId, "Fest", "2005-06", [erik.id]); const { items, undated } = await loadTimeline(bookId); expect(items.map((i) => `${i.date} ${i.kind} ${i.title}`)).toEqual([ "1960-05-10 birth Anna", "1990 birth Erik", "1999-07-01 scenario Olyckan", "2005-06 event Fest", "2010 relation Gift", "2020 death Anna", ]); expect(undated.map((u) => u.title)).toEqual(["Rymmen"]); expect(rymmen.id).toBeTruthy(); // Scenariot knyts till personerna via relationen och via kopplingsfältet, med ålder vid tillfället const scenario = items.find((i) => i.kind === "scenario")!; expect(scenario.people.map((p) => p.name).sort()).toEqual(["Anna", "Lisa"]); expect(scenario.ages).toEqual([{ id: anna.id, name: "Anna", age: 39 }]); expect(items.find((i) => i.kind === "relation")).toMatchObject({ endDate: "2015", people: expect.arrayContaining([{ id: erik.id, name: "Erik" }]) }); }); it("filtrerar på person och hör bara till den egna boken", async () => { const other = await makeBook(ownerId, "Bok två"); await makeEntity(other.id, "CHARACTER", "Främling", { data: { birthDate: "1900" } }); await makeEvent(bookId, "Fest", "2005", [erik.id]); const { items } = await loadTimeline(bookId, undefined, erik.id); expect(items.map((i) => i.title)).toEqual(["Erik", "Fest"]); expect((await loadTimeline(bookId)).items.some((i) => i.title === "Främling")).toBe(false); }); it("ignorerar ogiltiga datum i mallfält", async () => { await prisma.entity.update({ where: { id: lisa.id }, data: { data: { birthDate: "oklart", deathDate: 1999 } } }); const { items } = await loadTimeline(bookId); expect(items.some((i) => i.title === "Lisa")).toBe(false); }); }); });