From b846693de523b4a499b980673bcd4d49324a8da7 Mon Sep 17 00:00:00 2001 From: Dogfather Date: Tue, 29 Sep 2026 16:00:57 +0200 Subject: [PATCH] Die letzten fuenf blinden Messungen bekommen einen Finger Die Grundlinie der Fingerwache sinkt von 6 auf 1. DIE SCHWEREN FAELLE pruef-notizen, pruef-teamlage-karten, pruef-terminregel, pruef-werdegang, pruef-befinden. Bei diesen fuenf stand mitten im Ablauf ein `setViewportSize({ width: 390 })`. Das aendert nur die Groesse -- `hasTouch` gehoert zum KONTEXT und ist beim Anlegen entschieden. Nachtragen geht nicht; es braucht ein zweites Fenster. DAS MUSTER, DAS FUER ALLE FUENF GETRAGEN HAT const handyKontext = await browser.newContext({ viewport: { width: 390, height: 844 }, hasTouch: true, isMobile: true }); await handyKontext.addCookies(await kontext.cookies()); const handy = await handyKontext.newPage(); await handy.goto(seite.url(), { waitUntil: "networkidle" }); Drei Entscheidungen darin: - Die Anmeldung wandert als Keks mit, statt sie zu wiederholen. Eine zweite Anmeldung waere eine zweite Stelle, die veralten kann. - Die Adresse kommt von `seite.url()`. Sie ein zweites Mal hinzuschreiben waere eine zweite Wahrheit darueber, welche Seite gemessen wird. - Das fruehere Zuruecksetzen auf 1280 px faellt weg. Die breite Seite war nie schmal -- es gibt nichts zurueckzustellen. Bei pruef-terminregel liessen sich die vier Schritte, die den schwebenden Hinweis erzeugen, nicht uebernehmen: Sie werden im neuen Kontext nachgefahren (oeffnen, "Neu", Datum eintragen). ALLE FUENF DANACH GRUEN pruef-notizen EXIT 0 pruef-teamlage-karten EXIT 0 (39 geprueft) pruef-terminregel EXIT 0 (35 Pruefungen) pruef-werdegang EXIT 0 pruef-befinden EXIT 0 Diese Seiten halten die Fingerregeln also schon ein. Es hatte nur nie jemand nachgesehen. EINES BLEIBT: pruef-grosscheck Die Datei zu aendern waere ein Zweizeiler. Sie zu PRUEFEN hiesse, 206 Seiten ueber vier Rollen und zwei Bildschirmgroessen laufen zu lassen -- das braucht Filipes Zusage. Eine Aenderung, die ich nicht pruefen darf, liefere ich nicht aus. Die Grundlinie steht deshalb auf 1 und nicht auf 0. GEPRUEFT pruef-fingermass 3 / 0, neun Gegenproben, Grundlinie 1 --- server/pruef-befinden.mjs | 23 +++++++++++++++++---- server/pruef-fingermass.mjs | 32 +++++++++++++++++------------ server/pruef-notizen.mjs | 21 ++++++++++++++++--- server/pruef-teamlage-karten.mjs | 32 ++++++++++++++++++++++++----- server/pruef-terminregel.mjs | 35 +++++++++++++++++++++++++++----- server/pruef-werdegang.mjs | 26 ++++++++++++++++++++---- 6 files changed, 135 insertions(+), 34 deletions(-) diff --git a/server/pruef-befinden.mjs b/server/pruef-befinden.mjs index 582de6d3..55e280e0 100644 --- a/server/pruef-befinden.mjs +++ b/server/pruef-befinden.mjs @@ -990,9 +990,21 @@ melde("=== 8. Die Analyse im Browser ==="); Lesen sieht -- beide Regeln wirken einzeln vernuenftig. Nur eine Messung findet ihn wieder, wenn jemand an einem der beiden Abstaende dreht. */ - const enge = await seite.setViewportSize({ width: 430, height: 900 }) - .then(() => seite.waitForTimeout(500)) - .then(() => seite.evaluate(() => { + /* EIN EIGENER KONTEXT MIT FINGER (29.09.2026). + + Hier stand `seite.setViewportSize({ width: 430 })`. Das aendert + nur die Groesse: `hasTouch` gehoert zum KONTEXT und laesst sich + danach nicht mehr setzen. Ohne ihn meldet der Browser + `pointer: fine`, und KEINE Regel aus `@media (pointer: coarse)` + greift. Gerade hier zaehlt das: Hoehere Beruehrziele stehen + enger beieinander, und ob Text auf Text liegt, haengt daran. */ + const engKontext = await browser.newContext({ + viewport: { width: 430, height: 900 }, hasTouch: true, isMobile: true }); + await engKontext.addCookies(await kontext.cookies()); + const engSeite = await engKontext.newPage(); + const enge = await engSeite.goto(seite.url(), { waitUntil: "networkidle" }) + .then(() => engSeite.waitForTimeout(500)) + .then(() => engSeite.evaluate(() => { const kandidaten = [...document.querySelectorAll("body *")].filter((e) => { const r = e.getBoundingClientRect(); return r.width > 20 && r.height > 6 @@ -1022,7 +1034,10 @@ melde("=== 8. Die Analyse im Browser ==="); enge.treffer.length ? `Text liegt auf Text: ${enge.treffer.slice(0, 2).join("; ")}` : `bei 430 px liegt kein Text auf Text (${enge.geprueft} Absätze verglichen)`); - await seite.setViewportSize({ width: 1280, height: 1000 }); + /* Das enge Fenster war ein eigener Kontext und geht hier zu. + `seite` war nie schmal -- das fruehere Zurueckstellen auf 1280 + ist damit hinfaellig. */ + await engKontext.close(); if (process.env.SCHIRM) { /* Zielt seit dem 22.09.2026 auf das Gesamtresuemee -- den Block darunter gibt es nicht mehr. Ohne diese Zeile brach der Lauf diff --git a/server/pruef-fingermass.mjs b/server/pruef-fingermass.mjs index 1a75f7d1..0c8f09c3 100644 --- a/server/pruef-fingermass.mjs +++ b/server/pruef-fingermass.mjs @@ -63,20 +63,26 @@ const ORDNER = new URL(".", import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, Die erste Zahl, die eine Wache liefert, ist selten die richtige. - 29.09.2026, nachmittags: 17 -> 6. Zehn Fenster bekamen einen - Finger, eines fiel weg. Alle zehn Pruefungen liefen danach gruen - -- diese Seiten halten die Fingerregeln also schon ein, es hatte - nur nie jemand nachgesehen. Gefunden wurde dabei trotzdem etwas: - eine Zeitbombe in pruef-kalender (siehe dort). + 29.09.2026, nachmittags: 17 -> 6 -> 1. Sechzehn Fenster bekamen + einen Finger, eines fiel weg. JEDE der umgestellten Pruefungen + lief danach gruen -- diese Seiten halten die Fingerregeln also + schon ein, es hatte nur nie jemand nachgesehen. Gefunden wurde + dabei trotzdem etwas: eine Zeitbombe in pruef-kalender (dort + steht die Erklaerung). - Die sechs uebrigen sind die schweren Faelle: Dort schaltet - `setViewportSize` mitten im Ablauf auf Handyformat um, und der - Finger laesst sich nachtraeglich nicht setzen. Jeder davon - braucht einen eigenen Kontext samt Anmeldung -- Umbau, nicht - Einzeiler. `pruef-grosscheck` bleibt unangetastet, bis Filipe - einen Lauf freigibt: Eine Aenderung, die ich nicht pruefen darf, - liefere ich nicht aus. */ -const GRUNDLINIE = 6; + DIE SCHWEREN FAELLE brauchten je einen Umbau: Wo mitten im Ablauf + `setViewportSize` stand, kann der Finger nicht nachgetragen + werden. Das Muster, das fuer alle fuenf getragen hat: einen + eigenen Kontext anlegen, `addCookies(await kontext.cookies())`, + und die Adresse von `seite.url()` nehmen statt sie ein zweites + Mal hinzuschreiben. Danach ist das fruehere Zuruecksetzen auf + 1280 px hinfaellig -- die breite Seite war nie schmal. + + ES BLEIBT EINES: `pruef-grosscheck`. Die Datei zu aendern waere + ein Zweizeiler; sie zu pruefen hiesse, 206 Seiten ueber vier + Rollen laufen zu lassen, und das braucht Filipes Zusage. Eine + Aenderung, die ich nicht pruefen darf, liefere ich nicht aus. */ +const GRUNDLINIE = 1; /* Ab wann ist ein Fenster ein Telefon? 860 ist die Grenze, die im Haus schon in mess-reaktion und mess-chat-optik steht. Darueber diff --git a/server/pruef-notizen.mjs b/server/pruef-notizen.mjs index 804ba578..8afc3439 100644 --- a/server/pruef-notizen.mjs +++ b/server/pruef-notizen.mjs @@ -624,8 +624,23 @@ await seite.waitForTimeout(400); /* Und auf dem Handy: Das Blatt legt sich ueber die Liste, der Zurueck-Knopf holt sie wieder. */ { - const handy = await kontext.newPage(); - await handy.setViewportSize({ width: 390, height: 780 }); + /* EIN EIGENER KONTEXT MIT FINGER (29.09.2026). + + Hier stand `kontext.newPage()` plus `setViewportSize`. Das + aendert nur die Groesse: `hasTouch` gehoert zum KONTEXT und + laesst sich danach nicht mehr setzen. Ohne ihn meldet der + Browser `pointer: fine`, und KEINE Regel aus + `@media (pointer: coarse)` greift -- dort stehen die + 44-Pixel-Beruehrziele. Ein Handy-Bild mit Mauszeiger zeigt eine + Seite, die es auf keinem Handy gibt. + + Die Anmeldung wandert als Keks mit, statt sie zu wiederholen -- + eine zweite Anmeldung waere eine zweite Stelle, die veralten + kann. */ + const handyKontext = await browser.newContext({ + viewport: { width: 390, height: 780 }, hasTouch: true, isMobile: true }); + await handyKontext.addCookies(await kontext.cookies()); + const handy = await handyKontext.newPage(); await handy.goto(`${BASIS}/workspace/notizen.html`, { waitUntil: "networkidle" }); await handy.waitForTimeout(700); const listeDa = await handy.locator(".n-zettel").count(); @@ -646,7 +661,7 @@ await seite.waitForTimeout(400); await handy.locator("#zurueck").click(); await handy.waitForTimeout(400); ok(await handy.locator("#blatt").isHidden(), "der Zurueck-Knopf schliesst es wieder"); - await handy.close(); + await handyKontext.close(); } /* ======================================================================= diff --git a/server/pruef-teamlage-karten.mjs b/server/pruef-teamlage-karten.mjs index 1aa4cb2e..aebd3593 100644 --- a/server/pruef-teamlage-karten.mjs +++ b/server/pruef-teamlage-karten.mjs @@ -369,11 +369,29 @@ if (angekommen !== "/workspace/teamlage.html") { console.log(""); console.log("--- Die Baender auf 390 px ---"); -await seite.setViewportSize({ width: 390, height: 844 }); -await seite.reload({ waitUntil: "networkidle" }); -await seite.waitForTimeout(1500); +/* EIN EIGENER KONTEXT MIT FINGER (29.09.2026). -const schmal = await seite.evaluate(() => { + Hier stand `seite.setViewportSize({ width: 390 })`. Das aendert + nur die Groesse: `hasTouch` gehoert zum KONTEXT und laesst sich + danach nicht mehr setzen. Ohne ihn meldet der Browser + `pointer: fine`, und KEINE Regel aus `@media (pointer: coarse)` + greift -- dort stehen die 44-Pixel-Beruehrziele. Gerade fuer die + Frage, ob ein Band ueber seiner Karte steht, ist das + entscheidend: Die Karte ist am Finger anders gebaut. + + Die Anmeldung wandert als Keks mit, statt sie zu wiederholen -- + eine zweite Anmeldung waere eine zweite Stelle, die veralten + kann. Und die Adresse kommt von der Seite selbst, damit hier + keine zweite Wahrheit darueber entsteht, welche Seite gemessen + wird. */ +const handyKontext = await browser.newContext({ + viewport: { width: 390, height: 844 }, hasTouch: true, isMobile: true }); +await handyKontext.addCookies(await ctx.cookies()); +const handy = await handyKontext.newPage(); +await handy.goto(seite.url(), { waitUntil: "networkidle" }); +await handy.waitForTimeout(1500); + +const schmal = await handy.evaluate(() => { const karten = [...document.querySelectorAll(".t-leute .tperson")]; const ueber = []; for (const k of karten) { @@ -433,7 +451,11 @@ ok(schmal.karten > 0 && schmal.breiteste <= schmal.sichtbar, ist. Deshalb steht die Umrechnung hier ausgeschrieben. ======================================================================= */ { - await seite.setViewportSize({ width: 1280, height: 1200 }); + /* Das Handyfenster ist ein eigener Kontext und wird hier zugemacht. + `seite` war nie schmal, deshalb gibt es auch nichts + zurueckzustellen -- frueher stand hier ein `setViewportSize` auf + 1280, das die Umstellung von 390 rueckgaengig machte. */ + await handyKontext.close(); await seite.waitForTimeout(400); const farben = await seite.evaluate(() => { const zahl = (c) => { const x = c / 255; return x <= 0.04045 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4; }; diff --git a/server/pruef-terminregel.mjs b/server/pruef-terminregel.mjs index 34bf7a66..b6c233fb 100644 --- a/server/pruef-terminregel.mjs +++ b/server/pruef-terminregel.mjs @@ -307,9 +307,31 @@ melde("=== 4. Was man sieht ==="); schwebende Satz auf dem, was folgt. Gemessen wird die Ueberschneidung, nicht geschaetzt. */ - await seite.setViewportSize({ width: 390, height: 844 }); - await seite.waitForTimeout(500); - const eng = await seite.evaluate(() => { + /* EIN EIGENER KONTEXT MIT FINGER (29.09.2026). + + Hier stand `seite.setViewportSize({ width: 390 })`. Das + aendert nur die Groesse: `hasTouch` gehoert zum KONTEXT und + laesst sich danach nicht mehr setzen. Ohne ihn meldet der + Browser `pointer: fine`, und KEINE Regel aus + `@media (pointer: coarse)` greift -- dort stehen die + 44-Pixel-Beruehrziele. Genau sie entscheiden hier mit: + Hoehere Felder stehen enger beieinander, und ob ein + schwebender Hinweis das naechste ueberdeckt, haengt daran. + + Der kurze Weg zum Hinweis wird nachgefahren statt + uebernommen -- vier Schritte, dieselben wie oben. */ + const handyKontext = await browser.newContext({ + viewport: { width: 390, height: 844 }, hasTouch: true, isMobile: true }); + await handyKontext.addCookies(await sicht.cookies()); + const handy = await handyKontext.newPage(); + await handy.goto(`http://127.0.0.1:${PORT}/workspace/bereich.html?b=content`, + { waitUntil: "networkidle" }); + await handy.waitForTimeout(1600); + await handy.click("#neu-oeffnen"); + await handy.waitForTimeout(500); + await handy.fill("#f-datum", HEUTE); + await handy.waitForTimeout(500); + const eng = await handy.evaluate(() => { const h = document.getElementById("hinweis-datum"); if (!h || h.offsetHeight === 0) return { da: false }; const a2 = h.getBoundingClientRect(); @@ -323,8 +345,11 @@ melde("=== 4. Was man sieht ==="); ok(eng.da, "am Handy steht der Hinweis auch da"); ok(eng.da && eng.ueberdeckt === 0, `und liegt auf keinem anderen Feld (${eng.ueberdeckt} Ueberschneidungen)`); - await seite.setViewportSize({ width: 1280, height: 900 }); - await seite.waitForTimeout(400); + /* Das Handyfenster war ein eigener Kontext und geht hier zu. + `seite` war nie schmal -- deshalb gibt es auch nichts + zurueckzustellen; frueher stand hier ein `setViewportSize` + auf 1280, das die Umstellung rueckgaengig machte. */ + await handyKontext.close(); ok(konsole.length === 0, konsole.length ? `Konsolenfehler: ${konsole[0]}` : "kein Konsolenfehler"); diff --git a/server/pruef-werdegang.mjs b/server/pruef-werdegang.mjs index 36120d63..66298b32 100644 --- a/server/pruef-werdegang.mjs +++ b/server/pruef-werdegang.mjs @@ -770,18 +770,36 @@ melde("=== 11. Im Browser ==="); /* HANDY. Zwölf Seiten hatten am 06.09. genau hier ihren Fehler: ein Knopf lag über einem anderen, weil eine feste Schwelle nicht mehr passte. */ - await seite.setViewportSize({ width: 412, height: 915 }); - await seite.waitForTimeout(500); - const handy = await seite.evaluate(() => ({ + /* EIN EIGENER KONTEXT MIT FINGER (29.09.2026). + + Hier stand `seite.setViewportSize({ width: 412 })`. Das aendert + nur die Groesse: `hasTouch` gehoert zum KONTEXT und laesst sich + danach nicht mehr setzen. Ohne ihn meldet der Browser + `pointer: fine`, und KEINE Regel aus `@media (pointer: coarse)` + greift -- dort stehen die 44-Pixel-Beruehrziele, also genau die + Groessen, deren Ueberlappung dieser Abschnitt sucht. + + Die Anmeldung wandert als Keks mit, die Adresse kommt von der + Seite selbst -- keine zweite Wahrheit darueber, was gemessen + wird. */ + const handyKontext = await browser.newContext({ + viewport: { width: 412, height: 915 }, hasTouch: true, isMobile: true }); + await handyKontext.addCookies(await kontext.cookies()); + const handySeite = await handyKontext.newPage(); + await handySeite.goto(seite.url(), { waitUntil: "networkidle" }); + await handySeite.waitForTimeout(500); + const handy = await handySeite.evaluate(() => ({ breiter: document.documentElement.scrollWidth > document.documentElement.clientWidth + 1, balkenSichtbar: [...document.querySelectorAll('.w-bewegung__balken')] .every((b) => b.getBoundingClientRect().width >= 8), })); ok(!handy.breiter, "auf 412 px steht nichts über den Rand hinaus"); ok(handy.balkenSichtbar, "und die Balken sind noch breit genug, um sie zu sehen"); + await handyKontext.close(); if (process.env.SCHIRM) { - await seite.setViewportSize({ width: 1280, height: 1100 }); + /* `seite` war nie schmal -- das fruehere Zurueckstellen auf + 1280 ist damit hinfaellig. */ await seite.waitForTimeout(400); await seite.screenshot({ path: "C:/Users/qciga/Documents/Obelix/DogiHompage/pruef-werdegang.png",