Files
Betriebsf-hrungssoftware/test/api.test.ts
Claude bc5e15339a
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
Anmeldung und Rollen: eigene Zugänge, Benutzerverwaltung, Mitarbeiter-Ansicht (0.7.0)
Stufe 2, Schritt 1 (U1, U2, E27, P13). Passwörter mit scrypt, Sitzung als
HttpOnly-Cookie (90 Tage, gleitend), in der Datenbank nur der SHA-256.
Rollen Inhaber, Büro, Mitarbeiter; Mitarbeiter sehen nur eigene Einsätze
und die Ablage ihrer Projekte. Testversion ohne Passwörter mit Auswahl,
als wer gearbeitet wird. Anmeldung am Proxy entfällt.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
2026-10-20 06:26:05 +00:00

554 lines
35 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Prüft Server und Datenbank zusammen. Läuft nur mit TEST_DATABASE_URL (lokal und in der CI).
import { describe, it, expect, beforeAll, afterAll } from "vitest";
import { falscheNextcloud } from "./falsche-nextcloud.js";
import type { FastifyInstance } from "fastify";
import { erstellePool, type Pool } from "../src/server/db.js";
import { migriere } from "../src/server/migrate.js";
import { baueApp } from "../src/server/app.js";
import { readFileSync } from "node:fs";
import { uebernimmV70 } from "../src/domain/v70.js";
import { liquiditaetsDaten } from "../src/domain/projektplan.js";
import { liquiditaet } from "../src/domain/liquiditaet.js";
import { bestandAus } from "./v70-referenz.js";
const url = process.env.TEST_DATABASE_URL;
describe.skipIf(!url)("API mit Datenbank", () => {
let pool: Pool;
let app: FastifyInstance;
beforeAll(async () => {
pool = erstellePool(url!);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" });
});
afterAll(async () => {
await app?.close();
await pool?.end();
});
const anlegen = async (pfad: string, body: object, benutzer = "henning") => {
const r = await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body, headers: { "x-benutzer": benutzer } });
expect(r.statusCode, r.body).toBe(201);
return r.json();
};
it("Migrationen laufen nur einmal", async () => {
expect(await migriere(pool)).toEqual([]);
});
it("Status", async () => {
const r = await app.inject("/api/status");
expect(r.json()).toMatchObject({ ok: true });
});
it("umbenannter Kontakt erscheint überall mit neuem Namen (Abnahme Stufe 0)", async () => {
const k = await anlegen("kontakte", { name: "Dachdeckerei Meier", rolle: "subunternehmer" });
const p = await anlegen("projekte", { nummer: "26-01", bezeichnung: "Dachstuhl Musterweg", bauherr_id: k.id, umsatz_netto: 4_500_000 });
const a = await anlegen("abschnitte", { projekt_id: p.id, name: "Montage" });
const v = await anlegen("vorgaenge", { abschnitt_id: a.id, name: "Eindecken", start: "2026-11-02", dauer: 3, kontakt_id: k.id });
const r = await app.inject({ method: "PATCH", url: `/api/kontakte/${k.id}`, payload: { name: "Meier Bedachungen GmbH" } });
expect(r.statusCode).toBe(200);
const sicht = await pool.query(
`select kp.name as bauherr, kv.name as ausfuehrend from projekt p
join kontakt kp on kp.id = p.bauherr_id join vorgang v on v.id = $2 join kontakt kv on kv.id = v.kontakt_id where p.id = $1`,
[p.id, v.id],
);
expect(sicht.rows[0]).toEqual({ bauherr: "Meier Bedachungen GmbH", ausfuehrend: "Meier Bedachungen GmbH" });
});
it("Beträge bleiben centgenau", async () => {
const p = await anlegen("projekte", { nummer: "26-02", bezeichnung: "Carport" });
const z = await anlegen("zahlungen", { projekt_id: p.id, bezeichnung: "Anzahlung", netto: 123_456_789_01, termin: "2026-11-02" });
expect(z.netto).toBe(123_456_789_01);
expect(z.termin).toBe("2026-11-02");
});
it("lehnt ungültige Eingaben ab", async () => {
const r1 = await app.inject({ method: "POST", url: "/api/kontakte", payload: { name: "" } });
expect(r1.statusCode).toBe(400);
const r2 = await app.inject({ method: "POST", url: "/api/zahlungen", payload: { projekt_id: crypto.randomUUID(), bezeichnung: "x", netto: 1, termin: "2026-01-01" } });
expect(r2.statusCode).toBe(409);
const r3 = await app.inject({ method: "POST", url: "/api/zahlungen", payload: { projekt_id: crypto.randomUUID(), bezeichnung: "x", netto: 1.5, termin: "2026-01-01" } });
expect(r3.statusCode).toBe(400);
});
it("Protokoll hält fest, wer was geändert hat", async () => {
const k = await anlegen("kontakte", { name: "Holzhandel Nord" }, "henning");
await app.inject({ method: "PATCH", url: `/api/kontakte/${k.id}`, payload: { telefon: "04541 123" }, headers: { "x-benutzer": "buero" } });
await app.inject({ method: "DELETE", url: `/api/kontakte/${k.id}`, headers: { "x-benutzer": "henning" } });
const r = (await app.inject(`/api/protokoll?datensatz=${k.id}`)).json();
expect(r.map((x: { aktion: string; benutzer: string }) => [x.aktion, x.benutzer])).toEqual([
["loeschen", "henning"], ["aendern", "buero"], ["anlegen", "henning"],
]);
});
it("Einstellungen mit Vorgaben und Liquidität aus der Datenbank", async () => {
const e = (await app.inject("/api/einstellungen")).json();
expect(e.arbeitstage).toEqual([1, 2, 3, 4]);
expect(e.ust.satz).toBe(19);
await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...e, startsaldo: 500_000 } });
const p = await anlegen("projekte", { nummer: "26-03", bezeichnung: "Gaube" });
await anlegen("zahlungen", { projekt_id: p.id, bezeichnung: "Abschlag", netto: 1_000_000, termin: "2027-03-01" });
await anlegen("laufende-kosten", { bezeichnung: "Kfz-Versicherung", betrag: 60_000, rhythmus: "jaehrlich", start: "2027-03-20" });
const l = (await app.inject("/api/liquiditaet?ansicht=monat&start=2027-03-01&anzahl=1")).json();
expect(l[0]).toMatchObject({ einnahmen: 1_190_000, ausgaben: -60_000, kontostand: 500_000 + 1_190_000 - 60_000 });
});
it("Export enthält alle Tabellen", async () => {
const r = await app.inject("/api/export");
const j = r.json();
expect(Object.keys(j.daten)).toContain("vorgaenge");
expect(j.daten.kontakte.length).toBeGreaterThan(0);
});
});
describe.skipIf(!url)("Übernahme aus V70 über die API", () => {
let pool: Pool;
let app: FastifyInstance;
const sicherung = JSON.parse(readFileSync(new URL("./daten/v70-sicherung-2026-10-19.json", import.meta.url), "utf8"));
beforeAll(async () => {
pool = erstellePool(url!);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" });
});
afterAll(async () => {
await app?.close();
await pool?.end();
});
const importiere = (payload: object) => app.inject({ method: "POST", url: "/api/import/v70", payload, headers: { "x-benutzer": "henning" } });
it("lehnt fremde Dateien ab", async () => {
const r = await importiere({ format: "etwas anderes" });
expect(r.statusCode).toBe(400);
expect(r.json().fehler).toMatch(/keine Sicherung/);
});
it("übernimmt die Sicherung einmal, danach nicht mehr", async () => {
const r = await importiere(sicherung);
expect(r.statusCode, r.body).toBe(201);
expect(r.json().anzahl).toMatchObject({ projekte: 9, kontakte: 7, vorgaenge: 13, zahlungen: 5, kosten: 2, laufendeKosten: 10 });
expect((await importiere(sicherung)).statusCode).toBe(409);
const e = (await app.inject("/api/einstellungen")).json();
expect(e).toMatchObject({ arbeitstage: [1, 2, 3, 4], rundung: "halb", zahlungsziele: { kundenTage: 14, materialTage: 7 } });
const protokoll = (await app.inject("/api/protokoll?limit=1")).json();
expect(protokoll[0].benutzer).toBe("henning");
});
it("Liquidität aus der Datenbank wie aus der Sicherung gerechnet", async () => {
const u = uebernimmV70(sicherung); // wie der Server: Mo–Do
const erwartet = liquiditaet(liquiditaetsDaten(bestandAus(u), { tage: u.einstellungen.arbeitstage }), {
ansicht: "monat", start: "2026-07-01", anzahl: 12, startsaldo: 0, ziele: u.einstellungen.zahlungsziele,
});
const l = (await app.inject("/api/liquiditaet?ansicht=monat&start=2026-07-01&anzahl=12")).json();
const kurz = (p: { von: string; einnahmen: number; ausgaben: number; kontostand: number }[]) =>
p.map(({ von, einnahmen, ausgaben, kontostand }) => ({ von, einnahmen, ausgaben, kontostand }));
expect(kurz(l)).toEqual(kurz(erwartet));
expect(erwartet.some((p) => p.einnahmen > 0)).toBe(true);
});
it("Terminplan: Verknüpfungen eingehalten, V70-Nummern bleiben", async () => {
const t = (await app.inject("/api/terminplan")).json();
expect(t.vorgaenge).toHaveLength(13);
expect(t.vorgaenge.every((v: { nummer: number }) => v.nummer > 1000)).toBe(true);
const nr = new Map(t.vorgaenge.map((v: { id: string }) => [v.id, v]));
for (const k of t.verknuepfungen.filter((k: { art: string }) => k.art === "EA")) {
const a = nr.get(k.vorgaenger_id) as { ende: string };
const b = nr.get(k.vorgang_id) as { anfang: string; dauer: number };
if (b.dauer > 0) expect(b.anfang > a.ende, `${a.ende} → ${b.anfang}`).toBe(true);
}
});
it("längerer Vorgang schiebt Nachfolger, Kreis wird abgelehnt", async () => {
const t = (await app.inject("/api/terminplan")).json();
const k = t.verknuepfungen.find((k: { art: string; verzoegerung: number }) => k.art === "EA");
const vor = t.vorgaenge.find((v: { id: string }) => v.id === k.vorgaenger_id);
const nach = t.vorgaenge.find((v: { id: string }) => v.id === k.vorgang_id);
const r = await app.inject({ method: "PATCH", url: `/api/vorgaenge/${vor.id}`, payload: { dauer: Number(vor.dauer) + 10 } });
expect(r.statusCode, r.body).toBe(200);
const t2 = (await app.inject("/api/terminplan")).json();
const nach2 = t2.vorgaenge.find((v: { id: string }) => v.id === nach.id);
const vor2 = t2.vorgaenge.find((v: { id: string }) => v.id === vor.id);
expect(nach2.anfang > vor2.ende).toBe(true);
expect(nach2.anfang > nach.anfang).toBe(true);
const kreis = await app.inject({ method: "POST", url: "/api/verknuepfungen", payload: { vorgang_id: vor.id, vorgaenger_id: nach.id } });
expect(kreis.statusCode).toBe(409);
expect(kreis.json().fehler).toMatch(/Kreis/);
// kürzer machen: der enge Nachfolger rückt wieder nach vorn
await app.inject({ method: "PATCH", url: `/api/vorgaenge/${vor.id}`, payload: { dauer: Number(vor.dauer) } });
const t3 = (await app.inject("/api/terminplan")).json();
expect(t3.vorgaenge.find((v: { id: string }) => v.id === nach.id).anfang).toBe(nach.anfang);
// von Hand nach hinten gezogen: bleibt dort und zieht den Nachfolger mit
const spaeter = "2027-06-07";
await app.inject({ method: "PATCH", url: `/api/vorgaenge/${vor.id}`, payload: { start: spaeter } });
const t4 = (await app.inject("/api/terminplan")).json();
expect(t4.vorgaenge.find((v: { id: string }) => v.id === vor.id).anfang).toBe(spaeter);
expect(t4.vorgaenge.find((v: { id: string }) => v.id === nach.id).anfang > spaeter).toBe(true);
});
it("Besetzung: Mitarbeiter gelten sofort, Subunternehmer erst nach Freigabe; Überschneidung wird gemeldet", async () => {
const neu = async (pfad: string, body: object) => (await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body })).json();
const ma = await neu("kontakte", { name: "Henning Schaarschmidt", rolle: "mitarbeiter" });
const sub = await neu("kontakte", { name: "Jens Meier", firma: "Meier Bedachungen GmbH", rolle: "subunternehmer" });
const t = (await app.inject("/api/terminplan")).json();
const frei = (v: { id: string; dauer: number }) => Number(v.dauer) > 0 && !t.verknuepfungen.some((k: { vorgang_id: string }) => k.vorgang_id === v.id);
const [a, b] = t.vorgaenge.filter(frei);
await app.inject({ method: "PATCH", url: `/api/vorgaenge/${b.id}`, payload: { start: a.anfang } });
expect((await neu("besetzungen", { vorgang_id: a.id, kontakt_id: ma.id })).freigegeben).toBe(true);
expect((await neu("besetzungen", { vorgang_id: a.id, kontakt_id: sub.id, personen: 2 })).freigegeben).toBe(false);
expect((await neu("besetzungen", { vorgang_id: b.id, kontakt_id: ma.id })).freigegeben).toBe(true);
const ohne = await app.inject({ method: "POST", url: "/api/besetzungen", payload: { vorgang_id: a.id } });
expect(ohne.statusCode).toBe(400);
const t2 = (await app.inject("/api/terminplan")).json();
expect(t2.ueberschneidungen).toEqual([expect.objectContaining({ name: "Henning Schaarschmidt", ab: a.anfang })]);
expect(t2.besetzungen.map((x: { kurz: string }) => x.kurz).sort()).toEqual(["HS", "HS", "Meier"]);
});
it("Startseite: Aufgaben, Warnungen und wer macht was", async () => {
await app.inject({ method: "POST", url: "/api/aufgaben", payload: { text: "Statik anfragen", faellig_am: "2026-10-16" } });
const t = (await app.inject("/api/terminplan")).json();
const u = (await app.inject(`/api/uebersicht?heute=${t.ueberschneidungen[0].ab}`)).json();
expect(u.aufgaben.ueberfaellig.map((a: { text: string }) => a.text)).toContain("Statik anfragen");
const arten = u.warnungen.map((w: { art: string }) => w.art);
expect(arten).toEqual(expect.arrayContaining(["aufgabe", "kontostand"]));
expect(u.warnungen.find((w: { art: string }) => w.art === "kontostand").text).toMatch(/nicht eingetragen/);
expect(u.einsatz.tage).toHaveLength(8);
expect(u.einsatz.zeilen.map((z: { anzeige: string }) => z.anzeige)).toContain("Henning Schaarschmidt");
});
it("Aufgaben mit Kategorie, Projekt und Kunde; gelöschte Kategorie bleibt ohne Folgen", async () => {
const anlegen = async (pfad: string, body: object) => {
const r = await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body });
expect(r.statusCode, r.body).toBe(201);
return r.json();
};
const kat = await anlegen("aufgaben-kategorien", { name: "Bestellung" });
const doppelt = await app.inject({ method: "POST", url: "/api/aufgaben-kategorien", payload: { name: "Bestellung" } });
expect(doppelt.statusCode).toBeGreaterThanOrEqual(400);
const k = await anlegen("kontakte", { name: "Familie Groth", rolle: "bauherr" });
const p = await anlegen("projekte", { nummer: "P-26-099", bezeichnung: "Carport Groth", bauherr_id: k.id, baustelle_ort: "Mölln" });
const a = await anlegen("aufgaben", { text: "Holz bestellen", kategorie_id: kat.id, projekt_id: p.id, kontakt_id: k.id, faellig_am: "2026-10-01" });
const u = (await app.inject("/api/uebersicht?heute=2026-10-20")).json();
const zeile = u.aufgaben.ueberfaellig.find((x: { id: string }) => x.id === a.id);
expect(zeile).toMatchObject({ kategorie: "Bestellung", projekt_name: "Carport Groth", kontakt_name: "Familie Groth" });
expect((await app.inject({ method: "DELETE", url: `/api/aufgaben-kategorien/${kat.id}` })).statusCode).toBeLessThan(300);
const nach = (await app.inject("/api/aufgaben")).json().find((x: { id: string }) => x.id === a.id);
expect(nach.kategorie_id).toBeNull();
expect((await app.inject(`/api/projekte/${p.id}`)).json().baustelle_ort).toBe("Mölln");
});
it("Zahlungsplan entsteht automatisch, folgt Auftragswert und Terminen, bis er von Hand geändert wird", async () => {
const neu = async (pfad: string, body: object) => (await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body })).json();
const raten = async (id: string) => (await app.inject("/api/zahlungen")).json()
.filter((z: { projekt_id: string }) => z.projekt_id === id).sort((a: { reihenfolge: number }, b: { reihenfolge: number }) => a.reihenfolge - b.reihenfolge);
const p = await neu("projekte", { nummer: "P-26-098", bezeichnung: "Dachstuhl Ziegelei" });
expect((await app.inject({ method: "POST", url: `/api/projekte/${p.id}/zahlungsplan` })).statusCode).toBe(400);
await app.inject({ method: "PATCH", url: `/api/projekte/${p.id}`, payload: { umsatz_netto: 2_000_000 } });
expect(await raten(p.id)).toHaveLength(0); // noch keine Termine
const a = await neu("abschnitte", { projekt_id: p.id, name: "Ausführung" });
await neu("vorgaenge", { abschnitt_id: a.id, name: "Dach", start: "2026-11-09", dauer: 3 });
expect((await raten(p.id)).map((z: { netto: number }) => z.netto)).toEqual([600_000, 800_000, 400_000, 200_000]);
// ein später angelegter Vorgang „Richten“ bekommt die 40-%-Rate
const richten = await neu("vorgaenge", { abschnitt_id: a.id, name: "Richten", start: "2026-11-02", dauer: 2 });
expect((await raten(p.id))[1]).toMatchObject({ vorgang_id: richten.id, termin: "2026-11-03" });
// neuer Auftragswert: Raten anteilig
await app.inject({ method: "PATCH", url: `/api/projekte/${p.id}`, payload: { umsatz_netto: 3_000_000 } });
expect((await raten(p.id)).map((z: { netto: number }) => z.netto)).toEqual([900_000, 1_200_000, 600_000, 300_000]);
expect((await app.inject({ method: "POST", url: `/api/projekte/${p.id}/zahlungsplan` })).statusCode).toBe(409);
// Richten verschiebt sich um eine Woche: die geplante Rate geht mit
await app.inject({ method: "PATCH", url: `/api/vorgaenge/${richten.id}`, payload: { start: "2026-11-09" } });
const r1 = (await raten(p.id))[1];
expect(r1.termin).toBe("2026-11-10");
// von Hand geändert: Plan ist fest, Auftragswert ändert die Raten nicht mehr
await app.inject({ method: "PATCH", url: `/api/zahlungen/${r1.id}`, payload: { netto: 1_000_000 } });
expect((await app.inject(`/api/projekte/${p.id}`)).json().zahlungsplan).toBe("fest");
await app.inject({ method: "PATCH", url: `/api/projekte/${p.id}`, payload: { umsatz_netto: 4_000_000 } });
expect((await raten(p.id))[1].netto).toBe(1_000_000);
// gestellte Raten bleiben stehen, geplante wandern weiter mit
await app.inject({ method: "PATCH", url: `/api/zahlungen/${r1.id}`, payload: { status: "gestellt" } });
await app.inject({ method: "PATCH", url: `/api/vorgaenge/${richten.id}`, payload: { start: "2026-11-16" } });
expect((await app.inject(`/api/zahlungen/${r1.id}`)).json().termin).toBe("2026-11-10");
expect((await app.inject("/api/terminplan")).json().zahlungen.filter((z: { projekt_id: string }) => z.projekt_id === p.id)).toHaveLength(4);
// alle gelöscht: es kommt kein neuer automatisch
for (const z of await raten(p.id)) await app.inject({ method: "DELETE", url: `/api/zahlungen/${z.id}` });
await neu("vorgaenge", { abschnitt_id: a.id, name: "Abnahme", start: "2026-11-30", dauer: 0 });
expect(await raten(p.id)).toHaveLength(0);
});
it("Kalender-Abo nur mit gültigem Geheimnis", async () => {
expect((await app.inject("/kalender/xxxxxxxxxxxxxxxxxxxxxxxx/baustellen.ics")).statusCode).toBe(404);
const { kalenderToken } = (await app.inject({ method: "POST", url: "/api/kalender/neu" })).json();
const r = await app.inject(`/kalender/${kalenderToken}/baustellen.ics`);
expect(r.statusCode).toBe(200);
expect(r.headers["content-type"]).toMatch(/text\/calendar/);
expect(r.body).toContain("X-WR-CALNAME:Baustellen");
expect(r.body).toMatch(/SUMMARY:P-26-\d+/);
expect((await app.inject(`/kalender/${kalenderToken}/aufgaben.ics`)).body).toContain("Aufgabe: Statik anfragen");
expect((await app.inject(`/kalender/${kalenderToken.slice(0, -1)}${kalenderToken.endsWith("x") ? "y" : "x"}/baustellen.ics`)).statusCode).toBe(404);
});
});
describe.skipIf(!url)("Projektordner in der Nextcloud über die API", () => {
let pool: Pool;
let app: FastifyInstance;
const f = falscheNextcloud();
beforeAll(async () => {
pool = erstellePool(url!);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", nextcloud: f.nc, anmeldung: "testversion" });
});
afterAll(async () => {
await app?.close();
await pool?.end();
});
it("neues Projekt bekommt einen Ordner, Statuswechsel verschiebt ihn", async () => {
const p = (await app.inject({ method: "POST", url: "/api/projekte", payload: { nummer: "A-26-130", bezeichnung: "Carport Most", status: "angebot" } })).json();
expect(p.nextcloud_link).toBe("01 Angebot/A-26-130 Carport Most");
const q = (await app.inject({ method: "PATCH", url: `/api/projekte/${p.id}`, payload: { nummer: "P-26-021", status: "auftrag" } })).json();
expect(q.nextcloud_link).toBe("02 laufende Projekte/P-26-021 Carport Most");
expect(f.relativ()).toContain("02 laufende Projekte/P-26-021 Carport Most/02 Umsetzung");
});
it("Ablage zeigt den Projektordner und reicht Dateien durch", async () => {
const p = (await app.inject({ method: "POST", url: "/api/projekte", payload: { nummer: "P-26-022", bezeichnung: "Gaube Lüth", status: "auftrag" } })).json();
f.dateien.set(`${f.wurzel}/${p.nextcloud_link}/01 Auftrag/Angebot A-26-140.pdf`, "%PDF-Probe");
const wurzel = (await app.inject(`/api/projekte/${p.id}/ablage`)).json();
expect(wurzel.eintraege.map((e: { name: string }) => e.name)).toEqual(["01 Auftrag", "02 Umsetzung", "03 Bilder"]);
const auftrag = (await app.inject(`/api/projekte/${p.id}/ablage?pfad=${encodeURIComponent("01 Auftrag")}`)).json();
expect(auftrag.eintraege).toEqual([
{ name: "03 Stundenlohnarb.", ordner: true, groesse: 0, geaendert: null },
{ name: "Angebot A-26-140.pdf", ordner: false, groesse: 10, geaendert: "2026-10-19T08:00:00.000Z" },
]);
const d = await app.inject(`/api/projekte/${p.id}/ablage/datei?pfad=${encodeURIComponent("01 Auftrag/Angebot A-26-140.pdf")}`);
expect(d.statusCode).toBe(200);
expect(d.body).toBe("%PDF-Probe");
expect((await app.inject(`/api/projekte/${p.id}/ablage?pfad=..%2F..`)).statusCode).toBe(400);
expect((await app.inject(`/api/projekte/${p.id}/ablage/datei?pfad=gibtsnicht.pdf`)).statusCode).toBe(404);
});
it("Fehler der Nextcloud verhindert das Speichern nicht", async () => {
f.ordner.clear(); // Wurzel fehlt: jede Anlage schlägt fehl
const r = await app.inject({ method: "POST", url: "/api/projekte", payload: { nummer: "A-26-131", bezeichnung: "Gaube", status: "angebot" } });
expect(r.statusCode).toBe(201);
expect(r.json().ordner_fehler).toMatch(/Nextcloud/);
f.ordner.add(f.wurzel);
const nochmal = (await app.inject({ method: "POST", url: `/api/projekte/${r.json().id}/ordner` })).json();
expect(nochmal.nextcloud_link).toBe("01 Angebot/A-26-131 Gaube");
});
it("Testversion: der erste neue Benutzer legt den bisherigen Inhaber mit an", async () => {
const r = await app.inject({ method: "POST", url: "/api/benutzer", payload: { anmeldename: "jan", name: "Jan", rolle: "mitarbeiter" } });
expect(r.statusCode, r.body).toBe(201);
const s = (await app.inject("/api/sitzung")).json();
expect(s.benutzer).toMatchObject({ anmeldename: "henning", rolle: "inhaber" });
expect(s.benutzer.id).toBeTruthy();
expect(s.auswahl.map((x: { name: string }) => x.name).sort()).toEqual(["Henning", "Jan"]);
// Passwörter gibt es in der Testversion nicht
expect((await app.inject({ method: "PATCH", url: `/api/benutzer/${r.json().id}`, payload: { passwort: "geheim123" } })).statusCode).toBe(400);
});
});
describe.skipIf(!url)("Sicherung einspielen (Umzug aus der Testversion)", () => {
let pool: Pool;
let app: FastifyInstance;
const sicherung = JSON.parse(readFileSync(new URL("./daten/v70-sicherung-2026-10-19.json", import.meta.url), "utf8"));
beforeAll(async () => {
pool = erstellePool(url!);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" });
});
afterAll(async () => {
await app?.close();
await pool?.end();
});
it("bringt jeden Datensatz mit derselben ID zurück", async () => {
expect((await app.inject({ method: "POST", url: "/api/import/v70", payload: sicherung })).statusCode).toBe(201);
await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...(await app.inject("/api/einstellungen")).json(), startsaldo: 1234500 } });
const kat = (await app.inject({ method: "POST", url: "/api/aufgaben-kategorien", payload: { name: "Büro" } })).json();
await app.inject({ method: "POST", url: "/api/aufgaben", payload: { text: "Angebot nachfassen", kategorie_id: kat.id } });
const vorher = (await app.inject("/api/export")).json();
expect(vorher.daten["aufgaben-kategorien"]).toHaveLength(1);
expect((await app.inject({ method: "POST", url: "/api/import/stand", payload: vorher })).statusCode).toBe(409);
expect((await app.inject({ method: "POST", url: "/api/import/stand", payload: { programm: "anders" } })).statusCode).toBe(400);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
const r = await app.inject({ method: "POST", url: "/api/import/stand", payload: vorher });
expect(r.statusCode, r.body).toBe(201);
expect(r.json().anzahl.vorgaenge).toBe(13);
const nachher = (await app.inject("/api/export")).json();
const ohneZeit = (d: Record<string, Record<string, unknown>[]>) =>
Object.fromEntries(Object.entries(d).map(([k, z]) => [k, z.map(({ angelegt_am, geaendert_am, ...rest }) => rest)]));
expect(ohneZeit(nachher.daten)).toEqual(ohneZeit(vorher.daten));
expect(nachher.einstellungen.startsaldo).toBe(1234500);
// neue Vorgänge bekommen Nummern hinter den übernommenen
const a = vorher.daten.abschnitte[0];
const v = await app.inject({ method: "POST", url: "/api/vorgaenge", payload: { abschnitt_id: a.id, name: "Neu", start: "2026-11-02", dauer: 1 } });
expect(v.statusCode, v.body).toBe(201);
expect(v.json().nummer).toBeGreaterThan(Math.max(...vorher.daten.vorgaenge.map((x: { nummer: number }) => x.nummer)));
});
});
describe.skipIf(!url)("Anmeldung und Rollen (U1, U2)", () => {
let pool: Pool;
let app: FastifyInstance;
const CODE = "einrichtung-123";
beforeAll(async () => {
pool = erstellePool(url!);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "passwort", einrichtungsCode: CODE });
});
afterAll(async () => {
await app?.close();
await pool?.end();
});
const keks = (r: { headers: Record<string, unknown> }) => String(r.headers["set-cookie"]).split(";")[0]!;
const als = (cookie: string, method: "GET" | "POST" | "PATCH" | "DELETE", u: string, payload?: object) =>
app.inject({ method, url: u, payload, headers: { cookie } });
const anmelden = async (anmeldename: string, passwort: string) => {
const r = await app.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename, passwort } });
expect(r.statusCode, r.body).toBe(200);
return keks(r);
};
let inhaber = "";
it("ohne Anmeldung nichts außer Status und Anmeldeseite", async () => {
expect((await app.inject("/api/projekte")).statusCode).toBe(401);
expect((await app.inject("/api/status")).statusCode).toBe(200);
expect((await app.inject("/api/sitzung")).json()).toMatchObject({ art: "passwort", benutzer: null, einrichtung: true });
});
it("Einrichtung legt den Inhaber nur mit dem richtigen Code an, und nur einmal", async () => {
const daten = { name: "Henning Schaarschmidt", anmeldename: "Henning", passwort: "sehrgeheim1" };
expect((await app.inject({ method: "POST", url: "/api/einrichtung", payload: { ...daten, code: "falsch" } })).statusCode).toBe(403);
expect((await app.inject({ method: "POST", url: "/api/einrichtung", payload: { ...daten, passwort: "kurz", code: CODE } })).statusCode).toBe(400);
const r = await app.inject({ method: "POST", url: "/api/einrichtung", payload: { ...daten, code: CODE } });
expect(r.statusCode, r.body).toBe(201);
expect(String(r.headers["set-cookie"])).toMatch(/HttpOnly; SameSite=Lax; Max-Age=7776000/);
inhaber = keks(r);
expect((await als(inhaber, "GET", "/api/sitzung")).json().benutzer).toMatchObject({ anmeldename: "henning", rolle: "inhaber" });
expect((await als(inhaber, "GET", "/api/projekte")).statusCode).toBe(200);
expect((await app.inject({ method: "POST", url: "/api/einrichtung", payload: { ...daten, anmeldename: "zweiter", code: CODE } })).statusCode).toBe(409);
});
it("falsches Passwort und Sperre nach fünf Fehlversuchen", async () => {
expect((await app.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename: "gibtsnicht", passwort: "x" } })).statusCode).toBe(401);
for (let i = 0; i < 5; i++) {
expect((await app.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename: "henning", passwort: "falsch" } })).statusCode).toBe(401);
}
expect((await app.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename: "henning", passwort: "sehrgeheim1" } })).statusCode).toBe(429);
// Groß/klein und Leerzeichen umgehen die Sperre nicht
expect((await app.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename: "HENNING ", passwort: "sehrgeheim1" } })).statusCode).toBe(429);
});
it("Büro und Mitarbeiter: jeder sieht nur, was zu seiner Rolle gehört (E27, P13)", async () => {
const buero = await als(inhaber, "POST", "/api/benutzer", { anmeldename: "buero", name: "Büro", rolle: "buero", passwort: "buero12345" });
expect(buero.statusCode, buero.body).toBe(201);
expect(buero.json()).not.toHaveProperty("passwort");
expect(buero.json().hat_passwort).toBe(true);
const ma = (await als(inhaber, "POST", "/api/benutzer", { anmeldename: "jan", name: "Jan Zimmermann", rolle: "mitarbeiter", passwort: "jan123456" })).json();
expect(ma.kontakt_id).toBeTruthy();
const kontakt = (await als(inhaber, "GET", `/api/kontakte/${ma.kontakt_id}`)).json();
expect(kontakt).toMatchObject({ name: "Jan Zimmermann", rolle: "mitarbeiter" });
// Jan ist auf einem von zwei Projekten eingeteilt
const neu = async (pfad: string, d: object) => (await als(inhaber, "POST", `/api/${pfad}`, d)).json();
const p1 = await neu("projekte", { nummer: "P-26-101", bezeichnung: "Carport Kruse", baustelle_ort: "Mölln", umsatz_netto: 1_000_000 });
const p2 = await neu("projekte", { nummer: "P-26-102", bezeichnung: "Dach Lange" });
const a1 = await neu("abschnitte", { projekt_id: p1.id, name: "Montage" });
const a2 = await neu("abschnitte", { projekt_id: p2.id, name: "Montage" });
const v1 = await neu("vorgaenge", { abschnitt_id: a1.id, name: "Abbund", start: "2026-11-02", dauer: 2 });
await neu("vorgaenge", { abschnitt_id: a2.id, name: "Richten", start: "2026-11-02", dauer: 2 });
await neu("besetzungen", { vorgang_id: v1.id, kontakt_id: ma.kontakt_id });
const b = await anmelden("buero", "buero12345");
expect((await als(b, "GET", "/api/projekte")).statusCode).toBe(200);
expect((await als(b, "GET", "/api/benutzer")).statusCode).toBe(403);
expect((await als(b, "GET", "/api/export")).statusCode).toBe(403);
expect((await als(b, "PATCH", `/api/projekte/${p2.id}`, { notiz: "Büro war hier" })).statusCode).toBe(200);
const j = await anmelden("jan", "jan123456");
for (const u of ["/api/projekte", "/api/zahlungen", "/api/kontakte", "/api/terminplan", "/api/uebersicht", "/api/liquiditaet", "/api/benutzer", "/api/einstellungen"]) {
expect((await als(j, "GET", u)).statusCode, u).toBe(403);
}
expect((await als(j, "PATCH", `/api/projekte/${p1.id}`, { umsatz_netto: 1 })).statusCode).toBe(403);
const e = (await als(j, "GET", "/api/ich/einsaetze?heute=2026-11-02")).json();
expect(e.einsaetze).toHaveLength(1);
expect(e.einsaetze[0]).toMatchObject({ name: "Abbund", nummer: "P-26-101", baustelle_ort: "Mölln", anfang: "2026-11-02", ende: "2026-11-03" });
expect(JSON.stringify(e)).not.toMatch(/umsatz|netto/);
// Ablage nur für eigene Projekte; ohne Nextcloud kommt beim eigenen der Hinweis
expect((await als(j, "GET", `/api/projekte/${p2.id}/ablage`)).statusCode).toBe(403);
expect((await als(j, "GET", `/api/projekte/${p1.id}/ablage`)).statusCode).toBe(409);
});
it("Passwort ändern meldet andere Geräte ab; gesperrte Benutzer kommen nicht mehr rein", async () => {
const j1 = await anmelden("jan", "jan123456");
const j2 = await anmelden("jan", "jan123456");
expect((await als(j1, "POST", "/api/ich/passwort", { alt: "falsch", neu: "neuespasswort" })).statusCode).toBe(400);
expect((await als(j1, "POST", "/api/ich/passwort", { alt: "jan123456", neu: "neuespasswort" })).statusCode).toBe(200);
expect((await als(j1, "GET", "/api/ich/einsaetze")).statusCode).toBe(200);
expect((await als(j2, "GET", "/api/ich/einsaetze")).statusCode).toBe(401);
const jan = (await als(inhaber, "GET", "/api/benutzer")).json().find((x: { anmeldename: string }) => x.anmeldename === "jan");
expect((await als(inhaber, "PATCH", `/api/benutzer/${jan.id}`, { aktiv: false })).statusCode).toBe(200);
expect((await als(j1, "GET", "/api/ich/einsaetze")).statusCode).toBe(401);
expect((await app.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename: "jan", passwort: "neuespasswort" } })).statusCode).toBe(401);
});
it("es bleibt immer ein Inhaber; Passwörter stehen nirgends im Klartext oder im Protokoll", async () => {
const ich = (await als(inhaber, "GET", "/api/sitzung")).json().benutzer;
expect((await als(inhaber, "PATCH", `/api/benutzer/${ich.id}`, { rolle: "buero" })).statusCode).toBe(409);
expect((await als(inhaber, "DELETE", `/api/benutzer/${ich.id}`)).statusCode).toBe(409);
const prot = (await pool.query("select vorher, nachher from protokoll where tabelle = 'benutzer'")).rows;
expect(prot.length).toBeGreaterThan(0);
expect(JSON.stringify(prot)).not.toMatch(/passwort|scrypt/);
const hash = (await pool.query("select passwort from benutzer where anmeldename = 'henning'")).rows[0].passwort;
expect(hash).toMatch(/^scrypt\$/);
expect(hash).not.toContain("sehrgeheim1");
const sicherung = (await als(inhaber, "GET", "/api/export")).json();
expect(sicherung.daten.benutzer.length).toBe(3);
expect(JSON.stringify(sicherung)).not.toMatch(/scrypt/);
expect((await pool.query("select id from sitzung")).rows.every((r) => /^[0-9a-f]{64}$/.test(r.id))).toBe(true);
});
it("Anfragen von fremden Seiten werden abgewiesen", async () => {
const r = await app.inject({ method: "POST", url: "/api/aufgaben", payload: { text: "x" }, headers: { cookie: inhaber, origin: "https://boese.example", host: "betrieb.schaarschmidt-holzbau.de" } });
expect(r.statusCode).toBe(403);
const ok = await app.inject({ method: "POST", url: "/api/aufgaben", payload: { text: "x" }, headers: { cookie: inhaber, origin: "https://betrieb.schaarschmidt-holzbau.de", host: "betrieb.schaarschmidt-holzbau.de" } });
expect(ok.statusCode).toBe(201);
});
it("Abmelden beendet die Sitzung", async () => {
const b = await anmelden("buero", "buero12345");
expect((await als(b, "POST", "/api/abmeldung")).statusCode).toBe(200);
expect((await als(b, "GET", "/api/projekte")).statusCode).toBe(401);
});
it("Testversion: wer gewählt ist, bekommt dessen Rechte", async () => {
const t = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" });
const jan = (await pool.query("select id from benutzer where anmeldename = 'jan'")).rows[0].id;
await pool.query("update benutzer set aktiv = true where id = $1", [jan]);
expect((await t.inject("/api/projekte")).statusCode).toBe(200);
expect((await t.inject({ url: "/api/projekte", headers: { "x-test-benutzer": jan } })).statusCode).toBe(403);
expect((await t.inject({ url: "/api/sitzung", headers: { "x-test-benutzer": jan } })).json()).toMatchObject({ art: "testversion", benutzer: { anmeldename: "jan" } });
expect((await t.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename: "jan", passwort: "neuespasswort" } })).statusCode).toBe(400);
await t.close();
});
});