Automatiska tester, och rättningar som testerna hittade

Vitest med enhetstester utan databas och databastester mot en egen
testdatabas vars namn måste sluta på _test. Rättar tomma MAP_*-värden
i .env och säkerhetskopior med å, ä och ö i filnamnet.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
bobbanandClaude Sonnet 5.5 committed 2026-11-01 23:19:30 +01:00
1 parent 4e8d79ee10
commit dcb5d43429
30 files changed
+2872 -13

No files matched your search

+25
View File
@@ -0,0 +1,25 @@
// Testdatabasens adress: TEST_DATABASE_URL, annars databasen i DATABASE_URL med "_test" efter namnet.
// Testerna tömmer tabellerna, så databasens namn MÅSTE sluta på _test. Annars avbryts allt.
export function testDatabaseUrl(env: NodeJS.ProcessEnv = process.env): string | undefined {
const explicit = env.TEST_DATABASE_URL;
const base = env.DATABASE_URL;
let url: URL;
try {
if (explicit) {
url = new URL(explicit);
} else if (base) {
url = new URL(base);
// Redan en testdatabas (t.ex. när konfigurationen läses igen i en testprocess): lämna som den är
if (!decodeURIComponent(url.pathname.slice(1)).endsWith("_test")) url.pathname = `${url.pathname.replace(/\/$/, "")}_test`;
} else {
return undefined;
}
} catch {
return undefined;
}
const name = decodeURIComponent(url.pathname.slice(1));
if (!name.endsWith("_test")) {
throw new Error(`Testdatabasens namn måste sluta på _test (fick "${name}"). Testerna tömmer tabellerna.`);
}
return url.toString();
}
+135
View File
@@ -0,0 +1,135 @@
import { mkdir, readFile } from "node:fs/promises";
import path from "node:path";
import { beforeEach, describe, expect, it } from "vitest";
import { BACKUP_DIR, BACKUP_FILE_PATTERN, BACKUP_KEEP, backupDue, failStaleRuns, listBackups, runBackup, safeName } from "@/lib/backup";
import { importBook, readImportFile } from "@/lib/book-transfer";
import { saveImageBytes } from "@/lib/files";
import { makeImage } from "../helpers/fixtures";
import { describeDb, makeBook, makeEntity, makeRelation, makeUser, prisma, resetAll } from "../helpers/db";
describeDb("säkerhetskopiering", () => {
let ownerId: string;
beforeEach(async () => {
await resetAll();
ownerId = (await makeUser()).id;
});
it("sparar en zip per bok och en indexfil, och loggar körningen", async () => {
const image = await saveImageBytes(await makeImage(60, 40, "png"));
const a = await makeBook(ownerId, "Första boken");
const b = await makeBook(ownerId, "Andra boken");
await makeEntity(a.id, "CHARACTER", "Anna", { imageFile: image });
await makeEntity(b.id, "CHARACTER", "Bo");
const runId = await runBackup("manual");
const run = await prisma.backupRun.findUniqueOrThrow({ where: { id: runId } });
expect(run).toMatchObject({ status: "ok", trigger: "manual", books: 2, error: null });
expect(run.finishedAt).not.toBeNull();
const [folder] = await listBackups();
expect(folder.folder).toBe(run.folder);
// Filnamnen är ASCII (Första blir Forsta), annars kan de inte listas eller laddas ner
expect(folder.files.map((f) => f.name).sort()).toEqual([`Andra-boken-${b.id.slice(-8)}.zip`, `Forsta-boken-${a.id.slice(-8)}.zip`, "index.json"].sort());
const index = JSON.parse(await readFile(path.join(BACKUP_DIR, folder.folder, "index.json"), "utf8")) as { books: { title: string; file: string }[] };
expect(index.books.map((x) => x.title)).toEqual(["Första boken", "Andra boken"]);
});
it("filnamn av boktitlar blir alltid giltiga för nedladdning", () => {
expect(safeName("Skuggor över Lund")).toBe("Skuggor-over-Lund");
expect(safeName("Åsa & Örjan: del 2")).toBe("Asa-Orjan-del-2");
expect(safeName(" ")).toBe("bok");
expect(safeName("日本語")).toBe("bok");
expect(safeName("x".repeat(200))).toHaveLength(50);
for (const title of ["Skuggor över Lund", "Åsa/Örjan", "../../etc/passwd", "a b.c"]) {
expect(`${safeName(title)}-cmvabcde.zip`).toMatch(BACKUP_FILE_PATTERN);
}
});
it("zip-filerna går att importera igen, med bilder", async () => {
const image = await saveImageBytes(await makeImage(60, 40, "png"));
const book = await makeBook(ownerId, "Min bok");
const anna = await makeEntity(book.id, "CHARACTER", "Anna", { imageFile: image });
const erik = await makeEntity(book.id, "CHARACTER", "Erik");
await makeRelation(book.id, anna.id, erik.id);
await runBackup("schedule");
const [folder] = await listBackups();
const zip = folder.files.find((f) => f.name.endsWith(".zip"))!;
const { data, files } = readImportFile(new Uint8Array(await readFile(path.join(BACKUP_DIR, folder.folder, zip.name))));
const result = await importBook(ownerId, data, files);
expect(result).toMatchObject({ entities: 2, relations: 1, skippedImages: 0 });
expect((await prisma.entity.findFirstOrThrow({ where: { bookId: result.bookId, name: "Anna" } })).imageFile).toBeTruthy();
});
it("fungerar även utan några böcker", async () => {
const runId = await runBackup("schedule");
expect(await prisma.backupRun.findUniqueOrThrow({ where: { id: runId } })).toMatchObject({ status: "ok", books: 0 });
});
it(`behåller bara de ${BACKUP_KEEP} senaste körningarna`, async () => {
await makeBook(ownerId, "Bok");
// Äldre mappar med tidsstämpelnamn, äldre än dagens körning
for (let day = 1; day <= BACKUP_KEEP + 1; day++) {
await mkdir(path.join(BACKUP_DIR, `2020-01-${String(day).padStart(2, "0")}T03-00-00`), { recursive: true });
}
await runBackup("schedule");
const folders = (await listBackups()).map((f) => f.folder);
expect(folders).toHaveLength(BACKUP_KEEP);
expect(folders).not.toContain("2020-01-01T03-00-00"); // äldst är borttagen
expect(folders).not.toContain("2020-01-02T03-00-00");
expect(folders[0] > "2020").toBe(true); // nyaste först
});
it("listBackups ignorerar mappar och filer som inte är säkerhetskopior", async () => {
await mkdir(path.join(BACKUP_DIR, "vad-som-helst"), { recursive: true });
await mkdir(path.join(BACKUP_DIR, "2021-05-05T03-00-00"), { recursive: true });
const folders = await listBackups();
expect(folders.map((f) => f.folder)).toEqual(["2021-05-05T03-00-00"]);
});
describe("backupDue", () => {
const at = (hour: number) => new Date(2026, 5, 15, hour, 0, 0);
const runAt = (hour: number, status: string) => prisma.backupRun.create({ data: { trigger: "schedule", status, startedAt: at(hour) } });
it("är inte aktuell före inställd timme", async () => {
expect(await backupDue(at(2))).toBe(false);
});
it("är aktuell efter inställd timme när ingen körning gjorts i dag", async () => {
expect(await backupDue(at(3))).toBe(true);
expect(await backupDue(at(23))).toBe(true);
});
it("är inte aktuell när en körning redan lyckats eller pågår i dag", async () => {
await runAt(3, "ok");
expect(await backupDue(at(10))).toBe(false);
});
it("pågående körning hindrar en ny", async () => {
await runAt(4, "running");
expect(await backupDue(at(10))).toBe(false);
});
it("försöker igen efter en misslyckad körning", async () => {
await runAt(3, "error");
expect(await backupDue(at(10))).toBe(true);
});
it("en körning från igår räknas inte", async () => {
await prisma.backupRun.create({ data: { trigger: "schedule", status: "ok", startedAt: new Date(2026, 5, 14, 3, 0, 0) } });
expect(await backupDue(at(10))).toBe(true);
});
});
it("markerar körningar som fastnat som misslyckade", async () => {
const stale = await prisma.backupRun.create({ data: { trigger: "schedule", status: "running", startedAt: new Date(Date.now() - 2 * 3600_000) } });
const fresh = await prisma.backupRun.create({ data: { trigger: "manual", status: "running" } });
await failStaleRuns();
expect((await prisma.backupRun.findUniqueOrThrow({ where: { id: stale.id } })).status).toBe("error");
expect((await prisma.backupRun.findUniqueOrThrow({ where: { id: fresh.id } })).status).toBe("running");
});
});
+114
View File
@@ -0,0 +1,114 @@
import { beforeEach, expect, it } from "vitest";
import { collectFieldData } from "@/lib/field-values";
import { MAX_VERSIONS, recordVersion } from "@/lib/history";
import type { FieldDef } from "@/lib/templates";
import { describeDb, makeBook, makeEntity, makeUser, prisma, resetAll } from "../helpers/db";
describeDb("historik", () => {
let userId: string;
let bookId: string;
let entityId: string;
beforeEach(async () => {
await resetAll();
userId = (await makeUser()).id;
bookId = (await makeBook(userId)).id;
entityId = (await makeEntity(bookId, "CHARACTER", "Anna")).id;
});
it("sparar versionen med den som ändrade", async () => {
await prisma.$transaction((tx) => recordVersion(tx, bookId, entityId, userId, { name: "Gammal", summary: null, tags: [], data: {} }));
const [version] = await prisma.entityVersion.findMany({ where: { entityId } });
expect(version).toMatchObject({ bookId, entityId, userId });
expect(version.snapshot).toMatchObject({ name: "Gammal" });
});
it(`behåller bara de ${MAX_VERSIONS} senaste versionerna`, async () => {
for (let i = 1; i <= MAX_VERSIONS + 5; i++) {
await prisma.$transaction((tx) => recordVersion(tx, bookId, entityId, userId, { name: `v${i}`, summary: null, tags: [], data: {} }));
}
const versions = await prisma.entityVersion.findMany({ where: { entityId }, orderBy: { createdAt: "asc" } });
expect(versions).toHaveLength(MAX_VERSIONS);
const names = versions.map((v) => (v.snapshot as { name: string }).name);
expect(names[0]).toBe("v6"); // de fem äldsta är borta
expect(names.at(-1)).toBe(`v${MAX_VERSIONS + 5}`);
});
it("rensar bara den aktuella postens versioner", async () => {
const other = await makeEntity(bookId, "CHARACTER", "Bo");
for (let i = 0; i < MAX_VERSIONS + 2; i++) {
await prisma.$transaction((tx) => recordVersion(tx, bookId, entityId, userId, { name: `a${i}`, summary: null, tags: [], data: {} }));
}
await prisma.$transaction((tx) => recordVersion(tx, bookId, other.id, userId, { name: "b", summary: null, tags: [], data: {} }));
expect(await prisma.entityVersion.count({ where: { entityId: other.id } })).toBe(1);
});
it("följer med när boken tas bort", async () => {
await prisma.$transaction((tx) => recordVersion(tx, bookId, entityId, userId, { name: "x", summary: null, tags: [], data: {} }));
await prisma.book.delete({ where: { id: bookId } });
expect(await prisma.entityVersion.count()).toBe(0);
});
});
describeDb("fältvärden från formulär", () => {
let bookId: string;
let premisesId: string;
let characterId: string;
let foreignPremisesId: string;
const fields: FieldDef[] = [
{ key: "name", label: "Text", type: "text" },
{ key: "age", label: "Ålder", type: "number" },
{ key: "alive", label: "Vid liv", type: "checkbox" },
{ key: "premises", label: "Lokal", type: "reference", refKind: "PREMISES" },
{ key: "anything", label: "Vad som helst", type: "reference" },
];
const form = (values: Record<string, string>) => {
const data = new FormData();
for (const [key, value] of Object.entries(values)) data.set(`f_${key}`, value);
return data;
};
beforeEach(async () => {
await resetAll();
const user = await makeUser();
bookId = (await makeBook(user.id)).id;
premisesId = (await makeEntity(bookId, "PREMISES", "Lokal")).id;
characterId = (await makeEntity(bookId, "CHARACTER", "Anna")).id;
foreignPremisesId = (await makeEntity((await makeBook(user.id, "Annan")).id, "PREMISES", "Främmande")).id;
});
it("läser text, tal och kryssrutor", async () => {
const data = await collectFieldData(bookId, fields, form({ name: " Anna ", age: "1,5", alive: "on" }), null);
expect(data).toMatchObject({ name: "Anna", age: 1.5, alive: true });
});
it("en ibockad kryssruta som saknas i formuläret blir falsk", async () => {
const data = await collectFieldData(bookId, fields, form({ name: "x" }), { alive: true });
expect(data.alive).toBe(false);
});
it("tomma fält tas bort och ogiltiga tal ignoreras", async () => {
const data = await collectFieldData(bookId, fields, form({ name: "", age: "abc" }), { name: "gammal", age: 5 });
expect(data.name).toBeUndefined();
expect(data.age).toBe(5); // behåller det tidigare värdet när det nya inte är ett tal
});
it("låter data för fält som inte finns i mallen vara orörd", async () => {
const data = await collectFieldData(bookId, fields, form({ name: "x" }), { gammalt: "kvar" });
expect(data.gammalt).toBe("kvar");
});
it("godkänner en koppling till rätt typ av post i boken", async () => {
const data = await collectFieldData(bookId, fields, form({ premises: premisesId, anything: characterId }), null);
expect(data.premises).toBe(premisesId);
expect(data.anything).toBe(characterId);
});
it("tar bort kopplingar till fel typ, andra böcker och poster som inte finns", async () => {
for (const value of [characterId, foreignPremisesId, "finns-inte"]) {
const data = await collectFieldData(bookId, fields, form({ premises: value }), null);
expect(data.premises).toBeUndefined();
}
});
});
+50
View File
@@ -0,0 +1,50 @@
import { beforeEach, expect, it } from "vitest";
import { nextEntityCode, nextMapCode, nextMarkerCode, nextRelationCode, nextScheduleCode } from "@/lib/ids";
import { describeDb, makeBook, makeUser, prisma, resetAll } from "../helpers/db";
describeDb("löpande ID", () => {
let bookId: string;
let otherBookId: string;
beforeEach(async () => {
await resetAll();
const user = await makeUser();
bookId = (await makeBook(user.id, "A")).id;
otherBookId = (await makeBook(user.id, "B")).id;
});
it("räknar upp per typ i varje bok", async () => {
expect(await nextEntityCode(bookId, "CHARACTER")).toBe("KI-0001");
expect(await nextEntityCode(bookId, "CHARACTER")).toBe("KI-0002");
expect(await nextEntityCode(bookId, "PET")).toBe("DI-0001");
expect(await nextEntityCode(bookId, "CHARACTER")).toBe("KI-0003");
});
it("börjar om i en ny bok", async () => {
await nextEntityCode(bookId, "CHARACTER");
await nextEntityCode(bookId, "CHARACTER");
expect(await nextEntityCode(otherBookId, "CHARACTER")).toBe("KI-0001");
});
it("ger inget ID åt typer utan ID", async () => {
expect(await nextEntityCode(bookId, "APP")).toBeNull();
expect(await nextEntityCode(bookId, "WEBSITE")).toBeNull();
expect(await prisma.idCounter.count({ where: { bookId } })).toBe(0);
});
it("använder egna räknare för relationer, placeringar, scheman och kartor", async () => {
expect(await nextRelationCode(bookId)).toBe("REI-0001");
expect(await nextMarkerCode(bookId)).toBe("PI-0001");
expect(await nextScheduleCode(bookId)).toBe("SCI-0001");
expect(await nextMapCode(bookId, "GEO")).toBe("KD-R_0001");
expect(await nextMapCode(bookId, "IMAGE")).toBe("KD-E_0001");
expect(await nextMapCode(bookId, "GEO")).toBe("KD-R_0002");
});
it("ger unika nummer även när många skapas samtidigt", async () => {
const codes = await Promise.all(Array.from({ length: 25 }, () => nextEntityCode(bookId, "CHARACTER")));
expect(new Set(codes).size).toBe(25);
expect(codes.sort()[0]).toBe("KI-0001");
expect(codes.sort()[24]).toBe("KI-0025");
});
});
+149
View File
@@ -0,0 +1,149 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
import { isAdminUser } from "@/lib/admin";
import { saveImageBytes } from "@/lib/files";
import { trashEntity } from "@/lib/trash";
import { userImageNames, userStorageBytes } from "@/lib/storage";
import { makeImage } from "../helpers/fixtures";
import { describeDb, makeBook, makeEntity, makeUser, prisma, resetAll } from "../helpers/db";
// Sökvägen använder inloggningen. Här byter vi ut den mot en användare som testet väljer.
const current = vi.hoisted(() => ({ userId: "" as string | null }));
vi.mock("@/lib/session", () => ({ getCurrentUser: async () => (current.userId ? { id: current.userId } : null) }));
describeDb("lagringskvot", () => {
beforeEach(resetAll);
it("räknar bilder på poster, kartor och i papperskorgen, men bara användarens egna", async () => {
const me = await makeUser("Jag");
const other = await makeUser("Annan");
const mine = await makeBook(me.id);
const theirs = await makeBook(other.id);
const a = await saveImageBytes(await makeImage(100, 100, "png"));
const b = await saveImageBytes(await makeImage(120, 120, "png"), "map");
const c = await saveImageBytes(await makeImage(80, 80, "png"));
const foreign = await saveImageBytes(await makeImage(90, 90, "png"));
await makeEntity(mine.id, "CHARACTER", "Med bild", { imageFile: a });
await prisma.bookMap.create({ data: { bookId: mine.id, name: "K", kind: "IMAGE", imageFile: b } });
const inTrash = await makeEntity(mine.id, "CHARACTER", "Borttagen", { imageFile: c });
await trashEntity(me.id, mine.id, inTrash.id);
await makeEntity(theirs.id, "CHARACTER", "Någon annans", { imageFile: foreign });
expect((await userImageNames(me.id)).sort()).toEqual([a!, b!, c!].sort());
expect(await userStorageBytes(me.id)).toBeGreaterThan(0);
expect(await userStorageBytes(other.id)).toBeLessThan(await userStorageBytes(me.id));
});
it("räknar noll utan bilder", async () => {
const user = await makeUser();
expect(await userStorageBytes(user.id)).toBe(0);
});
it("withinQuota följer USER_QUOTA_MB", async () => {
vi.stubEnv("USER_QUOTA_MB", "0.0001"); // cirka 100 byte
vi.resetModules();
const { withinQuota, USER_QUOTA_BYTES } = await import("@/lib/storage");
expect(USER_QUOTA_BYTES).toBeLessThan(200);
const user = await makeUser();
const book = await makeBook(user.id);
expect(await withinQuota(user.id, 50)).toBe(true);
expect(await withinQuota(user.id, 5000)).toBe(false);
const { saveImageBytes: save } = await import("@/lib/files");
const image = await save(await makeImage(300, 300, "png"));
await prisma.entity.create({ data: { bookId: book.id, kind: "CHARACTER", name: "X", imageFile: image } });
expect(await withinQuota(user.id, 1)).toBe(false); // bilden ensam överskrider redan kvoten
vi.unstubAllEnvs();
vi.resetModules();
});
});
describeDb("administratör", () => {
beforeEach(resetAll);
it("den äldsta användaren är administratör när ADMIN_EMAILS saknas", async () => {
const first = await makeUser("Först");
const second = await makeUser("Sist");
expect(await isAdminUser(first.id, first.email)).toBe(true);
expect(await isAdminUser(second.id, second.email)).toBe(false);
});
it("ADMIN_EMAILS styr när den är satt, oberoende av stora bokstäver och mellanslag", async () => {
const first = await makeUser("Först", "forst@example.com");
const second = await makeUser("Sist", "Sist@Example.com");
vi.stubEnv("ADMIN_EMAILS", " sist@example.com , annan@example.com ");
expect(await isAdminUser(second.id, second.email)).toBe(true);
expect(await isAdminUser(first.id, first.email)).toBe(false); // äldst, men inte i listan
expect(await isAdminUser(first.id, null)).toBe(false);
vi.unstubAllEnvs();
});
});
describeDb("sök", () => {
let bookId: string;
let userId: string;
const search = async (q: string, book = bookId) => {
const { GET } = await import("@/app/api/books/[bookId]/search/route");
return GET(new Request(`http://localhost/api/books/${book}/search?q=${encodeURIComponent(q)}`, { headers: { "x-forwarded-for": `10.0.0.${Math.floor(Math.random() * 250)}` } }), {
params: Promise.resolve({ bookId: book }),
});
};
const names = async (q: string) => ((await (await search(q)).json()) as { results: { name: string }[] }).results.map((r) => r.name);
beforeEach(async () => {
await resetAll();
userId = (await makeUser()).id;
current.userId = userId;
bookId = (await makeBook(userId)).id;
await makeEntity(bookId, "CHARACTER", "Anna Lindqvist", { tags: ["huvudperson"], summary: "En bagare i Lund", data: { occupation: "Bagare", nickname: "Annie" } });
await makeEntity(bookId, "CHARACTER", "Erik Berg", { data: { occupation: "Barista" } });
await makeEntity(bookId, "PLACE", "100% Kaffe");
});
it("hittar på namn, ID, sammanfattning, taggar och värden i mallfält", async () => {
expect(await names("lindqvist")).toEqual(["Anna Lindqvist"]);
expect(await names("KI-0002")).toEqual(["Erik Berg"]);
expect(await names("bagare i lund")).toEqual(["Anna Lindqvist"]);
expect(await names("huvudperson")).toEqual(["Anna Lindqvist"]);
expect(await names("barista")).toEqual(["Erik Berg"]);
expect(await names("annie")).toEqual(["Anna Lindqvist"]);
});
it("söker i fältens värden men inte i deras nycklar", async () => {
expect(await names("occupation")).toEqual([]);
expect(await names("nickname")).toEqual([]);
});
it("behandlar procenttecken och understreck som vanliga tecken", async () => {
expect(await names("100%")).toEqual(["100% Kaffe"]);
expect(await names("%%")).toEqual([]);
expect(await names("A_n")).toEqual([]); // _ är inte jokertecken
});
it("sorterar träffar som börjar med söktexten först", async () => {
await makeEntity(bookId, "CHARACTER", "Maria Anna");
expect((await names("anna"))[0]).toBe("Anna Lindqvist");
});
it("kräver minst två tecken", async () => {
expect(await names("a")).toEqual([]);
});
it("nekar andra användare och utloggade", async () => {
const intruder = await makeUser("Inkräktare");
current.userId = intruder.id;
expect((await search("anna")).status).toBe(404);
current.userId = null;
expect((await search("anna")).status).toBe(401);
});
});
describe("hjälpare", () => {
it("testfilerna körs i en egen tillfällig mapp, inte i projektets data", () => {
expect(process.env.UPLOAD_DIR).toContain("bookmanager-test-data");
expect(process.env.BACKUP_DIR).toContain("bookmanager-test-data");
expect(process.env.TRASH_DIR).toContain("bookmanager-test-data");
});
});
+189
View File
@@ -0,0 +1,189 @@
import { readFile } from "node:fs/promises";
import path from "node:path";
import { strToU8, zipSync, type Zippable } from "fflate";
import { beforeEach, expect, it } from "vitest";
import { buildExport, importBook, readImportFile } from "@/lib/book-transfer";
import { UPLOAD_DIR, saveImageBytes } from "@/lib/files";
import { nextMapCode, nextMarkerCode, nextScheduleCode } from "@/lib/ids";
import { entityRow, makeImage, validExport } from "../helpers/fixtures";
import { describeDb, filesIn, makeBook, makeEntity, makeRelation, makeUser, prisma, resetAll } from "../helpers/db";
/** Skickar exporten genom samma zip-format som exportknappen och läser tillbaka den. */
function viaZip(exported: Awaited<ReturnType<typeof buildExport>>) {
const entries: Zippable = { "book.json": strToU8(JSON.stringify(exported.data)) };
for (const [name, bytes] of exported.files) entries[`files/${name}`] = [bytes, { level: 0 }];
return readImportFile(zipSync(entries));
}
describeDb("export och import", () => {
let ownerId: string;
let bookId: string;
const ids = {} as Record<"anna" | "erik" | "cafe" | "firma" | "relation" | "map", string>;
/** En bok med allt: bilder, relation med deltagare, kopplingsfält, scheman, kartor och mall. */
beforeEach(async () => {
await resetAll();
ownerId = (await makeUser("Ägare")).id;
bookId = (await makeBook(ownerId, "Testbok")).id;
const portrait = await saveImageBytes(await makeImage(120, 80, "png"));
const anna = await makeEntity(bookId, "CHARACTER", "Anna", { imageFile: portrait, tags: ["huvud"], summary: "Huvudperson", data: { age: 30 } });
const erik = await makeEntity(bookId, "CHARACTER", "Erik");
const cafe = await makeEntity(bookId, "PREMISES", "Café Lund");
const firma = await makeEntity(bookId, "COMPANY", "Lunds Kaffe", { data: { industry: "Kaffe", premises: cafe.id } });
const relation = await makeRelation(bookId, anna.id, erik.id, "Vänner", [cafe.id]);
const scheduleCode = await nextScheduleCode(bookId);
await prisma.shift.createMany({
data: [0, 1].map((weekday) => ({ bookId, personId: erik.id, workplaceId: cafe.id, weekday, startTime: "08:00", endTime: "16:00", scheduleCode })),
});
const mapImage = await saveImageBytes(await makeImage(200, 100, "png"), "map");
const geo = await prisma.bookMap.create({ data: { bookId, name: "Lund", kind: "GEO", code: await nextMapCode(bookId, "GEO"), centerLat: 55.7, centerLng: 13.19, zoom: 14 } });
await prisma.bookMap.create({ data: { bookId, name: "Egen", kind: "IMAGE", code: await nextMapCode(bookId, "IMAGE"), imageFile: mapImage } });
await prisma.marker.create({ data: { mapId: geo.id, entityId: cafe.id, label: "Café", code: await nextMarkerCode(bookId), lat: 55.7047, lng: 13.191, color: "orange", note: "Hörnet" } });
await prisma.template.create({ data: { bookId, kind: "CHARACTER", fields: [{ key: "mood", label: "Läge", type: "text" }] } });
Object.assign(ids, { anna: anna.id, erik: erik.id, cafe: cafe.id, firma: firma.id, relation: relation.id, map: geo.id });
});
it("en export som importeras igen blir en likadan bok med nya id", async () => {
const exported = await buildExport(bookId, true);
const { data, files } = viaZip(exported);
const result = await importBook(ownerId, data, files);
expect(result).toMatchObject({ entities: 4, relations: 1, maps: 2, markers: 1, shifts: 2, skippedImages: 0, skippedLinks: 0 });
expect(result.bookId).not.toBe(bookId);
const copy = await prisma.book.findUniqueOrThrow({
where: { id: result.bookId },
include: { entities: true, relations: { include: { members: true } }, shifts: true, maps: { include: { markers: true } }, templates: true, counters: true },
});
// Samma titel får ett tillägg så att böckerna går att skilja åt
expect(copy.title).toBe("Testbok (import)");
// Poster: nya id, men samma namn, ID-nummer, taggar och mallfält
const byName = Object.fromEntries(copy.entities.map((e) => [e.name, e]));
expect(Object.keys(byName).sort()).toEqual(["Anna", "Café Lund", "Erik", "Lunds Kaffe"]);
expect(byName.Anna).toMatchObject({ code: "KI-0001", tags: ["huvud"], summary: "Huvudperson", data: { age: 30 } });
expect(byName["Café Lund"].code).toBe("LI-0001");
for (const old of Object.values(ids)) expect(copy.entities.map((e) => e.id)).not.toContain(old);
// Kopplingsfältet pekar på den nya lokalen, inte den gamla
expect((byName["Lunds Kaffe"].data as { premises: string }).premises).toBe(byName["Café Lund"].id);
// Relationen och dess extra deltagare pekar på de nya posterna
const [relation] = copy.relations;
expect(relation).toMatchObject({ code: "REI-0001", type: "Vänner", fromId: byName.Anna.id, toId: byName.Erik.id });
expect(relation.members.map((m) => m.entityId)).toEqual([byName["Café Lund"].id]);
// Scheman delar schema-ID och pekar på nya poster
expect(copy.shifts).toHaveLength(2);
expect(new Set(copy.shifts.map((s) => s.scheduleCode))).toEqual(new Set(["SCI-0001"]));
expect(copy.shifts.every((s) => s.personId === byName.Erik.id && s.workplaceId === byName["Café Lund"].id)).toBe(true);
// Kartor och markeringar
const geo = copy.maps.find((m) => m.kind === "GEO")!;
expect(geo).toMatchObject({ code: "KD-R_0001", zoom: 14, centerLat: 55.7 });
expect(geo.markers[0]).toMatchObject({ code: "PI-0001", label: "Café", color: "orange", note: "Hörnet", entityId: byName["Café Lund"].id });
expect(copy.maps.find((m) => m.kind === "IMAGE")?.code).toBe("KD-E_0001");
// Mall och räknare
expect(copy.templates).toHaveLength(1);
const counter = Object.fromEntries(copy.counters.map((c) => [c.key, c.next]));
expect(counter).toMatchObject({ KI: 2, LI: 1, FI: 1, REI: 1, SCI: 1, PI: 1, "KD-R": 1, "KD-E": 1 });
});
it("bilderna kopieras till nya filer", async () => {
const before = await filesIn(UPLOAD_DIR);
expect(before).toHaveLength(2);
const { data, files } = viaZip(await buildExport(bookId, true));
const result = await importBook(ownerId, data, files);
const after = await filesIn(UPLOAD_DIR);
expect(after).toHaveLength(4);
const copy = await prisma.entity.findFirstOrThrow({ where: { bookId: result.bookId, name: "Anna" } });
expect(copy.imageFile).toBeTruthy();
expect(before).not.toContain(copy.imageFile);
expect((await readFile(path.join(UPLOAD_DIR, copy.imageFile!))).length).toBeGreaterThan(0);
});
it("nya poster fortsätter numreringen efter importen", async () => {
const { data, files } = viaZip(await buildExport(bookId, true));
const { bookId: copyId } = await importBook(ownerId, data, files);
const next = await makeEntity(copyId, "CHARACTER", "Ny");
expect(next.code).toBe("KI-0003");
});
it("JSON utan bilder går att importera", async () => {
const { data } = await buildExport(bookId, false);
const result = await importBook(ownerId, data, new Map());
expect(result.entities).toBe(4);
expect(result.skippedImages).toBe(0);
expect((await prisma.entity.findFirstOrThrow({ where: { bookId: result.bookId, name: "Anna" } })).imageFile).toBeNull();
});
it("kan importeras till en annan användare utan tillägg i titeln", async () => {
const other = await makeUser("Annan");
const { data, files } = viaZip(await buildExport(bookId, true));
const result = await importBook(other.id, data, files);
const copy = await prisma.book.findUniqueOrThrow({ where: { id: result.bookId } });
expect(copy.ownerId).toBe(other.id);
expect(copy.title).toBe("Testbok");
});
it("saknade bilder och trasiga kopplingar hoppas över och räknas", async () => {
const data = validExport({
entities: [entityRow("a", "CHARACTER", "Anna", { image: "saknas.png" }), entityRow("b", "CHARACTER", "Bo", { image: "skräp.png" })],
relations: [
{ id: "r1", code: null, fromId: "a", toId: "b", type: "Vänner", description: null, data: {}, members: ["finns-inte"] },
{ id: "r2", code: null, fromId: "a", toId: "okänd", type: "Fiende", description: null, data: {}, members: [] },
{ id: "r3", code: null, fromId: "a", toId: "a", type: "Självrelation", description: null, data: {}, members: [] },
],
shifts: [{ personId: "okänd", workplaceId: null, weekday: 0, startTime: "08:00", endTime: "16:00", weeks: "ALL", label: null, scheduleCode: null }],
});
const files = new Map([["skräp.png", new TextEncoder().encode("det här är ingen bild")]]);
const result = await importBook(ownerId, data, files);
expect(result).toMatchObject({ entities: 2, relations: 1, shifts: 0, skippedImages: 2, skippedLinks: 3 });
const relations = await prisma.relation.findMany({ where: { bookId: result.bookId }, include: { members: true } });
expect(relations).toHaveLength(1);
expect(relations[0].members).toHaveLength(0);
});
it("behåller giltiga ID men ger nya åt dubbletter och felaktiga", async () => {
const data = validExport({
entities: [
entityRow("a", "CHARACTER", "Anna", { code: "KI-0007" }),
entityRow("b", "CHARACTER", "Bo", { code: "KI-0007" }), // dubblett
entityRow("c", "CHARACTER", "Cia", { code: "FEL-1" }), // fel format
entityRow("d", "CHARACTER", "Dan", { code: "FI-0002" }), // fel prefix för en karaktär
entityRow("e", "CHARACTER", "Eva", { code: null }),
entityRow("f", "APP", "En app", { code: "KI-0001" }), // appar har inget ID
],
});
const result = await importBook(ownerId, data, new Map());
const rows = await prisma.entity.findMany({ where: { bookId: result.bookId }, orderBy: { name: "asc" } });
const code = (name: string) => rows.find((e) => e.name === name)!.code;
expect(code("Anna")).toBe("KI-0007");
expect(code("En app")).toBeNull();
const assigned = ["Bo", "Cia", "Dan", "Eva"].map(code);
expect(new Set([...assigned, "KI-0007"]).size).toBe(5); // alla unika
expect(assigned.every((c) => /^KI-\d{4}$/.test(c!))).toBe(true);
// Nya nummer fortsätter efter det högsta som användes
expect(assigned.sort()).toEqual(["KI-0008", "KI-0009", "KI-0010", "KI-0011"]);
});
it("tar bort de sparade bilderna igen om importen misslyckas", async () => {
const image = await makeImage(40, 40, "png");
const before = await filesIn(UPLOAD_DIR);
// Samma id två gånger gör att databasen avvisar raderna (unik nyckel) efter att bilderna sparats
const data = validExport({
entities: [entityRow("dubbel", "CHARACTER", "A", { image: "a.png" }), entityRow("dubbel", "CHARACTER", "B", { image: "b.png" })],
});
await expect(importBook(ownerId, data, new Map([["a.png", image], ["b.png", image]]))).rejects.toThrow();
expect(await filesIn(UPLOAD_DIR)).toEqual(before);
expect(await prisma.book.count({ where: { title: "Testbok (import)" } })).toBe(0);
});
});
+199
View File
@@ -0,0 +1,199 @@
import { readdir } from "node:fs/promises";
import { beforeEach, describe, expect, it } from "vitest";
import { UPLOAD_DIR, saveImageBytes } from "@/lib/files";
import { nextMapCode, nextMarkerCode, nextScheduleCode } from "@/lib/ids";
import { TRASH_DIR, TRASH_DAYS, emptyBookTrash, purgeExpiredTrash, purgeTrashItem, restoreBook, restoreEntity, trashBook, trashEntity } from "@/lib/trash";
import { makeImage } from "../helpers/fixtures";
import { describeDb, filesIn, makeBook, makeEntity, makeRelation, makeUser, prisma, resetAll } from "../helpers/db";
describeDb("papperskorg", () => {
let ownerId: string;
let bookId: string;
let anna: { id: string; code: string | null };
let erik: { id: string };
let cafe: { id: string };
let relationId: string;
let markerId: string;
let hostedShiftId: string;
beforeEach(async () => {
await resetAll();
ownerId = (await makeUser()).id;
bookId = (await makeBook(ownerId)).id;
const image = await saveImageBytes(await makeImage(80, 60, "png"));
anna = await makeEntity(bookId, "CHARACTER", "Anna", { imageFile: image, data: { age: 30 } });
erik = await makeEntity(bookId, "CHARACTER", "Erik");
cafe = await makeEntity(bookId, "PREMISES", "Café");
const company = await makeEntity(bookId, "COMPANY", "Firma");
// Anna är med i en relation som parti, i en annan som extra deltagare, har egna pass och är arbetsplats åt ett pass
relationId = (await makeRelation(bookId, anna.id, erik.id, "Vänner", [cafe.id])).id;
await makeRelation(bookId, erik.id, company.id, "Jobbar på", [anna.id]);
const code = await nextScheduleCode(bookId);
await prisma.shift.create({ data: { bookId, personId: anna.id, workplaceId: cafe.id, weekday: 0, startTime: "08:00", endTime: "16:00", scheduleCode: code } });
hostedShiftId = (await prisma.shift.create({ data: { bookId, personId: erik.id, workplaceId: anna.id, weekday: 1, startTime: "09:00", endTime: "17:00", scheduleCode: code } })).id;
const map = await prisma.bookMap.create({ data: { bookId, name: "Karta", kind: "GEO", code: await nextMapCode(bookId, "GEO") } });
markerId = (await prisma.marker.create({ data: { mapId: map.id, entityId: anna.id, label: "Annas hus", code: await nextMarkerCode(bookId), lat: 1, lng: 2 } })).id;
});
describe("poster", () => {
it("flyttar posten till papperskorgen och tar bort den ur boken", async () => {
await trashEntity(ownerId, bookId, anna.id);
expect(await prisma.entity.findUnique({ where: { id: anna.id } })).toBeNull();
const [item] = await prisma.trashItem.findMany();
expect(item).toMatchObject({ kind: "entity", label: "Anna", detail: "CHARACTER", ownerId, bookId });
// Annas relationer och egna pass följer med bort
expect(await prisma.relation.count({ where: { id: relationId } })).toBe(0);
expect(await prisma.shift.count({ where: { personId: anna.id } })).toBe(0);
// Det som bara pekade på henne blir kvar utan koppling
expect((await prisma.shift.findUniqueOrThrow({ where: { id: hostedShiftId } })).workplaceId).toBeNull();
expect((await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).entityId).toBeNull();
});
it("behåller bilden medan posten ligger i papperskorgen", async () => {
const image = (await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } })).imageFile!;
await trashEntity(ownerId, bookId, anna.id);
expect(await filesIn(UPLOAD_DIR)).toContain(image);
});
it("återställer allt: samma id och ID-nummer, relationer, deltagande, pass, arbetsplats och markering", async () => {
await trashEntity(ownerId, bookId, anna.id);
const [item] = await prisma.trashItem.findMany();
const restored = await restoreEntity(ownerId, item.id);
expect(restored).toEqual({ bookId, entityId: anna.id });
const back = await prisma.entity.findUniqueOrThrow({ where: { id: anna.id }, include: { outgoing: { include: { members: true } }, memberOf: true, shifts: true } });
expect(back).toMatchObject({ name: "Anna", code: anna.code, data: { age: 30 } });
expect(back.imageFile).toBeTruthy();
expect(back.outgoing).toHaveLength(1);
expect(back.outgoing[0].id).toBe(relationId);
expect(back.outgoing[0].members.map((m) => m.entityId)).toEqual([cafe.id]);
expect(back.memberOf).toHaveLength(1);
expect(back.shifts).toHaveLength(1);
expect(back.shifts[0].scheduleCode).toBe("SCI-0001");
expect((await prisma.shift.findUniqueOrThrow({ where: { id: hostedShiftId } })).workplaceId).toBe(anna.id);
expect((await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).entityId).toBe(anna.id);
expect(await prisma.trashItem.count()).toBe(0);
});
it("hoppar över relationer vars andra part tagits bort under tiden", async () => {
await trashEntity(ownerId, bookId, anna.id);
await prisma.entity.delete({ where: { id: erik.id } });
const [item] = await prisma.trashItem.findMany();
await restoreEntity(ownerId, item.id);
expect(await prisma.entity.findUnique({ where: { id: anna.id } })).not.toBeNull();
expect(await prisma.relation.count({ where: { id: relationId } })).toBe(0);
});
it("ger en ny kod om den gamla hunnit tas av en annan post", async () => {
await trashEntity(ownerId, bookId, anna.id);
await prisma.entity.update({ where: { id: erik.id }, data: { code: anna.code } });
const [item] = await prisma.trashItem.findMany();
await restoreEntity(ownerId, item.id);
const back = await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } });
expect(back.code).toMatch(/^KI-\d{4}$/);
expect(back.code).not.toBe(anna.code);
});
it("kan inte återställas av någon annan, eller när boken är borta", async () => {
const intruder = await makeUser("Inkräktare");
await trashEntity(ownerId, bookId, anna.id);
const [item] = await prisma.trashItem.findMany();
expect(await restoreEntity(intruder.id, item.id)).toBeNull();
expect(await prisma.entity.count({ where: { id: anna.id } })).toBe(0);
await prisma.book.delete({ where: { id: bookId } });
expect(await restoreEntity(ownerId, item.id)).toBeNull();
});
it("rensar för gott: tar bort bilden och historiken", async () => {
const image = (await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } })).imageFile!;
await prisma.entityVersion.create({ data: { bookId, entityId: anna.id, snapshot: { name: "Gammal" } } });
await trashEntity(ownerId, bookId, anna.id);
const [item] = await prisma.trashItem.findMany();
await purgeTrashItem(ownerId, item.id);
expect(await prisma.trashItem.count()).toBe(0);
expect(await filesIn(UPLOAD_DIR)).not.toContain(image);
expect(await prisma.entityVersion.count({ where: { entityId: anna.id } })).toBe(0);
});
it("kan inte rensa någon annans papperskorg", async () => {
const intruder = await makeUser("Inkräktare");
await trashEntity(ownerId, bookId, anna.id);
const [item] = await prisma.trashItem.findMany();
await purgeTrashItem(intruder.id, item.id);
expect(await prisma.trashItem.count()).toBe(1);
});
it("tömmer bokens papperskorg men rör inga andra böcker", async () => {
const otherBook = await makeBook(ownerId, "Annan");
const stray = await makeEntity(otherBook.id, "CHARACTER", "Kvar");
await trashEntity(ownerId, bookId, erik.id);
await trashEntity(ownerId, otherBook.id, stray.id);
await emptyBookTrash(ownerId, bookId);
const left = await prisma.trashItem.findMany();
expect(left.map((i) => i.label)).toEqual(["Kvar"]);
});
it("rensar bara det som legat längre än gränsen", async () => {
await trashEntity(ownerId, bookId, erik.id);
await trashEntity(ownerId, bookId, cafe.id);
const old = await prisma.trashItem.findFirstOrThrow({ where: { label: "Erik" } });
await prisma.trashItem.update({ where: { id: old.id }, data: { deletedAt: new Date(Date.now() - (TRASH_DAYS + 1) * 86_400_000) } });
expect(await purgeExpiredTrash()).toBe(1);
expect((await prisma.trashItem.findMany()).map((i) => i.label)).toEqual(["Café"]);
});
});
describe("böcker", () => {
it("sparar boken som zip med bilderna och tar bort den", async () => {
expect(await filesIn(UPLOAD_DIR)).toHaveLength(1);
await trashBook(ownerId, bookId);
expect(await prisma.book.count()).toBe(0);
const [item] = await prisma.trashItem.findMany();
expect(item).toMatchObject({ kind: "book", label: "Testbok", ownerId });
expect(await readdir(TRASH_DIR)).toEqual([item.file]);
// Bilden ligger nu i zip-filen och inte längre bland de uppladdade
expect(await filesIn(UPLOAD_DIR)).toHaveLength(0);
});
it("återställer boken som en ny bok med allt innehåll och bilderna", async () => {
await trashBook(ownerId, bookId);
const [item] = await prisma.trashItem.findMany();
const newId = await restoreBook(ownerId, item.id);
expect(newId).toBeTruthy();
const book = await prisma.book.findUniqueOrThrow({ where: { id: newId! }, include: { entities: true, relations: true, shifts: true, maps: { include: { markers: true } } } });
expect(book.title).toBe("Testbok");
expect(book.entities).toHaveLength(4);
expect(book.relations).toHaveLength(2);
expect(book.shifts).toHaveLength(2);
expect(book.maps[0].markers).toHaveLength(1);
expect(book.entities.find((e) => e.name === "Anna")?.code).toBe(anna.code);
expect(await filesIn(UPLOAD_DIR)).toHaveLength(1);
// Papperskorgen och zip-filen är borta
expect(await prisma.trashItem.count()).toBe(0);
expect(await readdir(TRASH_DIR)).toEqual([]);
});
it("kan inte återställas av någon annan", async () => {
const intruder = await makeUser("Inkräktare");
await trashBook(ownerId, bookId);
const [item] = await prisma.trashItem.findMany();
expect(await restoreBook(intruder.id, item.id)).toBeNull();
expect(await prisma.book.count()).toBe(0);
});
it("rensar zip-filen när den tas bort för gott", async () => {
await trashBook(ownerId, bookId);
const [item] = await prisma.trashItem.findMany();
await purgeTrashItem(ownerId, item.id);
expect(await readdir(TRASH_DIR)).toEqual([]);
expect(await prisma.trashItem.count()).toBe(0);
});
});
});
+41
View File
@@ -0,0 +1,41 @@
import { execSync } from "node:child_process";
import { mkdir, rm } from "node:fs/promises";
import os from "node:os";
import path from "node:path";
import { PrismaClient } from "@prisma/client";
import { testDatabaseUrl } from "./db-url.mts";
// Körs en gång före alla tester: skapar testdatabasen om den saknas, kör migreringarna och städar filmapparna.
// Hoppar över databasen helt om ingen testdatabas är konfigurerad (databastesterna hoppas då över).
export default async function setup() {
const dataDir = path.join(os.tmpdir(), "bookmanager-test-data");
await rm(dataDir, { recursive: true, force: true });
await mkdir(dataDir, { recursive: true });
const databaseUrl = testDatabaseUrl();
if (!databaseUrl) {
console.warn("\n[tester] Ingen databas konfigurerad. Databastesterna hoppas över (sätt DATABASE_URL eller TEST_DATABASE_URL).\n");
return async () => {};
}
const url = new URL(databaseUrl);
const name = decodeURIComponent(url.pathname.slice(1));
if (!name.endsWith("_test")) throw new Error(`Avbryter: databasen "${name}" slutar inte på _test`);
// Skapa databasen via en anslutning till standarddatabasen "postgres"
const admin = new URL(databaseUrl);
admin.pathname = "/postgres";
const client = new PrismaClient({ datasources: { db: { url: admin.toString() } } });
try {
const exists = await client.$queryRaw<{ datname: string }[]>`SELECT datname FROM pg_database WHERE datname = ${name}`;
if (exists.length === 0) await client.$executeRawUnsafe(`CREATE DATABASE "${name.replace(/"/g, "")}"`);
} finally {
await client.$disconnect();
}
execSync("npx prisma migrate deploy", { env: { ...process.env, DATABASE_URL: databaseUrl }, stdio: "pipe" });
return async () => {
await rm(dataDir, { recursive: true, force: true });
};
}
+63
View File
@@ -0,0 +1,63 @@
import { randomUUID } from "node:crypto";
import { mkdir, readdir, rm } from "node:fs/promises";
import type { EntityKind, Prisma } from "@prisma/client";
import { describe } from "vitest";
import { prisma } from "@/lib/db";
import { UPLOAD_DIR } from "@/lib/files";
import { nextEntityCode, nextRelationCode } from "@/lib/ids";
import { BACKUP_DIR } from "@/lib/backup";
import { TRASH_DIR } from "@/lib/trash";
export { prisma };
/** Databastester körs bara när en testdatabas är konfigurerad (se vitest.config.ts). */
export const hasDb = Boolean(process.env.DATABASE_URL);
export const describeDb = hasDb ? describe : describe.skip;
/** Tömmer alla tabeller och filmapparna. Kräver att databasens namn slutar på _test. */
export async function resetAll() {
const [{ current_database: name }] = await prisma.$queryRaw<{ current_database: string }[]>`SELECT current_database()`;
if (!name.endsWith("_test")) throw new Error(`Vägrar tömma databasen "${name}": namnet slutar inte på _test`);
const tables = await prisma.$queryRaw<{ tablename: string }[]>`SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename <> '_prisma_migrations'`;
if (tables.length > 0) {
await prisma.$executeRawUnsafe(`TRUNCATE TABLE ${tables.map((t) => `"${t.tablename}"`).join(", ")} RESTART IDENTITY CASCADE`);
}
for (const dir of [UPLOAD_DIR, BACKUP_DIR, TRASH_DIR]) {
await rm(dir, { recursive: true, force: true });
await mkdir(dir, { recursive: true });
}
}
export async function filesIn(dir: string): Promise<string[]> {
try {
return (await readdir(dir)).filter((f) => f !== "thumbs").sort();
} catch {
return [];
}
}
export async function makeUser(name = "Tester", email: string | null = `${name.toLowerCase()}@example.com`) {
return prisma.user.create({ data: { externalId: `test:${randomUUID()}`, name, email } });
}
export async function makeBook(ownerId: string, title = "Testbok") {
return prisma.book.create({ data: { ownerId, title } });
}
export async function makeEntity(
bookId: string,
kind: EntityKind,
name: string,
extra: { data?: Prisma.InputJsonObject; imageFile?: string | null; tags?: string[]; summary?: string } = {},
) {
return prisma.entity.create({
data: { bookId, kind, name, code: await nextEntityCode(bookId, kind), tags: extra.tags ?? [], data: extra.data ?? {}, imageFile: extra.imageFile ?? null, summary: extra.summary ?? null },
});
}
export async function makeRelation(bookId: string, fromId: string, toId: string, type = "Vänner", memberIds: string[] = []) {
return prisma.relation.create({
data: { bookId, fromId, toId, type, code: await nextRelationCode(bookId), members: { create: memberIds.map((entityId) => ({ entityId })) } },
});
}
+38
View File
@@ -0,0 +1,38 @@
import sharp from "sharp";
import type { ExportData } from "@/lib/book-transfer";
/** En giltig minimal exportfil. Åsidosätt delar för att testa enskilda fall. */
export function validExport(overrides: Partial<ExportData> = {}): ExportData {
return {
format: "bookmanager-export",
version: 1,
exportedAt: "2026-01-01T00:00:00.000Z",
includesImages: false,
book: { title: "Testbok", subtitle: null, genre: null, description: null },
entities: [],
relations: [],
shifts: [],
maps: [],
templates: [],
...overrides,
};
}
export function entityRow(id: string, kind: ExportData["entities"][number]["kind"], name: string, extra: Partial<ExportData["entities"][number]> = {}): ExportData["entities"][number] {
return { id, kind, name, code: null, summary: null, tags: [], data: {}, image: null, ...extra };
}
/** En riktig bild (PNG, JPEG eller WebP) av önskad storlek, för tester av bildbehandling och uppladdning. */
export async function makeImage(
width: number,
height: number,
format: "png" | "jpeg" | "webp" = "png",
options: { orientation?: number } = {},
): Promise<Uint8Array> {
let pipeline = sharp({ create: { width, height, channels: 3, background: { r: 200, g: 60, b: 60 } } });
if (format === "png") pipeline = pipeline.png();
else if (format === "jpeg") pipeline = pipeline.jpeg({ quality: 40 });
else pipeline = pipeline.webp({ quality: 40 });
if (options.orientation) pipeline = pipeline.withMetadata({ orientation: options.orientation });
return new Uint8Array(await pipeline.toBuffer());
}
+22
View File
@@ -0,0 +1,22 @@
import { describe, expect, it } from "vitest";
import { formatBytes, formatDuration } from "@/lib/format";
describe("formatBytes", () => {
it("visar storlekar med svenskt decimaltecken", () => {
expect(formatBytes(0)).toBe("0 B");
expect(formatBytes(1023)).toBe("1023 B");
expect(formatBytes(1536)).toBe("1,5 KB");
expect(formatBytes(1024 * 1024)).toBe("1,0 MB");
expect(formatBytes(150 * 1024 * 1024)).toBe("150 MB");
expect(formatBytes(3 * 1024 ** 3)).toBe("3,0 GB");
});
});
describe("formatDuration", () => {
it("visar dagar, timmar och minuter", () => {
expect(formatDuration(59)).toBe("0 min");
expect(formatDuration(3600)).toBe("1 h 0 min");
expect(formatDuration(93784)).toBe("1 d 2 h 3 min");
expect(formatDuration(86400)).toBe("1 d 0 h 0 min");
});
});
+59
View File
@@ -0,0 +1,59 @@
import { describe, expect, it } from "vitest";
import { diffSnapshots, sameSnapshot, snapshotOf, type Snapshot } from "@/lib/history";
import type { FieldDef } from "@/lib/templates";
const labels = { name: "Namn", summary: "Sammanfattning", tags: "Taggar" };
const fields: FieldDef[] = [
{ key: "age", label: "Ålder", type: "number" },
{ key: "alive", label: "Vid liv", type: "checkbox" },
];
const base: Snapshot = { name: "Anna", summary: null, tags: ["a"], data: { age: 30, alive: true } };
describe("snapshotOf", () => {
it("normaliserar saknad sammanfattning och ogiltig data", () => {
expect(snapshotOf({ name: "A", summary: null, tags: [], data: null })).toEqual({ name: "A", summary: null, tags: [], data: {} });
expect(snapshotOf({ name: "A", summary: "x", tags: ["t"], data: [1, 2] }).data).toEqual({});
expect(snapshotOf({ name: "A", summary: "x", tags: [], data: { k: 1 } }).data).toEqual({ k: 1 });
});
});
describe("sameSnapshot", () => {
it("är oberoende av nyckelordningen i data", () => {
const a = { ...base, data: { age: 30, alive: true } };
const b = { ...base, data: { alive: true, age: 30 } };
expect(sameSnapshot(a, b)).toBe(true);
});
it("upptäcker ändringar i namn, taggar och data", () => {
expect(sameSnapshot(base, { ...base, name: "Bo" })).toBe(false);
expect(sameSnapshot(base, { ...base, tags: ["a", "b"] })).toBe(false);
expect(sameSnapshot(base, { ...base, data: { age: 31, alive: true } })).toBe(false);
expect(sameSnapshot(base, { ...base })).toBe(true);
});
});
describe("diffSnapshots", () => {
it("ger inga skillnader när inget ändrats", () => {
expect(diffSnapshots(base, { ...base }, fields, labels)).toEqual([]);
});
it("namnger fälten med mallens rubriker", () => {
const changes = diffSnapshots(base, { ...base, name: "Anna L", data: { age: 31, alive: true } }, fields, labels);
expect(changes).toEqual([
{ label: "Namn", before: "Anna", after: "Anna L" },
{ label: "Ålder", before: "30", after: "31" },
]);
});
it("visar taggar som lista, kryssrutor som bock och tomt som tomt", () => {
const changes = diffSnapshots(base, { ...base, tags: ["a", "b"], summary: "ny", data: { age: 30, alive: false } }, fields, labels);
expect(changes).toContainEqual({ label: "Taggar", before: "a", after: "a, b" });
expect(changes).toContainEqual({ label: "Sammanfattning", before: "", after: "ny" });
expect(changes).toContainEqual({ label: "Vid liv", before: "✓", after: "" });
});
it("tar med värden för fält som inte längre finns i mallen", () => {
const changes = diffSnapshots({ ...base, data: { ...base.data, gammal: "x" } }, base, fields, labels);
expect(changes).toEqual([{ label: "gammal", before: "x", after: "" }]);
});
});
+40
View File
@@ -0,0 +1,40 @@
import { describe, expect, it } from "vitest";
import { ENTITY_PREFIX, mapLetter, pad } from "@/lib/ids";
import { KINDS } from "@/lib/kinds";
describe("ID-prefix", () => {
it("varje posttyp med ID har ett eget prefix", () => {
const prefixes = Object.values(ENTITY_PREFIX);
expect(new Set(prefixes).size).toBe(prefixes.length);
});
it("alla typer utom appar och hemsidor får ID", () => {
const without = KINDS.filter((k) => !ENTITY_PREFIX[k.kind]).map((k) => k.kind);
expect(without.sort()).toEqual(["APP", "WEBSITE"]);
});
it("följer ID-översikten", () => {
expect(ENTITY_PREFIX.CHARACTER).toBe("KI");
expect(ENTITY_PREFIX.COMPANY).toBe("FI");
expect(ENTITY_PREFIX.HOME).toBe("BI");
expect(ENTITY_PREFIX.PET).toBe("DI");
expect(ENTITY_PREFIX.PREMISES).toBe("LI");
expect(ENTITY_PREFIX.EDUCATION).toBe("UI");
expect(ENTITY_PREFIX.VEHICLE).toBe("FD");
expect(ENTITY_PREFIX.RESEARCH).toBe("RI");
expect(ENTITY_PREFIX.REFERENCE).toBe("RD");
expect(ENTITY_PREFIX.SKETCH).toBe("SI");
});
it("kartans bokstav följer typen", () => {
expect(mapLetter("GEO")).toBe("R");
expect(mapLetter("IMAGE")).toBe("E");
});
it("siffrorna fylls ut till fyra och växer vid behov", () => {
expect(pad(1)).toBe("0001");
expect(pad(42)).toBe("0042");
expect(pad(9999)).toBe("9999");
expect(pad(12345)).toBe("12345");
});
});
+79
View File
@@ -0,0 +1,79 @@
import sharp from "sharp";
import { describe, expect, it } from "vitest";
import { detectImageExt, makeThumbnail, optimizeImage } from "@/lib/images";
import { makeImage } from "../helpers/fixtures";
describe("detectImageExt", () => {
it("känner igen bildtyper på de första byten, inte på namnet", async () => {
expect(detectImageExt(await makeImage(4, 4, "png"))).toBe("png");
expect(detectImageExt(await makeImage(4, 4, "jpeg"))).toBe("jpg");
expect(detectImageExt(await makeImage(4, 4, "webp"))).toBe("webp");
expect(detectImageExt(new TextEncoder().encode("GIF89a......"))).toBe("gif");
});
it("avvisar annat än bilder", () => {
expect(detectImageExt(new TextEncoder().encode("<svg xmlns='http://www.w3.org/2000/svg'></svg>"))).toBeNull();
expect(detectImageExt(new TextEncoder().encode("#!/bin/sh\necho hej"))).toBeNull();
expect(detectImageExt(new Uint8Array([]))).toBeNull();
expect(detectImageExt(new Uint8Array([0x89, 0x50]))).toBeNull();
});
});
describe("optimizeImage", () => {
it("skalar ned stora bilder till högst 2400 px på längsta sidan", async () => {
const result = await optimizeImage(await makeImage(3600, 1800, "jpeg"), "entity");
const meta = await sharp(result!.bytes).metadata();
expect(result!.ext).toBe("jpg");
expect(meta.width).toBe(2400);
expect(meta.height).toBe(1200);
});
it("lämnar små bilder i storlek", async () => {
const result = await optimizeImage(await makeImage(300, 200, "png"), "entity");
const meta = await sharp(result!.bytes).metadata();
expect([meta.width, meta.height]).toEqual([300, 200]);
expect(result!.ext).toBe("png");
});
it("roterar efter EXIF och tar bort metadata", async () => {
const input = await makeImage(300, 200, "jpeg", { orientation: 6 });
expect((await sharp(input).metadata()).orientation).toBe(6);
const result = await optimizeImage(input, "entity");
const meta = await sharp(result!.bytes).metadata();
// 300x200 med rotation 90 grader blir 200x300, och orienteringsflaggan är borta
expect([meta.width, meta.height]).toEqual([200, 300]);
expect(meta.orientation).toBeUndefined();
expect(meta.exif).toBeUndefined();
});
it("kartbilder får behålla mer upplösning än porträtt", async () => {
const map = await optimizeImage(await makeImage(3000, 2000, "png"), "map");
expect((await sharp(map!.bytes).metadata()).width).toBe(3000);
const portrait = await optimizeImage(await makeImage(3000, 2000, "png"), "entity");
expect((await sharp(portrait!.bytes).metadata()).width).toBe(2400);
});
it("lämnar GIF orörd", async () => {
const gif = new TextEncoder().encode("GIF89a\x01\x00\x01\x00\x00\x00\x00;");
const result = await optimizeImage(gif, "entity");
expect(result?.ext).toBe("gif");
expect(Array.from(result!.bytes)).toEqual(Array.from(gif));
});
it("avvisar filer som inte är bilder eller är skadade", async () => {
expect(await optimizeImage(new TextEncoder().encode("hej"), "entity")).toBeNull();
const png = await makeImage(50, 50, "png");
expect(await optimizeImage(png.slice(0, 40), "entity")).toBeNull(); // avklippt bild
});
});
describe("makeThumbnail", () => {
it("ger en liten WebP-bild med högst 480 px", async () => {
const thumb = await makeThumbnail(await makeImage(2000, 1000, "jpeg"));
const meta = await sharp(thumb).metadata();
expect(meta.format).toBe("webp");
expect(meta.width).toBe(480);
expect(meta.height).toBe(240);
});
});
+138
View File
@@ -0,0 +1,138 @@
import { strToU8, zipSync } from "fflate";
import { describe, expect, it } from "vitest";
import { ImportError, parseExport, readImportFile, type ImportErrorCode } from "@/lib/book-transfer";
import { entityRow, validExport } from "../helpers/fixtures";
function codeOf(fn: () => unknown): ImportErrorCode | "no-error" {
try {
fn();
return "no-error";
} catch (error) {
if (error instanceof ImportError) return error.code;
throw error;
}
}
const json = (data: unknown) => new TextEncoder().encode(JSON.stringify(data));
const zip = (entries: Record<string, Uint8Array>) => zipSync(entries);
describe("parseExport", () => {
it("godkänner en minimal exportfil", () => {
const parsed = parseExport(validExport());
expect(parsed.book.title).toBe("Testbok");
expect(parsed.entities).toEqual([]);
});
it("avvisar annat än en exportfil", () => {
expect(codeOf(() => parseExport(null))).toBe("not-export");
expect(codeOf(() => parseExport([]))).toBe("not-export");
expect(codeOf(() => parseExport({ a: 1 }))).toBe("not-export");
expect(codeOf(() => parseExport({ ...validExport(), format: "annat" }))).toBe("not-export");
});
it("avvisar okänd version", () => {
expect(codeOf(() => parseExport({ ...validExport(), version: 2 }))).toBe("version");
});
it("kräver en boktitel", () => {
expect(codeOf(() => parseExport({ ...validExport(), book: { title: " " } }))).toBe("invalid");
expect(codeOf(() => parseExport({ ...validExport(), book: undefined }))).toBe("invalid");
});
it("avvisar poster med okänd typ, saknat id eller saknat namn", () => {
expect(codeOf(() => parseExport({ ...validExport(), entities: [{ id: "a", kind: "DRAGON", name: "X" }] }))).toBe("invalid");
expect(codeOf(() => parseExport({ ...validExport(), entities: [{ kind: "CHARACTER", name: "X" }] }))).toBe("invalid");
expect(codeOf(() => parseExport({ ...validExport(), entities: [{ id: "a", kind: "CHARACTER", name: "" }] }))).toBe("invalid");
expect(codeOf(() => parseExport({ ...validExport(), entities: ["x"] }))).toBe("invalid");
});
it("rensar och begränsar fält", () => {
const parsed = parseExport({
...validExport(),
entities: [{ id: "a", kind: "CHARACTER", name: ` ${"x".repeat(300)} `, tags: ["ok", "", 5, "y".repeat(100)], data: "inte ett objekt" }],
});
expect(parsed.entities[0].name).toHaveLength(200);
expect(parsed.entities[0].tags).toEqual(["ok", "y".repeat(40)]);
expect(parsed.entities[0].data).toEqual({});
});
it("avvisar för många poster", () => {
expect(codeOf(() => parseExport({ ...validExport(), entities: new Array(20001).fill(0) }))).toBe("too-large");
});
it("kontrollerar pass: veckodag och tider", () => {
const shift = { personId: "a", workplaceId: null, weekday: 0, startTime: "08:00", endTime: "16:00", weeks: "ALL", label: null, scheduleCode: null };
expect(parseExport({ ...validExport(), shifts: [shift] }).shifts).toHaveLength(1);
expect(codeOf(() => parseExport({ ...validExport(), shifts: [{ ...shift, weekday: 7 }] }))).toBe("invalid");
expect(codeOf(() => parseExport({ ...validExport(), shifts: [{ ...shift, startTime: "25:00" }] }))).toBe("invalid");
expect(parseExport({ ...validExport(), shifts: [{ ...shift, weeks: "knas" }] }).shifts[0].weeks).toBe("ALL");
});
it("kontrollerar kartor och markeringar", () => {
const marker = { code: null, entityId: null, label: "M", note: null, color: "neon", lat: 1, lng: 2 };
const map = { id: "m", code: null, name: "Karta", kind: "GEO", image: null, centerLat: null, centerLng: null, zoom: 3.7, markers: [marker] };
const parsed = parseExport({ ...validExport(), maps: [map] });
expect(parsed.maps[0].markers[0].color).toBe("blue"); // okänd färg blir standardfärg
expect(parsed.maps[0].zoom).toBe(4);
expect(codeOf(() => parseExport({ ...validExport(), maps: [{ ...map, markers: [{ ...marker, lat: "x" }] }] }))).toBe("invalid");
expect(parseExport({ ...validExport(), maps: [{ ...map, kind: "vad som helst" }] }).maps[0].kind).toBe("GEO");
});
it("hoppar över trasiga mallar utan att avvisa filen", () => {
const parsed = parseExport({
...validExport(),
templates: [
{ kind: "CHARACTER", fields: [{ key: "ok", label: "Ok", type: "text" }] },
{ kind: "HOME", fields: "trasig" },
{ kind: "NOPE", fields: [] },
"skräp",
],
});
expect(parsed.templates).toHaveLength(1);
expect(parsed.templates[0].kind).toBe("CHARACTER");
});
});
describe("readImportFile", () => {
const valid = validExport({ entities: [entityRow("e1", "CHARACTER", "Anna")] });
it("läser ren JSON, även med BOM", () => {
expect(readImportFile(json(valid)).data.entities).toHaveLength(1);
const withBom = new Uint8Array([0xef, 0xbb, 0xbf, ...json(valid)]);
expect(readImportFile(withBom).data.book.title).toBe("Testbok");
});
it("läser en zip med book.json och bilder", () => {
const image = new Uint8Array([1, 2, 3]);
const { data, files } = readImportFile(zip({ "book.json": json(valid), "files/a.png": image }));
expect(data.entities[0].name).toBe("Anna");
expect(Array.from(files.keys())).toEqual(["a.png"]);
});
it("ignorerar allt i zip-filen utom book.json och files/", () => {
const { files } = readImportFile(
zip({
"book.json": json(valid),
"files/ok.png": new Uint8Array([1]),
"files/undermapp/inne.png": new Uint8Array([2]),
"annat/fil.png": new Uint8Array([3]),
"hemlig.txt": new Uint8Array([4]),
}),
);
expect(Array.from(files.keys())).toEqual(["ok.png"]);
});
it("hoppar över bilder som är större än gränsen", () => {
const big = new Uint8Array(17 * 1024 * 1024); // komprimeras till nästan inget men packas inte upp
const { files } = readImportFile(zip({ "book.json": json(valid), "files/stor.png": big, "files/liten.png": new Uint8Array([1]) }));
expect(Array.from(files.keys())).toEqual(["liten.png"]);
});
it("ger tydliga fel", () => {
expect(codeOf(() => readImportFile(new Uint8Array([])))).toBe("empty");
expect(codeOf(() => readImportFile(new TextEncoder().encode("det här är inte JSON")))).toBe("invalid");
expect(codeOf(() => readImportFile(new Uint8Array([0x50, 0x4b, 3, 4, 1, 2, 3])))).toBe("invalid"); // trasig zip
expect(codeOf(() => readImportFile(zip({ "annat.txt": strToU8("hej") })))).toBe("not-export");
expect(codeOf(() => readImportFile(json({ a: 1 })))).toBe("not-export");
});
});
+97
View File
@@ -0,0 +1,97 @@
import { describe, expect, it } from "vitest";
import { normalizeName } from "@/lib/name-stats";
import { BUILT_IN_POOLS, FEMALE_NAMES, MALE_NAMES, SURNAMES, generateName, generateNames, type NamePools } from "@/lib/names";
/** Förutsägbar slumpföljd: ger värdena i tur och ordning, om och om igen. */
const sequence = (...values: number[]) => {
let i = 0;
return () => values[i++ % values.length];
};
describe("inbyggda namnlistor", () => {
it("har inga dubbletter och inget namn finns i båda könen", () => {
for (const list of [FEMALE_NAMES, MALE_NAMES, SURNAMES]) expect(new Set(list).size).toBe(list.length);
expect(FEMALE_NAMES.filter((n) => MALE_NAMES.includes(n))).toEqual([]);
});
it("är tillräckligt stora", () => {
expect(FEMALE_NAMES.length).toBeGreaterThan(100);
expect(MALE_NAMES.length).toBeGreaterThan(100);
expect(SURNAMES.length).toBeGreaterThan(100);
});
});
describe("generateName", () => {
const options = { gender: "female", middleName: false, surname: "all" } as const;
it("väljer förnamn efter kön", () => {
for (let i = 0; i < 50; i++) {
expect(FEMALE_NAMES).toContain(generateName({ ...options, gender: "female" }).split(" ")[0]);
expect(MALE_NAMES).toContain(generateName({ ...options, gender: "male" }).split(" ")[0]);
}
});
it("slumpar kön när det är valfritt", () => {
const female = generateName({ ...options, gender: "any" }, BUILT_IN_POOLS, sequence(0.1, 0, 0));
const male = generateName({ ...options, gender: "any" }, BUILT_IN_POOLS, sequence(0.9, 0, 0));
expect(FEMALE_NAMES).toContain(female.split(" ")[0]);
expect(MALE_NAMES).toContain(male.split(" ")[0]);
});
it("filtrerar efternamn på -son", () => {
for (let i = 0; i < 50; i++) {
expect(generateName({ ...options, surname: "son" }).endsWith("son")).toBe(true);
expect(generateName({ ...options, surname: "other" }).endsWith("son")).toBe(false);
}
});
it("lägger till ett mellannamn när det önskas", () => {
const name = generateName({ ...options, middleName: true }, BUILT_IN_POOLS, sequence(0, 0.5, 0.9));
expect(name.split(" ")).toHaveLength(3);
});
it("hoppar över mellannamnet om det blev samma som förnamnet", () => {
const name = generateName({ ...options, middleName: true }, BUILT_IN_POOLS, sequence(0, 0, 0));
expect(name.split(" ")).toHaveLength(2);
});
it("viktar efter hur vanligt namnet är", () => {
const pools: NamePools = { female: [["Vanlig", 1000], ["Ovanlig", 1]], male: [["X", 1]], surnames: [["Andersson", 1]] };
expect(generateName(options, pools, () => 0.5)).toBe("Vanlig Andersson");
expect(generateName(options, pools, () => 0.9999)).toBe("Ovanlig Andersson");
});
it("faller tillbaka på alla efternamn om filtret inte ger något", () => {
const pools: NamePools = { female: [["Anna", 1]], male: [["Erik", 1]], surnames: [["Lindqvist", 1]] };
expect(generateName({ ...options, surname: "son" }, pools)).toBe("Anna Lindqvist");
});
it("generateNames ger unika namn och högst begärt antal", () => {
const names = generateNames({ gender: "any", middleName: false, surname: "all" }, 20);
expect(names).toHaveLength(20);
expect(new Set(names).size).toBe(20);
const few = generateNames(options, 5, { female: [["Anna", 1]], male: [["Erik", 1]], surnames: [["A", 1]] });
expect(few).toEqual(["Anna A"]);
});
});
describe("normalizeName (statistik från SCB)", () => {
it("gör versaler till vanlig skrivning", () => {
expect(normalizeName("JACOB")).toBe("Jacob");
expect(normalizeName("ÅSA")).toBe("Åsa");
expect(normalizeName("ANN-MARIE")).toBe("Ann-Marie");
});
it("låter vanlig skrivning vara", () => {
expect(normalizeName("Anna")).toBe("Anna");
expect(normalizeName("Ann-Marie")).toBe("Ann-Marie");
expect(normalizeName(" Erik ")).toBe("Erik");
expect(normalizeName("O'Neil")).toBe("O'Neil");
});
it("avvisar namn med mellanslag, siffror eller konstiga tecken", () => {
for (const bad of ["", " ", "Mc Donald", "1Adam", "Anna2", "A".repeat(31), "Anna@", "<b>"]) {
expect(normalizeName(bad)).toBeNull();
}
});
});
+63
View File
@@ -0,0 +1,63 @@
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { clientIp, limitRequest, rateLimit, rateLimitStats } from "@/lib/rate-limit";
beforeEach(() => vi.useFakeTimers());
afterEach(() => vi.useRealTimers());
describe("rateLimit", () => {
it("släpper igenom upp till gränsen och stoppar sedan", () => {
const key = "test-limit";
expect(rateLimit(key, 3, 1000).ok).toBe(true);
expect(rateLimit(key, 3, 1000).ok).toBe(true);
expect(rateLimit(key, 3, 1000).ok).toBe(true);
const blocked = rateLimit(key, 3, 1000);
expect(blocked.ok).toBe(false);
expect(blocked.retryAfter).toBeGreaterThanOrEqual(1);
});
it("släpper igenom igen när tidsfönstret gått ut", () => {
const key = "test-window";
for (let i = 0; i < 2; i++) rateLimit(key, 2, 1000);
expect(rateLimit(key, 2, 1000).ok).toBe(false);
vi.advanceTimersByTime(1001);
expect(rateLimit(key, 2, 1000).ok).toBe(true);
});
it("räknar varje nyckel för sig", () => {
rateLimit("a", 1, 1000);
expect(rateLimit("a", 1, 1000).ok).toBe(false);
expect(rateLimit("b", 1, 1000).ok).toBe(true);
});
it("räknar stoppade anrop", () => {
const before = rateLimitStats.blocked;
rateLimit("count", 1, 1000);
rateLimit("count", 1, 1000);
rateLimit("count", 1, 1000);
expect(rateLimitStats.blocked).toBe(before + 2);
});
});
describe("clientIp och limitRequest", () => {
const request = (headers: Record<string, string>) => new Request("http://localhost/x", { headers });
it("läser första adressen i x-forwarded-for", () => {
expect(clientIp(request({ "x-forwarded-for": "1.2.3.4, 10.0.0.1" }))).toBe("1.2.3.4");
expect(clientIp(request({ "x-real-ip": "5.6.7.8" }))).toBe("5.6.7.8");
expect(clientIp(request({}))).toBe("unknown");
});
it("svarar 429 med Retry-After när gränsen är nådd", () => {
const req = request({ "x-forwarded-for": "9.9.9.9" });
expect(limitRequest(req, "route", 1, 60_000)).toBeNull();
const response = limitRequest(req, "route", 1, 60_000);
expect(response?.status).toBe(429);
expect(Number(response?.headers.get("Retry-After"))).toBeGreaterThanOrEqual(1);
});
it("begränsar per IP-adress", () => {
expect(limitRequest(request({ "x-forwarded-for": "1.1.1.1" }), "ip-route", 1, 60_000)).toBeNull();
expect(limitRequest(request({ "x-forwarded-for": "2.2.2.2" }), "ip-route", 1, 60_000)).toBeNull();
expect(limitRequest(request({ "x-forwarded-for": "1.1.1.1" }), "ip-route", 1, 60_000)).not.toBeNull();
});
});
+59
View File
@@ -0,0 +1,59 @@
import { afterEach, describe, expect, it, vi } from "vitest";
import { contentSecurityPolicy, runtimeSecurityHeaders } from "@/lib/security";
afterEach(() => vi.unstubAllEnvs());
const directive = (csp: string, name: string) => csp.split("; ").find((d) => d.startsWith(`${name} `)) ?? "";
describe("Content-Security-Policy", () => {
it("släpper igenom OpenStreetMap som standard", () => {
vi.stubEnv("MAP_TILE_URL", "");
vi.stubEnv("MAP_GEOCODER_URL", "");
// Tomma värden (t.ex. "MAP_TILE_URL=" i .env) ska ge standard
const csp = contentSecurityPolicy();
expect(directive(csp, "img-src")).toContain("https://tile.openstreetmap.org");
expect(directive(csp, "connect-src")).toContain("https://nominatim.openstreetmap.org");
expect(csp).toContain("frame-ancestors 'none'");
expect(csp).toContain("object-src 'none'");
expect(csp).toContain("base-uri 'self'");
});
it("använder adresserna från MAP_TILE_URL och MAP_GEOCODER_URL", () => {
vi.stubEnv("MAP_TILE_URL", "https://tiles.example.com/{z}/{x}/{y}.png");
vi.stubEnv("MAP_GEOCODER_URL", "https://geo.example.com/search");
const csp = contentSecurityPolicy();
expect(csp).toMatch(/img-src [^;]*https:\/\/tiles\.example\.com/);
expect(csp).toMatch(/connect-src [^;]*https:\/\/geo\.example\.com/);
expect(csp).not.toContain("openstreetmap.org");
});
it("tillåter underdomäner när tilladressen har {s}", () => {
vi.stubEnv("MAP_TILE_URL", "https://{s}.tiles.example.com/{z}/{x}/{y}.png");
expect(contentSecurityPolicy()).toContain("https://*.tiles.example.com");
});
it("tillåter inte eval i produktion men gör det vid utveckling", () => {
vi.stubEnv("NODE_ENV", "production");
expect(contentSecurityPolicy()).not.toContain("unsafe-eval");
vi.stubEnv("NODE_ENV", "development");
expect(contentSecurityPolicy()).toContain("unsafe-eval");
});
it("ignorerar en trasig adress i stället för att krascha", () => {
vi.stubEnv("MAP_TILE_URL", "inte en adress");
expect(() => contentSecurityPolicy()).not.toThrow();
});
});
describe("runtimeSecurityHeaders", () => {
it("sätter HSTS bara när AUTH_URL är https", () => {
vi.stubEnv("AUTH_URL", "https://bocker.example.com");
expect(runtimeSecurityHeaders()["Strict-Transport-Security"]).toContain("max-age=");
vi.stubEnv("AUTH_URL", "http://localhost:3000");
expect(runtimeSecurityHeaders()["Strict-Transport-Security"]).toBeUndefined();
});
it("innehåller alltid en policy", () => {
expect(runtimeSecurityHeaders()["Content-Security-Policy"]).toContain("default-src 'self'");
});
});
+119
View File
@@ -0,0 +1,119 @@
import { describe, expect, it } from "vitest";
import { KINDS } from "@/lib/kinds";
import { FIELD_TYPES, formatFieldValue, getDefaultTemplate, getPresets, validateFields } from "@/lib/templates";
const ALL_KINDS = [...KINDS.map((k) => k.kind), "RELATION" as const];
describe("standardmallar", () => {
for (const locale of ["sv", "en"] as const) {
for (const kind of ALL_KINDS) {
it(`${kind} (${locale}) har giltiga fält med unika nycklar`, () => {
const fields = getDefaultTemplate(kind, locale);
expect(fields.length).toBeGreaterThan(0);
// Mallen ska klara samma kontroll som en sparad mall
expect(validateFields(fields)).toEqual(fields);
expect(new Set(fields.map((f) => f.key)).size).toBe(fields.length);
});
}
}
it("val-fält har alternativ och kopplingsfält pekar på en känd typ", () => {
for (const kind of ALL_KINDS) {
for (const field of getDefaultTemplate(kind, "sv")) {
if (field.type === "select") expect(field.options?.length).toBeGreaterThan(0);
if (field.refKind) expect(KINDS.map((k) => k.kind)).toContain(field.refKind);
}
}
});
it("svenska och engelska mallar har samma nycklar i samma ordning", () => {
for (const kind of ALL_KINDS) {
expect(getDefaultTemplate(kind, "en").map((f) => f.key)).toEqual(getDefaultTemplate(kind, "sv").map((f) => f.key));
}
});
it("kopplingar i standardmallarna är fältet Lokal i företag och utbildning", () => {
const company = getDefaultTemplate("COMPANY", "sv").find((f) => f.key === "premises");
expect(company).toMatchObject({ type: "reference", refKind: "PREMISES" });
expect(getDefaultTemplate("EDUCATION", "sv").find((f) => f.key === "premises")).toMatchObject({ type: "reference", refKind: "PREMISES" });
});
it("den korta karaktärsmallen är en delmängd av den fulla", () => {
const full = getDefaultTemplate("CHARACTER", "sv").map((f) => f.key);
const [preset] = getPresets("CHARACTER", "sv");
expect(preset.id).toBe("short");
expect(preset.fields.length).toBeLessThan(full.length);
for (const field of preset.fields) expect(full).toContain(field.key);
expect(getPresets("HOME", "sv")).toEqual([]);
});
});
describe("validateFields", () => {
const ok = { key: "age", label: "Ålder", type: "number" };
it("godkänner en giltig mall och rensar mellanslag", () => {
expect(validateFields([{ key: " age ", label: " Ålder ", type: "number", section: " Basics " }])).toEqual([
{ key: "age", label: "Ålder", type: "number", section: "Basics" },
]);
});
it("kräver en lista", () => {
expect(() => validateFields({})).toThrow();
expect(() => validateFields("x")).toThrow();
});
it("avvisar ogiltiga nycklar", () => {
for (const key of ["", "1abc", "a-b", "a b", "å", "x".repeat(50)]) {
expect(() => validateFields([{ ...ok, key }])).toThrow();
}
});
it("avvisar dubbletter av nyckel", () => {
expect(() => validateFields([ok, { ...ok, label: "Annat" }])).toThrow(/duplicate/);
});
it("avvisar saknad rubrik och okänd typ", () => {
expect(() => validateFields([{ ...ok, label: " " }])).toThrow();
expect(() => validateFields([{ ...ok, type: "magic" }])).toThrow();
});
it("godkänner alla fälttyper", () => {
for (const type of FIELD_TYPES) expect(() => validateFields([{ key: "f", label: "F", type }])).not.toThrow();
});
it("val-fält får rensade alternativ och andra typer får inga", () => {
const [select] = validateFields([{ key: "s", label: "S", type: "select", options: [" A ", "", "B"] }]);
expect(select.options).toEqual(["A", "B"]);
const [text] = validateFields([{ key: "t", label: "T", type: "text", options: ["A"] }]);
expect(text.options).toBeUndefined();
});
it("kopplingsfält godkänner känd typ och avvisar okänd", () => {
expect(validateFields([{ key: "p", label: "P", type: "reference", refKind: "PREMISES" }])[0].refKind).toBe("PREMISES");
expect(validateFields([{ key: "p", label: "P", type: "reference" }])[0].refKind).toBeUndefined();
expect(() => validateFields([{ key: "p", label: "P", type: "reference", refKind: "NOPE" }])).toThrow();
});
it("begränsar antal fält och rubrikens längd", () => {
const many = Array.from({ length: 101 }, (_, i) => ({ key: `f${i}`, label: "F", type: "text" }));
expect(() => validateFields(many)).toThrow();
expect(validateFields([{ key: "f", label: "x".repeat(500), type: "text" }])[0].label.length).toBe(160);
});
});
describe("formatFieldValue", () => {
it("visar värden som text", () => {
const text = { key: "t", label: "T", type: "text" as const };
expect(formatFieldValue(text, "hej")).toBe("hej");
expect(formatFieldValue({ ...text, type: "number" }, 0)).toBe("0");
expect(formatFieldValue(text, null)).toBe("");
expect(formatFieldValue(text, undefined)).toBe("");
expect(formatFieldValue(text, "")).toBe("");
});
it("visar kryssrutor som bock eller tomt, och kopplingar som tomt", () => {
expect(formatFieldValue({ key: "c", label: "C", type: "checkbox" }, true)).toBe("✓");
expect(formatFieldValue({ key: "c", label: "C", type: "checkbox" }, false)).toBe("");
expect(formatFieldValue({ key: "r", label: "R", type: "reference" }, "abc")).toBe("");
});
});