- POST /api/projekte/:id/zahlungsplan schlägt 30/40/20/10 vor; geplante Raten mit Vorgang wandern mit dessen Ende - Terminplan: €-Meilensteine je Projekt, Zoom per Regler und Ziehen an der Zeitskala - Liquidität: Kennzahlen, Kontostandverlauf, Zahlungen je Zeitraum mit Fälligkeitsdatum Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
362 lines
22 KiB
TypeScript
362 lines
22 KiB
TypeScript
// Prüft Server und Datenbank zusammen. Läuft nur mit TEST_DATABASE_URL (lokal und in der CI).
|
||
import { describe, it, expect, beforeAll, afterAll } from "vitest";
|
||
import { falscheNextcloud } from "./falsche-nextcloud.js";
|
||
import type { FastifyInstance } from "fastify";
|
||
import { erstellePool, type Pool } from "../src/server/db.js";
|
||
import { migriere } from "../src/server/migrate.js";
|
||
import { baueApp } from "../src/server/app.js";
|
||
import { readFileSync } from "node:fs";
|
||
import { uebernimmV70 } from "../src/domain/v70.js";
|
||
import { liquiditaetsDaten } from "../src/domain/projektplan.js";
|
||
import { liquiditaet } from "../src/domain/liquiditaet.js";
|
||
import { bestandAus } from "./v70-referenz.js";
|
||
|
||
const url = process.env.TEST_DATABASE_URL;
|
||
|
||
describe.skipIf(!url)("API mit Datenbank", () => {
|
||
let pool: Pool;
|
||
let app: FastifyInstance;
|
||
|
||
beforeAll(async () => {
|
||
pool = erstellePool(url!);
|
||
await pool.query("drop schema public cascade; create schema public;");
|
||
await migriere(pool);
|
||
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht" });
|
||
});
|
||
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("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 wird als Meilensteine vorgeschlagen und wandert mit seinem Vorgang", async () => {
|
||
const neu = async (pfad: string, body: object) => (await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body })).json();
|
||
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 } });
|
||
const a = await neu("abschnitte", { projekt_id: p.id, name: "Ausführung" });
|
||
const richten = await neu("vorgaenge", { abschnitt_id: a.id, name: "Richten", start: "2026-11-02", dauer: 2 });
|
||
await neu("vorgaenge", { abschnitt_id: a.id, name: "Dach", start: "2026-11-09", dauer: 3 });
|
||
const r = await app.inject({ method: "POST", url: `/api/projekte/${p.id}/zahlungsplan` });
|
||
expect(r.statusCode, r.body).toBe(201);
|
||
const raten = r.json();
|
||
expect(raten.map((z: { netto: number }) => z.netto)).toEqual([600_000, 800_000, 400_000, 200_000]);
|
||
expect(raten[1]).toMatchObject({ vorgang_id: richten.id, termin: "2026-11-03" });
|
||
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" } });
|
||
expect((await app.inject(`/api/zahlungen/${raten[1].id}`)).json().termin).toBe("2026-11-10");
|
||
// gestellte Raten bleiben stehen
|
||
await app.inject({ method: "PATCH", url: `/api/zahlungen/${raten[1].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/${raten[1].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);
|
||
});
|
||
|
||
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 });
|
||
});
|
||
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("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");
|
||
});
|
||
});
|
||
|
||
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" });
|
||
});
|
||
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)));
|
||
});
|
||
});
|