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:
1 parent
bd269d70a5
commit
86fd435438
64 files changed
+4796
-235
No files matched your search
@@ -0,0 +1,242 @@
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { UPLOAD_DIR, saveImageBytes } from "@/lib/files";
|
||||
import { MAX_VERSIONS } from "@/lib/history";
|
||||
import { isStale, versionOf, type ConflictInfo, type SaveResult } from "@/lib/conflict";
|
||||
import { makeImage } from "../helpers/fixtures";
|
||||
import { describeDb, filesIn, makeBook, makeEntity, makeEvent, makeRelation, makeUser, prisma, resetAll } from "../helpers/db";
|
||||
|
||||
const login = vi.hoisted(() => ({ userId: "" as string }));
|
||||
vi.mock("@/auth", () => ({ auth: async () => (login.userId ? { user: { id: login.userId } } : null) }));
|
||||
vi.mock("next/cache", () => ({ revalidatePath: () => undefined }));
|
||||
vi.mock("next/navigation", () => ({
|
||||
redirect: (to: string) => {
|
||||
throw new Error(`REDIRECT:${to}`);
|
||||
},
|
||||
notFound: () => {
|
||||
throw new Error("NOT_FOUND");
|
||||
},
|
||||
}));
|
||||
vi.mock("@/i18n/server", async () => {
|
||||
const core = await import("@/i18n/core");
|
||||
return { getLocale: async () => "sv", getT: async () => ({ locale: "sv", t: core.makeT(core.dictionaries.sv) }) };
|
||||
});
|
||||
|
||||
import { saveEntity } from "@/actions/entities";
|
||||
import { saveEvent } from "@/actions/events";
|
||||
import { saveRelation } from "@/actions/relations";
|
||||
|
||||
const form = (fields: Record<string, string | string[] | Blob>) => {
|
||||
const data = new FormData();
|
||||
for (const [key, value] of Object.entries(fields)) {
|
||||
if (value instanceof Blob) data.append(key, value, "bild.png");
|
||||
else for (const v of Array.isArray(value) ? value : [value]) data.append(key, v);
|
||||
}
|
||||
return data;
|
||||
};
|
||||
|
||||
/** Kör en sparåtgärd. Antingen omdirigerar den (sparat) eller svarar med en krock. */
|
||||
async function save(run: () => Promise<SaveResult>): Promise<{ saved: true; to: string } | { saved: false; conflict: ConflictInfo }> {
|
||||
try {
|
||||
const result = await run();
|
||||
if (result?.conflict) return { saved: false, conflict: result.conflict };
|
||||
throw new Error("Åtgärden svarade varken med omdirigering eller krock");
|
||||
} catch (error) {
|
||||
const message = error instanceof Error ? error.message : "";
|
||||
if (message.startsWith("REDIRECT:")) return { saved: true, to: message.slice(9) };
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
describe("isStale", () => {
|
||||
const now = new Date("2026-01-01T12:00:00.000Z");
|
||||
it("jämför versionen som formuläret öppnades med", () => {
|
||||
expect(isStale(versionOf(now), now)).toBe(false);
|
||||
expect(isStale(versionOf(new Date(now.getTime() - 1)), now)).toBe(true);
|
||||
});
|
||||
it("kontrollerar inget när versionen saknas", () => {
|
||||
expect(isStale("", now)).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describeDb("skydd mot kolliderande ändringar", () => {
|
||||
let ownerId: string;
|
||||
let otherId: string;
|
||||
let bookId: string;
|
||||
|
||||
beforeEach(async () => {
|
||||
await resetAll();
|
||||
const owner = await makeUser("Ägare");
|
||||
const other = await makeUser("Kollega", "kollega@example.com");
|
||||
ownerId = owner.id;
|
||||
otherId = other.id;
|
||||
bookId = (await makeBook(ownerId)).id;
|
||||
await prisma.bookMember.create({ data: { bookId, userId: otherId, role: "EDITOR" } });
|
||||
login.userId = ownerId;
|
||||
});
|
||||
|
||||
describe("poster", () => {
|
||||
const edit = (id: string, version: string, fields: Record<string, string> = {}) =>
|
||||
save(() => saveEntity(form({ bookId, id, name: "Anna", version, ...fields })));
|
||||
|
||||
it("sparar när versionen stämmer, och ger en ny version", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
const result = await edit(anna.id, versionOf(anna.updatedAt), { summary: "Ny" });
|
||||
expect(result).toMatchObject({ saved: true });
|
||||
const after = await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } });
|
||||
expect(after.summary).toBe("Ny");
|
||||
expect(after.updatedById).toBe(ownerId);
|
||||
expect(versionOf(after.updatedAt)).not.toBe(versionOf(anna.updatedAt));
|
||||
});
|
||||
|
||||
it("sparar ingenting när någon annan hunnit före, och visar vad som skiljer", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna", { summary: "Från början", data: { nickname: "Ann" } });
|
||||
const opened = versionOf(anna.updatedAt);
|
||||
|
||||
// Kollegan sparar först
|
||||
login.userId = otherId;
|
||||
await edit(anna.id, opened, { summary: "Kollegans text", f_nickname: "Ann" });
|
||||
|
||||
// Sedan sparar den första med den gamla versionen
|
||||
login.userId = ownerId;
|
||||
const result = await edit(anna.id, opened, { summary: "Min text", f_nickname: "Annie" });
|
||||
expect(result.saved).toBe(false);
|
||||
if (result.saved) return;
|
||||
|
||||
expect(result.conflict.by).toBe("Kollega");
|
||||
expect(result.conflict.changes).toEqual(
|
||||
expect.arrayContaining([
|
||||
{ label: "Sammanfattning", before: "Kollegans text", after: "Min text" },
|
||||
{ label: "Smeknamn", before: "Ann", after: "Annie" },
|
||||
]),
|
||||
);
|
||||
const stored = await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } });
|
||||
expect(stored.summary).toBe("Kollegans text");
|
||||
expect(stored.updatedById).toBe(otherId);
|
||||
});
|
||||
|
||||
it("att spara ändå med den nya versionen skriver över, och den andras version hamnar i historiken", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna", { summary: "Från början" });
|
||||
const opened = versionOf(anna.updatedAt);
|
||||
login.userId = otherId;
|
||||
await edit(anna.id, opened, { summary: "Kollegans text" });
|
||||
|
||||
login.userId = ownerId;
|
||||
const conflict = await edit(anna.id, opened, { summary: "Min text" });
|
||||
if (conflict.saved) throw new Error("Väntade en krock");
|
||||
const forced = await edit(anna.id, conflict.conflict.version, { summary: "Min text" });
|
||||
expect(forced.saved).toBe(true);
|
||||
|
||||
expect((await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } })).summary).toBe("Min text");
|
||||
const versions = await prisma.entityVersion.findMany({ where: { entityId: anna.id }, orderBy: { createdAt: "asc" } });
|
||||
const summaries = versions.map((v) => (v.snapshot as { summary: string }).summary);
|
||||
expect(summaries).toEqual(["Från början", "Kollegans text"]);
|
||||
expect(versions[1].userId).toBe(ownerId);
|
||||
});
|
||||
|
||||
it("tre samtidiga redigerare: bara en kommer igenom med samma version", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
const opened = versionOf(anna.updatedAt);
|
||||
const results = await Promise.all([1, 2, 3].map((n) => edit(anna.id, opened, { summary: `Text ${n}` }).catch((e) => ({ error: String(e) }))));
|
||||
const saved = results.filter((r) => "saved" in r && r.saved).length;
|
||||
const conflicts = results.filter((r) => "saved" in r && !r.saved).length;
|
||||
expect(saved).toBe(1);
|
||||
expect(conflicts).toBe(2);
|
||||
});
|
||||
|
||||
it("en ny bild läggs inte kvar som skräp när sparningen avbryts av en krock", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
const opened = versionOf(anna.updatedAt);
|
||||
await edit(anna.id, opened, { summary: "Först" });
|
||||
|
||||
const before = await filesIn(UPLOAD_DIR);
|
||||
const png = new Blob([(await makeImage(50, 50, "png")) as BlobPart], { type: "image/png" });
|
||||
const result = await save(() => saveEntity(form({ bookId, id: anna.id, name: "Anna", version: opened, image: png })));
|
||||
expect(result.saved).toBe(false);
|
||||
expect(await filesIn(UPLOAD_DIR)).toEqual(before);
|
||||
});
|
||||
|
||||
it("en bild som byts ut tar bort den gamla först när sparningen lyckats", async () => {
|
||||
const old = await saveImageBytes(await makeImage(40, 40, "png"));
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna", { imageFile: old });
|
||||
const png = new Blob([(await makeImage(50, 50, "png")) as BlobPart], { type: "image/png" });
|
||||
const result = await edit(anna.id, versionOf(anna.updatedAt), { image: png as unknown as string });
|
||||
expect(result.saved).toBe(true);
|
||||
const after = await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } });
|
||||
expect(after.imageFile).toBeTruthy();
|
||||
expect(after.imageFile).not.toBe(old);
|
||||
expect(await filesIn(UPLOAD_DIR)).not.toContain(old);
|
||||
});
|
||||
|
||||
it("formulär utan version sparas som förut", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
expect((await save(() => saveEntity(form({ bookId, id: anna.id, name: "Anna", summary: "Utan version" })))).saved).toBe(true);
|
||||
});
|
||||
|
||||
it("nya poster behöver ingen version", async () => {
|
||||
const result = await save(() => saveEntity(form({ bookId, kind: "CHARACTER", name: "Ny", version: "" })));
|
||||
expect(result.saved).toBe(true);
|
||||
expect((await prisma.entity.findFirstOrThrow({ where: { name: "Ny" } })).updatedById).toBe(ownerId);
|
||||
});
|
||||
|
||||
it("historiken håller sig inom gränsen även med många krockar", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
let version = versionOf(anna.updatedAt);
|
||||
for (let i = 0; i < MAX_VERSIONS + 3; i++) {
|
||||
await edit(anna.id, version, { summary: `v${i}` });
|
||||
version = versionOf((await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } })).updatedAt);
|
||||
}
|
||||
expect(await prisma.entityVersion.count({ where: { entityId: anna.id } })).toBe(MAX_VERSIONS);
|
||||
});
|
||||
});
|
||||
|
||||
describe("relationer", () => {
|
||||
it("kan inte skriva över en relation som ändrats av någon annan", async () => {
|
||||
const a = await makeEntity(bookId, "CHARACTER", "A");
|
||||
const b = await makeEntity(bookId, "CHARACTER", "B");
|
||||
const relation = await makeRelation(bookId, a.id, b.id, "Vänner");
|
||||
const opened = versionOf(relation.updatedAt);
|
||||
const edit = (type: string, version: string) => save(() => saveRelation(form({ bookId, id: relation.id, type, version })));
|
||||
|
||||
login.userId = otherId;
|
||||
expect((await edit("Bästa vänner", opened)).saved).toBe(true);
|
||||
login.userId = ownerId;
|
||||
const result = await edit("Ovänner", opened);
|
||||
expect(result.saved).toBe(false);
|
||||
if (result.saved) return;
|
||||
expect(result.conflict.by).toBe("Kollega");
|
||||
expect((await prisma.relation.findUniqueOrThrow({ where: { id: relation.id } })).type).toBe("Bästa vänner");
|
||||
|
||||
expect((await edit("Ovänner", result.conflict.version)).saved).toBe(true);
|
||||
expect((await prisma.relation.findUniqueOrThrow({ where: { id: relation.id } })).type).toBe("Ovänner");
|
||||
});
|
||||
|
||||
it("deltagarna behålls när en sparning avvisas", async () => {
|
||||
const a = await makeEntity(bookId, "CHARACTER", "A");
|
||||
const b = await makeEntity(bookId, "CHARACTER", "B");
|
||||
const c = await makeEntity(bookId, "CHARACTER", "C");
|
||||
const relation = await makeRelation(bookId, a.id, b.id, "Grupp", [c.id]);
|
||||
const opened = versionOf(relation.updatedAt);
|
||||
await save(() => saveRelation(form({ bookId, id: relation.id, type: "Grupp 2", version: opened, memberIds: [c.id] })));
|
||||
const result = await save(() => saveRelation(form({ bookId, id: relation.id, type: "Grupp 3", version: opened })));
|
||||
expect(result.saved).toBe(false);
|
||||
expect(await prisma.relationMember.count({ where: { relationId: relation.id } })).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe("händelser", () => {
|
||||
it("kan inte skriva över en händelse som ändrats av någon annan", async () => {
|
||||
const a = await makeEntity(bookId, "CHARACTER", "A");
|
||||
const event = await makeEvent(bookId, "Fest", "2000", [a.id]);
|
||||
const opened = versionOf(event.updatedAt);
|
||||
const edit = (title: string, version: string) => save(() => saveEvent(form({ bookId, id: event.id, title, date: "2000", version, participantIds: [a.id] })));
|
||||
|
||||
login.userId = otherId;
|
||||
expect((await edit("Stor fest", opened)).saved).toBe(true);
|
||||
login.userId = ownerId;
|
||||
const result = await edit("Liten fest", opened);
|
||||
expect(result.saved).toBe(false);
|
||||
expect((await prisma.storyEvent.findUniqueOrThrow({ where: { id: event.id } })).title).toBe("Stor fest");
|
||||
expect(await prisma.eventParticipant.count({ where: { eventId: event.id } })).toBe(1);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,327 @@
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { UPLOAD_DIR, saveImageBytes } from "@/lib/files";
|
||||
import { makeImage } from "../helpers/fixtures";
|
||||
import { describeDb, filesIn, makeBook, makeEntity, makeEvent, makeRelation, makeUser, prisma, resetAll } from "../helpers/db";
|
||||
|
||||
// Här används den riktiga inloggningskontrollen (session.ts). Bara själva inloggningen, cache och
|
||||
// omdirigeringar ersätts, så att åtgärderna kan köras utan webbserver.
|
||||
const login = vi.hoisted(() => ({ userId: "" as string }));
|
||||
vi.mock("@/auth", () => ({ auth: async () => (login.userId ? { user: { id: login.userId } } : null) }));
|
||||
vi.mock("next/cache", () => ({ revalidatePath: () => undefined }));
|
||||
vi.mock("next/navigation", () => ({
|
||||
redirect: (to: string) => {
|
||||
throw new Error(`REDIRECT:${to}`);
|
||||
},
|
||||
notFound: () => {
|
||||
throw new Error("NOT_FOUND");
|
||||
},
|
||||
}));
|
||||
vi.mock("@/i18n/server", async () => {
|
||||
const core = await import("@/i18n/core");
|
||||
return { getLocale: async () => "sv", getT: async () => ({ locale: "sv", t: core.makeT(core.dictionaries.sv) }) };
|
||||
});
|
||||
|
||||
import { deleteBook, updateBook } from "@/actions/books";
|
||||
import { deleteEntity, saveEntity } from "@/actions/entities";
|
||||
import { addEvent } from "@/actions/events";
|
||||
import { addRelation } from "@/actions/relations";
|
||||
import { changeMemberRole, leaveSharedBook, removeBookMember, shareBook } from "@/actions/sharing";
|
||||
import { emptyTrash, purgeTrash, restoreTrashEntity } from "@/actions/trash";
|
||||
import { saveTemplate } from "@/actions/templates";
|
||||
import { GET as exportBook } from "@/app/api/books/[bookId]/export/route";
|
||||
import { GET as searchBook } from "@/app/api/books/[bookId]/search/route";
|
||||
import { bookAccess } from "@/lib/book-access";
|
||||
import { listMembers } from "@/lib/sharing";
|
||||
|
||||
const form = (fields: Record<string, string | string[]>) => {
|
||||
const data = new FormData();
|
||||
for (const [key, value] of Object.entries(fields)) for (const v of Array.isArray(value) ? value : [value]) data.append(key, v);
|
||||
return data;
|
||||
};
|
||||
|
||||
/** Kör en åtgärd. Returnerar "ok" om den gick igenom, annars vad som hände (omdirigering eller 404). */
|
||||
async function attempt(run: () => Promise<unknown>): Promise<string> {
|
||||
try {
|
||||
await run();
|
||||
return "ok";
|
||||
} catch (error) {
|
||||
const message = error instanceof Error ? error.message : String(error);
|
||||
if (message.startsWith("REDIRECT:") || message === "NOT_FOUND") return message;
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
describeDb("delning av böcker", () => {
|
||||
let owner: { id: string };
|
||||
let admin: { id: string };
|
||||
let editor: { id: string };
|
||||
let viewer: { id: string };
|
||||
let stranger: { id: string };
|
||||
let bookId: string;
|
||||
|
||||
const as = (user: { id: string }) => {
|
||||
login.userId = user.id;
|
||||
};
|
||||
|
||||
beforeEach(async () => {
|
||||
await resetAll();
|
||||
owner = await makeUser("Ägare");
|
||||
admin = await makeUser("Admin");
|
||||
editor = await makeUser("Redaktör");
|
||||
viewer = await makeUser("Läsare");
|
||||
stranger = await makeUser("Obehörig");
|
||||
bookId = (await makeBook(owner.id, "Delad bok")).id;
|
||||
await prisma.bookMember.createMany({
|
||||
data: [
|
||||
{ bookId, userId: admin.id, role: "ADMIN" },
|
||||
{ bookId, userId: editor.id, role: "EDITOR" },
|
||||
{ bookId, userId: viewer.id, role: "VIEWER" },
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
describe("åtkomst", () => {
|
||||
it("ger rätt roll åt ägare, medlemmar och ingen alls åt andra", async () => {
|
||||
expect((await bookAccess(bookId, owner.id))?.role).toBe("OWNER");
|
||||
expect((await bookAccess(bookId, admin.id))?.role).toBe("ADMIN");
|
||||
expect((await bookAccess(bookId, editor.id))?.role).toBe("EDITOR");
|
||||
expect((await bookAccess(bookId, viewer.id))?.role).toBe("VIEWER");
|
||||
expect(await bookAccess(bookId, stranger.id)).toBeNull();
|
||||
expect(await bookAccess("finns-inte", owner.id)).toBeNull();
|
||||
});
|
||||
|
||||
it("boken ligger kvar hos ägaren och medlemskapet försvinner med boken eller användaren", async () => {
|
||||
await prisma.user.delete({ where: { id: editor.id } });
|
||||
expect(await prisma.bookMember.count({ where: { bookId } })).toBe(2);
|
||||
await prisma.book.delete({ where: { id: bookId } });
|
||||
expect(await prisma.bookMember.count()).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe("vad varje roll får göra", () => {
|
||||
const create = (name: string) => saveEntity(form({ bookId, kind: "CHARACTER", name }));
|
||||
|
||||
it("läsare kan läsa men inte skriva", async () => {
|
||||
as(viewer);
|
||||
expect(await attempt(() => create("Ny"))).toBe("NOT_FOUND");
|
||||
expect(await attempt(() => addRelation(form({ bookId, fromId: "a", toId: "b", type: "x" })))).toBe("NOT_FOUND");
|
||||
expect(await attempt(() => addEvent(form({ bookId, title: "x", date: "2000" })))).toBe("NOT_FOUND");
|
||||
expect(await prisma.entity.count()).toBe(0);
|
||||
// Läsning och export fungerar
|
||||
const res = await exportBook(new Request("http://x/api"), { params: Promise.resolve({ bookId }) });
|
||||
expect(res.status).toBe(200);
|
||||
});
|
||||
|
||||
it("redaktörer skriver som ägaren men administrerar inte", async () => {
|
||||
as(editor);
|
||||
expect(await attempt(() => create("Anna"))).toMatch(/^REDIRECT:/);
|
||||
const anna = await prisma.entity.findFirstOrThrow({ where: { bookId } });
|
||||
expect(anna.updatedById).toBe(editor.id);
|
||||
expect(await attempt(() => updateBook(form({ bookId, title: "Ny titel" })))).toBe("NOT_FOUND");
|
||||
expect(await attempt(() => saveTemplate(form({ bookId, kind: "CHARACTER", fields: "[]" })))).toBe("NOT_FOUND");
|
||||
expect(await attempt(() => shareBook(form({ bookId, email: "x@example.com", role: "VIEWER" })))).toBe("NOT_FOUND");
|
||||
expect(await attempt(() => deleteBook(form({ bookId })))).toBe("NOT_FOUND");
|
||||
expect((await prisma.book.findUniqueOrThrow({ where: { id: bookId } })).title).toBe("Delad bok");
|
||||
});
|
||||
|
||||
it("administratörer ändrar bokens uppgifter och delar den, men tar inte bort den", async () => {
|
||||
as(admin);
|
||||
expect(await attempt(() => updateBook(form({ bookId, title: "Nytt namn" })))).toBe("ok");
|
||||
expect((await prisma.book.findUniqueOrThrow({ where: { id: bookId } })).title).toBe("Nytt namn");
|
||||
expect(await attempt(() => deleteBook(form({ bookId })))).toBe("NOT_FOUND");
|
||||
expect(await prisma.book.count()).toBe(1);
|
||||
});
|
||||
|
||||
it("bara ägaren tar bort boken, och den hamnar i ägarens papperskorg", async () => {
|
||||
as(owner);
|
||||
expect(await attempt(() => deleteBook(form({ bookId })))).toBe("REDIRECT:/");
|
||||
expect(await prisma.book.count()).toBe(0);
|
||||
expect(await prisma.trashItem.count({ where: { ownerId: owner.id, kind: "book" } })).toBe(1);
|
||||
});
|
||||
|
||||
it("obehöriga får 404 överallt, även för export och sök", async () => {
|
||||
as(stranger);
|
||||
expect(await attempt(() => create("Intrång"))).toBe("NOT_FOUND");
|
||||
expect(await attempt(() => updateBook(form({ bookId, title: "x" })))).toBe("NOT_FOUND");
|
||||
expect((await exportBook(new Request("http://x/api"), { params: Promise.resolve({ bookId }) })).status).toBe(404);
|
||||
expect((await searchBook(new Request("http://x/api?q=anna"), { params: Promise.resolve({ bookId }) })).status).toBe(404);
|
||||
});
|
||||
|
||||
it("sök fungerar för medlemmar", async () => {
|
||||
await makeEntity(bookId, "CHARACTER", "Annika");
|
||||
as(viewer);
|
||||
const res = await searchBook(new Request("http://x/api?q=anni"), { params: Promise.resolve({ bookId }) });
|
||||
expect(res.status).toBe(200);
|
||||
expect(((await res.json()) as { results: unknown[] }).results).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("inloggning krävs", async () => {
|
||||
login.userId = "";
|
||||
expect(await attempt(() => create("Anonym"))).toBe("REDIRECT:/login");
|
||||
expect((await exportBook(new Request("http://x/api"), { params: Promise.resolve({ bookId }) })).status).toBe(401);
|
||||
});
|
||||
});
|
||||
|
||||
describe("hantera delningen", () => {
|
||||
it("ägaren delar med e-postadress, oavsett stora och små bokstäver", async () => {
|
||||
const friend = await makeUser("Vän", "Vän@Example.com");
|
||||
as(owner);
|
||||
expect(await attempt(() => shareBook(form({ bookId, email: " vän@example.COM ", role: "EDITOR" })))).toBe("REDIRECT:" + `/books/${bookId}/settings?share=ok`);
|
||||
expect((await prisma.bookMember.findFirstOrThrow({ where: { userId: friend.id } })).role).toBe("EDITOR");
|
||||
});
|
||||
|
||||
it("ger tydliga svar när delningen inte går", async () => {
|
||||
as(owner);
|
||||
const share = (email: string, role = "EDITOR") => attempt(() => shareBook(form({ bookId, email, role })));
|
||||
expect(await share("ingen@example.com")).toContain("share=not-found");
|
||||
expect(await share("ägare@example.com")).toContain("share=owner");
|
||||
expect(await share("redaktör@example.com")).toContain("share=already");
|
||||
expect(await share("inte-en-adress")).toContain("share=invalid");
|
||||
expect(await share("läsare@example.com", "SUPER")).toContain("share=invalid");
|
||||
expect(await prisma.bookMember.count()).toBe(3);
|
||||
});
|
||||
|
||||
it("en administratör kan dela som redaktör eller läsare men inte utse administratörer", async () => {
|
||||
const friend = await makeUser("Vän");
|
||||
as(admin);
|
||||
expect(await attempt(() => shareBook(form({ bookId, email: "vän@example.com", role: "ADMIN" })))).toContain("share=forbidden");
|
||||
expect(await attempt(() => shareBook(form({ bookId, email: "vän@example.com", role: "VIEWER" })))).toContain("share=ok");
|
||||
expect((await prisma.bookMember.findFirstOrThrow({ where: { userId: friend.id } })).role).toBe("VIEWER");
|
||||
});
|
||||
|
||||
it("en administratör kan inte röra en annan administratör, ägaren kan", async () => {
|
||||
const second = await makeUser("Admin två");
|
||||
await prisma.bookMember.create({ data: { bookId, userId: second.id, role: "ADMIN" } });
|
||||
as(admin);
|
||||
expect(await attempt(() => changeMemberRole(form({ bookId, userId: second.id, role: "VIEWER" })))).toContain("share=forbidden");
|
||||
expect(await attempt(() => removeBookMember(form({ bookId, userId: second.id })))).toContain("share=forbidden");
|
||||
expect(await prisma.bookMember.count({ where: { userId: second.id } })).toBe(1);
|
||||
as(owner);
|
||||
expect(await attempt(() => changeMemberRole(form({ bookId, userId: second.id, role: "VIEWER" })))).toContain("share=ok");
|
||||
expect(await attempt(() => removeBookMember(form({ bookId, userId: second.id })))).toContain("share=ok");
|
||||
expect(await prisma.bookMember.count({ where: { userId: second.id } })).toBe(0);
|
||||
});
|
||||
|
||||
it("redaktörer och läsare kan inte hantera delningen", async () => {
|
||||
for (const user of [editor, viewer]) {
|
||||
as(user);
|
||||
expect(await attempt(() => removeBookMember(form({ bookId, userId: viewer.id })))).toBe("NOT_FOUND");
|
||||
expect(await attempt(() => changeMemberRole(form({ bookId, userId: viewer.id, role: "ADMIN" })))).toBe("NOT_FOUND");
|
||||
}
|
||||
expect(await prisma.bookMember.count()).toBe(3);
|
||||
});
|
||||
|
||||
it("en medlem kan lämna boken, och ägaren kan inte lämna sin egen", async () => {
|
||||
as(viewer);
|
||||
expect(await attempt(() => leaveSharedBook(form({ bookId })))).toBe("REDIRECT:/");
|
||||
expect(await bookAccess(bookId, viewer.id)).toBeNull();
|
||||
as(owner);
|
||||
await attempt(() => leaveSharedBook(form({ bookId })));
|
||||
expect((await bookAccess(bookId, owner.id))?.role).toBe("OWNER");
|
||||
});
|
||||
|
||||
it("listar ägare och medlemmar", async () => {
|
||||
const { owner: o, members } = await listMembers(bookId);
|
||||
expect(o.id).toBe(owner.id);
|
||||
expect(members.map((m) => [m.user.name, m.role])).toEqual([
|
||||
["Admin", "ADMIN"],
|
||||
["Redaktör", "EDITOR"],
|
||||
["Läsare", "VIEWER"],
|
||||
]);
|
||||
});
|
||||
|
||||
it("tar bort en delning utan att röra bokens innehåll", async () => {
|
||||
await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
as(owner);
|
||||
await attempt(() => removeBookMember(form({ bookId, userId: editor.id })));
|
||||
expect(await prisma.entity.count({ where: { bookId } })).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe("papperskorgen i en delad bok", () => {
|
||||
it("en redaktör flyttar en post dit under ägarens namn, och återställer den", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
as(editor);
|
||||
expect(await attempt(() => deleteEntity(form({ bookId, id: anna.id })))).toMatch(/^REDIRECT:/);
|
||||
const item = await prisma.trashItem.findFirstOrThrow();
|
||||
expect(item).toMatchObject({ ownerId: owner.id, bookId, kind: "entity" });
|
||||
|
||||
expect(await attempt(() => restoreTrashEntity(form({ bookId, id: item.id })))).toContain(`/entity/${anna.id}`);
|
||||
expect(await prisma.entity.count({ where: { id: anna.id } })).toBe(1);
|
||||
});
|
||||
|
||||
it("läsare kan inte ta bort eller återställa", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
as(viewer);
|
||||
expect(await attempt(() => deleteEntity(form({ bookId, id: anna.id })))).toBe("NOT_FOUND");
|
||||
expect(await prisma.entity.count()).toBe(1);
|
||||
});
|
||||
|
||||
it("bara administratörer rensar papperskorgen", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
as(editor);
|
||||
await attempt(() => deleteEntity(form({ bookId, id: anna.id })));
|
||||
const item = await prisma.trashItem.findFirstOrThrow();
|
||||
|
||||
expect(await attempt(() => purgeTrash(form({ bookId, id: item.id })))).toBe("NOT_FOUND");
|
||||
expect(await attempt(() => emptyTrash(form({ bookId })))).toBe("NOT_FOUND");
|
||||
expect(await prisma.trashItem.count()).toBe(1);
|
||||
|
||||
as(admin);
|
||||
expect(await attempt(() => purgeTrash(form({ bookId, id: item.id })))).toBe("ok");
|
||||
expect(await prisma.trashItem.count()).toBe(0);
|
||||
});
|
||||
|
||||
it("en annan boks papperskorg går inte att återställa eller rensa", async () => {
|
||||
const otherBook = await makeBook(stranger.id, "Annans bok");
|
||||
const secret = await makeEntity(otherBook.id, "CHARACTER", "Hemlig");
|
||||
const { trashEntity } = await import("@/lib/trash");
|
||||
await trashEntity(stranger.id, otherBook.id, secret.id);
|
||||
const item = await prisma.trashItem.findFirstOrThrow();
|
||||
|
||||
as(editor);
|
||||
// Rätt bok i formuläret men en annan boks post: ingenting återställs
|
||||
expect(await attempt(() => restoreTrashEntity(form({ bookId, id: item.id })))).toContain("restore=failed");
|
||||
expect(await attempt(() => purgeTrash(form({ bookId, id: item.id })))).toBe("NOT_FOUND");
|
||||
expect(await prisma.trashItem.count()).toBe(1);
|
||||
expect(await prisma.entity.count({ where: { id: secret.id } })).toBe(0);
|
||||
});
|
||||
|
||||
it("borttagna böcker går bara att återställa och rensa för ägaren", async () => {
|
||||
as(owner);
|
||||
await attempt(() => deleteBook(form({ bookId })));
|
||||
const item = await prisma.trashItem.findFirstOrThrow({ where: { kind: "book" } });
|
||||
as(admin);
|
||||
await attempt(() => purgeTrash(form({ id: item.id })));
|
||||
expect(await prisma.trashItem.count()).toBe(1);
|
||||
as(owner);
|
||||
await attempt(() => purgeTrash(form({ id: item.id })));
|
||||
expect(await prisma.trashItem.count()).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe("lagring", () => {
|
||||
it("bilder som en redaktör laddar upp räknas på ägaren", async () => {
|
||||
const image = await saveImageBytes(await makeImage(60, 40, "png"));
|
||||
await makeEntity(bookId, "CHARACTER", "Anna", { imageFile: image });
|
||||
const { userStorageBytes } = await import("@/lib/storage");
|
||||
expect(await userStorageBytes(owner.id)).toBeGreaterThan(0);
|
||||
expect(await userStorageBytes(editor.id)).toBe(0);
|
||||
expect(await filesIn(UPLOAD_DIR)).toContain(image);
|
||||
});
|
||||
});
|
||||
|
||||
describe("relationer och händelser skrivs av redaktörer", () => {
|
||||
it("sparar vem som gjorde ändringen", async () => {
|
||||
const a = await makeEntity(bookId, "CHARACTER", "A");
|
||||
const b = await makeEntity(bookId, "CHARACTER", "B");
|
||||
as(editor);
|
||||
await attempt(() => addEvent(form({ bookId, title: "Möte", date: "2001" })));
|
||||
expect((await prisma.storyEvent.findFirstOrThrow()).updatedById).toBe(editor.id);
|
||||
await attempt(() => addRelation(form({ bookId, fromId: a.id, toId: b.id, type: "Vänner" })));
|
||||
expect(await prisma.relation.count()).toBe(1);
|
||||
expect(await makeRelation(bookId, a.id, b.id)).toBeTruthy();
|
||||
expect(await makeEvent(bookId, "x", "2000")).toBeTruthy();
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,276 @@
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { makeDocx, para, table } from "../helpers/docx";
|
||||
import { describeDb, makeBook, makeEntity, makeUser, prisma, resetAll } from "../helpers/db";
|
||||
|
||||
const login = vi.hoisted(() => ({ userId: "" as string }));
|
||||
vi.mock("@/auth", () => ({ auth: async () => (login.userId ? { user: { id: login.userId } } : null) }));
|
||||
vi.mock("next/cache", () => ({ revalidatePath: () => undefined }));
|
||||
vi.mock("next/navigation", () => ({
|
||||
redirect: (to: string) => {
|
||||
throw new Error(`REDIRECT:${to}`);
|
||||
},
|
||||
notFound: () => {
|
||||
throw new Error("NOT_FOUND");
|
||||
},
|
||||
}));
|
||||
vi.mock("@/i18n/server", async () => {
|
||||
const core = await import("@/i18n/core");
|
||||
return { getLocale: async () => "sv", getT: async () => ({ locale: "sv", t: core.makeT(core.dictionaries.sv) }) };
|
||||
});
|
||||
|
||||
import { previewWordImport, saveWordImport } from "@/actions/word-import";
|
||||
import { MAX_DOCX_BYTES } from "@/lib/word-docx";
|
||||
import { commitWordImport, previewWordFiles, type CommitItem } from "@/lib/word-import-db";
|
||||
|
||||
const character = (name: string, extra: string[][] = [], code = "KI-0001") =>
|
||||
makeDocx([table(["Karaktärs ID:", code], ["Förnamn:", name], ["Efternamn:", "Test"], ...extra), para("Övrigt:"), para("Anteckning.")]);
|
||||
|
||||
const bytes = (doc: Uint8Array) => ({ name: "doc.docx", bytes: doc });
|
||||
|
||||
async function attempt(run: () => Promise<unknown>): Promise<string> {
|
||||
try {
|
||||
await run();
|
||||
return "ok";
|
||||
} catch (error) {
|
||||
const message = error instanceof Error ? error.message : String(error);
|
||||
if (message === "NOT_FOUND" || message.startsWith("REDIRECT:")) return message;
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
describeDb("import från Word", () => {
|
||||
let ownerId: string;
|
||||
let bookId: string;
|
||||
|
||||
beforeEach(async () => {
|
||||
await resetAll();
|
||||
ownerId = (await makeUser()).id;
|
||||
bookId = (await makeBook(ownerId)).id;
|
||||
login.userId = ownerId;
|
||||
});
|
||||
|
||||
describe("förhandsgranskning", () => {
|
||||
it("tolkar dokumentet mot bokens poster och markerar dubbletter", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna Test");
|
||||
const [doc] = await previewWordFiles(bookId, [bytes(character("Anna", [["Anställd hos:", "Okänd"]]))]);
|
||||
expect(doc.error).toBeNull();
|
||||
expect(doc.kind).toBe("CHARACTER");
|
||||
expect(doc.items[0]).toMatchObject({ name: "Anna Test", code: "KI-0001" });
|
||||
expect(doc.items[0].duplicates).toEqual([{ id: anna.id, name: "Anna Test", code: anna.code }]);
|
||||
expect(doc.items[0].links).toEqual([{ type: "Jobbar på", toDocument: false, entityId: null, text: "Okänd", note: "" }]);
|
||||
});
|
||||
|
||||
it("hittar poster i boken på ID och namn, men inte i en annan bok", async () => {
|
||||
const company = await makeEntity(bookId, "COMPANY", "Lunds skola");
|
||||
const otherBook = await makeBook(ownerId, "Annan bok");
|
||||
await makeEntity(otherBook.id, "COMPANY", "Främmande AB");
|
||||
const [doc] = await previewWordFiles(bookId, [
|
||||
bytes(character("Eva", [["Anställd hos:", `Lunds skola ${company.code}, Främmande AB`]])),
|
||||
]);
|
||||
expect(doc.items[0].links.map((l) => [l.text, l.entityId])).toEqual([
|
||||
[`Lunds skola ${company.code}`, company.id],
|
||||
["Främmande AB", null],
|
||||
]);
|
||||
});
|
||||
|
||||
it("använder bokens egen mall, med ändrade etiketter", async () => {
|
||||
await prisma.template.create({ data: { bookId, kind: "CHARACTER", fields: [{ key: "job", label: "Arbete", type: "text" }, { key: "notes", label: "Övrigt", type: "textarea" }] } });
|
||||
const [doc] = await previewWordFiles(bookId, [bytes(character("Eva", [["Arbete:", "Snickare"]]))]);
|
||||
expect(doc.items[0].data).toEqual({ job: "Snickare", notes: "Anteckning." });
|
||||
});
|
||||
|
||||
it("rapporterar filer som inte går att läsa, och läser de andra", async () => {
|
||||
const docs = await previewWordFiles(bookId, [
|
||||
{ name: "text.docx", bytes: new TextEncoder().encode("bara text") },
|
||||
bytes(character("Eva")),
|
||||
{ name: "stor.docx", bytes: new Uint8Array(MAX_DOCX_BYTES + 1) },
|
||||
]);
|
||||
expect(docs.map((d) => d.error)).toEqual(["not-docx", null, "too-large"]);
|
||||
expect(docs[1].items).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("låter användaren byta dokumenttyp", async () => {
|
||||
const [doc] = await previewWordFiles(bookId, [bytes(makeDocx([table(["Namn:", "Rex"], ["Ras:", "Boxer"])]))], ["PET"]);
|
||||
expect(doc).toMatchObject({ kind: "PET" });
|
||||
expect(doc.items[0]).toMatchObject({ name: "Rex", data: { breed: "Boxer" } });
|
||||
});
|
||||
|
||||
it("sparar ingenting", async () => {
|
||||
await previewWordFiles(bookId, [bytes(character("Eva"))]);
|
||||
expect(await prisma.entity.count()).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe("sparande", () => {
|
||||
const item = (overrides: Partial<CommitItem> = {}): CommitItem => ({
|
||||
include: true,
|
||||
entityKind: "CHARACTER",
|
||||
name: "Eva Test",
|
||||
code: "KI-0007",
|
||||
data: { occupation: "Lärare" },
|
||||
links: [],
|
||||
unmatched: [],
|
||||
...overrides,
|
||||
});
|
||||
const commit = (items: CommitItem[], appendUnmatched = true) => commitWordImport(bookId, ownerId, items, { appendUnmatched });
|
||||
|
||||
it("skapar poster med dokumentets ID när det är ledigt, annars ett nytt", async () => {
|
||||
await makeEntity(bookId, "CHARACTER", "Redan"); // tar KI-0001
|
||||
const result = await commit([item(), item({ name: "Två", code: "KI-0001" }), item({ name: "Tre", code: null }), item({ name: "Fyra", code: "FEL-1" })]);
|
||||
expect(result).toMatchObject({ created: 4, skipped: 0 });
|
||||
const codes = Object.fromEntries((await prisma.entity.findMany({ where: { bookId } })).map((e) => [e.name, e.code]));
|
||||
expect(codes["Eva Test"]).toBe("KI-0007");
|
||||
expect(new Set(Object.values(codes)).size).toBe(5); // alla ID är unika
|
||||
expect(codes["Två"]).not.toBe("KI-0001");
|
||||
});
|
||||
|
||||
it("nya poster fortsätter numreringen efter importerade ID", async () => {
|
||||
await commit([item({ code: "KI-0020" })]);
|
||||
expect((await makeEntity(bookId, "CHARACTER", "Nästa")).code).toBe("KI-0021");
|
||||
});
|
||||
|
||||
it("hoppar över poster som användaren valt bort, och poster utan namn", async () => {
|
||||
const result = await commit([item({ include: false }), item({ name: " " }), item({ name: "Behåll", code: null })]);
|
||||
expect(result).toMatchObject({ created: 1, skipped: 2 });
|
||||
expect((await prisma.entity.findMany({ where: { bookId } })).map((e) => e.name)).toEqual(["Behåll"]);
|
||||
});
|
||||
|
||||
it("lägger det som inte tolkats i Övrigt, om användaren vill", async () => {
|
||||
await commit([item({ data: { notes: "Först." }, unmatched: [{ label: "Relationer", value: "Vän med Bo." }] })]);
|
||||
const [saved] = await prisma.entity.findMany({ where: { bookId } });
|
||||
expect((saved.data as { notes: string }).notes).toBe("Först.\n\nRelationer: Vän med Bo.");
|
||||
|
||||
const other = await makeBook(ownerId, "Utan tillägg");
|
||||
await commitWordImport(other.id, ownerId, [item({ unmatched: [{ label: "Relationer", value: "Vän med Bo." }] })], { appendUnmatched: false });
|
||||
expect((await prisma.entity.findFirstOrThrow({ where: { bookId: other.id } })).data).toEqual({ occupation: "Lärare" });
|
||||
});
|
||||
|
||||
it("skapar relationer åt rätt håll med anteckning", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
const company = await makeEntity(bookId, "COMPANY", "Firma");
|
||||
await commit([
|
||||
item({ name: "Eva", links: [{ type: "Jobbar på", toDocument: false, entityId: company.id, text: "Firma", note: "" }] }),
|
||||
item({
|
||||
entityKind: "COMPANY",
|
||||
name: "Kaffe AB",
|
||||
code: null,
|
||||
data: {},
|
||||
links: [
|
||||
{ type: "Jobbar på", toDocument: true, entityId: anna.id, text: "Anna", note: "Barista" },
|
||||
{ type: "Jobbar på", toDocument: true, entityId: null, text: "Okänd", note: "" },
|
||||
],
|
||||
}),
|
||||
]);
|
||||
const relations = await prisma.relation.findMany({ include: { from: true, to: true }, orderBy: { createdAt: "asc" } });
|
||||
expect(relations.map((r) => [r.from.name, r.type, r.to.name, r.description])).toEqual([
|
||||
["Eva", "Jobbar på", "Firma", null],
|
||||
["Anna", "Jobbar på", "Kaffe AB", "Barista"],
|
||||
]);
|
||||
expect(relations.every((r) => r.code && r.updatedById === ownerId)).toBe(true);
|
||||
});
|
||||
|
||||
it("kopplingar till poster i en annan bok och till sig själv ignoreras", async () => {
|
||||
const otherBook = await makeBook(ownerId, "Annan");
|
||||
const foreign = await makeEntity(otherBook.id, "CHARACTER", "Främling");
|
||||
await commit([item({ links: [{ type: "Vän till", toDocument: false, entityId: foreign.id, text: "Främling", note: "" }] })]);
|
||||
expect(await prisma.relation.count()).toBe(0);
|
||||
});
|
||||
|
||||
it("rensar värden som inte hör hemma i mallen, och kopplingsfält till fel typ eller bok", async () => {
|
||||
const otherBook = await makeBook(ownerId, "Annan");
|
||||
const foreign = await makeEntity(otherBook.id, "PREMISES", "Främmande lokal");
|
||||
const own = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
await commit([
|
||||
item({
|
||||
entityKind: "COMPANY",
|
||||
name: "Firma",
|
||||
code: null,
|
||||
data: { industry: "Kaffe", premises: foreign.id, sketch: own.id, hotelRooms: "tio", okänt: "x", satisfaction: "Fantastisk", hasSketches: true },
|
||||
}),
|
||||
]);
|
||||
expect((await prisma.entity.findFirstOrThrow({ where: { bookId, name: "Firma" } })).data).toEqual({ industry: "Kaffe", hasSketches: true });
|
||||
});
|
||||
|
||||
it("okända dokumenttyper och trasiga poster hoppas över utan att stoppa resten", async () => {
|
||||
const result = await commit([item({ entityKind: "FINNS_INTE" }), null as unknown as CommitItem, item({ name: "Ok", code: null })]);
|
||||
expect(result.created).toBe(1);
|
||||
});
|
||||
|
||||
it("en relation kräver två deltagare i boken och sätter släktband för partner", async () => {
|
||||
const a = await makeEntity(bookId, "CHARACTER", "A");
|
||||
const b = await makeEntity(bookId, "CHARACTER", "B");
|
||||
const c = await makeEntity(bookId, "CHARACTER", "C");
|
||||
const relation = (participants: string[], category: string): CommitItem =>
|
||||
item({ entityKind: "RELATION", name: category, code: null, data: { category, healthy: true }, participants });
|
||||
|
||||
expect(await commit([relation([a.id], "Partner")])).toMatchObject({ relations: 0, skipped: 1 });
|
||||
expect(await commit([relation([a.id, "finns-inte"], "Partner")])).toMatchObject({ relations: 0 });
|
||||
|
||||
await commit([relation([a.id, b.id, c.id], "Partner"), relation([a.id, c.id], "Vännergrupp")]);
|
||||
const relations = await prisma.relation.findMany({ include: { members: true }, orderBy: { createdAt: "asc" } });
|
||||
expect(relations.map((r) => [r.type, r.bond, r.members.length])).toEqual([
|
||||
["Partner till", "PARTNER", 1],
|
||||
["Vänner", null, 0],
|
||||
]);
|
||||
expect(relations[0]).toMatchObject({ fromId: a.id, toId: b.id, data: { category: "Partner", healthy: true } });
|
||||
});
|
||||
|
||||
it("sparar allt eller inget om något går fel", async () => {
|
||||
const result = commit([item({ name: "Bra", code: null }), item({ name: "x".repeat(10), code: null, data: { nickname: "y".repeat(30000) } })]);
|
||||
await expect(result).resolves.toMatchObject({ created: 2 });
|
||||
// För långa värden kortas i stället för att avvisas
|
||||
const long = await prisma.entity.findFirstOrThrow({ where: { bookId, name: "xxxxxxxxxx" } });
|
||||
expect(((long.data as { nickname: string }).nickname ?? "").length).toBeLessThanOrEqual(20000);
|
||||
});
|
||||
});
|
||||
|
||||
describe("åtgärderna", () => {
|
||||
const formWith = (docs: { name: string; bytes: Uint8Array }[], kinds: string[] = []) => {
|
||||
const data = new FormData();
|
||||
data.set("bookId", bookId);
|
||||
for (const d of docs) data.append("files", new File([d.bytes as BlobPart], d.name));
|
||||
for (const k of kinds) data.append("kinds", k);
|
||||
return data;
|
||||
};
|
||||
|
||||
it("förhandsgranskar och sparar för redaktörer", async () => {
|
||||
const response = await previewWordImport(formWith([bytes(character("Eva"))]));
|
||||
if (!("docs" in response)) throw new Error("Väntade förhandsgranskning");
|
||||
expect(response.docs[0].items[0].name).toBe("Eva Test");
|
||||
|
||||
const result = await saveWordImport({ bookId, appendUnmatched: true, items: [{ include: true, entityKind: "CHARACTER", name: "Eva Test", code: null, data: {}, links: [], unmatched: [] }] });
|
||||
expect(result.created).toBe(1);
|
||||
});
|
||||
|
||||
it("kräver minst en fil och högst 20", async () => {
|
||||
expect(await previewWordImport(formWith([]))).toEqual({ error: "no-files" });
|
||||
expect(await previewWordImport(formWith(Array.from({ length: 21 }, () => bytes(character("Eva")))))).toEqual({ error: "limit" });
|
||||
});
|
||||
|
||||
it("stora filer läses inte alls", async () => {
|
||||
const response = await previewWordImport(formWith([{ name: "stor.docx", bytes: new Uint8Array(MAX_DOCX_BYTES + 10) }]));
|
||||
if (!("docs" in response)) throw new Error("Väntade svar");
|
||||
expect(response.docs[0].error).toBe("too-large");
|
||||
});
|
||||
|
||||
it("läsare och obehöriga får inte importera", async () => {
|
||||
const viewer = await makeUser("Läsare");
|
||||
const stranger = await makeUser("Obehörig");
|
||||
await prisma.bookMember.create({ data: { bookId, userId: viewer.id, role: "VIEWER" } });
|
||||
const editor = await makeUser("Redaktör");
|
||||
await prisma.bookMember.create({ data: { bookId, userId: editor.id, role: "EDITOR" } });
|
||||
|
||||
for (const user of [viewer, stranger]) {
|
||||
login.userId = user.id;
|
||||
expect(await attempt(() => previewWordImport(formWith([bytes(character("Eva"))])))).toBe("NOT_FOUND");
|
||||
expect(await attempt(() => saveWordImport({ bookId, appendUnmatched: false, items: [] }))).toBe("NOT_FOUND");
|
||||
}
|
||||
expect(await prisma.entity.count()).toBe(0);
|
||||
|
||||
login.userId = editor.id;
|
||||
const result = await saveWordImport({ bookId, appendUnmatched: false, items: [{ include: true, entityKind: "CHARACTER", name: "Av redaktör", code: null, data: {}, links: [], unmatched: [] }] });
|
||||
expect(result.created).toBe(1);
|
||||
expect((await prisma.entity.findFirstOrThrow()).updatedById).toBe(editor.id);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,67 @@
|
||||
import type { DocBlock } from "@/lib/word-docx";
|
||||
import { isOptionList, labelsMatch } from "@/lib/word-labels";
|
||||
|
||||
const labelOf = (line: string): string | null => {
|
||||
const colon = line.indexOf(":");
|
||||
const text = colon >= 0 ? line.slice(0, colon) : line;
|
||||
return text.trim() ? text.trim() : null;
|
||||
};
|
||||
|
||||
const isHint = (line: string) => /^\([^)]*\)$/.test(line.trim());
|
||||
|
||||
/**
|
||||
* Fyller i en etikett i ett dokument på det sätt en person skulle göra i Word: värdet skrivs i cellen bredvid,
|
||||
* i raden under, eller på raden efter etiketten i en cell med flera etiketter. Ett val ("Ja: X Nej:") ersätter
|
||||
* alternativlistan som redan står där. Kastar om etiketten inte finns.
|
||||
*/
|
||||
export function fill(blocks: DocBlock[], label: string, value: string, occurrence = 1): DocBlock[] {
|
||||
const copy: DocBlock[] = JSON.parse(JSON.stringify(blocks));
|
||||
let seen = 0;
|
||||
|
||||
for (const [b, block] of copy.entries()) {
|
||||
if (block.type === "paragraph") {
|
||||
if (labelsMatch(labelOf(block.text) ?? "", label) && ++seen === occurrence) {
|
||||
copy.splice(b + 1, 0, { type: "paragraph", text: value });
|
||||
return copy;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
for (const [r, row] of block.rows.entries()) {
|
||||
for (const [c, cell] of row.entries()) {
|
||||
const lines = cell.split("\n");
|
||||
const at = lines.findIndex((line) => {
|
||||
const l = labelOf(line);
|
||||
return l !== null && line.includes(":") && labelsMatch(l, label);
|
||||
});
|
||||
// Etiketter utan kolon följda av en alternativlista ("Finns skisser | Ja: Nej:")
|
||||
const plain = at < 0 && lines.length === 1 && labelsMatch(cell.trim(), label);
|
||||
if (at < 0 && !plain) continue;
|
||||
if (++seen !== occurrence) continue;
|
||||
|
||||
if (lines.filter((l) => l.trim()).length > 1) {
|
||||
// Flera etiketter i en cell: värdet hamnar efter etiketten (och efter dess hjälptext)
|
||||
let insert = at + 1;
|
||||
while (isHint(lines[insert] ?? "")) insert++;
|
||||
if (isOptionList(value) && isOptionList(lines[insert] ?? "")) lines[insert] = value;
|
||||
else lines.splice(insert, 0, value);
|
||||
block.rows[r][c] = lines.join("\n");
|
||||
} else if (c + 1 < row.length && !row[c + 1].trim()) {
|
||||
row[c + 1] = value;
|
||||
} else if (c + 1 < row.length && isOptionList(row[c + 1]) && isOptionList(value)) {
|
||||
row[c + 1] = value;
|
||||
} else if (row.filter((x) => x.trim()).length === 1 && block.rows[r + 1]) {
|
||||
// Värdet står i raden under: en tom rad eller en alternativlista där ersätts, annars läggs en ny rad till
|
||||
const next = block.rows[r + 1];
|
||||
if (next.every((x) => !x.trim()) || (isOptionList(next[0] ?? "") && isOptionList(value))) block.rows[r + 1] = [value];
|
||||
else block.rows.splice(r + 1, 0, [value]);
|
||||
} else {
|
||||
row[c] = `${cell.trim()} ${value}`;
|
||||
}
|
||||
return copy;
|
||||
}
|
||||
}
|
||||
}
|
||||
throw new Error(`Etiketten "${label}" finns inte i dokumentet`);
|
||||
}
|
||||
|
||||
export const fillAll = (blocks: DocBlock[], values: [string, string][]): DocBlock[] => values.reduce((acc, [label, value]) => fill(acc, label, value), blocks);
|
||||
@@ -0,0 +1,28 @@
|
||||
import { strToU8, zipSync } from "fflate";
|
||||
import type { DocBlock } from "@/lib/word-docx";
|
||||
|
||||
const escape = (text: string) => text.replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">");
|
||||
|
||||
const paragraphXml = (text: string) =>
|
||||
`<w:p><w:pPr><w:pStyle w:val="Normal"/></w:pPr>${text
|
||||
.split("\n")
|
||||
.map((line, i) => `${i > 0 ? "<w:r><w:br/></w:r>" : ""}<w:r><w:rPr><w:b/></w:rPr><w:t xml:space="preserve">${escape(line)}</w:t></w:r>`)
|
||||
.join("")}</w:p>`;
|
||||
|
||||
const cellXml = (text: string) => `<w:tc><w:tcPr><w:tcW w:w="2000" w:type="dxa"/></w:tcPr>${text.split("\n").map(paragraphXml).join("")}</w:tc>`;
|
||||
|
||||
/** Skriver block som ett Word-dokument på samma sätt som Word gör det, för att testa läsningen av riktiga filer. */
|
||||
export function makeDocx(blocks: DocBlock[]): Uint8Array {
|
||||
const body = blocks
|
||||
.map((b) =>
|
||||
b.type === "paragraph"
|
||||
? paragraphXml(b.text)
|
||||
: `<w:tbl><w:tblPr><w:tblW w:w="0" w:type="auto"/></w:tblPr><w:tblGrid/>${b.rows.map((r) => `<w:tr><w:trPr/>${r.map(cellXml).join("")}</w:tr>`).join("")}</w:tbl>`,
|
||||
)
|
||||
.join("");
|
||||
const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body>${body}<w:sectPr/></w:body></w:document>`;
|
||||
return zipSync({ "[Content_Types].xml": strToU8("<Types/>"), "word/document.xml": strToU8(xml) });
|
||||
}
|
||||
|
||||
export const para = (text: string): DocBlock => ({ type: "paragraph", text });
|
||||
export const table = (...rows: string[][]): DocBlock => ({ type: "table", rows });
|
||||
@@ -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);
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -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 & Jerry <3 åä")))).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("&<>"'")).toBe(`&<>"'`);
|
||||
expect(decodeXml("&okänd;")).toBe("&okänd;");
|
||||
expect(decodeXml("��")).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);
|
||||
});
|
||||
});
|
||||
@@ -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],
|
||||
]);
|
||||
});
|
||||
});
|
||||
@@ -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({});
|
||||
});
|
||||
});
|
||||
@@ -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();
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user