dogfather-universe/server/pruef-verborgen.mjs

/* Browserpruefung der Startseite: Gruppen, Zeichen, Farbtoene, Zahlen auf
   den Kacheln -- und was jede Rolle davon zu sehen bekommt. */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-start-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
process.env.PORT = "4186";
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-start-ansicht");
await new Promise((r) => setTimeout(r, 700));
const BASIS = "http://127.0.0.1:4186";
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 200_000).unref?.();

/* ORTSZEIT, nicht UTC. Die Anwendung rechnet "heute" nach der Uhr des
   Benutzers; toISOString() liefert dagegen UTC und damit zwischen
   Mitternacht und 2 Uhr den VORTAG. In diesem Fenster schlug diese
   Pruefung fehl, ohne dass etwas kaputt war. */
const tagText = (d = new Date()) =>
  `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`
  + `-${String(d.getDate()).padStart(2, "0")}`;

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 } = await import("node:crypto");
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
const heute = tagText();
const gestern = tagText(new Date(Date.now() - 86400_000));
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 idScout = anlegen("Patrick", "scout", "CODE-SCOU-0001");
const idAnna  = anlegen("Tili", "creator", "CODE-ANNA-0001");
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idAnna, idScout, jetzt);

/* Filipe, Patrick und Tili legt die Vorlage oben schon an. Hier kommen
   die drei dazu, die diese Pruefung braucht -- VanVan als ZWEITER
   Admin-Zugang (also mit hoeherer Nummer als Filipe, das ist der
   ganze Unterschied), dazu Spicy Media und ein Manager. */
const idVan   = anlegen("VanVan", "admin", "CODE-VAN-0001");
const idSpicy = anlegen("Cigdem", "spicy", "CODE-SPIC-0001");
const idMan   = anlegen("Schulle", "manager", "CODE-MAN-0001");
d.prepare("INSERT INTO scout_zuteilung (scout_id, manager_id, seit) VALUES (?,?,?)").run(idScout, idMan, jetzt);
d.close();

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

async function anmelden(kontext, rolle, code) {
  const seite = await kontext.newPage();
  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 seite;
}

console.log("\n=== Niemand sieht VanVan ausser DogFather ===");
console.log(`   (DogFather = id ${idDogi}, VanVan = id ${idVan})\n`);

/* Jede Schnittstelle, die Personen ausgibt. Wer eine neue baut, sollte
   sie hier eintragen -- die Liste ist die Landkarte dieser Regel. */
const WEGE = [
  ["Chat-Partner",        "/workspace/api/chat/partner",              (d) => d.personen],
  ["Personenverwaltung",  "/workspace/api/verwaltung/personen",       (d) => d.personen],
  ["Betreuer-Auswahl",    "/workspace/api/verwaltung/personen",       (d) => d.betreuer],
  ["Zentrale (Team)",     "/workspace/api/zentrale",                  (d) => d.segmente],
  /* NACHGESEHEN STATT GERATEN: Es gibt genau EINEN Endpunkt fuer die
     Personenwahl -- `/workspace/api/personen` aus workspace-aufgaben.js.
     Kalender, Aufgaben und Dateien benutzen alle denselben. Meine
     ersten beiden Pfade waren erfunden und lieferten 404; eine
     Pruefung, die auf einen 404 laeuft, prueft nichts. */
  ["Personenwahl",        "/workspace/api/personen",                  (d) => d.personen],
];

for (const [rolle, code, name] of [
  ["admin", "CODE-DOGI-0001", "Filipe (DogFather)"],
  ["admin", "CODE-VAN-0001", "VanVan selbst"],
  ["spicy", "CODE-SPIC-0001", "Cigdem (Spicy Media)"],
  ["manager", "CODE-MAN-0001", "Schulle (Manager)"],
  ["scout", "CODE-SCOU-0001", "Patrick (Scout)"],
  ["creator", "CODE-ANNA-0001", "Tili (Creator)"],
]) {
  const k = await browser.newContext({ viewport: { width: 1200, height: 900 } });
  const s = await anmelden(k, rolle, code);
  /* DARF diese Person VanVan sehen? Nur DogFather selbst -- und
     VanVan sich selbst. */
  const darf = code === "CODE-DOGI-0001" || code === "CODE-VAN-0001";
  for (const [was, pfad, ziehen] of WEGE) {
    const antwort = await s.evaluate(async (u) => {
      const a = await fetch(u);
      if (!a.ok) return { code: a.status };
      return { code: 200, daten: await a.json() };
    }, pfad);
    if (antwort.code !== 200) {
      /* Kein Zugriff ist kein Befund -- aber es wird GESAGT, damit
         niemand glaubt, hier sei etwas geprueft worden. */
      console.log(`  --   ${name.padEnd(22)} ${was.padEnd(20)} kein Zugriff (${antwort.code})`);
      continue;
    }
    let liste = [];
    try { liste = ziehen(antwort.daten) || []; } catch { liste = []; }
    const drin = liste.some((x) => x && (x.id === idVan || x.person_id === idVan
      || String(x.name || "").includes("VanVan")));
    if (darf) {
      ok(true, `${name.padEnd(22)} ${was.padEnd(20)} ${drin ? "sieht VanVan" : "(nicht in dieser Liste)"}`);
    } else {
      ok(!drin, `${name.padEnd(22)} ${was.padEnd(20)} ${drin ? "SIEHT VANVAN — FEHLER" : "sieht VanVan nicht"}`);
    }
  }
  await k.close();
}

/* ---- GEGENPROBE: Kann diese Pruefung ueberhaupt anschlagen? --------
   Ohne sie waere "sieht VanVan nicht" auch dann gruen, wenn die
   Listen leer zurueckkaemen oder die Namen anders hiessen. Also
   einmal ohne Regel nachsehen: Ein Manager MUSS DogFather sehen --
   dieselbe Liste, dieselbe Rolle, nur eine Person weiter. */
{
  const k = await browser.newContext({ viewport: { width: 1200, height: 900 } });
  const s = await anmelden(k, "manager", "CODE-MAN-0001");
  const daten = await s.evaluate(async () =>
    (await (await fetch("/workspace/api/chat/partner")).json()));
  const sichtDogi = (daten.personen || []).some((x) => x.id === idDogi);
  ok(sichtDogi, `Gegenprobe: der Manager SIEHT DogFather in derselben Liste `
    + `(${(daten.personen || []).length} Personen) — die Pruefung misst also wirklich etwas`);
  await k.close();
}

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