import { beforeEach, describe, expect, it, vi } from "vitest"; import { makeDocx, para, table } from "../helpers/docx"; 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 { previewWordImport, saveWordImport } from "@/actions/word-import"; import { MAX_DOCX_BYTES } from "@/lib/word-docx"; import { commitWordImport, previewWordFiles, type CommitItem } from "@/lib/word-import-db"; const character = (name: string, extra: string[][] = [], code = "KI-0001") => makeDocx([table(["Karaktärs ID:", code], ["Förnamn:", name], ["Efternamn:", "Test"], ...extra), para("Övrigt:"), para("Anteckning.")]); const bytes = (doc: Uint8Array) => ({ name: "doc.docx", bytes: doc }); async function attempt(run: () => Promise): Promise { try { await run(); return "ok"; } catch (error) { const message = error instanceof Error ? error.message : String(error); if (message === "NOT_FOUND" || message.startsWith("REDIRECT:")) return message; throw error; } } describeDb("import från Word", () => { let ownerId: string; let bookId: string; beforeEach(async () => { await resetAll(); ownerId = (await makeUser()).id; bookId = (await makeBook(ownerId)).id; login.userId = ownerId; }); describe("förhandsgranskning", () => { it("tolkar dokumentet mot bokens poster och markerar dubbletter", async () => { const anna = await makeEntity(bookId, "CHARACTER", "Anna Test"); const [doc] = await previewWordFiles(bookId, [bytes(character("Anna", [["Anställd hos:", "Okänd"]]))]); expect(doc.error).toBeNull(); expect(doc.kind).toBe("CHARACTER"); expect(doc.items[0]).toMatchObject({ name: "Anna Test", code: "KI-0001" }); expect(doc.items[0].duplicates).toEqual([{ id: anna.id, name: "Anna Test", code: anna.code }]); expect(doc.items[0].links).toEqual([{ type: "Jobbar på", toDocument: false, entityId: null, text: "Okänd", note: "" }]); }); it("hittar poster i boken på ID och namn, men inte i en annan bok", async () => { const company = await makeEntity(bookId, "COMPANY", "Lunds skola"); const otherBook = await makeBook(ownerId, "Annan bok"); await makeEntity(otherBook.id, "COMPANY", "Främmande AB"); const [doc] = await previewWordFiles(bookId, [ bytes(character("Eva", [["Anställd hos:", `Lunds skola ${company.code}, Främmande AB`]])), ]); expect(doc.items[0].links.map((l) => [l.text, l.entityId])).toEqual([ [`Lunds skola ${company.code}`, company.id], ["Främmande AB", null], ]); }); it("använder bokens egen mall, med ändrade etiketter", async () => { await prisma.template.create({ data: { bookId, kind: "CHARACTER", fields: [{ key: "job", label: "Arbete", type: "text" }, { key: "notes", label: "Övrigt", type: "textarea" }] } }); const [doc] = await previewWordFiles(bookId, [bytes(character("Eva", [["Arbete:", "Snickare"]]))]); expect(doc.items[0].data).toEqual({ job: "Snickare", notes: "Anteckning." }); }); it("rapporterar filer som inte går att läsa, och läser de andra", async () => { const docs = await previewWordFiles(bookId, [ { name: "text.docx", bytes: new TextEncoder().encode("bara text") }, bytes(character("Eva")), { name: "stor.docx", bytes: new Uint8Array(MAX_DOCX_BYTES + 1) }, ]); expect(docs.map((d) => d.error)).toEqual(["not-docx", null, "too-large"]); expect(docs[1].items).toHaveLength(1); }); it("låter användaren byta dokumenttyp", async () => { const [doc] = await previewWordFiles(bookId, [bytes(makeDocx([table(["Namn:", "Rex"], ["Ras:", "Boxer"])]))], ["PET"]); expect(doc).toMatchObject({ kind: "PET" }); expect(doc.items[0]).toMatchObject({ name: "Rex", data: { breed: "Boxer" } }); }); it("sparar ingenting", async () => { await previewWordFiles(bookId, [bytes(character("Eva"))]); expect(await prisma.entity.count()).toBe(0); }); }); describe("sparande", () => { const item = (overrides: Partial = {}): CommitItem => ({ include: true, entityKind: "CHARACTER", name: "Eva Test", code: "KI-0007", data: { occupation: "Lärare" }, links: [], unmatched: [], ...overrides, }); const commit = (items: CommitItem[], appendUnmatched = true) => commitWordImport(bookId, ownerId, items, { appendUnmatched }); it("skapar poster med dokumentets ID när det är ledigt, annars ett nytt", async () => { await makeEntity(bookId, "CHARACTER", "Redan"); // tar KI-0001 const result = await commit([item(), item({ name: "Två", code: "KI-0001" }), item({ name: "Tre", code: null }), item({ name: "Fyra", code: "FEL-1" })]); expect(result).toMatchObject({ created: 4, skipped: 0 }); const codes = Object.fromEntries((await prisma.entity.findMany({ where: { bookId } })).map((e) => [e.name, e.code])); expect(codes["Eva Test"]).toBe("KI-0007"); expect(new Set(Object.values(codes)).size).toBe(5); // alla ID är unika expect(codes["Två"]).not.toBe("KI-0001"); }); it("nya poster fortsätter numreringen efter importerade ID", async () => { await commit([item({ code: "KI-0020" })]); expect((await makeEntity(bookId, "CHARACTER", "Nästa")).code).toBe("KI-0021"); }); it("hoppar över poster som användaren valt bort, och poster utan namn", async () => { const result = await commit([item({ include: false }), item({ name: " " }), item({ name: "Behåll", code: null })]); expect(result).toMatchObject({ created: 1, skipped: 2 }); expect((await prisma.entity.findMany({ where: { bookId } })).map((e) => e.name)).toEqual(["Behåll"]); }); it("lägger det som inte tolkats i Övrigt, om användaren vill", async () => { await commit([item({ data: { notes: "Först." }, unmatched: [{ label: "Relationer", value: "Vän med Bo." }] })]); const [saved] = await prisma.entity.findMany({ where: { bookId } }); expect((saved.data as { notes: string }).notes).toBe("Först.\n\nRelationer: Vän med Bo."); const other = await makeBook(ownerId, "Utan tillägg"); await commitWordImport(other.id, ownerId, [item({ unmatched: [{ label: "Relationer", value: "Vän med Bo." }] })], { appendUnmatched: false }); expect((await prisma.entity.findFirstOrThrow({ where: { bookId: other.id } })).data).toEqual({ occupation: "Lärare" }); }); it("skapar relationer åt rätt håll med anteckning", async () => { const anna = await makeEntity(bookId, "CHARACTER", "Anna"); const company = await makeEntity(bookId, "COMPANY", "Firma"); await commit([ item({ name: "Eva", links: [{ type: "Jobbar på", toDocument: false, entityId: company.id, text: "Firma", note: "" }] }), item({ entityKind: "COMPANY", name: "Kaffe AB", code: null, data: {}, links: [ { type: "Jobbar på", toDocument: true, entityId: anna.id, text: "Anna", note: "Barista" }, { type: "Jobbar på", toDocument: true, entityId: null, text: "Okänd", note: "" }, ], }), ]); const relations = await prisma.relation.findMany({ include: { from: true, to: true }, orderBy: { createdAt: "asc" } }); expect(relations.map((r) => [r.from.name, r.type, r.to.name, r.description])).toEqual([ ["Eva", "Jobbar på", "Firma", null], ["Anna", "Jobbar på", "Kaffe AB", "Barista"], ]); expect(relations.every((r) => r.code && r.updatedById === ownerId)).toBe(true); }); it("kopplingar till poster i en annan bok och till sig själv ignoreras", async () => { const otherBook = await makeBook(ownerId, "Annan"); const foreign = await makeEntity(otherBook.id, "CHARACTER", "Främling"); await commit([item({ links: [{ type: "Vän till", toDocument: false, entityId: foreign.id, text: "Främling", note: "" }] })]); expect(await prisma.relation.count()).toBe(0); }); it("rensar värden som inte hör hemma i mallen, och kopplingsfält till fel typ eller bok", async () => { const otherBook = await makeBook(ownerId, "Annan"); const foreign = await makeEntity(otherBook.id, "PREMISES", "Främmande lokal"); const own = await makeEntity(bookId, "CHARACTER", "Anna"); await commit([ item({ entityKind: "COMPANY", name: "Firma", code: null, data: { industry: "Kaffe", premises: foreign.id, sketch: own.id, hotelRooms: "tio", okänt: "x", satisfaction: "Fantastisk", hasSketches: true }, }), ]); expect((await prisma.entity.findFirstOrThrow({ where: { bookId, name: "Firma" } })).data).toEqual({ industry: "Kaffe", hasSketches: true }); }); it("okända dokumenttyper och trasiga poster hoppas över utan att stoppa resten", async () => { const result = await commit([item({ entityKind: "FINNS_INTE" }), null as unknown as CommitItem, item({ name: "Ok", code: null })]); expect(result.created).toBe(1); }); it("en relation kräver två deltagare i boken och sätter släktband för partner", async () => { const a = await makeEntity(bookId, "CHARACTER", "A"); const b = await makeEntity(bookId, "CHARACTER", "B"); const c = await makeEntity(bookId, "CHARACTER", "C"); const relation = (participants: string[], category: string): CommitItem => item({ entityKind: "RELATION", name: category, code: null, data: { category, healthy: true }, participants }); expect(await commit([relation([a.id], "Partner")])).toMatchObject({ relations: 0, skipped: 1 }); expect(await commit([relation([a.id, "finns-inte"], "Partner")])).toMatchObject({ relations: 0 }); await commit([relation([a.id, b.id, c.id], "Partner"), relation([a.id, c.id], "Vännergrupp")]); const relations = await prisma.relation.findMany({ include: { members: true }, orderBy: { createdAt: "asc" } }); expect(relations.map((r) => [r.type, r.bond, r.members.length])).toEqual([ ["Partner till", "PARTNER", 1], ["Vänner", null, 0], ]); expect(relations[0]).toMatchObject({ fromId: a.id, toId: b.id, data: { category: "Partner", healthy: true } }); }); it("sparar allt eller inget om något går fel", async () => { const result = commit([item({ name: "Bra", code: null }), item({ name: "x".repeat(10), code: null, data: { nickname: "y".repeat(30000) } })]); await expect(result).resolves.toMatchObject({ created: 2 }); // För långa värden kortas i stället för att avvisas const long = await prisma.entity.findFirstOrThrow({ where: { bookId, name: "xxxxxxxxxx" } }); expect(((long.data as { nickname: string }).nickname ?? "").length).toBeLessThanOrEqual(20000); }); }); describe("åtgärderna", () => { const formWith = (docs: { name: string; bytes: Uint8Array }[], kinds: string[] = []) => { const data = new FormData(); data.set("bookId", bookId); for (const d of docs) data.append("files", new File([d.bytes as BlobPart], d.name)); for (const k of kinds) data.append("kinds", k); return data; }; it("förhandsgranskar och sparar för redaktörer", async () => { const response = await previewWordImport(formWith([bytes(character("Eva"))])); if (!("docs" in response)) throw new Error("Väntade förhandsgranskning"); expect(response.docs[0].items[0].name).toBe("Eva Test"); const result = await saveWordImport({ bookId, appendUnmatched: true, items: [{ include: true, entityKind: "CHARACTER", name: "Eva Test", code: null, data: {}, links: [], unmatched: [] }] }); expect(result.created).toBe(1); }); it("kräver minst en fil och högst 20", async () => { expect(await previewWordImport(formWith([]))).toEqual({ error: "no-files" }); expect(await previewWordImport(formWith(Array.from({ length: 21 }, () => bytes(character("Eva")))))).toEqual({ error: "limit" }); }); it("stora filer läses inte alls", async () => { const response = await previewWordImport(formWith([{ name: "stor.docx", bytes: new Uint8Array(MAX_DOCX_BYTES + 10) }])); if (!("docs" in response)) throw new Error("Väntade svar"); expect(response.docs[0].error).toBe("too-large"); }); it("läsare och obehöriga får inte importera", async () => { const viewer = await makeUser("Läsare"); const stranger = await makeUser("Obehörig"); await prisma.bookMember.create({ data: { bookId, userId: viewer.id, role: "VIEWER" } }); const editor = await makeUser("Redaktör"); await prisma.bookMember.create({ data: { bookId, userId: editor.id, role: "EDITOR" } }); for (const user of [viewer, stranger]) { login.userId = user.id; expect(await attempt(() => previewWordImport(formWith([bytes(character("Eva"))])))).toBe("NOT_FOUND"); expect(await attempt(() => saveWordImport({ bookId, appendUnmatched: false, items: [] }))).toBe("NOT_FOUND"); } expect(await prisma.entity.count()).toBe(0); login.userId = editor.id; const result = await saveWordImport({ bookId, appendUnmatched: false, items: [{ include: true, entityKind: "CHARACTER", name: "Av redaktör", code: null, data: {}, links: [], unmatched: [] }] }); expect(result.created).toBe(1); expect((await prisma.entity.findFirstOrThrow()).updatedById).toBe(editor.id); }); }); });