dogfather-universe/server/pruef-rollen.mjs

/* =====================================================================
   Rollen-Rundgang: was eine Rolle SIEHT, muss auch funktionieren.

   Anlass (02.09.2026): "cigdem kriegt als manager gewisse sachen nicht
   auf die sie sieht, check jede rolle ab und sieh zu dass alles
   funktioniert in jeder rolle."

   ---------------------------------------------------------------------
   WARUM DAS EINE EIGENE PRÜFUNG IST

   Die bestehenden Prüfungen sehen fast alle mit den Augen von DogFather
   auf die Anwendung — und DogFather sieht alles. Genau deshalb fallen
   Rollenfehler nicht auf: Eine Seite, die für einen Manager leer bleibt
   oder mit 404 antwortet, ist in einer Admin-Prüfung tadellos.

   Hier läuft jede der vier Rollen über JEDE Seite, und geprüft wird
   nicht "sieht gut aus", sondern dreierlei:

     1. Keine Fehler in der Browser-Konsole.
     2. Kein Aufruf an den Server, der mit 4xx/5xx zurückkommt
        (401 auf dem Anmeldeweg ausgenommen — der gehört dazu).
     3. Kein sichtbarer Knopf, der ins Leere führt: Jeder Verweis muss
        ein Ziel haben, das es gibt.

   Dazu die eigentliche Frage: Wo eine Rolle etwas sehen DARF, darf die
   Seite nicht wortlos leer sein. Ein leerer Bereich ohne Erklärung
   sieht aus wie ein Fehler — und ist oft auch einer.
   ===================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { heuteLokal, tagLokal } from "./helfer-zeit.mjs";

const ordner = mkdtempSync(join(tmpdir(), "ws-rollen-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
process.env.PORT = "4193";
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 }); };
import { notbremse } from "./helfer-notbremse.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
   zwei Auffangnetze ein, die einen Absturz nur protokollieren --
   richtig fuer den Betrieb, fatal fuer eine Pruefung. Ohne diese
   Zeile bleibt der Prozess nach einem Fehler ewig stehen, weil der
   Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
notbremse(480_000, "pruef-rollen");
await new Promise((r) => setTimeout(r, 700));
const BASIS = "http://127.0.0.1:4193";
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 540_000).unref?.();

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

/* ---------- Ein Team mit echten Daten ----------------------------------
   Ohne Daten prüft ein Rundgang nur leere Seiten -- und leere Seiten
   machen selten Fehler. Jede Rolle bekommt deshalb etwas zu sehen. */

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes, createHmac } = await import("node:crypto");
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
/* ORTSZEIT, nicht UTC -- Begruendung in helfer-zeit.mjs. */
const tag = (v) => tagLokal(v);

/* DER SUCHSCHLUESSEL ZUM CODE (09.09.2026).

   Ohne ihn kaeme ein Modi nicht herein: Er hat keine Kachel, der stille
   Zugang findet ihn allein ueber diesen Wert. Er muss dastehen, BEVOR
   die erste Person angelegt wird -- die Personen entstehen hier von
   Hand und nicht ueber personAnlegen(), das ihn sonst selbst schreibt. */
const kennungSchluessel = randomBytes(32).toString("hex");
d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
  + " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
  .run("code_kennung_schluessel", kennungSchluessel, jetzt);

function person(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");
  const kennung = createHmac("sha256", kennungSchluessel).update(code).digest("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, kennung, jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
const idDogi = person("Filipe", "admin", "CODE-DOGI-0001");
const idCigdem = person("Cigdem", "manager", "CODE-CIGDEM-01");
const idBen = person("Ben", "scout", "CODE-BEN-00001");
const idTili = person("Tili", "creator", "CODE-TILI-0001");
/* Zwei Neue ohne jede Zuteilung -- der Zustand am ersten Tag. */
person("Neu-Scout", "scout", "CODE-NEU-000001");
person("Neu-Manager", "manager", "CODE-NEUM-00001");
/* Ein Modi -- verborgen fuer alle ausser der DogFather-Rolle und den
   anderen Modis. Er laeuft hier ueber JEDE Seite, denn "verborgen"
   heisst nicht "darf kaputt sein": Was er sieht, muss auch gehen. */
person("Marina", "modi", "CODE-MODI-0001");

/* Cigdem betreut Tili, Ben ebenfalls -- so hat jede betreuende Rolle
   etwas zu sehen. Genau diese Zuteilung fehlte im echten Bestand, und
   deshalb blieben Cigdems Seiten leer. */
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idTili, idCigdem, jetzt);
/* Ein zweiter Creator, damit auch der Scout WIRKLICH jemanden betreut.
   Ohne ihn hiess ein Durchgang "Scout (mit Creator)" und prüfte in
   Wahrheit denselben leeren Fall wie der ohne -- eine Prüfung, die
   glaubt, zwei Fälle abzudecken, und in Wirklichkeit einen zweimal
   nimmt. */
const idLuna = person("Luna", "creator", "CODE-LUNA-0001");
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idBen, jetzt);
d.prepare("INSERT INTO scout_zuteilung (scout_id, manager_id, seit) VALUES (?,?,?)").run(idBen, idCigdem, jetzt);

d.prepare(`INSERT INTO aufgaben (titel, status, prioritaet, creator_id, verantwortlich_id, frist, erstellt, erstellt_von)
           VALUES (?,?,?,?,?,?,?,?)`)
  .run("Thumbnail bauen", "offen", "hoch", idTili, idTili, tag(2), jetzt, idDogi);
d.prepare(`INSERT INTO termine (titel, art, beginn, dauer_min, creator_id, teilnehmer_id, erledigt, erstellt, erstellt_von)
           VALUES (?,?,?,?,?,?,0,?,?)`)
  .run("Wochen-Call", "call", tag(1) + "T18:00", 30, idTili, idTili, jetzt, idDogi);
d.prepare(`INSERT INTO termine (titel, art, beginn, dauer_min, creator_id, teilnehmer_id, erledigt, erstellt, erstellt_von)
           VALUES (?,?,?,?,?,?,0,?,?)`)
  .run("Vergangener Call", "call", tag(-1) + "T18:00", 30, idTili, idTili, jetzt, idDogi);
d.prepare(`INSERT INTO eintraege (bereich, art, titel, datum, status, creator_id, erstellt, erstellt_von)
           VALUES (?,?,?,?,?,?,?,?)`)
  .run("live", "vorbereitung", "Technik prüfen", tag(0), "offen", idTili, jetzt, idDogi);
d.prepare(`INSERT INTO eintraege (bereich, art, titel, datum, status, creator_id, erstellt, erstellt_von)
           VALUES (?,?,?,?,?,?,?,?)`)
  .run("content", "idee", "Videoidee Halloween", tag(0), "offen", idTili, jetzt, idDogi);
d.close();

/* ---------- Der Rundgang ------------------------------------------------ */

const SEITEN = [
  "start.html", "uebersicht.html", "aufgaben.html", "kalender.html", "calls.html",
  "content.html", "bereich.html?b=live", "dateien.html", "personen.html",
  "scouting.html", "steckbrief.html", "profil.html", "report.html",
  "wissen.html", "startcheck.html", "automation.html",
];

/* Fünf Durchgänge, nicht vier.

   Der fünfte ist der wichtigste: eine Person MIT Rolle, aber OHNE
   zugeteilte Creator. Das ist kein Sonderfall, sondern der Normalfall
   am ersten Tag -- und es war Cigdems echte Lage, als sie meldete,
   dass Dinge nicht gehen. Genau in diesem Zustand fielen beim ersten
   Lauf drei Seiten durch, während dieselben Seiten mit Zuteilung
   tadellos waren. Wer nur den bestückten Fall prüft, findet das nie. */
const ROLLEN = [
  { rolle: "admin", code: "CODE-DOGI-0001", name: "DogFather" },
  { rolle: "manager", code: "CODE-CIGDEM-01", name: "Manager (mit Creator)" },
  { rolle: "scout", code: "CODE-BEN-00001", name: "Scout (mit Creator)" },
  { rolle: "creator", code: "CODE-TILI-0001", name: "Creator (Tili)" },
  { rolle: "scout", code: "CODE-NEU-000001", name: "Scout (OHNE Creator)" },
  { rolle: "manager", code: "CODE-NEUM-00001", name: "Manager (OHNE Creator)" },
  /* DER SIEBTE DURCHGANG: ein Modi (09.09.2026).

     `rolle` ist hier die KACHEL, auf die geklickt wird -- nicht die
     Rolle, die dabei herauskommt. Fuer einen Modi gibt es keine Kachel;
     er tippt auf irgendeine vorhandene, und der Code entscheidet. Dass
     ausgerechnet "creator" dasteht, ist Absicht und beweist nebenbei,
     dass die Kachel wirklich gleichgueltig ist. */
  { rolle: "creator", code: "CODE-MODI-0001", name: "Modi (Marina)" },
];

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

/* Fehler, die nichts mit uns zu tun haben. Bewusst kurz gehalten: Jede
   Ausnahme hier ist eine Stelle, an der eine echte Panne durchrutschen
   könnte. */
const EGAL = [
  /favicon/i,
  /Failed to load resource: net::ERR_/i,   // abgebrochene Bilder beim Seitenwechsel
];
const istEgal = (t) => EGAL.some((r) => r.test(t));

const berichte = [];

for (const r of ROLLEN) {
  const kontext = await browser.newContext({ viewport: { width: 1440, height: 1000 } });
  const seite = await kontext.newPage();

  const konsole = [];
  const schlechteAntworten = [];
  seite.on("console", (m) => { if (m.type() === "error" && !istEgal(m.text())) konsole.push(m.text()); });
  seite.on("pageerror", (e) => konsole.push("Absturz: " + e.message));
  seite.on("response", (a) => {
    const u = a.url();
    if (!u.includes("/workspace/")) return;
    /* 401 auf dem Anmeldeweg gehoert dazu -- die Seite fragt, bekommt
       "nicht angemeldet" und leitet um. Alles andere nicht. */
    if (a.status() === 401 && /\/api\/ich|\/api\/sitzung/.test(u)) return;
    if (a.status() >= 400) schlechteAntworten.push(`${a.status()} ${u.replace(BASIS, "")}`);
  });

  await seite.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
  await seite.click(`.rolle[data-rolle="${r.rolle}"]`);
  await seite.fill("#code", r.code);
  await seite.click("button[type=submit]");
  await seite.waitForURL("**/start.html", { timeout: 15000 });

  console.log(`\n===== ${r.name} =====`);

  for (const pfad of SEITEN) {
    konsole.length = 0;
    schlechteAntworten.length = 0;
    await seite.goto(BASIS + "/workspace/" + pfad, { waitUntil: "networkidle" });
    await seite.waitForTimeout(700);

    const zustand = await seite.evaluate(() => {
      const sichtbar = (e) => {
        const k = e.getBoundingClientRect();
        return k.width > 0 && k.height > 0 && getComputedStyle(e).visibility !== "hidden";
      };
      /* Verweise, die ins Leere zeigen. Ein Knopf, der nichts tut, ist
         schlimmer als kein Knopf: Man klickt ihn immer wieder. */
      const tote = [...document.querySelectorAll("a[href]")]
        .filter(sichtbar)
        .filter((a) => {
          const h = a.getAttribute("href");
          return !h || h === "#" || h === "javascript:void(0)";
        })
        .map((a) => a.textContent.trim().slice(0, 40));
      /* Sichtbarer Text insgesamt -- eine Seite, auf der praktisch
         nichts steht, ist entweder leer oder kaputt. */
      const text = (document.querySelector("main")?.innerText || "").trim();
      return {
        tote,
        laenge: text.length,
        /* Ein sichtbarer Hinweis, der die Leere erklärt. */
        erklaert: [...document.querySelectorAll('.leer-hinweis, .leer, .k-leer, .block__frage')]
          .some((e) => e.getBoundingClientRect().height > 0 && e.textContent.trim().length > 25),
        /* Steht ein Ladehinweis noch da, ist etwas haengengeblieben. */
        haengt: [...document.querySelectorAll('[aria-busy="true"]')].length,
        ueber: document.documentElement.scrollWidth - document.documentElement.clientWidth,
      };
    });

    const probleme = [];
    if (konsole.length) probleme.push("Konsole: " + konsole.slice(0, 2).join(" | ").slice(0, 160));
    if (schlechteAntworten.length) probleme.push("Server: " + [...new Set(schlechteAntworten)].slice(0, 3).join(", "));
    if (zustand.tote.length) probleme.push("tote Verweise: " + zustand.tote.slice(0, 3).join(", "));
    if (zustand.haengt) probleme.push(`${zustand.haengt}× haengt beim Laden`);
    if (zustand.laenge < 120) probleme.push(`fast kein Inhalt (${zustand.laenge} Zeichen)`);
    if (zustand.ueber > 0) probleme.push(`ragt ${zustand.ueber}px heraus`);

    ok(!probleme.length, `${r.name.padEnd(18)} ${pfad.padEnd(22)} ${probleme.join(" · ")}`);
    if (probleme.length) berichte.push({ rolle: r.name, pfad, probleme });
  }

  await seite.screenshot({ path: `pruef-rollen-${r.rolle}.png`, fullPage: false });
  await kontext.close();
}

await browser.close();

/* ---------- Abschluss --------------------------------------------------- */

console.log("");
const ERWARTET = ROLLEN.length * SEITEN.length;
ok(geprueft >= ERWARTET,
  `jede Rolle war auf jeder Seite (${geprueft} von ${ERWARTET} Durchgängen)`);

if (berichte.length) {
  console.log("\n--- Was zu tun ist ---");
  for (const b of berichte) console.log(`  ${b.rolle} · ${b.pfad}\n      ${b.probleme.join("\n      ")}`);
}

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);