Inbjudningslänkar, adressuppslag för kartregistret och närvaromärke

Böcker kan delas med en inbjudningslänk (roll, giltighetstid, en eller
flera personer, bara en hash sparas). Inloggningen går tillbaka till
inbjudan. Kartregistrets markeringar kan få position genom uppslag mot
karttjänsten, ett i sekunden. Redigeringsformulär och listor visar vem
som har något öppet för redigering. Migrering 0009.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
bobbanandClaude Sonnet 5.5 committed 2026-11-09 22:18:29 +01:00
1 parent 1fd1ce78cb
commit 5c58f70bdd
34 files changed
+1610 -30

No files matched your search

+281
View File
@@ -0,0 +1,281 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
import { createHash } from "node:crypto";
import { describeDb, makeBook, makeUser, prisma, resetAll } from "../helpers/db";
const login = vi.hoisted(() => ({ userId: "" as string }));
vi.mock("@/auth", () => ({ auth: async () => (login.userId ? { user: { id: login.userId } } : null) }));
vi.mock("next/cache", () => ({ revalidatePath: () => undefined }));
vi.mock("next/navigation", () => ({
redirect: (to: string) => {
throw new Error(`REDIRECT:${to}`);
},
notFound: () => {
throw new Error("NOT_FOUND");
},
}));
vi.mock("@/i18n/server", async () => {
const core = await import("@/i18n/core");
return { getLocale: async () => "sv", getT: async () => ({ locale: "sv", t: core.makeT(core.dictionaries.sv) }) };
});
import { createBookInvite, joinBook, revokeBookInvite } from "@/actions/invites";
import { bookAccess } from "@/lib/book-access";
import { acceptInvite, createInvite, hashToken, listInvites, newToken, previewInvite, revokeInvite } from "@/lib/invites";
const form = (fields: Record<string, string>) => {
const data = new FormData();
for (const [key, value] of Object.entries(fields)) data.append(key, value);
return data;
};
async function attempt(run: () => Promise<unknown>): Promise<string> {
try {
await run();
return "ok";
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
if (message.startsWith("REDIRECT:") || message === "NOT_FOUND") return message;
throw error;
}
}
describeDb("inbjudningslänkar", () => {
let owner: { id: string };
let admin: { id: string };
let editor: { id: string };
let guest: { id: string };
let bookId: string;
const DAY = 24 * 60 * 60 * 1000;
const asOwner = { userId: "", role: "OWNER" as const };
const make = async (role: "EDITOR" | "VIEWER" | "ADMIN" = "EDITOR", days = 7, maxUses: number | null = 1) => {
const result = await createInvite(bookId, { ...asOwner, userId: owner.id }, role, days, maxUses);
if (typeof result === "string") throw new Error(result);
return result.token;
};
beforeEach(async () => {
await resetAll();
owner = await makeUser("Ägare");
admin = await makeUser("Admin");
editor = await makeUser("Redaktör");
guest = await makeUser("Gäst");
bookId = (await makeBook(owner.id, "Delad bok")).id;
await prisma.bookMember.createMany({
data: [
{ bookId, userId: admin.id, role: "ADMIN" },
{ bookId, userId: editor.id, role: "EDITOR" },
],
});
login.userId = owner.id;
});
describe("skapa", () => {
it("lagrar bara en hash, och länken är lång och slumpmässig", async () => {
const token = await make();
expect(token.length).toBeGreaterThanOrEqual(43);
expect(newToken()).not.toBe(newToken());
const [row] = await prisma.bookInvite.findMany();
expect(row.tokenHash).toBe(createHash("sha256").update(token).digest("hex"));
expect(row.tokenHash).toBe(hashToken(token));
expect(JSON.stringify(row)).not.toContain(token);
expect(row).toMatchObject({ bookId, role: "EDITOR", maxUses: 1, usedCount: 0, createdById: owner.id, revokedAt: null });
expect(row.expiresAt.getTime()).toBeGreaterThan(Date.now() + 6 * DAY);
});
it("följer samma regler som delning: administratörer bjuder inte in administratörer", async () => {
const as = (userId: string, role: "OWNER" | "ADMIN" | "EDITOR" | "VIEWER") => ({ userId, role });
expect(await createInvite(bookId, as(admin.id, "ADMIN"), "ADMIN", 7, 1)).toBe("forbidden");
expect(typeof (await createInvite(bookId, as(admin.id, "ADMIN"), "VIEWER", 7, 1))).toBe("object");
expect(await createInvite(bookId, as(editor.id, "EDITOR"), "VIEWER", 7, 1)).toBe("forbidden");
expect(typeof (await createInvite(bookId, as(owner.id, "OWNER"), "ADMIN", 7, null))).toBe("object");
});
it("avvisar ogiltiga giltighetstider och antal", async () => {
const as = { userId: owner.id, role: "OWNER" as const };
expect(await createInvite(bookId, as, "EDITOR", 3, 1)).toBe("invalid");
expect(await createInvite(bookId, as, "EDITOR", 7, 0)).toBe("invalid");
expect(await createInvite(bookId, as, "EDITOR", 7, 1.5)).toBe("invalid");
expect(await createInvite(bookId, as, "EDITOR", 7, 5000)).toBe("invalid");
expect(await prisma.bookInvite.count()).toBe(0);
});
it("städar bort länkar som gått ut för länge sedan", async () => {
await prisma.bookInvite.create({ data: { bookId, tokenHash: "gammal", role: "VIEWER", expiresAt: new Date(Date.now() - 40 * DAY) } });
await prisma.bookInvite.create({ data: { bookId, tokenHash: "nyligen", role: "VIEWER", expiresAt: new Date(Date.now() - 2 * DAY) } });
await make();
expect((await prisma.bookInvite.findMany()).map((i) => i.tokenHash).sort()).not.toContain("gammal");
expect((await prisma.bookInvite.findMany()).map((i) => i.tokenHash)).toContain("nyligen");
});
});
describe("gå med", () => {
it("ger medlemskap med länkens roll, och räknar användningen", async () => {
const token = await make("VIEWER", 7, null);
expect(await acceptInvite(token, guest.id)).toEqual({ result: "joined", bookId });
expect((await bookAccess(bookId, guest.id))?.role).toBe("VIEWER");
expect((await prisma.bookInvite.findFirstOrThrow()).usedCount).toBe(1);
});
it("en länk för en person kan inte användas av en till", async () => {
const token = await make("EDITOR", 7, 1);
const other = await makeUser("Annan");
expect((await acceptInvite(token, guest.id)).result).toBe("joined");
expect((await acceptInvite(token, other.id)).result).toBe("used");
expect(await bookAccess(bookId, other.id)).toBeNull();
});
it("av tre som försöker samtidigt med en engångslänk kommer bara en in", async () => {
const token = await make("EDITOR", 7, 1);
const users = await Promise.all([makeUser("A"), makeUser("B"), makeUser("C")]);
const results = await Promise.all(users.map((u) => acceptInvite(token, u.id)));
expect(results.filter((r) => r.result === "joined")).toHaveLength(1);
expect(await prisma.bookMember.count({ where: { bookId, userId: { in: users.map((u) => u.id) } } })).toBe(1);
expect((await prisma.bookInvite.findFirstOrThrow()).usedCount).toBe(1);
});
it("en länk för flera räcker till så många som anges", async () => {
const token = await make("VIEWER", 7, 2);
const users = await Promise.all([makeUser("A"), makeUser("B"), makeUser("C")]);
const results = await Promise.all(users.map((u) => acceptInvite(token, u.id)));
expect(results.filter((r) => r.result === "joined")).toHaveLength(2);
expect(results.filter((r) => r.result === "used")).toHaveLength(1);
});
it("länkar utan gräns räcker så länge de gäller", async () => {
const token = await make("VIEWER", 30, null);
for (const name of ["A", "B", "C", "D"]) expect((await acceptInvite(token, (await makeUser(name)).id)).result).toBe("joined");
expect((await prisma.bookInvite.findFirstOrThrow()).usedCount).toBe(4);
});
it("den som redan har tillgång blir inte ändrad och räknas inte", async () => {
const token = await make("VIEWER", 7, 1);
expect(await acceptInvite(token, editor.id)).toEqual({ result: "already", bookId });
expect(await acceptInvite(token, owner.id)).toEqual({ result: "already", bookId });
expect((await bookAccess(bookId, editor.id))?.role).toBe("EDITOR");
expect((await prisma.bookInvite.findFirstOrThrow()).usedCount).toBe(0);
});
it("avvisar utgångna, indragna och okända länkar", async () => {
const expired = await make();
await prisma.bookInvite.updateMany({ data: { expiresAt: new Date(Date.now() - 1000) } });
expect((await acceptInvite(expired, guest.id)).result).toBe("expired");
const revoked = await make();
await prisma.bookInvite.updateMany({ where: { tokenHash: hashToken(revoked) }, data: { revokedAt: new Date() } });
expect((await acceptInvite(revoked, guest.id)).result).toBe("revoked");
expect((await acceptInvite("finns-inte", guest.id)).result).toBe("not-found");
expect((await acceptInvite("", guest.id)).result).toBe("not-found");
expect(await bookAccess(bookId, guest.id)).toBeNull();
});
it("länken slutar gälla när den som skapade den inte längre får bjuda in till rollen", async () => {
const as = { userId: admin.id, role: "ADMIN" as const };
const made = await createInvite(bookId, as, "EDITOR", 7, null);
if (typeof made === "string") throw new Error(made);
await prisma.bookMember.update({ where: { bookId_userId: { bookId, userId: admin.id } }, data: { role: "EDITOR" } });
expect((await acceptInvite(made.token, guest.id)).result).toBe("forbidden");
// Och när hen tagits bort helt
await prisma.bookMember.delete({ where: { bookId_userId: { bookId, userId: admin.id } } });
expect((await acceptInvite(made.token, guest.id)).result).toBe("forbidden");
expect(await bookAccess(bookId, guest.id)).toBeNull();
});
it("länken överlever inte att boken tas bort", async () => {
const token = await make();
await prisma.book.delete({ where: { id: bookId } });
expect((await acceptInvite(token, guest.id)).result).toBe("not-found");
});
});
describe("förhandsvisning och lista", () => {
it("visar bok, ägare och tillstånd utan att använda länken", async () => {
const token = await make("EDITOR", 7, 1);
const preview = await previewInvite(token);
expect(preview.state).toBe("ok");
expect(preview.invite?.book).toMatchObject({ title: "Delad bok", owner: { name: "Ägare" } });
expect((await prisma.bookInvite.findFirstOrThrow()).usedCount).toBe(0);
expect((await previewInvite("nej")).state).toBe("not-found");
await acceptInvite(token, guest.id);
expect((await previewInvite(token)).state).toBe("used");
});
it("listar bara länkar som går att använda, med vem som skapade dem", async () => {
await make("EDITOR", 7, 1);
const spent = await make("VIEWER", 7, 1);
await acceptInvite(spent, guest.id);
const gone = await make("VIEWER", 1, null);
await prisma.bookInvite.updateMany({ where: { tokenHash: hashToken(gone) }, data: { revokedAt: new Date() } });
const list = await listInvites(bookId);
expect(list).toHaveLength(1);
expect(list[0]).toMatchObject({ role: "EDITOR", creator: "Ägare", usedCount: 0 });
expect(list[0]).not.toHaveProperty("token");
});
it("dra tillbaka: bara de roller man själv får hantera, och den som gått med behåller sin tillgång", async () => {
const token = await make("ADMIN", 7, null);
const [invite] = await prisma.bookInvite.findMany();
expect(await revokeInvite(bookId, "ADMIN", invite.id)).toBe("forbidden");
expect(await revokeInvite(bookId, "OWNER", "finns-inte")).toBe("not-found");
await acceptInvite(token, guest.id);
expect(await revokeInvite(bookId, "OWNER", invite.id)).toBe("ok");
expect((await acceptInvite(token, (await makeUser("Sen")).id)).result).toBe("revoked");
expect(await bookAccess(bookId, guest.id)).not.toBeNull();
});
});
describe("åtgärderna", () => {
it("administratörer skapar länkar, redaktörer och obehöriga får 404", async () => {
login.userId = admin.id;
const ok = await createBookInvite({ bookId, role: "VIEWER", days: 7, multiple: false });
expect(ok).toHaveProperty("token");
expect(await createBookInvite({ bookId, role: "ADMIN", days: 7, multiple: false })).toEqual({ error: "forbidden" });
expect(await createBookInvite({ bookId, role: "SUPER", days: 7, multiple: false })).toEqual({ error: "invalid" });
expect(await createBookInvite({ bookId, role: "VIEWER", days: 5, multiple: false })).toEqual({ error: "invalid" });
for (const user of [editor, guest]) {
login.userId = user.id;
expect(await attempt(() => createBookInvite({ bookId, role: "VIEWER", days: 7, multiple: false }))).toBe("NOT_FOUND");
}
});
it("länken skapas för en person om inte flera valts", async () => {
await createBookInvite({ bookId, role: "EDITOR", days: 1, multiple: false });
await createBookInvite({ bookId, role: "EDITOR", days: 30, multiple: true });
const rows = await prisma.bookInvite.findMany({ orderBy: { createdAt: "asc" } });
expect(rows.map((r) => r.maxUses)).toEqual([1, null]);
});
it("gå med skickar till boken, eller visar varför det inte gick", async () => {
const token = await make("EDITOR", 7, 1);
login.userId = guest.id;
expect(await attempt(() => joinBook(form({ token })))).toBe(`REDIRECT:/books/${bookId}`);
expect((await bookAccess(bookId, guest.id))?.role).toBe("EDITOR");
const other = await makeUser("Sen");
login.userId = other.id;
expect(await attempt(() => joinBook(form({ token })))).toBe(`REDIRECT:/invite/${token}?result=used`);
expect(await attempt(() => joinBook(form({ token: "fel" })))).toBe("REDIRECT:/invite/fel?result=not-found");
});
it("dra tillbaka kräver administratör", async () => {
await make("EDITOR", 7, null);
const [invite] = await prisma.bookInvite.findMany();
login.userId = editor.id;
expect(await attempt(() => revokeBookInvite(form({ bookId, inviteId: invite.id })))).toBe("NOT_FOUND");
login.userId = admin.id;
await revokeBookInvite(form({ bookId, inviteId: invite.id }));
expect((await prisma.bookInvite.findFirstOrThrow()).revokedAt).not.toBeNull();
});
it("kan inte dra tillbaka en länk i en annan bok", async () => {
const otherBook = await makeBook(guest.id, "Annans");
const foreign = await createInvite(otherBook.id, { userId: guest.id, role: "OWNER" }, "VIEWER", 7, null);
if (typeof foreign === "string") throw new Error(foreign);
const [row] = await prisma.bookInvite.findMany({ where: { bookId: otherBook.id } });
await revokeBookInvite(form({ bookId, inviteId: row.id }));
expect((await prisma.bookInvite.findUniqueOrThrow({ where: { id: row.id } })).revokedAt).toBeNull();
});
});
});
+174
View File
@@ -0,0 +1,174 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
import { describeDb, makeBook, makeEntity, makeEvent, makeRelation, makeUser, prisma, resetAll } from "../helpers/db";
const login = vi.hoisted(() => ({ userId: "" as string }));
vi.mock("@/auth", () => ({ auth: async () => (login.userId ? { user: { id: login.userId } } : null) }));
vi.mock("next/cache", () => ({ revalidatePath: () => undefined }));
vi.mock("next/navigation", () => ({
redirect: (to: string) => {
throw new Error(`REDIRECT:${to}`);
},
notFound: () => {
throw new Error("NOT_FOUND");
},
}));
import { heartbeat, leave } from "@/actions/presence";
import { PRESENCE_TTL_MS, editingNow, leavePresence, parsePresenceKind, touchPresence, whoIsEditing } from "@/lib/presence";
describeDb("vem som har något öppet", () => {
let owner: { id: string };
let editor: { id: string };
let viewer: { id: string };
let bookId: string;
let anna: { id: string };
beforeEach(async () => {
await resetAll();
owner = await makeUser("Ägare");
editor = await makeUser("Kollega", "kollega@example.com");
viewer = await makeUser("Läsare");
bookId = (await makeBook(owner.id)).id;
await prisma.bookMember.createMany({
data: [
{ bookId, userId: editor.id, role: "EDITOR" },
{ bookId, userId: viewer.id, role: "VIEWER" },
],
});
anna = await makeEntity(bookId, "CHARACTER", "Anna");
login.userId = owner.id;
});
it("parsePresenceKind godtar bara kända typer", () => {
for (const kind of ["entity", "relation", "event", "template", "book"]) expect(parsePresenceKind(kind)).toBe(kind);
expect(parsePresenceKind("marker")).toBeNull();
expect(parsePresenceKind(undefined)).toBeNull();
});
describe("biblioteket", () => {
it("registrerar och visar andra, men inte en själv", async () => {
await touchPresence(bookId, editor.id, "entity", anna.id);
await touchPresence(bookId, owner.id, "entity", anna.id);
expect(await whoIsEditing(bookId, "entity", anna.id, owner.id)).toEqual(["Kollega"]);
expect((await whoIsEditing(bookId, "entity", anna.id)).sort()).toEqual(["Kollega", "Ägare"]);
expect(await whoIsEditing(bookId, "entity", "annan-post", owner.id)).toEqual([]);
expect(await whoIsEditing(bookId, "relation", anna.id, owner.id)).toEqual([]);
});
it("en rad per person och sak, som uppdateras", async () => {
await touchPresence(bookId, editor.id, "entity", anna.id);
const first = await prisma.presence.findFirstOrThrow();
await new Promise((r) => setTimeout(r, 15));
await touchPresence(bookId, editor.id, "entity", anna.id);
expect(await prisma.presence.count()).toBe(1);
expect((await prisma.presence.findFirstOrThrow()).seenAt.getTime()).toBeGreaterThan(first.seenAt.getTime());
});
it("den som inte hörts av på en stund räknas inte längre, och gamla rader städas bort", async () => {
await touchPresence(bookId, editor.id, "entity", anna.id);
await prisma.presence.updateMany({ data: { seenAt: new Date(Date.now() - PRESENCE_TTL_MS - 1000) } });
expect(await whoIsEditing(bookId, "entity", anna.id, owner.id)).toEqual([]);
expect(await prisma.presence.count()).toBe(1);
await prisma.presence.updateMany({ data: { seenAt: new Date(Date.now() - 11 * 60_000) } });
await touchPresence(bookId, owner.id, "entity", anna.id);
expect(await prisma.presence.count()).toBe(1); // bara den nya finns kvar
});
it("lämna tar bort närvaron", async () => {
await touchPresence(bookId, editor.id, "entity", anna.id);
await leavePresence(editor.id, "entity", anna.id);
expect(await whoIsEditing(bookId, "entity", anna.id, owner.id)).toEqual([]);
});
it("visar e-postens första del när namn saknas, och samma person bara en gång", async () => {
const nameless = await makeUser("X", "nameless@example.com");
await prisma.user.update({ where: { id: nameless.id }, data: { name: null } });
await touchPresence(bookId, nameless.id, "entity", anna.id);
expect(await whoIsEditing(bookId, "entity", anna.id, owner.id)).toEqual(["nameless"]);
});
it("editingNow ger poster med namn för märken i listor", async () => {
const bo = await makeEntity(bookId, "CHARACTER", "Bo");
await touchPresence(bookId, editor.id, "entity", anna.id);
await touchPresence(bookId, viewer.id, "entity", anna.id);
await touchPresence(bookId, editor.id, "entity", bo.id);
await touchPresence(bookId, owner.id, "entity", bo.id);
await touchPresence(bookId, editor.id, "relation", "r1");
const map = await editingNow(bookId, "entity", owner.id);
expect([...map.keys()].sort()).toEqual([anna.id, bo.id].sort());
expect(map.get(anna.id)?.sort()).toEqual(["Kollega", "Läsare"]);
expect(map.get(bo.id)).toEqual(["Kollega"]);
});
it("hör till boken: försvinner med boken, och syns inte i en annan bok", async () => {
const otherBook = await makeBook(owner.id, "Annan");
await touchPresence(bookId, editor.id, "entity", anna.id);
expect(await whoIsEditing(otherBook.id, "entity", anna.id)).toEqual([]);
await prisma.book.delete({ where: { id: bookId } });
expect(await prisma.presence.count()).toBe(0);
});
});
describe("åtgärden heartbeat", () => {
it("registrerar och svarar med vilka andra som har samma sak öppen", async () => {
login.userId = editor.id;
expect(await heartbeat(bookId, "entity", anna.id)).toEqual([]);
login.userId = owner.id;
expect(await heartbeat(bookId, "entity", anna.id)).toEqual(["Kollega"]);
login.userId = editor.id;
expect(await heartbeat(bookId, "entity", anna.id)).toEqual(["Ägare"]);
});
it("fungerar för relationer, händelser, mallar och bokinställningar", async () => {
const bo = await makeEntity(bookId, "CHARACTER", "Bo");
const relation = await makeRelation(bookId, anna.id, bo.id);
const event = await makeEvent(bookId, "Fest", "2000");
login.userId = editor.id;
await heartbeat(bookId, "relation", relation.id);
await heartbeat(bookId, "event", event.id);
await heartbeat(bookId, "template", "CHARACTER");
await heartbeat(bookId, "book", bookId);
expect((await prisma.presence.findMany()).map((p) => p.kind).sort()).toEqual(["book", "event", "relation", "template"]);
});
it("avvisar okända typer, saker som inte finns och saker i en annan bok", async () => {
const otherBook = await makeBook(owner.id, "Annan");
const foreign = await makeEntity(otherBook.id, "CHARACTER", "Främling");
login.userId = editor.id;
expect(await heartbeat(bookId, "marker", anna.id)).toEqual([]);
expect(await heartbeat(bookId, "entity", "finns-inte")).toEqual([]);
expect(await heartbeat(bookId, "entity", foreign.id)).toEqual([]);
expect(await heartbeat(bookId, "template", "INTE_EN_TYP")).toEqual([]);
expect(await heartbeat(bookId, "book", otherBook.id)).toEqual([]);
expect(await prisma.presence.count()).toBe(0);
});
it("kräver redaktör: läsare och obehöriga får 404 och registreras inte", async () => {
const stranger = await makeUser("Obehörig");
for (const user of [viewer, stranger]) {
login.userId = user.id;
await expect(heartbeat(bookId, "entity", anna.id)).rejects.toThrow("NOT_FOUND");
await expect(leave(bookId, "entity", anna.id)).rejects.toThrow("NOT_FOUND");
}
expect(await prisma.presence.count()).toBe(0);
});
it("har en gräns för hur ofta en användare kan anmäla sig: över gränsen registreras inget mer", async () => {
login.userId = editor.id;
for (let i = 0; i < 60; i++) await heartbeat(bookId, "entity", anna.id);
await prisma.presence.deleteMany();
// Det 61:a anropet inom en minut ignoreras
expect(await heartbeat(bookId, "entity", anna.id)).toEqual([]);
expect(await prisma.presence.count()).toBe(0);
});
it("lämna tar bort ens egen närvaro men inte andras", async () => {
login.userId = editor.id;
await heartbeat(bookId, "entity", anna.id);
login.userId = owner.id;
await heartbeat(bookId, "entity", anna.id);
await leave(bookId, "entity", anna.id);
expect((await prisma.presence.findMany()).map((p) => p.userId)).toEqual([editor.id]);
});
});
});
+27
View File
@@ -189,6 +189,33 @@ describeDb("import från Word: scheman och kartregister", () => {
expect(new Set(markerCodes).size).toBe(markerCodes.length);
});
it("använder uppslagna positioner, och lägger resten kring kartans mitt", async () => {
await commitMaps([
map({
code: null,
centerLat: 55.7047,
centerLng: 13.191,
markers: [
{ code: null, label: "Exakt", note: null, lat: 55.71, lng: 13.2 },
{ code: null, label: "Ej hittad", note: null, lat: null, lng: null },
{ code: null, label: "Ogiltig", note: null, lat: 999, lng: 13 },
],
}),
]);
const created = await prisma.bookMap.findFirstOrThrow({ where: { bookId }, include: { markers: { orderBy: { createdAt: "asc" } } } });
expect(created).toMatchObject({ centerLat: 55.7047, centerLng: 13.191, zoom: 13 });
const [exact, missing, invalid] = created.markers;
expect([exact.lat, exact.lng]).toEqual([55.71, 13.2]);
// Utan position hamnar markeringen nära kartans mitt, inte i Stockholm
for (const m of [missing, invalid]) expect(Math.abs(m.lat - 55.7047) + Math.abs(m.lng - 13.191)).toBeLessThan(0.1);
expect(new Set([missing, invalid].map((m) => `${m.lat},${m.lng}`)).size).toBe(2);
});
it("en karta utan uppslagen mitt ligger kvar i standardvyn", async () => {
await commitMaps([map({ code: null, centerLat: null, centerLng: null })]);
expect(await prisma.bookMap.findFirstOrThrow({ where: { bookId } })).toMatchObject({ zoom: 11 });
});
it("hoppar över ID som redan används även när räknaren ligger efter", async () => {
// Poster som lagts in utan räknaren (för hand eller av en äldre version)
const existing = await prisma.bookMap.create({ data: { bookId, name: "Befintlig", kind: "GEO", code: "KD-R_0001" } });
+153
View File
@@ -0,0 +1,153 @@
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { clearGeocodeCache, distanceKm, geocode, geocodingEnabled, validPosition } from "@/lib/geocode";
import { safeCallbackPath } from "@/lib/redirect";
describe("distanceKm", () => {
it("räknar avstånd mellan städer", () => {
expect(distanceKm({ lat: 55.7047, lng: 13.191 }, { lat: 55.7047, lng: 13.191 })).toBe(0);
expect(Math.round(distanceKm({ lat: 55.6761, lng: 12.5683 }, { lat: 59.3293, lng: 18.0686 }))).toBeGreaterThan(500); // Köpenhamn–Stockholm
expect(Math.round(distanceKm({ lat: 55.7047, lng: 13.191 }, { lat: 55.6050, lng: 13.0038 }))).toBeLessThan(25); // Lund–Malmö
});
});
describe("validPosition", () => {
it("godtar bara riktiga koordinater", () => {
expect(validPosition({ lat: 55.7, lng: 13.2 })).toBe(true);
expect(validPosition({ lat: 90, lng: -180 })).toBe(true);
expect(validPosition({ lat: 91, lng: 0 })).toBe(false);
expect(validPosition({ lat: 0, lng: 181 })).toBe(false);
expect(validPosition({ lat: Number.NaN, lng: 0 })).toBe(false);
expect(validPosition({ lat: "55" as unknown as number, lng: 13 })).toBe(false);
expect(validPosition({ lat: undefined, lng: 13 })).toBe(false);
expect(validPosition(null)).toBe(false);
});
});
describe("geocode", () => {
const calls: { url: string; init?: RequestInit }[] = [];
const answer = (rows: unknown, ok = true) => ({ ok, status: ok ? 200 : 503, json: async () => rows });
beforeEach(() => {
calls.length = 0;
clearGeocodeCache();
process.env.GEOCODER_INTERVAL_MS = "0";
delete process.env.MAP_GEOCODER_URL;
delete process.env.GEOCODING_ENABLED;
});
afterEach(() => {
vi.unstubAllGlobals();
delete process.env.GEOCODER_INTERVAL_MS;
delete process.env.MAP_GEOCODER_URL;
delete process.env.GEOCODING_ENABLED;
});
const stub = (handler: (url: string) => unknown) =>
vi.stubGlobal(
"fetch",
vi.fn(async (url: string, init?: RequestInit) => {
calls.push({ url, init });
return handler(url);
}),
);
it("ger position och namn, och skickar en tydlig användaragent utan personuppgifter", async () => {
stub(() => answer([{ lat: "55.7047", lon: "13.1910", display_name: "Lund, Skåne" }]));
expect(await geocode(" Lund ")).toEqual({ lat: 55.7047, lng: 13.191, name: "Lund, Skåne" });
expect(calls[0].url).toContain("nominatim.openstreetmap.org/search");
expect(calls[0].url).toContain("q=Lund");
expect(calls[0].url).toContain("limit=1");
const headers = calls[0].init?.headers as Record<string, string>;
expect(headers["User-Agent"]).toMatch(/^Bokplanerare\//);
expect(headers["User-Agent"]).not.toContain("@");
});
it("använder den adress som anges i MAP_GEOCODER_URL", async () => {
process.env.MAP_GEOCODER_URL = "https://geo.example.com/sok";
stub(() => answer([]));
await geocode("Lund");
expect(calls[0].url.startsWith("https://geo.example.com/sok?")).toBe(true);
});
it("ger null när inget hittas, och för tomma eller trasiga svar", async () => {
stub(() => answer([]));
expect(await geocode("Finns inte")).toBeNull();
stub(() => answer([{ lat: "abc", lon: "13" }]));
expect(await geocode("Trasigt")).toBeNull();
stub(() => answer([{ lat: "99", lon: "13" }]));
expect(await geocode("Utanför")).toBeNull();
stub(() => answer({ fel: true }));
expect(await geocode("Objekt")).toBeNull();
expect(await geocode(" ")).toBeNull();
});
it("kastar när tjänsten inte svarar, och nästa fråga fungerar ändå", async () => {
stub(() => answer([], false));
await expect(geocode("Lund")).rejects.toThrow("503");
stub(() => answer([{ lat: "1", lon: "2" }]));
expect(await geocode("Malmö")).toMatchObject({ lat: 1, lng: 2 });
});
it("sparar svaren, även när inget hittades, och skiljer inte på stora och små bokstäver", async () => {
stub(() => answer([{ lat: "1", lon: "2" }]));
await geocode("Lund");
await geocode("lund");
await geocode(" LUND ");
expect(calls).toHaveLength(1);
stub(() => answer([]));
await geocode("Ingenstans");
await geocode("Ingenstans");
expect(calls).toHaveLength(2);
});
it("köar anropen så att tjänsten får högst ett i sekunden", async () => {
process.env.GEOCODER_INTERVAL_MS = "120";
stub(() => answer([{ lat: "1", lon: "2" }]));
const started = Date.now();
await Promise.all(["A", "B", "C"].map((q) => geocode(q)));
expect(Date.now() - started).toBeGreaterThanOrEqual(220);
expect(calls).toHaveLength(3);
});
it("kortar långa frågor och kodar tecken", async () => {
stub(() => answer([]));
await geocode(`Å&=?${"x".repeat(500)}`);
const q = new URL(calls[0].url).searchParams.get("q")!;
expect(q).toHaveLength(200);
expect(q.startsWith("Å&=?")).toBe(true);
});
it("kan stängas av", () => {
expect(geocodingEnabled()).toBe(true);
process.env.GEOCODING_ENABLED = "false";
expect(geocodingEnabled()).toBe(false);
});
});
describe("safeCallbackPath", () => {
const origin = "https://bocker.example.com";
it("godtar adresser inom appen", () => {
expect(safeCallbackPath("/invite/abc", origin)).toBe("/invite/abc");
expect(safeCallbackPath("/books/1/settings?share=ok", origin)).toBe("/books/1/settings?share=ok");
expect(safeCallbackPath("https://bocker.example.com/invite/abc?x=1", origin)).toBe("/invite/abc?x=1");
});
it("avvisar andra sajter och knep", () => {
for (const bad of ["https://evil.example.com/x", "//evil.example.com", "/\\evil.example.com", "javascript:alert(1)", "http://bocker.example.com.evil.com/", "evil.com", "/a\r\nSet-Cookie: x=1"]) {
expect(safeCallbackPath(bad, origin)).toBe("/");
}
});
it("skickar inte tillbaka till inloggningen och klarar tomt", () => {
expect(safeCallbackPath("/login", origin)).toBe("/");
expect(safeCallbackPath("/login?callbackUrl=/x", origin)).toBe("/");
expect(safeCallbackPath("/api/auth/signin", origin)).toBe("/");
expect(safeCallbackPath("", origin)).toBe("/");
expect(safeCallbackPath(undefined, origin)).toBe("/");
expect(safeCallbackPath("/x".repeat(3000), origin)).toBe("/");
});
it("utan känd adress godtas bara relativa adresser", () => {
expect(safeCallbackPath("https://bocker.example.com/x", undefined)).toBe("/");
expect(safeCallbackPath("/x", undefined)).toBe("/x");
});
});