Kennzahlen werden Wege, Team wird sichtbar, Felder bekommen ein Aussehen
Vier Wuensche vom 01.09.2026, dazu ein gemeldeter Fehler.
SCREEN 1 -- "wenn man auf die Kisten drueckt, sofort zu der Seite,
diesem Punkt". Jede Kennzahl im Bericht fuehrt jetzt dorthin, wo die
gezaehlten Dinge stehen: nicht nur auf die richtige Seite, sondern auf
die richtige Stelle (?zeigen=...). Ein gemeinsamer Helfer in kopf.js,
damit nicht jede Seite ihr eigenes Sprungverhalten erfindet.
Auf dem Aufgabenbrett wird HERVORGEHOBEN, nicht gefiltert -- das Brett
lebt davon, dass man die vier Spalten nebeneinander sieht. Bei den
Dateien wird gefiltert, denn die Seite hat ohnehin eine Filterleiste,
und deren Knoepfe zeigen dann mit an, wo man steht. Der Kalender
schaltet auf die Liste um: In der Monatsansicht liesse sich
"vergangen" gar nicht sinnvoll markieren.
Immer mit einem Weg zurueck ("Alles zeigen"), der auch den Parameter
aus der Adresse nimmt. Eine Seite, die gefiltert bleibt, ist eine
Falle: Man kommt spaeter wieder, sieht drei von zwanzig Aufgaben und
haelt das fuer den Bestand.
Drei Entscheidungen gegen den ersten Entwurf:
* KEIN ?creator= im Verweis. Das sah hilfreich aus und waere eine
Luege gewesen -- keine Zielseite liest den Wert.
* Kisten mit Null fuehren NIRGENDWOHIN. Ein Weg zu null Dingen ist
eine Enttaeuschung, kein Angebot.
* "neu angelegt" fuehrt ohne Ausschnitt aufs Brett: Der Bericht zaehlt
einen Zeitraum, das Brett kennt keinen. Eine Hervorhebung, die nicht
dieselbe Menge trifft, ist schlimmer als keine.
SCREEN 2 -- "ich will, dass wir Manager, Scouts, DogFather auch die
Fotos, Namen und so alles sehen". Der Steckbrief war eine Einbahnstrasse:
Jeder pflegte seinen, niemand bekam ihn je zu Gesicht. Die
Schnittstelle dafuer lag fertig da und wurde von keiner Seite
aufgerufen. Jetzt steht "Das Team" auf steckbrief.html und (fuer
Creator) auf profil.html -- nach Rollen gruppiert, mit Bild, Rolle,
eigenem Satz und Kanaelen. Wer wen sieht, entscheidet weiterhin der
Server; ein Creator sieht seine Betreuung, nicht die anderen Creator.
SCREEN 4 -- "das soll richtig geil aussehen und nicht so einfach, auch
die Schrift". Die Ursache war kein Geschmack, sondern ein Loch im
Aufbau: Jede Seite gestaltete ihre Felder mit einem EIGENEN Selektor,
und wer ein Feld anderswo hinsetzt, faellt durch alle Netze. Genau so
stand "Ein Satz ueber dich" als grauer Kasten in MONOSPACE da --
<textarea> faellt ohne `font: inherit` auf Schreibmaschinenschrift
zurueck. Jetzt gibt es eine Grundlage fuer jedes Feld, und die drei
wortgleichen Kopien in aufgaben/profil/bereich sind weg.
Der erste Anlauf setzte dort auch `width: 100%` -- die Pruefung
meldete sofort Felder von 28 statt 362 Pixeln. Breite ist LAYOUT und
gehoert der Seite; eine Grundlage mit Staerke null verliert jeden
Breitenstreit, also darf sie ihn nicht anfangen.
SCREEN 5 -- "wieso seh ich mein Bild da nicht?" Ein lehrreicher Fehler:
Der Server liefert das Bild laengst mit, und im Quelltext dort steht
ausdruecklich "es steht in der Kopfleiste JEDER Seite UND IN DER
BEGRUESSUNG". Die Absicht war aufgeschrieben, die Haelfte nie gebaut --
und aufgefallen ist es nicht, weil ein Buchstabe im Kreis nicht falsch
aussieht, nur eben nicht wie man selbst.
PRUEFUNGEN. Zwei neue (pruef-sprung, pruef-team), eine erweiterte
(pruef-formulare). Sie haben vier echte Fehler gefunden, die mit blossem
Auge nicht zu sehen waren:
* Der Sprung auf "dringend" hob auch ERLEDIGTE dringende Eintraege
hervor -- man klickt auf "2" und bekommt drei markiert.
* Auf einer leeren Zielseite erschien gar keine Erklaerung (frueher
Ausstieg uebersprang sie). Das ist der wichtigere Fall: Wer auf eine
Zahl klickt und im Leeren landet, glaubt, er sei falsch abgebogen.
* Das Kachel-Merkzeichen stiess mit der Zahl zusammen.
* Die Feldpruefung fand vier RICHTIGE Felder falsch (die Kanaele holen
ihren Rahmen vom Umschlag mit dem "@"). Eine Pruefung, die
Richtiges anmahnt, gewoehnt man sich ab zu lesen.
Und zwei Faelle, in denen die Pruefung sich selbst belogen haette: null
gefundene Felder galten als "in Ordnung", und der Ueberdeckungsvergleich
war nach einer Aenderung ohne ein einziges Vergleichselement gruen.
Beide zaehlen jetzt mit, wie viel sie tatsaechlich angesehen haben.
Co-Authored-By: Claude Opus 5 <[email protected]>
This commit is contained in:
Claude Opus 5
@@ -54,6 +54,14 @@ const salt = randomBytes(16).toString("hex");
|
||||
const hash = scryptSync("CODE-DOGI-0001", salt, 64, { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
|
||||
d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
|
||||
.run("Filipe", "admin", hash, salt, 32768, new Date().toISOString());
|
||||
/* EIN CREATOR MUSS DA SEIN. Ohne ihn bauen profil.html und
|
||||
startcheck.html ihr Formular gar nicht erst auf -- die Pruefung findet
|
||||
dort null Felder und meldet "in Ordnung", ohne ein einziges angesehen
|
||||
zu haben. Genau deshalb steht die Anzahl in der Bedingung. */
|
||||
const salt2 = randomBytes(16).toString("hex");
|
||||
const hash2 = scryptSync("CODE-ANNA-0001", salt2, 64, { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
|
||||
d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
|
||||
.run("Tili", "creator", hash2, salt2, 32768, new Date().toISOString());
|
||||
d.close();
|
||||
|
||||
const { chromium } = await import(
|
||||
@@ -141,6 +149,128 @@ for (const [breite, wie] of [[1280, "Computer"], [390, "Handy"]]) {
|
||||
await kontext.close();
|
||||
}
|
||||
|
||||
/* =====================================================================
|
||||
KEIN FELD OHNE GESTALTUNG (01.09.2026)
|
||||
|
||||
Der gemeldete Fehler: Das Feld "Ein Satz ueber dich" stand als grauer
|
||||
Kasten in Monospace da, direkt neben gestalteten Feldern. Die Ursache
|
||||
war ein Loch im Aufbau -- jede Seite gestaltete ihre Felder mit einem
|
||||
EIGENEN Selektor (.gruppe textarea, .neu input, ...), und wer ein Feld
|
||||
irgendwo anders hinsetzt, faellt durch alle Netze.
|
||||
|
||||
Ein Loch im Aufbau schliesst man nicht mit Hinsehen: Das naechste neue
|
||||
Feld faellt an einer anderen Stelle durch. Diese Pruefung geht deshalb
|
||||
ueber JEDES sichtbare Feld auf JEDER Seite und misst, was der Browser
|
||||
tatsaechlich zeichnet.
|
||||
|
||||
Die Merkmale sind genau die, die im gemeldeten Fall fehlten:
|
||||
RAHMEN ohne Rand ist ein Feld im dunklen Entwurf nicht zu sehen
|
||||
ECKEN eckig heisst: der Browser hat gezeichnet, nicht wir
|
||||
SCHRIFT <textarea> faellt ohne `font: inherit` auf Monospace
|
||||
===================================================================== */
|
||||
console.log("\n=== Kein Feld ohne Gestaltung");
|
||||
{
|
||||
const kontext = await browser.newContext({ viewport: { width: 1280, height: 1100 } });
|
||||
const seite = await kontext.newPage();
|
||||
await seite.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
|
||||
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: 15000 });
|
||||
|
||||
let gesamt = 0;
|
||||
for (const pfad of ["steckbrief.html", "profil.html", "aufgaben.html", "kalender.html",
|
||||
"dateien.html", "bereich.html?b=live", "content.html",
|
||||
"personen.html", "startcheck.html", "report.html"]) {
|
||||
await seite.goto(BASIS + "/workspace/" + pfad, { waitUntil: "networkidle" });
|
||||
await seite.waitForTimeout(900);
|
||||
/* Zugeklappte Formulare aufmachen -- sonst pruefen wir genau die
|
||||
Felder nicht, die selten jemand sieht und die deshalb ungestaltet
|
||||
bleiben. */
|
||||
for (const w of ["#neu-oeffnen", "#neu-auf", "#anlegen-auf"]) {
|
||||
try { await seite.click(w, { timeout: 500 }); } catch { /* gibt es hier nicht */ }
|
||||
}
|
||||
await seite.waitForTimeout(400);
|
||||
|
||||
const r = await seite.evaluate(() => {
|
||||
const felder = [...document.querySelectorAll(
|
||||
'.inhalt input:not([type=file]):not([type=checkbox]):not([type=radio]), '
|
||||
+ '.inhalt textarea, .inhalt select')]
|
||||
.filter((e) => e.getBoundingClientRect().width > 0);
|
||||
const schlecht = [];
|
||||
for (const e of felder) {
|
||||
const st = getComputedStyle(e);
|
||||
/* MANCHE FELDER HOLEN IHREN RAHMEN VOM UMSCHLAG, und das ist
|
||||
richtig so: Bei den Kanaelen steht ein festes "@" vor dem Feld,
|
||||
beide zusammen liegen in einem gemeinsamen Rahmen. Das Feld
|
||||
selbst hat dort absichtlich keinen -- zwei Rahmen ineinander
|
||||
saehen aus wie ein Fehler.
|
||||
|
||||
Der erste Anlauf dieser Pruefung meldete genau diese vier als
|
||||
kaputt. Sie war damit eine Pruefung, die Richtiges anmahnt --
|
||||
und die gewoehnt man sich ab zu lesen. Gemessen wird deshalb
|
||||
der RAHMEN, der um das Feld herum tatsaechlich sichtbar ist,
|
||||
egal ob er am Feld selbst oder am Umschlag haengt. */
|
||||
const umschlag = e.parentElement;
|
||||
const us = umschlag ? getComputedStyle(umschlag) : null;
|
||||
const rahmenAmUmschlag = !!us && parseFloat(us.borderTopWidth) >= 1
|
||||
&& parseFloat(us.borderTopLeftRadius) >= 4;
|
||||
const grund = [];
|
||||
if (!rahmenAmUmschlag) {
|
||||
if (parseFloat(st.borderTopWidth) < 1) grund.push("kein Rand");
|
||||
if (parseFloat(st.borderTopLeftRadius) < 4) grund.push("eckig");
|
||||
if (parseFloat(st.paddingLeft) < 6) grund.push("keine Polsterung");
|
||||
}
|
||||
/* Die Schrift gilt IMMER -- ein Umschlag kann sie nicht liefern. */
|
||||
if (/mono|courier/i.test(st.fontFamily)) grund.push("Monospace");
|
||||
if (parseFloat(st.fontSize) < 12) grund.push("Schrift " + st.fontSize);
|
||||
if (grund.length) schlecht.push((e.id || e.tagName) + " – " + grund.join(", "));
|
||||
}
|
||||
return { anzahl: felder.length, schlecht };
|
||||
});
|
||||
gesamt += r.anzahl;
|
||||
/* DIE ANZAHL GEHOERT IN DIE BEDINGUNG, nicht nur in den Meldetext:
|
||||
Eine Seite ohne gefundene Felder waere sonst "in Ordnung". */
|
||||
const gut = r.anzahl > 0 && r.schlecht.length === 0;
|
||||
if (!gut) fehler++;
|
||||
console.log(` ${gut ? "ok " : "FEHL"} ${pfad.padEnd(22)}${r.anzahl} Felder`
|
||||
+ (r.schlecht.length ? " -> " + r.schlecht.join(" | ")
|
||||
: (r.anzahl ? "" : " KEIN FELD GEFUNDEN – die Pruefung hat nichts geprueft")));
|
||||
}
|
||||
ok(gesamt >= 40, `insgesamt ${gesamt} Felder gemessen`);
|
||||
|
||||
/* GEGENPROBE: Kann diese Pruefung ueberhaupt anschlagen? Ein Feld wird
|
||||
absichtlich auf den Rohzustand des Browsers zurueckgesetzt -- sie MUSS
|
||||
es melden. Ohne diesen Nachweis waere sie eine Pruefung, die immer
|
||||
bestaetigt, und die bestaetigt nichts. */
|
||||
await seite.goto(BASIS + "/workspace/steckbrief.html", { waitUntil: "networkidle" });
|
||||
await seite.waitForTimeout(900);
|
||||
const gegen = await seite.evaluate(() => {
|
||||
const e = document.getElementById("sb-ueber");
|
||||
const vorher = getComputedStyle(e);
|
||||
const gut = parseFloat(vorher.borderTopLeftRadius) >= 4
|
||||
&& !/mono|courier/i.test(vorher.fontFamily);
|
||||
e.style.all = "revert";
|
||||
const st = getComputedStyle(e);
|
||||
return {
|
||||
vorherGut: gut,
|
||||
ecken: parseFloat(st.borderTopLeftRadius),
|
||||
schrift: st.fontFamily,
|
||||
erkannt: parseFloat(st.borderTopLeftRadius) < 4 || /mono|courier/i.test(st.fontFamily),
|
||||
};
|
||||
});
|
||||
ok(gegen.vorherGut === true,
|
||||
"das gemeldete Feld 'Ein Satz ueber dich' ist gestaltet (runde Ecken, keine Monospace)");
|
||||
ok(gegen.erkannt === true,
|
||||
`Gegenprobe: ein zurueckgesetztes Feld wird erkannt `
|
||||
+ `(Ecken ${gegen.ecken}px, Schrift ${gegen.schrift})`);
|
||||
|
||||
await seite.goto(BASIS + "/workspace/steckbrief.html", { waitUntil: "networkidle" });
|
||||
await seite.waitForTimeout(900);
|
||||
await seite.screenshot({ path: "pruef-felder.png", fullPage: false });
|
||||
await kontext.close();
|
||||
}
|
||||
|
||||
await browser.close();
|
||||
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
|
||||
console.log(fehler ? `\n${fehler} Formular(e) fehlerhaft.` : "\nAlles in Ordnung.");
|
||||
|
||||
@@ -0,0 +1,334 @@
|
||||
/* Prueft den Sprung vom Bericht zu der Stelle, die eine Zahl zaehlt.
|
||||
|
||||
Wunsch vom 01.09.2026: "auf dieser Seite will ich, dass wenn man auf
|
||||
die Kisten drueckt, sofort zu der Seite -- diesem Punkt --
|
||||
weitergeschickt wird, wo man draufgedrueckt hat."
|
||||
|
||||
WAS HIER WIRKLICH SCHIEFGEHEN KANN, und warum diese Pruefung so
|
||||
ausfuehrlich ist:
|
||||
|
||||
1. Ein Verweis, der irgendwohin fuehrt. "aufgaben.html" statt
|
||||
"aufgaben.html?zeigen=ueberfaellig" faellt niemandem auf -- man
|
||||
landet ja auf der richtigen Seite. Nur eben nicht an der Stelle.
|
||||
Geprueft wird deshalb die ADRESSE jeder einzelnen Kiste.
|
||||
|
||||
2. Ein Ausschnitt, aus dem man nicht mehr herauskommt. Bleibt die
|
||||
Zielseite gefiltert, sieht man beim naechsten Besuch drei von
|
||||
zwanzig Aufgaben und haelt das fuer den ganzen Bestand. Geprueft
|
||||
wird, dass "Alles zeigen" wirklich alles zurueckbringt UND den
|
||||
Parameter aus der Adresse nimmt.
|
||||
|
||||
3. Eine Hervorhebung, die das Falsche trifft. Deshalb wird gezaehlt:
|
||||
Die Zahl der hervorgehobenen Karten muss zu dem passen, was
|
||||
angelegt wurde -- nicht "mehr als null".
|
||||
|
||||
4. Eine Pruefung, die immer bestaetigt. Zu jedem Sprung gehoert
|
||||
deshalb eine GEGENPROBE: dieselbe Seite OHNE Parameter darf
|
||||
nichts hervorheben und keine Leiste zeigen. */
|
||||
|
||||
import { mkdtempSync, rmSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
|
||||
const ordner = mkdtempSync(join(tmpdir(), "ws-sprung-"));
|
||||
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
|
||||
process.env.PORT = "4212";
|
||||
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 }); };
|
||||
await import("./index.js");
|
||||
await new Promise((r) => setTimeout(r, 700));
|
||||
const BASIS = "http://127.0.0.1:4212";
|
||||
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 300_000).unref?.();
|
||||
|
||||
let fehler = 0;
|
||||
const ok = (b, t) => { console.log((b ? " ok " : " FEHL ") + t); if (!b) fehler++; };
|
||||
|
||||
await fetch(BASIS + "/workspace/api/anmelden", {
|
||||
method: "POST", headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});
|
||||
|
||||
const { DatabaseSync } = await import("node:sqlite");
|
||||
const { scryptSync, randomBytes } = await import("node:crypto");
|
||||
for (let i = 0; i < 60; i++) {
|
||||
try {
|
||||
const p = new DatabaseSync(process.env.WORKSPACE_DB);
|
||||
try { p.prepare("SELECT 1 FROM personen LIMIT 1").get(); break; } finally { p.close(); }
|
||||
} catch { await new Promise((r) => setTimeout(r, 250)); }
|
||||
}
|
||||
const d = new DatabaseSync(process.env.WORKSPACE_DB);
|
||||
const jetzt = new Date().toISOString();
|
||||
const heute = jetzt.slice(0, 10);
|
||||
const gestern = new Date(Date.now() - 86400_000).toISOString().slice(0, 10);
|
||||
const morgen = new Date(Date.now() + 86400_000).toISOString().slice(0, 10);
|
||||
|
||||
function anlegen(name, rolle, code) {
|
||||
const salt = randomBytes(16).toString("hex");
|
||||
const hash = scryptSync(code, salt, 64, { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
|
||||
d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
|
||||
.run(name, rolle, hash, salt, 32768, jetzt);
|
||||
return d.prepare("SELECT last_insert_rowid() AS id").get().id;
|
||||
}
|
||||
const idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
|
||||
const idTili = anlegen("Tili", "creator", "CODE-ANNA-0001");
|
||||
|
||||
/* ---- Ein Bestand mit BEKANNTEN Zahlen. Nur so kann die Pruefung
|
||||
sagen "genau drei" statt "mehr als null". ---- */
|
||||
const AUFG = { offen: 3, arbeit: 1, review: 2, erledigt: 4 };
|
||||
let nr = 0;
|
||||
for (const [status, anzahl] of Object.entries(AUFG)) {
|
||||
for (let i = 0; i < anzahl; i++) {
|
||||
d.prepare(`INSERT INTO aufgaben
|
||||
(titel, beschreibung, status, prioritaet, creator_id, verantwortlich_id, erstellt, erstellt_von)
|
||||
VALUES (?,?,?,?,?,?,?,?)`)
|
||||
.run(`Aufgabe ${++nr} (${status})`, "", status, "mittel", idTili, idDogi, jetzt, idDogi);
|
||||
}
|
||||
}
|
||||
/* Zwei ueberfaellige -- eine offene und eine in Arbeit, damit die
|
||||
Hervorhebung SPALTENUEBERGREIFEND geprueft wird. Genau da bricht eine
|
||||
Umsetzung, die nur in einer Spalte sucht. */
|
||||
for (const status of ["offen", "arbeit"]) {
|
||||
d.prepare(`INSERT INTO aufgaben
|
||||
(titel, beschreibung, status, prioritaet, frist, creator_id, verantwortlich_id, erstellt, erstellt_von)
|
||||
VALUES (?,?,?,?,?,?,?,?,?)`)
|
||||
.run(`Laengst faellig (${status})`, "", status, "hoch", gestern, idTili, idDogi, jetzt, idDogi);
|
||||
}
|
||||
const UEBERFAELLIG = 2;
|
||||
/* Eine Frist in der Zukunft und eine erledigte mit alter Frist: Beide
|
||||
duerfen NICHT als ueberfaellig gelten. Ohne sie wuerde eine Umsetzung
|
||||
durchgehen, die schlicht jede Karte mit Frist hervorhebt. */
|
||||
d.prepare(`INSERT INTO aufgaben (titel, beschreibung, status, prioritaet, frist,
|
||||
creator_id, verantwortlich_id, erstellt, erstellt_von) VALUES (?,?,?,?,?,?,?,?,?)`)
|
||||
.run("Frist erst morgen", "", "offen", "mittel", morgen, idTili, idDogi, jetzt, idDogi);
|
||||
d.prepare(`INSERT INTO aufgaben (titel, beschreibung, status, prioritaet, frist,
|
||||
creator_id, verantwortlich_id, erstellt, erstellt_von) VALUES (?,?,?,?,?,?,?,?,?)`)
|
||||
.run("Alte Frist, aber fertig", "", "erledigt", "mittel", gestern, idTili, idDogi, jetzt, idDogi);
|
||||
AUFG.offen += 2; /* die beiden neuen offenen */
|
||||
AUFG.arbeit += 1;
|
||||
AUFG.erledigt += 1;
|
||||
|
||||
/* Bereichseintraege: zwei dringende, einer harmlos. */
|
||||
for (const [titel, dringlich, status] of [
|
||||
["Ton bricht ab", "hoch", "offen"],
|
||||
["Licht zu dunkel", "hoch", "offen"],
|
||||
["Kleinigkeit", "niedrig", "offen"],
|
||||
["Schon erledigt", "hoch", "erledigt"],
|
||||
]) {
|
||||
d.prepare(`INSERT INTO eintraege
|
||||
(bereich, art, titel, text, status, dringlichkeit, datum, creator_id, erstellt, erstellt_von)
|
||||
VALUES ('live','vorbereitung',?,?,?,?,?,?,?,?)`)
|
||||
.run(titel, "", status, dringlich, heute, idTili, jetzt, idDogi);
|
||||
}
|
||||
const DRINGEND_LIVE = 2;
|
||||
const OFFEN_LIVE = 3;
|
||||
d.close();
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
|
||||
const { chromium } = await import(
|
||||
"file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
|
||||
const browser = await chromium.launch();
|
||||
const kontext = await browser.newContext({ viewport: { width: 1280, height: 1000 } });
|
||||
const konsole = [];
|
||||
const seite = await kontext.newPage();
|
||||
seite.on("console", (m) => { if (m.type() === "error") konsole.push(m.text()); });
|
||||
seite.on("pageerror", (e) => konsole.push("pageerror: " + e.message));
|
||||
|
||||
await seite.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
|
||||
await seite.click('.rolle[data-rolle="admin"]');
|
||||
await seite.fill("#code", "CODE-DOGI-0001");
|
||||
await seite.click("button[type=submit]");
|
||||
await seite.waitForURL("**/start.html", { timeout: 15000 });
|
||||
|
||||
/* ================================================================
|
||||
1. Die Kisten im Bericht sind Wege -- mit dem richtigen Ziel
|
||||
================================================================ */
|
||||
console.log("\n=== Die Kisten im Bericht fuehren irgendwohin");
|
||||
await seite.goto(BASIS + "/workspace/report.html", { waitUntil: "networkidle" });
|
||||
await seite.waitForTimeout(1400);
|
||||
|
||||
const kisten = await seite.evaluate(() => [...document.querySelectorAll(".kacheln .kachel")]
|
||||
.map((k) => ({
|
||||
name: k.querySelector(".kachel__name")?.textContent?.trim(),
|
||||
zahl: k.querySelector(".kachel__zahl")?.textContent?.trim(),
|
||||
ziel: k.tagName === "A" ? k.getAttribute("href") : null,
|
||||
beschriftung: k.getAttribute("aria-label") || "",
|
||||
})));
|
||||
|
||||
ok(kisten.length >= 10, `${kisten.length} Kennzahlen auf der Seite`);
|
||||
const mitWeg = kisten.filter((k) => k.ziel);
|
||||
ok(mitWeg.length >= 8, ` davon ${mitWeg.length} mit einem Weg dahinter`);
|
||||
|
||||
/* Die wichtigsten einzeln -- ein Verweis auf die richtige SEITE, aber
|
||||
ohne Stelle, waere sonst nicht zu unterscheiden. */
|
||||
const soll = [
|
||||
["Aufgaben erledigt", "aufgaben.html?zeigen=erledigt"],
|
||||
["Aufgaben offen", "aufgaben.html?zeigen=offen"],
|
||||
["überfällig", "aufgaben.html?zeigen=ueberfaellig"],
|
||||
["Dateien im Review", "dateien.html?zeigen=review"],
|
||||
["Dateien freigegeben", "dateien.html?zeigen=frei"],
|
||||
["Termine gewesen", "kalender.html?zeigen=vergangen"],
|
||||
["Termine stehen an", "kalender.html?zeigen=kommend"],
|
||||
["dringende Punkte", "bereich.html?b=live&zeigen=dringend"],
|
||||
];
|
||||
for (const [name, ziel] of soll) {
|
||||
const k = kisten.find((x) => x.name === name);
|
||||
ok(k?.ziel === ziel, ` "${name}" fuehrt auf ${k?.ziel || "NIRGENDWOHIN"}`);
|
||||
}
|
||||
ok(kisten.every((k) => !k.ziel || /ansehen/.test(k.beschriftung)),
|
||||
" jeder Weg hat einen Satz fuer Vorleseprogramme");
|
||||
|
||||
/* GEGENPROBE: Eine Kiste ohne Inhalt darf NICHT verlinkt sein. Ein Weg
|
||||
zu null Dingen ist eine Enttaeuschung, kein Angebot. Geprueft an
|
||||
"Content: neue Eintraege" -- dort wurde nichts angelegt. */
|
||||
const leer = kisten.find((k) => k.name === "LIVE-Schnitt aus 0 Bewertung(en)");
|
||||
ok(leer && !leer.ziel, ` Gegenprobe: "${leer?.name}" fuehrt bewusst nirgendwohin`);
|
||||
|
||||
/* ================================================================
|
||||
2. Aufgabenbrett: hervorheben, nicht filtern
|
||||
================================================================ */
|
||||
console.log("\n=== Der Sprung auf das Aufgabenbrett");
|
||||
for (const [was, erwartet, wort] of [
|
||||
["offen", AUFG.offen, "offen"],
|
||||
["review", AUFG.review, "Freigabe"],
|
||||
["erledigt", AUFG.erledigt, "erledigt"],
|
||||
["ueberfaellig", UEBERFAELLIG, "Frist"],
|
||||
]) {
|
||||
await seite.goto(`${BASIS}/workspace/aufgaben.html?zeigen=${was}`, { waitUntil: "networkidle" });
|
||||
await seite.waitForTimeout(900);
|
||||
const r = await seite.evaluate(() => ({
|
||||
treffer: document.querySelectorAll('.karte[data-treffer="ja"]').length,
|
||||
/* ALLE Karten muessen weiterhin da sein -- das Brett lebt davon,
|
||||
dass man die vier Spalten nebeneinander sieht. */
|
||||
karten: document.querySelectorAll(".karte").length,
|
||||
leiste: !!document.querySelector(".ziel-leiste"),
|
||||
text: document.querySelector(".ziel-leiste__text")?.textContent || "",
|
||||
marke: document.querySelector(".ziel-leiste__marke")?.textContent || "",
|
||||
}));
|
||||
ok(r.treffer === erwartet,
|
||||
`?zeigen=${was}: ${r.treffer} hervorgehoben (erwartet ${erwartet}), ${r.karten} Karten insgesamt`);
|
||||
ok(r.leiste && r.marke === String(erwartet), ` die Leiste sagt "${r.marke}"`);
|
||||
ok(new RegExp(wort, "i").test(r.text), ` und erklaert es ("${r.text}")`);
|
||||
ok(r.karten > erwartet, " es wird hervorgehoben, NICHT gefiltert");
|
||||
}
|
||||
|
||||
/* Der Weg zurueck. Ohne ihn bliebe die Seite fuer immer markiert. */
|
||||
const zurueck = await seite.evaluate(async () => {
|
||||
document.querySelector(".ziel-leiste__weg").click();
|
||||
await new Promise((r) => setTimeout(r, 250));
|
||||
return {
|
||||
treffer: document.querySelectorAll('[data-treffer="ja"]').length,
|
||||
leiste: !!document.querySelector(".ziel-leiste"),
|
||||
adresse: location.search,
|
||||
};
|
||||
});
|
||||
ok(zurueck.treffer === 0 && !zurueck.leiste, '"Alles zeigen" nimmt die Hervorhebung zurueck');
|
||||
ok(!zurueck.adresse.includes("zeigen"),
|
||||
` und raeumt die Adresse mit auf ("${zurueck.adresse}") – sonst kaeme sie beim Neuladen wieder`);
|
||||
|
||||
/* GEGENPROBE: ohne Parameter darf nichts markiert sein. */
|
||||
await seite.goto(BASIS + "/workspace/aufgaben.html", { waitUntil: "networkidle" });
|
||||
await seite.waitForTimeout(900);
|
||||
const ohne = await seite.evaluate(() => ({
|
||||
treffer: document.querySelectorAll('[data-treffer="ja"]').length,
|
||||
leiste: !!document.querySelector(".ziel-leiste"),
|
||||
karten: document.querySelectorAll(".karte").length,
|
||||
}));
|
||||
ok(ohne.treffer === 0 && !ohne.leiste && ohne.karten > 0,
|
||||
`Gegenprobe: ohne Parameter nichts hervorgehoben (${ohne.karten} Karten, ${ohne.treffer} markiert)`);
|
||||
|
||||
/* Und ein unbekannter Wert darf ebenfalls nichts tun -- nicht abstuerzen
|
||||
und nicht eine leere Leiste zeigen. */
|
||||
await seite.goto(BASIS + "/workspace/aufgaben.html?zeigen=quatsch", { waitUntil: "networkidle" });
|
||||
await seite.waitForTimeout(900);
|
||||
const quatsch = await seite.evaluate(() => ({
|
||||
leiste: !!document.querySelector(".ziel-leiste"),
|
||||
karten: document.querySelectorAll(".karte").length,
|
||||
}));
|
||||
ok(!quatsch.leiste && quatsch.karten > 0,
|
||||
"Gegenprobe: ein unbekannter Wert wird still ignoriert");
|
||||
|
||||
/* ================================================================
|
||||
3. Bereichsseite: dringend hervorheben, offen filtern
|
||||
================================================================ */
|
||||
console.log("\n=== Der Sprung in die LIVE-Analyse");
|
||||
await seite.goto(BASIS + "/workspace/bereich.html?b=live&zeigen=dringend", { waitUntil: "networkidle" });
|
||||
await seite.waitForTimeout(1200);
|
||||
const dr = await seite.evaluate(() => ({
|
||||
treffer: document.querySelectorAll('.eintrag-karte[data-treffer="ja"]').length,
|
||||
alle: document.querySelectorAll(".eintrag-karte").length,
|
||||
marke: document.querySelector(".ziel-leiste__marke")?.textContent || "",
|
||||
}));
|
||||
ok(dr.treffer === DRINGEND_LIVE,
|
||||
`dringende Eintraege hervorgehoben: ${dr.treffer} von ${dr.alle} (erwartet ${DRINGEND_LIVE})`);
|
||||
ok(dr.alle > dr.treffer, " die harmlosen stehen weiterhin da");
|
||||
|
||||
await seite.goto(BASIS + "/workspace/bereich.html?b=live&zeigen=offen", { waitUntil: "networkidle" });
|
||||
await seite.waitForTimeout(1200);
|
||||
const of = await seite.evaluate(() => ({
|
||||
alle: document.querySelectorAll(".eintrag-karte").length,
|
||||
treffer: document.querySelectorAll('.eintrag-karte[data-treffer="ja"]').length,
|
||||
gedrueckt: [...document.querySelectorAll("#filter .schritt")]
|
||||
.find((b) => b.getAttribute("aria-pressed") === "true")?.textContent,
|
||||
}));
|
||||
ok(of.alle === OFFEN_LIVE && of.treffer === OFFEN_LIVE,
|
||||
`nur die offenen: ${of.alle} gezeigt (erwartet ${OFFEN_LIVE})`);
|
||||
ok(of.gedrueckt === "Nur offene",
|
||||
` und der Filterknopf zeigt es an ("${of.gedrueckt}") – ein unsichtbarer Ausschnitt waere eine Falle`);
|
||||
|
||||
/* ================================================================
|
||||
4. Dateien: hier wird wirklich gefiltert
|
||||
================================================================ */
|
||||
console.log("\n=== Der Sprung in die Dateien");
|
||||
await seite.goto(BASIS + "/workspace/dateien.html?zeigen=review", { waitUntil: "networkidle" });
|
||||
await seite.waitForTimeout(1200);
|
||||
const da = await seite.evaluate(() => ({
|
||||
leiste: !!document.querySelector(".ziel-leiste"),
|
||||
text: document.querySelector(".ziel-leiste__text")?.textContent || "",
|
||||
gedrueckt: [...document.querySelectorAll("#filter .schritt")]
|
||||
.find((b) => b.getAttribute("aria-pressed") === "true")?.textContent?.trim(),
|
||||
}));
|
||||
/* Es liegt keine Datei da -- und genau dieser Fall ist der wichtige:
|
||||
Wer auf eine Zahl klickt und auf einer leeren Seite landet, glaubt,
|
||||
er sei falsch abgebogen. Die Leiste muss ihm sagen, dass er richtig
|
||||
ist und die Sache erledigt. */
|
||||
ok(da.leiste, "auch ohne Treffer erscheint die Leiste");
|
||||
ok(/nichts davon da/.test(da.text), ` und sagt, dass hier nichts liegt ("${da.text}")`);
|
||||
ok(/review/i.test(da.gedrueckt || ""), ` der Filter steht auf "${da.gedrueckt}"`);
|
||||
|
||||
/* ================================================================
|
||||
5. Kalender: schaltet auf die Liste um
|
||||
================================================================ */
|
||||
console.log("\n=== Der Sprung in den Kalender");
|
||||
await seite.goto(BASIS + "/workspace/kalender.html?zeigen=kommend", { waitUntil: "networkidle" });
|
||||
await seite.waitForTimeout(1400);
|
||||
const ka = await seite.evaluate(() => ({
|
||||
ansicht: document.getElementById("kalender")?.dataset.ansicht,
|
||||
gedrueckt: [...document.querySelectorAll(".k-ansicht")]
|
||||
.find((b) => b.getAttribute("aria-pressed") === "true")?.dataset.ansicht,
|
||||
leiste: !!document.querySelector(".ziel-leiste"),
|
||||
}));
|
||||
ok(ka.ansicht === "liste",
|
||||
`der Kalender schaltet auf die Liste um (${ka.ansicht}) – in der Monatsansicht liesse sich `
|
||||
+ "vergangen/kommend gar nicht hervorheben");
|
||||
ok(ka.gedrueckt === "liste",
|
||||
` und der Ansichtsknopf zeigt dasselbe (${ka.gedrueckt}) – sonst behauptet die Leiste "Monat"`);
|
||||
ok(ka.leiste, " die Leiste ist da");
|
||||
|
||||
/* ================================================================ */
|
||||
ok(konsole.length === 0,
|
||||
`keine Fehler in der Konsole${konsole.length ? " -> " + konsole.join(" | ") : ""}`);
|
||||
|
||||
await seite.goto(BASIS + "/workspace/report.html", { waitUntil: "networkidle" });
|
||||
await seite.waitForTimeout(1200);
|
||||
await seite.screenshot({ path: "pruef-sprung.png", fullPage: false });
|
||||
|
||||
await kontext.close();
|
||||
await browser.close();
|
||||
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
|
||||
console.log(fehler ? `\n${fehler} Prüfung(en) fehlgeschlagen.` : "\nAlles in Ordnung.");
|
||||
process.exit(fehler ? 1 : 0);
|
||||
@@ -0,0 +1,326 @@
|
||||
/* Prueft zwei Wuensche vom 01.09.2026:
|
||||
|
||||
SCREEN 2: "ich will, dass wir Manager, Scouts, DogFather auch die
|
||||
Fotos, Namen und so alles sehen, alles was die in ihrem Profil
|
||||
eintragen."
|
||||
|
||||
SCREEN 5: "wieso seh ich mein Bild da nicht, obwohl ich schon ein Foto
|
||||
drin hab?"
|
||||
|
||||
WAS AN DIESER PRUEFUNG WICHTIG IST.
|
||||
|
||||
Ein Profilbild zu pruefen, ohne ein echtes Bild zu haben, beweist
|
||||
nichts. Beim .wer__bild-Fehler im August benutzte die Pruefung ein
|
||||
1x1-Pixel-PNG -- damit kann kein Stil-Fehler sichtbar werden, weil
|
||||
ein Punkt nichts ueberdecken kann. Hier wird deshalb ein RICHTIGES
|
||||
Bild hochgeladen (600x600) und danach gemessen, ob es auch die
|
||||
Flaeche fuellt, die es fuellen soll -- und ob es rund beschnitten ist
|
||||
statt quadratisch ueber den Rahmen zu ragen.
|
||||
|
||||
Und zu jeder Aussage die Gegenprobe: Wer KEIN Bild hat, muss den
|
||||
Buchstaben sehen. Sonst koennte die Pruefung gruen sein, weil
|
||||
ueberall Bilder erscheinen -- auch da, wo keine sind. */
|
||||
|
||||
import { mkdtempSync, rmSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import { deflateSync } from "node:zlib";
|
||||
|
||||
const ordner = mkdtempSync(join(tmpdir(), "ws-team-"));
|
||||
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
|
||||
/* DATEN_ORDNER wird aus dem Datenbankpfad abgeleitet (workspace.js) --
|
||||
die Profilbilder landen also von selbst im Testordner. */
|
||||
process.env.PORT = "4213";
|
||||
process.env.SITE_ACCESS_SECRET = "lokaler-test";
|
||||
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
|
||||
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
|
||||
|
||||
const express = (await import("express")).default;
|
||||
const ec = express.response.cookie;
|
||||
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
|
||||
await import("./index.js");
|
||||
await new Promise((r) => setTimeout(r, 700));
|
||||
const BASIS = "http://127.0.0.1:4213";
|
||||
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 300_000).unref?.();
|
||||
|
||||
let fehler = 0;
|
||||
const ok = (b, t) => { console.log((b ? " ok " : " FEHL ") + t); if (!b) fehler++; };
|
||||
|
||||
await fetch(BASIS + "/workspace/api/anmelden", {
|
||||
method: "POST", headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});
|
||||
|
||||
const { DatabaseSync } = await import("node:sqlite");
|
||||
const { scryptSync, randomBytes, createHash } = await import("node:crypto");
|
||||
for (let i = 0; i < 60; i++) {
|
||||
try {
|
||||
const p = new DatabaseSync(process.env.WORKSPACE_DB);
|
||||
try { p.prepare("SELECT 1 FROM personen LIMIT 1").get(); break; } finally { p.close(); }
|
||||
} catch { await new Promise((r) => setTimeout(r, 250)); }
|
||||
}
|
||||
const d = new DatabaseSync(process.env.WORKSPACE_DB);
|
||||
const jetzt = new Date().toISOString();
|
||||
function anlegen(name, rolle, code) {
|
||||
const salt = randomBytes(16).toString("hex");
|
||||
const hash = scryptSync(code, salt, 64, { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
|
||||
d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
|
||||
.run(name, rolle, hash, salt, 32768, jetzt);
|
||||
return d.prepare("SELECT last_insert_rowid() AS id").get().id;
|
||||
}
|
||||
const idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
|
||||
const idMgr = anlegen("Mara", "manager", "CODE-MANA-0001");
|
||||
const idScout = anlegen("Patrick", "scout", "CODE-SCOU-0001");
|
||||
const idTili = anlegen("Tili", "creator", "CODE-ANNA-0001");
|
||||
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)")
|
||||
.run(idTili, idScout, jetzt);
|
||||
|
||||
/* Jeder traegt etwas in seinen Steckbrief ein -- sonst koennte die
|
||||
Pruefung nicht unterscheiden, ob "alles was die eintragen" wirklich
|
||||
ankommt oder ob nur Namen angezeigt werden. */
|
||||
d.prepare("UPDATE personen SET ueber_mich = ?, tiktok = ? WHERE id = ?")
|
||||
.run("Manager & CEO dieser Seite", "dogfather", idDogi);
|
||||
d.prepare("UPDATE personen SET ueber_mich = ?, instagram = ? WHERE id = ?")
|
||||
.run("Ich kuemmere mich um die Vertraege.", "mara.mgmt", idMgr);
|
||||
d.prepare("UPDATE personen SET ueber_mich = ? WHERE id = ?")
|
||||
.run("Ich finde neue Leute.", idScout);
|
||||
/* Tili bekommt BEWUSST nichts -- die Gegenprobe zum Platzhaltersatz. */
|
||||
d.close();
|
||||
|
||||
/* ---- Ein echtes PNG, 600x600, einfarbig. Kein 1x1-Punkt: Der kann
|
||||
nichts ueberdecken und wuerde jeden Stil-Fehler verstecken. ---- */
|
||||
function pngBauen(breite, hoehe) {
|
||||
const roh = Buffer.alloc((breite * 3 + 1) * hoehe);
|
||||
for (let y = 0; y < hoehe; y++) {
|
||||
const z = y * (breite * 3 + 1);
|
||||
roh[z] = 0;
|
||||
for (let x = 0; x < breite; x++) {
|
||||
roh[z + 1 + x * 3] = 200; roh[z + 2 + x * 3] = 60; roh[z + 3 + x * 3] = 120;
|
||||
}
|
||||
}
|
||||
const stueck = (art, daten) => {
|
||||
const l = Buffer.alloc(4); l.writeUInt32BE(daten.length);
|
||||
const k = Buffer.concat([Buffer.from(art), daten]);
|
||||
const c = Buffer.alloc(4);
|
||||
c.writeUInt32BE(crc32(k) >>> 0);
|
||||
return Buffer.concat([l, k, c]);
|
||||
};
|
||||
const ihdr = Buffer.alloc(13);
|
||||
ihdr.writeUInt32BE(breite, 0); ihdr.writeUInt32BE(hoehe, 4);
|
||||
ihdr[8] = 8; ihdr[9] = 2; ihdr[10] = 0; ihdr[11] = 0; ihdr[12] = 0;
|
||||
return Buffer.concat([
|
||||
Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
|
||||
stueck("IHDR", ihdr), stueck("IDAT", deflateSync(roh)), stueck("IEND", Buffer.alloc(0)),
|
||||
]);
|
||||
}
|
||||
let tabelle = null;
|
||||
function crc32(buf) {
|
||||
if (!tabelle) {
|
||||
tabelle = new Int32Array(256);
|
||||
for (let n = 0; n < 256; n++) {
|
||||
let c = n;
|
||||
for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
|
||||
tabelle[n] = c;
|
||||
}
|
||||
}
|
||||
let c = -1;
|
||||
for (const b of buf) c = tabelle[(c ^ b) & 0xff] ^ (c >>> 8);
|
||||
return c ^ -1;
|
||||
}
|
||||
const BILD = pngBauen(600, 600);
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
|
||||
const { chromium } = await import(
|
||||
"file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
|
||||
const browser = await chromium.launch();
|
||||
|
||||
async function anmelden(rolle, code) {
|
||||
const kontext = await browser.newContext({ viewport: { width: 1280, height: 1000 } });
|
||||
const konsole = [];
|
||||
const seite = await kontext.newPage();
|
||||
seite.on("console", (m) => { if (m.type() === "error") konsole.push(m.text()); });
|
||||
seite.on("pageerror", (e) => konsole.push("pageerror: " + e.message));
|
||||
await seite.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
|
||||
await seite.click(`.rolle[data-rolle="${rolle}"]`);
|
||||
await seite.fill("#code", code);
|
||||
await seite.click("button[type=submit]");
|
||||
await seite.waitForURL("**/start.html", { timeout: 15000 });
|
||||
return { kontext, seite, konsole };
|
||||
}
|
||||
|
||||
/* ================================================================
|
||||
1. Ein echtes Bild hochladen -- und pruefen, dass es ueberall ankommt
|
||||
================================================================ */
|
||||
console.log("\n=== Das eigene Bild (Screen 5)");
|
||||
const a1 = await anmelden("admin", "CODE-DOGI-0001");
|
||||
|
||||
const hoch = await a1.seite.evaluate(async (b64) => {
|
||||
const roh = Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
|
||||
const a = await fetch("/workspace/api/steckbrief/bild", {
|
||||
method: "POST", credentials: "same-origin",
|
||||
headers: { "Content-Type": "image/png" }, body: roh,
|
||||
});
|
||||
return { status: a.status, ...(await a.json().catch(() => ({}))) };
|
||||
}, BILD.toString("base64"));
|
||||
ok(hoch.status === 200 && !!hoch.bild, `ein echtes Bild (600x600) laesst sich hochladen (${hoch.status})`);
|
||||
|
||||
/* Kommt es auf der STARTSEITE in der Begruessung an? Das war der
|
||||
gemeldete Fehler: Dort stand der Buchstabe, obwohl ein Foto da war --
|
||||
und im Server steht seit jeher der Kommentar "es steht in der
|
||||
Kopfleiste JEDER Seite UND IN DER BEGRUESSUNG". Die Absicht war
|
||||
aufgeschrieben, die Haelfte nie gebaut. */
|
||||
await a1.seite.goto(BASIS + "/workspace/start.html", { waitUntil: "networkidle" });
|
||||
await a1.seite.waitForTimeout(1500);
|
||||
const gruss = await a1.seite.evaluate(() => {
|
||||
const p = document.getElementById("plakette");
|
||||
const b = p?.querySelector("img");
|
||||
if (!b) return { bild: false, text: p?.textContent || "" };
|
||||
const r = b.getBoundingClientRect();
|
||||
const pr = p.getBoundingClientRect();
|
||||
const st = getComputedStyle(b);
|
||||
const ps = getComputedStyle(p);
|
||||
return {
|
||||
bild: true,
|
||||
geladen: b.complete && b.naturalWidth > 0,
|
||||
/* Fuellt es die Plakette wirklich aus? Ein Bild, das nur zu einem
|
||||
Viertel drinsteht, sieht aus wie ein Fehler. */
|
||||
fuellt: r.width >= pr.width - 2 && r.height >= pr.height - 2,
|
||||
/* Rund beschnitten -- ohne overflow:hidden ragt ein quadratisches
|
||||
Bild aus dem runden Rahmen. */
|
||||
beschnitten: ps.overflow === "hidden",
|
||||
passung: st.objectFit,
|
||||
kein_text: (p.textContent || "").trim() === "",
|
||||
};
|
||||
});
|
||||
ok(gruss.bild === true, "die Begruessung zeigt das Bild statt des Buchstabens");
|
||||
ok(gruss.geladen === true, " und es ist wirklich geladen (nicht nur ein leerer Rahmen)");
|
||||
ok(gruss.fuellt === true, " es fuellt die Plakette aus");
|
||||
ok(gruss.beschnitten === true, " und ist rund beschnitten (overflow: hidden)");
|
||||
ok(gruss.passung === "cover", ` ohne zu verzerren (object-fit: ${gruss.passung})`);
|
||||
ok(gruss.kein_text === true, " der Buchstabe steht nicht mehr daneben");
|
||||
|
||||
/* ================================================================
|
||||
2. Das Team -- alle Rollen, mit allem, was sie eingetragen haben
|
||||
================================================================ */
|
||||
console.log("\n=== Das Team (Screen 2)");
|
||||
await a1.seite.goto(BASIS + "/workspace/steckbrief.html", { waitUntil: "networkidle" });
|
||||
await a1.seite.waitForTimeout(1600);
|
||||
|
||||
const team = await a1.seite.evaluate(() => {
|
||||
const block = document.getElementById("team-block");
|
||||
const karten = [...document.querySelectorAll(".team-karte")];
|
||||
const sichtbar = (e) => {
|
||||
const r = e.getBoundingClientRect();
|
||||
return r.width > 0 && r.height > 0;
|
||||
};
|
||||
return {
|
||||
da: block && !block.hidden,
|
||||
/* IST DER STIL ANGEKOMMEN? Die .block__*-Klassen stehen in
|
||||
automation.css und wissen.css -- diese Seite laedt beide nicht.
|
||||
Genau so sind hier schon zweimal Stile ins Leere gelaufen.
|
||||
Gemessen wird deshalb der tatsaechliche Stil, nicht die Klasse. */
|
||||
gestaltet: karten[0] ? (() => {
|
||||
const st = getComputedStyle(karten[0]);
|
||||
return parseFloat(st.borderTopWidth) >= 1 && parseFloat(st.paddingLeft) >= 8;
|
||||
})() : null,
|
||||
anzahl: karten.length,
|
||||
sichtbare: karten.filter(sichtbar).length,
|
||||
gruppen: [...document.querySelectorAll(".team-gruppe__name")].map((e) => e.textContent),
|
||||
leute: karten.map((k) => ({
|
||||
name: k.querySelector(".team-karte__name")?.textContent,
|
||||
rolle: k.dataset.rolle,
|
||||
rollenname: k.querySelector(".team-karte__rolle")?.textContent,
|
||||
ueber: k.querySelector(".team-karte__ueber")?.textContent || null,
|
||||
bild: !!k.querySelector(".team-karte__bild img"),
|
||||
buchstabe: k.querySelector(".team-karte__bild img")
|
||||
? null : (k.querySelector(".team-karte__bild")?.textContent || "").trim(),
|
||||
kanaele: [...k.querySelectorAll(".team-kanal")].map((a) => a.getAttribute("href")),
|
||||
ich: k.dataset.ich === "ja",
|
||||
})),
|
||||
ueber: document.documentElement.scrollWidth - document.documentElement.clientWidth,
|
||||
};
|
||||
});
|
||||
|
||||
ok(team.da === true, "der Team-Block erscheint");
|
||||
ok(team.gestaltet === true, " und die Stile sind angekommen (Rand und Polsterung gemessen)");
|
||||
ok(team.anzahl === 4 && team.sichtbare === 4,
|
||||
`alle vier Personen stehen da (${team.anzahl}, davon ${team.sichtbare} sichtbar)`);
|
||||
ok(team.gruppen.join(", ") === "Management, Scouting, Creator",
|
||||
`nach Rollen gruppiert: ${team.gruppen.join(", ")}`);
|
||||
|
||||
const dogi = team.leute.find((l) => l.name === "Filipe");
|
||||
const mara = team.leute.find((l) => l.name === "Mara");
|
||||
const pat = team.leute.find((l) => l.name === "Patrick");
|
||||
const tili = team.leute.find((l) => l.name === "Tili");
|
||||
|
||||
ok(!!dogi && !!mara && !!pat && !!tili,
|
||||
"Manager, Scout, DogFather UND Creator sind dabei – nicht nur Creator");
|
||||
ok(dogi?.bild === true, "DogFather wird mit seinem Foto gezeigt");
|
||||
ok(dogi?.ueber === "Manager & CEO dieser Seite",
|
||||
` und mit dem, was er ueber sich geschrieben hat ("${dogi?.ueber}")`);
|
||||
ok(dogi?.ich === true, " seine eigene Karte ist als solche gekennzeichnet");
|
||||
ok(/tiktok\.com/.test(dogi?.kanaele?.[0] || ""),
|
||||
` sein Kanal fuehrt wirklich hin (${dogi?.kanaele?.[0]})`);
|
||||
ok(mara?.ueber === "Ich kuemmere mich um die Vertraege.", "der Manager-Text kommt an");
|
||||
ok(pat?.ueber === "Ich finde neue Leute.", "der Scout-Text kommt an");
|
||||
ok(mara?.rollenname === "Manager" && pat?.rollenname === "Scout",
|
||||
`die Rolle steht dabei (${mara?.rollenname}, ${pat?.rollenname})`);
|
||||
|
||||
/* GEGENPROBEN -- ohne sie waere oben alles auch dann gruen, wenn die
|
||||
Seite einfach ueberall Bilder und Texte hinschriebe. */
|
||||
ok(mara?.bild === false && mara?.buchstabe === "M",
|
||||
`Gegenprobe: wer kein Foto hat, bekommt den Buchstaben ("${mara?.buchstabe}")`);
|
||||
ok(tili?.ueber === null,
|
||||
"Gegenprobe: wer nichts ueber sich geschrieben hat, bekommt keinen Platzhaltersatz");
|
||||
ok(tili?.kanaele?.length === 0,
|
||||
"Gegenprobe: ohne Kanal steht dort auch keiner");
|
||||
ok(mara?.ich === false, "Gegenprobe: fremde Karten sind nicht als 'du' markiert");
|
||||
ok(team.ueber <= 0, `nichts steht seitlich ueber (${team.ueber}px)`);
|
||||
ok(a1.konsole.length === 0,
|
||||
`keine Fehler in der Konsole${a1.konsole.length ? " -> " + a1.konsole.join(" | ") : ""}`);
|
||||
|
||||
await a1.seite.screenshot({ path: "pruef-team.png", fullPage: false });
|
||||
await a1.kontext.close();
|
||||
|
||||
/* ================================================================
|
||||
3. Ein Creator sieht seine Betreuung -- aber nicht die anderen Creator
|
||||
================================================================ */
|
||||
console.log("\n=== Was ein Creator davon sieht");
|
||||
const a2 = await anmelden("creator", "CODE-ANNA-0001");
|
||||
await a2.seite.goto(BASIS + "/workspace/profil.html", { waitUntil: "networkidle" });
|
||||
await a2.seite.waitForTimeout(1600);
|
||||
const sicht = await a2.seite.evaluate(() => ({
|
||||
da: !document.getElementById("team-block")?.hidden,
|
||||
namen: [...document.querySelectorAll(".team-karte__name")].map((e) => e.textContent).sort(),
|
||||
}));
|
||||
ok(sicht.da === true, "ein Creator sieht das Team auf seiner Profilseite");
|
||||
ok(sicht.namen.includes("Patrick"), " seinen Scout");
|
||||
ok(sicht.namen.includes("Filipe") && sicht.namen.includes("Mara"),
|
||||
" und das Management");
|
||||
ok(a2.konsole.length === 0,
|
||||
`keine Fehler in der Konsole${a2.konsole.length ? " -> " + a2.konsole.join(" | ") : ""}`);
|
||||
await a2.kontext.close();
|
||||
|
||||
/* Ein zweiter Creator, um zu pruefen, dass Creator einander NICHT sehen.
|
||||
Das ist kein Schoenheitsfehler: Der Server entscheidet das, und wenn
|
||||
sich die Regel je aendert, muss es hier auffallen. */
|
||||
const d2 = new DatabaseSync(process.env.WORKSPACE_DB);
|
||||
const salt = randomBytes(16).toString("hex");
|
||||
const hash = scryptSync("CODE-LUNA-0001", salt, 64, { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
|
||||
d2.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
|
||||
.run("Luna", "creator", hash, salt, 32768, jetzt);
|
||||
d2.close();
|
||||
|
||||
const a3 = await anmelden("creator", "CODE-ANNA-0001");
|
||||
await a3.seite.goto(BASIS + "/workspace/profil.html", { waitUntil: "networkidle" });
|
||||
await a3.seite.waitForTimeout(1600);
|
||||
const fremd = await a3.seite.evaluate(() =>
|
||||
[...document.querySelectorAll(".team-karte__name")].map((e) => e.textContent));
|
||||
ok(!fremd.includes("Luna"),
|
||||
`Gegenprobe: ein Creator sieht einen fremden Creator NICHT (${fremd.join(", ")})`);
|
||||
await a3.kontext.close();
|
||||
|
||||
await browser.close();
|
||||
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
|
||||
console.log(fehler ? `\n${fehler} Prüfung(en) fehlgeschlagen.` : "\nAlles in Ordnung.");
|
||||
process.exit(fehler ? 1 : 0);
|
||||
Reference in New Issue
Block a user