Files
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

722 lines
33 KiB
TypeScript

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("flera lokaler i ett kopplingsfält", () => {
const more: KnownEntity[] = [...known, { id: "l2", name: "Torget 3", code: "LI-0002", kind: "PREMISES" }];
const company = (value: string) => analyzeDocument([table(["Företags ID:", ""], ["Företagets namn:", "Kaffe AB"], ["Lokal ID:", value])], "f.docx", more).items[0];
it("ger en lista med alla som hittas", () => {
const item = company("Café Lund LI-0001, Torget 3 LI-0002");
expect(item.data.premises).toEqual(["l1", "l2"]);
expect(item.display.premises).toBe("LI-0001 · Café Lund, LI-0002 · Torget 3");
expect(item.unmatched).toEqual([]);
});
it("rapporterar de som inte hittas och behåller resten", () => {
const item = company("LI-0001, Okänd lokal");
expect(item.data.premises).toEqual(["l1"]);
expect(item.unmatched).toEqual([{ label: "Lokal ID", value: "Okänd lokal" }]);
});
it("inget hittat ger ingen koppling och hamnar bland det som inte tolkats", () => {
const item = company("Okänd lokal");
expect(item.data.premises).toBeUndefined();
expect(item.unmatched).toEqual([{ label: "Lokal ID", value: "Okänd lokal" }]);
});
it("ett fält med ett val tar bara en post", () => {
const item = analyzeDocument([table(["Fordons ID:", ""], ["Märke och modell:", "Volvo"], ["Ägare:", "Anna Lind KI-0001"])], "v.docx", more).items[0];
expect(item.data.owner).toBe("k1");
});
});
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, schemaregister och kartregister känns igen, och är tomma när inget är ifyllt", () => {
const days = ["Tid:", "Måndag:", "Tisdag:", "Onsdag:", "Torsdag:", "Fredag:", "Lördag:", "Söndag:"];
const blank = (time: string) => [time, "", "", "", "", "", "", ""];
const schedule = analyze([para("Schema: Schema ID:___"), table(days, blank("06:00"), blank("07:00"))]);
expect(schedule).toMatchObject({ kind: "SCHEDULE", warnings: ["empty"] });
const scheduleRegister = analyze([table(["Schema ID:", "Karaktärs ID:", "Dag/natt:"], ["", "", "Dag: Natt:"], ["", "", "Dag: Natt:"])]);
expect(scheduleRegister).toMatchObject({ kind: "SCHEDULE_REGISTER", warnings: ["empty"] });
const maps = analyze([table(["Kart ID:", "Placerings ID:", "Stad/Område:"], ["", "", ""], ["", "", ""])]);
expect(maps).toMatchObject({ kind: "MAP_REGISTER", warnings: ["empty"] });
});
});
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", "SCHEDULE"],
["Mall/Schema natt.docx", "SCHEDULE"],
["Register/Fordonsregister.docx", "VEHICLE"],
["Register/Referensregister.docx", "REFERENCE"],
["Register/Researchregister.docx", "RESEARCH"],
["Register/Appregister.docx", "APP"],
["Register/hemsideregister.docx", "WEBSITE"],
["Register/Kartregister.docx", "MAP_REGISTER"],
["Register/Schemaregister.docx", "SCHEDULE_REGISTER"],
];
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([]);
expect(doc.schedule?.shifts ?? []).toEqual([]);
expect(doc.scheduleRows).toEqual([]);
expect(doc.maps).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({});
});
});