// 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"; import { feiertag } from "../src/domain/kalender.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[]>) => 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))); }); it("Sicherung von vor 0.12: Vorgänge behalten ihre Dauer (T15)", async () => { const vorher = (await app.inject("/api/export")).json(); vorher.daten.vorgaenge = vorher.daten.vorgaenge.map(({ dauer_fest, ...v }: { dauer_fest: boolean }) => v); await pool.query("drop schema public cascade; create schema public;"); await migriere(pool); expect((await app.inject({ method: "POST", url: "/api/import/stand", payload: vorher })).statusCode).toBe(201); expect((await pool.query("select bool_and(dauer_fest) as alle from vorgang")).rows[0].alle).toBe(true); }); it("Ansichten der Tabellen je Benutzer: speichern, Sicherung, Umzug", async () => { const ansicht = { aktuell: { sort: [["faellig", "auf"]], filter: { erledigt: ["erledigt"] }, zeit: { faellig: "bis-wochenende" }, aus: [] }, name: "Meine Woche", ansichten: [] }; expect((await app.inject({ method: "PUT", url: "/api/ich/ansichten/aufgaben", payload: ansicht })).statusCode).toBe(204); expect((await app.inject({ method: "PUT", url: "/api/ich/ansichten/Böse Tabelle", payload: ansicht })).statusCode).toBe(400); expect((await app.inject({ method: "PUT", url: "/api/ich/ansichten/aufgaben", payload: { x: "y".repeat(100_001) } })).statusCode).toBe(413); expect((await app.inject("/api/ich/ansichten")).json()).toEqual({ aufgaben: ansicht }); const stand = (await app.inject("/api/export")).json(); expect(stand.daten.ansichten).toHaveLength(1); // auf dem Server gibt es schon eine Ansicht des Inhabers: die aus der Sicherung gewinnt, die Daten zählen trotzdem als leer await pool.query("drop schema public cascade; create schema public;"); await migriere(pool); expect((await app.inject({ method: "PUT", url: "/api/ich/ansichten/aufgaben", payload: { name: null } })).statusCode).toBe(204); const r = await app.inject({ method: "POST", url: "/api/import/stand", payload: stand }); expect(r.statusCode, r.body).toBe(201); expect((await app.inject("/api/ich/ansichten")).json()).toEqual({ aufgaben: ansicht }); }); }); 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(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("Personal: Modell, Abwesenheit, Urlaubskonto; den Stundenlohn sieht nur der Inhaber (M1, M8, M4, U2)", async () => { const jan = (await pool.query("select kontakt_id from benutzer where anmeldename = 'jan'")).rows[0].kontakt_id; const m = await als(inhaber, "POST", "/api/mitarbeiter", { kontakt_id: jan, personalnummer: "17", lohn_cent: 2850, urlaubstage: 28 }); expect(m.statusCode, m.body).toBe(201); expect(m.json().lohn_cent).toBe(2850); const mod = await als(inhaber, "POST", "/api/arbeitszeitmodelle", { kontakt_id: jan, gueltig_ab: "2026-01-01", stunden: [8, 8, 8, 8, 6.5, 0, 0] }); expect(mod.statusCode, mod.body).toBe(201); expect(mod.json().stunden).toEqual([8, 8, 8, 8, 6.5, 0, 0]); expect((await als(inhaber, "POST", "/api/arbeitszeitmodelle", { kontakt_id: jan, gueltig_ab: "2026-02-01", stunden: [8, 8] })).statusCode).toBe(400); expect((await als(inhaber, "POST", "/api/abwesenheiten", { kontakt_id: jan, art: "urlaub", von: "2026-11-02", bis: "2026-11-06" })).statusCode).toBe(201); expect((await als(inhaber, "POST", "/api/abwesenheiten", { kontakt_id: jan, art: "urlaub", von: "2026-11-09", bis: "2026-11-08" })).statusCode).toBe(400); expect((await als(inhaber, "POST", "/api/urlaubskonten", { kontakt_id: jan, jahr: 2026, uebertrag: 3 })).statusCode).toBe(201); const b = await anmelden("buero", "buero12345"); const liste = (await als(b, "GET", "/api/personal?heute=2026-11-03")).json(); const j = liste.find((x: { id: string }) => x.id === jan); expect(j).toMatchObject({ stunden: [8, 8, 8, 8, 6.5, 0, 0], eigenesModell: true, heute: { soll: 8, frei: 0 } }); expect(j.urlaub).toMatchObject({ anspruch: 28, uebertrag: 3, genommen: 2, geplant: 3, rest: 26 }); expect(j.stammdaten.lohn_cent).toBeUndefined(); expect((await als(b, "GET", "/api/mitarbeiter")).json()[0]).not.toHaveProperty("lohn_cent"); expect((await als(b, "PATCH", `/api/mitarbeiter/${m.json().id}`, { lohn_cent: 9999 })).statusCode).toBe(403); expect((await als(b, "PATCH", `/api/mitarbeiter/${m.json().id}`, { personalnummer: "18" })).json()).not.toHaveProperty("lohn_cent"); const v = (await als(b, "GET", `/api/verfuegbarkeit?von=2026-11-06&bis=2026-11-09&kontakt_id=${jan}`)).json(); expect(v[0].tage.map((t: { frei: number }) => t.frei)).toEqual([0, 0, 0, 8]); // Mitarbeiter selbst kommen an die Personalliste nicht heran (Jan wurde oben gesperrt) const janB = (await pool.query("select id from benutzer where anmeldename = 'jan'")).rows[0].id; expect((await als(inhaber, "PATCH", `/api/benutzer/${janB}`, { aktiv: true })).statusCode).toBe(200); const jj = await anmelden("jan", "neuespasswort"); expect((await als(jj, "GET", "/api/personal")).statusCode).toBe(403); expect((await als(jj, "GET", "/api/mitarbeiter")).statusCode).toBe(403); }); it("Zeiterfassung: ein Eintrag je Tag, Pausenabzug nach M3, Anteile je Vorgang (Z1, E21)", async () => { const heute = new Date().toISOString().slice(0, 10); const tag = (n: number) => new Date(Date.now() + n * 86400000).toISOString().slice(0, 10); const jj = await anmelden("jan", "neuespasswort"); const ich = (await als(jj, "GET", "/api/ich/zeiten")).json(); expect(ich.angestellt).toBe(true); expect(ich.projekte.map((p: { nummer: string }) => p.nummer)).toContain("P-26-101"); expect(JSON.stringify(ich)).not.toMatch(/umsatz|netto"|lohn/); const v1 = ich.einsaetze[0]; expect(v1).toMatchObject({ name: "Abbund" }); // 7:00 bis 16:10 ohne Pause: 9:10 da, voller Abzug 45 Min → 8:25 (Standard „voll“) const r = await als(jj, "PUT", `/api/ich/zeiten/${heute}`, { beginn: "7:00", ende: "16:10", anteile: [{ vorgang_id: v1.id, taetigkeit: "Abbund Sparren" }] }); expect(r.statusCode, r.body).toBe(200); expect(r.json()).toMatchObject({ beginn: "07:00", ende: "16:10", pause_min: 0, abzug_min: 45, netto_min: 505, ueber_zehn: false }); expect(r.json().anteile).toMatchObject([{ vorgang_id: v1.id, projekt_id: v1.projekt_id, stunden: 8.42, taetigkeit: "Abbund Sparren" }]); // gleicher Tag noch einmal: ersetzt, aufgeteilt auf zwei Baustellen const p2 = ich.projekte.find((p: { nummer: string }) => p.nummer === "P-26-102"); const falsch = await als(jj, "PUT", `/api/ich/zeiten/${heute}`, { beginn: "07:00", ende: "15:30", pause_min: 30, anteile: [{ vorgang_id: v1.id, stunden: 4 }, { projekt_id: p2.id, stunden: 3 }] }); expect(falsch.statusCode).toBe(400); expect(falsch.json().fehler).toMatch(/ergeben 7, gearbeitet wurden 8 Stunden/); const zwei = await als(jj, "PUT", `/api/ich/zeiten/${heute}`, { beginn: "07:00", ende: "15:30", pause_min: 30, anteile: [{ vorgang_id: v1.id, stunden: 5 }, { projekt_id: p2.id, stunden: 3 }] }); expect(zwei.statusCode, zwei.body).toBe(200); expect(zwei.json()).toMatchObject({ pause_min: 30, abzug_min: 0, netto_min: 480 }); expect((await pool.query("select count(*) as n from zeiteintrag")).rows[0].n).toBe(1); expect((await als(jj, "PUT", `/api/ich/zeiten/${tag(1)}`, { beginn: "07:00", ende: "15:00" })).statusCode).toBe(400); expect((await als(jj, "PUT", `/api/ich/zeiten/${tag(-20)}`, { beginn: "07:00", ende: "15:00" })).statusCode).toBe(403); expect((await als(jj, "PUT", `/api/ich/zeiten/${tag(-3)}`, { beginn: "15:00", ende: "07:00" })).statusCode).toBe(400); expect((await als(jj, "GET", `/api/zeiten?von=${tag(-30)}&bis=${heute}`)).statusCode).toBe(403); // Inhaber bucht für sich selbst: Kontakt entsteht, keine Pausenregel; und trägt für Jan nach const selbst = await als(inhaber, "PUT", `/api/ich/zeiten/${heute}`, { beginn: "06:00", ende: "17:00", anteile: [{ projekt_id: p2.id }] }); expect(selbst.statusCode, selbst.body).toBe(200); expect(selbst.json()).toMatchObject({ abzug_min: 0, netto_min: 660, ueber_zehn: true }); const jan = (await pool.query("select kontakt_id from benutzer where anmeldename = 'jan'")).rows[0].kontakt_id; expect((await als(inhaber, "PUT", `/api/zeiten/${jan}/${tag(-20)}`, { beginn: "07:00", ende: "13:00" })).statusCode).toBe(200); const alle = (await als(inhaber, "GET", `/api/zeiten?von=${tag(-30)}&bis=${heute}`)).json(); expect(alle.tage).toHaveLength(3); expect(alle.leute.find((l: { id: string }) => l.id === jan).angestellt).toBe(true); expect((await als(inhaber, "GET", "/api/zeiten/projekte")).json()).toEqual({ [v1.projekt_id]: 5, [p2.id]: 14 }); // 2 Jahre aufbewahren: Kontakt mit Stunden lässt sich nicht löschen; Sicherung enthält die Stunden expect((await als(inhaber, "DELETE", `/api/kontakte/${jan}`)).statusCode).toBe(409); const sicherung = (await als(inhaber, "GET", "/api/export")).json(); expect(sicherung.daten.zeiteintraege).toHaveLength(3); expect(sicherung.daten.zeitanteile).toHaveLength(4); }); it("Stundenliste fürs Steuerbüro: nur Angestellte, Excel-tauglich, Mitarbeiter kommen nicht heran (M5)", async () => { const heute = new Date().toISOString().slice(0, 10); const monat = heute.slice(0, 7); const r = await als(inhaber, "GET", `/api/zeiten/csv?monat=${monat}`); expect(r.statusCode, r.body).toBe(200); expect(r.headers["content-type"]).toMatch(/text\/csv/); expect(r.headers["content-disposition"]).toContain(`stunden-${monat}.csv`); expect(r.rawPayload[0]).toBe(0xef); // BOM, damit Excel die Umlaute richtig liest const zeilen = r.body.replace(/^\uFEFF/, "").split("\r\n"); expect(zeilen[0]).toBe("Personalnr.;Name;Datum;Tag;Beginn;Ende;Pause Min.;Arbeitszeit Std.;Soll Std.;Abwesenheit;Abwesend Std.;Baustellen;Bemerkung"); const d = `${heute.slice(8, 10)}.${heute.slice(5, 7)}.${heute.slice(0, 4)}`; const tag = zeilen.find((z) => z.startsWith("18;Jan Zimmermann;" + d))!; expect(tag).toMatch(/;07:00;15:30;30;8,00;/); expect(tag).toMatch(/"P-26-101 Abbund 5,00; P-26-102 3,00";$/); expect(zeilen.some((z) => z.startsWith("18;Jan Zimmermann;Summe "))).toBe(true); expect(r.body).not.toContain("Henning"); expect((await als(inhaber, "GET", "/api/zeiten/csv?monat=2026-13")).statusCode).toBe(400); const b = await anmelden("buero", "buero12345"); expect((await als(b, "GET", `/api/zeiten/csv?monat=${monat}`)).statusCode).toBe(200); const jj = await anmelden("jan", "neuespasswort"); expect((await als(jj, "GET", `/api/zeiten/csv?monat=${monat}`)).statusCode).toBe(403); }); it("Urlaubsantrag: Mitarbeiter beantragt, sieht Rest und Einsätze, Henning entscheidet mit Antwort (M10)", async () => { // drei Arbeitstage Di–Do ohne Feiertag, mindestens 60 Tage voraus const plus = (d: string, n: number) => new Date(Date.parse(`${d}T00:00:00Z`) + n * 86400000).toISOString().slice(0, 10); let von = plus(new Date().toISOString().slice(0, 10), 60); while (new Date(`${von}T00:00:00Z`).getUTCDay() !== 2 || [0, 1, 2].some((i) => feiertag(plus(von, i)))) von = plus(von, 1); const bis = plus(von, 2); const jj = await anmelden("jan", "neuespasswort"); const konto = (await als(jj, "GET", "/api/ich/urlaub")).json(); expect(konto.konto).toHaveProperty("rest"); const p = await als(jj, "GET", `/api/ich/urlaub/pruefen?von=${von}&bis=${bis}`); expect(p.statusCode, p.body).toBe(200); expect(p.json()).toMatchObject({ tage: 3, einsaetze: [] }); expect((await als(jj, "POST", "/api/ich/urlaub", { von: "2020-01-07", bis: "2020-01-08" })).statusCode).toBe(400); expect((await als(jj, "POST", "/api/ich/urlaub", { von, bis, halbtag: true })).statusCode).toBe(400); const samstag = plus(von, 4); expect((await als(jj, "POST", "/api/ich/urlaub", { von: samstag, bis: plus(samstag, 1) })).json().fehler).toMatch(/keine Arbeitstage/); const a = await als(jj, "POST", "/api/ich/urlaub", { von, bis, notiz: "Hochzeit" }); expect(a.statusCode, a.body).toBe(201); expect(a.json()).toMatchObject({ status: "beantragt", tage: 3, kontakt_id: expect.any(String) }); expect((await als(jj, "POST", "/api/ich/urlaub", { von: bis, bis: bis })).statusCode).toBe(409); // beantragt sperrt noch nichts const jan = a.json().kontakt_id; expect((await als(inhaber, "GET", `/api/verfuegbarkeit?von=${von}&bis=${von}&kontakt_id=${jan}`)).json()[0].tage[0].frei).toBe(8); const u = (await als(inhaber, "GET", "/api/uebersicht")).json(); expect(u.warnungen[0]).toMatchObject({ art: "urlaub", ziel: `mitarbeiter-${jan}`, text: expect.stringMatching(/^Urlaubsantrag von Jan Zimmermann: /) }); const b = await anmelden("buero", "buero12345"); const offen = (await als(b, "GET", "/api/urlaub/antraege")).json(); expect(offen).toHaveLength(1); expect(offen[0]).toMatchObject({ name: "Jan Zimmermann", tage: 3, notiz: "Hochzeit" }); expect(offen[0].rest_danach).toBe(offen[0].rest_vorher - 3); expect((await als(jj, "POST", `/api/urlaub/${a.json().id}/entscheidung`, { status: "genehmigt" })).statusCode).toBe(403); expect((await als(jj, "GET", "/api/urlaub/antraege")).statusCode).toBe(403); const ok = await als(inhaber, "POST", `/api/urlaub/${a.json().id}/entscheidung`, { status: "genehmigt", antwort: "Viel Spaß!" }); expect(ok.statusCode, ok.body).toBe(200); expect((await als(inhaber, "POST", `/api/urlaub/${a.json().id}/entscheidung`, { status: "abgelehnt" })).statusCode).toBe(409); const meine = (await als(jj, "GET", "/api/ich/urlaub")).json(); expect(meine.antraege.find((x: { id: string }) => x.id === a.json().id)).toMatchObject({ status: "genehmigt", antwort: "Viel Spaß!", tage: 3 }); expect((await als(jj, "DELETE", `/api/ich/urlaub/${a.json().id}`)).statusCode).toBe(409); expect((await als(inhaber, "GET", `/api/verfuegbarkeit?von=${von}&bis=${von}&kontakt_id=${jan}`)).json()[0].tage[0].frei).toBe(0); expect((await als(inhaber, "GET", "/api/uebersicht")).json().warnungen.some((w: { art: string }) => w.art === "urlaub")).toBe(false); // zweiter Antrag, zurückgezogen const z = await als(jj, "POST", "/api/ich/urlaub", { von: plus(von, 7), halbtag: true }); expect(z.statusCode, z.body).toBe(201); expect(z.json()).toMatchObject({ bis: plus(von, 7), halbtag: true, tage: 0.5 }); expect((await als(jj, "DELETE", `/api/ich/urlaub/${z.json().id}`)).statusCode).toBe(204); }); it("Dauer aus Stunden und Besetzung, Auslastung im Terminplan (T15, T16)", async () => { const tp = (await als(inhaber, "GET", "/api/terminplan")).json(); const abschnitt = tp.vorgaenge.find((v: { name: string }) => v.name === "Abbund").abschnitt_id; // ein Montag gut vier Monate voraus, die Woche ohne Feiertag const plus = (d: string, n: number) => new Date(Date.parse(`${d}T00:00:00Z`) + n * 86400000).toISOString().slice(0, 10); let start = plus(new Date().toISOString().slice(0, 10), 120); while (new Date(`${start}T00:00:00Z`).getUTCDay() !== 1 || [0, 1, 2, 3, 7].some((i) => feiertag(plus(start, i)))) start = plus(start, 1); const v = (await als(inhaber, "POST", "/api/vorgaenge", { abschnitt_id: abschnitt, name: "Dach decken", start, dauer: 1, stunden: 32 })).json(); expect(v.dauer_fest).toBe(false); const jan = (await pool.query("select kontakt_id from benutzer where anmeldename = 'jan'")).rows[0].kontakt_id; expect((await als(inhaber, "POST", "/api/besetzungen", { vorgang_id: v.id, kontakt_id: jan })).statusCode).toBe(201); const lies = async () => (await als(inhaber, "GET", "/api/terminplan")).json().vorgaenge.find((x: { id: string }) => x.id === v.id); expect(await lies()).toMatchObject({ dauer: 4, dauer_besetzung: 4, ende: plus(start, 3) }); // Jan Mo–Do je 8 Std. // zweite Person: halb so lang const kolonne = (await als(inhaber, "POST", "/api/besetzungen", { vorgang_id: v.id, platzhalter: "Helfer", personen: 1 })).json(); expect((await lies()).dauer).toBe(2); await als(inhaber, "DELETE", `/api/besetzungen/${kolonne.id}`); // genehmigter Urlaub am Dienstag: einen Tag länger, Balken an dem Tag heller const u = (await als(inhaber, "POST", "/api/abwesenheiten", { kontakt_id: jan, art: "frei", von: plus(start, 1), bis: plus(start, 1), status: "genehmigt" })).json(); expect(await lies()).toMatchObject({ dauer: 5, reduziert: [plus(start, 1)] }); await als(inhaber, "DELETE", `/api/abwesenheiten/${u.id}`); expect((await lies()).dauer).toBe(4); // von Hand geändert: Dauer fest, die Berechnung bleibt als Abweichung sichtbar const fest = await als(inhaber, "PATCH", `/api/vorgaenge/${v.id}`, { dauer: 6 }); expect(fest.json()).toMatchObject({ dauer: 6, dauer_fest: true }); expect(await lies()).toMatchObject({ dauer: 6, dauer_besetzung: 4, dauer_fest: true }); expect((await als(inhaber, "PATCH", `/api/vorgaenge/${v.id}`, { dauer_fest: false })).statusCode).toBe(200); expect((await lies()).dauer).toBe(4); // Auslastung: Jan steht im Team, die Woche des Vorgangs zählt seine 32 Stunden als geplant const plan = (await als(inhaber, "GET", "/api/terminplan")).json(); expect(plan.team).toContain(jan); const w = plan.auslastung.find((x: { ab: string }) => x.ab === start); expect(w.personen.find((x: { kontakt_id: string }) => x.kontakt_id === jan).geplant).toBe(32); }); 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(); }); }); describe.skipIf(!url)("Zahlungen, Kosten und Aufgaben im Terminplan", () => { 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 neu = 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 aendern = async (pfad: string, body: object) => { const r = await app.inject({ method: "PATCH", url: `/api/${pfad}`, payload: body }); expect(r.statusCode, r.body).toBe(200); return r.json(); }; const hole = async (pfad: string) => (await app.inject(`/api/${pfad}`)).json(); it("Aufgaben aus der Vorlage hängen am Vorgang und wandern mit; gelöschte kommen nicht wieder", async () => { const p = await neu("projekte", { nummer: "P-26-200", bezeichnung: "Carport Lindenweg", status: "angebot" }); const a = await neu("abschnitte", { projekt_id: p.id, name: "Bauablauf" }); const abbund = await neu("vorgaenge", { abschnitt_id: a.id, name: "Abbund", start: "2027-03-08", dauer: 3 }); // nur beauftragte Projekte bekommen Vorlage-Aufgaben expect((await hole("aufgaben")).filter((x: { projekt_id: string }) => x.projekt_id === p.id)).toHaveLength(0); await aendern(`projekte/${p.id}`, { status: "auftrag" }); const auf = (await hole("aufgaben")).filter((x: { projekt_id: string }) => x.projekt_id === p.id); // Gerüst wartet auf einen Vorgang „Richten“ expect(auf.map((x: { text: string }) => x.text).sort()).toEqual(["Material bestellen", "Statik anfordern", "Subunternehmer beauftragen"]); const material = auf.find((x: { text: string }) => x.text === "Material bestellen"); // 7 Arbeitstage (Mo–Do) vor Montag, 8.3.2027 expect(material).toMatchObject({ vorgang_id: abbund.id, bezug_art: "AA", bezug_tage: -7, faellig_am: "2027-02-23" }); // Abbund eine Woche später: die Aufgabe geht mit await aendern(`vorgaenge/${abbund.id}`, { start: "2027-03-15" }); expect((await hole(`aufgaben/${material.id}`)).faellig_am).toBe("2027-03-02"); // Fälligkeit von Hand (Raute gezogen): neuer Versatz, bleibt verknüpft expect(await aendern(`aufgaben/${material.id}`, { faellig_am: "2027-03-08" })).toMatchObject({ vorgang_id: abbund.id, bezug_tage: -4 }); await aendern(`vorgaenge/${abbund.id}`, { start: "2027-03-22" }); expect((await hole(`aufgaben/${material.id}`)).faellig_am).toBe("2027-03-15"); // erledigt: bleibt stehen await aendern(`aufgaben/${material.id}`, { erledigt_am: "2026-10-20T10:00:00Z" }); await aendern(`vorgaenge/${abbund.id}`, { start: "2027-03-29" }); expect((await hole(`aufgaben/${material.id}`)).faellig_am).toBe("2027-03-15"); // Richten kommt dazu: jetzt auch das Gerüst await neu("vorgaenge", { abschnitt_id: a.id, name: "Richten", start: "2027-04-05", dauer: 1 }); const statik = auf.find((x: { text: string }) => x.text === "Statik anfordern"); await app.inject({ method: "DELETE", url: `/api/aufgaben/${statik.id}` }); expect((await app.inject({ method: "POST", url: "/api/vorlage/anwenden" })).json()).toEqual({ neu: 0 }); const jetzt = (await hole("aufgaben")).filter((x: { projekt_id: string }) => x.projekt_id === p.id).map((x: { text: string }) => x.text).sort(); expect(jetzt).toEqual(["Gerüst bestellen", "Material bestellen", "Subunternehmer beauftragen"]); // im Terminplan stehen sie beim Projekt expect((await hole("terminplan")).aufgaben.filter((x: { projekt_id: string }) => x.projekt_id === p.id)).toHaveLength(3); }); it("neue Vorlage-Einträge gelten auch für laufende Projekte; schon angefangene Vorgänge bekommen keine Aufgabe mehr", async () => { const p = await neu("projekte", { nummer: "P-26-201", bezeichnung: "Gaube Bergstraße", status: "ausfuehrung" }); const a = await neu("abschnitte", { projekt_id: p.id, name: "Bauablauf" }); await neu("vorgaenge", { abschnitt_id: a.id, name: "Abbund", start: "2026-01-05", dauer: 2 }); await neu("vorgaenge", { abschnitt_id: a.id, name: "Dämmung", start: "2027-05-03", dauer: 2 }); expect((await hole("aufgaben")).filter((x: { projekt_id: string }) => x.projekt_id === p.id)).toHaveLength(0); const e = await hole("einstellungen"); const r = await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...e, aufgabenVorlage: [...e.aufgabenVorlage, { id: "daemmung", text: "Dämmstoff abrufen", bezug: "dämm", art: "AA", tage: -3, kategorie_id: null }] } }); expect(r.statusCode, r.body).toBe(200); const auf = (await hole("aufgaben")).filter((x: { projekt_id: string }) => x.projekt_id === p.id); expect(auf).toMatchObject([{ text: "Dämmstoff abrufen", faellig_am: "2027-04-27" }]); // schon überfällig: kommt nicht (Vorgang in drei Tagen, Aufgabe 15 Arbeitstage davor) const q = await neu("projekte", { nummer: "P-26-204", bezeichnung: "Vordach Kirchweg", status: "auftrag" }); const qa = await neu("abschnitte", { projekt_id: q.id, name: "Bauablauf" }); const bald = new Date(Date.now() + 3 * 86400000).toISOString().slice(0, 10); await neu("vorgaenge", { abschnitt_id: qa.id, name: "Abbund", start: bald, dauer: 2 }); const texte = (await hole("aufgaben")).filter((x: { projekt_id: string }) => x.projekt_id === q.id).map((x: { text: string }) => x.text); expect(texte).not.toContain("Statik anfordern"); }); it("Kosten und Raten hängen mit Versatz am Vorgang; Liquidität folgt", async () => { const p = await neu("projekte", { nummer: "P-26-202", bezeichnung: "Anbau Seeweg", status: "auftrag", umsatz_netto: 1_000_000 }); const a = await neu("abschnitte", { projekt_id: p.id, name: "Bauablauf" }); const v = await neu("vorgaenge", { abschnitt_id: a.id, name: "Montage", start: "2027-06-07", dauer: 4 }); const k = await neu("kosten", { projekt_id: p.id, art: "material", bezeichnung: "Holz", netto: 300_000, termin: "2027-06-01", vorgang_id: v.id, bezug_art: "AA", bezug_tage: -2 }); expect((await hole(`kosten/${k.id}`)).termin).toBe("2027-06-02"); await aendern(`vorgaenge/${v.id}`, { start: "2027-06-14" }); expect((await hole(`kosten/${k.id}`)).termin).toBe("2027-06-09"); const tp = await hole("terminplan"); expect(tp.kosten.find((x: { id: string }) => x.id === k.id)).toMatchObject({ vorgang_id: v.id, bezug_art: "AA", bezug_tage: -2 }); // Raten: EE mit Versatz const z = (await hole("zahlungen")).filter((x: { projekt_id: string }) => x.projekt_id === p.id); expect(z).toHaveLength(4); const schluss = z.find((x: { art: string }) => x.art === "schluss"); await aendern(`zahlungen/${schluss.id}`, { termin: "2027-06-23" }); expect((await hole(`zahlungen/${schluss.id}`))).toMatchObject({ vorgang_id: v.id, bezug_art: "EE", bezug_tage: 3 }); await aendern(`vorgaenge/${v.id}`, { start: "2027-06-21" }); expect((await hole(`zahlungen/${schluss.id}`)).termin).toBe("2027-06-30"); }); it("Schlussrechnung ohne Betrag ist der Rest aus Auftragswert und allen anderen Raten", async () => { const p = await neu("projekte", { nummer: "P-26-203", bezeichnung: "Dachsanierung Mühlenweg", umsatz_netto: 5_000_000 }); await neu("zahlungen", { projekt_id: p.id, art: "anzahlung", bezeichnung: "Anzahlung", netto: 1_500_000, termin: "2027-01-04", status: "bezahlt" }); const ab = await neu("zahlungen", { projekt_id: p.id, art: "abschlag", bezeichnung: "1. Abschlag", netto: 2_000_000, termin: "2027-02-01", status: "gestellt" }); const s = await neu("zahlungen", { projekt_id: p.id, art: "schluss", bezeichnung: "Schlussrechnung", netto: 0, rest: true, termin: "2027-03-01" }); expect((await hole(`zahlungen/${s.id}`)).netto).toBe(1_500_000); await aendern(`zahlungen/${ab.id}`, { netto: 2_500_000 }); expect((await hole(`zahlungen/${s.id}`)).netto).toBe(1_000_000); await aendern(`projekte/${p.id}`, { umsatz_netto: 5_600_000 }); expect((await hole(`zahlungen/${s.id}`)).netto).toBe(1_600_000); // eigener Betrag: nicht mehr automatisch await aendern(`zahlungen/${s.id}`, { netto: 1_200_000, rest: false }); await aendern(`projekte/${p.id}`, { umsatz_netto: 6_000_000 }); expect((await hole(`zahlungen/${s.id}`)).netto).toBe(1_200_000); }); }); describe.skipIf(!url)("Kolonnen und Subunternehmer (0.15)", () => { 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 neu = 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 aendern = async (pfad: string, body: object) => { const r = await app.inject({ method: "PATCH", url: `/api/${pfad}`, payload: body }); expect(r.statusCode, r.body).toBe(200); return r.json(); }; const hole = async (pfad: string) => (await app.inject(`/api/${pfad}`)).json(); type K = { kontakt_id: string; besetzung_teil: string; netto: number; termin: string; zahlungsziel_tage: number | null; automatisch: boolean; id: string; bezeichnung: string }; const subKosten = async (id: string) => ((await hole("kosten")) as K[]).filter((k) => k.kontakt_id === id).sort((a, b) => a.besetzung_teil.localeCompare(b.besetzung_teil)); it("Kolonne als eine Ressource: zählt mit allen Mitgliedern, mit Subunternehmer erst nach Freigabe", async () => { const anna = await neu("kontakte", { name: "Anna Holz", rolle: "mitarbeiter" }); const ben = await neu("kontakte", { name: "Ben Balken", rolle: "mitarbeiter" }); const sub = await neu("kontakte", { name: "Jan Meier", firma: "Meier Dach GmbH", rolle: "subunternehmer" }); await neu("subunternehmer", { kontakt_id: sub.id, stundensatz: 5000, kolonnengroesse: 2 }); const k1 = await neu("kolonnen", { name: "Kolonne 1", leitung_kontakt_id: anna.id }); for (const m of [anna, ben]) await neu("kolonnen-mitglieder", { kolonne_id: k1.id, kontakt_id: m.id }); const p = await neu("projekte", { nummer: "P-26-300", bezeichnung: "Halle Nord", status: "auftrag" }); const a = await neu("abschnitte", { projekt_id: p.id, name: "Bauablauf" }); // 64 Stunden mit zwei Leuten à 8 Std. = 4 Arbeitstage const v = await neu("vorgaenge", { abschnitt_id: a.id, name: "Abbund", start: "2027-03-08", dauer: 1, stunden: 64, dauer_fest: false }); const b = await neu("besetzungen", { vorgang_id: v.id, kolonne_id: k1.id }); expect(b.freigegeben).toBe(true); expect((await hole(`vorgaenge/${v.id}`)).dauer).toBe(4); // ein Mitarbeiter der Kolonne zugleich direkt auf einem anderen Vorgang: Überschneidung const v2 = await neu("vorgaenge", { abschnitt_id: a.id, name: "Dach", start: "2027-03-09", dauer: 1 }); await neu("besetzungen", { vorgang_id: v2.id, kontakt_id: ben.id }); const tp = await hole("terminplan"); expect(tp.ueberschneidungen.some((u: { wer: string }) => u.wer === ben.id)).toBe(true); expect(tp.besetzungen.find((x: { id: string }) => x.id === b.id)).toMatchObject({ anzeige: "Kolonne 1", mitglieder: [anna.id, ben.id] }); // Kolonne mit Subunternehmer: nur vorgemerkt const k2 = await neu("kolonnen", { name: "Dachkolonne" }); await neu("kolonnen-mitglieder", { kolonne_id: k2.id, kontakt_id: sub.id }); const b2 = await neu("besetzungen", { vorgang_id: v2.id, kolonne_id: k2.id }); expect(b2.freigegeben).toBe(false); // Person, Platzhalter oder Kolonne, nie zwei davon const r = await app.inject({ method: "POST", url: "/api/besetzungen", payload: { vorgang_id: v.id, kolonne_id: k1.id, kontakt_id: anna.id } }); expect(r.statusCode).toBeGreaterThanOrEqual(400); }); it("Einsatz eines Subunternehmers wird zur Ausgabe mit Skonto, Einbehalt und Zahlungsziel", async () => { const sub = await neu("kontakte", { name: "Kai Kran", firma: "Kran Kai", rolle: "subunternehmer" }); await neu("subunternehmer", { kontakt_id: sub.id, stundensatz: 6000, helfersatz: 4000, zahlungsziel_tage: 14, skonto_prozent: 2, skonto_tage: 7, einbehalt_prozent: 5 }); const p = await neu("projekte", { nummer: "P-26-301", bezeichnung: "Carport", status: "auftrag" }); const a = await neu("abschnitte", { projekt_id: p.id, name: "Bauablauf" }); const v = await neu("vorgaenge", { abschnitt_id: a.id, name: "Richten", start: "2027-03-08", dauer: 2 }); const b = await neu("besetzungen", { vorgang_id: v.id, kontakt_id: sub.id, personen: 2 }); // vorgemerkt: noch keine Kosten expect(await subKosten(sub.id)).toHaveLength(0); await aendern(`besetzungen/${b.id}`, { freigegeben: true }); // 2 Tage × 8 Std. × (60 € + 40 €) = 1.600 €; 2 % Skonto = 1.568 €; davon 5 % Einbehalt = 78,40 € let [einbehalt, leistung] = await subKosten(sub.id); expect(leistung).toMatchObject({ netto: 148960, termin: "2027-03-09", zahlungsziel_tage: 7, automatisch: true }); expect(einbehalt).toMatchObject({ netto: 7840, termin: "2032-03-09" }); // Vorgang länger: Kosten und Termin gehen mit await aendern(`vorgaenge/${v.id}`, { dauer: 3 }); [einbehalt, leistung] = await subKosten(sub.id); expect(leistung).toMatchObject({ netto: 223440, termin: "2027-03-10" }); // Betrag von Hand: bleibt fest await aendern(`kosten/${leistung.id}`, { netto: 200000 }); await aendern(`vorgaenge/${v.id}`, { dauer: 4 }); [einbehalt, leistung] = await subKosten(sub.id); expect(leistung).toMatchObject({ netto: 200000, automatisch: false }); expect(einbehalt.netto).toBe(15680); // Einsatz entfernt: geplante automatische Kosten verschwinden, die von Hand geänderte bleibt await app.inject({ method: "DELETE", url: `/api/besetzungen/${b.id}` }); const rest = await subKosten(sub.id); expect(rest.map((k) => k.netto)).toEqual([200000]); // Einbehalt steht nicht im Terminplan expect((await hole("terminplan")).kosten.some((k: { bezeichnung: string }) => k.bezeichnung.includes("Sicherheitseinbehalt"))).toBe(false); }); it("Übersicht warnt vor fehlender oder ablaufender Freistellungsbescheinigung", async () => { const sub = await neu("kontakte", { name: "Olaf Ohne", rolle: "subunternehmer" }); await neu("subunternehmer", { kontakt_id: sub.id, freistellung_bis: "2027-03-20" }); const u = await hole("uebersicht?heute=2027-03-01"); expect(u.warnungen).toContainEqual(expect.objectContaining({ art: "freistellung", ziel: `subunternehmer-${sub.id}`, text: expect.stringContaining("läuft am 20.03.2027 ab") })); const u2 = await hole("uebersicht?heute=2027-03-21"); expect(u2.warnungen).toContainEqual(expect.objectContaining({ text: expect.stringContaining("Olaf Ohne ist seit 20.03.2027 abgelaufen") })); }); });