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

/* =====================================================================
   DER AUFGABENKATALOG AUS TEIL 2 DES ANFORDERUNGSDOKUMENTS

   Kapitel 14: "Alle Aufgaben dieses Katalogs koennen 1:1 als Vorlagen in
   die App importiert werden -- inklusive Kategorie, empfohlener Rolle
   und Frequenz. So ist das Aufgaben-Board ab dem ersten Tag vollstaendig
   befuellt, statt leer zu starten."

   GEPRUEFT WIRD NICHT NUR, DASS ER DA IST. Ein Katalog, den man ansehen,
   aber nicht uebernehmen kann, ist eine Speisekarte ohne Kueche. Und ein
   uebernommener Eintrag, bei dem die Kategorie unterwegs verlorengeht,
   ist die Haelfte wert -- dann sortiert man 60-mal von Hand ein, was im
   Dokument bereits danebensteht.

   DAZU DIE VERBORGENHEIT: Wer den Katalog nicht bekommt, darf auch nicht
   erfahren, dass es ihn gibt. Eine Absage muss deshalb wortgleich mit
   der fuer eine erfundene Art sein.
   ===================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-kat2-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
process.env.PORT = "4363";
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";

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-katalog");
await new Promise((r) => setTimeout(r, 700));
const BASIS = "http://127.0.0.1:4363";

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

/* ---------- Personen ------------------------------------------------- */
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();
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;
}
const idDogi  = anlegen("Filipe", "admin", "CODE-DOGI-0001");
const idMan   = anlegen("Schulle", "manager", "CODE-MAN-0001");
const idCreat = anlegen("Tili", "creator", "CODE-ANNA-0001");
const idModi  = anlegen("Marina", "modi", "CODE-MODI-0001");
d.close();
void idDogi;
void idMan;

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" };

const modiAn = await anmelden("creator", "CODE-MODI-0001");
const dogiAn = await anmelden("admin", "CODE-DOGI-0001");
const manAn = await anmelden("manager", "CODE-MAN-0001");
const creatAn = await anmelden("creator", "CODE-ANNA-0001");

/* ---------- 1. Ist er vollstaendig da? ------------------------------- */
console.log("\n=== 1. Der Katalog, wie ihn das Dokument beschreibt ===\n");

let katalog = null;
{
  const a = await hole(modiAn.keks, "/workspace/api/vorlagen");
  katalog = a.daten?.katalog || null;
  /* SECHZIG, fest hingeschrieben. Das Dokument wirbt mit "60+ konkrete
     Aufgaben"; faellt eine heraus, muss das auffallen. Eine Zahl, die
     sich selbst nachzaehlt, kann das nicht. */
  ok(katalog && katalog.aufgaben.length === 60,
    `${katalog?.aufgaben?.length ?? 0} Aufgaben (erwartet 60)`);
  ok(katalog && katalog.gruppen.length === 9,
    `${katalog?.gruppen?.length ?? 0} Etappen (erwartet 9)`);
  /* Die Verteilung aus Teil 2, Phase fuer Phase. Sie steht hier, weil
     eine reine Gesamtzahl auch dann stimmt, wenn zwoelf Aufgaben in der
     falschen Etappe liegen. */
  const soll = { aufbau: 12, alltag: 9, vor: 5, waehrend: 5, nach: 4,
    content: 8, woche: 5, monat: 5, community: 7 };
  const ist = {};
  for (const v of katalog?.aufgaben || []) ist[v.gruppe] = (ist[v.gruppe] || 0) + 1;
  ok(JSON.stringify(ist) === JSON.stringify(soll),
    `die Verteilung stimmt (${Object.entries(ist).map(([k, n]) => `${k}:${n}`).join(" ")})`);
  ok((katalog?.aufgaben || []).every((v) => v.titel && v.text && v.kategorie && v.rolle && v.tage),
    "jede Aufgabe hat Titel, Text, Kategorie, empfohlene Rolle und Frist");
}

/* Jede Kategorie im Katalog muss es auch wirklich geben -- sonst nimmt
   der Server sie beim Uebernehmen an und lehnt sie beim Aendern ab. */
{
  const a = await hole(modiAn.keks, "/workspace/api/aufgaben");
  const gueltig = new Set((a.daten?.kategorien || []).map((k) => k.wert));
  const unbekannt = [...new Set((katalog?.aufgaben || []).map((v) => v.kategorie))]
    .filter((k) => !gueltig.has(k));
  ok(gueltig.size > 0 && unbekannt.length === 0,
    unbekannt.length
      ? `unbekannte Kategorie(n) im Katalog: ${unbekannt.join(", ")}`
      : `alle ${gueltig.size} Kategorien passen zum Katalog`);
}

/* ---------- 2. Wer bekommt ihn nicht? -------------------------------- */
console.log("\n=== 2. Und wer ihn nicht bekommt ===\n");
for (const [name, an] of [["Manager", manAn], ["Creator", creatAn]]) {
  const a = await hole(an.keks, "/workspace/api/vorlagen");
  ok(a.status === 200 && a.daten?.katalog === null,
    `${name}: kein Katalog (${JSON.stringify(a.daten?.katalog)})`);
  /* Und der ANDERE Katalog ist bei ihnen sehr wohl da -- sonst waere
     oben auch gruen, wenn die ganze Antwort leer kaeme. */
  ok(a.daten?.aufgaben && Object.keys(a.daten.aufgaben).length > 0,
    `${name}: der Creator-Katalog dagegen schon`);
}
{
  const a = await hole(modiAn.keks, "/workspace/api/vorlagen");
  ok(a.daten?.aufgaben === null,
    "und der Modi bekommt umgekehrt den Creator-Katalog nicht");
}

/* ---------- 3. Uebernehmen ------------------------------------------- */
console.log("\n=== 3. Aus der Vorlage wird eine echte Aufgabe ===\n");
{
  const nr = katalog.aufgaben.findIndex((v) => v.gruppe === "waehrend");
  const vorlage = katalog.aufgaben[nr];
  const a = await hole(modiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "katalog", nr, gruppe: "waehrend" }),
  });
  ok(a.status === 200 && a.daten?.angelegt === 1, `übernommen (${a.status})`);

  const b = await hole(modiAn.keks, "/workspace/api/aufgaben");
  const neu = (b.daten?.aufgaben || []).find((x) => x.vorlage === vorlage.schluessel);
  ok(!!neu, `sie liegt auf seinem Brett (${neu?.titel || "nicht gefunden"})`);
  /* DIE KATEGORIE IST DER HALBE WERT DER VORLAGE. Ginge sie unterwegs
     verloren, muesste man 60-mal von Hand einsortieren, was im Dokument
     danebensteht -- und niemand merkte es, weil die Aufgabe ja da ist. */
  ok(neu?.kategorie === vorlage.kategorie,
    `mit ihrer Kategorie (${neu?.kategorie} / erwartet ${vorlage.kategorie})`);
  ok(!!neu?.frist, `und mit Frist (${neu?.frist})`);
  ok(neu?.verantwortlich_id === idModi, "und er selbst ist verantwortlich");
}

/* Eine ganze Etappe auf einmal. */
{
  const wieViele = katalog.aufgaben.filter((v) => v.gruppe === "nach").length;
  const a = await hole(modiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "katalog_alle", gruppe: "nach" }),
  });
  ok(a.status === 200 && a.daten?.angelegt === wieViele,
    `eine ganze Etappe auf einmal: ${a.daten?.angelegt} von ${wieViele}`);
}

/* ---------- 4. DogFather traegt fuer jemanden ein -------------------- */
console.log("\n=== 4. DogFather trägt für einen Modi ein ===\n");
{
  const nr = katalog.aufgaben.findIndex((v) => v.gruppe === "monat");
  const a = await hole(dogiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "katalog", nr, gruppe: "monat", person_id: idModi }),
  });
  ok(a.status === 200 && a.daten?.angelegt === 1, `für den Modi geht es (${a.status})`);

  /* Aber nicht an einen Creator -- sonst laege eine Aufgabe mit
     Modi-Kategorie an jemandem, der die Kategorien gar nicht kennt, und
     die Trennung waere von innen aufgeweicht. */
  const b = await hole(dogiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "katalog", nr, gruppe: "monat", person_id: idCreat }),
  });
  ok(b.status === 404, `an einen Creator dagegen nicht (${b.status})`);

  /* Und ohne Person gar nicht -- eine Aufgabe ohne Adressaten ist ein
     Zettel. */
  const c = await hole(dogiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "katalog", nr, gruppe: "monat" }),
  });
  ok(c.status === 400 && /Person/i.test(c.daten?.fehler || ""),
    `ohne Person wird gefragt (${c.status} ${c.daten?.fehler || ""})`);
}

/* ---------- 5. Der heikelste Fall ------------------------------------ */
console.log("\n=== 5. Ein Manager versucht es trotzdem ===\n");
{
  const a = await hole(manAn.keks, "/workspace/api/vorlagen/uebernehmen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "katalog", nr: 0, gruppe: "aufbau", person_id: idModi }),
  });
  const b = await hole(manAn.keks, "/workspace/api/vorlagen/uebernehmen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "gibtesnicht", nr: 0 }),
  });
  /* WORTGLEICH. Ein eigener Fehlertext waere die Auskunft, dass es die
     Art gibt -- und damit, dass es den Katalog gibt. */
  ok(a.status === b.status && JSON.stringify(a.daten) === JSON.stringify(b.daten),
    `klingt wie eine erfundene Art (${a.status} ${JSON.stringify(a.daten)})`);
}

/* ---------- 6. Im Browser -------------------------------------------- */
console.log("\n=== 6. Das Brett 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));
    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 });
    await seite.goto(BASIS + "/workspace/aufgaben.html", { waitUntil: "networkidle" });
    await seite.waitForTimeout(1200);

    /* Aufklappen, falls es zugeklappt startet. */
    const zu = await seite.evaluate(() =>
      document.getElementById("vorlagenbrett")?.dataset.auf !== "ja");
    if (zu) {
      await seite.click(".vorlagenbrett__kopf").catch(() => {});
      await seite.waitForTimeout(700);
    }

    const bild = await seite.evaluate(() => ({
      sichtbar: !document.getElementById("vorlagenbrett")?.hidden,
      etappen: [...document.querySelectorAll(".stufenleiter__knopf .stufenleiter__name")]
        .map((z) => z.textContent.trim()),
      karten: document.querySelectorAll(".vorlagenbrett__karte").length,
      text: document.body.innerText,
      kopf: (document.querySelector(".kopfleiste .marke__text") || {}).textContent || "",
    }));
    ok(bild.sichtbar, "das Brett steht da");
    ok(bild.etappen.length === 9, `mit neun Etappen (${bild.etappen.join(" · ")})`);
    ok(bild.karten > 0, `und ${bild.karten} Karten in der offenen Etappe`);
    /* Der Katalog des ANDEREN darf nirgends durchschlagen. */
    ok(!/vier Bereichen und vier Stufen/.test(bild.text),
      "kein Wort vom Creator-Katalog");
    /* DIE KOPFLEISTE. Auf jeder Seite steht dort fest "Creator
       Workspace" -- fuer jemanden, der moderiert statt einen Kanal
       aufzubauen, ist das schlicht der falsche Name. Aufgefallen auf
       dem Bildschirmfoto, wie schon die Zierzeile auf der Startseite. */
    ok(bild.kopf.includes("Team") && !bild.kopf.includes("Creator"),
      `die Kopfleiste nennt seinen Betrieb ("${bild.kopf.trim()}")`);
    /* Und der Seitenname dahinter steht noch da -- ihn beim Austausch
       zu verlieren waere lautlos passiert. */
    ok(/Aufgaben/.test(bild.kopf), "der Seitenname dahinter blieb erhalten");
    ok(konsole.length === 0,
      konsole.length ? `Fehler in der Konsole: ${konsole[0]}` : "keine Fehler in der Konsole");
    await seite.screenshot({ path: "pruef-modi-katalog.png", fullPage: false });
    console.log("  --   Bildschirmfoto: server/pruef-modi-katalog.png");
    await kontext.close();
  } finally {
    await browser.close();
  }
}

/* ---------- 7. Gegenprobe -------------------------------------------- */
console.log("\n=== 7. Gegenprobe: kann das hier ueberhaupt scheitern? ===\n");
{
  /* Eine Vorlagennummer, die es nicht gibt. Kaeme dafuer ein 200,
     wuerden die Haken oben nichts beweisen -- dann sagt der Server zu
     allem ja. */
  const a = await hole(modiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "katalog", nr: 9999, gruppe: "aufbau" }),
  });
  ok(a.status === 400, `eine erfundene Vorlagennummer wird abgelehnt (${a.status})`);
  const b = await hole(modiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
    method: "POST", headers: jsonKopf,
    body: JSON.stringify({ art: "katalog_alle", gruppe: "gibtesnicht" }),
  });
  ok(b.status === 400, `und eine erfundene Etappe ebenso (${b.status})`);
}

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