Files
Betriebsf-hrungssoftware/test/api.test.ts
Claude 334cd9357e
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
Pausenabzug standardmäßig voll: 6:10 wird 5:40 (0.15.1)
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
2026-10-20 21:26:46 +00:00

992 lines
67 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";
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<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)));
});
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, 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("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") }));
});
});