DogFatherGitandClaude Opus 5
b31bd9b515
VanVan im Support, Meldung #11, VIERMAL gemeldet: „Hier im Supportbereich kann man immer nur ein Bild hinzufuegen bei einer Meldung. 2-3 waeren besser." Und in der zweiten Runde der Satz, auf den es ankommt: „wenn man es nacheinander versucht hinzuzufuegen wird das Bild immer nur ersetzt." EINE TABELLE STATT NEUER SPALTEN `support_bilder` haelt ab jetzt JEDES Supportbild -- das der Meldung (`runde_nr` NULL) und das einer Antwort (`runde_nr` = Runde). Die Alternative waere `bild2_datei`, `bild3_datei` gewesen, und beim vierten Bild wieder. Eine Zeile je Bild kennt keine Obergrenze im Schema; die Grenze steht an EINER Stelle im Code (`BILDER_MAX = 3`) und kommt von dort in die Oberflaeche, statt dort ein zweites Mal zu stehen. DIE ACHT VORHANDENEN BILDER WANDERN MIT. Ohne diesen Schritt haette die neue Tabelle ab heute recht und die alten Bilder waeren unsichtbar -- ohne Fehler, ohne rote Zeile, nur acht leere Karten. Der Umzug steht NACH der Spaltennachruestung: Er liest `urteil_bild_datei`, und die gibt es in einer bestehenden Datenbank erst, nachdem sie ergaenzt wurde. Stuende er davor, scheiterte er genau dort, wo es darauf ankommt -- live, waehrend lokal alles gruen bliebe, weil jede Pruefung ihre Datenbank frisch anlegt. DREI BILDER IN EINER ANFRAGE `x-bilder: 20481,15320` sagt, wo zu schneiden ist, der Rumpf ist die Aneinanderreihung. `multipart/form-data` haette einen Zerleger gebraucht, den dieses Haus nicht hat; drei Anfragen nacheinander haetten den Zustand „Meldung da, Bild zwei laedt noch" erzeugt -- genau den, gegen den die Kommentare an dieser Route schon vorher argumentieren. Die Summe muss auf das Byte stimmen, und jedes Stueck wird einzeln an seinen ersten Bytes erkannt: Wer falsch schneidet, bekommt eine Absage, kein verfaelschtes Bild. Ohne den Kopf gilt der ganze Rumpf als ein Bild -- derselbe Satz mit einer Laenge, damit eine Seite aus dem Zwischenspeicher weiterlaeuft. EINE ROUTE STATT DREI. `/:id/bild` und `/:id/runde/:nr/bild` sind weg; es gibt `/:id/bild/:bid`. Wohin ein Bild gehoert, steht in seiner Zeile -- der Weg muss es nicht wiederholen. Die Meldungsnummer bleibt trotzdem im Pfad: Sie ist die Sichtbarkeitsfrage, und beides muss zusammenpassen (gemessen). ZWEI FUNDE, DIE DIE PRUEFUNG GEMACHT HAT UND NICHT ICH 1. UEBER DIE SEITE KAM GAR KEIN BILD MEHR AN. Beim Melden stand kein `Content-Type`. Das ging gut, solange der Rumpf eine einzelne Datei war -- ein `File` bringt seinen Typ mit. Ein `Blob` aus mehreren hat keinen, `fetch` schickt die Zeile dann gar nicht, `express.raw` fuehlt sich nicht zustaendig, und der Server bekam einen leeren Rumpf. Die Meldung waere durchgegangen, der Text angekommen, die Bilder weg -- ohne Fehlermeldung. Alle Pruefungen am Server waren dabei gruen; gefunden hat es erst der echte Browser. 2. DAS KREUZ DES DRITTEN BILDES LAG AUF DEM ZWEITEN. Der Entfernen-Knopf ist 44 px breit und absolut gesetzt, der Kasten aber nur so breit wie sein Bild. Bei einem schmalen Bild ragt er darueber hinaus -- wer „das zweite weg" antippt, loescht das dritte. `min-width`/`min-height` loesen das an der Ursache: Ein Kasten ist nie schmaler als der Knopf in ihm. WAS ICH FALSCH ANGENOMMEN HATTE: Ich hatte eingebaut, dass ein Nachtrag in derselben Runde die Bilder ersetzt. Die Pruefung dazu wurde rot -- zu Recht: Eine zweite Antwort in derselben Runde kann es nicht geben, die erste verlaesst den Stand „wartet". Der Code waere nie gelaufen und damit nie pruefbar gewesen. Er ist weg; an seiner Stelle steht der Beweis, dass er nicht fehlt. DREI WEITERE ROTE ZEILEN, DIE NICHT ZU DIESEM UMBAU GEHOERTEN * `manager-ziele.js` hatte einen ZWEITEN Notnagel (`frageNach ? … : confirm(…)`). `nachfrage.js` hat denselben laengst, und zwar mit dem vollstaendigen Text; der hiesige war der kuerzere und haette gewonnen. Zwei Antworten auf dieselbe Frage -- gemeldet von `pruef-nachfrage`. * Zwei Mittelpunkte in `reaktion.css` standen woertlich im `content`. Sie liegen im Latin-1-Block, wo `pruef-zeichen` die Truemmer einer verunglueckten Kodierung sucht. Jetzt als Escape -- im Browser nachgemessen, es steht Zeichen fuer Zeichen dasselbe da. * Das Aufraeumen nach 90 Tagen loeschte nur das EINE Bild der Meldung; die Bilder aus den Antwortrunden blieben ohne Zeile auf der Platte liegen. Die Liste kommt jetzt aus einer Abfrage statt aus einer Spalte und kann deshalb nicht wieder unvollstaendig sein. GEPRUEFT pruef-support 78 -> 104 ok darunter: der Umzug der alten Bilder auf einer eigenen Wegwerf-Datenbank -- zweimal und dreimal gestartet, nichts verdoppelt, Datum von damals erhalten pruef-support-bilder NEU, 36 ok (echter Browser) dreimal nacheinander waehlen ergibt drei, das vierte wird mit einem Satz abgelehnt, dasselbe zaehlt nicht doppelt, einzeln entfernen laesst die anderen stehen, alle drei laden wirklich (naturalWidth), Kreuze 44x44 und keines verdeckt (mit Gegenprobe per Deckel), nichts ragt auf 390 px heraus pruef-nachfrage 69 -> 74 ok pruef-struktur 102 ok, 413 Routen (vorher 414: zwei weg, eine neu) pruef-zeichen 7 ok (vorher 1 Fehler) pruef-aufbewahrung 45 ok pruef-manager-ziele 216 ok pruef-ports 10 ok · pruef-portnummern 41 ok (die neue Pruefdatei verschiebt die abgeleiteten Nummern) NUR DAS AGENTURHAUS IST BETROFFEN. Die Supportseite liegt unter `/workspace`; am Crew-Haus aendert sich keine Zeile. Co-Authored-By: Claude Opus 5 <[email protected]>
960 lines
45 KiB
JavaScript
960 lines
45 KiB
JavaScript
/* =====================================================================
|
||
pruef-nachfrage.mjs — Nichts verschwindet ohne Nachfrage.
|
||
|
||
Filipe, 19.09.2026: „Es darf vor allem keine Stellen geben, an denen
|
||
ein Benutzer etwas falsch machen kann, nur weil die Seite es nicht
|
||
verständlich genug erklärt." Und: „Fehler möglichst verhindern,
|
||
bevor sie entstehen."
|
||
|
||
---------------------------------------------------------------------
|
||
WAS DAS PROBLEM WAR
|
||
|
||
Das Haus hatte die richtige Bauweise — einen <dialog> statt
|
||
`confirm()` — und begründete sie in `aufgaben.html` sogar ausführlich.
|
||
Nur stand sie IN EINER SEITE. Gemessen am 19.09.2026: **30 Stellen**
|
||
in 16 Dateien griffen weiterhin zu `confirm()` oder `prompt()`.
|
||
|
||
Der Unterschied ist nicht Geschmack. `confirm('Wirklich löschen?')`
|
||
stellt die falsche Frage: Es fragt, ob man sicher ist, und nennt
|
||
nicht, WAS passiert, was BLEIBT und ob es ZURÜCK geht. Genau das
|
||
sind die drei Dinge, die man vor einem Löschen wissen will.
|
||
|
||
---------------------------------------------------------------------
|
||
VIER DINGE WERDEN GEPRÜFT
|
||
|
||
1. KEIN NATIVER DIALOG mehr in einer Seiten-Datei. Ausgenommen ist
|
||
allein der Notnagel in `nachfrage.js` selbst — für Browser ohne
|
||
<dialog>. (Ein Verbot ohne diese Ausnahme wäre falsch: Ein
|
||
iPhone vor Safari 15.4 bekäme sonst gar nichts angezeigt.)
|
||
|
||
2. ANGESCHLOSSEN — jede Seite, deren Skripte `frageNach` benutzen,
|
||
lädt auch `nachfrage.js`. Ohne die Datei wäre `frageNach` nicht
|
||
definiert, und aus einer Rückfrage würde ein Absturz: Der Knopf
|
||
täte stillschweigend nichts.
|
||
|
||
ACHTUNG, hier steckte beim Bauen schon eine Falle: Die erste
|
||
Fassung dieser Prüfung zählte `nachfrage.js` SELBST als Nutzer
|
||
(die Datei enthält das Wort natürlich) — damit war jede Seite
|
||
„Nutzer", die Prüfung immer grün und sie bewies nichts. Deshalb
|
||
ist die Datei unten ausdrücklich ausgenommen.
|
||
|
||
3. GESTALTET — `.dialog` wird in einer Datei gestaltet, die JEDE
|
||
Seite lädt. Vorher stand sie in `aufgaben.css`; auf `dateien.html`
|
||
wäre der Dialog ein weißer Systemkasten auf dunkler Seite
|
||
gewesen. Das ist keine Schönheitsfrage: Ein Kasten, der aussieht
|
||
wie eine Browser-Warnung, wird weggeklickt statt gelesen.
|
||
|
||
4. VOLLSTÄNDIG — jeder Aufruf hat einen `titel` und sagt, was
|
||
passiert (`was`). Ein Dialog ohne diese Angabe ist ein
|
||
`confirm()` mit mehr Zeilen Code.
|
||
|
||
Dazu GEGENPROBEN: Jede Prüfung muss beweisen, dass sie auch
|
||
„nicht in Ordnung" sagen kann.
|
||
|
||
AUFRUF: node server/pruef-nachfrage.mjs
|
||
Läuft in unter zwei Sekunden, ohne Server.
|
||
===================================================================== */
|
||
|
||
import { readFileSync, readdirSync } from "node:fs";
|
||
import { join, dirname } from "node:path";
|
||
import { fileURLToPath } from "node:url";
|
||
import { bestaetige, nachfrageText } from "./helfer-nachfrage.mjs";
|
||
|
||
const HIER = dirname(fileURLToPath(import.meta.url));
|
||
const WURZEL = join(HIER, "..");
|
||
const SEITEN_ORDNER = join(WURZEL, "workspace");
|
||
const JS_ORDNER = join(SEITEN_ORDNER, "assets", "js");
|
||
const CSS_ORDNER = join(SEITEN_ORDNER, "assets", "css");
|
||
|
||
/* Die eine Datei, die `confirm`/`prompt` benutzen DARF -- sie ist der
|
||
Notnagel fuer Browser ohne <dialog>. */
|
||
const DER_NOTNAGEL = "nachfrage.js";
|
||
|
||
/** Ein winziges, gueltiges PNG (1x1) -- echte Kopfbytes, damit der
|
||
* Browser wirklich ein Bild bekommt und die Vorschau etwas anzeigen
|
||
* kann. Vorgetaeuschte Bytes ergaeben ein leeres `<img>`, und die
|
||
* Pruefung haette „Vorschau da" gemeldet, ohne eine zu sehen. */
|
||
const PNG_PROBE = Buffer.from(
|
||
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk"
|
||
+ "YPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==", "base64");
|
||
|
||
let ok = 0, fehl = 0;
|
||
const pruef = (name, bedingung, zusatz = "") => {
|
||
if (bedingung) { ok++; console.log(` OK ${name}`); }
|
||
else { fehl++; console.log(` FEHL ${name}${zusatz ? "\n " + zusatz : ""}`); }
|
||
};
|
||
|
||
const lies = (p) => readFileSync(p, "utf8");
|
||
const seiten = readdirSync(SEITEN_ORDNER).filter((f) => f.endsWith(".html"));
|
||
const skripte = readdirSync(JS_ORDNER).filter((f) => f.endsWith(".js"));
|
||
|
||
console.log("\n=== Nachfragen: kein nativer Dialog, und keiner ohne Erklärung ===\n");
|
||
|
||
/* ---------------------------------------------------------------------
|
||
1. KEIN NATIVER DIALOG
|
||
------------------------------------------------------------------ */
|
||
|
||
/** Entfernt Kommentare, bevor gesucht wird. Ohne das zaehlt jeder
|
||
* Kommentar, der `confirm()` ERWAEHNT, als Fund -- und davon gibt es
|
||
* in diesem Haus absichtlich mehrere (die Begruendungen). */
|
||
function ohneKommentare(js) {
|
||
return js.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
|
||
}
|
||
|
||
const nativ = [];
|
||
for (const f of skripte) {
|
||
if (f === DER_NOTNAGEL) continue;
|
||
const code = ohneKommentare(lies(join(JS_ORDNER, f)));
|
||
/* DAS MUSTER HATTE EINE LUECKE, UND ZWAR DIE GROESSTE MOEGLICHE
|
||
(gefunden am 22.09.2026).
|
||
|
||
Vorher stand hier `(?:^|[^.\w])(confirm|prompt)\s*\(`. Das
|
||
`[^.\w]` sollte fremde Methoden ausschliessen -- etwas wie
|
||
`angebot.prompt()` (so heisst die Installations-Aufforderung des
|
||
Browsers) ist kein nativer Dialog und darf nicht als Fund zaehlen.
|
||
|
||
Nur trifft dieser Ausschluss ausgerechnet die HAEUFIGSTE
|
||
Schreibweise: `window.prompt(` hat einen Punkt davor. Die Pruefung
|
||
war damit gruen, waehrend in teamlage.js ZWEI native prompt()
|
||
standen -- einer davon seit Wochen.
|
||
|
||
Genau das Muster, vor dem dieses Haus warnt: eine Pruefung, die
|
||
laeuft, gruen ist und das Falsche prueft. Gefunden hat es nicht
|
||
sie, sondern eine Suche von Hand.
|
||
|
||
Jetzt zwei Faelle statt einem: mit `window.` davor -- oder ganz
|
||
ohne Punkt. Alles andere (`irgendwas.prompt()`) bleibt aussen
|
||
vor, und das ist weiterhin richtig. */
|
||
for (const m of code.matchAll(/(?:^|[^.\w])(?:window\s*\.\s*)?(confirm|prompt)\s*\(/g)) {
|
||
const zeile = code.slice(0, m.index).split("\n").length;
|
||
nativ.push(`${f}:${zeile} → ${m[1]}()`);
|
||
}
|
||
}
|
||
pruef("keine Seite benutzt noch confirm() oder prompt()", nativ.length === 0,
|
||
nativ.slice(0, 8).join("\n "));
|
||
|
||
/* Und der Notnagel ist da -- sonst haetten Browser ohne <dialog> gar
|
||
nichts. Die ZAHL gehoert in die Bedingung, nicht nur in den Text. */
|
||
const notnagel = lies(join(JS_ORDNER, DER_NOTNAGEL));
|
||
pruef("der Notnagel für alte Browser ist vorhanden",
|
||
/HTMLDialogElement/.test(notnagel) && /window\.confirm\(/.test(notnagel));
|
||
|
||
/* ---------------------------------------------------------------------
|
||
2. ANGESCHLOSSEN
|
||
------------------------------------------------------------------ */
|
||
|
||
/** Welche Skripte rufen frageNach auf? OHNE die Datei, die es
|
||
* DEFINIERT -- sonst ist die Antwort immer „alle". */
|
||
const nutzer = new Set();
|
||
/* EIN AUFRUF HINTER EINER `typeof`-ABFRAGE IST KEINE PFLICHT
|
||
(24.09.2026 -- und die Pruefung war aus genau diesem Grund rot,
|
||
ohne dass etwas kaputt war).
|
||
|
||
`installieren.js` liegt auf fast jeder Seite und ruft frageNach
|
||
auf -- aber ausdruecklich nur, wenn es da ist:
|
||
|
||
if (typeof window.frageNach === 'function') { … }
|
||
|
||
Der Kommentar daneben erklaert seit dem 22.09.2026 genau, warum:
|
||
Die Datei laeuft auch auf der Anmeldewand, wo nachfrage.js mit
|
||
Absicht nicht geladen wird. Die Pruefung zaehlte den Aufruf
|
||
trotzdem als "diese Seite fragt nach" -- und weil installieren.js
|
||
ueberall liegt, wurde damit JEDE Seite zur fragenden. Ergebnis:
|
||
fuenf rote Zeilen, kein einziger echter Mangel.
|
||
|
||
EINE PRUEFUNG, DIE IMMER ROT IST, IST KEINE PRUEFUNG MEHR -- genau
|
||
wie eine Warnung, die immer kommt. Ab dem zweiten Mal liest man
|
||
sie weg, und dann auch die echte.
|
||
|
||
Die Unterscheidung ist einfach und haelt: Wer vorher fragt, ob es
|
||
die Funktion gibt, kommt ohne sie aus. Wer sie einfach aufruft,
|
||
braucht sie. */
|
||
const geschuetzt = (text) =>
|
||
/typeof\s+window\.frageNach\s*===?\s*['"]function['"]/.test(text)
|
||
|| /window\.frageNach\s*\?\./.test(text);
|
||
const freiwillig = new Set();
|
||
for (const f of skripte) {
|
||
if (f === DER_NOTNAGEL) continue;
|
||
const text = ohneKommentare(lies(join(JS_ORDNER, f)));
|
||
if (!/\bfrageNach\s*\(/.test(text)) continue;
|
||
if (geschuetzt(text)) { freiwillig.add(f); continue; }
|
||
nutzer.add(f);
|
||
}
|
||
pruef("es gibt überhaupt Seiten, die nachfragen", nutzer.size > 0,
|
||
`gefunden: ${nutzer.size}`);
|
||
/* WAS HIER HERAUSFAELLT, WIRD BENANNT. Ein stilles Aussortieren
|
||
waere die bequeme Art, eine Pruefung gruen zu bekommen -- man
|
||
saehe dann nicht mehr, wie gross die Ausnahme geworden ist. */
|
||
pruef("die geschützten Aufrufe sind benannt und wenige",
|
||
freiwillig.size <= 3,
|
||
`ohne Pflicht zur Datei (typeof-Abfrage davor): ${[...freiwillig].join(", ") || "keine"}`);
|
||
/* GEGENPROBE: Ein UNGESCHUETZTER Aufruf muss weiterhin zaehlen --
|
||
sonst hiesse "alle angeschlossen" nur, dass die Regel niemanden
|
||
mehr erfasst. */
|
||
pruef("Gegenprobe: ein ungeschützter Aufruf zählt weiterhin",
|
||
!geschuetzt("frageNach({ titel: 'x' });")
|
||
&& geschuetzt("if (typeof window.frageNach === 'function') frageNach({});"),
|
||
`${nutzer.size} Dateien rufen ungeschützt auf`);
|
||
|
||
const ohneDatei = [], totesGewicht = [], fragendeSeiten = [];
|
||
let mitNutzung = 0;
|
||
for (const s of seiten) {
|
||
const html = lies(join(SEITEN_ORDNER, s));
|
||
const geladen = [...html.matchAll(/<script src="assets\/js\/([a-z0-9-]+\.js)/g)]
|
||
.map((m) => m[1]);
|
||
/* ZWEI GRUENDE, die Datei zu brauchen (20.09.2026):
|
||
fragen -- oder einen Dialog mit Eingabefeldern haben. Seit die
|
||
Verwurfwache existiert, bewacht `nachfrage.js` jeden solchen
|
||
Dialog von selbst, auch ohne einen einzigen `frageNach`-Aufruf
|
||
in der Seite. Ohne diesen zweiten Grund wuerde eine Seite mit
|
||
einem reinen Formular-Dialog hier als „totes Gewicht" gemeldet --
|
||
und jemand naehme die Datei heraus, die dort gerade arbeitet. */
|
||
const hatDialogMitFeld = [...html.matchAll(/<dialog[^>]*>[\s\S]*?<\/dialog>/g)]
|
||
.some((m) => /<(input|textarea|select)\b/.test(m[0]));
|
||
const kannFragen = geladen.some((g) => nutzer.has(g)) || hatDialogMitFeld;
|
||
const hatDatei = html.includes("assets/js/nachfrage.js");
|
||
if (kannFragen) { mitNutzung++; fragendeSeiten.push(s); if (!hatDatei) ohneDatei.push(s); }
|
||
else if (hatDatei) totesGewicht.push(s);
|
||
}
|
||
pruef("jede Seite, die nachfragt, lädt auch nachfrage.js",
|
||
mitNutzung > 0 && ohneDatei.length === 0,
|
||
`${mitNutzung} Seiten nutzen es, ohne Datei: ${ohneDatei.join(", ") || "keine"}`);
|
||
|
||
/* UND DIE GEGENRICHTUNG. Ohne sie waere „ueberall einbinden" die
|
||
bequeme Antwort -- und die Anmeldewand, die jeder Besucher als
|
||
erste laedt, truege 4,8 KB fuer einen Dialog, den sie nie zeigt.
|
||
Zwei Richtungen, eine Regel: Die Datei liegt genau dort, wo sie
|
||
gebraucht wird. */
|
||
pruef("und keine Seite lädt sie, ohne je nachzufragen",
|
||
totesGewicht.length === 0,
|
||
`unnötig geladen auf: ${totesGewicht.join(", ")}`);
|
||
|
||
/* ---------------------------------------------------------------------
|
||
3. GESTALTET, UND ZWAR ÜBERALL
|
||
------------------------------------------------------------------ */
|
||
|
||
/** In welchen CSS-Dateien wird `.dialog` gestaltet? */
|
||
const dialogCss = readdirSync(CSS_ORDNER).filter((f) => f.endsWith(".css"))
|
||
.filter((f) => /^\.dialog[\s,{:]/m.test(lies(join(CSS_ORDNER, f))));
|
||
|
||
/** Und welche davon laedt jede Seite, DIE NACHFRAGEN KANN? Abgeleitet,
|
||
* nicht behauptet -- eine Liste „module.css laedt ueberall" waere genau
|
||
* die abgeschriebene Liste, vor der die Hausregeln warnen.
|
||
*
|
||
* Gemessen wird gegen die fragenden Seiten, nicht gegen alle: Die zwei
|
||
* Anmeldewaende zeigen nie einen Dialog. Von ihnen die Dialog-
|
||
* Gestaltung zu verlangen hiesse, 12 KB auf die Seite zu legen, die
|
||
* jeder Besucher als erste laedt -- fuer nichts. */
|
||
const ueberall = new Set(dialogCss);
|
||
for (const s of fragendeSeiten) {
|
||
const html = lies(join(SEITEN_ORDNER, s));
|
||
const css = new Set([...html.matchAll(/href="assets\/css\/([a-z0-9-]+\.css)/g)]
|
||
.map((m) => m[1]));
|
||
for (const d of [...ueberall]) if (!css.has(d)) ueberall.delete(d);
|
||
}
|
||
pruef(".dialog wird dort gestaltet, wo jede fragende Seite es lädt",
|
||
ueberall.size > 0 && fragendeSeiten.length > 0,
|
||
`.dialog steht in: ${dialogCss.join(", ")} — von allen `
|
||
+ `${fragendeSeiten.length} fragenden Seiten geladen: `
|
||
+ `${[...ueberall].join(", ") || "KEINE"}`);
|
||
|
||
/* Die zwei eigenen Bauteile des Nachfrage-Dialogs gehoeren in dieselbe
|
||
Datei -- sonst waere der wichtigste Satz ("nicht rueckgaengig")
|
||
ungestaltet. */
|
||
const gemeinsam = [...ueberall][0];
|
||
const gCss = gemeinsam ? lies(join(CSS_ORDNER, gemeinsam)) : "";
|
||
pruef("auch die Warnzeile und die Fehlerzeile sind dort gestaltet",
|
||
/\.nachfrage__endgueltig/.test(gCss) && /\.nachfrage__fehler/.test(gCss));
|
||
|
||
/* Und sie traegt ihre Aussage nicht nur ueber Farbe. */
|
||
pruef("die Warnzeile hat ein Zeichen, nicht nur eine Farbe",
|
||
/\.nachfrage__endgueltig::before\s*{[^}]*content/.test(gCss),
|
||
"Farbe allein trägt keine Aussage — Rot-Grün-Schwäche, Kontrastmodus");
|
||
|
||
/* ---------------------------------------------------------------------
|
||
4. VOLLSTÄNDIG: jeder Aufruf sagt, was passiert
|
||
------------------------------------------------------------------ */
|
||
|
||
/** Schneidet den Objektliteral-Teil eines frageNach-Aufrufs heraus,
|
||
* klammergenau. Ein Muster „bis zur naechsten }" wuerde bei jedem
|
||
* verschachtelten Ausdruck danebengreifen. */
|
||
function aufrufe(js) {
|
||
const out = [];
|
||
for (const m of js.matchAll(/frageNach\s*\(\s*{/g)) {
|
||
let i = m.index + m[0].length - 1, tiefe = 0, j = i;
|
||
for (; j < js.length; j++) {
|
||
if (js[j] === "{") tiefe++;
|
||
else if (js[j] === "}") { tiefe--; if (tiefe === 0) { j++; break; } }
|
||
}
|
||
out.push(js.slice(i, j));
|
||
}
|
||
return out;
|
||
}
|
||
|
||
let gezaehlt = 0;
|
||
const ohneTitel = [], ohneWas = [];
|
||
for (const f of skripte) {
|
||
if (f === DER_NOTNAGEL) continue;
|
||
const code = ohneKommentare(lies(join(JS_ORDNER, f)));
|
||
for (const a of aufrufe(code)) {
|
||
gezaehlt++;
|
||
/* AUCH DIE KURZSCHREIBWEISE ZAEHLT (24.09.2026).
|
||
Gesucht wurde nur `titel:`. In installieren.js steht aber
|
||
`frageNach({ titel, was: weg, … })` -- die Kurzform, die den
|
||
Titel aus einer gleichnamigen Variablen nimmt. Gueltiges JS,
|
||
gesetzter Titel, und trotzdem gemeldet. Eine Pruefung, die eine
|
||
richtige Schreibweise bemaengelt, bringt einem bei, ihre
|
||
Meldungen zu ignorieren. */
|
||
if (!/\btitel\s*[:,}]/.test(a)) ohneTitel.push(f);
|
||
if (!/\bwas\s*:/.test(a)) ohneWas.push(f);
|
||
}
|
||
}
|
||
/* DIE ZAHL GEHOERT IN DIE BEDINGUNG: Bei null Aufrufen waere
|
||
„alle haben einen Titel" trivialerweise wahr. */
|
||
pruef("jeder Aufruf hat einen Titel", gezaehlt > 0 && ohneTitel.length === 0,
|
||
`${gezaehlt} Aufrufe geprüft, ohne Titel: ${ohneTitel.join(", ") || "keiner"}`);
|
||
pruef("jeder Aufruf sagt, WAS passiert", gezaehlt > 0 && ohneWas.length === 0,
|
||
`ohne „was": ${ohneWas.join(", ") || "keiner"}`);
|
||
|
||
/* Und die gefaehrlichste Handlung im Haus -- eine Person loeschen --
|
||
verlangt das Abtippen des Namens. Das ist keine Schikane: Der
|
||
Loeschknopf sitzt neben dem Sperrknopf. */
|
||
pruef("eine Person löschen verlangt den Namen abgetippt",
|
||
/tippen:\s*v\.person\.name/.test(lies(join(JS_ORDNER, "personen.js"))));
|
||
|
||
/* ---------------------------------------------------------------------
|
||
DIE VERWURFWACHE — beide Schliesswege, und kein Dauerfeuer
|
||
------------------------------------------------------------------ */
|
||
const wache = notnagel;
|
||
pruef("die Verwurfwache faengt Esc ab (das `cancel`-Ereignis)",
|
||
/addEventListener\('cancel'/.test(wache),
|
||
"ohne sie liefe Esc durch -- der Browser ruft close() dabei NICHT auf");
|
||
pruef("und sie faengt auch close() ab (die Abbrechen-Knoepfe)",
|
||
/dlg\.close = function/.test(wache),
|
||
"ohne sie liefe der Knopf durch -- er loest kein `cancel` aus");
|
||
pruef("sie ersetzt close() nur AM DIALOG, nicht am Prototyp",
|
||
!/HTMLDialogElement\.prototype\.close\s*=/.test(wache),
|
||
"ein globaler Eingriff traefe den Nachfrage-Dialog selbst -- der ginge nie mehr zu");
|
||
pruef("sie fragt nur bei wirklicher Aenderung",
|
||
/const geaendert = \(\) =>/.test(wache) && /if \(!geaendert\(\)\)/.test(wache),
|
||
"eine Warnung, die immer kommt, ist keine Warnung mehr");
|
||
pruef("sie bewacht sich nicht selbst",
|
||
/dialog:not\(\.nachfrage\)/.test(wache),
|
||
"sonst fragte der Nachfrage-Dialog beim Schliessen nach sich selbst");
|
||
|
||
/* Und die Speicherwege sagen ihr Bescheid -- sonst fragte sie nach
|
||
jedem erfolgreichen Speichern. */
|
||
let speicherwege = 0;
|
||
for (const f of skripte) {
|
||
if (f === DER_NOTNAGEL) continue;
|
||
speicherwege += [...ohneKommentare(lies(join(JS_ORDNER, f)))
|
||
.matchAll(/\.vergessen\?\.\(\)/g)].length;
|
||
}
|
||
pruef("die Speicherwege melden der Wache, dass nichts mehr zu retten ist",
|
||
speicherwege >= 8, `${speicherwege} Stellen rufen vergessen()`);
|
||
|
||
/* ---------------------------------------------------------------------
|
||
DIE GEGENPROBEN — jede muss anschlagen
|
||
------------------------------------------------------------------ */
|
||
console.log("\n --- Gegenproben (jede MUSS anschlagen) ---");
|
||
|
||
/* DIE GEGENPROBE PRUEFT JETZT BEIDE SCHREIBWEISEN. Haette sie das
|
||
vorher getan, waere die Luecke im Muster am selben Tag aufgefallen,
|
||
an dem es geschrieben wurde. */
|
||
pruef("Gegenprobe: ein erfundenes window.prompt() würde gefunden",
|
||
/(?:^|[^.\w])(?:window\s*\.\s*)?(confirm|prompt)\s*\(/.test(
|
||
"const g = window.prompt('Warum nicht?');"));
|
||
pruef("Gegenprobe: eine fremde Methode NICHT (angebot.prompt())",
|
||
!/(?:^|[^.\w])(?:window\s*\.\s*)?(confirm|prompt)\s*\(/.test(
|
||
"angebot.prompt();"));
|
||
pruef("Gegenprobe: ein erfundenes confirm() würde gefunden",
|
||
/(?:^|[^.\w])(confirm|prompt)\s*\(/.test(
|
||
ohneKommentare("function x(){ if (!confirm('weg?')) return; }")));
|
||
|
||
pruef("Gegenprobe: ein confirm() im KOMMENTAR wird NICHT gemeldet",
|
||
!/(?:^|[^.\w])(confirm|prompt)\s*\(/.test(
|
||
ohneKommentare("/* frueher stand hier confirm('weg?') */")));
|
||
|
||
pruef("Gegenprobe: nachfrage.js selbst zählt nicht als Nutzer",
|
||
!nutzer.has(DER_NOTNAGEL),
|
||
'sonst wäre jede Seite trivialerweise Nutzer und die Prüfung grün ohne Inhalt');
|
||
|
||
pruef("Gegenprobe: die Gestaltung-Prüfung kann auch NEIN sagen",
|
||
(() => {
|
||
/* Eine erfundene Seite, die nachfragt, aber die Datei nicht laedt:
|
||
Die Schnittmenge muss dadurch leer werden. */
|
||
const probe = new Set(dialogCss);
|
||
for (const d of [...probe]) if (!new Set(["gibt-es-nicht.css"]).has(d)) probe.delete(d);
|
||
return probe.size === 0;
|
||
})());
|
||
|
||
pruef("Gegenprobe: ein Aufruf ohne Titel würde auffallen",
|
||
aufrufe("frageNach({ was: 'x' })").length === 1
|
||
&& !/\btitel\s*:/.test(aufrufe("frageNach({ was: 'x' })")[0]));
|
||
|
||
pruef("Gegenprobe: der Klammerzähler findet das Ende auch bei Verschachtelung",
|
||
aufrufe("frageNach({ titel: f({a:1}), was: 'x' }) ; danach")[0]
|
||
=== "{ titel: f({a:1}), was: 'x' }");
|
||
|
||
/* =====================================================================
|
||
UND JETZT AM ECHTEN BILDSCHIRM
|
||
|
||
Alles oben ist Textsuche. Sie beweist, dass der Aufruf dasteht --
|
||
nicht, dass der Dialog aufgeht, dass "Doch nicht" wirklich nichts
|
||
tut und dass das Abtippen wirklich sperrt.
|
||
|
||
Geprüft wird ausgerechnet der gefährlichste Handgriff im Haus: eine
|
||
Person löschen. `pruef-personen-loeschen` gibt es zwar, aber sie
|
||
kennt nur die Schnittstelle -- kein Browser, kein Knopf, kein
|
||
Dialog. Der Weg, den ein Mensch geht, war nie geprüft.
|
||
===================================================================== */
|
||
if (process.env.OHNE_BROWSER === "ja") {
|
||
console.log("\n (Browserteil übersprungen — OHNE_BROWSER=ja)");
|
||
} else {
|
||
const { mkdtempSync, rmSync } = await import("node:fs");
|
||
const { tmpdir } = await import("node:os");
|
||
const { eigenerPort } = await import("./helfer-port.mjs");
|
||
const { notbremse } = await import("./helfer-notbremse.mjs");
|
||
|
||
const ordner = mkdtempSync(join(tmpdir(), "ws-nachfrage-"));
|
||
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
|
||
const PORT = await eigenerPort(import.meta, "die Nachfragepruefung");
|
||
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 });
|
||
};
|
||
await import("./index.js");
|
||
notbremse(240_000, "pruef-nachfrage");
|
||
await new Promise((r) => setTimeout(r, 1000));
|
||
const BASIS = `http://127.0.0.1:${PORT}`;
|
||
|
||
const { DatabaseSync } = await import("node:sqlite");
|
||
const { scryptSync, randomBytes } = await import("node:crypto");
|
||
await fetch(BASIS + "/workspace/api/anmelden", {
|
||
method: "POST", headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});
|
||
for (let i = 0; i < 60; i++) {
|
||
try {
|
||
const pb = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
try { pb.prepare("SELECT 1 FROM personen LIMIT 1").get(); break; } finally { pb.close(); }
|
||
} catch { await new Promise((r) => setTimeout(r, 250)); }
|
||
}
|
||
const db = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
const jetzt = new Date().toISOString();
|
||
const anlegen = (name, rolle, code) => {
|
||
const salt = randomBytes(16).toString("hex");
|
||
const h = scryptSync(code, salt, 64,
|
||
{ N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
|
||
db.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt)"
|
||
+ " VALUES (?,?,?,?,?,1,?)").run(name, rolle, h, salt, 32768, jetzt);
|
||
};
|
||
anlegen("Filipe", "admin", "CODE-DOGI-0001");
|
||
anlegen("Testolina", "creator", "CODE-CREA-0001");
|
||
db.close();
|
||
|
||
const pw = await import("file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
|
||
const browser = await pw.chromium.launch();
|
||
const ctx = await browser.newContext({ viewport: { width: 1280, height: 900 } });
|
||
const seite = await ctx.newPage();
|
||
const abstuerze = [];
|
||
seite.on("pageerror", (f) => abstuerze.push(f.message));
|
||
|
||
await seite.goto(BASIS + "/workspace/", { waitUntil: "networkidle" });
|
||
await seite.click('.rolle[data-rolle="admin"]');
|
||
await seite.fill("#code", "CODE-DOGI-0001");
|
||
await seite.click("button[type=submit]");
|
||
await seite.waitForURL("**/start.html", { timeout: 25000 });
|
||
await seite.goto(BASIS + "/workspace/personen.html", { waitUntil: "networkidle" });
|
||
await seite.waitForTimeout(900);
|
||
|
||
console.log("\n --- Am echten Bildschirm: eine Person löschen ---");
|
||
|
||
const wieViele = () => seite.evaluate(() =>
|
||
[...document.querySelectorAll(".person")].length);
|
||
/* DEN ABSCHNITT AUFKLAPPEN. Die Rollen-Abschnitte sind
|
||
standardmäßig ZU -- nur der eigene ist offen. Das ist so gewollt
|
||
(eine Liste mit fünf offenen Abschnitten ist unlesbar), und eine
|
||
Prüfung, die das nicht weiß, misst eine leere Liste und hält das
|
||
für einen Befund. Genau das ist beim Bauen passiert. */
|
||
await seite.waitForSelector('.gruppe[data-rolle="creator"] .gruppe__kopf',
|
||
{ timeout: 15_000 });
|
||
await seite.click('.gruppe[data-rolle="creator"] .gruppe__kopf');
|
||
await seite.waitForFunction(
|
||
() => document.querySelectorAll(".person").length >= 2,
|
||
{ timeout: 15_000 }).catch(() => {});
|
||
const vorher = await wieViele();
|
||
const namen2 = await seite.evaluate(() =>
|
||
[...document.querySelectorAll(".person")]
|
||
.map((e) => e.textContent.trim().slice(0, 30)).join(" | "));
|
||
pruef("die Liste steht da", vorher >= 2, `${vorher} Personen: ${namen2}`);
|
||
|
||
const loeschKnopf = seite.locator(".person", { hasText: "Testolina" })
|
||
.locator("button", { hasText: "Löschen" }).first();
|
||
await loeschKnopf.click();
|
||
|
||
let dialogDa = true;
|
||
try { await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 4000 }); }
|
||
catch { dialogDa = false; }
|
||
pruef("der Dialog geht auf", dialogDa);
|
||
|
||
if (dialogDa) {
|
||
const inhalt = await nachfrageText(seite);
|
||
pruef("er nennt den Namen im Titel", /Testolina/.test(inhalt.titel), inhalt.titel);
|
||
pruef("er sagt, dass es endgültig ist", inhalt.endgueltig);
|
||
pruef("er sagt, WAS passiert", inhalt.was.length > 10, inhalt.was);
|
||
pruef("und was BLEIBT", inhalt.bleibt.length > 10, inhalt.bleibt);
|
||
|
||
/* DER RIEGEL: Ein falsch abgetippter Name darf NICHTS loeschen. */
|
||
await seite.fill("#nachfrage-tipp", "Testolinaa");
|
||
await seite.click('dialog.nachfrage [data-teil="ja"]');
|
||
await seite.waitForTimeout(500);
|
||
const nochOffen = await seite.evaluate(() =>
|
||
!!document.querySelector("dialog.nachfrage[open]"));
|
||
pruef("ein falsch abgetippter Name schließt den Dialog NICHT", nochOffen);
|
||
const fehlertext = await seite.evaluate(() =>
|
||
document.querySelector('dialog.nachfrage [data-teil="fehler"]')?.textContent?.trim() || "");
|
||
pruef("und sagt, was erwartet wird", /Testolina/.test(fehlertext), fehlertext);
|
||
pruef("die Person ist noch da", await wieViele() === vorher);
|
||
|
||
/* Der Knopf daneben muss wirklich nichts tun. */
|
||
await seite.click('dialog.nachfrage [data-teil="nein"]');
|
||
await seite.waitForTimeout(400);
|
||
pruef("der Abbruchknopf schließt den Dialog",
|
||
!await seite.evaluate(() => !!document.querySelector("dialog.nachfrage[open]")));
|
||
pruef("und löscht nichts", await wieViele() === vorher);
|
||
|
||
/* Und jetzt richtig. */
|
||
await bestaetige(seite, () => loeschKnopf.click(), { tippen: "Testolina" });
|
||
await seite.waitForTimeout(1400);
|
||
const nachher = await wieViele();
|
||
pruef("mit richtig abgetipptem Namen wird gelöscht",
|
||
nachher === vorher - 1, `${vorher} → ${nachher}`);
|
||
}
|
||
|
||
/* Und Esc bricht ab -- auf einem Dialog OHNE Abtippen. */
|
||
await seite.goto(BASIS + "/workspace/start.html", { waitUntil: "networkidle" });
|
||
await seite.waitForTimeout(700);
|
||
await seite.click("#abmelden");
|
||
let abmeldeDialog = true;
|
||
try { await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 4000 }); }
|
||
catch { abmeldeDialog = false; }
|
||
pruef("auch Abmelden fragt nach", abmeldeDialog);
|
||
if (abmeldeDialog) {
|
||
const t = await nachfrageText(seite);
|
||
pruef("und nennt den Grund: der Zugangscode", /Zugangscode/.test(t.was), t.was);
|
||
await seite.keyboard.press("Escape");
|
||
await seite.waitForTimeout(800);
|
||
pruef("Esc bricht ab – man bleibt angemeldet",
|
||
seite.url().includes("start.html"), seite.url());
|
||
}
|
||
|
||
/* ===================================================================
|
||
DIE VERWURFWACHE AM ECHTEN BILDSCHIRM (20.09.2026)
|
||
|
||
Alles oben ist Textsuche. Sie beweist, dass der Code dasteht --
|
||
nicht, dass Esc wirklich abgefangen wird, dass ein unberührter
|
||
Dialog still zugeht und dass „Verwerfen" wirklich verwirft.
|
||
|
||
Geprüft wird am größten Formular des Hauses: „Aufgabe bearbeiten",
|
||
zehn Felder. Wer dort tippt und mit dem Daumen den Rand trifft,
|
||
verlor bis heute alles, wortlos.
|
||
=================================================================== */
|
||
console.log("\n --- Die Verwurfwache am Bildschirm ---");
|
||
|
||
/* Eine Aufgabe, damit es etwas zu bearbeiten gibt. */
|
||
{
|
||
const dbz = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
const wer = dbz.prepare("SELECT id FROM personen WHERE rolle = 'admin' LIMIT 1").get()?.id;
|
||
dbz.prepare("INSERT INTO aufgaben (titel, beschreibung, status, verantwortlich_id,"
|
||
+ " erstellt_von, erstellt) VALUES (?,?,?,?,?,?)")
|
||
.run("Zum Bearbeiten", "Ein Text, der nicht verlorengehen darf.",
|
||
"offen", wer, wer, new Date().toISOString());
|
||
dbz.close();
|
||
}
|
||
|
||
await seite.goto(BASIS + "/workspace/aufgaben.html", { waitUntil: "networkidle" });
|
||
await seite.waitForTimeout(900);
|
||
|
||
const auf = async () => {
|
||
await seite.click(".karte, .aufgabe, [data-id]", { timeout: 5000 }).catch(() => {});
|
||
await seite.waitForTimeout(500);
|
||
return seite.evaluate(() =>
|
||
!!document.getElementById("bearbeiten-dialog")?.open);
|
||
};
|
||
|
||
/* Erst über den Bearbeiten-Knopf an der Karte. */
|
||
let offen = await seite.evaluate(() => {
|
||
const k = [...document.querySelectorAll("button")]
|
||
.find((b) => /bearbeiten/i.test(b.textContent || "") || /bearbeiten/i.test(b.title || ""));
|
||
if (k) { k.click(); return true; }
|
||
return false;
|
||
});
|
||
await seite.waitForTimeout(700);
|
||
let istAuf = await seite.evaluate(() =>
|
||
!!document.getElementById("bearbeiten-dialog")?.open);
|
||
if (!istAuf) istAuf = await auf();
|
||
|
||
pruef("der Bearbeiten-Dialog geht auf", istAuf);
|
||
|
||
if (istAuf) {
|
||
/* 1. UNBERÜHRT -> still zu. Das ist der wichtigere Fall: Wer
|
||
nichts getippt hat, darf nichts gefragt werden. */
|
||
await seite.keyboard.press("Escape");
|
||
await seite.waitForTimeout(500);
|
||
const nachEsc = await seite.evaluate(() => ({
|
||
dialogZu: !document.getElementById("bearbeiten-dialog")?.open,
|
||
gefragt: !!document.querySelector("dialog.nachfrage[open]"),
|
||
}));
|
||
pruef("unberührt geht er ohne Nachfrage zu", nachEsc.dialogZu && !nachEsc.gefragt,
|
||
`zu: ${nachEsc.dialogZu}, gefragt: ${nachEsc.gefragt}`);
|
||
|
||
/* 2. GETIPPT -> Esc fragt nach. */
|
||
await seite.evaluate(() => {
|
||
const k = [...document.querySelectorAll("button")]
|
||
.find((b) => /bearbeiten/i.test(b.textContent || "") || /bearbeiten/i.test(b.title || ""));
|
||
k?.click();
|
||
});
|
||
await seite.waitForTimeout(600);
|
||
await seite.fill("#b-titel", "Etwas ganz anderes");
|
||
await seite.keyboard.press("Escape");
|
||
await seite.waitForTimeout(600);
|
||
const nachTippen = await seite.evaluate(() => ({
|
||
nochOffen: !!document.getElementById("bearbeiten-dialog")?.open,
|
||
gefragt: !!document.querySelector("dialog.nachfrage[open]"),
|
||
text: document.querySelector('dialog.nachfrage [data-teil="was"]')?.textContent || "",
|
||
}));
|
||
pruef("nach einer Änderung fragt Esc nach", nachTippen.gefragt,
|
||
`gefragt: ${nachTippen.gefragt}`);
|
||
pruef("und der Dialog bleibt solange offen", nachTippen.nochOffen);
|
||
pruef("die Frage sagt, was verloren geht",
|
||
/verloren/i.test(nachTippen.text), nachTippen.text);
|
||
|
||
/* 3. „Weiter bearbeiten" -> der Text steht noch da. */
|
||
await seite.click('dialog.nachfrage [data-teil="nein"]');
|
||
await seite.waitForTimeout(500);
|
||
const nachWeiter = await seite.evaluate(() => ({
|
||
nochOffen: !!document.getElementById("bearbeiten-dialog")?.open,
|
||
titel: document.getElementById("b-titel")?.value || "",
|
||
}));
|
||
pruef("Weiter bearbeiten laesst den Dialog offen", nachWeiter.nochOffen);
|
||
pruef("und der getippte Text steht noch da",
|
||
nachWeiter.titel === "Etwas ganz anderes", `„${nachWeiter.titel}"`);
|
||
|
||
/* 4. DER KNOPF-WEG -- und er muss JEDES MAL fragen.
|
||
----------------------------------------------------------------
|
||
NICHT noch einmal Esc. Gemessen am 20.09.2026: Ein ZWEITES Esc
|
||
hintereinander schliesst den Dialog, egal was die Seite tut.
|
||
Das ist Chromiums „close watcher": Eine Seite darf den Nutzer
|
||
nicht mit Esc einsperren. Die Regel ist richtig, und dagegen
|
||
anzubauen waere falsch -- also wird sie hier festgehalten statt
|
||
umgangen.
|
||
|
||
Der Knopf unterliegt ihr nicht. Er ist auch der Weg, den man am
|
||
Handy nimmt, wo es kein Esc gibt. */
|
||
await seite.click("#b-abbrechen");
|
||
await seite.waitForTimeout(600);
|
||
const nachKnopf = await seite.evaluate(() => ({
|
||
nochOffen: !!document.getElementById("bearbeiten-dialog")?.open,
|
||
gefragt: !!document.querySelector("dialog.nachfrage[open]"),
|
||
}));
|
||
pruef("auch der Abbrechen-Knopf fragt nach",
|
||
nachKnopf.gefragt && nachKnopf.nochOffen,
|
||
`gefragt: ${nachKnopf.gefragt}, noch offen: ${nachKnopf.nochOffen}`);
|
||
|
||
await seite.click('dialog.nachfrage [data-teil="ja"]', { timeout: 6000 });
|
||
await seite.waitForTimeout(700);
|
||
const nachVerwerfen = await seite.evaluate(() =>
|
||
!document.getElementById("bearbeiten-dialog")?.open);
|
||
pruef('Verwerfen schliesst den Dialog wirklich', nachVerwerfen);
|
||
|
||
/* Und danach ist nichts uebernommen worden -- verwerfen heisst
|
||
verwerfen, nicht speichern. */
|
||
const inListe = await seite.evaluate(() =>
|
||
document.body.textContent.includes("Etwas ganz anderes"));
|
||
pruef("und der verworfene Text steht nirgends in der Liste", !inListe);
|
||
}
|
||
|
||
/* =================================================================
|
||
EIN BILD IM DIALOG (02.10.2026)
|
||
|
||
VanVan (Support): „Wenn man hier im Support auf deine Frage 'geht
|
||
es wieder' reagiert und antwortet, kann man auch kein Bild
|
||
hinzufuegen."
|
||
|
||
Das Feld ist eine OPTION dieses Dialogs, damit Grund und Bild in
|
||
denselben Kasten passen -- zwei Dialoge nacheinander hiessen: Wer
|
||
beim zweiten abbricht, hat den ersten umsonst getippt.
|
||
|
||
GEPRUEFT WIRD DER MECHANISMUS, NICHT DIE SUPPORTSEITE. Der Dialog
|
||
wird hier direkt aufgerufen; dass die Supportseite ihn mit `bild`
|
||
aufruft, steht weiter oben in der Dateiprüfung. Beides zusammen
|
||
deckt den Weg ab, und keins von beidem braucht eine Meldung im
|
||
Zustand „wartet", die diese Pruefung erst herstellen muesste.
|
||
|
||
DIE VORGABE IST AUS, und das ist die wichtigste Zeile hier: Ohne
|
||
sie bekaemen die 56 anderen Rueckfragen im Haus ein Bildfeld,
|
||
nach dem niemand gefragt hat. */
|
||
console.log("\n --- Ein Bild im Dialog ---");
|
||
{
|
||
/* OHNE `bild` DARF NICHTS DASTEHEN. */
|
||
await seite.evaluate(() => {
|
||
window.__probe = window.frageNach({ titel: "Ohne Bild", grund: "Warum?" });
|
||
});
|
||
await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 6000 });
|
||
const ohne = await seite.evaluate(() => {
|
||
const z = document.querySelector('dialog.nachfrage [data-teil="bildzeile"]');
|
||
return { da: !!z, versteckt: !!z && z.hidden };
|
||
});
|
||
pruef("ohne Angabe bleibt die Bildzeile verborgen",
|
||
ohne.da && ohne.versteckt);
|
||
await seite.click('dialog.nachfrage [data-teil="nein"]');
|
||
await seite.waitForTimeout(400);
|
||
|
||
/* MIT `bild` IST SIE DA -- und liefert die Datei zurueck. */
|
||
await seite.evaluate(() => {
|
||
window.__probe = window.frageNach({
|
||
titel: "Mit Bild", ja: "Senden",
|
||
grund: "Was geht noch nicht?", grundPflicht: true, grundMin: 3,
|
||
bild: "Bildschirmfoto dazu (freiwillig)",
|
||
});
|
||
});
|
||
await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 6000 });
|
||
const mit = await seite.evaluate(() => {
|
||
const z = document.querySelector('dialog.nachfrage [data-teil="bildzeile"]');
|
||
const k = document.querySelector('dialog.nachfrage [data-teil="bildwaehlen"]');
|
||
const r = k ? k.getBoundingClientRect() : null;
|
||
return {
|
||
sichtbar: !!z && !z.hidden,
|
||
schild: document.querySelector('dialog.nachfrage [data-teil="bildschild"]')
|
||
?.textContent || "",
|
||
knopfHoch: r ? Math.round(r.height) : 0,
|
||
/* „Noch keins gewählt" statt einer leeren Zeile: Wer nichts
|
||
sieht, weiss nicht, ob er etwas vergessen hat. */
|
||
name: document.querySelector('dialog.nachfrage [data-teil="bildname"]')
|
||
?.textContent || "",
|
||
wegVerborgen: document.querySelector('dialog.nachfrage [data-teil="bildweg"]')?.hidden,
|
||
};
|
||
});
|
||
pruef("mit Angabe steht die Bildzeile da", mit.sichtbar);
|
||
pruef(` mit der Beschriftung aus dem Aufruf („${mit.schild}")`,
|
||
/Bildschirmfoto/.test(mit.schild));
|
||
pruef(` der Knopf ist ${mit.knopfHoch} px hoch (Fingermass 44)`,
|
||
mit.knopfHoch >= 44);
|
||
pruef(` und es steht da, dass noch keins gewählt ist („${mit.name}")`,
|
||
/Noch keins/.test(mit.name));
|
||
pruef(" der Entfernen-Knopf ist noch verborgen", mit.wegVerborgen === true);
|
||
|
||
/* EIN BILD WAEHLEN -- mit einer echten Datei, nicht mit einem
|
||
vorgetaeuschten Ereignis. */
|
||
await seite.setInputFiles("dialog.nachfrage #nachfrage-bild", {
|
||
name: "bildschirm.png", mimeType: "image/png", buffer: PNG_PROBE,
|
||
});
|
||
await seite.waitForTimeout(400);
|
||
const gewaehlt = await seite.evaluate(() => {
|
||
/* EIN KASTEN MIT EINER LISTE statt eines einzelnen <img>
|
||
(02.10.2026): Seit VanVans Meldung #11 koennen es bis zu
|
||
drei sein, und `bildMax` entscheidet, wie viele. */
|
||
const kasten = document.querySelector('dialog.nachfrage [data-teil="bildvorschauen"]');
|
||
const schau = kasten?.querySelector("img") || null;
|
||
return {
|
||
name: document.querySelector('dialog.nachfrage [data-teil="bildname"]')
|
||
?.textContent || "",
|
||
wegDa: document.querySelector('dialog.nachfrage [data-teil="bildweg"]')?.hidden === false,
|
||
vorschau: !!kasten && !kasten.hidden && !!schau
|
||
&& (schau.getAttribute("src") || "").length > 0,
|
||
hoch: schau ? Math.round(schau.getBoundingClientRect().height) : 0,
|
||
};
|
||
});
|
||
pruef(` nach der Wahl steht der Name da („${gewaehlt.name}")`,
|
||
/bildschirm\.png/.test(gewaehlt.name));
|
||
pruef(" der Entfernen-Knopf erscheint", gewaehlt.wegDa);
|
||
/* WER SIEHT, WAS ER ANHAENGT, haengt seltener das falsche Bild an
|
||
-- dieselbe Ueberlegung wie beim Melden. */
|
||
pruef(" und eine Vorschau ist da", gewaehlt.vorschau);
|
||
|
||
/* ==== UND JETZT MIT EINEM HOHEN BILD =========================
|
||
|
||
Hier stand die Grenze zuerst am 1x1-Bild von oben gemessen:
|
||
„3 px, hoechstens 160". Das ist gruen und wertlos -- ein ein
|
||
Pixel hohes Bild kann keine Obergrenze ueberschreiten. Genau
|
||
die Sorte Haken, vor der die Hausregeln warnen.
|
||
|
||
Ein hochkantes Bildschirmfoto vom Handy ist der echte Fall:
|
||
Ohne Deckel waere es hoeher als der ganze Dialog, und die
|
||
Knoepfe darunter waeren nicht mehr zu sehen. Das Bild entsteht
|
||
im Browser (300x900) und kommt als ECHTE Datei in das Feld --
|
||
mit `DataTransfer`, nicht mit einem vorgetaeuschten Ereignis. */
|
||
const hoch = await seite.evaluate(async () => {
|
||
const c = document.createElement("canvas");
|
||
c.width = 300; c.height = 900;
|
||
const g = c.getContext("2d");
|
||
g.fillStyle = "#2b6cb0"; g.fillRect(0, 0, c.width, c.height);
|
||
const blob = await new Promise((r) => c.toBlob(r, "image/png"));
|
||
const dt = new DataTransfer();
|
||
dt.items.add(new File([blob], "hochkant.png", { type: "image/png" }));
|
||
const feld = document.querySelector("dialog.nachfrage #nachfrage-bild");
|
||
feld.files = dt.files;
|
||
feld.dispatchEvent(new Event("change", { bubbles: true }));
|
||
await new Promise((r) => setTimeout(r, 300));
|
||
const schau = document.querySelector('dialog.nachfrage .nachfrage__vorschau img');
|
||
const dlg = document.querySelector("dialog.nachfrage");
|
||
const ja = document.querySelector('dialog.nachfrage [data-teil="ja"]');
|
||
const r = schau.getBoundingClientRect();
|
||
return {
|
||
echt: schau.naturalHeight,
|
||
gezeigt: Math.round(r.height),
|
||
breit: Math.round(r.width),
|
||
/* DER EIGENTLICHE PUNKT: Der Senden-Knopf muss noch im Fenster
|
||
stehen. Eine Obergrenze ist kein Selbstzweck. */
|
||
jaImFenster: (() => {
|
||
const j = ja.getBoundingClientRect();
|
||
return j.bottom <= window.innerHeight && j.height > 0;
|
||
})(),
|
||
dialogHoch: Math.round(dlg.getBoundingClientRect().height),
|
||
};
|
||
});
|
||
/* 120 STATT 160 SEIT DEM 02.10.2026. Der Deckel ist gesunken,
|
||
weil in dem Kasten jetzt bis zu drei Bilder nebeneinander
|
||
stehen koennen -- bei 160 waere der Senden-Knopf bei drei
|
||
hochkanten Bildern aus dem Fenster. Die Zahl steht in
|
||
module.css und wird hier nachgemessen, nicht geraten. */
|
||
pruef(` ein 300x900 grosses Bild wird auf ${hoch.gezeigt} px gedeckelt`
|
||
+ ` (echt ${hoch.echt}, höchstens 120)`,
|
||
hoch.echt === 900 && hoch.gezeigt > 0 && hoch.gezeigt <= 120);
|
||
pruef(` und es bleibt in der Breite (${hoch.breit} px)`, hoch.breit <= 300);
|
||
pruef(` der Senden-Knopf steht weiter im Fenster (Dialog ${hoch.dialogHoch} px)`,
|
||
hoch.jaImFenster);
|
||
|
||
await seite.fill("dialog.nachfrage #nachfrage-grund", "Geht noch nicht, siehe Bild.");
|
||
await seite.click('dialog.nachfrage [data-teil="ja"]');
|
||
await seite.waitForTimeout(500);
|
||
const erg = await seite.evaluate(async () => {
|
||
const a = await window.__probe;
|
||
/* `bilder` UND NICHT `bild` (02.10.2026): Der Dialog gibt
|
||
immer eine Liste zurueck, auch wenn nur eines erlaubt war.
|
||
Ein Sonderfall „genau eines" waere die zweite Auskunft auf
|
||
dieselbe Frage -- und die veraltet. */
|
||
const eins = a && Array.isArray(a.bilder) ? a.bilder[0] : null;
|
||
return {
|
||
grund: a && a.grund,
|
||
anzahl: a && Array.isArray(a.bilder) ? a.bilder.length : -1,
|
||
bildName: eins ? eins.name : null,
|
||
bildTyp: eins ? eins.type : null,
|
||
istDatei: !!(eins && typeof eins.size === "number"),
|
||
};
|
||
});
|
||
pruef(`der Dialog gibt den Grund zurück („${erg.grund}")`,
|
||
/siehe Bild/.test(erg.grund || ""));
|
||
pruef(` er gibt eine LISTE zurueck, nicht ein Feld (${erg.anzahl})`,
|
||
erg.anzahl === 1);
|
||
pruef(` und die Datei dazu (${erg.bildName}, ${erg.bildTyp})`,
|
||
/* und nicht : Zwei Zeilen
|
||
weiter oben wurde das Bild ERSETZT. Meine erste Fassung
|
||
erwartete noch das erste und wurde rot -- die Pruefung
|
||
hatte recht, die Erwartung war veraltet. */
|
||
erg.istDatei && erg.bildName === "hochkant.png" && erg.bildTyp === "image/png");
|
||
|
||
/* GEGENPROBE: Abbrechen gibt gar nichts zurueck -- auch nicht das
|
||
Bild. Ohne diese Zeile koennte ein Abbruch trotzdem etwas
|
||
hochladen. */
|
||
await seite.evaluate(() => {
|
||
window.__probe2 = window.frageNach({
|
||
titel: "Abbrechen", grund: "Warum?", bild: "Bild dazu",
|
||
});
|
||
});
|
||
await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 6000 });
|
||
await seite.setInputFiles("dialog.nachfrage #nachfrage-bild", {
|
||
name: "egal.png", mimeType: "image/png", buffer: PNG_PROBE,
|
||
});
|
||
await seite.waitForTimeout(300);
|
||
await seite.click('dialog.nachfrage [data-teil="nein"]');
|
||
await seite.waitForTimeout(400);
|
||
const abbruch = await seite.evaluate(async () => await window.__probe2);
|
||
pruef("Gegenprobe: Abbrechen gibt nichts zurück, auch kein Bild",
|
||
abbruch === false);
|
||
|
||
/* UND JEDES OEFFNEN FAENGT LEER AN. Ohne das haengt beim zweiten
|
||
Mal noch das Bild vom ersten dran -- und niemand sieht es,
|
||
weil der Dialog oben schon zu war. */
|
||
await seite.evaluate(() => {
|
||
window.__probe3 = window.frageNach({
|
||
titel: "Nochmal", grund: "Warum?", bild: "Bild dazu",
|
||
});
|
||
});
|
||
await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 6000 });
|
||
const frisch = await seite.evaluate(() =>
|
||
document.querySelector('dialog.nachfrage [data-teil="bildname"]')?.textContent || "");
|
||
pruef(` und beim nächsten Öffnen ist es leer („${frisch}")`,
|
||
/Noch keins/.test(frisch));
|
||
await seite.click('dialog.nachfrage [data-teil="nein"]');
|
||
await seite.waitForTimeout(300);
|
||
|
||
/* ==== UND MIT `bildMax` SIND ES MEHRERE (02.10.2026) =========
|
||
|
||
VanVan im Support, Meldung #11: „2-3 wären besser." Der
|
||
Dialog kann das seither; ohne Angabe bleibt es bei einem,
|
||
damit sich fuer jeden anderen Aufruf im Haus nichts aendert.
|
||
|
||
DER UNTERSCHIED ZUM FALL DARUEBER IST DER PUNKT: Dort hat die
|
||
zweite Wahl die erste ERSETZT (ein Platz, eine Korrektur),
|
||
hier muss sie DAZUKOMMEN. Beides in derselben Pruefung, sonst
|
||
beweist keines etwas. */
|
||
await seite.evaluate(() => {
|
||
window.__probe4 = window.frageNach({
|
||
titel: "Mit dreien", ja: "Senden",
|
||
grund: "Was geht noch nicht?", grundPflicht: true, grundMin: 3,
|
||
bild: "Bildschirmfotos dazu (freiwillig)", bildMax: 3,
|
||
});
|
||
});
|
||
await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 6000 });
|
||
const zaehl = () => seite.evaluate(() =>
|
||
document.querySelectorAll("dialog.nachfrage .nachfrage__vorschau").length);
|
||
for (const name of ["a.png", "b.png", "c.png", "d.png"]) {
|
||
await seite.setInputFiles("dialog.nachfrage #nachfrage-bild", {
|
||
name, mimeType: "image/png", buffer: PNG_PROBE,
|
||
});
|
||
await seite.waitForTimeout(250);
|
||
}
|
||
const dreiDa = await zaehl();
|
||
pruef(`mit bildMax 3 legt jede Wahl DAZU (${dreiDa} nach vier Griffen)`,
|
||
dreiDa === 3);
|
||
const grenzWort = await seite.evaluate(() =>
|
||
document.querySelector('dialog.nachfrage [data-teil="fehler"]')?.textContent || "");
|
||
pruef(` und das vierte wird mit einem Satz abgelehnt („${grenzWort}")`,
|
||
/3 Bilder/.test(grenzWort));
|
||
|
||
/* EINZELN WEGNEHMEN, nicht alles. */
|
||
await seite.click("dialog.nachfrage .nachfrage__vorschau:nth-child(2) "
|
||
+ ".nachfrage__vorschau-weg");
|
||
await seite.waitForTimeout(200);
|
||
pruef(` eines einzeln entfernen laesst die anderen stehen (${await zaehl()})`,
|
||
await zaehl() === 2);
|
||
|
||
await seite.fill("dialog.nachfrage #nachfrage-grund", "Hier zwei Bilder dazu.");
|
||
await seite.click('dialog.nachfrage [data-teil="ja"]');
|
||
await seite.waitForTimeout(400);
|
||
const viele = await seite.evaluate(async () => {
|
||
const a = await window.__probe4;
|
||
return (a && Array.isArray(a.bilder)) ? a.bilder.map((b) => b.name) : null;
|
||
});
|
||
pruef(` und der Dialog gibt beide zurueck (${(viele || []).join(", ")})`,
|
||
Array.isArray(viele) && viele.length === 2
|
||
&& viele[0] === "a.png" && viele[1] === "c.png");
|
||
}
|
||
|
||
pruef("keine Abstürze im Browser", abstuerze.length === 0, abstuerze[0] || "");
|
||
|
||
await browser.close();
|
||
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
|
||
}
|
||
|
||
console.log(`\n ${ok} bestanden, ${fehl} fehlgeschlagen`);
|
||
console.log(` (${gezaehlt} Rückfragen in ${nutzer.size} Dateien, `
|
||
+ `${mitNutzung} Seiten)\n`);
|
||
process.exit(fehl ? 1 : 0);
|