Krockskydd för mallar, inställningar och markeringar, flera val i kopplingsfält, Word-import av scheman och kartregister, fler namn för äldre år

Mallar, bokinställningar och kartmarkeringar skickar med version och visar
en krockruta. Kopplingsfält kan ha flera val. Scheman och kartregister kan
importeras från Word, och nya ID hoppar över upptagna. Äldre födelseår får
fler namn genom två SCB-tabeller och grannår. Migrering 0008.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
bobbanandClaude Sonnet 5.5 committed 2026-11-08 23:23:31 +01:00
1 parent 86fd435438
commit 1fd1ce78cb
37 files changed
+2274 -149

No files matched your search

+278
View File
@@ -0,0 +1,278 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
import { versionOf, versionOfOptional, type ConflictInfo } from "@/lib/conflict";
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 { updateBook } from "@/actions/books";
import { createMarker, moveMarker, updateMarker } from "@/actions/maps";
import { resetTemplate, saveTemplate } from "@/actions/templates";
import { templateChanges } from "@/lib/template-diff";
const form = (fields: Record<string, string>) => {
const data = new FormData();
for (const [key, value] of Object.entries(fields)) data.append(key, value);
return data;
};
type Outcome = "saved" | { conflict: ConflictInfo };
async function outcome(run: () => Promise<{ conflict: ConflictInfo } | undefined | void>): Promise<Outcome> {
try {
const result = await run();
if (result && "conflict" in result) return result;
return "saved";
} catch (error) {
const message = error instanceof Error ? error.message : "";
if (message.startsWith("REDIRECT:")) return "saved";
throw error;
}
}
const fieldsJson = (...labels: string[]) => JSON.stringify(labels.map((label, i) => ({ key: `f${i}`, label, type: "text" })));
describeDb("skydd mot kolliderande ändringar: mallar, bokinställningar och kartmarkeringar", () => {
let ownerId: string;
let otherId: string;
let bookId: string;
beforeEach(async () => {
await resetAll();
ownerId = (await makeUser("Ägare")).id;
otherId = (await makeUser("Kollega", "kollega@example.com")).id;
bookId = (await makeBook(ownerId, "Bok")).id;
await prisma.bookMember.create({ data: { bookId, userId: otherId, role: "ADMIN" } });
login.userId = ownerId;
});
describe("mallar", () => {
const save = (fields: string, version: string) => outcome(() => saveTemplate(form({ bookId, kind: "CHARACTER", fields, version })));
it("den första sparningen av en standardmall behöver ingen version", async () => {
expect(await save(fieldsJson("A"), versionOfOptional(null))).toBe("saved");
expect(await prisma.template.count({ where: { bookId } })).toBe(1);
});
it("sparar med rätt version och ger en ny", async () => {
await save(fieldsJson("A"), versionOfOptional(null));
const row = await prisma.template.findFirstOrThrow({ where: { bookId } });
expect(await save(fieldsJson("A", "B"), versionOf(row.updatedAt))).toBe("saved");
const after = await prisma.template.findFirstOrThrow({ where: { bookId } });
expect(versionOf(after.updatedAt)).not.toBe(versionOf(row.updatedAt));
expect(after.updatedById).toBe(ownerId);
});
it("avvisar en sparning med gammal version och visar vilka fält som skiljer", async () => {
await save(fieldsJson("A"), versionOfOptional(null));
const opened = versionOf((await prisma.template.findFirstOrThrow({ where: { bookId } })).updatedAt);
login.userId = otherId;
await save(fieldsJson("A", "Kollegans fält"), opened);
login.userId = ownerId;
const result = await save(fieldsJson("A", "Mitt fält"), opened);
expect(result).not.toBe("saved");
if (result === "saved") return;
expect(result.conflict.by).toBe("Kollega");
expect(result.conflict.changes).toEqual([{ label: "Mitt fält", before: "Kollegans fält (text)", after: "Mitt fält (text)" }]);
expect(((await prisma.template.findFirstOrThrow({ where: { bookId } })).fields as { label: string }[]).map((f) => f.label)).toEqual(["A", "Kollegans fält"]);
// Spara ändå med den nya versionen
expect(await save(fieldsJson("A", "Mitt fält"), (result.conflict as ConflictInfo).version)).toBe("saved");
expect(((await prisma.template.findFirstOrThrow({ where: { bookId } })).fields as { label: string }[]).map((f) => f.label)).toEqual(["A", "Mitt fält"]);
});
it("någon annan skapade mallen medan du tittade på standardmallen", async () => {
login.userId = otherId;
await save(fieldsJson("Kollegans"), versionOfOptional(null));
login.userId = ownerId;
const result = await save(fieldsJson("Min"), versionOfOptional(null));
expect(result).not.toBe("saved");
expect(await prisma.template.count({ where: { bookId } })).toBe(1);
});
it("någon annan återställde mallen till standard", async () => {
await save(fieldsJson("A"), versionOfOptional(null));
const opened = versionOf((await prisma.template.findFirstOrThrow({ where: { bookId } })).updatedAt);
login.userId = otherId;
await outcome(() => resetTemplate(form({ bookId, kind: "CHARACTER" })));
login.userId = ownerId;
const result = await save(fieldsJson("B"), opened);
expect(result).not.toBe("saved");
if (result === "saved") return;
expect(result.conflict.version).toBe("none");
expect(await save(fieldsJson("B"), "none")).toBe("saved");
});
it("av tre samtidiga sparningar med samma version går bara en igenom", async () => {
await save(fieldsJson("A"), versionOfOptional(null));
const opened = versionOf((await prisma.template.findFirstOrThrow({ where: { bookId } })).updatedAt);
const results = await Promise.all([1, 2, 3].map((n) => save(fieldsJson("A", `Från ${n}`), opened)));
expect(results.filter((r) => r === "saved")).toHaveLength(1);
expect(results.filter((r) => r !== "saved")).toHaveLength(2);
});
it("och tre som skapar mallen samtidigt", async () => {
const results = await Promise.all([1, 2, 3].map((n) => save(fieldsJson(`Skapad ${n}`), "none")));
expect(results.filter((r) => r === "saved")).toHaveLength(1);
expect(await prisma.template.count({ where: { bookId } })).toBe(1);
});
it("ogiltig mall sparas inte och ger ett fel, inte en krock", async () => {
expect(await save("[{\"key\":\"1fel\",\"label\":\"x\",\"type\":\"text\"}]", "none")).toBe("saved"); // redirect med felet
expect(await prisma.template.count({ where: { bookId } })).toBe(0);
});
});
describe("templateChanges", () => {
it("jämför på nyckel och beskriver typ, flera val och alternativ", () => {
const a = [{ key: "x", label: "Lokal", type: "reference" as const, refKind: "PREMISES" as const }, { key: "y", label: "Typ", type: "select" as const, options: ["a", "b"] }];
const b = [{ key: "x", label: "Lokal", type: "reference" as const, refKind: "PREMISES" as const, multiple: true }, { key: "z", label: "Ny", type: "text" as const }];
expect(templateChanges(a, b)).toEqual([
{ label: "Lokal", before: "Lokal (reference: PREMISES)", after: "Lokal (reference, flera: PREMISES)" },
{ label: "Typ", before: "Typ (select: a/b)", after: "" },
{ label: "Ny", before: "", after: "Ny (text)" },
]);
expect(templateChanges(a, a)).toEqual([]);
});
});
describe("bokinställningar", () => {
const save = (title: string, version: string) => outcome(() => updateBook(form({ bookId, title, subtitle: "", genre: "", description: "", version })));
it("sparar med rätt version, och sparar vem som ändrade", async () => {
const book = await prisma.book.findUniqueOrThrow({ where: { id: bookId } });
expect(await save("Ny titel", versionOf(book.updatedAt))).toBe("saved");
const after = await prisma.book.findUniqueOrThrow({ where: { id: bookId } });
expect(after).toMatchObject({ title: "Ny titel", updatedById: ownerId });
expect(versionOf(after.updatedAt)).not.toBe(versionOf(book.updatedAt));
});
it("avvisar en sparning med gammal version och visar skillnaderna med namn", async () => {
const opened = versionOf((await prisma.book.findUniqueOrThrow({ where: { id: bookId } })).updatedAt);
login.userId = otherId;
await save("Kollegans titel", opened);
login.userId = ownerId;
const result = await save("Min titel", opened);
expect(result).not.toBe("saved");
if (result === "saved") return;
expect(result.conflict.by).toBe("Kollega");
expect(result.conflict.changes).toEqual([{ label: "Titel", before: "Kollegans titel", after: "Min titel" }]);
expect((await prisma.book.findUniqueOrThrow({ where: { id: bookId } })).title).toBe("Kollegans titel");
expect(await save("Min titel", result.conflict.version)).toBe("saved");
expect((await prisma.book.findUniqueOrThrow({ where: { id: bookId } })).title).toBe("Min titel");
});
it("tre samtidiga sparningar: en går igenom", async () => {
const opened = versionOf((await prisma.book.findUniqueOrThrow({ where: { id: bookId } })).updatedAt);
const results = await Promise.all([1, 2, 3].map((n) => save(`Titel ${n}`, opened)));
expect(results.filter((r) => r === "saved")).toHaveLength(1);
});
});
describe("kartmarkeringar", () => {
let mapId: string;
let markerId: string;
const input = (label: string, extra: { lat?: number; lng?: number; note?: string } = {}) => ({ label, note: extra.note ?? "", color: "blue", entityId: null, lat: extra.lat ?? 59.3, lng: extra.lng ?? 18.0 });
beforeEach(async () => {
mapId = (await prisma.bookMap.create({ data: { bookId, name: "Karta", kind: "GEO" } })).id;
markerId = (await prisma.marker.create({ data: { mapId, label: "Hus", lat: 59.3, lng: 18.0 } })).id;
});
const version = async () => versionOf((await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).updatedAt);
it("uppdatering med rätt version lyckas och ger en ny version", async () => {
const result = await updateMarker(bookId, mapId, markerId, input("Villa"), await version());
expect(result).toHaveProperty("version");
const after = await prisma.marker.findUniqueOrThrow({ where: { id: markerId } });
expect(after).toMatchObject({ label: "Villa", updatedById: ownerId });
expect((result as { version: string }).version).toBe(versionOf(after.updatedAt));
});
it("en gammal version ger en krock med skillnader, och ändrar ingenting", async () => {
const opened = await version();
login.userId = otherId;
await updateMarker(bookId, mapId, markerId, input("Kollegans", { note: "Anteckning" }), opened);
login.userId = ownerId;
const result = await updateMarker(bookId, mapId, markerId, input("Mitt"), opened);
expect(result).toHaveProperty("conflict");
const { conflict } = result as { conflict: ConflictInfo };
expect(conflict.by).toBe("Kollega");
expect(conflict.changes).toEqual(expect.arrayContaining([{ label: "Etikett", before: "Kollegans", after: "Mitt" }, { label: "Anteckning", before: "Anteckning", after: "" }]));
expect((await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).label).toBe("Kollegans");
expect(await updateMarker(bookId, mapId, markerId, input("Mitt"), conflict.version)).toHaveProperty("version");
expect((await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).label).toBe("Mitt");
});
it("att flytta en markering som ändrats av någon annan sparar inte flytten", async () => {
const opened = await version();
login.userId = otherId;
await updateMarker(bookId, mapId, markerId, input("Kollegans"), opened);
login.userId = ownerId;
const result = await moveMarker(bookId, mapId, markerId, 60, 19, opened);
expect(result).toHaveProperty("conflict");
expect(await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).toMatchObject({ lat: 59.3, lng: 18 });
});
it("en lyckad flytt ger en version som går att använda direkt efteråt", async () => {
const moved = await moveMarker(bookId, mapId, markerId, 60, 19, await version());
expect(moved).toHaveProperty("version");
expect(await updateMarker(bookId, mapId, markerId, input("Efter flytt", { lat: 60, lng: 19 }), (moved as { version: string }).version)).toHaveProperty("version");
});
it("en borttagen markering ger gone", async () => {
const opened = await version();
await prisma.marker.delete({ where: { id: markerId } });
expect(await updateMarker(bookId, mapId, markerId, input("Spöke"), opened)).toEqual({ gone: true });
expect(await moveMarker(bookId, mapId, markerId, 1, 1, opened)).toEqual({ gone: true });
});
it("av tre samtidiga ändringar med samma version går en igenom", async () => {
const opened = await version();
const results = await Promise.all([1, 2, 3].map((n) => updateMarker(bookId, mapId, markerId, input(`Från ${n}`), opened)));
expect(results.filter((r) => "version" in r)).toHaveLength(1);
expect(results.filter((r) => "conflict" in r)).toHaveLength(2);
});
it("utan version kontrolleras inget (som förut)", async () => {
expect(await updateMarker(bookId, mapId, markerId, input("Utan version"))).toHaveProperty("version");
});
it("nya markeringar får ID och vem som skapade dem", async () => {
await createMarker(bookId, mapId, input("Ny"));
const created = await prisma.marker.findFirstOrThrow({ where: { label: "Ny" } });
expect(created.code).toMatch(/^PI-/);
expect(created.updatedById).toBe(ownerId);
});
it("en markering i en annan bok kan inte ändras", async () => {
const otherBook = await makeBook(ownerId, "Annan");
const foreignMap = await prisma.bookMap.create({ data: { bookId: otherBook.id, name: "K", kind: "GEO" } });
const foreign = await prisma.marker.create({ data: { mapId: foreignMap.id, label: "Främmande", lat: 1, lng: 1 } });
expect(await updateMarker(bookId, mapId, foreign.id, input("Kapad"))).toEqual({ gone: true });
expect((await prisma.marker.findUniqueOrThrow({ where: { id: foreign.id } })).label).toBe("Främmande");
});
it("kopplingen till en post i boken behålls vid uppdatering", async () => {
const entity = await makeEntity(bookId, "PREMISES", "Lokal");
await updateMarker(bookId, mapId, markerId, { ...input("Med koppling"), entityId: entity.id });
expect((await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).entityId).toBe(entity.id);
});
});
});
+106
View File
@@ -0,0 +1,106 @@
import { beforeEach, expect, it } from "vitest";
import { buildExport, importBook } from "@/lib/book-transfer";
import { collectFieldData } from "@/lib/field-values";
import { getDefaultTemplate, getTemplate, refIds, validateFields, type FieldDef } from "@/lib/templates";
import { restoreEntity, trashEntity } from "@/lib/trash";
import { describeDb, makeBook, makeEntity, makeUser, prisma, resetAll } from "../helpers/db";
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;
};
describeDb("flera val i kopplingsfält", () => {
let ownerId: string;
let bookId: string;
let cafe: { id: string };
let bar: { id: string };
let person: { id: string };
const premisesField: FieldDef = { key: "premises", label: "Lokal", type: "reference", refKind: "PREMISES", multiple: true };
const single: FieldDef = { key: "premises", label: "Lokal", type: "reference", refKind: "PREMISES" };
beforeEach(async () => {
await resetAll();
ownerId = (await makeUser()).id;
bookId = (await makeBook(ownerId)).id;
cafe = await makeEntity(bookId, "PREMISES", "Café");
bar = await makeEntity(bookId, "PREMISES", "Bar");
person = await makeEntity(bookId, "CHARACTER", "Anna");
});
it("refIds läser både ett id och en lista", () => {
expect(refIds("a")).toEqual(["a"]);
expect(refIds(["a", "b", "a", "", 5])).toEqual(["a", "b"]);
expect(refIds("")).toEqual([]);
expect(refIds(undefined)).toEqual([]);
expect(refIds(7)).toEqual([]);
});
it("standardmallarna tillåter flera lokaler och skisser där det passar", () => {
const multiple = (kind: Parameters<typeof getDefaultTemplate>[0], key: string) => getDefaultTemplate(kind, "sv").find((f) => f.key === key)?.multiple === true;
expect(multiple("COMPANY", "premises")).toBe(true);
expect(multiple("COMPANY", "sketch")).toBe(true);
expect(multiple("EDUCATION", "premises")).toBe(true);
expect(multiple("HOME", "sketch")).toBe(true);
expect(multiple("VEHICLE", "owner")).toBe(false); // ett fordon har en ägare
expect(multiple("SCENARIO", "linkedEntity")).toBe(false);
});
it("flera val sparas som en lista, utan dubbletter, och bara poster i boken av rätt typ", async () => {
const otherBook = await makeBook(ownerId, "Annan");
const foreign = await makeEntity(otherBook.id, "PREMISES", "Främmande");
const data = await collectFieldData(bookId, [premisesField], form({ f_premises: [cafe.id, bar.id, cafe.id, foreign.id, person.id, "finns-inte", ""] }), null);
expect(data.premises).toEqual([cafe.id, bar.id]);
});
it("inga val tar bort fältet", async () => {
expect(await collectFieldData(bookId, [premisesField], form({}), { premises: [cafe.id], annat: 1 })).toEqual({ annat: 1 });
expect(await collectFieldData(bookId, [premisesField], form({ f_premises: ["finns-inte"] }), null)).toEqual({});
});
it("ett äldre värde med ett id i ett fält som nu tillåter flera blir en lista", async () => {
const data = await collectFieldData(bookId, [{ key: "other", label: "X", type: "text" }, premisesField], form({ f_premises: [cafe.id] }), { premises: cafe.id });
expect(data.premises).toEqual([cafe.id]);
// Ett värde som lämnas orört i data för ett fält som inte skickas med formuläret tas inte bort av kontrollen
const kept = await collectFieldData(bookId, [{ key: "other", label: "X", type: "text" }], form({}), { premises: [cafe.id, bar.id] });
expect(kept.premises).toEqual([cafe.id, bar.id]);
});
it("ett fält med ett val som tidigare hade flera behåller bara det första", async () => {
// Kopplingskontrollen kör för alla kopplingsfält i mallen, även när formuläret inte skickar något
const data = await collectFieldData(bookId, [single], form({ f_premises: bar.id }), { premises: [cafe.id, bar.id] });
expect(data.premises).toBe(bar.id);
});
it("ett fält med ett val sparar ett id som förut", async () => {
expect((await collectFieldData(bookId, [single], form({ f_premises: cafe.id }), null)).premises).toBe(cafe.id);
expect((await collectFieldData(bookId, [single], form({ f_premises: person.id }), null)).premises).toBeUndefined();
});
it("mallens flera val sparas och läses från bokens egen mall", async () => {
expect(validateFields([{ key: "a", label: "A", type: "reference", multiple: true }])[0].multiple).toBe(true);
expect(validateFields([{ key: "a", label: "A", type: "text", multiple: true }])[0].multiple).toBeUndefined();
expect(validateFields([{ key: "a", label: "A", type: "reference", multiple: "ja" }])[0].multiple).toBeUndefined();
await prisma.template.create({ data: { bookId, kind: "COMPANY", fields: [premisesField as unknown as object] } });
expect((await getTemplate(bookId, "COMPANY", "sv")).fields[0].multiple).toBe(true);
});
it("export och import pekar om alla poster i listan", async () => {
const company = await makeEntity(bookId, "COMPANY", "Firma", { data: { premises: [cafe.id, bar.id] } });
const { data, files } = await buildExport(bookId, false);
const result = await importBook(ownerId, data, files);
const copy = await prisma.entity.findMany({ where: { bookId: result.bookId } });
const byName = Object.fromEntries(copy.map((e) => [e.name, e]));
expect((byName.Firma.data as { premises: string[] }).premises).toEqual([byName["Café"].id, byName.Bar.id]);
expect(company.id).not.toBe(byName.Firma.id);
});
it("en post i papperskorgen kommer tillbaka med sina listor", async () => {
const company = await makeEntity(bookId, "COMPANY", "Firma", { data: { premises: [cafe.id, bar.id] } });
await trashEntity(ownerId, bookId, company.id);
const [item] = await prisma.trashItem.findMany();
await restoreEntity(ownerId, item.id);
expect((await prisma.entity.findUniqueOrThrow({ where: { id: company.id } })).data).toEqual({ premises: [cafe.id, bar.id] });
});
});
+97
View File
@@ -0,0 +1,97 @@
import { afterEach, beforeEach, expect, it, vi } from "vitest";
import { OLD_YEARS_MARKER, getGivenNames } from "@/lib/name-stats";
import { describeDb, prisma, resetAll } from "../helpers/db";
/** Ett svar från SCB: ett namn och ett år per rad. */
const scb = (rows: Record<string, Record<number, number>>) => ({
ok: true,
status: 200,
text: async () =>
JSON.stringify({
data: Object.entries(rows).flatMap(([name, years]) => Object.entries(years).map(([year, n]) => ({ key: [name, year], values: [String(n)] }))),
}),
});
describeDb("namnstatistik för äldre år", () => {
const calls: string[] = [];
beforeEach(async () => {
await resetAll();
calls.length = 0;
});
afterEach(() => vi.unstubAllGlobals());
const stub = (handler: (url: string) => unknown) =>
vi.stubGlobal(
"fetch",
vi.fn(async (url: string) => {
calls.push(url);
return handler(url);
}),
);
it("slår ihop tilltalsnamn och förnamn och sparar resultatet", async () => {
stub((url) =>
url.includes("BE0001F100")
? scb({ "1Anders": { 1960: 500 }, "1Gösta": { 1958: 30, 1960: 20, 1961: 10 } })
: scb({ "1Anders": { 1960: 300 }, "1Rune": { 1959: 40 } }),
);
const result = await getGivenNames("male", 1960);
expect(result.year).toBe(1960);
expect(result.source).toContain(OLD_YEARS_MARKER);
expect(Object.fromEntries(result.entries)).toEqual({ Anders: 300, Gösta: 20, Rune: 10 });
// Båda tabellerna hämtades i ett enda anrop var, med flera år
expect(calls).toHaveLength(2);
expect(calls.some((u) => u.includes("BE0001T100"))).toBe(true);
expect(calls.some((u) => u.includes("BE0001F100"))).toBe(true);
});
it("använder det sparade nästa gång utan att fråga SCB igen", async () => {
stub(() => scb({ "2Anna": { 1960: 100 } }));
await getGivenNames("female", 1960);
const before = calls.length;
const again = await getGivenNames("female", 1960);
expect(again.entries).toEqual([["Anna", 100]]);
expect(calls).toHaveLength(before);
});
it("hämtar om en lista som byggts på det gamla sättet", async () => {
await prisma.nameStat.create({ data: { kind: "given-female", year: 1960, source: "SCB, födda 1960", entries: [["Gammal", 5]] } });
stub(() => scb({ "2Anna": { 1960: 100 } }));
const result = await getGivenNames("female", 1960);
expect(result.entries).toEqual([["Anna", 100]]);
expect((await prisma.nameStat.findUniqueOrThrow({ where: { kind_year: { kind: "given-female", year: 1960 } } })).source).toContain(OLD_YEARS_MARKER);
});
it("behåller en gammal lista när SCB inte svarar", async () => {
await prisma.nameStat.create({ data: { kind: "given-female", year: 1960, source: "SCB, födda 1960", entries: [["Gammal", 5]] } });
stub(() => {
throw new Error("ingen kontakt");
});
expect((await getGivenNames("female", 1960)).entries).toEqual([["Gammal", 5]]);
});
it("kastar när SCB inte svarar och inget finns sparat", async () => {
stub(() => {
throw new Error("ingen kontakt");
});
await expect(getGivenNames("female", 1960)).rejects.toThrow("ingen kontakt");
});
it("frågar bara efter år som finns i statistiken", async () => {
stub(() => scb({ "1Karl": { 1922: 10, 1923: 12, 1924: 9 } }));
await getGivenNames("male", 1922);
const body = (init: RequestInit | undefined) => JSON.parse(String(init?.body)) as { query: { code: string; selection: { values: string[] } }[] };
const fetchMock = fetch as unknown as ReturnType<typeof vi.fn>;
const years = body(fetchMock.mock.calls[0][1]).query.find((q) => q.code === "Tid")!.selection.values;
expect(years).toEqual(["1922", "1923", "1924"]);
});
it("årtal efter 1997 hämtas som förut, från nyfödda", async () => {
stub(() => scb({ "Olivia": { 2005: 700 } }));
const result = await getGivenNames("female", 2005);
expect(result.source).toBe("SCB, nyfödda 2005");
expect(calls).toHaveLength(1);
expect(calls[0]).toContain("BE0001Nyfodda");
});
});
+239
View File
@@ -0,0 +1,239 @@
import { beforeEach, describe, expect, it } from "vitest";
import { nextMapCode, nextMarkerCode, nextScheduleCode } from "@/lib/ids";
import { commitWordImport, previewWordFiles, type CommitMap } from "@/lib/word-import-db";
import { makeDocx, para, table } from "../helpers/docx";
import { describeDb, makeBook, makeEntity, makeUser, prisma, resetAll } from "../helpers/db";
const bytes = (doc: Uint8Array) => ({ name: "doc.docx", bytes: doc });
describeDb("import från Word: scheman och kartregister", () => {
let ownerId: string;
let bookId: string;
beforeEach(async () => {
await resetAll();
ownerId = (await makeUser()).id;
bookId = (await makeBook(ownerId)).id;
});
describe("scheman", () => {
const grid = (cells: [number, number, string][], code = "Schema: Schema ID: SCI-0009") => {
const days = ["Tid:", "Måndag:", "Tisdag:", "Onsdag:", "Torsdag:", "Fredag:", "Lördag:", "Söndag:"];
const rows = ["06:00", "07:00", "08:00", "09:00", "10:00", "11:00", "12:00"].map((t) => [t, "", "", "", "", "", "", ""]);
for (const [r, c, v] of cells) rows[r][c] = v;
return makeDocx([para(code), table(days, ...rows)]);
};
const register = (rows: string[][]) => makeDocx([table(["Schema ID:", "Karaktärs ID:", "Företags/utbildnings ID:", "Dag/natt:"], ...rows, ["", "", "", ""])]);
const shiftsOf = () => prisma.shift.findMany({ where: { bookId }, orderBy: [{ weekday: "asc" }, { startTime: "asc" }] });
const commit = (schedules: Parameters<typeof commitWordImport>[3]["schedules"]) => commitWordImport(bookId, ownerId, [], { appendUnmatched: false, schedules });
it("schemaregistret i samma uppladdning ger scheman person och arbetsplats", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
const firma = await makeEntity(bookId, "COMPANY", "Firma");
const docs = await previewWordFiles(bookId, [
bytes(grid([[2, 1, "Arbete"], [3, 1, "Arbete"]])),
bytes(register([["SCI-0009", anna.code!, firma.code!, "Dag: X Natt:"]])),
]);
expect(docs[0].kind).toBe("SCHEDULE");
expect(docs[0].schedule).toMatchObject({ code: "SCI-0009", personId: anna.id, workplaceId: firma.id, source: "register", existing: 0 });
expect(docs[0].schedule?.shifts).toEqual([{ weekday: 0, startTime: "08:00", endTime: "10:00", label: "Arbete" }]);
expect(docs[1].scheduleRows[0]).toMatchObject({ code: "SCI-0009", personId: anna.id, workplaceId: firma.id });
});
it("ett schema med ett Schema-ID som redan finns i boken får samma person och arbetsplats, och antal befintliga pass", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
const firma = await makeEntity(bookId, "COMPANY", "Firma");
await prisma.shift.create({ data: { bookId, personId: anna.id, workplaceId: firma.id, weekday: 2, startTime: "08:00", endTime: "16:00", scheduleCode: "SCI-0009" } });
const [doc] = await previewWordFiles(bookId, [bytes(grid([[2, 1, "X"]]))]);
expect(doc.schedule).toMatchObject({ personId: anna.id, workplaceId: firma.id, source: "existing", existing: 1 });
});
it("utan känt Schema-ID får personen väljas, och inget är förvalt", async () => {
const [doc] = await previewWordFiles(bookId, [bytes(grid([[2, 1, "X"]], "Schema: Schema ID:____"))]);
expect(doc.schedule).toMatchObject({ code: null, personId: null, workplaceId: null, source: null });
});
it("sparar pass för vald person och arbetsplats med dokumentets Schema-ID", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
const firma = await makeEntity(bookId, "COMPANY", "Firma");
const result = await commit([
{
include: true,
code: "SCI-0009",
personId: anna.id,
workplaceId: firma.id,
replace: false,
shifts: [
{ weekday: 0, startTime: "08:00", endTime: "16:00", label: "Arbete" },
{ weekday: 1, startTime: "18:00", endTime: "06:00", label: null },
],
},
]);
expect(result).toMatchObject({ shifts: 2 });
expect((await shiftsOf()).map((s) => [s.weekday, s.startTime, s.endTime, s.label, s.scheduleCode, s.weeks])).toEqual([
[0, "08:00", "16:00", "Arbete", "SCI-0009", "ALL"],
[1, "18:00", "06:00", null, "SCI-0009", "ALL"],
]);
// Räknaren har flyttats förbi det importerade ID:t
expect(await nextScheduleCode(bookId)).toBe("SCI-0010");
});
it("samma person och arbetsplats behåller sitt Schema-ID, och pass som redan finns läggs inte till igen", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
await prisma.shift.create({ data: { bookId, personId: anna.id, workplaceId: null, weekday: 0, startTime: "08:00", endTime: "16:00", scheduleCode: "SCI-0003" } });
const result = await commit([
{
include: true,
code: "SCI-0099",
personId: anna.id,
workplaceId: null,
replace: false,
shifts: [
{ weekday: 0, startTime: "08:00", endTime: "16:00", label: null },
{ weekday: 3, startTime: "09:00", endTime: "12:00", label: null },
],
},
]);
expect(result.shifts).toBe(1);
expect((await shiftsOf()).map((s) => [s.weekday, s.scheduleCode])).toEqual([[0, "SCI-0003"], [3, "SCI-0003"]]);
});
it("kan ersätta personens befintliga pass hos arbetsplatsen, men bara hos den", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
const firma = await makeEntity(bookId, "COMPANY", "Firma");
const annat = await makeEntity(bookId, "COMPANY", "Annat");
await prisma.shift.createMany({
data: [
{ bookId, personId: anna.id, workplaceId: firma.id, weekday: 0, startTime: "08:00", endTime: "16:00", scheduleCode: "SCI-0001" },
{ bookId, personId: anna.id, workplaceId: annat.id, weekday: 1, startTime: "08:00", endTime: "16:00", scheduleCode: "SCI-0002" },
],
});
await commit([{ include: true, code: null, personId: anna.id, workplaceId: firma.id, replace: true, shifts: [{ weekday: 4, startTime: "10:00", endTime: "14:00", label: null }] }]);
expect((await shiftsOf()).map((s) => [s.weekday, s.workplaceId === firma.id ? "firma" : "annat"])).toEqual([
[1, "annat"],
[4, "firma"],
]);
});
it("avvisar ogiltiga personer, arbetsplatser och pass", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
const sketch = await makeEntity(bookId, "SKETCH", "Skiss");
const other = await makeBook(ownerId, "Annan");
const foreign = await makeEntity(other.id, "CHARACTER", "Främling");
const ok = { weekday: 0, startTime: "08:00", endTime: "16:00", label: null };
const result = await commit([
{ include: true, code: null, personId: foreign.id, workplaceId: null, replace: false, shifts: [ok] }, // person i en annan bok
{ include: true, code: null, personId: null, workplaceId: null, replace: false, shifts: [ok] }, // ingen person
{ include: true, code: null, personId: anna.id, workplaceId: null, replace: false, shifts: [{ ...ok, weekday: 7 }, { ...ok, startTime: "25:00" }, { ...ok, endTime: "08:00" }] }, // bara ogiltiga pass
{ include: false, code: null, personId: anna.id, workplaceId: null, replace: false, shifts: [ok] }, // bortvald
{ include: true, code: null, personId: anna.id, workplaceId: sketch.id, replace: false, shifts: [{ ...ok, weekday: 2 }] }, // arbetsplats av fel typ: pass utan arbetsplats
]);
expect(result.shifts).toBe(1);
expect(result.skipped).toBe(3);
const [only] = await shiftsOf();
expect(only).toMatchObject({ weekday: 2, workplaceId: null });
});
it("ett Schema-ID som används av en annan får personen ett nytt", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
const bo = await makeEntity(bookId, "CHARACTER", "Bo");
await prisma.shift.create({ data: { bookId, personId: bo.id, workplaceId: null, weekday: 0, startTime: "08:00", endTime: "09:00", scheduleCode: "SCI-0005" } });
await commit([{ include: true, code: "SCI-0005", personId: anna.id, workplaceId: null, replace: false, shifts: [{ weekday: 1, startTime: "08:00", endTime: "09:00", label: null }] }]);
const codes = (await prisma.shift.findMany({ where: { personId: anna.id } })).map((s) => s.scheduleCode);
expect(codes).toHaveLength(1);
expect(codes[0]).not.toBe("SCI-0005");
});
});
describe("kartregister", () => {
const map = (overrides: Partial<CommitMap> = {}): CommitMap => ({
include: true,
code: "KD-R_0005",
name: "Lund",
kind: "GEO",
markers: [
{ code: "PI-0007", label: "Kaféet", note: "Vid torget" },
{ code: null, label: "Biblioteket", note: null },
],
...overrides,
});
const commitMaps = (maps: CommitMap[]) => commitWordImport(bookId, ownerId, [], { appendUnmatched: false, maps });
it("skapar kartor med markeringar i kartans mitt, och behåller lediga ID", async () => {
expect(await commitMaps([map()])).toMatchObject({ maps: 1, markers: 2 });
const created = await prisma.bookMap.findFirstOrThrow({ where: { bookId }, include: { markers: { orderBy: { code: "asc" } } } });
expect(created).toMatchObject({ name: "Lund", kind: "GEO", code: "KD-R_0005", zoom: 11 });
expect(created.centerLat).toBeCloseTo(59.3293);
expect(created.markers.map((m) => [m.code, m.label, m.note])).toEqual([
["PI-0007", "Kaféet", "Vid torget"],
["PI-0008", "Biblioteket", null],
]);
// Markeringarna ligger på olika ställen så att de går att dra isär
expect(new Set(created.markers.map((m) => `${m.lat},${m.lng}`)).size).toBe(2);
expect(created.markers.every((m) => m.updatedById === ownerId)).toBe(true);
});
it("räknarna fortsätter efter de importerade ID:na", async () => {
await commitMaps([map()]);
expect(await nextMapCode(bookId, "GEO")).toBe("KD-R_0006");
expect(await nextMarkerCode(bookId)).toBe("PI-0009");
});
it("ett ID som redan används ger ett nytt, och bildkartor och namnlösa kartor hoppas över", async () => {
await commitMaps([map()]);
const result = await commitMaps([map(), map({ kind: "IMAGE", code: "KD-E_0001" }), map({ name: " " }), map({ include: false })]);
expect(result).toMatchObject({ maps: 1, skipped: 2 });
const codes = (await prisma.bookMap.findMany({ where: { bookId } })).map((m) => m.code);
expect(new Set(codes).size).toBe(2);
const markerCodes = (await prisma.marker.findMany({ where: { map: { bookId } } })).map((m) => m.code);
expect(new Set(markerCodes).size).toBe(markerCodes.length);
});
it("hoppar över ID som redan används även när räknaren ligger efter", async () => {
// Poster som lagts in utan räknaren (för hand eller av en äldre version)
const existing = await prisma.bookMap.create({ data: { bookId, name: "Befintlig", kind: "GEO", code: "KD-R_0001" } });
await prisma.marker.create({ data: { mapId: existing.id, label: "Gammal", code: "PI-0001", lat: 1, lng: 1 } });
await prisma.entity.create({ data: { bookId, kind: "CHARACTER", name: "Gammal", code: "KI-0001" } });
await prisma.shift.create({ data: { bookId, personId: (await prisma.entity.findFirstOrThrow({ where: { bookId } })).id, weekday: 0, startTime: "08:00", endTime: "09:00", scheduleCode: "SCI-0001" } });
const result = await commitWordImport(
bookId,
ownerId,
[{ include: true, entityKind: "CHARACTER", name: "Ny", code: null, data: {}, links: [], unmatched: [] }],
{ appendUnmatched: false, maps: [map({ code: null, markers: [{ code: null, label: "Ny markering", note: null }] })] },
);
expect(result).toMatchObject({ created: 1, maps: 1, markers: 1 });
expect((await prisma.bookMap.findMany({ where: { bookId }, orderBy: { code: "asc" } })).map((m) => m.code)).toEqual(["KD-R_0001", "KD-R_0002"]);
expect((await prisma.marker.findMany({ where: { map: { bookId } }, orderBy: { code: "asc" } })).map((m) => m.code)).toEqual(["PI-0001", "PI-0002"]);
expect((await prisma.entity.findFirstOrThrow({ where: { bookId, name: "Ny" } })).code).toBe("KI-0002");
// Och samma för ett nytt schema
const bo = await prisma.entity.create({ data: { bookId, kind: "CHARACTER", name: "Bo", code: "KI-0003" } });
await commitWordImport(bookId, ownerId, [], {
appendUnmatched: false,
schedules: [{ include: true, code: null, personId: bo.id, workplaceId: null, replace: false, shifts: [{ weekday: 1, startTime: "08:00", endTime: "09:00", label: null }] }],
});
expect((await prisma.shift.findFirstOrThrow({ where: { personId: bo.id } })).scheduleCode).toBe("SCI-0002");
});
it("hoppar över markeringar utan etikett och kortar för långa texter", async () => {
await commitMaps([map({ markers: [{ code: null, label: "", note: null }, { code: null, label: "x".repeat(500), note: "y".repeat(9000) }] })]);
const [marker] = await prisma.marker.findMany({ where: { map: { bookId } } });
expect(marker.label).toHaveLength(200);
expect(marker.note).toHaveLength(5000);
});
it("förhandsgranskningen visar vilka kartor som redan finns", async () => {
await prisma.bookMap.create({ data: { bookId, name: "Befintlig", kind: "GEO", code: "KD-R_0001" } });
const doc = makeDocx([
table(["Kart ID:", "Placerings ID:", "Stad/Område:", "Beskrivning:", "Övrigt:"], ["KD-R_0001", "PI-0001", "Lund", "Kaféet", ""], ["KD-R_0002", "", "Malmö", "", ""], ["", "", "", "", ""]),
]);
const [preview] = await previewWordFiles(bookId, [bytes(doc)]);
expect(preview.kind).toBe("MAP_REGISTER");
expect(preview.maps.map((m) => [m.code, m.exists])).toEqual([
["KD-R_0001", true],
["KD-R_0002", false],
]);
});
});
});
+9
View File
@@ -191,6 +191,15 @@ describeDb("import från Word", () => {
expect((await prisma.entity.findFirstOrThrow({ where: { bookId, name: "Firma" } })).data).toEqual({ industry: "Kaffe", hasSketches: true });
});
it("flera lokaler sparas som en lista, bara de som finns i boken", async () => {
const a = await makeEntity(bookId, "PREMISES", "A");
const b = await makeEntity(bookId, "PREMISES", "B");
const other = await makeBook(ownerId, "Annan");
const foreign = await makeEntity(other.id, "PREMISES", "Främmande");
await commit([item({ entityKind: "COMPANY", name: "Firma", code: null, data: { premises: [a.id, b.id, foreign.id, "finns-inte"] } })]);
expect((await prisma.entity.findFirstOrThrow({ where: { bookId, name: "Firma" } })).data).toEqual({ premises: [a.id, b.id] });
});
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);