Files
Betriebsf-hrungssoftware/test/api.test.ts

234 lines
14 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 type { FastifyInstance } from "fastify";
import { erstellePool, type Pool } from "../src/server/db.js";
import { migriere } from "../src/server/migrate.js";
import { baueApp } from "../src/server/app.js";
import { readFileSync } from "node:fs";
import { uebernimmV70 } from "../src/domain/v70.js";
import { liquiditaetsDaten } from "../src/domain/projektplan.js";
import { liquiditaet } from "../src/domain/liquiditaet.js";
import { bestandAus } from "./v70-referenz.js";
const url = process.env.TEST_DATABASE_URL;
describe.skipIf(!url)("API mit Datenbank", () => {
let pool: Pool;
let app: FastifyInstance;
beforeAll(async () => {
pool = erstellePool(url!);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht" });
});
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" });
});
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("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);
});
});