dogfather-universe/server/pruef-modi-ideen.mjs

/* =====================================================================
   DAS IDEEN-BOARD (Kapitel 5.6 des Anforderungsdokuments)

   "Sammelstelle für Content-, Live- und Community-Ideen mit
   Priorisierung."

   ZWEI GANZ VERSCHIEDENE FRAGEN, und die erste ist die gefaehrliche:

     1. Kommt der neue Bereich auf einer BESTEHENDEN Datenbank
        ueberhaupt an? Die erlaubten Bereiche stehen als CHECK-Regel in
        der Tabelle, und SQLite kann eine CHECK-Regel nicht aendern --
        die Tabelle muss neu gebaut werden. Das ist der Moment, in dem
        Daten verlorengehen.
     2. Sieht ihn nur, wer ihn sehen darf?

   DIE ERSTE WIRD HIER AUF EINER ECHTEN ALTEN TABELLE GEPRUEFT, nicht
   auf einer frischen. Eine frische Datenbank bringt den Bereich schon
   im Bauplan mit -- die Umstellung liefe gar nicht erst an, und die
   Pruefung waere gruen, ohne das Riskante angesehen zu haben. Genau so
   ein gruener Haken hat im Haus schon zweimal nichts bewiesen.

   Beim Bauen hat sich das gelohnt: Das Muster fuer den Tabellenkopf
   stand in einem Template-Literal, JavaScript verschluckte den
   Backslash, und die Umstellung haette STILLSCHWEIGEND nichts getan --
   kein Fehler, kein Hinweis, nur ein Bereich, den es nie gegeben
   haette.
   ===================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

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

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

/* ---------- Eine ALTE Datenbank bauen -------------------------------- */
const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes, createHmac } = await import("node:crypto");
const jetzt = new Date().toISOString();

console.log("\n=== 1. Eine bestehende Datenbank ohne den neuen Bereich ===\n");
{
  const d = new DatabaseSync(process.env.WORKSPACE_DB);
  /* Der Bauplan von gestern -- sechs Bereiche, kein 'ideen'. Die
     Spalten sind die echten; kaemen hier weniger, pruefte der Test
     nicht, ob die Umstellung ALLE mitnimmt. */
  d.exec(`
    CREATE TABLE eintraege (
      id            INTEGER PRIMARY KEY AUTOINCREMENT,
      bereich       TEXT NOT NULL
                    CHECK (bereich IN ('live','content','technik','community','schutz','agentur')),
      art           TEXT NOT NULL,
      titel         TEXT NOT NULL,
      text          TEXT,
      datum         TEXT NOT NULL,
      bewertung     INTEGER CHECK (bewertung IS NULL OR (bewertung BETWEEN 1 AND 5)),
      dringlichkeit TEXT NOT NULL DEFAULT 'mittel'
                    CHECK (dringlichkeit IN ('hoch','mittel','niedrig')),
      status        TEXT NOT NULL DEFAULT 'offen'
                    CHECK (status IN ('offen','erledigt')),
      creator_id    INTEGER,
      erstellt      TEXT NOT NULL,
      erstellt_von  INTEGER,
      geaendert     TEXT
    );`);
  for (let i = 1; i <= 7; i++) {
    d.prepare("INSERT INTO eintraege (bereich, art, titel, datum, erstellt) VALUES (?,?,?,?,?)")
      .run("live", "vorbereitung", `Altbestand ${i}`, jetzt.slice(0, 10), jetzt);
  }
  const abgelehnt = (() => {
    try {
      d.prepare("INSERT INTO eintraege (bereich, art, titel, datum, erstellt) VALUES (?,?,?,?,?)")
        .run("ideen", "content", "geht noch nicht", jetzt.slice(0, 10), jetzt);
      return false;
    } catch { return true; }
  })();
  /* DIE GEGENPROBE VORWEG: Der alte Stand muss den Bereich wirklich
     ablehnen. Taete er es nicht, bewiese die Umstellung unten nichts. */
  ok(abgelehnt, "der alte Stand lehnt den Bereich 'ideen' wirklich ab");
  ok(d.prepare("SELECT COUNT(*) AS n FROM eintraege").get().n === 7,
    "sieben Alt-Einträge liegen darin");
  d.close();
}

/* ---------- Jetzt erst den Server starten ---------------------------- */
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 }); };
import { notbremse } from "./helfer-notbremse.mjs";
await import("./index.js");
notbremse(180_000, "pruef-modi-ideen");
await new Promise((r) => setTimeout(r, 900));
const BASIS = "http://127.0.0.1:4365";

console.log("\n=== 2. Die Umstellung ===\n");
{
  const d = new DatabaseSync(process.env.WORKSPACE_DB);
  const plan = d.prepare(
    "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'eintraege'").get()?.sql || "";
  const regel = plan.match(/bereich\s+IN\s*\(([^)]*)\)/i)?.[1] || "";
  ok(regel.includes("'ideen'"), `die Regel kennt den Bereich jetzt (${regel})`);
  /* UND DIE ALTEN BEREICHE SIND NOCH DA. Eine Umstellung, die den neuen
     hinzufuegt und dabei einen alten verliert, ist schlimmer als keine. */
  ok(["live", "content", "technik", "community", "schutz", "agentur"]
    .every((b) => regel.includes(`'${b}'`)), "und alle sechs alten ebenfalls");
  ok(d.prepare("SELECT COUNT(*) AS n FROM eintraege").get().n === 7,
    "alle sieben Alt-Einträge sind noch da");
  const spalten = d.prepare("PRAGMA table_info(eintraege)").all().map((z) => z.name);
  ok(["bereich", "art", "titel", "text", "datum", "bewertung", "dringlichkeit",
    "status", "creator_id", "erstellt", "erstellt_von", "geaendert"]
    .every((sp) => spalten.includes(sp)),
  `keine Spalte verloren (${spalten.length} Spalten)`);
  ok(d.prepare("PRAGMA foreign_key_check").all().length === 0, "keine verwaisten Verweise");
  d.close();
}

/* ---------- Personen ------------------------------------------------- */
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const schluessel = randomBytes(32).toString("hex");
d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
  + " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
  .run("code_kennung_schluessel", schluessel, jetzt);
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, code_kennung, aktiv, erstellt)"
    + " VALUES (?,?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768,
      createHmac("sha256", schluessel).update(code).digest("hex"), jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
anlegen("Filipe", "admin", "CODE-DOGI-0001");
anlegen("Cigdem", "spicy", "CODE-SPIC-0001");
anlegen("Schulle", "manager", "CODE-MAN-0001");
anlegen("Tili", "creator", "CODE-ANNA-0001");
const idModi1 = anlegen("Marina", "modi", "CODE-MODI-0001");
const idModi2 = anlegen("Kim", "modi", "CODE-MODI-0002");
d.close();
void idModi1;

async function anmelden(rolle, code) {
  const a = await fetch(BASIS + "/workspace/api/anmelden", {
    method: "POST", headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ rolle, code }),
  });
  const keks = (a.headers.getSetCookie?.() || []).map((z) => z.split(";")[0]).join("; ");
  return { status: a.status, keks };
}
async function hole(keks, pfad, aufruf = {}) {
  const a = await fetch(BASIS + pfad, {
    ...aufruf, headers: { ...(aufruf.headers || {}), cookie: keks },
  });
  return { status: a.status, daten: await a.json().catch(() => null) };
}
const jsonKopf = { "Content-Type": "application/json" };

/* ---------- 3. Sammeln und priorisieren ------------------------------ */
console.log("\n=== 3. Ideen sammeln und nach Dringlichkeit ordnen ===\n");
const modiAn = await anmelden("creator", "CODE-MODI-0001");
const modi2An = await anmelden("creator", "CODE-MODI-0002");
const dogiAn = await anmelden("admin", "CODE-DOGI-0001");
{
  const IDEEN = [
    ["content", "Reihe: Die drei häufigsten Fragen im Chat", "hoch"],
    ["live", "Zuschauer-Challenge am Freitag", "mittel"],
    ["community", "Willkommens-Runde für Neue", "niedrig"],
    ["sonstiges", "Kooperation mit der Nachbar-Community", "mittel"],
  ];
  let angelegt = 0;
  for (const [art, titel, dringlichkeit] of IDEEN) {
    const a = await hole(modiAn.keks, "/workspace/api/bereich/ideen", {
      method: "POST", headers: jsonKopf,
      body: JSON.stringify({ art, titel, text: "aus dem Team", dringlichkeit }),
    });
    if (a.status === 201 || a.status === 200) angelegt++;
    else unklar(`"${titel}" ging nicht (${a.status}: ${JSON.stringify(a.daten)})`);
  }
  ok(angelegt === IDEEN.length, `${angelegt} von ${IDEEN.length} Ideen angelegt`);

  const b = await hole(modiAn.keks, "/workspace/api/bereich/ideen");
  const liste = b.daten?.eintraege || b.daten?.liste || [];
  ok(liste.length === IDEEN.length, `er sieht sie alle wieder (${liste.length})`);
  /* DIE PRIORISIERUNG IST DER PUNKT aus Kapitel 5.6 -- ohne sie waere es
     eine Zettelsammlung. */
  const stufen = liste.map((z) => z.dringlichkeit).sort();
  ok(stufen.includes("hoch") && stufen.includes("mittel") && stufen.includes("niedrig"),
    `mit Dringlichkeit (${stufen.join(", ")})`);
  /* Und eine Idee gehoert der Runde, nicht einer Person. */
  ok(liste.every((z) => z.creator_id === null),
    "keine Idee hängt an einer einzelnen Person");
}

/* Das Team teilt sich die Sammlung -- sonst waere es keine. */
{
  const b = await hole(modi2An.keks, "/workspace/api/bereich/ideen");
  const liste = b.daten?.eintraege || b.daten?.liste || [];
  ok(liste.length >= 4, `der zweite Modi sieht dieselben Ideen (${liste.length})`);
}
{
  const b = await hole(dogiAn.keks, "/workspace/api/bereich/ideen");
  const liste = b.daten?.eintraege || b.daten?.liste || [];
  ok(liste.length >= 4, `DogFather ebenfalls (${liste.length})`);
}

/* ---------- 4. Für alle anderen gibt es den Bereich nicht ------------ */
console.log("\n=== 4. Und für alle anderen gibt es ihn nicht ===\n");
for (const [name, kachel, code] of [
  ["Spicy Media", "spicy", "CODE-SPIC-0001"],
  ["Manager", "manager", "CODE-MAN-0001"],
  ["Creator", "creator", "CODE-ANNA-0001"],
]) {
  const an = await anmelden(kachel, code);
  const a = await hole(an.keks, "/workspace/api/bereich/ideen");
  const b = await hole(an.keks, "/workspace/api/bereich/gibtesnicht");
  /* WORTGLEICH mit einem erfundenen Bereich. Ein eigener Fehlertext
     waere die Auskunft, dass es ihn gibt. */
  ok(a.status === 404 && a.status === b.status
    && JSON.stringify(a.daten) === JSON.stringify(b.daten),
  `${name.padEnd(12)} bekommt dieselbe Antwort wie für einen erfundenen `
    + `(${a.status} ${JSON.stringify(a.daten)})`);
  /* Auch nicht schreiben -- eine Sperre, die nur beim Lesen gilt, ist
     keine. */
  const c = await hole(an.keks, "/workspace/api/bereich/ideen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "content", titel: "reingeschmuggelt" }),
  });
  ok(c.status === 404, `${name.padEnd(12)} kann dort auch nichts anlegen (${c.status})`);
}

/* Und die Ideen tauchen auch nirgends sonst auf -- die Suche ist der
   Weg, auf dem so etwas erfahrungsgemaess durchsickert. */
{
  const an = await anmelden("spicy", "CODE-SPIC-0001");
  const a = await hole(an.keks, "/workspace/api/suche?q=Zuschauer-Challenge");
  if (a.status !== 200) {
    unklar(`Suche für Spicy Media nicht abfragbar (${a.status})`);
  } else {
    /* NICHT DEN ROHEN TEXT DURCHSUCHEN. Beim ersten Anlauf stand hier
       `!JSON.stringify(antwort).includes("Zuschauer-Challenge")` -- und
       das schlug an, obwohl nichts gefunden wurde: Die Antwort spiegelt
       den SUCHBEGRIFF im Feld `frage` zurueck. Die Pruefung fand ihre
       eigene Frage wieder und meldete ein Leck, das es nicht gibt.
       Beinahe haette ich daraufhin etwas repariert, das heil war.

       Gezaehlt wird deshalb, was die Suche wirklich gefunden hat. */
    ok(a.daten?.gesamt === 0 && (a.daten?.gruppen || []).length === 0,
      `auch die Suche findet nichts (${a.daten?.gesamt} Treffer)`);
  }
  const b = await hole(dogiAn.keks, "/workspace/api/suche?q=Zuschauer-Challenge");
  if (b.status !== 200) {
    unklar(`Suche für DogFather nicht abfragbar (${b.status})`);
  } else {
    /* GEGENPROBE: Dieselbe Suche muss die Idee bei DogFather SEHR WOHL
       finden -- sonst waere der Haken darüber auch dann grün, wenn die
       Suche gar nichts findet. */
    const treffer = (b.daten?.gruppen || [])
      .flatMap((g) => g.treffer || g.eintraege || [])
      .some((z) => String(z.titel || "").includes("Zuschauer-Challenge"));
    ok(b.daten?.gesamt > 0 && treffer,
      `bei DogFather findet dieselbe Suche sie sehr wohl (${b.daten?.gesamt} Treffer)`);
  }
}

/* ---------- 5. Im echten Browser ------------------------------------- */
console.log("\n=== 5. Das Board im echten Browser ===\n");
{
  const { chromium } = await import(
    "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
  const browser = await chromium.launch();
  try {
    const kontext = await browser.newContext({ viewport: { width: 1280, height: 1000 } });
    const seite = await kontext.newPage();
    const konsole = [];
    seite.on("console", (e) => { if (e.type() === "error") konsole.push(e.text()); });
    seite.on("pageerror", (e) => konsole.push("Absturz: " + e.message));
    const schlecht = [];
    seite.on("response", (r) => {
      if (r.url().includes("/workspace/api/") && r.status() >= 400) {
        schlecht.push(`${r.status()} ${r.url().replace(BASIS, "")}`);
      }
    });
    await seite.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
    await seite.click('.rolle[data-rolle="creator"]');
    await seite.fill("#code", "CODE-MODI-0001");
    await seite.click("button[type=submit]");
    await seite.waitForURL("**/start.html", { timeout: 15000 });
    /* WARTEN, BIS DIE KACHELN DA SIND. Sie entstehen erst, wenn
       /api/ich geantwortet hat -- direkt nach waitForURL ist die Seite
       zwar geladen, aber leer. Beim ersten Anlauf meldete diese
       Pruefung deshalb "keine Kachel", obwohl fuenf dastanden. */
    await seite.waitForSelector(".gruppe a[href]", { timeout: 15000 });

    /* Erst die Kachel auf der Startseite -- ohne sie findet niemand den
       Weg dorthin, und ein Bereich, den man nur ueber die Adresszeile
       erreicht, ist keiner. */
    const kachel = await seite.evaluate(() =>
      [...document.querySelectorAll(".gruppe a[href]")]
        .some((a) => a.getAttribute("href").includes("b=ideen")));
    ok(kachel, "die Kachel steht auf seiner Startseite");

    schlecht.length = 0;
    await seite.goto(BASIS + "/workspace/bereich.html?b=ideen", { waitUntil: "networkidle" });
    await seite.waitForTimeout(1200);
    const bild = await seite.evaluate(() => ({
      text: document.body.innerText,
      ober: (document.getElementById("ober") || {}).textContent || "",
      /* Die Dringlichkeit steht als Merkmal an der Karte und faerbt
         ihre linke Kante. Sie IST die Priorisierung aus Kapitel 5.6 --
         ohne sie waere das Board eine Zettelsammlung. */
      reihenfolge: [...document.querySelectorAll("[data-dringlich]")]
        .map((k) => k.dataset.dringlich),
    }));
    /* Die Adresse gehoert in die Bedingung: Bliebe eine Umleitung
       unbemerkt, pruefte alles darunter die Startseite. Genau das ist
       hier passiert -- der Server liess `modi` nicht auf bereich.html,
       und die Pruefung sah eine Seite, die "Ideen-Board" enthielt (den
       Text der KACHEL) und hielt sie fuer das Board. */
    ok(seite.url().includes("b=ideen"),
      `die Seite bleibt stehen (${seite.url().replace(BASIS, "")})`);
    ok(/Ideen/i.test(bild.text), "die Seite nennt sich Ideen-Board");
    /* Die vier Arten aus Kapitel 5.6 muessen zur Wahl stehen -- sonst
       ist es eine Liste, keine Sammelstelle. */
    const arten = ["Content-Idee", "Live-Idee", "Community-Idee", "Sonstiges"];
    const gefunden = arten.filter((a) => bild.text.includes(a));
    ok(gefunden.length === arten.length,
      `alle vier Arten stehen zur Wahl (${gefunden.join(", ") || "keine"})`);
    ok(/Zuschauer-Challenge/.test(bild.text), "und die angelegten Ideen stehen darin");
    /* NACH DRINGLICHKEIT GEORDNET -- das Dringende zuerst. Eine
       Sammlung ohne Ordnung waere genau der Zettelhaufen, den das Board
       ersetzen soll. */
    const rang = { hoch: 0, mittel: 1, niedrig: 2 };
    const geordnet = bild.reihenfolge.every((d, i) =>
      i === 0 || rang[bild.reihenfolge[i - 1]] <= rang[d]);
    ok(bild.reihenfolge.length === 4 && geordnet,
      `nach Dringlichkeit geordnet (${bild.reihenfolge.join(" → ")})`);
    /* Und das Wort ueber dem Titel passt: "Betreuung" waere hier falsch
       -- eine Ideensammlung wird nicht ueber jemanden gefuehrt. */
    ok(bild.ober.trim() === "Sammelstelle" && !/Betreuung/i.test(bild.ober),
      `die Oberzeile passt ("${bild.ober.trim()}")`);
    ok(schlecht.length === 0,
      schlecht.length ? `abgewiesene Anfragen: ${schlecht.join(" | ")}` : "keine Anfrage abgewiesen");
    ok(konsole.length === 0,
      konsole.length ? `Fehler in der Konsole: ${konsole[0]}` : "keine Fehler in der Konsole");
    await seite.screenshot({ path: "pruef-modi-ideen.png", fullPage: false });
    console.log("  --   Bildschirmfoto: server/pruef-modi-ideen.png");
    await kontext.close();
  } finally {
    await browser.close();
  }
}
console.log(`\n${fehler ? "FEHLGESCHLAGEN" : "BESTANDEN"} -- `
  + `${geprueft} geprueft, ${fehler} Fehler, ${offen} nicht nachsehbar`);
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
process.exit(fehler ? 1 : 0);