dogfather-universe/server/pruef-team.mjs

/* Prueft zwei Wuensche vom 01.09.2026:

   SCREEN 2: "ich will, dass wir Manager, Scouts, DogFather auch die
   Fotos, Namen und so alles sehen, alles was die in ihrem Profil
   eintragen."

   SCREEN 5: "wieso seh ich mein Bild da nicht, obwohl ich schon ein Foto
   drin hab?"

   WAS AN DIESER PRUEFUNG WICHTIG IST.

   Ein Profilbild zu pruefen, ohne ein echtes Bild zu haben, beweist
   nichts. Beim .wer__bild-Fehler im August benutzte die Pruefung ein
   1x1-Pixel-PNG -- damit kann kein Stil-Fehler sichtbar werden, weil
   ein Punkt nichts ueberdecken kann. Hier wird deshalb ein RICHTIGES
   Bild hochgeladen (600x600) und danach gemessen, ob es auch die
   Flaeche fuellt, die es fuellen soll -- und ob es rund beschnitten ist
   statt quadratisch ueber den Rahmen zu ragen.

   Und zu jeder Aussage die Gegenprobe: Wer KEIN Bild hat, muss den
   Buchstaben sehen. Sonst koennte die Pruefung gruen sein, weil
   ueberall Bilder erscheinen -- auch da, wo keine sind. */

import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { deflateSync } from "node:zlib";

const ordner = mkdtempSync(join(tmpdir(), "ws-team-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DATEN_ORDNER wird aus dem Datenbankpfad abgeleitet (workspace.js) --
   die Profilbilder landen also von selbst im Testordner. */
process.env.PORT = "4213";
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");
/* 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-team");
await new Promise((r) => setTimeout(r, 700));
const BASIS = "http://127.0.0.1:4213";
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 300_000).unref?.();

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

await fetch(BASIS + "/workspace/api/anmelden", {
  method: "POST", headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes, createHash } = await import("node:crypto");
for (let i = 0; i < 60; i++) {
  try {
    const p = new DatabaseSync(process.env.WORKSPACE_DB);
    try { p.prepare("SELECT 1 FROM personen LIMIT 1").get(); break; } finally { p.close(); }
  } catch { await new Promise((r) => setTimeout(r, 250)); }
}
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("Filipe", "admin", "CODE-DOGI-0001");
const idMgr   = anlegen("Mara", "manager", "CODE-MANA-0001");
const idScout = anlegen("Patrick", "scout", "CODE-SCOU-0001");
const idTili  = anlegen("Tili", "creator", "CODE-ANNA-0001");
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)")
  .run(idTili, idScout, jetzt);

/* Jeder traegt etwas in seinen Steckbrief ein -- sonst koennte die
   Pruefung nicht unterscheiden, ob "alles was die eintragen" wirklich
   ankommt oder ob nur Namen angezeigt werden. */
d.prepare("UPDATE personen SET ueber_mich = ?, tiktok = ? WHERE id = ?")
  .run("Manager & CEO dieser Seite", "dogfather", idDogi);
d.prepare("UPDATE personen SET ueber_mich = ?, instagram = ? WHERE id = ?")
  .run("Ich kuemmere mich um die Vertraege.", "mara.mgmt", idMgr);
d.prepare("UPDATE personen SET ueber_mich = ? WHERE id = ?")
  .run("Ich finde neue Leute.", idScout);
/* Tili bekommt BEWUSST nichts -- die Gegenprobe zum Platzhaltersatz. */
d.close();

/* ---- Ein echtes PNG, 600x600, einfarbig. Kein 1x1-Punkt: Der kann
       nichts ueberdecken und wuerde jeden Stil-Fehler verstecken. ---- */
function pngBauen(breite, hoehe) {
  const roh = Buffer.alloc((breite * 3 + 1) * hoehe);
  for (let y = 0; y < hoehe; y++) {
    const z = y * (breite * 3 + 1);
    roh[z] = 0;
    for (let x = 0; x < breite; x++) {
      roh[z + 1 + x * 3] = 200; roh[z + 2 + x * 3] = 60; roh[z + 3 + x * 3] = 120;
    }
  }
  const stueck = (art, daten) => {
    const l = Buffer.alloc(4); l.writeUInt32BE(daten.length);
    const k = Buffer.concat([Buffer.from(art), daten]);
    const c = Buffer.alloc(4);
    c.writeUInt32BE(crc32(k) >>> 0);
    return Buffer.concat([l, k, c]);
  };
  const ihdr = Buffer.alloc(13);
  ihdr.writeUInt32BE(breite, 0); ihdr.writeUInt32BE(hoehe, 4);
  ihdr[8] = 8; ihdr[9] = 2; ihdr[10] = 0; ihdr[11] = 0; ihdr[12] = 0;
  return Buffer.concat([
    Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
    stueck("IHDR", ihdr), stueck("IDAT", deflateSync(roh)), stueck("IEND", Buffer.alloc(0)),
  ]);
}
let tabelle = null;
function crc32(buf) {
  if (!tabelle) {
    tabelle = new Int32Array(256);
    for (let n = 0; n < 256; n++) {
      let c = n;
      for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
      tabelle[n] = c;
    }
  }
  let c = -1;
  for (const b of buf) c = tabelle[(c ^ b) & 0xff] ^ (c >>> 8);
  return c ^ -1;
}
const BILD = pngBauen(600, 600);

/* ---------------------------------------------------------------- */

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: 1280, height: 1000 } });
  const konsole = [];
  const seite = await kontext.newPage();
  seite.on("console", (m) => { if (m.type() === "error") konsole.push(m.text()); });
  seite.on("pageerror", (e) => konsole.push("pageerror: " + e.message));
  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 { kontext, seite, konsole };
}

/* ================================================================
   1. Ein echtes Bild hochladen -- und pruefen, dass es ueberall ankommt
   ================================================================ */
console.log("\n=== Das eigene Bild (Screen 5)");
const a1 = await anmelden("admin", "CODE-DOGI-0001");

const hoch = await a1.seite.evaluate(async (b64) => {
  const roh = Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
  const a = await fetch("/workspace/api/steckbrief/bild", {
    method: "POST", credentials: "same-origin",
    headers: { "Content-Type": "image/png" }, body: roh,
  });
  return { status: a.status, ...(await a.json().catch(() => ({}))) };
}, BILD.toString("base64"));
ok(hoch.status === 200 && !!hoch.bild, `ein echtes Bild (600x600) laesst sich hochladen (${hoch.status})`);

/* Kommt es auf der STARTSEITE in der Begruessung an? Das war der
   gemeldete Fehler: Dort stand der Buchstabe, obwohl ein Foto da war --
   und im Server steht seit jeher der Kommentar "es steht in der
   Kopfleiste JEDER Seite UND IN DER BEGRUESSUNG". Die Absicht war
   aufgeschrieben, die Haelfte nie gebaut. */
await a1.seite.goto(BASIS + "/workspace/start.html", { waitUntil: "networkidle" });
await a1.seite.waitForTimeout(1500);
const gruss = await a1.seite.evaluate(() => {
  const p = document.getElementById("plakette");
  const b = p?.querySelector("img");
  if (!b) return { bild: false, text: p?.textContent || "" };
  const r = b.getBoundingClientRect();
  const pr = p.getBoundingClientRect();
  const st = getComputedStyle(b);
  const ps = getComputedStyle(p);
  return {
    bild: true,
    geladen: b.complete && b.naturalWidth > 0,
    /* Fuellt es die Plakette wirklich aus? Ein Bild, das nur zu einem
       Viertel drinsteht, sieht aus wie ein Fehler. */
    fuellt: r.width >= pr.width - 2 && r.height >= pr.height - 2,
    /* Rund beschnitten -- ohne overflow:hidden ragt ein quadratisches
       Bild aus dem runden Rahmen. */
    beschnitten: ps.overflow === "hidden",
    passung: st.objectFit,
    kein_text: (p.textContent || "").trim() === "",
  };
});
ok(gruss.bild === true, "die Begruessung zeigt das Bild statt des Buchstabens");
ok(gruss.geladen === true, "  und es ist wirklich geladen (nicht nur ein leerer Rahmen)");
ok(gruss.fuellt === true, "  es fuellt die Plakette aus");
ok(gruss.beschnitten === true, "  und ist rund beschnitten (overflow: hidden)");
ok(gruss.passung === "cover", `  ohne zu verzerren (object-fit: ${gruss.passung})`);
ok(gruss.kein_text === true, "  der Buchstabe steht nicht mehr daneben");

/* ================================================================
   2. Das Team -- alle Rollen, mit allem, was sie eingetragen haben
   ================================================================ */
console.log("\n=== Das Team (Screen 2)");
await a1.seite.goto(BASIS + "/workspace/steckbrief.html", { waitUntil: "networkidle" });
await a1.seite.waitForTimeout(1600);

const team = await a1.seite.evaluate(() => {
  const block = document.getElementById("team-block");
  const karten = [...document.querySelectorAll(".team-karte")];
  const sichtbar = (e) => {
    const r = e.getBoundingClientRect();
    return r.width > 0 && r.height > 0;
  };
  return {
    da: block && !block.hidden,
    /* IST DER STIL ANGEKOMMEN? Die .block__*-Klassen stehen in
       automation.css und wissen.css -- diese Seite laedt beide nicht.
       Genau so sind hier schon zweimal Stile ins Leere gelaufen.
       Gemessen wird deshalb der tatsaechliche Stil, nicht die Klasse. */
    /* SEIT DEM 07.09.2026 IST DER RAND KEINE `border` MEHR, sondern
       eine Silhouette mit abgeschnittener Ecke aus module.css. Die
       alte Bedingung (border >= 1) wurde dadurch zwangsläufig rot,
       ohne dass ein Stil fehlte. Die FRAGE bleibt aber genau dieselbe
       und ist so wichtig wie zuvor: Ist der Stil auf DIESER Seite
       angekommen? Gemessen wird sie jetzt an der neuen Bauweise --
       Polsterung wie bisher, dazu die Silhouette, die es nur gibt,
       wenn module.css wirklich geladen wurde. */
    gestaltet: karten[0] ? (() => {
      const st = getComputedStyle(karten[0]);
      return parseFloat(st.paddingLeft) >= 8 && /polygon/.test(st.clipPath);
    })() : null,
    anzahl: karten.length,
    sichtbare: karten.filter(sichtbar).length,
    gruppen: [...document.querySelectorAll(".team-gruppe__name")].map((e) => e.textContent),
    leute: karten.map((k) => ({
      name: k.querySelector(".team-karte__name")?.textContent,
      rolle: k.dataset.rolle,
      rollenname: k.querySelector(".team-karte__rolle")?.textContent,
      ueber: k.querySelector(".team-karte__ueber")?.textContent || null,
      bild: !!k.querySelector(".team-karte__bild img"),
      buchstabe: k.querySelector(".team-karte__bild img")
        ? null : (k.querySelector(".team-karte__bild")?.textContent || "").trim(),
      kanaele: [...k.querySelectorAll(".team-kanal")].map((a) => a.getAttribute("href")),
      ich: k.dataset.ich === "ja",
    })),
    ueber: document.documentElement.scrollWidth - document.documentElement.clientWidth,
  };
});

ok(team.da === true, "der Team-Block erscheint");
ok(team.gestaltet === true, "  und die Stile sind angekommen (Rand und Polsterung gemessen)");
ok(team.anzahl === 4 && team.sichtbare === 4,
   `alle vier Personen stehen da (${team.anzahl}, davon ${team.sichtbare} sichtbar)`);
ok(team.gruppen.join(", ") === "Management, Scouting, Creator",
   `nach Rollen gruppiert: ${team.gruppen.join(", ")}`);

const dogi = team.leute.find((l) => l.name === "Filipe");
const mara = team.leute.find((l) => l.name === "Mara");
const pat  = team.leute.find((l) => l.name === "Patrick");
const tili = team.leute.find((l) => l.name === "Tili");

ok(!!dogi && !!mara && !!pat && !!tili,
   "Manager, Scout, DogFather UND Creator sind dabei – nicht nur Creator");
ok(dogi?.bild === true, "DogFather wird mit seinem Foto gezeigt");
ok(dogi?.ueber === "Manager & CEO dieser Seite",
   `  und mit dem, was er ueber sich geschrieben hat ("${dogi?.ueber}")`);
ok(dogi?.ich === true, "  seine eigene Karte ist als solche gekennzeichnet");
ok(/tiktok\.com/.test(dogi?.kanaele?.[0] || ""),
   `  sein Kanal fuehrt wirklich hin (${dogi?.kanaele?.[0]})`);
ok(mara?.ueber === "Ich kuemmere mich um die Vertraege.", "der Manager-Text kommt an");
ok(pat?.ueber === "Ich finde neue Leute.", "der Scout-Text kommt an");
ok(mara?.rollenname === "Manager" && pat?.rollenname === "Scout",
   `die Rolle steht dabei (${mara?.rollenname}, ${pat?.rollenname})`);

/* GEGENPROBEN -- ohne sie waere oben alles auch dann gruen, wenn die
   Seite einfach ueberall Bilder und Texte hinschriebe. */
ok(mara?.bild === false && mara?.buchstabe === "M",
   `Gegenprobe: wer kein Foto hat, bekommt den Buchstaben ("${mara?.buchstabe}")`);
ok(tili?.ueber === null,
   "Gegenprobe: wer nichts ueber sich geschrieben hat, bekommt keinen Platzhaltersatz");
ok(tili?.kanaele?.length === 0,
   "Gegenprobe: ohne Kanal steht dort auch keiner");
ok(mara?.ich === false, "Gegenprobe: fremde Karten sind nicht als 'du' markiert");
ok(team.ueber <= 0, `nichts steht seitlich ueber (${team.ueber}px)`);
ok(a1.konsole.length === 0,
   `keine Fehler in der Konsole${a1.konsole.length ? " -> " + a1.konsole.join(" | ") : ""}`);

await a1.seite.screenshot({ path: "pruef-team.png", fullPage: false });
await a1.kontext.close();

/* ================================================================
   3. Ein Creator sieht seine Betreuung -- aber nicht die anderen Creator
   ================================================================ */
console.log("\n=== Was ein Creator davon sieht");
const a2 = await anmelden("creator", "CODE-ANNA-0001");
await a2.seite.goto(BASIS + "/workspace/profil.html", { waitUntil: "networkidle" });
await a2.seite.waitForTimeout(1600);
const sicht = await a2.seite.evaluate(() => ({
  da: !document.getElementById("team-block")?.hidden,
  namen: [...document.querySelectorAll(".team-karte__name")].map((e) => e.textContent).sort(),
}));
ok(sicht.da === true, "ein Creator sieht das Team auf seiner Profilseite");
ok(sicht.namen.includes("Patrick"), "  seinen Scout");
ok(sicht.namen.includes("Filipe") && sicht.namen.includes("Mara"),
   "  und das Management");
ok(a2.konsole.length === 0,
   `keine Fehler in der Konsole${a2.konsole.length ? " -> " + a2.konsole.join(" | ") : ""}`);
await a2.kontext.close();

/* Ein zweiter Creator, um zu pruefen, dass Creator einander NICHT sehen.
   Das ist kein Schoenheitsfehler: Der Server entscheidet das, und wenn
   sich die Regel je aendert, muss es hier auffallen. */
const d2 = new DatabaseSync(process.env.WORKSPACE_DB);
const salt = randomBytes(16).toString("hex");
const hash = scryptSync("CODE-LUNA-0001", salt, 64, { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
d2.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
  .run("Luna", "creator", hash, salt, 32768, jetzt);
d2.close();

const a3 = await anmelden("creator", "CODE-ANNA-0001");
await a3.seite.goto(BASIS + "/workspace/profil.html", { waitUntil: "networkidle" });
await a3.seite.waitForTimeout(1600);
const fremd = await a3.seite.evaluate(() =>
  [...document.querySelectorAll(".team-karte__name")].map((e) => e.textContent));
ok(!fremd.includes("Luna"),
   `Gegenprobe: ein Creator sieht einen fremden Creator NICHT (${fremd.join(", ")})`);
await a3.kontext.close();

await browser.close();
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
console.log(fehler ? `\n${fehler} Prüfung(en) fehlgeschlagen.` : "\nAlles in Ordnung.");
process.exit(fehler ? 1 : 0);