Delning av böcker, skydd mot kolliderande ändringar och import från Word

Böcker kan delas med roller (läsare, redaktör, administratör), och
behörigheten kontrolleras på servern. Formulär för poster, relationer och
händelser skickar med version, och en krock visar vad som skiljer och låter
användaren spara ändå eller ladda om. Ifyllda Word-mallar kan importeras med
förhandsgranskning. Importerade ID flyttar nu räknaren. Migrering 0007.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
bobbanandClaude Sonnet 5.5 committed 2026-11-04 23:53:33 +01:00
1 parent bd269d70a5
commit 86fd435438
64 files changed
+4796 -235

No files matched your search

+61
View File
@@ -0,0 +1,61 @@
import { describe, expect, it } from "vitest";
import { canChangeMember, hasRole, manageableRoles, parseMemberRole, type BookRole } from "@/lib/access";
const ROLES: BookRole[] = ["VIEWER", "EDITOR", "ADMIN", "OWNER"];
describe("hasRole", () => {
it("varje roll räcker för sin egen nivå och allt under", () => {
for (const [i, role] of ROLES.entries()) {
for (const [j, min] of ROLES.entries()) expect(hasRole(role, min)).toBe(i >= j);
}
});
it("läsare får inte skriva, redaktörer får inte administrera, bara ägaren äger", () => {
expect(hasRole("VIEWER", "EDITOR")).toBe(false);
expect(hasRole("EDITOR", "ADMIN")).toBe(false);
expect(hasRole("ADMIN", "OWNER")).toBe(false);
expect(hasRole("OWNER", "OWNER")).toBe(true);
});
});
describe("parseMemberRole", () => {
it("godtar bara roller som kan delas ut", () => {
expect(parseMemberRole("ADMIN")).toBe("ADMIN");
expect(parseMemberRole("EDITOR")).toBe("EDITOR");
expect(parseMemberRole("VIEWER")).toBe("VIEWER");
expect(parseMemberRole("OWNER")).toBeNull();
expect(parseMemberRole("admin")).toBeNull();
expect(parseMemberRole(undefined)).toBeNull();
expect(parseMemberRole(1)).toBeNull();
});
});
describe("vem som får hantera vem", () => {
it("ägaren hanterar alla, administratören bara redaktörer och läsare, andra ingen", () => {
expect(manageableRoles("OWNER")).toEqual(["ADMIN", "EDITOR", "VIEWER"]);
expect(manageableRoles("ADMIN")).toEqual(["EDITOR", "VIEWER"]);
expect(manageableRoles("EDITOR")).toEqual([]);
expect(manageableRoles("VIEWER")).toEqual([]);
});
it("en administratör kan varken ändra, ta bort eller utse andra administratörer", () => {
expect(canChangeMember("ADMIN", "ADMIN", "EDITOR")).toBe(false);
expect(canChangeMember("ADMIN", "ADMIN", null)).toBe(false);
expect(canChangeMember("ADMIN", "EDITOR", "ADMIN")).toBe(false);
expect(canChangeMember("ADMIN", "EDITOR", "VIEWER")).toBe(true);
expect(canChangeMember("ADMIN", "VIEWER", null)).toBe(true);
});
it("ägaren kan göra allt", () => {
expect(canChangeMember("OWNER", "ADMIN", "VIEWER")).toBe(true);
expect(canChangeMember("OWNER", "EDITOR", "ADMIN")).toBe(true);
expect(canChangeMember("OWNER", "VIEWER", null)).toBe(true);
});
it("redaktörer och läsare kan inte hantera någon", () => {
for (const actor of ["EDITOR", "VIEWER"] as const) {
expect(canChangeMember(actor, "VIEWER", "EDITOR")).toBe(false);
expect(canChangeMember(actor, "VIEWER", null)).toBe(false);
}
});
});
+93
View File
@@ -0,0 +1,93 @@
import { strToU8, zipSync } from "fflate";
import { describe, expect, it } from "vitest";
import { DocxError, MAX_DOCX_BYTES, decodeXml, parseDocumentXml, readDocx } from "@/lib/word-docx";
import { makeDocx, para, table } from "../helpers/docx";
const wrap = (body: string) => `<w:document xmlns:w="x"><w:body>${body}</w:body></w:document>`;
const p = (text: string) => `<w:p><w:r><w:t>${text}</w:t></w:r></w:p>`;
describe("parseDocumentXml", () => {
it("läser stycken i ordning och hoppar över tomma", () => {
expect(parseDocumentXml(wrap(`${p("Första")}<w:p/><w:p><w:pPr/></w:p>${p("Andra")}`))).toEqual([
{ type: "paragraph", text: "Första" },
{ type: "paragraph", text: "Andra" },
]);
});
it("sätter ihop text som Word delat upp i flera delar", () => {
const xml = wrap(`<w:p><w:r><w:t>Hej </w:t></w:r><w:r><w:t xml:space="preserve">världen</w:t></w:r></w:p>`);
expect(parseDocumentXml(xml)).toEqual([{ type: "paragraph", text: "Hej världen" }]);
});
it("läser tabeller med rader och celler, och behåller tomma celler", () => {
const cell = (text: string) => `<w:tc><w:tcPr/>${text ? p(text) : "<w:p/>"}</w:tc>`;
const xml = wrap(`<w:tbl><w:tblPr/><w:tr>${cell("Namn:")}${cell("")}</w:tr><w:tr>${cell("Ålder:")}${cell("30")}</w:tr></w:tbl>${p("Efter")}`);
expect(parseDocumentXml(xml)).toEqual([
{ type: "table", rows: [["Namn:", ""], ["Ålder:", "30"]] },
{ type: "paragraph", text: "Efter" },
]);
});
it("flera stycken i en cell slås ihop med radbrytning", () => {
const xml = wrap(`<w:tbl><w:tr><w:tc>${p("Rad ett")}${p("Rad två")}</w:tc></w:tr></w:tbl>`);
expect(parseDocumentXml(xml)).toEqual([{ type: "table", rows: [["Rad ett\nRad två"]] }]);
});
it("en tabell i en cell blir text i den yttre cellen", () => {
const inner = `<w:tbl><w:tr><w:tc>${p("Inre")}</w:tc></w:tr></w:tbl>`;
const xml = wrap(`<w:tbl><w:tr><w:tc>${p("Yttre")}${inner}</w:tc><w:tc>${p("Bredvid")}</w:tc></w:tr></w:tbl>`);
expect(parseDocumentXml(xml)).toEqual([{ type: "table", rows: [["Yttre\nInre", "Bredvid"]] }]);
});
it("tolkar radbrytning, tabb och symboler", () => {
const xml = wrap(`<w:p><w:r><w:t>A</w:t><w:br/><w:t>B</w:t><w:tab/><w:t>C</w:t><w:sym w:font="Wingdings" w:char="F0FE"/></w:r></w:p>`);
expect(parseDocumentXml(xml)).toEqual([{ type: "paragraph", text: "A\nB\tC✓" }]);
});
it("avkodar tecken i texten", () => {
expect(parseDocumentXml(wrap(p("Tom &amp; Jerry &lt;3 &#229;&#xE4;")))).toEqual([{ type: "paragraph", text: "Tom & Jerry <3 åä" }]);
});
it("klarar tomt och trasigt innehåll utan att kasta", () => {
expect(parseDocumentXml("")).toEqual([]);
expect(parseDocumentXml(wrap("<w:tbl><w:tr><w:tc>"))).toEqual([]);
expect(() => parseDocumentXml("</w:tbl></w:tbl></w:p><w:t>")).not.toThrow();
});
});
describe("decodeXml", () => {
it("avkodar de vanliga tecknen och lämnar okända som de är", () => {
expect(decodeXml("&amp;&lt;&gt;&quot;&apos;")).toBe(`&<>"'`);
expect(decodeXml("&okänd;")).toBe("&okänd;");
expect(decodeXml("&#0;&#1114112;")).toBe("");
});
});
describe("readDocx", () => {
it("läser en docx-fil som skrivits som Word gör", () => {
const blocks = [para("Rubrik:"), table(["Förnamn:", "Åsa"], ["Smeknamn:", "Rad ett\nRad två"]), para("Text med <tecken> & annat")];
expect(readDocx(makeDocx(blocks))).toEqual(blocks);
});
it("avvisar filer som inte är Word-dokument", () => {
const code = (bytes: Uint8Array) => {
try {
readDocx(bytes);
return null;
} catch (error) {
return error instanceof DocxError ? error.code : "annat";
}
};
expect(code(new Uint8Array())).toBe("not-docx");
expect(code(strToU8("det här är text"))).toBe("not-docx");
expect(code(zipSync({ "annat.txt": strToU8("x") }))).toBe("not-docx");
expect(code(new Uint8Array([0x50, 0x4b, 1, 2, 3, 4, 5, 6]))).toBe("invalid");
expect(code(new Uint8Array(MAX_DOCX_BYTES + 1))).toBe("too-large");
});
it("packar inte upp något annat än huvuddokumentet", () => {
// Ett jättestort dokument stoppas av gränsen för uppackad storlek
const huge = zipSync({ "word/document.xml": strToU8("x".repeat(31 * 1024 * 1024)) });
expect(() => readDocx(huge)).toThrow(DocxError);
});
});
+212
View File
@@ -0,0 +1,212 @@
import { existsSync, readFileSync } from "node:fs";
import { describe, expect, it } from "vitest";
import { readDocx, type DocBlock } from "@/lib/word-docx";
import { analyzeDocument, type KnownEntity } from "@/lib/word-import";
import { fillAll } from "../helpers/docx-fill";
// Ifyllda versioner av de riktiga Word-mallarna i Mall/ och Register/. Mallen läses ur filen och fylls i på det sätt
// en person skulle göra i Word, så att tolkningen prövas mot mallarnas verkliga uppbyggnad.
const root = new URL("../../", import.meta.url);
const available = existsSync(new URL("Mall/Karaktärermall.docx", root));
const load = (path: string): DocBlock[] => readDocx(new Uint8Array(readFileSync(new URL(path, root))));
const known: KnownEntity[] = [
{ id: "k1", name: "Anna Lind", code: "KI-0001", kind: "CHARACTER" },
{ id: "k2", name: "Bo Ek", code: "KI-0002", kind: "CHARACTER" },
{ id: "c1", name: "Lunds skola", code: "FI-0002", kind: "COMPANY" },
{ id: "l1", name: "Café Lund", code: "LI-0001", kind: "PREMISES" },
];
const analyze = (blocks: DocBlock[], file: string) => {
const doc = analyzeDocument(blocks, file, known);
expect(doc.items.length).toBeGreaterThan(0);
return { doc, item: doc.items[0] };
};
describe.skipIf(!available)("ifyllda riktiga mallar", () => {
it("karaktärsmallen", () => {
const blocks = fillAll(load("Mall/Karaktärermall.docx"), [
["Karaktärs ID", "KI-0042"],
["Förnamn", "Åsa"],
["Efternamn", "Berg"],
["Smeknamn", "Åsa-Lena"],
["Yrke", "Lärare"],
["Anställd hos", "Lunds skola FI-0002"],
["Utseende", "Lång och smal."],
["Personlighet", "Varm och nyfiken."],
]);
const { doc, item } = analyze(blocks, "asa.docx");
expect(doc.kind).toBe("CHARACTER");
expect(item).toMatchObject({ name: "Åsa Berg", code: "KI-0042" });
expect(item.data).toMatchObject({ nickname: "Åsa-Lena", occupation: "Lärare", appearance: "Lång och smal.", personality: "Varm och nyfiken." });
expect(item.links).toEqual([{ type: "Jobbar på", toDocument: false, entityId: "c1", text: "Lunds skola FI-0002", note: "" }]);
expect(item.unmatched).toEqual([]);
});
it("korta karaktärsmallen, ifylld i samma cell och i cellen bredvid", () => {
const original = load("Mall/Karaktärermall-kort.docx");
const inline = fillAll(original, [
["Förnamn", "Åsa"],
["Efternamn", "Berg"],
["Yrke", "Lärare"],
["Utseende", "Lång."],
]);
expect(analyze(inline, "kort.docx").item).toMatchObject({ name: "Åsa Berg", data: { occupation: "Lärare", appearance: "Lång." } });
// Värdena i cellen bredvid, på raden som motsvarar etiketten
const beside: DocBlock[] = JSON.parse(JSON.stringify(original));
const first = beside[0];
if (first.type !== "table") throw new Error("Väntade en tabell");
const lines = first.rows[0][0].split("\n");
const values = lines.map(() => "");
values[lines.indexOf("Förnamn:")] = "Åsa";
values[lines.indexOf("Efternamn:")] = "Berg";
values[lines.indexOf("Yrke:")] = "Lärare";
first.rows[0][1] = values.join("\n");
expect(analyze(beside, "kort.docx").item).toMatchObject({ name: "Åsa Berg", data: { occupation: "Lärare" } });
});
it("bostadsmallen", () => {
const blocks = fillAll(load("Mall/Bostadsmall.docx"), [
["Bostads ID", "BI-0003"],
["Bostads typ", "Hyresrätt: X Bostadsrätt: Villa:"],
["Adress", "Storgatan 1"],
["Antal Rum", "3"],
["Boarea", "75"],
["Namn", "Anna Lind KI-0001"],
["Byggnadsutseende", "Rött trähus."],
["Balkong", "Ja: X Nej:"],
["Hyra lägenhet", "5000 kr"],
]);
const { doc, item } = analyze(blocks, "bostad.docx");
expect(doc.kind).toBe("HOME");
expect(item).toMatchObject({ name: "Storgatan 1", code: "BI-0003" });
expect(item.data).toMatchObject({ homeType: "Hyresrätt", address: "Storgatan 1", rooms: 3, livingArea: 75, buildingLook: "Rött trähus.", balcony: true, rentFee: "5000 kr" });
expect(item.links.map((l) => [l.type, l.entityId])).toEqual([["Bor på", "k1"]]);
});
it("företagsmallen", () => {
const blocks = fillAll(load("Mall/Företagsmall.docx"), [
["Företagets namn", "Lunds Kaffe"],
["Företags ID", "FI-0003"],
["Bransch", "Kaffe"],
["Lokal ID", "LI-0001"],
["Finns skisser", "Ja: X Nej:"],
["Namn", "Anna Lind\tBarista\tKI-0001"],
["Alkoholservering", "Ja: X Nej:"],
["Generell nöjdhet bland de anställda", "Bra: X Dåligt:"],
["Beskriv arbetsmiljön", "Trevlig."],
]);
const { doc, item } = analyze(blocks, "foretag.docx");
expect(doc.kind).toBe("COMPANY");
expect(item).toMatchObject({ name: "Lunds Kaffe", code: "FI-0003" });
expect(item.data).toMatchObject({ industry: "Kaffe", premises: "l1", hasSketches: true, alcohol: true, satisfaction: "Bra", workEnvironment: "Trevlig." });
expect(item.links).toEqual([{ type: "Jobbar på", toDocument: true, entityId: "k1", text: "Anna Lind KI-0001", note: "Barista" }]);
});
it("scenariomallen, där frågorna står som egna rader", () => {
const blocks = fillAll(load("Mall/Scenariomall.docx"), [
["Scenario ID", "SNI-0003"],
["Kopplat ID", "KI-0001"],
["Scenario typ", "Bråk: X Olycka: Dödsfall: Otrohet: Brott: Övrigt:"],
["Namn", "Anna Lind KI-0001"],
["Beskriv scenariot", "De bråkade om pengar."],
["Hur påverkas karaktärerna under scenariot", "Mycket spänt."],
]);
const { doc, item } = analyze(blocks, "scenario.docx");
expect(doc.kind).toBe("SCENARIO");
expect(item.code).toBe("SNI-0003");
expect(item.data).toMatchObject({ linkedEntity: "k1", scenarioType: "Bråk", description: "De bråkade om pengar.", impactDuring: "Mycket spänt." });
expect(item.links.map((l) => [l.type, l.entityId])).toEqual([["Involverad i", "k1"]]);
});
it("relationsmallen", () => {
const blocks = fillAll(load("Mall/Relationsmall.docx"), [
["Relations ID", "REI-0009"],
["Relations typ", "Vännergrupper: Partner: X Familj: Kollegor:"],
["Är relationen Hälsosam", "Ja: X Nej:"],
["Namn", "Anna Lind KI-0001"],
["Namn", "Bo Ek KI-0002"],
["Hur fungerar relationen", "De bråkar sällan."],
]);
const { doc, item } = analyze(blocks, "relation.docx");
expect(doc.kind).toBe("RELATION");
expect(doc.relation?.participants.map((p) => p.entityId).sort()).toEqual(["k1", "k2"]);
expect(item.data).toMatchObject({ category: "Partner", healthy: true, howItWorks: "De bråkar sällan." });
});
it("utbildningsmallen", () => {
const blocks = fillAll(load("Mall/Utbildningsmall.docx"), [
["Utbildnings ID", "UI-0002"],
["Skolans namn", "Lunds gymnasium"],
["Utbildningstyp", "Förskola: lågstadium: Mellanstadium: Högstadium:\nGymnasium: X Högskola: Yrkeshögskola: Komvux:"],
["Linje", "Natur"],
["Klass", "3A"],
]);
const { doc, item } = analyze(blocks, "skola.docx");
expect(doc.kind).toBe("EDUCATION");
expect(item).toMatchObject({ name: "Lunds gymnasium", code: "UI-0002" });
expect(item.data).toMatchObject({ educationType: "Gymnasium", program: "Natur", class: "3A" });
});
it("lokalmallen", () => {
const blocks = fillAll(load("Mall/Lokalmall.docx"), [
["Lokal ID", "LI-0005"],
["Adress", "Torget 3"],
["Placerings ID", "PI-0001"],
["Ägande", "Hyr: X Äga:"],
["Hiss", "Ja: X Nej:"],
["Beskriv insidan av lokalen", "Ljust."],
]);
const { doc, item } = analyze(blocks, "lokal.docx");
expect(doc.kind).toBe("PREMISES");
expect(item).toMatchObject({ name: "Torget 3", code: "LI-0005" });
expect(item.data).toMatchObject({ address: "Torget 3", placementId: "PI-0001", tenure: "Hyr", elevator: true, interior: "Ljust." });
});
it("djurmallen", () => {
const blocks = fillAll(load("Mall/Djurmall.docx"), [
["Djur ID", "DI-0004"],
["Namn", "Findus"],
["Ägare", "Anna Lind"],
["Djur kategori", "Husdjur: X Gårdsdjur: Annat:"],
["Ålder", "5"],
["Djurets personlighet", "Nyfiken."],
]);
const { doc, item } = analyze(blocks, "djur.docx");
expect(doc.kind).toBe("PET");
expect(item).toMatchObject({ name: "Findus", code: "DI-0004" });
expect(item.data).toMatchObject({ category: "Husdjur", age: 5, personality: "Nyfiken." });
expect(item.links.map((l) => [l.type, l.entityId])).toEqual([["Husdjur till", "k1"]]);
});
it("fordonsregistret med flera rader", () => {
const blocks = load("Register/Fordonsregister.docx");
const first = blocks[0];
if (first.type !== "table") throw new Error("Väntade en tabell");
first.rows[1] = ["FD-0001", "Volvo V70", "Diesel", "Anna Lind KI-0001", ""];
first.rows[2] = ["FD-0002", "Tesla Model 3", "El", "", ""];
const doc = analyzeDocument(blocks, "fordon.docx", known);
expect(doc.kind).toBe("VEHICLE");
expect(doc.items.map((i) => [i.name, i.code, i.data.fuel, i.data.owner])).toEqual([
["Volvo V70", "FD-0001", "Diesel", "k1"],
["Tesla Model 3", "FD-0002", "El", undefined],
]);
});
it("appregistret med en post per namn", () => {
const blocks = load("Register/Appregister.docx");
const first = blocks.find((b) => b.type === "table");
if (first?.type !== "table") throw new Error("Väntade en tabell");
first.rows[0] = ["Namn: Instagram"];
first.rows[1] = ["Beskrivning: Bilder"];
first.rows[2] = ["Namn: Bankapp"];
const doc = analyzeDocument(blocks, "appar.docx", known);
expect(doc.kind).toBe("APP");
expect(doc.items.map((i) => [i.name, i.data.description])).toEqual([
["Instagram", "Bilder"],
["Bankapp", undefined],
]);
});
});
+687
View File
@@ -0,0 +1,687 @@
import { existsSync, readFileSync } from "node:fs";
import { describe, expect, it } from "vitest";
import type { DocBlock } from "@/lib/word-docx";
import { readDocx } from "@/lib/word-docx";
import { analyzeDocument, detectKind, extract, findEntity, multiLabels, parseCellList, parseInlineBlock, splitLabel, usableCode, type ImportKind, type KnownEntity, type ParsedDocument } from "@/lib/word-import";
import { cleanData } from "@/lib/word-import-db";
import { getDefaultTemplate } from "@/lib/templates";
import { makeDocx, para, table } from "../helpers/docx";
const known: KnownEntity[] = [
{ id: "k1", name: "Anna Lind", code: "KI-0001", kind: "CHARACTER" },
{ id: "k2", name: "Bo Ek", code: "KI-0002", kind: "CHARACTER" },
{ id: "c1", name: "Lunds skola", code: "FI-0002", kind: "COMPANY" },
{ id: "l1", name: "Café Lund", code: "LI-0001", kind: "PREMISES" },
{ id: "r1", name: "Fågelboken", code: "RD-0002", kind: "REFERENCE" },
];
const analyze = (blocks: DocBlock[], file = "mall.docx", kind?: ImportKind): ParsedDocument => analyzeDocument(blocks, file, known, { kind });
const only = (doc: ParsedDocument) => {
expect(doc.items).toHaveLength(1);
return doc.items[0];
};
describe("splitLabel", () => {
it("delar etikett och värde, och ser hjälptexten som en del av resten", () => {
expect(splitLabel("Förnamn: Anna")).toEqual({ label: "Förnamn", rest: " Anna" });
expect(splitLabel("Anställd hos:(inkludera ID)")).toEqual({ label: "Anställd hos", rest: "(inkludera ID)" });
});
it("avvisar det som inte är en etikett", () => {
expect(splitLabel("Ingen etikett här")).toBeNull();
expect(splitLabel("06:00")).toBeNull();
expect(splitLabel(":kolon först")).toBeNull();
expect(splitLabel("http://example.com")).toBeNull();
expect(splitLabel(`${"x".repeat(100)}: för lång`)).toBeNull();
});
});
describe("multiLabels", () => {
it("läser en etikett per rad och slår ihop etiketter som delats över två rader", () => {
const entries = multiLabels("Karaktärs ID:\n\nFörnamn:\nEfternamn:\nÅlder\nfödelsedatum:\nAnställd hos:\n(inkludera ID)");
expect(entries.map((e) => e.label)).toEqual(["Karaktärs ID", "Förnamn", "Efternamn", "Ålder födelsedatum", "Anställd hos"]);
expect(entries[3].lines).toEqual([4, 5]);
});
it("tar värden som står direkt efter etiketten", () => {
expect(multiLabels("Förnamn: Anna\nEfternamn: Lind").map((e) => e.inline)).toEqual(["Anna", "Lind"]);
});
});
describe("celler med flera rader", () => {
it("ett block med etiketter och värden om vartannat", () => {
const block = parseInlineBlock(
"Arbetsplats för karaktärer:\nJa: X Nej:\n\nAlkoholservering:\n(om restaurang/hotell)\nJa: Nej:\n\nAntal rum:\n(Om hotell)\n12\n\nHyra:\n5000 kr\nmånadsvis",
() => false,
);
expect(block.labels).toEqual(["Arbetsplats för karaktärer", "Alkoholservering", "Antal rum", "Hyra"]);
expect(block.pairs).toEqual([
{ label: "Arbetsplats för karaktärer", value: "Ja: X Nej:" },
{ label: "Alkoholservering", value: "Ja: Nej:" },
{ label: "Antal rum", value: "12" },
{ label: "Hyra", value: "5000 kr\nmånadsvis" },
]);
});
it("ett alternativ på en egen rad hör till föregående lista, men en känd etikett gör det inte", () => {
const known = (label: string) => label === "Eldstad";
const block = parseInlineBlock("Inglasad:\nJa: delvis:\nNej: X\nEldstad:\nJa: X Nej:", known);
expect(block.pairs).toEqual([
{ label: "Inglasad", value: "Ja: delvis:\nNej: X" },
{ label: "Eldstad", value: "Ja: X Nej:" },
]);
});
it("en lista i en cell: rubriker på egna rader och en deltagare per rad", () => {
expect(parseCellList("Namn:\nRoll:\nKaraktärsnummer:\n\nAnna Lind\tBarista\tKI-0001\nBo Ek KI-0002\n\n")).toEqual([
{ name: "Anna Lind", code: "KI-0001", role: "Barista", subject: "" },
{ name: "Bo Ek", code: "KI-0002", role: "", subject: "" },
]);
expect(parseCellList("Namn:\nKaraktärs ID:\nNamn:\nKaraktärs ID:")).toEqual([]);
expect(parseCellList("Förnamn:\nEfternamn:")).toBeNull();
});
it("tabellrader med en enda cell tolkas som lista eller block", () => {
const { pairs, lists } = extract(
[table(["Anställda:"], ["Namn:\nRoll:\nKaraktärsnummer:\nAnna Lind\tBarista\tKI-0001"], ["Annan information:"], ["Bransch:\nKaffe\nSkyltat utomhus:\nJa: X Nej:"])],
() => false,
);
expect(lists).toEqual([{ heading: "Anställda", entries: [{ name: "Anna Lind", code: "KI-0001", role: "Barista", subject: "" }] }]);
expect(pairs).toEqual([
{ label: "Bransch", value: "Kaffe" },
{ label: "Skyltat utomhus", value: "Ja: X Nej:" },
]);
});
it("val utan markering är tomma värden", () => {
expect(extract([table(["Bostads typ:", "Hyresrätt: Bostadsrätt: Villa:"], ["Balkong:", "Ja: Nej:"])], () => false).pairs).toEqual([]);
});
it("en fråga utan kolon som är en känd etikett är inte ett värde", () => {
const known = (label: string) => label.startsWith("Hur påverkas");
const { pairs } = extract([table(["Beskriv scenariot:"], [""], ["Hur påverkas karaktärerna under scenariot?"], ["Mycket."])], known);
expect(pairs).toEqual([{ label: "Hur påverkas karaktärerna under scenariot?", value: "Mycket." }]);
});
});
describe("extract", () => {
it("läser etikett/värde-par åt båda hållen, med värdet i samma eller nästa cell", () => {
const { pairs } = extract([table(["Förnamn:", "Anna"], ["Efternamn: Lind"], ["Smeknamn:", ""], ["Yrke:", "Lärare", "Kön:", "Kvinna"])], () => false);
expect(pairs).toEqual([
{ label: "Förnamn", value: "Anna" },
{ label: "Efternamn", value: "Lind" },
{ label: "Yrke", value: "Lärare" },
{ label: "Kön", value: "Kvinna" },
]);
});
it("samlar alla etiketter, även utan värde", () => {
expect(extract([table(["Förnamn:", ""], ["Efternamn:", ""]), para("Utseende:")], () => false).labels).toEqual(["Förnamn", "Efternamn", "Utseende"]);
});
it("hjälptexter i parentes är inte värden", () => {
const { pairs } = extract([table(["Anställd hos:(inkludera ID)", ""]), para("Hur fungerar relationen: (Finns det något känsligt?)"), para("Bråkar sällan.")], () => false);
expect(pairs).toEqual([{ label: "Hur fungerar relationen", value: "Bråkar sällan." }]);
});
it("stycken under en rubrik blir värdet, tills nästa rubrik", () => {
const { pairs } = extract([para("Utseende:"), para("Lång."), para("Mörkt hår."), para("Personlighet:"), para("Varm."), para("Intressen:")], () => false);
expect(pairs).toEqual([
{ label: "Utseende", value: "Lång.\nMörkt hår." },
{ label: "Personlighet", value: "Varm." },
]);
});
it("en rad med kolon mitt i löpande text är inte en ny rubrik", () => {
const { pairs } = extract([para("Bakgrund:"), para("Hon växte upp i Lund. Tid: sommaren 1990."), para("Fler detaljer.")], () => false);
expect(pairs).toEqual([{ label: "Bakgrund", value: "Hon växte upp i Lund. Tid: sommaren 1990.\nFler detaljer." }]);
});
it("en känd etikett med värde i samma stycke läses som en etikett", () => {
const { pairs } = extract([para("Smeknamn: Annie"), para("Okänd: något")], (label) => label === "Smeknamn");
expect(pairs).toEqual([{ label: "Smeknamn", value: "Annie" }]);
});
it("val i rutor behålls som de skrevs", () => {
const { pairs } = extract([table(["Finns skisser", "Ja: X Nej:"], ["Balkong:", "Ja: Nej: X"])], () => false);
expect(pairs).toEqual([
{ label: "Finns skisser", value: "Ja: X Nej:" },
{ label: "Balkong", value: "Ja: Nej: X" },
]);
});
it("en etikett på en rad och alternativen på nästa rad hör ihop", () => {
const { pairs } = extract([table(["Scenario typ:"], ["Bråk: X Olycka: Dödsfall:"])], () => false);
expect(pairs).toEqual([{ label: "Scenario typ", value: "Bråk: X Olycka: Dödsfall:" }]);
});
it("deltagarlistor läses med rubrik, namn, ID och roll, och tomma rader hoppas över", () => {
const { lists, pairs } = extract(
[table(["Anställda:"], ["Namn:", "Roll:", "Karaktärsnummer:"], ["Anna Lind", "Barista", "KI-0001"], ["", "", ""], ["Bo Ek", "", "KI-0002"], ["", "", ""], ["Annan information:"], ["Alkoholservering:", "Ja: X Nej:"])],
() => false,
);
expect(lists).toEqual([
{
heading: "Anställda",
entries: [
{ name: "Anna Lind", code: "KI-0001", role: "Barista", subject: "" },
{ name: "Bo Ek", code: "KI-0002", role: "", subject: "" },
],
},
]);
expect(pairs).toEqual([{ label: "Alkoholservering", value: "Ja: X Nej:" }]);
});
it("en lista utan ifyllda rader ger ingen lista", () => {
expect(extract([table(["Boende:"], ["Namn:", "Karaktärs ID:"], ["", ""], ["", ""])], () => false).lists).toEqual([]);
});
it("register med rubrikrad och flera rader", () => {
const { registers } = extract([table(["Referens ID:", "Beskrivning:"], ["RD-0001", "En bok"], ["", ""], ["RD-0002", "En film"])], () => false);
expect(registers).toEqual([{ header: ["Referens ID", "Beskrivning"], rows: [["RD-0001", "En bok"], ["RD-0002", "En film"]] }]);
});
it("en tabell med tomma celler i första raden är inget register", () => {
const { registers, pairs } = extract([table(["Djur ID:", "", "Namn:", ""], ["Smeknamn:", "", "Ägare:", ""], ["Ras:", ""])], () => false);
expect(registers).toEqual([]);
expect(pairs).toEqual([]);
});
it("flera etiketter i en cell med värden på motsvarande rader i cellen bredvid", () => {
const { pairs } = extract([table(["Förnamn:\nEfternamn:\nÅlder\nfödelsedatum:\nKön:", "Anna\nLind\n1990\n\nKvinna"])], () => false);
expect(pairs).toEqual([
{ label: "Förnamn", value: "Anna" },
{ label: "Efternamn", value: "Lind" },
{ label: "Ålder födelsedatum", value: "1990" },
{ label: "Kön", value: "Kvinna" },
]);
});
it("kraschar inte på konstiga block", () => {
expect(() => extract([table(), table([]), table([""]), para(""), para(":"), table(["::", ":"])], () => true)).not.toThrow();
});
});
describe("findEntity", () => {
it("hittar på ID, på namn och på båda", () => {
expect(findEntity("KI-0001", known)?.id).toBe("k1");
expect(findEntity("Anna Lind", known)?.id).toBe("k1");
expect(findEntity("anna lind (KI-0001)", known)?.id).toBe("k1");
expect(findEntity("Lunds skola FI-0002", known)?.id).toBe("c1");
});
it("ID går före ett namn som pekar på en annan post", () => {
expect(findEntity("Bo Ek KI-0001", known)?.id).toBe("k1");
});
it("begränsar till en typ och hittar inte det som är tvetydigt eller okänt", () => {
expect(findEntity("KI-0001", known, "COMPANY")).toBeNull();
expect(findEntity("Okänd", known)).toBeNull();
expect(findEntity("", known)).toBeNull();
const twins: KnownEntity[] = [
{ id: "a", name: "Sven", code: "KI-0010", kind: "CHARACTER" },
{ id: "b", name: "Sven", code: "KI-0011", kind: "CHARACTER" },
];
expect(findEntity("Sven", twins)).toBeNull();
expect(findEntity("Sven KI-0011", twins)?.id).toBe("b");
});
});
describe("usableCode", () => {
it("godtar bara ID med rätt prefix", () => {
expect(usableCode("CHARACTER", "KI-0007")).toBe("KI-0007");
expect(usableCode("CHARACTER", "FI-0007")).toBeNull();
expect(usableCode("CHARACTER", "KI-abc")).toBeNull();
expect(usableCode("CHARACTER", null)).toBeNull();
expect(usableCode("APP", "KI-0001")).toBeNull();
});
});
// ─── Hela dokument, byggda som de riktiga mallarna ──────────────────────────
describe("karaktär", () => {
const blocks = [
table(
["Karaktärs ID:", "KI-0007"],
["Förnamn:", "Anna"],
["Efternamn:", "Lind"],
["Smeknamn:", "Annie"],
["Ålderfödelsedatum:", "1990-05-04"],
["Längd:", "170"],
["Kön:", "Kvinna"],
["Läggning:", ""],
["Yrke:", "Lärare"],
["Anställd hos:(inkludera ID)", "Lunds skola FI-0002"],
),
para("Utseende:"),
para("Lång och smal."),
para("Personlighet:"),
para("Varm."),
para("Relationer:"),
para("Vän med Bo."),
para("Övrigt:"),
para("Gillar katter."),
];
it("känns igen och tolkas till namn, ID, fält och koppling", () => {
const doc = analyze(blocks);
expect(doc.kind).toBe("CHARACTER");
const item = only(doc);
expect(item).toMatchObject({ entityKind: "CHARACTER", name: "Anna Lind", code: "KI-0007" });
expect(item.data).toEqual({
nickname: "Annie",
birthDate: "1990-05-04",
height: "170",
gender: "Kvinna",
occupation: "Lärare",
appearance: "Lång och smal.",
personality: "Varm.",
notes: "Gillar katter.",
});
expect(item.links).toEqual([{ type: "Jobbar på", toDocument: false, entityId: "c1", text: "Lunds skola FI-0002", note: "" }]);
expect(item.unmatched).toEqual([{ label: "Relationer", value: "Vän med Bo." }]);
});
it("ålder utan födelsedatum blir ålder", () => {
const item = only(analyze([table(["Karaktärs ID:", ""], ["Förnamn:", "Eva"], ["Ålderfödelsedatum:", "34"])]));
expect(item.data).toEqual({ age: 34 });
});
it("namnet kan bara vara ett förnamn, och utan namn används filnamnet", () => {
expect(only(analyze([table(["Karaktärs ID:", ""], ["Förnamn:", "Eva"])])).name).toBe("Eva");
expect(only(analyze([table(["Karaktärs ID:", ""], ["Yrke:", "Lärare"])], "Min figur.docx")).name).toBe("Min figur");
});
it("korta mallen med alla etiketter i en cell och värdena i cellen bredvid", () => {
const labels = "Karaktärs ID:\n\nFörnamn:\nEfternamn:\nSmeknamn:\nÅlder\nfödelsedatum:\nLängd:\nKön:\nLäggning:\nYrke:\nAnställd hos:\n(inkludera ID)";
const values = "KI-0009\n\nAnna\nLind\nAnnie\n1990-05-04\n\n170\nKvinna\n\nLärare\nLunds skola FI-0002";
const item = only(analyze([table([labels, values]), table(["Utseende:"], ["Lång."], ["Övrigt:"], ["Hej."])]));
expect(item).toMatchObject({ name: "Anna Lind", code: "KI-0009" });
expect(item.data).toMatchObject({ nickname: "Annie", birthDate: "1990-05-04", height: "170", gender: "Kvinna", occupation: "Lärare", appearance: "Lång.", notes: "Hej." });
expect(item.links[0]).toMatchObject({ type: "Jobbar på", entityId: "c1" });
});
it("flera anställningar i samma fält", () => {
const item = only(analyze([table(["Karaktärs ID:", ""], ["Förnamn:", "Eva"], ["Anställd hos:(inkludera ID)", "Lunds skola FI-0002, Okänd AB"])]));
expect(item.links.map((l) => [l.text, l.entityId])).toEqual([["Lunds skola FI-0002", "c1"], ["Okänd AB", null]]);
});
});
describe("djur", () => {
it("val i rutor och ägare", () => {
const doc = analyze([
table(["Djur ID:", "DI-0004", "Namn:", "Findus"], ["Smeknamn:", "Fisse", "Ägare:", "Anna Lind"]),
para("Djuridentitet:"),
table(["Djur kategori:", "Husdjur: X Gårdsdjur: Annat:"], ["Djur typ:(Hund/katt/häst)", "Katt"], ["Ras:", "Huskatt"], ["Ålder:", "5", "Kön:", "Hona/kvinnlig: Hane/manlig: X"], ["Päls/hud/fjäder färg:", "Grå", "Vikt:", "4,5 kg"]),
para("Djurets personlighet:"),
para("Nyfiken."),
]);
expect(doc.kind).toBe("PET");
const item = only(doc);
expect(item).toMatchObject({ name: "Findus", code: "DI-0004" });
expect(item.data).toMatchObject({ nickname: "Fisse", category: "Husdjur", species: "Katt", breed: "Huskatt", age: 5, sex: "Hane", coat: "Grå", weight: "4,5 kg", personality: "Nyfiken." });
expect(item.links).toEqual([{ type: "Husdjur till", toDocument: false, entityId: "k1", text: "Anna Lind", note: "" }]);
});
});
describe("bostad", () => {
const blocks = [
table(
["Bostads ID:", "BI-0001", "Bostads typ:", "Hyresrätt: Bostadsrätt: X Villa:"],
["Adress:", "Storgatan 1"],
["Antal Rum:", "3", "Boarea:", "75,5", "Skiss ID:(Boarea)", ""],
["Boende:"],
["Namn:", "Karaktärs ID:"],
["Anna Lind", "KI-0001"],
["Bo Ek", ""],
["", ""],
),
para("Byggnadsutseende: (Beskriv byggnadens utseende kring byggnaden)"),
para("Rött trähus."),
table(["Hyra lägenhet:", "5000 kr", "Våning:", "2"], ["Hyra parkeringsplats:", "", "Balkong:", "Ja: X Nej:"]),
];
it("tolkar fält av olika sorter och deltagarlistan", () => {
const doc = analyze(blocks);
expect(doc.kind).toBe("HOME");
const item = only(doc);
expect(item.name).toBe("Storgatan 1");
expect(item.data).toEqual({ homeType: "Bostadsrätt", address: "Storgatan 1", rooms: 3, livingArea: 75.5, buildingLook: "Rött trähus.", rentFee: "5000 kr", floor: "2", balcony: true });
expect(item.links.map((l) => [l.type, l.toDocument, l.entityId])).toEqual([["Bor på", true, "k1"], ["Bor på", true, "k2"]]);
});
it("ett val som saknas i mallen hamnar bland det som inte tolkats", () => {
const item = only(analyze([table(["Bostads ID:", ""], ["Bostads typ:", "Slott: X Koja:"], ["Adress:", "Vägen 2"])]));
expect(item.data).toEqual({ address: "Vägen 2" });
expect(item.unmatched).toEqual([{ label: "Bostads typ", value: "Slott: X Koja:" }]);
});
});
describe("företag", () => {
const blocks = [
table(
["Företagets namn:", "Lunds Kaffe", "Företags ID:", "FI-0003"],
["Bransch:", "Kaffe", "Finns skisser", "Ja: X Nej:"],
["Lokal ID:", "LI-0001", "Skiss ID:", ""],
["Anställda:"],
["Namn:", "Roll:", "Karaktärsnummer:"],
["Anna Lind", "Barista", "KI-0001"],
["", "", ""],
),
para("Annan information:"),
table(
["Arbetsplats för karaktärer:", "Ja: X Nej:", "Plats för karaktärerna att umgås:", "Ja: Nej: X"],
["Bryr sig chefen om de anställda?", "Ja: X Nej:", "Generell nöjdhet bland de anställda:", "Bra: X Dåligt:"],
),
para("Arbetsmiljö:"),
para("Trevlig."),
];
it("tolkar namn, ID, koppling till lokal, val i rutor och anställda med roll", () => {
const doc = analyze(blocks);
expect(doc.kind).toBe("COMPANY");
const item = only(doc);
expect(item).toMatchObject({ name: "Lunds Kaffe", code: "FI-0003" });
expect(item.data).toEqual({
industry: "Kaffe",
hasSketches: true,
premises: "l1",
workplaceForCharacters: true,
socialPlace: false,
bossCares: true,
satisfaction: "Bra",
workEnvironment: "Trevlig.",
});
expect(item.display.premises).toBe("LI-0001 · Café Lund");
expect(item.links).toEqual([{ type: "Jobbar på", toDocument: true, entityId: "k1", text: "Anna Lind KI-0001", note: "Barista" }]);
});
});
describe("lokal och utbildning", () => {
it("lokalens eget ID är dess ID, inte en koppling", () => {
const doc = analyze([table(["Lokal ID:", "LI-0005", "Adress:", "Torget 3"], ["Placerings ID:", "PI-0001", "Branschanpassning:", "Café"], ["Antal rum:", "2", "Yta:", "40", "Ägande:", "Hyr: X Äga:"], ["Kyl och Frys:", "Ja: X Nej:", "Hiss:", "Ja: Nej: X"])]);
expect(doc.kind).toBe("PREMISES");
const item = only(doc);
expect(item).toMatchObject({ code: "LI-0005", name: "Torget 3" });
expect(item.data).toEqual({ address: "Torget 3", placementId: "PI-0001", industryFit: "Café", rooms: 2, area: 40, tenure: "Hyr", coldStorage: true, elevator: false });
});
it("utbildning med lärare och elever", () => {
const doc = analyze([
table(
["Utbildnings ID:", "UI-0001", "Skolans namn:", "Lunds gymnasium"],
["Utbildningstyp:", "Förskola: lågstadium: Mellanstadium: Högstadium: Gymnasium: X Högskola:"],
["Linje:(Om Gymnasium eller högre)", "Natur"],
["Lärare till klassen:"],
["Namn:", "Ämne:", "Karaktärs ID:"],
["Anna Lind", "Biologi", "KI-0001"],
["", "", ""],
["Elever i klassen:"],
["Namn:", "Karaktärs ID:"],
["Bo Ek", "KI-0002"],
),
]);
expect(doc.kind).toBe("EDUCATION");
const item = only(doc);
expect(item).toMatchObject({ name: "Lunds gymnasium", code: "UI-0001" });
expect(item.data).toEqual({ educationType: "Gymnasium", program: "Natur" });
expect(item.links.map((l) => [l.type, l.entityId, l.note])).toEqual([
["Lärare på", "k1", "Biologi"],
["Elev på", "k2", ""],
]);
});
});
describe("scenario", () => {
it("typ på nästa rad, kopplat ID och två deltagarlistor", () => {
const doc = analyze([
table(
["Scenario ID:", "SNI-0001", "Kopplat ID:", "KI-0001"],
["Scenario typ:"],
["Bråk: X Olycka: Dödsfall: Otrohet: Brott: Övrigt:"],
["Involverade karaktärer:"],
["Namn:", "Karaktärs ID:"],
["Anna Lind", "KI-0001"],
["", ""],
),
para("Berörda karaktärer:"),
table(["Namn:", "Karaktärs ID:"], ["Bo Ek", "KI-0002"]),
para("Beskriv scenariot:"),
para("De bråkade om pengar."),
para("Övrig information:"),
]);
expect(doc.kind).toBe("SCENARIO");
const item = only(doc);
expect(item.code).toBe("SNI-0001");
expect(item.data).toEqual({ linkedEntity: "k1", scenarioType: "Bråk", description: "De bråkade om pengar." });
expect(item.name).toBe("Bråk SNI-0001");
expect(item.links.map((l) => [l.type, l.toDocument, l.entityId])).toEqual([["Involverad i", true, "k1"], ["Berörd av", true, "k2"]]);
});
});
describe("relation", () => {
const blocks = [
table(
["Relations ID:", "REI-0004", "Relations typ:", "Vännergrupper: Partner: X Familj: Kollegor:"],
["Är relationen Hälsosam?", "Ja: X Nej:", "Är relationen aktiv:", "Ja: X Nej: Blivande:"],
["Vilka ingår i relationen:"],
["Namn:", "Karaktärs ID:"],
["Anna Lind", "KI-0001"],
["Bo Ek", ""],
["Okänd Person", "KI-9999"],
["", ""],
),
para("Hur fungerar relationen: (Finns det som är känsligt eller gammalt bråk)"),
para("De bråkar sällan."),
para("Övrigt:"),
];
it("ger deltagare, typ och fält", () => {
const doc = analyze(blocks);
expect(doc.kind).toBe("RELATION");
expect(doc.relation).toEqual({
type: "Partner",
participants: [
{ text: "Anna Lind KI-0001", entityId: "k1" },
{ text: "Bo Ek", entityId: "k2" },
{ text: "Okänd Person KI-9999", entityId: null },
],
});
expect(only(doc).data).toEqual({ category: "Partner", healthy: true, active: "Ja", howItWorks: "De bråkar sällan." });
expect(doc.warnings).toEqual([]);
});
it("varnar när deltagare saknas", () => {
const doc = analyze([table(["Relations ID:", ""], ["Vilka ingår i relationen:"], ["Namn:", "Karaktärs ID:"], ["Anna Lind", "KI-0001"])]);
expect(doc.warnings).toContain("few-participants");
});
});
describe("register", () => {
it("fordon med koppling till ägare och referens, en post per rad", () => {
const doc = analyze([
table(
["Fordons ID:", "Märke och modell:", "Drivmedel: (Bensin/diesel/el)", "Ägare: (Karaktärens namn och ID)", "Referens ID:"],
["FD-0001", "Volvo V70", "Diesel", "Anna Lind KI-0001", "RD-0002"],
["", "", "", "", ""],
["FD-0002", "Tesla Model 3", "El", "Okänd", ""],
),
]);
expect(doc.kind).toBe("VEHICLE");
expect(doc.items).toHaveLength(2);
expect(doc.items[0]).toMatchObject({ name: "Volvo V70", code: "FD-0001" });
expect(doc.items[0].data).toEqual({ model: "Volvo V70", fuel: "Diesel", owner: "k1", reference: "r1" });
expect(doc.items[1].data).toEqual({ model: "Tesla Model 3", fuel: "El" });
expect(doc.items[1].unmatched).toEqual([{ label: "Ägare", value: "Okänd" }]);
});
it("referenser får namn av beskrivningen", () => {
const doc = analyze([table(["Referens ID:", "Beskrivning:"], ["RD-0005", "En bok om fåglar"], ["", ""], ["RD-0006", "En film"])]);
expect(doc.kind).toBe("REFERENCE");
expect(doc.items.map((i) => [i.code, i.name, i.data.description])).toEqual([
["RD-0005", "En bok om fåglar", "En bok om fåglar"],
["RD-0006", "En film", "En film"],
]);
});
it("research", () => {
expect(analyze([table(["Research ID:", "Beskrivning:"], ["RI-0001", "Polisens rutiner"], ["", ""], ["", ""])]).kind).toBe("RESEARCH");
});
it("appar och hemsidor: en post per namn", () => {
const apps = analyze([para("Appar:"), para("Applikationer på telefoner som karaktärerna kommer att använda."), table(["Namn: Instagram"], ["Beskrivning: Bilder"], ["Namn: Bankapp"], ["Beskrivning:"], ["Namn:"], ["Beskrivning:"])]);
expect(apps.kind).toBe("APP");
expect(apps.items.map((i) => [i.name, i.data.description])).toEqual([
["Instagram", "Bilder"],
["Bankapp", undefined],
]);
const sites = analyze([para("Hemsidor:"), para("Hemsidor på telefoner och datorer."), table(["Namn:", "Lunds kommun"], ["Beskrivning:", "Kommunens sida"])]);
expect(sites.kind).toBe("WEBSITE");
expect(only(sites)).toMatchObject({ name: "Lunds kommun", data: { description: "Kommunens sida" } });
});
it("scheman och kartregister importeras inte", () => {
const schedule = analyze([para("Schema: Schema ID:___"), table(["Tid:", "Måndag:", "Tisdag:"], ["06:00", "", ""], ["07:00", "", ""])]);
expect(schedule).toMatchObject({ kind: null, warnings: ["unsupported"] });
const scheduleRegister = analyze([table(["Schema ID:", "Karaktärs ID:", "Dag/natt:"], ["", "", "Dag: Natt:"], ["", "", "Dag: Natt:"])]);
expect(scheduleRegister).toMatchObject({ kind: null, warnings: ["unsupported"] });
const maps = analyze([table(["Kart ID:", "Placerings ID:", "Stad/Område:"], ["", "", ""], ["", "", ""])]);
expect(maps).toMatchObject({ kind: null, warnings: ["unsupported"] });
});
});
describe("typ och varningar", () => {
it("ett dokument som inte liknar någon mall får okänd typ", () => {
expect(analyze([para("Bara lite text."), para("Mer text.")])).toMatchObject({ kind: null, warnings: ["unknown-kind"] });
});
it("användaren kan välja typ själv", () => {
const doc = analyze([table(["Namn:", "Rex"], ["Ras:", "Boxer"])], "hund.docx", "PET");
expect(doc.kind).toBe("PET");
expect(only(doc)).toMatchObject({ name: "Rex", data: { breed: "Boxer" } });
});
it("ett tomt dokument ger en varning", () => {
expect(analyze([table(["Referens ID:", "Beskrivning:"], ["", ""], ["", ""])]).warnings).toContain("empty");
});
it("detectKind går på dokumentets eget ID före andra etiketter", () => {
// Ett företag har både Företags ID och Lokal ID, men är ett företag
const ex = extract([table(["Företags ID:", ""], ["Lokal ID:", ""])], () => false);
expect(detectKind(ex, "x.docx")).toBe("COMPANY");
});
});
describe("tolkning av värden", () => {
const item = (rows: string[][], kind: ImportKind = "CHARACTER") => analyzeDocument([table(...rows)], "x.docx", known, { kind }).items[0];
it("tal med komma, text runt talet och ogiltiga tal", () => {
expect(item([["Förnamn:", "A"], ["Antal Rum:", "3,5"]], "HOME").data).toMatchObject({ rooms: 3.5 });
expect(item([["Adress:", "X"], ["Antal rum:", "ca 4 st"]], "HOME").data).toMatchObject({ rooms: 4 });
expect(item([["Adress:", "X"], ["Antal rum:", "många"]], "HOME").unmatched).toEqual([{ label: "Antal rum", value: "många" }]);
});
it("datum med bara år, och text som inte är ett datum", () => {
expect(item([["Förnamn:", "A"], ["Ålderfödelsedatum:", "1985"]]).data).toEqual({ birthDate: "1985" });
expect(item([["Förnamn:", "A"], ["Ålderfödelsedatum:", "i våras"]]).unmatched).toHaveLength(1);
});
it("länkar måste vara riktiga webbadresser", () => {
expect(item([["Namn:", "Wiki"], ["Länk eller källa:", "https://sv.wikipedia.org"]], "REFERENCE").data).toEqual({ link: "https://sv.wikipedia.org" });
expect(item([["Namn:", "Wiki"], ["Länk eller källa:", "javascript:alert(1)"]], "REFERENCE").data).toEqual({});
});
it("samma fält två gånger: första räknas, resten rapporteras", () => {
const parsed = item([["Förnamn:", "A"], ["Yrke:", "Lärare"], ["Yrke:", "Chef"]]);
expect(parsed.data).toEqual({ occupation: "Lärare" });
expect(parsed.unmatched).toEqual([{ label: "Yrke", value: "Chef" }]);
});
});
describe("riktiga Word-filer", () => {
const dir = new URL("../../", import.meta.url);
const file = (path: string) => new Uint8Array(readFileSync(new URL(path, dir)));
const available = existsSync(new URL("Mall/Karaktärermall.docx", dir));
// Mallarna är blanka, så typen kommer av etiketterna: alla dokument ska ändå kännas igen och inget ska krascha
const expected: [string, string | null][] = [
["Mall/Karaktärermall.docx", "CHARACTER"],
["Mall/Karaktärermall-kort.docx", "CHARACTER"],
["Mall/Djurmall.docx", "PET"],
["Mall/Bostadsmall.docx", "HOME"],
["Mall/Företagsmall.docx", "COMPANY"],
["Mall/Lokalmall.docx", "PREMISES"],
["Mall/Utbildningsmall.docx", "EDUCATION"],
["Mall/Scenariomall.docx", "SCENARIO"],
["Mall/Relationsmall.docx", "RELATION"],
["Mall/Schema dag.docx", null],
["Mall/Schema natt.docx", null],
["Register/Fordonsregister.docx", "VEHICLE"],
["Register/Referensregister.docx", "REFERENCE"],
["Register/Researchregister.docx", "RESEARCH"],
["Register/Appregister.docx", "APP"],
["Register/hemsideregister.docx", "WEBSITE"],
["Register/Kartregister.docx", null],
["Register/Schemaregister.docx", null],
];
it.skipIf(!available).each(expected)("%s känns igen som %s", (path, kind) => {
const doc = analyzeDocument(readDocx(file(path)), path.split("/").pop()!, known);
expect(doc.kind).toBe(kind);
// En blank mall ger inga poster med innehåll: mallens egna etiketter och frågor får inte tolkas som värden
expect(doc.items.filter((i) => Object.keys(i.data).length > 0 || i.unmatched.length > 0 || i.links.length > 0)).toEqual([]);
});
it.skipIf(!available)("alla mallar går att läsa och tolka utan fel", () => {
for (const [path] of expected) expect(() => analyzeDocument(readDocx(file(path)), path, known)).not.toThrow();
});
it("ett ifyllt dokument i riktigt Word-format går hela vägen från fil till post", () => {
const bytes = makeDocx([table(["Karaktärs ID:", "KI-0042"], ["Förnamn:", "Åsa"], ["Efternamn:", "Öberg"], ["Yrke:", "Läkare"]), para("Övrigt:"), para("Rad ett"), para("Rad två")]);
const doc = analyzeDocument(readDocx(bytes), "asa.docx", known);
expect(doc.kind).toBe("CHARACTER");
expect(only(doc)).toMatchObject({ name: "Åsa Öberg", code: "KI-0042", data: { occupation: "Läkare", notes: "Rad ett\nRad två" } });
});
});
describe("cleanData", () => {
const fields = getDefaultTemplate("COMPANY", "sv");
const entities = new Map<string, "COMPANY" | "PREMISES" | "SKETCH">([["l1", "PREMISES"], ["c1", "COMPANY"]]);
it("behåller bara giltiga värden av rätt sort i fält som finns i mallen", () => {
const clean = cleanData(
fields,
{
industry: " Kaffe ",
premises: "l1",
hasSketches: true,
satisfaction: "Bra",
hotelRooms: 10,
okänt: "x",
},
entities as never,
);
expect(clean).toEqual({ industry: "Kaffe", premises: "l1", hasSketches: true, satisfaction: "Bra", hotelRooms: 10 });
});
it("avvisar fel sorts värden och kopplingar till fel typ eller okända poster", () => {
const clean = cleanData(
fields,
{ industry: 5, premises: "c1", sketch: "finns-inte", hasSketches: "ja", satisfaction: "Fantastisk", hotelRooms: "10", signOutside: null },
entities as never,
);
expect(clean).toEqual({});
});
it("datum normaliseras och ogiltiga avvisas", () => {
const characterFields = getDefaultTemplate("CHARACTER", "sv");
expect(cleanData(characterFields, { birthDate: "1990-5-4", deathDate: "nej" }, new Map())).toEqual({ birthDate: "1990-05-04" });
});
it("webbadresser måste börja med http", () => {
const refFields = getDefaultTemplate("REFERENCE", "sv");
expect(cleanData(refFields, { link: "https://example.com" }, new Map())).toEqual({ link: "https://example.com" });
expect(cleanData(refFields, { link: "javascript:alert(1)" }, new Map())).toEqual({});
});
});
+139
View File
@@ -0,0 +1,139 @@
import { describe, expect, it } from "vitest";
import { isOptionList, labelsMatch, looseMatch, markedOption, normLabel, parseOptions, parseYesNo, pickOption } from "@/lib/word-labels";
describe("normLabel", () => {
it("tar bort hjälptexter, skiljetecken och ID-ord", () => {
expect(normLabel("Anställd hos:(inkludera ID)")).toBe("anställd hos");
expect(normLabel("Skiss ID:(Boarea)")).toBe("skiss");
expect(normLabel("Är relationen Hälsosam?")).toBe("är relationen hälsosam");
expect(normLabel("Schema-ID")).toBe("schema");
expect(normLabel(" Alkoholservering:(om restaurang/hotell) ")).toBe("alkoholservering");
});
});
describe("labelsMatch", () => {
it("känner igen samma etikett skriven på olika sätt", () => {
expect(labelsMatch("Djur kategori", "Djurkategori")).toBe(true);
expect(labelsMatch("Antal Rum:", "Antal rum")).toBe(true);
expect(labelsMatch("Boarea:", "Boarea (m²)")).toBe(true);
expect(labelsMatch("Är relationen Hälsosam?", "Relationen är hälsosam")).toBe(true);
expect(labelsMatch("Ordförråd: (världsspråk och fackspråk):", "Ordförråd (världsspråk och fackspråk)")).toBe(true);
expect(labelsMatch("Lokal ID", "Lokal")).toBe(true);
});
it("godtar ett skrivfel i slutet men inte olika ord", () => {
expect(labelsMatch("Längde", "Längd")).toBe(true);
expect(labelsMatch("Alkohol", "Alkoholservering")).toBe(false);
expect(labelsMatch("Ålder", "Födelsedatum")).toBe(false);
expect(labelsMatch("Kön", "Läggning")).toBe(false);
expect(labelsMatch("Våning", "Antal våningar")).toBe(false);
});
it("tomma etiketter matchar ingenting", () => {
expect(labelsMatch("", "")).toBe(false);
expect(labelsMatch("ID", "ID")).toBe(false);
});
});
describe("looseMatch", () => {
it("känner igen etiketter som skrivits längre än i mallen", () => {
expect(looseMatch("Djurets personlighet", "Personlighet")).toBe(true);
expect(looseMatch("Päls/hud/fjäder färg", "Päls-, hud- eller fjäderfärg")).toBe(true);
expect(looseMatch("Beskriv djurets utseende mer detaljerat", "Utseende i detalj")).toBe(true);
});
it("kräver att alla betydelsebärande ord finns", () => {
expect(looseMatch("Personlighet", "Djurets personlighet och bakgrund")).toBe(false);
expect(looseMatch("Adress", "Antal rum")).toBe(false);
expect(looseMatch("Ja", "Hiss")).toBe(false);
});
it("korta etiketter räcker inte för en lös träff", () => {
expect(looseMatch("Hiss i huset", "Hiss")).toBe(false);
});
});
describe("alternativ i rutor", () => {
it("känner igen en lista med alternativ men inte en vanlig etikett", () => {
expect(isOptionList("Ja: Nej:")).toBe(true);
expect(isOptionList("Förskola: lågstadium: Mellanstadium: Högstadium:")).toBe(true);
expect(isOptionList("Anställd hos:(inkludera ID)")).toBe(false);
expect(isOptionList("Ordförråd: (världsspråk och fackspråk):")).toBe(false);
expect(isOptionList("Namn:")).toBe(false);
expect(isOptionList("Bara en vanlig text utan kolon")).toBe(false);
});
it("läser kryss efter alternativet", () => {
expect(parseOptions("Ja: X Nej:")).toEqual([
{ label: "Ja", marked: true },
{ label: "Nej", marked: false },
]);
expect(parseOptions("Ja: Nej: x")).toEqual([
{ label: "Ja", marked: false },
{ label: "Nej", marked: true },
]);
expect(parseOptions("Bra: Dåligt:")?.every((o) => !o.marked)).toBe(true);
});
it("läser kryssrutor före alternativet", () => {
expect(parseOptions("☒ Ja: ☐ Nej:")).toEqual([
{ label: "Ja", marked: true },
{ label: "Nej", marked: false },
]);
expect(parseOptions("✓ Hona/kvinnlig: Hane/manlig:")).toEqual([
{ label: "Hona/kvinnlig", marked: true },
{ label: "Hane/manlig", marked: false },
]);
});
it("flera alternativ och hjälptexter", () => {
const options = parseOptions("Hyresrätt: Bostadsrätt: X Villa:")!;
expect(options.map((o) => o.label)).toEqual(["Hyresrätt", "Bostadsrätt", "Villa"]);
expect(markedOption(options)).toBe("Bostadsrätt");
});
it("inget eller flera markerade ger inget val", () => {
expect(markedOption(parseOptions("Ja: Nej:")!)).toBeNull();
expect(markedOption(parseOptions("Ja: X Nej: X")!)).toBeNull();
});
it("ett alternativ som börjar på x tolkas inte som kryss", () => {
expect(parseOptions("Ja: Xavier:")?.map((o) => o.marked)).toEqual([false, false]);
});
});
describe("parseYesNo", () => {
it("tolkar ja och nej på flera sätt", () => {
expect(parseYesNo("Ja: X Nej:")).toBe(true);
expect(parseYesNo("Ja: Nej: X")).toBe(false);
expect(parseYesNo("ja")).toBe(true);
expect(parseYesNo("Nej.")).toBe(false);
expect(parseYesNo("X")).toBe(true);
expect(parseYesNo("✓")).toBe(true);
});
it("ger null när det inte går att avgöra", () => {
expect(parseYesNo("")).toBeNull();
expect(parseYesNo("Ja: Nej:")).toBeNull();
expect(parseYesNo("kanske")).toBeNull();
});
});
describe("pickOption", () => {
const options = ["Husdjur", "Gårdsdjur", "Annat"];
it("väljer det markerade alternativet eller texten", () => {
expect(pickOption("Husdjur: X Gårdsdjur: Annat:", options)).toBe("Husdjur");
expect(pickOption("gårdsdjur", options)).toBe("Gårdsdjur");
});
it("godtar en längre form av alternativet", () => {
expect(pickOption("Hona/kvinnlig: Hane/manlig: X", ["Hona", "Hane"])).toBe("Hane");
expect(pickOption("Vännergrupper", ["Vännergrupp", "Partner"])).toBe("Vännergrupp");
});
it("ger null för okända val", () => {
expect(pickOption("Hund", options)).toBeNull();
expect(pickOption("", options)).toBeNull();
expect(pickOption("Husdjur: Gårdsdjur: Annat:", options)).toBeNull();
});
});