Files
bookmanager/tests/unit/word-schedule.test.ts
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

287 lines
14 KiB
TypeScript

import { existsSync, readFileSync } from "node:fs";
import { describe, expect, it } from "vitest";
import { readDocx, type DocBlock } from "@/lib/word-docx";
import { analyzeDocument, type KnownEntity, type RegisterTable } from "@/lib/word-import";
import { findScheduleCode, isScheduleGrid, normalizeTime, parseMapRegister, parseScheduleGrid, parseScheduleRegister, weekdayOf } from "@/lib/word-schedule";
import { table } from "../helpers/docx";
const DAYS = ["Tid", "Måndag", "Tisdag", "Onsdag", "Torsdag", "Fredag", "Lördag", "Söndag"];
const grid = (rows: string[][]): RegisterTable => ({ header: DAYS, rows });
/** En rad i schemat: tiden och sju rutor, där `cells` fyller i de första. */
const row = (time: string, ...cells: string[]) => [time, ...Array.from({ length: 7 }, (_, i) => cells[i] ?? "")];
const known: KnownEntity[] = [
{ id: "k1", name: "Anna Lind", code: "KI-0001", kind: "CHARACTER" },
{ id: "c1", name: "Lunds Kaffe", code: "FI-0001", kind: "COMPANY" },
{ id: "u1", name: "Lunds skola", code: "UI-0001", kind: "EDUCATION" },
];
describe("weekdayOf och normalizeTime", () => {
it("känner igen veckodagar, hela och förkortade", () => {
expect(["Måndag:", "tis", "ONSDAG", "Tors", "Fre", "Lördag", "Sön"].map(weekdayOf)).toEqual([0, 1, 2, 3, 4, 5, 6]);
expect(weekdayOf("Tid")).toBeNull();
expect(weekdayOf("Ma")).toBeNull();
expect(weekdayOf("")).toBeNull();
});
it("skriver tider som HH:MM", () => {
expect(normalizeTime("6")).toBe("06:00");
expect(normalizeTime("6:30")).toBe("06:30");
expect(normalizeTime("06.00")).toBe("06:00");
expect(normalizeTime(" 23:59 ")).toBe("23:59");
expect(normalizeTime("24:00")).toBeNull();
expect(normalizeTime("12:60")).toBeNull();
expect(normalizeTime("lunch")).toBeNull();
expect(normalizeTime("")).toBeNull();
});
});
describe("isScheduleGrid", () => {
it("kräver Tid och minst fem veckodagar", () => {
expect(isScheduleGrid(grid([]))).toBe(true);
expect(isScheduleGrid({ header: ["Tid", "Måndag", "Tisdag"], rows: [] })).toBe(false);
expect(isScheduleGrid({ header: ["Datum", ...DAYS.slice(1)], rows: [] })).toBe(false);
});
});
describe("parseScheduleGrid", () => {
const times = ["06:00", "07:00", "08:00", "09:00", "10:00", "11:00", "12:00", "13:00", "14:00", "15:00", "16:00", "17:00", "18:00"];
it("följande timmar med innehåll blir ett pass", () => {
const rows = times.map((t) => row(t, t >= "08:00" && t < "16:00" ? "Arbete" : ""));
expect(parseScheduleGrid(grid(rows))).toEqual([{ weekday: 0, startTime: "08:00", endTime: "16:00", label: "Arbete" }]);
});
it("flera dagar och flera pass per dag", () => {
const rows = [
row("06:00", "X", "", "", "", "X"),
row("07:00", "X", "", "", "", "X"),
row("08:00", "", "", "", "", ""),
row("09:00", "Möte", "Möte", "", "", ""),
row("10:00", "Möte", "Möte", "", "", ""),
];
expect(parseScheduleGrid(grid(rows))).toEqual([
{ weekday: 0, startTime: "06:00", endTime: "08:00", label: null },
{ weekday: 0, startTime: "09:00", endTime: "11:00", label: "Möte" },
{ weekday: 1, startTime: "09:00", endTime: "11:00", label: "Möte" },
{ weekday: 4, startTime: "06:00", endTime: "08:00", label: null },
]);
});
it("olika innehåll i följd ger olika pass, oavsett stora och små bokstäver", () => {
const rows = [row("08:00", "Kassa"), row("09:00", "kassa"), row("10:00", "Lager"), row("11:00", "Lager")];
expect(parseScheduleGrid(grid(rows))).toEqual([
{ weekday: 0, startTime: "08:00", endTime: "10:00", label: "Kassa" },
{ weekday: 0, startTime: "10:00", endTime: "12:00", label: "Lager" },
]);
});
it("ett nattschema som går över midnatt blir ett pass som går över midnatt", () => {
const hours = ["18:00", "19:00", "20:00", "21:00", "22:00", "23:00", "00:00", "01:00", "02:00", "03:00", "04:00", "05:00"];
const rows = hours.map((t) => row(t, "X", "", "", "", "", "", ""));
expect(parseScheduleGrid(grid(rows))).toEqual([{ weekday: 0, startTime: "18:00", endTime: "06:00", label: null }]);
});
it("ett uppehåll i tiderna delar passet", () => {
const rows = [row("08:00", "X"), row("09:00", "X"), row("13:00", "X"), row("14:00", "X")];
expect(parseScheduleGrid(grid(rows))).toEqual([
{ weekday: 0, startTime: "08:00", endTime: "10:00", label: null },
{ weekday: 0, startTime: "13:00", endTime: "15:00", label: null },
]);
});
it("halvtimmar och ensamma rader", () => {
const rows = [row("08:00", "X"), row("08:30", "X"), row("09:00", ""), row("12:00", "", "Lunch")];
expect(parseScheduleGrid(grid(rows))).toEqual([
{ weekday: 0, startTime: "08:00", endTime: "09:00", label: null },
{ weekday: 1, startTime: "12:00", endTime: "13:00", label: "Lunch" },
]);
});
it("ignorerar rader utan tid och ett tomt eller trasigt schema", () => {
expect(parseScheduleGrid(grid([]))).toEqual([]);
expect(parseScheduleGrid(grid([row("lunch", "X"), row("", "X")]))).toEqual([]);
expect(parseScheduleGrid({ header: ["Tid", "Foo", "Bar"], rows: [["08:00", "X", "X"]] })).toEqual([]);
});
it("ett helt dygn kan inte skrivas som ett pass (start och slut vore samma tid) och hoppas över", () => {
const rows = Array.from({ length: 24 }, (_, h) => row(`${String(h).padStart(2, "0")}:00`, "X"));
expect(parseScheduleGrid(grid(rows))).toEqual([]);
});
it("långa texter kortas till 100 tecken", () => {
const [shift] = parseScheduleGrid(grid([row("08:00", "x".repeat(300))]));
expect(shift.label).toHaveLength(100);
});
});
describe("findScheduleCode", () => {
it("hittar Schema-ID i texten", () => {
expect(findScheduleCode(["Schema: Schema ID: SCI-0003"])).toBe("SCI-0003");
expect(findScheduleCode(["Schema: Schema ID:___________"])).toBeNull();
expect(findScheduleCode(["x", "SCI-12"])).toBe("SCI-12");
expect(findScheduleCode([])).toBeNull();
});
});
describe("parseScheduleRegister", () => {
const resolve = (text: string, kinds?: string[]) => known.find((e) => text.includes(e.code ?? "§") && (!kinds || kinds.includes(e.kind))) ?? null;
const register: RegisterTable = {
header: ["Schema ID", "Karaktärs ID", "Företags/utbildnings ID", "Dag/natt"],
rows: [
["SCI-0001", "Anna Lind KI-0001", "FI-0001", "Dag: X Natt:"],
["SCI-0002", "KI-9999", "UI-0001", "Dag: Natt: X"],
["", "KI-0001", "", ""],
["SCI-0003", "", "", "Dag: Natt:"],
],
};
it("kopplar Schema-ID till person och arbetsplats", () => {
expect(parseScheduleRegister(register, resolve)).toEqual([
{ code: "SCI-0001", personText: "Anna Lind KI-0001", workplaceText: "FI-0001", personId: "k1", workplaceId: "c1", dayNight: "Dag" },
{ code: "SCI-0002", personText: "KI-9999", workplaceText: "UI-0001", personId: null, workplaceId: "u1", dayNight: "Natt" },
{ code: "SCI-0003", personText: "", workplaceText: "", personId: null, workplaceId: null, dayNight: "" },
]);
});
});
describe("parseMapRegister", () => {
const header = ["Kart ID", "Placerings ID", "Stad/Område", "Beskrivning", "Övrigt"];
it("rader med samma Kart-ID blir en karta med flera markeringar", () => {
const maps = parseMapRegister({
header,
rows: [
["KD-R_0001", "PI-0001", "Lund", "Kaféet", "Vid torget"],
["KD-R_0001", "PI-0002", "", "Biblioteket", ""],
["KD-R_0002", "", "Malmö", "", ""],
],
});
expect(maps).toEqual([
{
code: "KD-R_0001",
name: "Lund",
kind: "GEO",
markers: [
{ code: "PI-0001", label: "Kaféet", note: "Vid torget" },
{ code: "PI-0002", label: "Biblioteket", note: null },
],
},
{ code: "KD-R_0002", name: "Malmö", kind: "GEO", markers: [] },
]);
});
it("utan Kart-ID hör rader med samma område ihop, och bildkartor känns igen", () => {
const maps = parseMapRegister({
header,
rows: [
["", "", "Lund", "Hus A", ""],
["", "", "lund", "Hus B", ""],
["KD-E_0001", "", "Egen karta", "Ruta", ""],
["", "", "", "", ""],
],
});
expect(maps.map((m) => [m.code, m.name, m.kind, m.markers.length])).toEqual([
[null, "Lund", "GEO", 2],
["KD-E_0001", "Egen karta", "IMAGE", 1],
]);
});
it("en markering utan beskrivning får områdets namn", () => {
const [map] = parseMapRegister({ header, rows: [["KD-R_0001", "PI-0009", "Lund", "", ""]] });
expect(map.markers).toEqual([{ code: "PI-0009", label: "Lund", note: null }]);
});
it("namnlös karta får Kart-ID som namn", () => {
expect(parseMapRegister({ header, rows: [["KD-R_0004", "", "", "", ""]] })[0].name).toBe("KD-R_0004");
});
});
describe("hela dokument", () => {
const analyze = (blocks: DocBlock[], file = "x.docx") => analyzeDocument(blocks, file, known);
it("ett ifyllt schema med Schema-ID", () => {
const rows = [row("08:00", "Arbete", "Arbete"), row("09:00", "Arbete", "Arbete"), row("10:00", "", "")];
const doc = analyze([{ type: "paragraph", text: "Schema: Schema ID: SCI-0007" }, table(DAYS.map((d) => `${d}:`), ...rows)]);
expect(doc.kind).toBe("SCHEDULE");
expect(doc.schedule).toMatchObject({ code: "SCI-0007", personId: null, source: null });
expect(doc.schedule?.shifts).toEqual([
{ weekday: 0, startTime: "08:00", endTime: "10:00", label: "Arbete" },
{ weekday: 1, startTime: "08:00", endTime: "10:00", label: "Arbete" },
]);
});
it("schemaregistret slår upp personer och arbetsplatser i boken", () => {
const doc = analyze([table(["Schema ID:", "Karaktärs ID:", "Företags/utbildnings ID:", "Dag/natt:"], ["SCI-0001", "KI-0001", "FI-0001", "Dag: X Natt:"], ["", "", "", ""], ["", "", "", ""])]);
expect(doc.kind).toBe("SCHEDULE_REGISTER");
expect(doc.scheduleRows).toEqual([{ code: "SCI-0001", personText: "KI-0001", workplaceText: "FI-0001", personId: "k1", workplaceId: "c1", dayNight: "Dag" }]);
});
it("kartregistret ger kartor", () => {
const doc = analyze([table(["Kart ID:", "Placerings ID:", "Stad/Område:", "Beskrivning:", "Övrigt:"], ["KD-R_0001", "PI-0001", "Lund", "Kaféet", ""], ["", "", "", "", ""], ["", "", "", "", ""])]);
expect(doc.kind).toBe("MAP_REGISTER");
expect(doc.maps).toHaveLength(1);
expect(doc.maps[0].markers).toHaveLength(1);
});
it("användaren kan byta ett dokument till schema, och en tom mall ger varning", () => {
const doc = analyzeDocument([table(["Namn:", "x"])], "x.docx", known, { kind: "SCHEDULE" });
expect(doc).toMatchObject({ kind: "SCHEDULE", warnings: ["empty"] });
});
});
const root = new URL("../../", import.meta.url);
const available = existsSync(new URL("Mall/Schema dag.docx", root));
const load = (path: string): DocBlock[] => readDocx(new Uint8Array(readFileSync(new URL(path, root))));
describe.skipIf(!available)("riktiga scheman och register, ifyllda", () => {
const fillGrid = (blocks: DocBlock[], cells: [number, number, string][]) => {
const copy: DocBlock[] = JSON.parse(JSON.stringify(blocks));
const tbl = copy.find((b) => b.type === "table");
if (tbl?.type !== "table") throw new Error("Väntade en tabell");
for (const [r, c, text] of cells) tbl.rows[r][c] = text;
return copy;
};
it("dagschemat: rutnätet läses och Schema-ID hittas i rubrikraden", () => {
const blocks = load("Mall/Schema dag.docx");
const first = blocks.find((b) => b.type === "paragraph");
if (first?.type !== "paragraph") throw new Error("Väntade ett stycke");
const filled = blocks.map((b) => (b === first ? { ...b, text: "Schema:Schema ID: SCI-0042" } : b));
// Rad 1 är 06:00, rad 3 08:00 ... kolumn 1 är måndag, 2 tisdag
const doc = analyzeDocument(fillGrid(filled, [[3, 1, "Arbete"], [4, 1, "Arbete"], [5, 1, "Arbete"], [3, 5, "X"], [4, 5, "X"]]), "dag.docx", known);
expect(doc.kind).toBe("SCHEDULE");
expect(doc.schedule?.code).toBe("SCI-0042");
expect(doc.schedule?.shifts).toEqual([
{ weekday: 0, startTime: "08:00", endTime: "11:00", label: "Arbete" },
{ weekday: 4, startTime: "08:00", endTime: "10:00", label: null },
]);
});
it("nattschemat: kvällens och nattens timmar blir ett pass över midnatt", () => {
const blocks = load("Mall/Schema natt.docx");
const tbl = blocks.find((b) => b.type === "table");
if (tbl?.type !== "table") throw new Error("Väntade en tabell");
const times = tbl.rows.slice(1).map((r) => r[0]);
expect(times[0]).toBe("18:00");
expect(times).toContain("00:00");
const all = tbl.rows.slice(1).map((_, i) => [i + 1, 3, "Natt"] as [number, number, string]);
const doc = analyzeDocument(fillGrid(blocks, all), "natt.docx", known);
expect(doc.schedule?.shifts).toHaveLength(1);
expect(doc.schedule?.shifts[0]).toMatchObject({ weekday: 2, startTime: "18:00", label: "Natt" });
expect(doc.schedule!.shifts[0].endTime < doc.schedule!.shifts[0].startTime).toBe(true);
});
it("schemaregistret och kartregistret med ifyllda rader", () => {
const register = load("Register/Schemaregister.docx");
const filled = fillGrid(register, [[1, 0, "SCI-0001"], [1, 1, "KI-0001"], [1, 2, "FI-0001"], [1, 3, "Dag: X Natt:"]]);
const doc = analyzeDocument(filled, "reg.docx", known);
expect(doc.kind).toBe("SCHEDULE_REGISTER");
expect(doc.scheduleRows).toEqual([{ code: "SCI-0001", personText: "KI-0001", workplaceText: "FI-0001", personId: "k1", workplaceId: "c1", dayNight: "Dag" }]);
const maps = analyzeDocument(fillGrid(load("Register/Kartregister.docx"), [[1, 0, "KD-R_0001"], [1, 1, "PI-0001"], [1, 2, "Lund"], [1, 3, "Kaféet"]]), "karta.docx", known);
expect(maps.kind).toBe("MAP_REGISTER");
expect(maps.maps).toEqual([{ code: "KD-R_0001", name: "Lund", kind: "GEO", markers: [{ code: "PI-0001", label: "Kaféet", note: null }] }]);
});
});