DogFatherGitandClaude Opus 5
1ce2c3785e
VanVan im Support, Meldung #5, zweite Runde: „Man kann sich jetzt nur noch über die richtige Schaltfläche anmelden. Das funktioniert jetzt. Aber wenn man sich 2x versucht über den falschen Button anzumelden, dann kommt ein irreführender Text wo steht, dass die Auswahl oben nicht schuld ist." SIE HAT RECHT -- UND DER GRUND IST MEINE EIGENE AENDERUNG Auf der Crew-Wand stand ab dem zweiten Fehlversuch: „Zugangscode stimmt nicht. Achte auf die Bindestriche -- die Auswahl oben ist nicht schuld." Das war am 20.09.2026 richtig. Dort gab es den STILLEN ZUGANG: Die rechte Hand und die Modis kamen ueber die Codekennung herein, egal welche Kachel sie antippten. Der Satz „Stimmt die Auswahl oben?" haette sie in eine Schleife geschickt -- alle Kacheln durchprobieren, acht Fehlversuche, Adresse gesperrt. Ein Hinweis, der die Sperre herbeifuehrt, gegen die er helfen soll. Mit VanVans ERSTER Runde derselben Meldung ist der stille Zugang weggefallen („es soll fest sein"). Nachgemessen in workspace.js: Die Kandidaten kommen seither aus `WHERE rolle = ?`, auf beiden Waenden. Die Kachel entscheidet ueberall -- und der Satz sagte ab diesem Tag das Gegenteil der Wahrheit, genau an der Stelle, an der jemand feststeckt. DAS IST DIE SORTE FEHLER, DIE EIN UMBAU HINTERLAESST: Nicht der neue Code war falsch, sondern ein Satz drei Dateien weiter, dessen Voraussetzung er entfernt hat. Er stand sogar ausfuehrlich begruendet da -- und die Begruendung las sich beim Umbau wie eine Bestaetigung, weil sie von einem Zustand sprach, den es nicht mehr gab. Gefunden hat ihn kein Prueflauf, sondern VanVan beim Benutzen. GEAENDERT: Ein Satz fuer beide Waende. Die Fallunterscheidung nach Wand ist weg -- es gibt nur noch eine Regel, also auch nur noch eine Auskunft. Der Hinweis auf die Bindestriche bleibt; er galt nie nur fuer eine Wand. „Zugangscode stimmt nicht. Stimmt die Auswahl oben? Ein Code gehört immer zu genau einer davon – und achte auf die Bindestriche." GEPRUEFT -- pruef-modi-verborgen 87 -> 94 ok Im echten Browser, beide Waende (crew-index.html und index.html), je zweimal mit einem falschen Code: · die Waende sind wirklich verschieden (gate--crew true/false) · „nicht schuld" steht nirgends mehr · stattdessen die Frage nach der Auswahl -- die dort seit dem 01.10. wirklich gilt (Abschnitt 1 derselben Datei misst das) · derselbe Satz auf beiden Waenden · Gegenprobe: nach dem ERSTEN Versuch steht er noch nicht da, dort steht die kurze Absage. Ein Hinweis, der immer kommt, waere keiner. DIE VERSUCHSSPERRE WIRD VOR DER MESSUNG GELEERT. Acht Fehlversuche je Adresse in zehn Minuten -- die Abschnitte davor verbrauchen welche, und ab dem neunten stuende „Zu viele Versuche" statt des Satzes. Das waere ein roter Haken ueber die Messumgebung gewesen, nicht ueber das Programm. Dazu: pruef-struktur 102 ok. BEIDE HAEUSER BETROFFEN, und das ist hier richtig: Es ist dieselbe Anmeldung mit derselben Regel. Nachgewiesen wird genau das -- der Satz ist auf beiden Waenden derselbe, und er stimmt auf beiden. Co-Authored-By: Claude Opus 5 <[email protected]>
834 lines
40 KiB
JavaScript
834 lines
40 KiB
JavaScript
/* =====================================================================
|
|
DER VERBORGENE MODI-ZUGANG
|
|
|
|
Zwei Fragen, und sie sind nicht dieselbe:
|
|
|
|
1. KOMMT EIN MODI HEREIN, ohne dass es dafuer eine Kachel gibt?
|
|
2. MERKT SONST JEMAND ETWAS DAVON?
|
|
|
|
Die zweite ist die schwierigere. Eine Liste zu filtern ist leicht;
|
|
uebersehen wird die ZAHL daneben, die weiter alles mitzaehlt -- und
|
|
eine Personenzahl, die nicht zur Liste passt, verraet genauso viel
|
|
wie ein Name.
|
|
|
|
MIT GEGENPROBE. Ganz unten wird die Regel absichtlich ausgehebelt
|
|
(ein Modi bekommt in der Datenbank eine andere Rolle), und dann MUSS
|
|
der Manager ihn sehen. Ohne diesen Teil waere nicht bewiesen, dass
|
|
die Pruefung ueberhaupt anschlagen kann -- eine Pruefung, die immer
|
|
bestaetigt, bestaetigt nichts.
|
|
===================================================================== */
|
|
import { mkdtempSync, rmSync } from "node:fs";
|
|
import { tmpdir } from "node:os";
|
|
import { join } from "node:path";
|
|
|
|
const ordner = mkdtempSync(join(tmpdir(), "ws-modi-"));
|
|
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
|
|
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
|
|
Ohne diese Zeile startet der eigene Server bei belegtem Port
|
|
STILL nicht -- und alles Folgende misst gegen einen fremden
|
|
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
|
|
als kaputt. */
|
|
const PORT = await eigenerPort(import.meta, "pruef-modi-verborgen");
|
|
process.env.PORT = `${PORT}`;
|
|
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";
|
|
import { eigenerPort } from "./helfer-port.mjs";
|
|
await import("./index.js");
|
|
/* NACH index.js: Der Server haengt dort zwei Auffangnetze ein, die
|
|
einen Absturz nur protokollieren. Fuer den Betrieb richtig, fuer eine
|
|
Pruefung fatal -- ohne diese Zeile bliebe der Prozess ewig stehen. */
|
|
notbremse(180_000, "pruef-modi-verborgen");
|
|
await new Promise((r) => setTimeout(r, 700));
|
|
const BASIS = `http://127.0.0.1:${PORT}`;
|
|
|
|
let fehler = 0;
|
|
let geprueft = 0;
|
|
const ok = (b, t) => { geprueft++; console.log((b ? " ok " : " FEHL ") + t); if (!b) fehler++; };
|
|
/* Der dritte Ausgang: Konnte nicht nachgesehen werden. Kein Befund,
|
|
aber auch keine Bestaetigung -- und es wird gesagt, damit niemand
|
|
glaubt, hier sei etwas geprueft worden. */
|
|
let offen = 0;
|
|
const unklar = (t) => { offen++; console.log(" -- " + t); };
|
|
|
|
/* ---------- Personen anlegen ---------------------------------------- */
|
|
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();
|
|
|
|
/* Der Suchschluessel muss VOR dem Anlegen dastehen -- die Personen
|
|
werden hier von Hand eingetragen, nicht ueber personAnlegen(). */
|
|
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);
|
|
const kennung = (code) => createHmac("sha256", schluessel).update(code).digest("hex");
|
|
|
|
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, kennung(code), jetzt);
|
|
return d.prepare("SELECT last_insert_rowid() AS id").get().id;
|
|
}
|
|
|
|
const idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
|
|
const idVan = anlegen("VanVan", "admin", "CODE-VAN-0001");
|
|
const idSpicy = anlegen("Cigdem", "spicy", "CODE-SPIC-0001");
|
|
const idMan = anlegen("Schulle", "manager", "CODE-MAN-0001");
|
|
const idScout = anlegen("Patrick", "scout", "CODE-SCOU-0001");
|
|
const idCreat = anlegen("Tili", "creator", "CODE-ANNA-0001");
|
|
const idModi1 = anlegen("Marina", "modi", "CODE-MODI-0001");
|
|
const idModi2 = anlegen("Kim", "modi", "CODE-MODI-0002");
|
|
/* DIE STELLVERTRETUNG GEHOERT IN DIESELBE PRUEFUNG (10.09.2026).
|
|
|
|
Sie ist seit heute die zweite verborgene Rolle. Ohne diese Zeile
|
|
waere der ganze Lauf weiter gruen gewesen -- und haette die neue
|
|
Rolle kein einziges Mal angesehen. Genau die Sorte gruener Haken,
|
|
vor der die Hausregeln warnen: Er bestaetigt etwas, das er nicht
|
|
geprueft hat.
|
|
|
|
Sie wird bewusst in dieselben Listen aufgenommen wie die Modis, statt
|
|
danebenzustehen: Was fuer einen Modi gilt, gilt fuer sie -- und wenn
|
|
morgen jemand einen Weg hinzufuegt, deckt er beide ab, ohne dass es
|
|
ihm jemand sagen muss. */
|
|
const idHand = anlegen("Rieke", "hand", "CODE-HAND-0001");
|
|
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)")
|
|
.run(idCreat, idScout, jetzt);
|
|
d.prepare("INSERT INTO scout_zuteilung (scout_id, manager_id, seit) VALUES (?,?,?)")
|
|
.run(idScout, idMan, jetzt);
|
|
d.close();
|
|
|
|
const MODIS = [idModi1, idModi2, idHand];
|
|
void idSpicy;
|
|
|
|
/* ---------- Anmelden ueber die Schnittstelle -------------------------
|
|
|
|
MIT WAND, SEIT DEM 01.10.2026. Vorher ging jede Anmeldung hier ueber
|
|
`fetch` auf 127.0.0.1 -- eine Adresse OHNE Wand. Gemessen wurde
|
|
damit der stille Zugang und nicht die Kachelregel; seit er weg ist,
|
|
waere das die Messung der falschen Sache.
|
|
|
|
WARUM node:http UND NICHT fetch: `fetch` (undici) setzt den
|
|
Host-Kopf selbst aus der Adresse und ignoriert einen mitgegebenen.
|
|
Nachgemessen, nicht vermutet -- dieselbe Stelle steht seit dem
|
|
22.09. in pruef-chat-kanaele. */
|
|
const { request: httpAnfrage } = await import("node:http");
|
|
const CREW_WAND = "crew.dogfather-universe.com";
|
|
const AGENTUR_WAND = "workspace.dogfather-universe.com";
|
|
|
|
/** Auf welcher Wand steht die Kachel dieser Rolle?
|
|
*
|
|
* ABGELEITET STATT AUFGEZAEHLT (01.10.2026). Nach dem Umbau meldeten
|
|
* sich acht Stellen ueber eine fremde Kachel an -- ein Manager auf
|
|
* der Crew-Wand etwa, wo es seine Kachel gar nicht gibt. Eine Liste
|
|
* von Hand waere die, bei der man zwei Stellen vergisst.
|
|
*
|
|
* Wer eine Wand AUSDRUECKLICH nennt, bekommt sie: Das brauchen die
|
|
* Zeilen, die absichtlich die falsche Wand pruefen. */
|
|
const CREW_ROLLEN = new Set(["admin", "hand", "linke", "modi", "gast"]);
|
|
const wandFuer = (rolle) => (CREW_ROLLEN.has(rolle) ? CREW_WAND : AGENTUR_WAND);
|
|
|
|
function anmelden(rolle, code, wand = wandFuer(rolle)) {
|
|
return new Promise((fertig) => {
|
|
const rumpf = JSON.stringify({ rolle, code });
|
|
const a = httpAnfrage({
|
|
host: "127.0.0.1", port: PORT, path: "/workspace/api/anmelden", method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
"Content-Length": Buffer.byteLength(rumpf),
|
|
Host: wand,
|
|
},
|
|
}, (antwort) => {
|
|
const teile = [];
|
|
antwort.on("data", (t) => teile.push(t));
|
|
antwort.on("end", () => {
|
|
let daten = {};
|
|
try { daten = JSON.parse(Buffer.concat(teile).toString("utf8")); } catch { /* kein JSON */ }
|
|
fertig({
|
|
status: antwort.statusCode,
|
|
daten,
|
|
keks: [].concat(antwort.headers["set-cookie"] || [])
|
|
.map((z) => z.split(";")[0]).join("; "),
|
|
});
|
|
});
|
|
});
|
|
a.on("error", () => fertig({ status: 0, daten: {}, keks: "" }));
|
|
a.end(rumpf);
|
|
});
|
|
}
|
|
|
|
/* =====================================================================
|
|
1. DIE KACHEL IST BINDEND (01.10.2026)
|
|
|
|
Filipe: „mach das. es soll fest sein."
|
|
|
|
VanVan hatte gemeldet: „Man kann sich mit seinem Zugangscode immer
|
|
noch über jeden Button der Startseite anmelden, egal welche Rolle
|
|
man hat."
|
|
|
|
BIS HEUTE STAND HIER DAS GEGENTEIL, und das war richtig: Vom
|
|
09.09.2026 an hatten die Modis KEINE eigene Kachel -- wer keine
|
|
hat, muss irgendeine nehmen koennen.
|
|
|
|
Seit der Haustrennung am 24.09. hat `crew.` einen eigenen
|
|
Kachelsatz mit allen fuenf Rollen. Das Verbergen leistet die
|
|
ADRESSE; der Trick mit der beliebigen Kachel war ein Rest.
|
|
===================================================================== */
|
|
console.log("\n=== 1. Der Eingang: die Kachel gilt ===\n");
|
|
|
|
{
|
|
const a = await anmelden("modi", "CODE-MODI-0001");
|
|
ok(a.status === 200 && a.daten?.rolle === "modi",
|
|
`auf der Modi-Kachel kommt ein Modi herein (${a.daten?.rolle || a.status})`);
|
|
}
|
|
|
|
/* UND AUF KEINER ANDEREN. Das ist die Aenderung. */
|
|
for (const kachel of ["admin", "hand", "linke", "gast"]) {
|
|
const a = await anmelden(kachel, "CODE-MODI-0001");
|
|
ok(a.status === 401,
|
|
`Kachel "${kachel}" + Modi-Code -> abgewiesen (${a.status})`);
|
|
}
|
|
|
|
/* GEGENPROBE: Die anderen Rollen der Crew-Wand kommen auf IHRER
|
|
Kachel herein. Ohne sie hiesse „401 ueberall" womoeglich nur, dass
|
|
dort gar niemand mehr hereinkommt. */
|
|
{
|
|
const h = await anmelden("hand", "CODE-HAND-0001");
|
|
ok(h.status === 200 && h.daten?.rolle === "hand",
|
|
`die rechte Hand auf ihrer Kachel (${h.daten?.rolle || h.status})`);
|
|
}
|
|
|
|
/* UND DIE AGENTURWAND BLEIBT, WIE SIE WAR. Dort war der stille Weg
|
|
nie aktiv; ein Modi-Code verhaelt sich weiter wie ein erfundener. */
|
|
{
|
|
const a = await anmelden("creator", "CODE-MODI-0001", AGENTUR_WAND);
|
|
const b = await anmelden("creator", "GIBT-ES-NICHT-1", AGENTUR_WAND);
|
|
ok(a.status === 401 && b.status === 401
|
|
&& JSON.stringify(a.daten) === JSON.stringify(b.daten),
|
|
`auf der Agenturwand klingt ein Modi-Code wie ein erfundener `
|
|
+ `(${a.status} vs. ${b.status})`);
|
|
}
|
|
|
|
/* Und die Rollenpruefung der Agentur ist unveraendert: Ein Manager
|
|
mit der Kachel "creator" scheitert weiterhin. */
|
|
{
|
|
const a = await anmelden("creator", "CODE-MAN-0001", AGENTUR_WAND);
|
|
ok(a.status === 401, `Manager-Code auf der Creator-Kachel bleibt abgewiesen (${a.status})`);
|
|
}
|
|
|
|
/* Wortgleichheit: "modi" von aussen anzugeben darf nicht anders klingen
|
|
als eine erfundene Rolle. */
|
|
{
|
|
/* AUF DER AGENTURWAND klingt „modi" wie eine erfundene Rolle --
|
|
dort gibt es die Kachel nicht. Auf crew. gibt es sie, und dort
|
|
entscheidet der Code; deshalb wird das hier ausdruecklich an der
|
|
Agenturwand gefragt. */
|
|
const m = await anmelden("modi", "FALSCH-FALSCH-1", AGENTUR_WAND);
|
|
const x = await anmelden("gibtesnicht", "FALSCH-FALSCH-1", AGENTUR_WAND);
|
|
ok(m.status === 401 && x.status === 401
|
|
&& JSON.stringify(m.daten) === JSON.stringify(x.daten),
|
|
"Rolle \"modi\" von aussen klingt wie eine erfundene "
|
|
+ `(${m.status} ${JSON.stringify(m.daten)} vs. ${x.status} ${JSON.stringify(x.daten)})`);
|
|
}
|
|
|
|
{
|
|
const a = await anmelden("modi", "CODE-MODI-FALSCH");
|
|
ok(a.status === 401, `ein falscher Modi-Code wird abgewiesen (${a.status})`);
|
|
}
|
|
|
|
/* ---------- 2. Die Unsichtbarkeit ------------------------------------ */
|
|
console.log("\n=== 2. Wer sieht die Modis? ===\n");
|
|
|
|
/* Jede Schnittstelle, die Personen ausgibt. Dieselbe Landkarte wie in
|
|
pruef-verborgen.mjs -- wer eine neue baut, traegt sie in BEIDE ein. */
|
|
const WEGE = [
|
|
["Chat-Partner", "/workspace/api/chat/partner", (x) => x.personen],
|
|
["Personenwahl", "/workspace/api/personen", (x) => x.personen],
|
|
["Personenverwaltung", "/workspace/api/verwaltung/personen", (x) => x.personen],
|
|
["Betreuer-Auswahl", "/workspace/api/verwaltung/personen", (x) => x.betreuer],
|
|
/* NACHGESEHEN, NICHT ANGENOMMEN: Die Segmente der Zentrale tragen
|
|
KEINE Nummer -- nur `{ name, rolle, stufe, heute, alt }`, und der
|
|
Name ist auf den Vornamen gekuerzt. Wer hier nur nach `id` sucht,
|
|
bekommt einen gruenen Haken, ohne etwas angesehen zu haben. Genau
|
|
deshalb vergleicht der Treffer unten BEIDES. */
|
|
["Zentrale (Team)", "/workspace/api/zentrale", (x) => x.segmente],
|
|
];
|
|
|
|
/* Die Namen der Modis -- fuer die Wege, die keine Nummern liefern. */
|
|
const MODI_NAMEN = ["Marina", "Kim", "Rieke"];
|
|
|
|
const LEUTE = [
|
|
["DogFather", "admin", "CODE-DOGI-0001", true],
|
|
["VanVan", "admin", "CODE-VAN-0001", true],
|
|
["Spicy Media", "spicy", "CODE-SPIC-0001", false],
|
|
["Manager", "manager", "CODE-MAN-0001", false],
|
|
["Scout", "scout", "CODE-SCOU-0001", false],
|
|
["Creator", "creator", "CODE-ANNA-0001", false],
|
|
/* AUF IHRER EIGENEN KACHEL (01.10.2026). Hier stand „creator" --
|
|
der stille Zugang liess damals jede Kachel durch. Seit die Kachel
|
|
bindend ist, scheiterte ihre Anmeldung STILL: `unklar(...)` und
|
|
weiter, und acht Sichtbarkeitspruefungen fielen lautlos weg.
|
|
|
|
Genau der Rueckgang, vor dem die Hausregel warnt -- gruen bei
|
|
weniger Pruefungen. Gefunden hat ihn nicht der Lauf, sondern der
|
|
Vergleich der Anzahl mit dem Lauf davor. */
|
|
["Modi Marina", "modi", "CODE-MODI-0001", true],
|
|
["Rechte Hand", "hand", "CODE-HAND-0001", true],
|
|
];
|
|
|
|
async function hole(keks, pfad) {
|
|
const a = await fetch(BASIS + pfad, { headers: { cookie: keks } });
|
|
if (!a.ok) return { status: a.status, daten: null };
|
|
return { status: 200, daten: await a.json().catch(() => null) };
|
|
}
|
|
|
|
for (const [name, kachel, code, darf] of LEUTE) {
|
|
const an = await anmelden(kachel, code);
|
|
if (an.status !== 200) { unklar(`${name}: Anmeldung misslang (${an.status})`); continue; }
|
|
for (const [was, pfad, ziehen] of WEGE) {
|
|
const { status, daten } = await hole(an.keks, pfad);
|
|
if (status !== 200) {
|
|
unklar(`${name.padEnd(12)} ${was.padEnd(20)} kein Zugriff (${status})`);
|
|
continue;
|
|
}
|
|
let liste = [];
|
|
try { liste = ziehen(daten) || []; } catch { liste = []; }
|
|
const drin = liste.filter((z) => z
|
|
&& (MODIS.includes(z.id ?? z.person_id)
|
|
|| MODI_NAMEN.includes(String(z.name || "").trim().split(/\s+/)[0])));
|
|
if (darf) {
|
|
ok(true, `${name.padEnd(12)} ${was.padEnd(20)} sieht ${drin.length} Modi(s)`);
|
|
} else {
|
|
ok(drin.length === 0,
|
|
`${name.padEnd(12)} ${was.padEnd(20)} `
|
|
+ (drin.length ? `SIEHT ${drin.length} MODI -- FEHLER` : "sieht keinen Modi"));
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ---------- 3. Die Zahl daneben -------------------------------------- */
|
|
console.log("\n=== 3. Auch die ZAHL darf sie nicht mitzaehlen ===\n");
|
|
{
|
|
const an = await anmelden("manager", "CODE-MAN-0001");
|
|
const { status, daten } = await hole(an.keks, "/workspace/api/personen");
|
|
if (status !== 200 || !Array.isArray(daten?.personen)) {
|
|
unklar(`Personenwahl fuer den Manager nicht lesbar (${status})`);
|
|
} else {
|
|
const namen = daten.personen.map((z) => z.name);
|
|
/* Die Zahl der geprueften Dinge gehoert in die BEDINGUNG, nicht nur
|
|
in den Meldetext: Eine leere Liste wuerde sonst als "keine Modis
|
|
drin" durchgehen, und die Pruefung waere wertlos. */
|
|
ok(namen.length > 0 && !namen.includes("Marina") && !namen.includes("Kim"),
|
|
`der Manager sieht ${namen.length} Personen, keine davon ein Modi `
|
|
+ `(${namen.join(", ")})`);
|
|
}
|
|
}
|
|
|
|
/* ---------- 4. Sehen die Modis einander? ----------------------------- */
|
|
console.log("\n=== 4. Die Modis sind untereinander ein Team ===\n");
|
|
{
|
|
const an = await anmelden("modi", "CODE-MODI-0001");
|
|
const { status, daten } = await hole(an.keks, "/workspace/api/personen");
|
|
if (status !== 200 || !Array.isArray(daten?.personen)) {
|
|
unklar(`Personenwahl fuer den Modi nicht lesbar (${status})`);
|
|
} else {
|
|
const ids = daten.personen.map((z) => z.id);
|
|
ok(ids.includes(idModi2), "Marina sieht Kim");
|
|
ok(ids.includes(idDogi), "Marina sieht DogFather");
|
|
/* VanVan bleibt fuer alle ausser DogFather verborgen -- das ist die
|
|
Regel vom 09.09.2026, und sie gilt auch gegenueber Modis. */
|
|
ok(!ids.includes(idVan), "Marina sieht VanVan NICHT (verborgener Zugang)");
|
|
ok(!ids.includes(idMan) && !ids.includes(idScout) && !ids.includes(idCreat),
|
|
"Marina sieht weder Manager noch Scout noch Creator");
|
|
}
|
|
}
|
|
|
|
/* ---------- 5. Der echte Weg durch die Anwendung --------------------- */
|
|
console.log("\n=== 5. Anlegen wie im Betrieb: DogFather legt einen Modi an ===\n");
|
|
{
|
|
const an = await anmelden("admin", "CODE-DOGI-0001");
|
|
const kopf = { "Content-Type": "application/json", cookie: an.keks };
|
|
|
|
/* a) Steht die Rolle ueberhaupt zur Auswahl -- und kommt sie vom
|
|
Server, nicht aus einer Datei im Browser? */
|
|
const { status, daten } = await hole(an.keks, "/workspace/api/verwaltung/personen");
|
|
if (status !== 200) {
|
|
unklar(`Verwaltung fuer DogFather nicht lesbar (${status})`);
|
|
} else {
|
|
const zusatz = daten?.zusatzrollen || [];
|
|
ok(zusatz.some((z) => z.wert === "modi"),
|
|
"DogFather bekommt die Rolle zur Auswahl angeboten "
|
|
+ `(${zusatz.map((z) => z.wert).join(", ") || "keine"})`);
|
|
}
|
|
|
|
/* b) Anlegen -- ueber genau den Weg, den die Oberflaeche benutzt. */
|
|
const a = await fetch(BASIS + "/workspace/api/verwaltung/personen", {
|
|
method: "POST", headers: kopf,
|
|
body: JSON.stringify({ name: "Testmodi Neu", rolle: "modi" }),
|
|
});
|
|
const neuDaten = await a.json().catch(() => ({}));
|
|
ok(a.status === 201 && neuDaten?.rolle === "modi" && typeof neuDaten?.code === "string",
|
|
`angelegt (${a.status}, Rolle ${neuDaten?.rolle}, `
|
|
+ `Code ${neuDaten?.code ? "erhalten" : "FEHLT"})`);
|
|
|
|
/* c) DER EIGENTLICHE PUNKT: Kommt der so angelegte Modi auch herein?
|
|
|
|
Die Abschnitte oben haben die Personen VON HAND eingetragen und
|
|
den Suchschluessel selbst ausgerechnet. Damit ist nicht bewiesen,
|
|
dass personAnlegen() ihn im Betrieb auch wirklich schreibt -- und
|
|
ohne ihn findet der stille Zugang niemanden. Waere die Zeile dort
|
|
vergessen worden, waeren oben trotzdem alle Haken gruen und kein
|
|
einziger echter Modi kaeme herein. */
|
|
if (neuDaten?.code) {
|
|
/* AUF DER MODI-KACHEL, seit dem 01.10.2026 -- vorher ging jede. */
|
|
const b = await anmelden("modi", neuDaten.code);
|
|
ok(b.status === 200 && b.daten?.rolle === "modi",
|
|
"und meldet sich mit seinem Code an, ueber eine fremde Kachel "
|
|
+ `(${b.status}, ${b.daten?.rolle})`);
|
|
} else {
|
|
unklar("ohne Code laesst sich die Anmeldung nicht pruefen");
|
|
}
|
|
|
|
/* d) Und ist auch der Neue fuer den Manager unsichtbar? */
|
|
const m = await anmelden("manager", "CODE-MAN-0001");
|
|
const sicht = await hole(m.keks, "/workspace/api/personen");
|
|
if (sicht.status !== 200 || !Array.isArray(sicht.daten?.personen)) {
|
|
unklar(`Personenwahl fuer den Manager nicht lesbar (${sicht.status})`);
|
|
} else {
|
|
const namen = sicht.daten.personen.map((z) => z.name);
|
|
ok(namen.length > 0 && !namen.includes("Testmodi Neu"),
|
|
`der Manager sieht ihn nicht (${namen.length} Personen: ${namen.join(", ")})`);
|
|
}
|
|
}
|
|
/* ---------- 6. Die Startseite eines Modis ---------------------------- */
|
|
console.log("\n=== 6. Was ein Modi auf seiner Startseite sieht ===\n");
|
|
{
|
|
/* AUF SEINER EIGENEN KACHEL, seit dem 01.10.2026. Hier stand
|
|
„creator" -- damals gab es fuer einen Modi keine eigene, und der
|
|
stille Zugang liess jede durch. Jetzt gilt die Kachel. */
|
|
const an = await anmelden("modi", "CODE-MODI-0001");
|
|
const { status, daten } = await hole(an.keks, "/workspace/api/ich");
|
|
if (status !== 200) {
|
|
unklar(`/api/ich nicht lesbar (${status})`);
|
|
} else {
|
|
const b = daten?.bereiche;
|
|
ok(Array.isArray(b) && b.length > 0,
|
|
`der Server schickt ihm ${Array.isArray(b) ? b.length : "keine"} Kacheln`);
|
|
/* Nichts aus der Agentur. Nicht "moeglichst wenig", sondern keine
|
|
einzige -- diese Seiten drehen sich um betreute Creator, um
|
|
Rechte oder um Automationen. */
|
|
/* `calls.html` STAND HIER UND IST AM 25.09.2026 HERAUSGENOMMEN.
|
|
|
|
Nicht, weil die Pruefung zu streng war, sondern weil sich die
|
|
Sache geaendert hat: Filipe hat die Calls-Kachel ausdruecklich
|
|
fuer alle verlangt, die einen Kalender haben („jeder der einen
|
|
kalender hat soll auch sowas haben danke"), und ein Modi hat
|
|
einen. Seither war diese Zeile rot, ohne dass etwas kaputt war
|
|
-- und eine Warnung, die immer kommt, wird ueberlesen.
|
|
|
|
DIE LISTE BLEIBT EINE LISTE VON HAND, und das ist ihre Schwaeche:
|
|
Sie altert genau so wie diese Zeile gealtert ist. Deshalb steht
|
|
darunter eine Gegenprobe -- ohne sie waere „nichts Verbotenes
|
|
dabei" auch dann gruen, wenn die Pruefung gar nichts mehr
|
|
prueft. */
|
|
const verboten = ["personen.html", "scouting.html", "automation.html",
|
|
"report.html", "uebersicht.html", "content.html"];
|
|
const ziele = (b || []).map((x) => x.ziel);
|
|
const drin = ziele.filter((z) => verboten.includes(z));
|
|
ok(Array.isArray(b) && verboten.length >= 6 && drin.length === 0,
|
|
drin.length ? `ABER AUCH: ${drin.join(", ")} -- FEHLER`
|
|
: `und nichts aus der Agentur (${verboten.length} Seiten geprueft)`);
|
|
/* GEGENPROBE: Haette er eine davon, MUSS die Zeile darueber
|
|
anschlagen. Gepruft wird an einer erfundenen Liste, nicht an
|
|
echten Daten -- es wird nichts angelegt und nichts veraendert. */
|
|
const alsHaette = [...ziele, "scouting.html"].filter((z) => verboten.includes(z));
|
|
ok(alsHaette.length === 1,
|
|
`und sie wuerde es merken, wenn doch (Probe: ${alsHaette.join(", ") || "merkt nichts"})`);
|
|
/* Die Beschriftung gehoert zum Empfaenger: "Alle Creator auf einen
|
|
Blick" waere fuer jemanden ohne Creator schlicht falsch. */
|
|
ok((b || []).every((x) => x.name && x.unter && x.zeichen && x.ziel),
|
|
"jede Kachel hat Beschriftung, Zeichen und Ziel");
|
|
}
|
|
|
|
/* GEGENPROBE ZUR QUELLE: Fuer eine bekannte Rolle muss `null`
|
|
herauskommen -- nicht eine leere Liste. Die Oberflaeche
|
|
unterscheidet die beiden, und verwechselte man sie, haetten alle
|
|
anderen ab sofort eine leere Startseite. */
|
|
const m = await anmelden("manager", "CODE-MAN-0001");
|
|
const mi = await hole(m.keks, "/workspace/api/ich");
|
|
ok(mi.status === 200 && mi.daten?.bereiche === null,
|
|
`beim Manager steht dort null, nicht [] (${JSON.stringify(mi.daten?.bereiche)})`);
|
|
}
|
|
|
|
/* ---------- 7. Und im echten Browser? -------------------------------- */
|
|
console.log("\n=== 7. Dieselbe Seite mit einem 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 {
|
|
/* MIT FINGER. Ohne `hasTouch` meldet der Browser einen feinen
|
|
Zeiger, und keine Regel aus `@media (pointer: coarse)` greift --
|
|
dort stehen die 44-Pixel-Beruehrziele. Siehe pruef-fingermass.mjs. */
|
|
const kontext = await browser.newContext({ viewport: { width: 390, height: 844 },
|
|
hasTouch: true, isMobile: true });
|
|
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));
|
|
|
|
/* ==== ANGEMELDET WIRD UEBER DIE WAND, NICHT UEBER DIE SEITE
|
|
(01.10.2026)
|
|
|
|
Hier wurde bis heute im Browser auf die Creator-Kachel getippt
|
|
und der Modi-Code eingegeben -- das ging, solange der stille
|
|
Zugang jede Kachel durchliess.
|
|
|
|
Seit die Kachel bindend ist, braeuchte der Browser die
|
|
CREW-Wand: Dort steht die Modi-Kachel. Ein Browser auf
|
|
127.0.0.1 bekommt aber die Agenturwand, und ein Host-Kopf
|
|
laesst sich dort nur mit einer Namensumleitung setzen (so macht
|
|
es mess-reaktion mit `--host-resolver-rules`).
|
|
|
|
Der kuerzere und ehrlichere Weg: an der richtigen Wand
|
|
anmelden und den Keks mitgeben. Gemessen werden soll, was ein
|
|
Modi auf seiner STARTSEITE sieht -- nicht, wie er hereinkommt.
|
|
Das steht in Abschnitt 1, und dort wird es an der echten Wand
|
|
gemessen. */
|
|
const modiKeks = (await anmelden("modi", "CODE-MODI-0001")).keks;
|
|
await kontext.addCookies(modiKeks.split("; ").filter(Boolean).map((z) => {
|
|
const [n, ...r] = z.split("=");
|
|
return { name: n, value: r.join("="), domain: "127.0.0.1", path: "/" };
|
|
}));
|
|
await seite.goto(BASIS + "/workspace/start.html", { waitUntil: "domcontentloaded" });
|
|
/* KEIN `waitForURL` MEHR. Es wartete auf eine Navigation, die es
|
|
seit dem 01.10.2026 nicht mehr gibt -- angemeldet wird ueber
|
|
die Wand, nicht ueber das Formular. Steht die Seite schon da,
|
|
wartet es trotzdem und laeuft in die Frist.
|
|
|
|
Und wenn der Keks NICHT angenommen wurde, sagt die Zeile
|
|
darunter genau das, statt fuenfzehn Sekunden zu schweigen. */
|
|
if (!/start\.html/.test(seite.url())) {
|
|
unklar(`nach dem Anmelden steht die Seite auf ${seite.url()}`);
|
|
}
|
|
await seite.waitForTimeout(1200);
|
|
|
|
const bild = await seite.evaluate(() => ({
|
|
kacheln: [...document.querySelectorAll(".gruppe a[href]")].map((a) => a.getAttribute("href")),
|
|
gruppen: [...document.querySelectorAll(".gruppe__kopf")].map((k) => k.textContent.trim().slice(0, 40)),
|
|
rolle: (document.getElementById("zgruss-rolle") || {}).textContent || "",
|
|
rollentext: (document.getElementById("rollentext") || {}).textContent || "",
|
|
marke: (document.querySelector(".zmarke") || {}).textContent || "",
|
|
rauten: document.querySelectorAll(".zmarke .zraute").length,
|
|
}));
|
|
|
|
/* Die ZAHL gehoert in die Bedingung, nicht nur in den Text: Eine
|
|
leere Seite wuerde sonst als "nichts Verbotenes dabei" durchgehen. */
|
|
ok(bild.kacheln.length >= 8,
|
|
`${bild.kacheln.length} Kacheln stehen wirklich auf der Seite (${bild.gruppen.join(" | ")})`);
|
|
ok(bild.kacheln.some((h) => h.startsWith("aufgaben.html")),
|
|
"darunter das Aufgabenbrett -- das Herzstueck aus Kapitel 6");
|
|
ok(!bild.kacheln.some((h) => /personen|scouting|automation|report/.test(h)),
|
|
"und nichts aus der Agentur");
|
|
/* Der Anzeigename kommt aus /api/ich, nicht aus einer Datei im
|
|
Browser -- sonst stuende das Wort in einer Datei, die jeder
|
|
bekommt. Dass er hier steht, ist der Nachweis, dass der Weg geht. */
|
|
ok(bild.rolle.trim() === "MODI",
|
|
`die Plakette sagt "${bild.rolle.trim()}" (kommt vom Server)`);
|
|
/* EIN SATZ, KEIN WORT. Die fuenf bekannten Rollen bekommen unter
|
|
der Begruessung eine Erklaerung ("Creator · dein eigener
|
|
Bereich"). Stuende dort nur "Modi", saehe die Seite nicht
|
|
verborgen aus, sondern unfertig -- und genau das stand da, bis
|
|
diese Pruefung es gemeldet hat. */
|
|
ok(bild.rollentext.includes("·") && bild.rollentext.trim().length > 12,
|
|
`und die Zeile darunter ist ein ganzer Satz ("${bild.rollentext.trim()}")`);
|
|
/* DIE MARKE UEBER DEM TITEL. Ein Modi gehoert nicht zur Agentur --
|
|
stand dort "Spicy Media", war die Seite fuer ihn schlicht falsch
|
|
beschriftet. Gefunden auf dem Bildschirmfoto, nicht im Code. */
|
|
ok(bild.marke.includes("Team Dogi") && !bild.marke.includes("Spicy"),
|
|
`die Zierzeile nennt seinen Betrieb ("${bild.marke.trim()}")`);
|
|
/* Und die beiden Zierrauten sind noch da: Sie beim Austausch des
|
|
Textes zu verlieren waere lautlos passiert. */
|
|
ok(bild.rauten === 2, `die beiden Zierrauten stehen noch (${bild.rauten})`);
|
|
ok(konsole.length === 0,
|
|
konsole.length ? `Fehler in der Konsole: ${konsole[0]}` : "keine Fehler in der Konsole");
|
|
|
|
await seite.screenshot({ path: "pruef-modi-start.png", fullPage: true });
|
|
console.log(" -- Bildschirmfoto: server/pruef-modi-start.png");
|
|
|
|
/* ==== DER CREATOR-KATALOG GEHOERT IHM NICHT (25.09.2026) ========
|
|
|
|
Filipe, zu einem Bildschirmfoto der Aufgabenseite: „es gibt
|
|
keine creator auf dieser seite. die app ist nur fuer modis und
|
|
community also steht das falsch da."
|
|
|
|
Dort stand ein Katalog mit vier Bereichen und vier Stufen -- der
|
|
fuer CREATOR -- und darunter „Waehle oben einen Creator, dann
|
|
lassen sich diese Aufgaben uebernehmen". Auf dieser Adresse gibt
|
|
es keine; der Satz forderte zu etwas auf, das nie geht.
|
|
|
|
GEPRUEFT WIRD DER KASTEN UND DER SATZ, nicht nur einer von
|
|
beiden: Verschwindet der Satz und der leere Kasten bleibt, ist
|
|
es dieselbe Sackgasse in leise. */
|
|
await seite.goto(BASIS + "/workspace/aufgaben.html", { waitUntil: "networkidle" });
|
|
await seite.waitForTimeout(1200);
|
|
const katalog = await seite.evaluate(() => {
|
|
const kasten = document.getElementById("vorlagenbrett");
|
|
return {
|
|
daUeberhaupt: !!kasten,
|
|
sichtbar: !!(kasten && !kasten.hidden && kasten.offsetHeight > 0),
|
|
text: (document.body.textContent || "").includes("Wähle oben einen Creator"),
|
|
/* GEGENPROBE IM SELBEN ZUG: Sein EIGENES Aufgabenbrett muss da
|
|
sein. Waere die ganze Seite leer, meldeten die zwei Zeilen
|
|
darueber brav "nichts Fremdes zu sehen". */
|
|
eigenes: !!document.querySelector("#brett, .spalten, .aufgabe, #aufgaben"),
|
|
};
|
|
});
|
|
ok(katalog.daUeberhaupt,
|
|
"der Kasten fuer den Katalog steht im Bauplan der Seite (Gegenprobe)");
|
|
ok(!katalog.sichtbar,
|
|
`der Creator-Katalog wird ihm NICHT gezeigt (sichtbar: ${katalog.sichtbar})`);
|
|
ok(!katalog.text,
|
|
"und der Satz „Waehle oben einen Creator“ steht nirgends");
|
|
ok(katalog.eigenes,
|
|
"sein eigenes Aufgabenbrett ist trotzdem da (Gegenprobe)");
|
|
|
|
await kontext.close();
|
|
} finally {
|
|
await browser.close();
|
|
}
|
|
}
|
|
/* ---------- 8. Was einem Modi GEHOERT, sieht sonst niemand ----------- */
|
|
console.log("\n=== 8. Aufgaben, Einträge und Dateien eines Modis ===\n");
|
|
{
|
|
/* DREI TABELLEN, DREI EIGENE SICHTBARKEITSREGELN. Fuer Personen ist
|
|
die Regel zentral (verborgeneIds); fuer ZEILEN gibt es sie dreimal
|
|
-- in workspace-aufgaben.js, workspace-bereiche.js und
|
|
workspace-dateien.js. Alle drei geben Spicy Media "alles ausser dem,
|
|
was DogFather gehoert" -- und ein Modi-Eintrag gehoert ihm nicht.
|
|
|
|
Der Kalender ist bewusst nicht dabei: termineSichtbar() gibt jedem
|
|
nur Eigenes, dort kann nichts durchsickern. Nachgesehen, nicht
|
|
angenommen. */
|
|
const an = await anmelden("modi", "CODE-MODI-0001");
|
|
const MERKMAL = "GEHEIMER MODI-EINTRAG";
|
|
|
|
/* (a) Eine Aufgabe -- ueber den normalen Weg. */
|
|
const t1 = await fetch(BASIS + "/workspace/api/aufgaben", {
|
|
method: "POST", headers: { "Content-Type": "application/json", cookie: an.keks },
|
|
body: JSON.stringify({ titel: MERKMAL + " Aufgabe" }),
|
|
});
|
|
/* ==== UMGEDREHT -- UND STRENGER (25.09.2026) ====================
|
|
|
|
Hier stand `status === 201`: „der Modi legt eine Aufgabe an". Das
|
|
war bis zum 22.09.2026 richtig. An dem Tag hat Filipe es
|
|
abgeschafft: „sie sich nicht selber aufgaben geben" und „die modis
|
|
sollen nur diese aufgaben wo sie von den drauf markiert werden
|
|
annehmen koennen". Seither antwortet der Server mit 403 -- und
|
|
diese Zeile war seitdem rot, ohne dass etwas kaputt war.
|
|
|
|
SIE PRUEFT JETZT MEHR ALS VORHER, nicht weniger: nicht nur die
|
|
Nummer, sondern auch das WORT. Eine 403 aus einem anderen Grund
|
|
(etwa weil die Anmeldung kaputt ist) saehe sonst genauso aus wie
|
|
die gewollte Absage -- und die Pruefung waere gruen ueber einem
|
|
ganz anderen Fehler.
|
|
|
|
WARUM DAS WORT ZAEHLT: `nur_leitung_legt_an` hat in meldung.js
|
|
einen ganzen Satz („Aufgaben werden dir zugeteilt -- anlegen
|
|
kannst du hier keine"). Eine nackte 403 haette ihn nicht. */
|
|
const t1Fehler = (await t1.json().catch(() => ({})))?.fehler;
|
|
ok(t1.status === 403 && t1Fehler === "nur_leitung_legt_an",
|
|
`der Modi legt KEINE Aufgabe an -- mit Begruendung (${t1.status} ${t1Fehler || "ohne Wort"})`);
|
|
|
|
/* (b) Ein Bereichs-Eintrag -- ebenfalls ueber den normalen Weg. */
|
|
const t2 = await fetch(BASIS + "/workspace/api/bereich/live", {
|
|
method: "POST", headers: { "Content-Type": "application/json", cookie: an.keks },
|
|
body: JSON.stringify({ art: "vorbereitung", titel: MERKMAL + " Eintrag", text: "nur für das Team" }),
|
|
});
|
|
const t2daten = await t2.json().catch(() => ({}));
|
|
if (t2.status !== 201 && t2.status !== 200) {
|
|
unklar(`kein Bereichs-Eintrag moeglich (${t2.status}: ${JSON.stringify(t2daten)})`);
|
|
} else {
|
|
ok(true, `und einen Bereichs-Eintrag (${t2.status})`);
|
|
}
|
|
|
|
/* (c) Eine Datei -- direkt in die Tabelle. Der normale Weg braeuchte
|
|
einen echten Datei-Upload; hier geht es nicht um das Hochladen,
|
|
sondern allein um die Frage, WER die Zeile danach sieht. */
|
|
{
|
|
const dd = new DatabaseSync(process.env.WORKSPACE_DB);
|
|
dd.prepare(`INSERT INTO dateien
|
|
(name_original, name_datei, groesse, typ, status, creator_id, hochgeladen_von, erstellt)
|
|
VALUES (?,?,?,?,'entwurf',NULL,?,?)`)
|
|
.run(MERKMAL + " Datei", "modi-probe.txt", 12, "text/plain", idModi1, jetzt);
|
|
dd.close();
|
|
ok(true, "und eine Datei liegt auf seinen Namen");
|
|
}
|
|
|
|
const WEGE2 = [
|
|
["Aufgaben", "/workspace/api/aufgaben", (x) => x.aufgaben],
|
|
["Einträge", "/workspace/api/bereich/live", (x) => x.eintraege || x.liste],
|
|
["Dateien", "/workspace/api/dateien", (x) => x.dateien],
|
|
];
|
|
for (const [name, kachel, code, darf] of [
|
|
["DogFather", "admin", "CODE-DOGI-0001", true],
|
|
["Spicy Media", "spicy", "CODE-SPIC-0001", false],
|
|
["Manager", "manager", "CODE-MAN-0001", false],
|
|
["Scout", "scout", "CODE-SCOU-0001", false],
|
|
["Creator", "creator", "CODE-ANNA-0001", false],
|
|
]) {
|
|
const w = await anmelden(kachel, code);
|
|
for (const [was, pfad, ziehen] of WEGE2) {
|
|
const r = await hole(w.keks, pfad);
|
|
if (r.status !== 200) { unklar(`${name.padEnd(12)} ${was.padEnd(9)} kein Zugriff (${r.status})`); continue; }
|
|
let liste = [];
|
|
try { liste = ziehen(r.daten) || []; } catch { liste = []; }
|
|
const drin = liste.some((z) =>
|
|
String(z.titel || z.name_original || z.name || "").includes(MERKMAL));
|
|
if (darf) ok(true, `${name.padEnd(12)} ${was.padEnd(9)} sieht es (${drin ? "ja" : "nein"})`);
|
|
else ok(!drin, `${name.padEnd(12)} ${was.padEnd(9)} `
|
|
+ (drin ? "SIEHT ES -- LECK" : "sieht es nicht"));
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ---------- 8b. Was nach zwei Fehlversuchen dasteht -------------------
|
|
=====================================================================
|
|
|
|
VanVan im Support, Meldung #5, zweite Runde: „Man kann sich jetzt
|
|
nur noch über die richtige Schaltfläche anmelden. Das funktioniert
|
|
jetzt. Aber wenn man sich 2x versucht über den falschen Button
|
|
anzumelden, dann kommt ein irreführender Text wo steht, dass die
|
|
Auswahl oben nicht schuld ist."
|
|
|
|
DER SATZ WAR EINMAL RICHTIG. Auf der Crew-Wand gab es den stillen
|
|
Zugang; dort entschied die Kachel wirklich nicht, und wer alle
|
|
durchprobierte, sperrte sich nur selbst aus. Mit Abschnitt 1 oben
|
|
ist dieser Weg weggefallen -- und ab da sagte der Satz auf der
|
|
Wand, auf der jemand gerade feststeckt, das Gegenteil der Wahrheit.
|
|
|
|
GEPRUEFT WIRD BEIDES ZUSAMMEN: dass die Kachel wirklich entscheidet
|
|
(Abschnitt 1) UND dass der Satz das sagt. Eines ohne das andere
|
|
waere wieder die Lage von gestern.
|
|
|
|
DIE SPERRE WIRD VORHER GELEERT. Acht Fehlversuche je Adresse in
|
|
zehn Minuten -- die Abschnitte davor verbrauchen welche, und ab
|
|
dem neunten steht „Zu viele Versuche" statt des Satzes, um den es
|
|
hier geht. Das waere ein roter Haken ueber die Messumgebung, nicht
|
|
ueber das Programm. Gemessen werden soll der Hinweis, nicht die
|
|
Bremse.
|
|
-------------------------------------------------------------------- */
|
|
console.log("\n=== 8b. Der Hinweis nach zwei Fehlversuchen ===\n");
|
|
{
|
|
const { chromium } = await import(
|
|
"file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
|
|
const browser = await chromium.launch();
|
|
try {
|
|
const satzVon = async (wand) => {
|
|
/* Die Sperre je Lauf zuruecksetzen -- siehe oben. */
|
|
const dx = new DatabaseSync(process.env.WORKSPACE_DB);
|
|
dx.exec("DELETE FROM versuche");
|
|
dx.close();
|
|
|
|
const kontext = await browser.newContext({
|
|
viewport: { width: 390, height: 844 }, hasTouch: true, isMobile: true });
|
|
const seite = await kontext.newPage();
|
|
const konsole = [];
|
|
seite.on("pageerror", (e) => konsole.push("Absturz: " + e.message));
|
|
await seite.goto(`${BASIS}/workspace/${wand}`, { waitUntil: "domcontentloaded" });
|
|
await seite.waitForTimeout(400);
|
|
/* Irgendeine Kachel und ein Code, der zu keiner gehoert. */
|
|
await seite.click(".rolle >> nth=0");
|
|
const raus = [];
|
|
for (const n of [1, 2]) {
|
|
await seite.fill("#code", `FALSCH-CODE-000${n}`);
|
|
await seite.click("button[type=submit]");
|
|
await seite.waitForTimeout(900);
|
|
raus.push((await seite.textContent("#fehler") || "").replace(/\s+/g, " ").trim());
|
|
}
|
|
const crewKlasse = await seite.evaluate(() =>
|
|
document.body.classList.contains("gate--crew"));
|
|
await kontext.close();
|
|
return { nach1: raus[0], nach2: raus[1], crewKlasse, konsole };
|
|
};
|
|
|
|
const crew = await satzVon("crew-index.html");
|
|
const agentur = await satzVon("index.html");
|
|
|
|
ok(crew.crewKlasse === true && agentur.crewKlasse === false,
|
|
`zwei verschiedene Waende gemessen (crew ${crew.crewKlasse}, `
|
|
+ `agentur ${agentur.crewKlasse})`);
|
|
|
|
/* DER EIGENTLICHE BEFUND: Der alte Satz ist weg. */
|
|
ok(!/nicht schuld/i.test(crew.nach2),
|
|
`auf der Crew-Wand steht nicht mehr „die Auswahl oben ist nicht schuld" `
|
|
+ `(„${crew.nach2}")`);
|
|
ok(/Auswahl oben/.test(crew.nach2),
|
|
"sondern die Frage nach der Auswahl -- die dort seit Abschnitt 1 wirklich gilt");
|
|
/* EIN SATZ FUER BEIDE WAENDE. Zwei verschiedene waeren wieder zwei
|
|
Antworten auf dieselbe Frage, und eine davon veraltet. */
|
|
ok(crew.nach2 === agentur.nach2,
|
|
`und es ist derselbe Satz wie auf der Agenturwand (${crew.nach2 === agentur.nach2})`);
|
|
|
|
/* GEGENPROBE: Nach dem ERSTEN Fehlversuch steht der Hinweis noch
|
|
NICHT da. Ohne sie waere „der Hinweis kommt" auch dann gruen,
|
|
wenn er immer kaeme -- und ein Hinweis, der immer kommt, ist
|
|
keiner. */
|
|
ok(!/Auswahl oben/.test(crew.nach1),
|
|
`Gegenprobe: nach dem ersten Versuch steht er noch nicht da („${crew.nach1}")`);
|
|
ok(crew.nach1.length > 0 && /stimmt nicht/i.test(crew.nach1),
|
|
` dort steht die kurze Absage („${crew.nach1}")`);
|
|
|
|
ok(crew.konsole.length === 0 && agentur.konsole.length === 0,
|
|
`kein Skriptfehler auf beiden Waenden (${crew.konsole[0] || agentur.konsole[0] || "keiner"})`);
|
|
} finally {
|
|
await browser.close();
|
|
}
|
|
}
|
|
|
|
/* ---------- 9. Die Gegenprobe ----------------------------------------
|
|
Sie steht ABSICHTLICH GANZ UNTEN: Sie haengt eine Person
|
|
absichtlich aus der Regel aus. Lief sie weiter oben, tauchte
|
|
diese Person in jeder Liste DANACH auf -- und jeder spaetere
|
|
Abschnitt maesse einen Zustand, den es im Betrieb nicht gibt.
|
|
-------------------------------------------------------------------- */
|
|
console.log("\n=== 9. Gegenprobe: kann diese Pruefung ueberhaupt anschlagen? ===\n");
|
|
{
|
|
const d2 = new DatabaseSync(process.env.WORKSPACE_DB);
|
|
d2.prepare("UPDATE personen SET rolle = 'creator' WHERE id = ?").run(idModi1);
|
|
/* Betreuung dazu, sonst waere der Creator fuer den Manager auch ohne
|
|
die Verbergen-Regel unsichtbar -- und die Gegenprobe pruefte nichts. */
|
|
d2.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)")
|
|
.run(idModi1, idScout, jetzt);
|
|
d2.close();
|
|
|
|
const an = await anmelden("manager", "CODE-MAN-0001");
|
|
const { status, daten } = await hole(an.keks, "/workspace/api/personen");
|
|
if (status !== 200 || !Array.isArray(daten?.personen)) {
|
|
unklar(`Gegenprobe nicht durchfuehrbar (${status})`);
|
|
} else {
|
|
const sichtbar = daten.personen.some((z) => z.id === idModi1);
|
|
ok(sichtbar, sichtbar
|
|
? "ohne die Rolle 'modi' sieht der Manager dieselbe Person sehr wohl "
|
|
+ "-- die Pruefung oben kann also anschlagen"
|
|
: "GEGENPROBE FEHLGESCHLAGEN: auch ohne die Regel bleibt die Person "
|
|
+ "unsichtbar. Die Pruefung oben beweist damit nichts.");
|
|
}
|
|
}
|
|
|
|
|
|
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);
|