n.siegfried
4d3258113a
Containing block first, as the task asks. The drawer is a body child with no
transformed ancestor, so its containing block was already the viewport - the
positioning context was never wrong. What was wrong was `top: 0` with
`height: 100vh`: the drawer started at the very top of the viewport, and the
creator's .header is sticky with z-index:100 against the drawer's 61. The
header won, so the drawer's own head - its title and its close button - was
roofed over and unreachable. It read as "off-screen" because the part you
needed was covered, not because the box had escaped the viewport.
That is why raising z-index would have been the wrong move: it does not remove
the collision, it just swaps which element is on top, and then the drawer
covers the header instead. The fix is to stop them occupying the same band.
The drawer now starts at var(--rail-top) and is that much shorter. --rail-top
is the header's measured height, set by wp-creation-app.js:1328 and already
used by .wp-nav for exactly this purpose, so "below the header" has one
definition on this page rather than two.
The iframe boundary is NOT implicated. position:fixed inside the embedded
creator resolves against the iframe's own viewport, which is self-consistent,
and the drawer behaves identically framed and unframed. T7.1 can dissolve the
boundary without revisiting this.
The probe was checking one width, one mode, and placement only. It now checks
390 and 1440, standalone and embedded, that the close button is genuinely
hit-testable via elementFromPoint rather than merely present, that the drawer
reopens after closing, and that opening it does not move the page's scroll
position. All pass.
One honest caveat, attributed rather than hidden. At 390px the drawer sits at
the right edge of a 485px layout viewport while the screen is 390px, so 95px of
it is off-screen. That is not the drawer: the creator forces its containing
block to 485px, and while chasing it I found BL-001's root cause -
wp-creation-app.js:1389 injects `body{--nav-w:288px}` with no media query,
which lands after wp-creation-styles.css:815's
`@media (max-width:860px){body{--nav-w:56px}}` and overrides it, so the page
reserves 288px of rail that is not there at any width. Every `right: 0` fixed
element on the page is displaced by it, not only this one.
Left unfixed on purpose - it is the creator's layout, T7.1 rebuilds it, and
CLAUDE.md is explicit about not fixing things noticed in passing. BL-001 now
carries the exact cause and the five rules that consume the token, so T7.1 does
not have to find it again. The probe reports it as an attributed note naming
BL-001, so nobody is sent to the wrong file.
browser_check 71/71. f_items: F1, F2, F3, F4 FIXED.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
503 lines
24 KiB
Python
503 lines
24 KiB
Python
#!/usr/bin/env python3
|
|
"""Does each of F1-F6 still reproduce? Measured in a browser, not read from source.
|
|
|
|
T0.2 has to record reproduces / does not reproduce for every rendering defect before
|
|
wave 1 starts fixing them, and waves 1-3 have to prove each one stopped. Both halves
|
|
are the same measurement, so this is one script that reports either way:
|
|
|
|
REPRODUCES the defect is present -- correct before its fix lands
|
|
FIXED the defect is gone -- correct after
|
|
INCONCLUSIVE the probe could not decide; never silently a pass
|
|
|
|
python tests/f_items.py # all six
|
|
python tests/f_items.py F2 F5 # a subset, e.g. after one task
|
|
|
|
Self-contained on the same terms as tests/browser_check.py, whose seed() and
|
|
start_server() it reuses: throwaway SQLite, its own uvicorn, headless Edge or
|
|
Chrome, all torn down afterwards. Your real database is never touched.
|
|
|
|
Each probe states the threshold it applies, because "the drawer is off-screen" and
|
|
"the fields look disabled" are judgements a screenshot cannot settle in CI. Where the
|
|
review gave a number, that number is the threshold.
|
|
|
|
Exit codes: 0 ran to completion (read the report) - 2 could not run.
|
|
"""
|
|
import argparse
|
|
import json
|
|
import os
|
|
import shutil
|
|
import sys
|
|
import tempfile
|
|
import time
|
|
|
|
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
|
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
|
|
|
import cdp # noqa: E402
|
|
from browser_check import seed, start_server # noqa: E402
|
|
|
|
# Project names and page copy contain em dashes and other non-cp1252 characters, and
|
|
# the default Windows console encoding raises UnicodeEncodeError on them mid-run.
|
|
try:
|
|
sys.stdout.reconfigure(encoding="utf-8", errors="replace")
|
|
except (AttributeError, ValueError): # pragma: no cover
|
|
pass
|
|
|
|
REPRO, FIXED, UNKNOWN = "REPRODUCES", "FIXED", "INCONCLUSIVE"
|
|
_RESULTS = []
|
|
|
|
# F3 only breaks with a real project name. "Micron EUV Cleanroom Enable 2667008" is
|
|
# the one the review used and the one that overflows the header.
|
|
LONG_ID = "projLong"
|
|
LONG_NAME = "Micron EUV Cleanroom Enable 2667008"
|
|
|
|
|
|
def add_long_project(db_path):
|
|
"""Add the long-named project to the seeded database, before the server starts.
|
|
|
|
It has to exist in the database rather than be faked in localStorage: every page
|
|
reached with ?project= re-pulls the project from the server, which would overwrite
|
|
a local fake and quietly measure the short name instead -- a false FIXED."""
|
|
os.environ["DATABASE_URL"] = "sqlite:///" + db_path.replace("\\", "/")
|
|
from server.db import SessionLocal
|
|
from server import models
|
|
with SessionLocal() as db:
|
|
db.add(models.Project(id=LONG_ID, name=LONG_NAME, number="2667008",
|
|
client="Micron"))
|
|
db.flush()
|
|
db.add(models.ProjectMember(id="pmLong", user_id="user_root",
|
|
project_id=LONG_ID, role=""))
|
|
db.commit()
|
|
|
|
|
|
def _c(s, code):
|
|
return f"\033[{code}m{s}\033[0m" if sys.stdout.isatty() else s
|
|
|
|
|
|
def report(item, verdict, detail):
|
|
colour = {REPRO: "31", FIXED: "32", UNKNOWN: "33"}[verdict]
|
|
_RESULTS.append((item, verdict, detail))
|
|
print(f" {item:3s} {_c(verdict, colour):22s} {detail}")
|
|
|
|
|
|
def rect(page, sel):
|
|
"""Bounding box of the first match, or None. Zero-size counts as absent."""
|
|
got = page.eval(
|
|
f"(function(){{var e=document.querySelector({sel!r});if(!e)return 'null';"
|
|
"var r=e.getBoundingClientRect();"
|
|
"return JSON.stringify({x:r.x,y:r.y,w:r.width,h:r.height,"
|
|
"right:r.right,bottom:r.bottom,text:(e.textContent||'').trim().slice(0,60)});})()")
|
|
if not got or got == "null":
|
|
return None
|
|
r = json.loads(got)
|
|
return None if r["w"] == 0 and r["h"] == 0 else r
|
|
|
|
|
|
# ── F1 ────────────────────────────────────────────────────────────────────────
|
|
def f1(page, base, tok):
|
|
"""App bar stale while the page body shows the active project.
|
|
|
|
Driven through the real control: land on the launcher with storage cleared, pick a
|
|
project from the picker, and read both labels without reloading. That is the
|
|
interaction the review describes -- the hero and the picker update, the app bar
|
|
does not, because wp-chrome.js renders projectLabel() once and only refreshes it
|
|
on the /api/projects callback, never on the selection itself.
|
|
|
|
Priming localStorage before load would hide this, so it is cleared first."""
|
|
page.clear_cookies()
|
|
page.set_cookie("wp_session", tok["root"])
|
|
page.viewport(1440)
|
|
page.goto(base + "/index.html")
|
|
page.eval("localStorage.clear(); true")
|
|
page.goto(base + "/index.html", wait_for="!!document.querySelector('.wpc-proj-name')")
|
|
time.sleep(1.3) # let /api/projects land and wpcRefresh run
|
|
|
|
picked = page.eval("""(function(){
|
|
var s=document.querySelector('select'); if(!s) return 'no-select';
|
|
var o=[].slice.call(s.options).filter(function(x){return x.value==='projA';})[0];
|
|
if(!o) return 'no-projA';
|
|
s.value='projA'; s.dispatchEvent(new Event('change',{bubbles:true}));
|
|
return 'ok';})()""")
|
|
if picked != "ok":
|
|
return report("F1", UNKNOWN, f"could not drive the project picker ({picked})")
|
|
time.sleep(1.4) # generous: a correct fix may re-render async
|
|
|
|
bar = rect(page, ".wpc-proj-name")
|
|
hero = rect(page, "#hero-title")
|
|
if not bar or not hero:
|
|
return report("F1", UNKNOWN, "app bar or hero not found after selection")
|
|
stored = page.eval("localStorage.getItem('wp_active_project')")
|
|
reloaded = page.eval("location.search")
|
|
|
|
bar_txt, hero_txt = bar["text"], hero["text"]
|
|
body_knows = "Job A" in hero_txt
|
|
bar_knows = "Job A" in bar_txt
|
|
if body_knows and not bar_knows:
|
|
return report("F1", REPRO,
|
|
f"picked Job A: hero {hero_txt!r}, app bar still {bar_txt!r} "
|
|
f"(wp_active_project={stored!r}, no reload{', url ' + reloaded if reloaded else ''})")
|
|
if not body_knows:
|
|
return report("F1", UNKNOWN,
|
|
f"selection did not reach the hero either (hero {hero_txt!r}) - probe drove the wrong control")
|
|
return report("F1", FIXED,
|
|
f"app bar {bar_txt!r} tracks hero {hero_txt!r} in the same interaction")
|
|
|
|
|
|
# ── F2 ────────────────────────────────────────────────────────────────────────
|
|
def f2(page, base, tok):
|
|
"""App bar clips at 390px. The review names Sign out cut in half and search
|
|
truncated, on the field view. Threshold: any bar control whose box crosses the
|
|
viewport edge, or a bar that scrolls wider than it is."""
|
|
page.clear_cookies()
|
|
page.set_cookie("wp_session", tok["root"])
|
|
page.viewport(390, 900, mobile=True)
|
|
page.goto(base + "/field.html")
|
|
page.eval("localStorage.setItem('wp_active_project','projA');"
|
|
"localStorage.setItem('wp_active_project_obj',"
|
|
"JSON.stringify({id:'projA',name:'Job A',number:'A-1'})); true")
|
|
page.goto(base + "/field.html", wait_for="!!document.querySelector('.wp-appbar')")
|
|
time.sleep(0.8)
|
|
|
|
over = page.eval("""(function(){
|
|
var bar=document.querySelector('.wp-appbar'); if(!bar) return 'null';
|
|
var vw=document.documentElement.clientWidth, out=[];
|
|
bar.querySelectorAll('a,button,input').forEach(function(e){
|
|
var r=e.getBoundingClientRect();
|
|
if(r.width===0&&r.height===0) return;
|
|
if(r.right>vw+0.5||r.left<-0.5)
|
|
out.push(((e.textContent||e.placeholder||e.tagName).trim().slice(0,26))
|
|
+' @'+Math.round(r.left)+'-'+Math.round(r.right));
|
|
});
|
|
var br=bar.getBoundingClientRect();
|
|
return JSON.stringify({vw:vw, rows:Math.round(br.height/48), clipped:out,
|
|
scrollW:bar.scrollWidth, clientW:bar.clientWidth});})()""")
|
|
if over == "null":
|
|
return report("F2", UNKNOWN, ".wp-appbar not found on field.html")
|
|
m = json.loads(over)
|
|
if m["clipped"] or m["scrollW"] > m["clientW"]:
|
|
why = f"{len(m['clipped'])} control(s) past the {m['vw']}px edge"
|
|
if m["clipped"]:
|
|
why += ": " + "; ".join(m["clipped"][:3])
|
|
if m["scrollW"] > m["clientW"]:
|
|
why += f" | bar {m['scrollW']}px in {m['clientW']}px"
|
|
return report("F2", REPRO, why + f" | ~{m['rows']} row(s) tall")
|
|
return report("F2", FIXED, f"no control past {m['vw']}px, bar {m['rows']} row(s)")
|
|
|
|
|
|
# ── F3 ────────────────────────────────────────────────────────────────────────
|
|
def f3(page, base, tok):
|
|
""".header-left and the injected chrome overlap in the SOP header. Verified with
|
|
the real long project name, which is what the review says breaks it. Threshold:
|
|
the two boxes intersect by more than 2px on both axes."""
|
|
page.clear_cookies()
|
|
page.set_cookie("wp_session", tok["root"])
|
|
page.viewport(1440)
|
|
# Measure against the LOGO, not against .header-left. With the long name
|
|
# .header-left (flex:1, min-width:0) collapses to clientWidth 0, so comparing its
|
|
# box to the chrome's reports a tidy zero gap while the chrome is in fact painting
|
|
# straight across the logo. The logo is flex-shrink:0, so it is the one box in the
|
|
# bar whose position means something.
|
|
hits, measured, clear = [], 0, []
|
|
for w in (390, 768, 1024, 1440):
|
|
page.viewport(w, 900, mobile=(w <= 500))
|
|
page.goto(base + f"/work-package-suite.html?project={LONG_ID}",
|
|
wait_for="!!document.querySelector('.header-left')")
|
|
time.sleep(0.9)
|
|
got = page.eval("""(function(){
|
|
var hdr=document.querySelector('.header'),
|
|
hl=document.querySelector('.header-left'),
|
|
logo=document.querySelector('.header-left .logo');
|
|
if(!hdr||!hl||!logo) return 'null';
|
|
// Every group sharing this bar, not just the two the review named: the
|
|
// markup's own, plus what wp-chrome.js and auth-guard.js inject into it.
|
|
var boxes=[];
|
|
['.header-left','.wp-chrome','.header-right','#wp-usermenu'].forEach(function(s){
|
|
var e=hdr.querySelector(s); if(!e) return;
|
|
var r=e.getBoundingClientRect();
|
|
if(r.width>0||r.height>0) boxes.push({s:s,r:r});
|
|
});
|
|
var pairs=[];
|
|
for(var i=0;i<boxes.length;i++) for(var j=i+1;j<boxes.length;j++){
|
|
var A=boxes[i].r,B=boxes[j].r;
|
|
var ox=Math.min(A.right,B.right)-Math.max(A.left,B.left);
|
|
var oy=Math.min(A.bottom,B.bottom)-Math.max(A.top,B.top);
|
|
if(ox>1&&oy>1) pairs.push(boxes[i].s+'/'+boxes[j].s+' '+Math.round(ox)+'x'+Math.round(oy));
|
|
}
|
|
// The logo is flex-shrink:0 and keeps its width even when its parent is
|
|
// crushed, so check it against the chrome directly too.
|
|
var ch=hdr.querySelector('.wpc-proj')||hdr.querySelector('.wp-chrome');
|
|
var lox=0,loy=0;
|
|
if(ch){var L=logo.getBoundingClientRect(),C=ch.getBoundingClientRect();
|
|
lox=Math.min(C.right,L.right)-Math.max(C.left,L.left);
|
|
loy=Math.min(C.bottom,L.bottom)-Math.max(C.top,L.top);}
|
|
// Anything spilling past the bar lands on the tab row underneath it.
|
|
var H=hdr.getBoundingClientRect(), spill=0;
|
|
[].forEach.call(hdr.children,function(e){
|
|
var r=e.getBoundingClientRect();
|
|
if(r.width===0&&r.height===0) return;
|
|
if(r.bottom>H.bottom+1||r.top<H.top-1) spill++;
|
|
});
|
|
return JSON.stringify({
|
|
pairs:pairs, ox:Math.round(lox), oy:Math.round(loy), spill:spill,
|
|
collapsed: hl.clientWidth===0 && hl.scrollWidth>0,
|
|
hlsw:hl.scrollWidth, hlcw:hl.clientWidth,
|
|
name:((document.querySelector('.wpc-proj-name')||{}).textContent||'').trim()});})()""")
|
|
if got == "null":
|
|
continue
|
|
measured += 1
|
|
o = json.loads(got)
|
|
why = []
|
|
if o["ox"] > 1 and o["oy"] > 1:
|
|
why.append(f"chrome over the logo by {o['ox']}x{o['oy']}px")
|
|
if o["collapsed"]:
|
|
why.append(f".header-left collapsed to 0 (content {o['hlsw']}px)")
|
|
if o["pairs"]:
|
|
why.append("overlapping groups: " + "; ".join(o["pairs"]))
|
|
if o["spill"]:
|
|
why.append(f"{o['spill']} group(s) spilling out of the bar")
|
|
if why:
|
|
hits.append(f"{w}px: " + ", ".join(why))
|
|
else:
|
|
clear.append(f"{w}px")
|
|
if not measured:
|
|
return report("F3", UNKNOWN,
|
|
".header-left, its logo and the injected chrome were never all present")
|
|
if hits:
|
|
return report("F3", REPRO, "; ".join(hits))
|
|
return report("F3", FIXED,
|
|
f"logo clear of the chrome and .header-left intact at {', '.join(clear)} "
|
|
f"with the long project name")
|
|
|
|
|
|
# ── F4 ────────────────────────────────────────────────────────────────────────
|
|
def f4(page, base, tok):
|
|
"""Comments drawer renders off-screen and over the header in the STANDALONE
|
|
creator (no ?embedded=1). Threshold: once open, the drawer's box sits wholly or
|
|
partly outside the viewport, or intersects the header."""
|
|
MEASURE = """(function(){
|
|
var d=document.querySelector('#cmt-drawer'); if(!d) return 'null';
|
|
var r=d.getBoundingClientRect();
|
|
var vw=document.documentElement.clientWidth, vh=document.documentElement.clientHeight;
|
|
var open=d.classList.contains('open')||d.getAttribute('aria-hidden')==='false';
|
|
var hdr=document.querySelector('.header,.wp-appbar,header');
|
|
var ov=null;
|
|
if(hdr){var h=hdr.getBoundingClientRect();
|
|
var ox=Math.min(r.right,h.right)-Math.max(r.left,h.left);
|
|
var oy=Math.min(r.bottom,h.bottom)-Math.max(r.top,h.top);
|
|
if(ox>2&&oy>2) ov=Math.round(ox)+'x'+Math.round(oy);}
|
|
// The head carries the title and the close button. If it is not hit-testable
|
|
// the drawer is unusable however tidy its box looks.
|
|
var head=d.querySelector('.cmt-head'), x=d.querySelector('.cmt-x'), reach=null;
|
|
if(x){var q=x.getBoundingClientRect();
|
|
var top=document.elementFromPoint(Math.round(q.left+q.width/2), Math.round(q.top+q.height/2));
|
|
reach = !!(top && (top===x || x.contains(top)));}
|
|
// A page whose layout viewport is wider than the screen puts every `right:0`
|
|
// fixed element off the visible area, drawer included. That is the page's
|
|
// overflow, not the drawer's placement, so it is reported separately -
|
|
// blaming the drawer for it sends the next person to the wrong file.
|
|
var icb=window.innerWidth;
|
|
return JSON.stringify({open:open,x:Math.round(r.x),right:Math.round(r.right),
|
|
top:Math.round(r.top),bottom:Math.round(r.bottom),vw:vw,vh:vh,icb:icb,
|
|
offscreen:(r.right>icb+2||r.x<-2||r.top<-2||r.bottom>vh+2),
|
|
overHeader:ov, closeReachable:reach,
|
|
headH: head?Math.round(head.getBoundingClientRect().height):0});})()"""
|
|
|
|
def toggle():
|
|
try:
|
|
page.click("#comments-btn", settle=0.9)
|
|
except Exception:
|
|
page.eval("typeof toggleComments==='function'?(toggleComments(),true):false")
|
|
time.sleep(0.9)
|
|
|
|
problems, notes = [], []
|
|
for mode, qs in (("standalone", ""), ("embedded", "&embedded=1")):
|
|
for w in (390, 1440):
|
|
page.clear_cookies()
|
|
page.set_cookie("wp_session", tok["root"])
|
|
page.viewport(w, 900, mobile=(w <= 500))
|
|
page.goto(base + f"/wp-creation-index.html?project=projA{qs}",
|
|
wait_for="!!document.querySelector('#cmt-drawer')")
|
|
time.sleep(1.0)
|
|
# Scroll down first: the drawer must not cost the user their place.
|
|
page.eval("window.scrollTo(0, 600); true")
|
|
time.sleep(0.3)
|
|
before_y = page.eval("Math.round(window.scrollY)")
|
|
|
|
toggle()
|
|
m = page.eval(MEASURE)
|
|
if m == "null":
|
|
problems.append(f"{mode}@{w}: #cmt-drawer missing")
|
|
continue
|
|
d = json.loads(m)
|
|
if not d["open"]:
|
|
notes.append(f"{mode}@{w}: did not open")
|
|
continue
|
|
if d["offscreen"]:
|
|
problems.append(f"{mode}@{w}: box {d['x']}-{d['right']} x {d['top']}-{d['bottom']} "
|
|
f"outside {d['icb']}x{d['vh']}")
|
|
elif d["icb"] > w + 2:
|
|
# Compared against the width we ASKED for, not clientWidth, which is
|
|
# short by the scrollbar and would flag every page as overflowing.
|
|
notes.append(f"{mode}@{w}: correctly at the right edge of a {d['icb']}px layout "
|
|
f"viewport, but the screen is {w}px - page overflow, BL-001")
|
|
if d["overHeader"]:
|
|
problems.append(f"{mode}@{w}: overlaps the header by {d['overHeader']}px")
|
|
if d["closeReachable"] is False:
|
|
problems.append(f"{mode}@{w}: close button covered by another element")
|
|
|
|
# close, reopen, and check the page did not jump
|
|
toggle()
|
|
time.sleep(0.4)
|
|
toggle()
|
|
m2 = json.loads(page.eval(MEASURE))
|
|
if not m2["open"]:
|
|
problems.append(f"{mode}@{w}: did not reopen")
|
|
elif m2["offscreen"] or m2["overHeader"]:
|
|
problems.append(f"{mode}@{w}: misplaced after reopen")
|
|
after_y = page.eval("Math.round(window.scrollY)")
|
|
if abs(after_y - before_y) > 4:
|
|
problems.append(f"{mode}@{w}: scroll moved {before_y}->{after_y}")
|
|
toggle()
|
|
|
|
if problems:
|
|
return report("F4", REPRO, "; ".join(problems[:4]))
|
|
if len(notes) >= 4:
|
|
return report("F4", UNKNOWN, "drawer never opened: " + "; ".join(notes[:2]))
|
|
detail = "on screen, clear of the header, reopens, scroll kept - at 390 and 1440, standalone and embedded"
|
|
return report("F4", FIXED, detail + (f" ({'; '.join(notes)})" if notes else ""))
|
|
|
|
|
|
# ── F5 ────────────────────────────────────────────────────────────────────────
|
|
def f5(page, base, tok):
|
|
"""SOP wizard inputs read as read-only. The review names the exact colours:
|
|
#f4f4f4 fill, #e0e0e0 border, because the wizard never sees --cds-field #ffffff.
|
|
Threshold: an ENABLED input computing to that fill."""
|
|
page.clear_cookies()
|
|
page.set_cookie("wp_session", tok["root"])
|
|
page.viewport(1440)
|
|
page.goto(base + "/work-package-suite.html?project=projA",
|
|
wait_for="!!document.querySelector('.field input, .field select')")
|
|
time.sleep(0.9)
|
|
got = page.eval("""(function(){
|
|
var out=[], n=0;
|
|
document.querySelectorAll('.field input,.field select,.field textarea').forEach(function(e){
|
|
if(e.disabled||e.readOnly||e.type==='hidden'||e.type==='checkbox'||e.type==='radio') return;
|
|
var r=e.getBoundingClientRect(); if(r.width===0&&r.height===0) return;
|
|
n++;
|
|
var s=getComputedStyle(e);
|
|
out.push(s.backgroundColor+' | '+s.borderTopColor);
|
|
});
|
|
var tally={}; out.forEach(function(v){tally[v]=(tally[v]||0)+1;});
|
|
return JSON.stringify({n:n,tally:tally});})()""")
|
|
m = json.loads(got)
|
|
if not m["n"]:
|
|
return report("F5", UNKNOWN, "no enabled wizard inputs found")
|
|
GREY = ("rgb(244, 244, 244)", "rgb(243, 243, 243)")
|
|
greyed = sum(c for k, c in m["tally"].items() if any(g in k for g in GREY))
|
|
top = sorted(m["tally"].items(), key=lambda kv: -kv[1])[0]
|
|
if greyed:
|
|
return report("F5", REPRO,
|
|
f"{greyed}/{m['n']} enabled inputs fill #f4f4f4 (most common: {top[0]})")
|
|
return report("F5", FIXED, f"{m['n']} enabled inputs, none grey-filled (most common: {top[0]})")
|
|
|
|
|
|
# ── F6 ────────────────────────────────────────────────────────────────────────
|
|
def f6(page, base, tok):
|
|
"""The creator is one very tall form: the review counted 11 cards and ~4,700px
|
|
with jump links standing in for structure. Threshold: no sectioning control
|
|
(tabs/steps) and every card in the document flow at once."""
|
|
page.clear_cookies()
|
|
page.set_cookie("wp_session", tok["root"])
|
|
page.viewport(1440)
|
|
page.goto(base + "/wp-creation-index.html?project=projA",
|
|
wait_for="!!document.querySelector('.card, .section')")
|
|
time.sleep(1.0)
|
|
got = page.eval("""(function(){
|
|
var h=document.documentElement.scrollHeight;
|
|
var cards=document.querySelectorAll('.card,.wp-card,section.card').length;
|
|
var vis=0;
|
|
document.querySelectorAll('.card,.wp-card,section.card').forEach(function(e){
|
|
var s=getComputedStyle(e);
|
|
if(s.display!=='none'&&s.visibility!=='hidden') vis++;});
|
|
var tabs=document.querySelectorAll('[role=tab],.tab,.section-tab').length;
|
|
var jump=document.querySelectorAll('a[href^="#"]').length;
|
|
return JSON.stringify({h:h,cards:cards,vis:vis,tabs:tabs,jump:jump});})()""")
|
|
m = json.loads(got)
|
|
if m["vis"] > 1 and not m["tabs"] and m["h"] > 3000:
|
|
return report("F6", REPRO,
|
|
f"{m['vis']} cards in one {m['h']}px scroll, {m['tabs']} tabs, "
|
|
f"{m['jump']} jump link(s)")
|
|
if m["tabs"]:
|
|
return report("F6", FIXED,
|
|
f"{m['tabs']} sectioning control(s), {m['vis']} card(s) visible, {m['h']}px")
|
|
return report("F6", UNKNOWN,
|
|
f"{m['vis']} card(s), {m['h']}px, {m['tabs']} tabs - below the 3000px threshold")
|
|
|
|
|
|
PROBES = {"F1": f1, "F2": f2, "F3": f3, "F4": f4, "F5": f5, "F6": f6}
|
|
|
|
|
|
def main():
|
|
ap = argparse.ArgumentParser(description=__doc__,
|
|
formatter_class=argparse.RawDescriptionHelpFormatter)
|
|
ap.add_argument("items", nargs="*", default=[], help="subset, e.g. F2 F5")
|
|
ap.add_argument("--base-url", default="")
|
|
args = ap.parse_args()
|
|
|
|
wanted = [i.upper() for i in args.items] or list(PROBES)
|
|
bad = [i for i in wanted if i not in PROBES]
|
|
if bad:
|
|
print(f"unknown item(s): {', '.join(bad)}; known: {', '.join(PROBES)}")
|
|
return 2
|
|
if not cdp.find_browser():
|
|
print("no headless-capable browser found (set WP_BROWSER)")
|
|
return 2
|
|
|
|
tmpdir = tempfile.mkdtemp(prefix="wpsuite-f-items-")
|
|
db_path = os.path.join(tmpdir, "f.db")
|
|
proc = browser = None
|
|
try:
|
|
tok = seed(db_path)
|
|
add_long_project(db_path)
|
|
if args.base_url:
|
|
base = args.base_url.rstrip("/")
|
|
else:
|
|
port = cdp.free_port()
|
|
proc = start_server(port, db_path)
|
|
base = f"http://127.0.0.1:{port}"
|
|
if not proc:
|
|
print("the server would not start")
|
|
return 2
|
|
|
|
print(f"\n probing {', '.join(wanted)}\n")
|
|
browser = cdp.Browser()
|
|
page = browser.page()
|
|
for item in wanted:
|
|
try:
|
|
PROBES[item](page, base, tok)
|
|
except Exception as exc: # noqa: BLE001
|
|
report(item, UNKNOWN, f"probe raised: {str(exc)[:120]}")
|
|
|
|
r = sum(1 for _, v, _ in _RESULTS if v == REPRO)
|
|
f = sum(1 for _, v, _ in _RESULTS if v == FIXED)
|
|
u = sum(1 for _, v, _ in _RESULTS if v == UNKNOWN)
|
|
print(f"\n {_c(str(r) + ' reproduce', '31')}, {_c(str(f) + ' fixed', '32')}"
|
|
+ (f", {_c(str(u) + ' inconclusive', '33')}" if u else "") + "\n")
|
|
return 0
|
|
finally:
|
|
if browser:
|
|
browser.close()
|
|
if proc:
|
|
proc.kill()
|
|
proc.wait(timeout=10)
|
|
try:
|
|
from server.db import engine
|
|
engine.dispose()
|
|
except Exception: # noqa: BLE001
|
|
pass
|
|
shutil.rmtree(tmpdir, ignore_errors=True)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|