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

+2
View File
@@ -10,3 +10,5 @@ docker-compose*.yml
Dockerfile Dockerfile
README.md README.md
*.tsbuildinfo *.tsbuildinfo
tests
vitest.config.mts
+23
View File
@@ -196,6 +196,29 @@ Namnen viktas efter hur vanliga de var, så en man född 1960 blir oftare Anders
- Från en posts sida kan du gå direkt till *Placera på karta*. - Från en posts sida kan du gå direkt till *Placera på karta*.
- Kartplattor och adressökning hämtas som standard från OpenStreetMaps publika servrar, som är tänkta för lätt användning. För tyngre bruk, sätt `MAP_TILE_URL` och `MAP_GEOCODER_URL` till egen eller betald tjänst. Adressökningar skickas då från webbläsaren till den tjänsten. - Kartplattor och adressökning hämtas som standard från OpenStreetMaps publika servrar, som är tänkta för lätt användning. För tyngre bruk, sätt `MAP_TILE_URL` och `MAP_GEOCODER_URL` till egen eller betald tjänst. Adressökningar skickas då från webbläsaren till den tjänsten.
## Tester
Testerna körs med Vitest (`npm test`). Det finns cirka 170 tester:
- **Enhetstester utan databas** (`tests/unit`): mallar och deras validering, ID-prefix, hastighetsbegränsning, säkerhetsrubriker, namngenerering, historikens jämförelser, bildbehandling (storlek, EXIF-rotation, borttagen metadata) och läsning och kontroll av importfiler (inklusive skydd mot för stora filer).
- **Databastester** (`tests/db`): löpande ID (även vid samtidiga anrop), export och import fram och tillbaka med bilder och kopplingar, papperskorg (poster och böcker), historikens gräns, fältvärden och kopplingskontroller, säkerhetskopiering (rensning, schema, att zip-filerna går att importera), lagringskvot, administratör och sök.
Databastesterna behöver en PostgreSQL-databas och använder alltid en **egen testdatabas** vars namn slutar på `_test`. De tömmer den mellan testerna och vägrar köra mot en databas med något annat namn, så din riktiga data berörs aldrig. Databasen skapas och migreras automatiskt första gången.
Med Docker (utvecklingsmiljön) räcker det att köra:
```bash
docker compose -f docker-compose.dev.yml exec app npm test
```
Testdatabasen blir då `bookmanager_test` i samma databasserver. Utan Docker, peka på en databasserver (användaren behöver få skapa databaser):
```bash
TEST_DATABASE_URL=postgresql://användare:lösenord@localhost:5432/bookmanager_test npm test
```
Saknas databas körs bara enhetstesterna och databastesterna hoppas över. Uppladdade filer och säkerhetskopior från testerna hamnar i en tillfällig mapp som städas bort. `npm run typecheck` kontrollerar även testfilerna.
## Struktur ## Struktur
``` ```
+40
View File
@@ -68,6 +68,46 @@ jobs:
**Valfritt:** automatisk uppdatering av prod (Watchtower, eller ett SSH-steg som bara körs på versionstaggar). Rekommendation: vänta tills flödet känns tryggt. **Valfritt:** automatisk uppdatering av prod (Watchtower, eller ett SSH-steg som bara körs på versionstaggar). Rekommendation: vänta tills flödet känns tryggt.
## Köra testerna automatiskt i Gitea Actions
Kör typkontroll och tester vid varje push och pull request, innan imagen byggs. Databastesterna behöver en PostgreSQL-tjänst; databasen måste heta något som slutar på `_test` (testerna lägger själva på `_test` om det saknas).
**Utkast till `.gitea/workflows/test.yml`**
```yaml
name: Tester
on:
push:
branches: [main]
pull_request:
jobs:
test:
runs-on: ubuntu-latest
services:
postgres:
image: postgres:16
env:
POSTGRES_USER: test
POSTGRES_PASSWORD: test
POSTGRES_DB: bookmanager
env:
DATABASE_URL: postgresql://test:test@postgres:5432/bookmanager
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: 22
cache: npm
- run: npm ci
- run: npx prisma generate
- run: npm run typecheck
- run: npm test
```
Samma `act_runner` som för publiceringen räcker. Tjänstecontainern nås som `postgres` när jobbet körs i en container; om runnern kör direkt på värden byts adressen mot `localhost` och en publicerad port. Låt publiceringsflödet vänta på testerna (`needs: test`) när båda finns på plats.
## Verifiera ## Verifiera
- Ladda upp en stor kartbild (10–15 MB). Gränsen för förfrågningar via inloggningskontrollen höjdes till 300 MB i samband med import och export, men en stor kartbild är inte testad. - Ladda upp en stor kartbild (10–15 MB). Gränsen för förfrågningar via inloggningskontrollen höjdes till 300 MB i samband med import och export, men en stor kartbild är inte testad.
+1077 -1
View File
File diff suppressed because it is too large. Load diff
+5 -2
View File
@@ -8,7 +8,9 @@
"start": "next start", "start": "next start",
"typecheck": "tsc --noEmit", "typecheck": "tsc --noEmit",
"db:deploy": "prisma migrate deploy", "db:deploy": "prisma migrate deploy",
"db:migrate": "prisma migrate dev" "db:migrate": "prisma migrate dev",
"test": "vitest run",
"test:watch": "vitest"
}, },
"dependencies": { "dependencies": {
"@fontsource-variable/inter": "^5.2.5", "@fontsource-variable/inter": "^5.2.5",
@@ -29,6 +31,7 @@
"@types/node": "^22.10.0", "@types/node": "^22.10.0",
"@types/react": "^19.1.0", "@types/react": "^19.1.0",
"@types/react-dom": "^19.1.0", "@types/react-dom": "^19.1.0",
"typescript": "^5.9.3" "typescript": "^5.9.3",
"vitest": "^5.0.5"
} }
} }
+3 -3
View File
@@ -9,9 +9,9 @@ import { fileUrl } from "@/lib/files";
import { requireBook } from "@/lib/session"; import { requireBook } from "@/lib/session";
// Standard är OpenStreetMaps publika tjänster. Byt via miljövariabler vid tyngre användning. // Standard är OpenStreetMaps publika tjänster. Byt via miljövariabler vid tyngre användning.
const TILE_URL = process.env.MAP_TILE_URL ?? "https://tile.openstreetmap.org/{z}/{x}/{y}.png"; const TILE_URL = process.env.MAP_TILE_URL || "https://tile.openstreetmap.org/{z}/{x}/{y}.png";
const TILE_ATTRIBUTION = process.env.MAP_TILE_ATTRIBUTION ?? "&copy; OpenStreetMap-bidragsgivare"; const TILE_ATTRIBUTION = process.env.MAP_TILE_ATTRIBUTION || "&copy; OpenStreetMap-bidragsgivare";
const GEOCODER_URL = process.env.MAP_GEOCODER_URL ?? "https://nominatim.openstreetmap.org/search"; const GEOCODER_URL = process.env.MAP_GEOCODER_URL || "https://nominatim.openstreetmap.org/search";
export default async function MapPage({ export default async function MapPage({
params, params,
+9 -2
View File
@@ -17,7 +17,14 @@ export const BACKUP_HOUR = Number.isInteger(hour) && hour >= 0 && hour <= 23 ? h
export const FOLDER_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}$/; export const FOLDER_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}$/;
export const BACKUP_FILE_PATTERN = /^[A-Za-z0-9._-]{1,120}\.(zip|json)$/; export const BACKUP_FILE_PATTERN = /^[A-Za-z0-9._-]{1,120}\.(zip|json)$/;
const safeName = (title: string) => title.replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-|-$/g, "").slice(0, 50) || "bok"; // Filnamnet får bara innehålla ASCII, annars avvisas det av nedladdningsrutten. å, ä och ö blir a, a och o.
export const safeName = (title: string) =>
title
.normalize("NFD")
.replace(/[̀-ͯ]/g, "")
.replace(/[^A-Za-z0-9]+/g, "-")
.replace(/^-|-$/g, "")
.slice(0, 50) || "bok";
/** Kör en säkerhetskopiering av alla böcker. Returnerar körningens id. */ /** Kör en säkerhetskopiering av alla böcker. Returnerar körningens id. */
export async function runBackup(trigger: "schedule" | "manual"): Promise<string> { export async function runBackup(trigger: "schedule" | "manual"): Promise<string> {
@@ -41,7 +48,7 @@ export async function runBackup(trigger: "schedule" | "manual"): Promise<string>
const entries: Zippable = { "book.json": strToU8(JSON.stringify(data)) }; const entries: Zippable = { "book.json": strToU8(JSON.stringify(data)) };
for (const [name, content] of files) entries[`files/${name}`] = [content, { level: 0 }]; for (const [name, content] of files) entries[`files/${name}`] = [content, { level: 0 }];
const zip = zipSync(entries); const zip = zipSync(entries);
const file = `${safeName(book.title)}-${book.id.slice(0, 8)}.zip`; const file = `${safeName(book.title)}-${book.id.slice(-8)}.zip`;
await writeFile(path.join(dir, file), zip); await writeFile(path.join(dir, file), zip);
bytes += zip.length; bytes += zip.length;
index.push({ bookId: book.id, title: book.title, owner: book.owner.name ?? book.owner.email, file, megabytes: Math.round((zip.length / 1048576) * 100) / 100 }); index.push({ bookId: book.id, title: book.title, owner: book.owner.name ?? book.owner.email, file, megabytes: Math.round((zip.length / 1048576) * 100) / 100 });
+2 -2
View File
@@ -22,7 +22,7 @@ const REFRESH_AFTER_MS = 90 * 24 * 60 * 60 * 1000;
export const maxYear = () => new Date().getFullYear() - 1; export const maxYear = () => new Date().getFullYear() - 1;
/** Gör SCB:s versaler (JACOB, MOHAMMAD) till vanlig skrivning och slår ihop dubbletter. */ /** Gör SCB:s versaler (JACOB, MOHAMMAD) till vanlig skrivning och slår ihop dubbletter. */
function normalize(raw: string): string | null { export function normalizeName(raw: string): string | null {
const name = raw.trim(); const name = raw.trim();
if (!name || name.length > 30 || /[\d\s]/.test(name) || !/^[\p{L}'-]+$/u.test(name)) return null; if (!name || name.length > 30 || /[\d\s]/.test(name) || !/^[\p{L}'-]+$/u.test(name)) return null;
return name return name
@@ -37,7 +37,7 @@ function toEntries(counts: Map<string, number>, keep?: number): Entry[] {
} }
function add(counts: Map<string, number>, rawName: string, rawCount: unknown) { function add(counts: Map<string, number>, rawName: string, rawCount: unknown) {
const name = normalize(rawName); const name = normalizeName(rawName);
const count = Number(rawCount); const count = Number(rawCount);
if (!name || !Number.isFinite(count) || count <= 0) return; if (!name || !Number.isFinite(count) || count <= 0) return;
counts.set(name, (counts.get(name) ?? 0) + count); counts.set(name, (counts.get(name) ?? 0) + count);
+2 -2
View File
@@ -16,8 +16,8 @@ function origin(url: string | undefined): string | null {
export function contentSecurityPolicy(): string { export function contentSecurityPolicy(): string {
const dev = process.env.NODE_ENV !== "production"; const dev = process.env.NODE_ENV !== "production";
const tiles = origin(process.env.MAP_TILE_URL ?? "https://tile.openstreetmap.org/{z}/{x}/{y}.png"); const tiles = origin(process.env.MAP_TILE_URL || "https://tile.openstreetmap.org/{z}/{x}/{y}.png");
const geocoder = origin(process.env.MAP_GEOCODER_URL ?? "https://nominatim.openstreetmap.org/search"); const geocoder = origin(process.env.MAP_GEOCODER_URL || "https://nominatim.openstreetmap.org/search");
const directives: Record<string, string[]> = { const directives: Record<string, string[]> = {
"default-src": ["'self'"], "default-src": ["'self'"],
+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("");
});
});
+2 -1
View File
@@ -26,7 +26,8 @@
"@/*": [ "@/*": [
"./src/*" "./src/*"
] ]
} },
"allowImportingTsExtensions": true
}, },
"include": [ "include": [
"next-env.d.ts", "next-env.d.ts",
+28
View File
@@ -0,0 +1,28 @@
import os from "node:os";
import path from "node:path";
import { defineConfig } from "vitest/config";
import { testDatabaseUrl } from "./tests/db-url.mts";
const databaseUrl = testDatabaseUrl();
const dataDir = path.join(os.tmpdir(), "bookmanager-test-data");
export default defineConfig({
resolve: { alias: { "@": path.resolve(import.meta.dirname, "src") } },
test: {
environment: "node",
include: ["tests/**/*.test.ts"],
globalSetup: ["tests/global-setup.ts"],
// Alla filer delar en databas, så de körs efter varandra
fileParallelism: false,
testTimeout: 30_000,
env: {
// Tom sträng betyder att databastesterna hoppas över
DATABASE_URL: databaseUrl ?? "",
UPLOAD_DIR: path.join(dataDir, "uploads"),
BACKUP_DIR: path.join(dataDir, "backups"),
TRASH_DIR: path.join(dataDir, "trash"),
LOG_LEVEL: "error",
ADMIN_EMAILS: "",
},
},
});