dogfather-universe/server/pruef-schritt.mjs

/* =====================================================================
   Aus einer Beobachtung wird ein Schritt (15.09.2026)

   Filipe: „ich will dass du die 2 kategorien perfektionnierst […] es
   soll so einfach wie möglich sein für jeden."

   ---------------------------------------------------------------------
   WAS GEFEHLT HAT

   Die Entwicklungskarte konnte genau eines: festhalten, dass etwas
   hakt — mit Anlass, das war schon richtig. Danach passierte nichts.
   Beim nächsten Öffnen stand dieselbe Beobachtung da, nur älter.

   Ein Entwicklungsplan wirkt dann, wenn er an einer ECHTEN Aufgabe
   hängt. Also wird aus „da hakt es" eine Aufgabe auf dem Brett — und
   wenn sie erledigt ist, fragt die Karte dieselbe Frage noch einmal.

   ---------------------------------------------------------------------
   UND GENAU DA SIND DIE RIEGEL

     Aus „läuft" einen Schritt machen?          (darf nicht)
     Aus der Beobachtung eines anderen?         (darf nicht)
     Zweimal zum selben Punkt?                  (darf nicht)
     Ein Modi für sich selbst?                  (darf nicht)
     Steht der Anlass hinterher im Protokoll?   (darf nicht)

   Aufrufen mit:  node server/pruef-schritt.mjs
   ===================================================================== */

import { mkdtempSync, rmSync, readFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { request as httpAnfrage } from "node:http";
import { portMussFreiSein } from "./helfer-port.mjs";

const PORT = await portMussFreiSein(4421, "pruef-schritt");

const ordner = mkdtempSync(join(tmpdir(), "ws-schritt-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
process.env.PORT = String(PORT);
process.env.SITE_ACCESS_SECRET = "lokaler-test";
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(240_000, "pruef-schritt");
await new Promise((r) => setTimeout(r, 700));

process.on("uncaughtException", (f) => { console.error("ABSTURZ:", f); process.exit(7); });
process.on("unhandledRejection", (f) => { console.error("ABSTURZ (Versprechen):", f); process.exit(7); });

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

const CREW = "crew.dogfather-universe.com";
const HAUS = "workspace.dogfather-universe.com";

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes, createHmac } = await import("node:crypto");
const kat = await import("./workspace-entwicklungs-punkte.js");
const ent = await import("./workspace-entwicklung.js");

const oeffne = () => new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();

let idDogi, idHand, idFrida;
{
  const d = oeffne();
  const s = randomBytes(32).toString("hex");
  d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
    + " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
    .run("code_kennung_schluessel", s, jetzt);
  const 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", s).update(code).digest("hex"), jetzt);
    return d.prepare("SELECT last_insert_rowid() AS id").get().id;
  };
  idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
  idHand = anlegen("Rieke", "hand", "CODE-HAND-0001");
  idFrida = anlegen("Frida", "modi", "CODE-MODI-0001");
  d.close();
}

function ruf(pfad, host, methode, kopf = {}, koerper = null) {
  return new Promise((fertig, schief) => {
    const a = httpAnfrage({ host: "127.0.0.1", port: PORT, path: pfad, method: methode,
      headers: { Host: host, ...(koerper ? { "Content-Type": "application/json" } : {}), ...kopf } },
    (antwort) => {
      let text = "";
      antwort.on("data", (s) => { text += s; });
      antwort.on("end", () => fertig({ code: antwort.statusCode, text, kopf: antwort.headers }));
    });
    a.on("error", schief);
    if (koerper) a.write(JSON.stringify(koerper));
    a.end();
  });
}
const json = (a) => { try { return JSON.parse(a.text); } catch { return {}; } };
async function anmelden(rolle, code, host) {
  const r = await ruf("/workspace/api/anmelden", host, "POST", {}, { rolle, code });
  return [].concat(r.kopf?.["set-cookie"] || []).map((c) => c.split(";")[0]).join("; ");
}
const kDogi = await anmelden("admin", "CODE-DOGI-0001", HAUS);
const kHand = await anmelden("hand", "CODE-HAND-0001", CREW);
const kFrida = await anmelden("modi", "CODE-MODI-0001", CREW);
ok(!!kDogi && !!kHand && !!kFrida, "DogFather, die rechte Hand und ein Modi sind angemeldet");

/* Zwei Punkte, die andere setzen dürfen. */
const P1 = kat.ENTWICKLUNG_FREMD[0].schluessel;
const P2 = kat.ENTWICKLUNG_FREMD[1].schluessel;
const SELBST = kat.ENTWICKLUNG_SELBST[0].schluessel;

/* DIE ADRESSE GEHÖRT ZUM KEKS.

   Ein Zugang ist an das Haus gebunden, über das er angemeldet wurde --
   die rechte Hand arbeitet auf crew., DogFather auf workspace. Mein
   erster Entwurf schickte beide über dieselbe Adresse; die rechte Hand
   bekam daraufhin 401, und WEIL sie nichts setzen konnte, ging ein
   zweiter Test ("aus der Beobachtung eines anderen wird kein Schritt")
   aus dem falschen Grund durch. Ein grüner Haken über einer Leere. */
const wo = (keks) => (keks === kDogi ? HAUS : CREW);
const setzen = (keks, punkt, stufe, anlass) =>
  ruf(`/workspace/api/entwicklung/person/${idFrida}/${punkt}`, wo(keks),
    "PUT", { cookie: keks }, { stufe, anlass });
const schritt = (keks, punkt, person = idFrida) =>
  ruf(`/workspace/api/entwicklung/person/${person}/${punkt}/schritt`, wo(keks),
    "POST", { cookie: keks }, {});
const karte = async (keks = kDogi) => json(await ruf(
  `/workspace/api/entwicklung/person/${idFrida}`, wo(keks), "GET", { cookie: keks }));
const punktVon = (k, s) => k.bloecke?.flatMap((b) => b.punkte).find((p) => p.schluessel === s);

/* =======================================================================
   1. EIN SCHRITT ENTSTEHT NUR AUS EINEM „DA HAKT ES"
   ======================================================================= */
melde("");
melde("=== 1. Nur aus „Da hakt es“ ===");
{
  const l = await setzen(kDogi, P1, "laeuft");
  ok(l.code === 200, `„Läuft“ ist gesetzt (${l.code})`);
  const ohne = await schritt(kDogi, P1);
  ok(ohne.code === 400 && json(ohne).fehler === "kein_hakt",
    `daraus wird kein Schritt (${ohne.code}, ${json(ohne).fehler})`);

  /* Gar nichts gesetzt: auch nicht. */
  const nichts = await schritt(kDogi, P2);
  ok(nichts.code === 400 && json(nichts).fehler === "kein_hakt",
    "und aus gar nichts erst recht nicht");

  const h = await setzen(kDogi, P1, "hakt", "Am Dienstag zweimal hintereinander gesehen.");
  ok(h.code === 200, `mit „Da hakt es“ und Anlass geht es (${h.code})`);
  const ja = await schritt(kDogi, P1);
  ok(ja.code === 201, `und daraus wird ein Schritt (${ja.code})`);
  ok(json(ja).titel === kat.ENTWICKLUNG_FREMD[0].titel,
    `er heißt wie der Punkt: „${json(ja).titel}“`);
  ok(/^\d{4}-\d{2}-\d{2}$/.test(json(ja).frist || ""),
    `mit einer Frist in ${ent.SCHRITT_TAGE} Tagen (${json(ja).frist})`);
}

/* =======================================================================
   2. ES IST EINE ECHTE AUFGABE — keine Notiz
   ======================================================================= */
melde("");
melde("=== 2. Eine echte Aufgabe ===");
{
  const d = oeffne();
  const a = d.prepare("SELECT * FROM aufgaben WHERE aus_punkt = ?").get(P1);
  d.close();
  ok(!!a, "sie steht in der Aufgabentabelle, nicht in einer eigenen Liste");
  ok(a.verantwortlich_id === idFrida, "Frida ist verantwortlich, nicht DogFather");
  ok(a.erstellt_von === idDogi, "und DogFather hat sie angelegt");
  ok(a.status === "offen", `sie ist offen (${a.status})`);
  /* DER ANLASS WANDERT MIT -- ohne ihn stuende auf dem Brett ein Satz
     ohne Grund, und die Aufgabe waere ein Vorwurf. */
  ok(/Am Dienstag zweimal/.test(a.beschreibung || ""),
    "der Anlass steht in der Beschreibung");

  /* UND SIE STEHT WIRKLICH AUF DEM BRETT, nicht nur in der Tabelle. */
  const brett = json(await ruf("/workspace/api/aufgaben", HAUS, "GET", { cookie: kDogi }));
  const drauf = (brett.aufgaben || []).find((x) => x.id === a.id);
  ok(!!drauf, "und sie taucht auf dem Aufgabenbrett auf");

  /* AUCH FRIDA SIEHT SIE -- eine Aufgabe, die nur die Leitung sieht,
     waere wieder eine Notiz. */
  const ihres = json(await ruf("/workspace/api/aufgaben", CREW, "GET", { cookie: kFrida }));
  ok((ihres.aufgaben || []).some((x) => x.id === a.id),
    "Frida sieht sie ebenfalls — sonst wäre sie keine Aufgabe");
}

/* =======================================================================
   3. DIE KARTE ZEIGT IHN
   ======================================================================= */
melde("");
melde("=== 3. Die Karte zeigt ihn ===");
{
  const k = await karte();
  const p = punktVon(k, P1);
  ok(!!p?.schritt, "an dem Punkt hängt der Schritt");
  ok(p.schritt.status === "offen", `er läuft (${p.schritt.status})`);
  ok(punktVon(k, P2)?.schritt === null, "an einem Punkt ohne Schritt hängt nichts");

  /* ZWEIMAL ZUM SELBEN PUNKT WAERE ZWEIMAL DIESELBE ERINNERUNG -- und
     die zweite macht die erste wertlos. */
  const nochmal = await schritt(kDogi, P1);
  ok(nochmal.code === 400 && json(nochmal).fehler === "schon_da",
    `ein zweiter Schritt zum selben Punkt: abgelehnt (${json(nochmal).fehler})`);
  ok(json(nochmal).aufgabe_id === p.schritt.id,
    "und die Absage nennt den, der schon läuft");
}

/* =======================================================================
   4. WER DARF — UND WER NICHT
   ======================================================================= */
melde("");
melde("=== 4. Wer darf ===");
{
  /* DIE RECHTE HAND FÜHRT DAS TEAM MIT -- sie darf. */
  await setzen(kHand, P2, "hakt", "Ist mir im Stream am Freitag aufgefallen.");
  const hand = await schritt(kHand, P2);
  ok(hand.code === 201, `die rechte Hand darf auch (${hand.code})`);

  /* EIN MODI NICHT -- nicht für sich und nicht für andere. */
  const modi = await ruf(`/workspace/api/entwicklung/person/${idFrida}/${P1}/schritt`,
    CREW, "POST", { cookie: kFrida }, {});
  ok(json(modi).fehler === "nicht_gefunden", "mit der Auskunft „gibt es nicht“");
  ok(modi.code === 404, `ein Modi bekommt 404 — nicht „verboten“ (${modi.code})`);

  /* AUS DER BEOBACHTUNG EINES ANDEREN wird kein Schritt: DogFather hat
     bei P2 nichts gesetzt, die rechte Hand schon. */
  const fremd = await schritt(kDogi, P2);
  ok(fremd.code === 400 && json(fremd).fehler === "kein_hakt",
    "und aus der Beobachtung eines anderen auch nicht");

  /* EIN PUNKT AUS BLOCK 5 SIEHT VON AUSSEN AUS WIE EIN ERFUNDENER. */
  const geheim = await schritt(kDogi, SELBST);
  ok(geheim.code === 404, `ein Punkt aus „Wie geht's dir?“ gibt 404 (${geheim.code})`);
  const quatsch = await schritt(kDogi, "e-gibt-es-nicht");
  ok(quatsch.code === 404, "ein erfundener Punkt ebenfalls");
}

/* =======================================================================
   5. IM PROTOKOLL STEHT, DASS — NICHT WORAN
   ======================================================================= */
melde("");
melde("=== 5. Das Protokoll ===");
{
  const d = oeffne();
  const zeilen = d.prepare(
    "SELECT detail FROM protokoll WHERE aktion = 'entwicklung_schritt'").all();
  d.close();
  ok(zeilen.length === 2, `${zeilen.length} Schritte stehen im Protokoll`);
  ok(zeilen.every((z) => /Frida/.test(z.detail || "")),
    "mit Punkt und Name — das ist der Vorgang");
  /* WORAN JEMAND ETWAS GEMERKT HAT, GEHÖRT NICHT INS PROTOKOLL. Es
     liest sich anders, wenn es zwischen Anmeldungen steht. */
  ok(!zeilen.some((z) => /Dienstag|Freitag/.test(z.detail || "")),
    "aber ohne den Anlass");
}

/* =======================================================================
   6. UND DANN SCHLIESST SICH DER KREIS
   ======================================================================= */
melde("");
melde("=== 6. Der Kreis ===");
{
  const d = oeffne();
  const a = d.prepare("SELECT id FROM aufgaben WHERE aus_punkt = ?").get(P1);
  d.close();
  const fertig = await ruf(`/workspace/api/aufgaben/${a.id}`, HAUS, "PATCH",
    { cookie: kDogi }, { status: "erledigt" });
  ok(fertig.code === 200, `die Aufgabe wird erledigt (${fertig.code})`);

  const k = await karte();
  const p = punktVon(k, P1);
  ok(p.schritt?.status === "erledigt", `die Karte sieht das (${p.schritt?.status})`);
  ok(!!p.schritt?.erledigt_am, "mit Datum");

  /* UND DANACH GEHT ES WIEDER -- der Kreis ist ein Kreis, keine
     Einbahnstrasse. Waere das gesperrt, koennte man denselben Punkt
     nie wieder angehen. */
  const zweite = await schritt(kDogi, P1);
  ok(zweite.code === 201, `zum selben Punkt geht danach ein neuer Schritt (${zweite.code})`);
  const k2 = await karte();
  ok(punktVon(k2, P1).schritt?.id === json(zweite).id,
    "und die Karte zeigt den NEUEN, nicht den alten");
}

/* =======================================================================
   7. DER VERWEIS AUFS BRETT FÜHRT WIRKLICH HIN
   ======================================================================= */
melde("");
melde("=== 7. Der Verweis ===");
{
  /* `aufgaben.html#a12` stand an drei Stellen im Haus und wurde von
     keiner gelesen -- das Brett kannte nur `?zeigen=`. Wer draufdrueckte,
     landete auf dem Brett und suchte von Hand. */
  const brett = readFileSync(new URL("../workspace/assets/js/aufgaben.js", import.meta.url), "utf8");
  ok(/data-id=/.test(brett), "die Karten auf dem Brett tragen ihre Nummer");
  ok(/\^#a/.test(brett), "und das Brett liest `#a<nummer>` aus der Adresse");

  const e = readFileSync(new URL("../workspace/assets/js/entwicklung.js", import.meta.url), "utf8");
  ok(/aufgaben\.html#a/.test(e), "die Entwicklungskarte verweist in dieser Schreibweise");
  const b = readFileSync(new URL("../workspace/assets/js/bereich.js", import.meta.url), "utf8");
  const r = readFileSync(new URL("../workspace/assets/js/report.js", import.meta.url), "utf8");
  ok(/aufgaben\.html#a/.test(b) && /aufgaben\.html#a/.test(r),
    "die beiden anderen Stellen auch — sie funktionieren jetzt mit");
}

/* =======================================================================
   8. IM BROWSER
   ======================================================================= */
melde("");
melde("=== 8. Im Browser ===");
{
  const { chromium } = await import(
    "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
  const browser = await chromium.launch();
  const kontext = await browser.newContext({ viewport: { width: 1280, height: 1100 } });
  await kontext.addCookies(kDogi.split("; ").filter(Boolean).map((teil) => {
    const i = teil.indexOf("=");
    return { name: teil.slice(0, i), value: teil.slice(i + 1), domain: "127.0.0.1", path: "/" };
  }));
  const seite = await kontext.newPage();
  const konsole = [];
  seite.on("console", (m) => { if (m.type() === "error" && !/favicon|ERR_/i.test(m.text())) konsole.push(m.text()); });
  seite.on("pageerror", (e) => konsole.push("Absturz: " + e.message));

  await seite.goto(`http://127.0.0.1:${PORT}/workspace/entwicklung.html`, { waitUntil: "networkidle" });
  await seite.waitForTimeout(800);
  /* Erst die Person öffnen -- ohne Karte gibt es keine Punkte. */
  /* FRIDAS KARTE, nicht die erste in der Liste. Die steht dort nach
     der Hierarchie des Hauses -- also die rechte Hand -- und die hat
     keinen Schritt. Mein erster Entwurf klickte blind auf die erste
     und maß danach eine leere Karte. */
  await seite.click('.e-person:has-text("Frida")');
  await seite.waitForTimeout(900);

  const stand = await seite.evaluate(() => ({
    punkte: document.querySelectorAll(".e-punkt").length,
    laeuft: document.querySelectorAll('.e-schritt[data-lage="laeuft"]').length,
    knoepfe: document.querySelectorAll(".e-schritt__knopf").length,
    leere: document.querySelectorAll(".e-schritt:not([data-lage])").length,
    verweis: document.querySelector(".e-schritt__hin")?.getAttribute("href") || "",
  }));
  ok(stand.punkte > 20, `${stand.punkte} Punkte stehen auf der Karte`);
  ok(stand.laeuft >= 1, `${stand.laeuft} Schritt läuft sichtbar`);
  ok(/aufgaben\.html#a\d+/.test(stand.verweis),
    `und verweist auf die Aufgabe (${stand.verweis})`);
  /* KEIN KNOPF, WO ER NICHTS TUN KANN. Bei über zwanzig Punkten wären
     zwanzig Knöpfe, die fast alle „geht nicht" antworten, schlimmer
     als keiner. */
  ok(stand.knoepfe === 0,
    "an den übrigen Punkten steht kein Knopf — dort hakt nichts");
  ok(stand.leere > 20, `und dort steht auch kein leerer Kasten (${stand.leere})`);

  /* DER SPRUNG: die Adresse mit der Nummer, und das Brett zeigt genau
     die eine Aufgabe. */
  const d = oeffne();
  const a = d.prepare("SELECT id FROM aufgaben WHERE aus_punkt IS NOT NULL ORDER BY id DESC").get();
  d.close();
  await seite.goto(`http://127.0.0.1:${PORT}/workspace/aufgaben.html#a${a.id}`,
    { waitUntil: "networkidle" });
  await seite.waitForTimeout(1100);
  const sprung = await seite.evaluate(() => ({
    leiste: document.querySelector(".ziel-leiste__text")?.textContent || "",
    marke: document.querySelector(".ziel-leiste__marke")?.textContent || "",
  }));
  ok(/Diese eine Aufgabe/.test(sprung.leiste),
    `das Brett sagt, was es zeigt: „${sprung.leiste}“`);
  ok(sprung.marke === "1", `und es ist genau eine (${sprung.marke})`);

  ok(konsole.length === 0,
    konsole.length ? "Fehler im Browser: " + konsole[0].slice(0, 90) : "keine Fehler im Browser");
  await browser.close();
}

/* ------------------------------------------------------------------- */
melde("");
melde(`${geprueft} Pruefungen, ${fehler} Fehler`);
melde(fehler ? "NICHT IN ORDNUNG" : "ALLES IN ORDNUNG");
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* Aufraeumrest */ }
process.exit(fehler ? 1 : 0);