Files
bookmanager/tests/db/storage-admin-search.test.ts
bobbanandClaude Sonnet 5.5 dcb5d43429 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>
2026-11-01 23:19:30 +01:00

150 lines
6.6 KiB
TypeScript

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