dogfather-universe/server/pruef-protokoll-loeschen.mjs

/* =====================================================================
   Prüfung: Protokolle löschen, nur eins offen, und die Startseite lügt
   nicht mehr (02.09.2026).

   Drei Wünsche aus einer Meldung:

     "wie du siehst hab ich es gemacht und wie du auf screen2 siehst wird
      es immer noch angezeigt" — die Startseite meldete weiter ein
      fehlendes Protokoll, obwohl es geschrieben war.

     "ich will auch dass ich die löschen kann. und nur ich kann die
      löschen sonst keiner."

     "es soll immer automatisch nur 1 angezeigt werden."

   Der erste Punkt ist der lehrreiche: Der Server lag die ganze Zeit
   richtig. Nachgestellt wurde, dass der Hinweis erscheint, sobald ein
   vergangenes Gespräch kein Protokoll hat, und in dem Moment
   verschwindet, in dem eines geschrieben ist. Falsch war der BILDSCHIRM
   -- der Browser holte die verlassene Startseite beim Zurückgehen
   unverändert aus seiner Schublade (bfcache), ohne ein Skript erneut
   laufen zu lassen.

   Deshalb steht hier beides: dass die Zahl stimmt UND dass sie nach dem
   Zurückgehen stimmt. Die erste Prüfung allein wäre grün gewesen,
   während der Fehler weiter da war.
   ===================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-prot-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
process.env.PORT = "4197";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";

const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
await import("./index.js");
await new Promise((r) => setTimeout(r, 700));
const BASIS = "http://127.0.0.1:4197";
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 300_000).unref?.();

let fehler = 0;
let geprueft = 0;
const ok = (b, t) => { geprueft++; console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();

function anlegen(name, rolle, code) {
  const salt = randomBytes(16).toString("hex");
  const hash = scryptSync(code, salt, 64, { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
  d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768, jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
const idDogi = anlegen("Dogfather", "admin", "CODE-DOGI-0001");
const idCigdem = anlegen("Cigdem", "manager", "CODE-CIGDEM-01");

/* Drei vergangene Gespräche -- damit "nur eins offen" überhaupt etwas
   zu zeigen hat und nicht zufällig stimmt. */
const p = (n) => String(n).padStart(2, "0");
const vorhin = (stunden) => {
  const n = new Date(Date.now() - stunden * 3600_000);
  return `${n.getFullYear()}-${p(n.getMonth() + 1)}-${p(n.getDate())}T${p(n.getHours())}:00`;
};
for (const [titel, h] of [["Call - VanVan", 3], ["Call - Tili", 4], ["Review - September", 5]]) {
  d.prepare(`INSERT INTO termine (titel, art, beginn, dauer_min, creator_id, teilnehmer_id, erledigt, erstellt, erstellt_von)
             VALUES (?,?,?,?,?,?,0,?,?)`)
    .run(titel, "call", vorhin(h), 10, idDogi, idDogi, jetzt, idDogi);
}
const zahl = (sql, ...w) => d.prepare(sql).get(...w)?.n ?? 0;

const { chromium } = await import(
  "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
const browser = await chromium.launch();

async function anmelden(rolle, code) {
  const kontext = await browser.newContext({ viewport: { width: 1440, height: 1000 } });
  const seite = await kontext.newPage();
  await seite.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
  await seite.click(`.rolle[data-rolle="${rolle}"]`);
  await seite.fill("#code", code);
  await seite.click("button[type=submit]");
  await seite.waitForURL("**/start.html", { timeout: 15000 });
  return seite;
}
const api = (seite, pfad, optionen) => seite.evaluate(async ([pf, o]) => {
  const a = await fetch(pf, {
    credentials: "same-origin", ...(o || {}),
    headers: o?.koerper ? { "Content-Type": "application/json" } : undefined,
    body: o?.koerper ? JSON.stringify(o.koerper) : undefined,
  });
  return { status: a.status, daten: await a.json().catch(() => ({})) };
}, [pfad, optionen]);

const dogi = await anmelden("admin", "CODE-DOGI-0001");

/* ===================================================================
   TEIL 1 — Der Hinweis stimmt, auch nach dem Zurückgehen
   =================================================================== */

console.log("\n— Der Hinweis auf der Startseite —");

const hinweisZahl = async (seite) => {
  const r = await api(seite, "/workspace/api/hinweise");
  return (r.daten.hinweise || []).find((h) => h.art === "protokoll_fehlt")?.anzahl ?? 0;
};

ok(await hinweisZahl(dogi) === 3, "drei Gespräche ohne Protokoll werden gemeldet");

const calls = await api(dogi, "/workspace/api/calls");
const ersterCall = calls.daten.offen[0];
ok(!!ersterCall, "sie stehen unter „Protokoll fehlt“");

await api(dogi, `/workspace/api/calls/${ersterCall.id}/protokoll`, {
  method: "POST", koerper: { punkte: "War ein Test." },
});
ok(await hinweisZahl(dogi) === 2,
  "nach einem geschriebenen Protokoll meldet der Server nur noch zwei");

/* DER EIGENTLICHE FEHLER: die Seite, nicht der Server.
   Erst zur Calls-Seite, dann mit der Zurück-Taste auf die Startseite --
   genau der Weg, den Filipe gegangen ist. */
console.log("\n— Zurück-Taste: die Startseite darf nicht lügen —");

await dogi.goto(BASIS + "/workspace/start.html", { waitUntil: "networkidle" });
await dogi.waitForTimeout(700);
await dogi.goto(BASIS + "/workspace/calls.html", { waitUntil: "networkidle" });
await dogi.waitForTimeout(500);
const zweiterCall = calls.daten.offen[1];
await api(dogi, `/workspace/api/calls/${zweiterCall.id}/protokoll`, {
  method: "POST", koerper: { punkte: "Auch erledigt." },
});
await dogi.goBack({ waitUntil: "networkidle" });

/* Nachfassen statt einmal schauen: Wird die Seite aus der Schublade
   geholt, stösst kopf.js ein Neuladen an -- und das braucht einen
   Augenblick. Ein einzelner Blick direkt nach dem Zurückgehen erwischt
   womöglich noch die alte Anzeige und würde einen Fehler melden, den es
   nicht gibt. Deshalb bis zu fünf Sekunden lang hinsehen. */
/* Gemessen wird an EINZAHL gegen MEHRZAHL, nicht an einer Ziffer: Die
   Zahl steht in einem eigenen Feld und taucht im Fliesstext gar nicht
   auf -- der Satz selbst verrät sie aber zuverlässig.

     "1 Gespräch HAT noch kein Protokoll"     -> richtig (eins offen)
     "2 Gespräche HABEN noch kein Protokoll"  -> der alte Stand

   Genau diese Unterscheidung ist der ganze Fehler. */
let text = "";
let alterStand = true;
for (let i = 0; i < 25; i++) {
  await dogi.waitForTimeout(200);
  text = await dogi.evaluate(() => document.querySelector("main")?.innerText || "");
  alterStand = /Gespräche haben noch kein Protokoll/.test(text);
  if (!alterStand) break;
}
ok(!alterStand,
  "die zurückgeholte Startseite zeigt den NEUEN Stand (Einzahl), nicht den alten (Mehrzahl)");
ok(/Gespräch hat noch kein Protokoll/.test(text),
  "und meldet das eine verbliebene Gespräch weiterhin – die Zeile ist nicht bloss verschwunden");

/* GEGENPROBE: Die Zahl darf nicht einfach immer verschwinden -- sonst
   wäre die Zeile darüber auch dann grün, wenn der Hinweis gar nicht
   mehr funktioniert. Ein drittes Gespräch ist noch ohne Protokoll. */
ok(await hinweisZahl(dogi) === 1,
  "GEGENPROBE: das dritte Gespräch wird weiterhin gemeldet – der Hinweis lebt");

/* ===================================================================
   TEIL 2 — Löschen: nur DogFather
   =================================================================== */

console.log("\n— Protokoll löschen —");

const cigdem = await anmelden("manager", "CODE-CIGDEM-01");
const verboten = await api(cigdem, `/workspace/api/calls/${ersterCall.id}/protokoll`, { method: "DELETE" });
ok(verboten.status === 403, `ein Manager darf NICHT löschen (${verboten.status})`);
ok(zahl("SELECT COUNT(*) AS n FROM protokolle WHERE termin_id = ?", ersterCall.id) === 1,
  "und das Protokoll steht danach unverändert da");

const geloescht = await api(dogi, `/workspace/api/calls/${ersterCall.id}/protokoll`, { method: "DELETE" });
ok(geloescht.status === 200, "DogFather darf löschen");
ok(zahl("SELECT COUNT(*) AS n FROM protokolle WHERE termin_id = ?", ersterCall.id) === 0,
  "das Protokoll ist weg");
ok(zahl("SELECT COUNT(*) AS n FROM termine WHERE id = ?", ersterCall.id) === 1,
  "das GESPRÄCH steht weiterhin im Kalender – nur das Protokoll war gemeint");

const danach = await api(dogi, "/workspace/api/calls");
ok(danach.daten.offen.some((c) => c.id === ersterCall.id),
  "es steht wieder unter „Protokoll fehlt“ – die Handlung ist umkehrbar");
ok(await hinweisZahl(dogi) === 2, "und der Hinweis zählt es wieder mit");

const nochmal = await api(dogi, `/workspace/api/calls/${ersterCall.id}/protokoll`, { method: "DELETE" });
ok(nochmal.status === 404, "ein zweites Löschen läuft sauber ins Leere, statt etwas kaputtzumachen");

/* ===================================================================
   TEIL 3 — Immer nur eins offen
   =================================================================== */

console.log("\n— Immer nur ein Protokoll aufgeklappt —");

await dogi.goto(BASIS + "/workspace/calls.html", { waitUntil: "networkidle" });
await dogi.waitForTimeout(900);

const knoepfe = dogi.locator(".call__karte button, .kk__knoepfe button");
const zustand = async () => dogi.evaluate(() => ({
  offen: document.querySelectorAll(".call__detail").length,
  loeschen: [...document.querySelectorAll("button")]
    .filter((b) => /Protokoll löschen/.test(b.textContent)).length,
}));

ok((await zustand()).offen === 0, "beim Laden ist alles zugeklappt");

const alleAuf = dogi.locator("button", { hasText: /Protokoll (ansehen|schreiben)/ });
const wieviele = await alleAuf.count();
ok(wieviele >= 2, `es gibt mindestens zwei Gespräche zum Aufklappen (${wieviele})`);

await alleAuf.nth(0).click();
await dogi.waitForTimeout(400);
ok((await zustand()).offen === 1, "nach dem ersten Klick ist genau eins offen");

await dogi.locator("button", { hasText: /Protokoll (ansehen|schreiben)/ }).nth(0).click();
await dogi.waitForTimeout(400);
const nachZweitem = await zustand();
ok(nachZweitem.offen <= 1,
  `auch nach dem zweiten Klick ist höchstens eins offen (${nachZweitem.offen})`);

await dogi.screenshot({ path: "pruef-protokoll-loeschen.png", fullPage: false });

/* Und der Löschknopf steht NUR bei DogFather. */
await cigdem.goto(BASIS + "/workspace/calls.html", { waitUntil: "networkidle" });
await cigdem.waitForTimeout(900);
await cigdem.locator("button", { hasText: /Protokoll ansehen/ }).first().click().catch(() => {});
await cigdem.waitForTimeout(400);
const beiCigdem = await cigdem.evaluate(() => [...document.querySelectorAll("button")]
  .filter((b) => /Protokoll löschen/.test(b.textContent)).length);
ok(beiCigdem === 0,
  "GEGENPROBE: bei einer Managerin steht der Löschknopf gar nicht erst da");

const ERWARTET = 19;
console.log("");
ok(geprueft >= ERWARTET, `es sind ${geprueft} Prüfungen gelaufen (erwartet mindestens ${ERWARTET})`);

await browser.close();
d.close();
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
console.log(`\n${fehler ? "FEHLER: " + fehler : "Alles in Ordnung"} — ${geprueft} Prüfungen`);
process.exit(fehler ? 1 : 0);