Files
bookmanager/tests/db/multi-reference.test.ts
bobbanandClaude Sonnet 5.5 1fd1ce78cb Krockskydd för mallar, inställningar och markeringar, flera val i kopplingsfält, Word-import av scheman och kartregister, fler namn för äldre år
Mallar, bokinställningar och kartmarkeringar skickar med version och visar
en krockruta. Kopplingsfält kan ha flera val. Scheman och kartregister kan
importeras från Word, och nya ID hoppar över upptagna. Äldre födelseår får
fler namn genom två SCB-tabeller och grannår. Migrering 0008.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-08 23:23:31 +01:00

107 lines
6.0 KiB
TypeScript

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] });
});
});