n.siegfried/Project-SDE-WP-Suite
3
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity
Files
b97ccd7ad87df14afd344383a3008f7e5d2e09a1
Project-SDE-WP-Suite/tests/launcher_check.py
Cody Schaefer c47b2ae210 T10.7 D13 - the suite runs without a domain controller 
Far smaller than estimated, because the premise was wrong. I had said four
checks sign in and would each need a fake directory. They do not: seed() mints
a session token with auth.create_token() and sets the cookie directly -
browser_check's own docstring says so - and the only breakage was a leftover
password_hash= kwarg on a model that no longer has the column. Deleting that one
line in browser_check.seed() unblocked 39 files that import seed/start_server
from it. launcher_check needed the same.

console_dialogs_check's password-reset half is deleted rather than ported. Its
docstring now records what went and where the prompt kit is still covered
(wpPromptDialog has five callers left in wp-creation-app.js; creator_dialogs_check
exercises them, validation included - verified, 20/20). Nothing was left skipped
in place of the removed section.

Exactly one check genuinely needed a seam: url_state_check drives the real login
form to prove a deep link's ?next= survives authentication. That cannot be faked
by minting a cookie, because the login round trip is the thing under test.

The seam is env-driven because it has to be: start_server launches the app as a
SUBPROCESS, so a monkeypatch in the test process would never reach the code doing
the authenticating. server/ldap_fake.py reads WP_LDAP_FAKE_DIRECTORY and
ldap_auth dispatches to it AFTER the empty-input guard, so the anonymous-bind
guard covers the fake path too - a fake that reimplemented it would let the real
one rot unnoticed.

The production guard is the point of that module. An env var that makes any
password work is exactly the kind of thing that escapes into production, and D13
left no other way in. is_active() refuses whenever a non-SQLite DATABASE_URL is
configured - the same test auth._load_secret uses - and describe() shouts in
capitals so a fake run can never be mistaken for a real one in the startup log.

Two things found on the way, neither of them the app's fault:

- url_state_check's "signing in continues to the requested page" asserted
  `"wp-creation-index.html" in location.href`. That string is in the ?next=
  parameter too, so it passed while sitting on login.html with the sign-in
  rejected. It would have passed with login entirely broken. Tightened to assert
  we actually left the login page.
- Two assertions in my own new ldap_auth_check read the WRONG database:
  server/db.py binds its engine from DATABASE_URL at import, so setting the env
  var afterwards keeps reading whichever file was configured first. users_in()
  now opens the file it is asked about with sqlite3. The CERT_NONE check also had
  to become an AST walk - the module docstring names validate=ssl.CERT_NONE in
  order to explain why it is banned, and a text search cannot tell that apart
  from a real call.

tests/ldap_auth_check.py is new coverage rather than repair: the anonymous-bind
guard, CERT_REQUIRED by AST, the nested matching rule in the filter, the
production refusal, a refused sign-in creating no account, and an existing admin
still being an admin with their locally-set name intact. 20/20.

Run so far, all green: browser_check 71/71, launcher_check 58/58,
console_dialogs 12/12, url_state 23/23, qa_gate 41/41, critical_reopen 11/11,
creator_dialogs 20/20, a11y 22/22, kitting_notify 17/17, ldap_auth 20/20.
A full sweep of the remaining ~30 is running; its box stays unticked until it
reports.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-24 09:18:05 -05:00

403 lines
18 KiB
Python
Raw Blame History

#!/usr/bin/env python3
"""The launcher's project entry points — B3 (T5.2).
B3's warning is about ORDER: the proposal removes the project-picker card, and
the first-run empty state was built inside it. Remove the card first and every
brand-new account lands on a page whose only instruction is to choose from a list
with nothing in it.
So the state that matters most here is the one the fixture does not naturally
produce — an account with zero projects — and it is tested against a database
seeded with none, not by hiding rows in the browser.
1. a brand-new account with zero projects sees a clear path to create one
2. the sample project stays discoverable from that empty state
3. the picker card is gone, and nothing on the page re-creates it
4. switching projects still works from the app bar for users who have projects
5. creating a project from the launcher still works, end to end
6. the rebuilt form is accessible: labelled, keyboard-reachable, and its
validation lands at the field rather than in a native dialog (C1)
Exit 0 all passed, 1 a failure, 2 could not run.
"""
import json
import os
import subprocess
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, chk, _PASS, _FAIL, _c, PW # noqa: E402
STUB = """
window.__dialogs = [];
window.alert = function (m) { window.__dialogs.push(['alert', String(m)]); };
window.confirm = function (m) { window.__dialogs.push(['confirm', String(m)]); return false; };
window.prompt = function (m) { window.__dialogs.push(['prompt', String(m)]); return null; };
true
"""
READY = "!!(document.getElementById('proj-status') && !document.querySelector('.proj-loading'))"
def seed_empty(db_path):
"""One account, no projects at all. This is the state B3 is about, and no
existing fixture has it — browser_check's seeds two projects precisely so the
scoping assertions have something to scope."""
os.environ["DATABASE_URL"] = "sqlite:///" + db_path.replace("\\", "/")
os.environ.setdefault("AUTH_SECRET_KEY", "browser-check-secret-not-for-production")
from server.db import SessionLocal, Base, engine
from server import models, auth
Base.metadata.create_all(bind=engine)
with SessionLocal() as db:
db.add(models.User(id="user_new", username="new", email="new@example.test",
full_name="New Starter", role=auth.ROLE_ADMIN))
db.commit()
return {u.username: auth.create_token(u) for u in db.query(models.User).all()}
def settle(seconds=1.4):
time.sleep(seconds)
def js_errors(page):
"""page.js_errors() minus one known false alarm.
A project with no SOP yet answers GET /api/sops/latest with 404, correctly —
and the browser logs every 404 resource at error level whatever the app does
about it. browser_check.py's fixture seeds a SOP to sidestep this; a probe
that CREATES a project cannot, because a brand-new project has no SOP by
definition. That is exactly the state under test, so the entry is filtered by
name rather than the check being dropped."""
return [e for e in page.js_errors() if "/api/sops/latest" not in e]
def visible(page, sel):
return page.eval(
"(() => { const e = document.querySelector(%r); if (!e) return false; "
"const r = e.getBoundingClientRect(); return !!(r.width && r.height); })()" % sel)
def run_empty(page, base, tok):
print("\n1 + 2. a brand-new account with no projects at all")
page.clear_cookies()
page.set_cookie("wp_session", tok["new"])
page.goto(base + "/index.html", READY)
settle(1.6)
page.eval(STUB)
chk("the page boots with no JavaScript errors", not page.js_errors(), page.js_errors())
chk("it says there are no projects yet", visible(page, "#first-run"))
chk("...and explains what a project is for, not just that there are none",
len((page.eval("(document.getElementById('first-run')||{}).textContent||''")).strip()) > 120)
chk("the create form is open, not behind another click",
visible(page, "#new-project") and visible(page, "#np_name"))
chk("...headed as the first one", "first" in (page.eval(
"(document.getElementById('new-project-head')||{}).textContent||''")).lower(),
page.eval("(document.getElementById('new-project-head')||{}).textContent||''"))
chk("...with no Cancel, because there is nothing to cancel back to",
not visible(page, "#np-cancel"))
chk("the hero says create, not select",
"reate" in (page.eval("(document.getElementById('hero-sub')||{}).textContent||''")),
page.eval("(document.getElementById('hero-sub')||{}).textContent||''"))
chk("the sample project is offered from the empty state", visible(page, "#sample-offer"))
chk("...as a button that says what it does",
"sample" in (page.eval(
"(document.getElementById('use-sample-btn')||{}).textContent||''")).lower())
chk("no tool cards are shown over a project that does not exist",
not visible(page, "#overview"))
chk("...and no 'choose a project' prompt with nothing to choose from",
not visible(page, "#pick-prompt"))
print("\n6. the rebuilt create form is accessible (C1)")
labelled = json.loads(page.eval("""JSON.stringify(
[...document.querySelectorAll('#np-form input')].map(i => ({
id: i.id,
labelled: !!(i.labels && i.labels.length),
describedby: i.getAttribute('aria-describedby'),
tabindex: i.tabIndex,
})))"""))
chk("every input has a real label", labelled and all(f["labelled"] for f in labelled),
[f for f in labelled if not f["labelled"]])
chk("...and every one is keyboard reachable",
labelled and all(f["tabindex"] >= 0 for f in labelled))
chk("the required field points at its error region",
any(f["id"] == "np_name" and f["describedby"] == "np_name_err" for f in labelled),
labelled)
ring = page.eval("""(() => {
const i = document.getElementById('np_name');
i.focus();
if (document.activeElement !== i) return 'not focusable';
const cs = getComputedStyle(i);
return cs.outlineStyle !== 'none' && parseFloat(cs.outlineWidth) > 0
? 'ring ' + cs.outlineWidth + ' ' + cs.outlineColor : 'no ring';
})()""")
chk("...and shows a focus ring when focused (BL-014's third site)",
str(ring).startswith("ring"), ring)
print(" submitting it empty says so at the field, not in a dialog")
page.eval("document.getElementById('np-form').requestSubmit()")
settle(0.6)
chk("an empty submit is refused", visible(page, "#first-run"))
chk("...with the reason at the field",
bool((page.eval("(document.getElementById('np_name_err')||{}).textContent||''")).strip()),
page.eval("(document.getElementById('np_name_err')||{}).textContent||''"))
chk("...announced through a live region",
page.eval("(document.getElementById('np_name_err')||{}).getAttribute('role')") == "alert")
chk("...the field marked invalid",
page.eval("document.getElementById('np_name').getAttribute('aria-invalid')") == "true")
chk("...focus moved to it",
page.eval("(document.activeElement||{}).id") == "np_name")
chk("...and no native dialog was opened",
not json.loads(page.eval("JSON.stringify(window.__dialogs||[])")),
page.eval("JSON.stringify(window.__dialogs||[])"))
print("\n5. creating the first project works end to end")
page.eval("""(() => {
const n = document.getElementById('np_name');
n.value = 'First Job'; n.dispatchEvent(new Event('input', {bubbles:true}));
document.getElementById('np_number').value = 'FJ-1';
return true;
})()""")
page.eval("document.getElementById('np-form').requestSubmit()")
for _ in range(30):
if page.eval("!document.getElementById('overview') || "
"getComputedStyle(document.getElementById('overview')).display !== 'none'"):
break
time.sleep(0.3)
settle(1.2)
chk("the new project becomes the active one",
page.eval("(ProjectData.getActive()||{}).name") == "First Job",
page.eval("JSON.stringify(ProjectData.getActive()||{})"))
chk("...the tool cards appear", visible(page, "#overview"))
chk("...the first-run state stands down", not visible(page, "#first-run"))
chk("...and so does the sample offer", not visible(page, "#sample-offer"))
chk("...the hero names the project",
page.eval("(document.getElementById('hero-title')||{}).textContent") == "First Job")
chk("...and the URL carries it, so the address bar is shareable (S3)",
"project=" in page.eval("location.search"), page.eval("location.search"))
chk("no JavaScript error through the whole first-run flow",
not js_errors(page), js_errors(page))
print("\n2b. the sample project is reachable from the empty state")
page.eval("localStorage.clear()")
page.goto(base + "/index.html", READY)
settle(1.6)
page.eval(STUB)
# One project exists now, so this is the "projects exist, none active" state.
chk("with a project on the account but none chosen, the launcher says to choose",
visible(page, "#pick-prompt"))
chk("...and points at the app bar's switcher, not at a second list on the page",
"switcher" in (page.eval(
"(document.getElementById('pick-prompt-sub')||{}).textContent||''")).lower())
chk("...offering New project as well", visible(page, "#new-project-btn"))
chk("...with the create form closed until asked for", not visible(page, "#new-project"))
chk("...and the first-run state not shown to someone who is not new",
not visible(page, "#first-run"))
page.eval("document.getElementById('new-project-btn').click()")
settle(0.6)
chk("New project opens the form", visible(page, "#new-project"))
chk("...and moves focus into it",
page.eval("(document.activeElement||{}).id") == "np_name")
chk("...with Cancel available now that there is something to cancel to",
visible(page, "#np-cancel"))
page.eval("document.getElementById('np-cancel').click()")
settle(0.5)
chk("Cancel closes it again", not visible(page, "#new-project"))
chk("...and brings the choose-a-project prompt back", visible(page, "#pick-prompt"))
def run_populated(page, base, tok):
print("\n3 + 4. the picker card is gone; the app bar still switches")
page.clear_cookies()
page.set_cookie("wp_session", tok["root"])
page.goto(base + "/index.html?project=projA", READY)
settle(1.8)
page.eval(STUB)
chk("the page boots with no JavaScript errors", not page.js_errors(), page.js_errors())
chk("the picker card is gone", page.eval("!document.getElementById('project-section')"))
chk("...and so is its dropdown", page.eval("!document.getElementById('project-select')"))
chk("...and nothing else on the page lists projects to pick from",
page.eval("""(() => {
const inMain = [...document.querySelectorAll('.container select')];
return inMain.filter(s => s.options.length > 1).length === 0;
})()"""),
page.eval("[...document.querySelectorAll('.container select')].map(s => s.id)"))
chk("the app bar carries a project switcher",
page.eval("!!document.querySelector('.wp-appbar .wpc-proj-btn')"))
chk("...naming the active project",
"Job A" in (page.eval(
"(document.querySelector('.wpc-proj-name')||{}).textContent||''")),
page.eval("(document.querySelector('.wpc-proj-name')||{}).textContent||''"))
page.eval("document.querySelector('.wpc-proj-btn').click()")
settle(0.6)
chk("...it opens", page.eval(
"document.querySelector('.wpc-proj-btn').getAttribute('aria-expanded')") == "true")
chk("...and lists both projects on the account",
page.eval("document.querySelectorAll('.wpc-pop .wpc-item').length") == 2,
page.eval("document.querySelectorAll('.wpc-pop .wpc-item').length"))
chk("...its footer offers a new project rather than a list that moved",
"New project" in (page.eval(
"(document.querySelector('.wpc-pop-foot')||{}).textContent||''")),
page.eval("(document.querySelector('.wpc-pop-foot')||{}).textContent||''"))
chk("...pointing at the launcher's form",
"#new-project" in (page.eval(
"(document.querySelector('.wpc-foot-btn')||{}).getAttribute('href')||''") or ""),
page.eval("(document.querySelector('.wpc-foot-btn')||{}).getAttribute('href')||''"))
page.eval("""[...document.querySelectorAll('.wpc-pop .wpc-item')]
.find(b => /Job B/.test(b.textContent)).click()""")
for _ in range(30):
if "projB" in page.eval("location.search"):
break
time.sleep(0.3)
settle(1.6)
chk("switching from the bar changes project", "projB" in page.eval("location.search"),
page.eval("location.search"))
chk("...and the launcher follows it",
page.eval("(document.getElementById('hero-title')||{}).textContent") == "Job B",
page.eval("(document.getElementById('hero-title')||{}).textContent"))
chk("...with the tool cards still shown", visible(page, "#overview"))
chk("...and no first-run or choose-a-project state on a page that has both",
not visible(page, "#first-run") and not visible(page, "#pick-prompt"))
print("\n the app bar's 'New project' link lands on the form")
page.goto(base + "/index.html#new-project", READY)
settle(1.6)
chk("arriving at #new-project opens the create form", visible(page, "#new-project"))
chk("...and not the first-run state, on an account that has projects",
not visible(page, "#first-run"))
print("\n both widths")
for w, label in ((390, "390px"), (1440, "1440px")):
page.viewport(w, 900, mobile=(w == 390))
page.goto(base + "/index.html?project=projA", READY)
settle(1.4)
chk("%s: the page does not scroll sideways" % label,
page.eval("document.documentElement.scrollWidth <= window.innerWidth + 1"),
page.eval("[document.documentElement.scrollWidth, window.innerWidth]"))
chk("%s: the switcher is reachable" % label,
page.eval("""(() => { const b = document.querySelector('.wpc-proj-btn');
if (!b) return false; const r = b.getBoundingClientRect();
return r.width > 0 && r.right <= window.innerWidth + 1; })()"""))
page.viewport(1400, 1000)
def one_run(seeder, body, title):
exe = cdp.find_browser()
if not exe:
print("no headless-capable browser found; set WP_BROWSER.")
return 2
tmpdir = tempfile.mkdtemp(prefix="wpsuite-launcher-")
db_path = os.path.join(tmpdir, "check.db")
server = None
try:
tok = seeder(db_path)
port = cdp.free_port()
base = "http://127.0.0.1:%d" % port
server = start_server(port, db_path)
if server is None:
print("the test server would not start.")
return 2
print("\n%s\nTarget: %s" % (title, base))
browser = cdp.Browser(exe)
page = browser.page()
# Trap 5, in reverse: without focus emulation the headless document is
# not the focused one, :focus-visible never matches, and every control
# reports NO ring — a false red where a11y_check.py would get a false
# green. Same switch, same reason.
page.ws.call("Emulation.setFocusEmulationEnabled", {"enabled": True})
try:
body(page, base, tok)
finally:
page.close()
browser.close()
finally:
if server:
server.kill()
try:
server.wait(timeout=10)
except subprocess.TimeoutExpired:
pass
try:
from server.db import engine
engine.dispose()
except Exception:
pass
import shutil
for _ in range(10):
shutil.rmtree(tmpdir, ignore_errors=True)
if not os.path.exists(tmpdir):
break
time.sleep(0.3)
return 0
PHASES = {
"empty": (seed_empty, run_empty, "Launcher — a brand-new account (B3)"),
"populated": (seed, run_populated, "Launcher — an account with projects (B3)"),
}
def phase_main(name):
seeder, body, title = PHASES[name]
rc = one_run(seeder, body, title)
if rc == 2:
return 2
total = len(_PASS) + len(_FAIL)
print("\n%s\n%d/%d checks passed." % ("-" * 54, len(_PASS), total))
for f in _FAIL:
print(" - " + f)
print("RESULT %d %d" % (len(_PASS), total))
return 1 if _FAIL else 0
def main():
# The two states are DATABASE states, not view states — faking "no projects"
# in the browser would test the fake — so each phase needs its own database.
#
# And each needs its own PROCESS. server/db.py builds its engine at import
# time from DATABASE_URL, so a second seed() in the same interpreter still
# points at the first phase's database, which has been deleted by then. That
# surfaces as "unable to open database file", which reads like a broken test
# environment rather than what it is.
if len(sys.argv) > 1 and sys.argv[1] in PHASES:
return phase_main(sys.argv[1])
passed = total = 0
worst = 0
for name in ("empty", "populated"):
proc = subprocess.run([sys.executable, os.path.abspath(__file__), name],
capture_output=True, text=True,
cwd=os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
for line in proc.stdout.splitlines():
if line.startswith("RESULT "):
_, p, t = line.split()
passed += int(p)
total += int(t)
continue
print(line)
if proc.stderr.strip():
print(proc.stderr.strip()[-2000:])
worst = max(worst, proc.returncode)
# A fresh browser per phase, and a pause between: started back to back
# they exhaust the headless browser's ports and abort with "browser would
# not start", which looks like a code fault and is not one.
time.sleep(2.0)
print("\n%s\n%d/%d checks passed." % ("=" * 54, passed, total))
if worst:
return worst
print("\nResult: " + _c("ALL PASS — new accounts have a way in; switching moved to the bar.", "32") + "\n")
return 0
if __name__ == "__main__":
sys.exit(main())
Reference in New Issue View Git Blame Copy Permalink