vh
1558a7fa07
The bug hunt (4/4) and code review (4/4) were both clean on mechanism.
Their shared catch was the one-sided minute check.
Dates:
- The date filters never raise. One clock outside the calendar's range
500'd the Desk for every booth, because every row renders in one
response. An unrenderable date now renders nothing.
- "Updated" shows whenever it differs from "created" by a minute or more,
either way. Copied content is often older than its folder.
- A clock ahead of now shows its date, never "just now".
- A day is 24h ("1d ago" never appeared).
The row:
- The controls are last in the markup, so the booth's name comes first in
tab order and wipe last. The cluster is placed over the strip from the
row's box.
The theme:
- A choice made in one tab moves the Booth's other open tabs.
- The theme mark goes only on ask fragments the embed mounted.
Tests, strengthened after the code review:
- the pill is visible at rest;
- keyboard focus reveals the controls;
- the controls act with scripts off;
- Reveal all reaches the doc page;
- the high-contrast check reads tokens that actually differ;
- the art-light extras are written from SVOS, not derived from the
copies;
- two overstated mutation rows are replaced (one was a runtime no-op, one
went red through a syntax error).
Contract amended.
r2b.toml 55/55 proved. 799 passed.
1086 lines
51 KiB
Python
1086 lines
51 KiB
Python
"""R2 C3/C5/C6 in a real DOM: in-place judgment.
|
||
|
||
A TestClient can prove what the server answers. It cannot prove that a flag
|
||
made in the page lands without a reload, that the regions come back fresh, or
|
||
that a failure never re-POSTs. So: a real uvicorn, a real Chromium — the same
|
||
harness as test_embed_browser.py, and like it this SKIPS, never fails, when no
|
||
browser is available.
|
||
"""
|
||
import contextlib
|
||
import pathlib
|
||
import socket
|
||
import sys
|
||
import threading
|
||
import time
|
||
|
||
import pytest
|
||
|
||
sys.path.insert(0, str(pathlib.Path(__file__).parent.parent))
|
||
|
||
from booth.app import create_app # noqa: E402
|
||
|
||
playwright_api = pytest.importorskip("playwright.sync_api", reason="playwright is not installed")
|
||
|
||
PNG = b"\x89PNG\r\n\x1a\n"
|
||
|
||
|
||
# NO INTERNET for the test browser. Every Booth page asks fonts.googleapis.com
|
||
# for its faces, and "networkidle" waits for that request — so a stalled request
|
||
# to Google hung the page until goto's 30s timeout, the failure mode of the
|
||
# full-suite flake (Page.goto timeouts in tests far apart in one run; a stalled
|
||
# font request reproduces it exactly). Whether that was THE cause is unproven;
|
||
# a test that depends on Google being reachable is wrong regardless. Every
|
||
# hostname but 127.0.0.1 now fails DNS at once, and the pages fall back to the
|
||
# system stacks the tokens declare. Positive control: test_*_has_no_internet.
|
||
OFFLINE = ["--host-resolver-rules=MAP * ~NOTFOUND , EXCLUDE 127.0.0.1"]
|
||
|
||
|
||
@pytest.fixture(scope="module")
|
||
def browser():
|
||
with playwright_api.sync_playwright() as pw:
|
||
try:
|
||
b = pw.chromium.launch(args=OFFLINE)
|
||
except Exception as exc: # noqa: BLE001 - any launch failure is a skip
|
||
pytest.skip(f"no usable chromium: {exc}")
|
||
yield b
|
||
b.close()
|
||
|
||
|
||
@contextlib.contextmanager
|
||
def _serving(data_dir: pathlib.Path):
|
||
"""A real uvicorn on a free port over `data_dir`. A context manager rather
|
||
than only a fixture, so a test can serve from a data dir of its own shape
|
||
(a long install path, say)."""
|
||
import uvicorn
|
||
|
||
sock = socket.socket()
|
||
sock.bind(("127.0.0.1", 0))
|
||
port = sock.getsockname()[1]
|
||
# ⚠ THE SOCKET IS HANDED TO UVICORN STILL BOUND, never closed and
|
||
# re-opened by port number. The old form did bind -> getsockname -> CLOSE ->
|
||
# tell uvicorn the number, which leaves a window where the kernel can give
|
||
# that port to somebody else — and this suite runs TWO browser files that
|
||
# each start a server per test, so the other one is right there competing
|
||
# for it. Passing the live socket removes the window rather than narrowing
|
||
# it.
|
||
#
|
||
# Honest about the evidence: two different browser tests failed once each
|
||
# across full-suite runs while passing 3/3 and 5/5 on their own, which is
|
||
# the signature of contention. We cannot prove from two samples that this
|
||
# race was the cause. It is a real defect either way, and it is the only
|
||
# one visible in the harness.
|
||
|
||
app = create_app(data_dir, ttl_hours=24, start_sweeper=False)
|
||
server = uvicorn.Server(uvicorn.Config(app, host="127.0.0.1", port=port, log_level="error"))
|
||
thread = threading.Thread(target=lambda: server.run(sockets=[sock]), daemon=True)
|
||
thread.start()
|
||
deadline = time.time() + 10
|
||
while not server.started and time.time() < deadline:
|
||
time.sleep(0.02)
|
||
if not server.started:
|
||
pytest.skip("uvicorn did not come up")
|
||
try:
|
||
yield f"http://127.0.0.1:{port}"
|
||
finally:
|
||
server.should_exit = True
|
||
thread.join(timeout=10)
|
||
|
||
|
||
@pytest.fixture
|
||
def live(tmp_path):
|
||
with _serving(tmp_path) as base:
|
||
yield base, tmp_path
|
||
|
||
|
||
def _set(root: pathlib.Path, n: int = 30) -> pathlib.Path:
|
||
b = root / "g"
|
||
b.mkdir()
|
||
for i in range(1, n + 1):
|
||
(b / f"{i:02d}.png").write_bytes(PNG)
|
||
return b
|
||
|
||
|
||
def test_a_flag_lands_in_place_and_every_region_catches_up(browser, live):
|
||
"""Click a tile's flag far down the page: no reload, the scroll position
|
||
holds, and the tile, the tray and the rail's count all show the server's
|
||
new state — the three places one flag appears."""
|
||
base, root = live
|
||
_set(root)
|
||
posts = []
|
||
page = browser.new_page(viewport={"width": 1400, "height": 800})
|
||
page.on("request", lambda r: posts.append(r.url) if r.method == "POST" else None)
|
||
page.goto(f"{base}/b/g/", wait_until="networkidle")
|
||
page.evaluate("window.__noReload = 1")
|
||
tile = page.locator('figure.item[data-item="24.png"]')
|
||
tile.scroll_into_view_if_needed()
|
||
y = page.evaluate("window.scrollY")
|
||
tile.locator(".flagtoggle button").click()
|
||
page.wait_for_selector('figure.item.is-flagged[data-item="24.png"]', timeout=10000)
|
||
state = page.evaluate("""() => ({
|
||
reload: window.__noReload !== 1,
|
||
y: window.scrollY,
|
||
tray: [...document.querySelectorAll('.tray .tray-ord')].map(e => e.textContent),
|
||
count: document.querySelector('.rail-f[data-filter="flagged"] b').textContent,
|
||
})""")
|
||
page.close()
|
||
assert not state["reload"]
|
||
assert abs(state["y"] - y) < 4, "the page must not jump"
|
||
assert state["tray"] == ["#24"]
|
||
assert state["count"] == "1"
|
||
assert len(posts) == 1
|
||
|
||
|
||
def test_a_failed_save_says_so_reloads_and_never_re_posts(browser, live):
|
||
"""The server refuses the write (the marks file went bad under the page).
|
||
The script must not retry — a retry after a lost response would duplicate
|
||
the judgment — it says so and reloads to show the server's truth."""
|
||
base, root = live
|
||
b = _set(root, 3)
|
||
posts = []
|
||
page = browser.new_page()
|
||
page.on("request", lambda r: posts.append(r.url) if r.method == "POST" else None)
|
||
page.goto(f"{base}/b/g/", wait_until="networkidle")
|
||
(b / ".marks.json").write_text("{damaged")
|
||
page.locator('figure.item[data-item="01.png"] .flagtoggle button').click()
|
||
# the reader is TOLD before the page goes (Wren, hulda: nothing asserted it)
|
||
page.wait_for_selector('[data-region="status"]:not([hidden])', timeout=5000)
|
||
said = page.locator('[data-region="status"]').inner_text()
|
||
page.wait_for_load_state("networkidle")
|
||
page.wait_for_timeout(1500) # past the reload
|
||
page.close()
|
||
assert "Could not save in place" in said
|
||
assert len(posts) == 1, f"re-POSTed: {posts}"
|
||
|
||
|
||
def test_a_lost_response_after_a_landed_write_is_never_retried(browser, live):
|
||
"""The case the never-re-POST rule exists for: the server WROTE the note,
|
||
then the response was lost. A retry would write it twice. The route lets
|
||
the request reach the server and then drops the reply."""
|
||
from booth.marks import marks_for
|
||
base, root = live
|
||
b = _set(root, 2)
|
||
page = browser.new_page(viewport={"width": 1400, "height": 900})
|
||
page.goto(f"{base}/b/g/", wait_until="networkidle")
|
||
|
||
def drop_after_write(route):
|
||
route.fetch() # the write lands
|
||
route.abort() # ...and the browser never hears back
|
||
page.route("**/b/g/note", drop_after_write)
|
||
page.locator(".verdict .mark-add textarea").fill("exactly once")
|
||
page.locator(".verdict .mark-add button").click()
|
||
page.wait_for_selector('[data-region="status"]:not([hidden])', timeout=5000)
|
||
page.wait_for_timeout(1500)
|
||
page.close()
|
||
notes = [m for m in marks_for(b) if m.shape == "note" and m.text == "exactly once"]
|
||
assert len(notes) == 1, f"written {len(notes)} times"
|
||
|
||
|
||
def test_a_tile_the_fresh_page_no_longer_has_stays_put_marked_stale(browser, live):
|
||
"""Un-flag under ?filter=flagged: the fresh page has no such tile. It is
|
||
left where it is (nothing shifts under the reader) and marked stale."""
|
||
from booth.marks import set_flag
|
||
base, root = live
|
||
b = _set(root, 3)
|
||
set_flag(b, "01.png", True)
|
||
set_flag(b, "02.png", True)
|
||
page = browser.new_page(viewport={"width": 1400, "height": 900})
|
||
page.goto(f"{base}/b/g/?filter=flagged", wait_until="networkidle")
|
||
page.locator('figure.item[data-item="01.png"] .flagtoggle button').click()
|
||
page.wait_for_selector('figure.item.is-stale[data-item="01.png"]', timeout=10000)
|
||
tiles = page.eval_on_selector_all("figure.item", "els => els.map(e => e.dataset.item)")
|
||
page.close()
|
||
assert tiles == ["01.png", "02.png"]
|
||
|
||
|
||
def test_the_review_keys_judge_in_place_and_stay_out_of_the_note(browser, live):
|
||
"""At full size: F typed into the note is a letter; F outside it flags IN
|
||
PLACE (the filmstrip underline and the tape catch up, no reload); Space
|
||
moves on; Esc goes back to the grid at the tile you were on."""
|
||
base, root = live
|
||
_set(root, 4)
|
||
page = browser.new_page(viewport={"width": 1400, "height": 900})
|
||
page.goto(f"{base}/b/g/view?f=02.png", wait_until="networkidle")
|
||
page.evaluate("window.__noReload = 1")
|
||
|
||
page.locator("#vnote-text").click()
|
||
page.keyboard.type("fff")
|
||
assert page.locator(".vflag-btn.is-flagged").count() == 0
|
||
assert page.locator("#vnote-text").input_value() == "fff"
|
||
|
||
page.locator(".vr-where").click() # focus back on the page, not a field
|
||
page.keyboard.press("f")
|
||
page.wait_for_selector(".vflag-btn.is-flagged", timeout=10000)
|
||
state = page.evaluate("""() => ({
|
||
reload: window.__noReload !== 1,
|
||
film: [...document.querySelectorAll('.film-f.is-flagged .film-ord')].map(e => e.textContent),
|
||
draft: document.getElementById('vnote-text').value,
|
||
})""")
|
||
assert not state["reload"]
|
||
assert state["film"] == ["#2"]
|
||
assert state["draft"] == "fff", "an unsaved note must survive a swap it was not part of"
|
||
|
||
page.keyboard.press("n")
|
||
focused = page.evaluate("document.activeElement.id")
|
||
assert focused == "vnote-text", "N focuses the note"
|
||
page.locator(".vr-where").click()
|
||
|
||
with page.expect_navigation():
|
||
page.keyboard.press(" ")
|
||
assert page.url.endswith("/b/g/view?f=03.png")
|
||
with page.expect_navigation():
|
||
page.keyboard.press("ArrowRight")
|
||
assert page.url.endswith("/b/g/view?f=04.png")
|
||
with page.expect_navigation():
|
||
page.keyboard.press("ArrowLeft")
|
||
assert page.url.endswith("/b/g/view?f=03.png")
|
||
with page.expect_navigation():
|
||
page.keyboard.press("Escape")
|
||
assert page.url.endswith("/b/g/#item-03.png")
|
||
page.close()
|
||
|
||
|
||
def test_the_stage_survives_an_in_place_save_and_a_focused_radio_keeps_f(browser, live):
|
||
"""The stage is never a region: the same node must still be on the page
|
||
after a flag lands (a playing track would restart otherwise). And F while
|
||
a radio — an <input> — has focus is not a flag."""
|
||
from booth.marks import declare_pick
|
||
base, root = live
|
||
b = _set(root, 2)
|
||
declare_pick(b, "q", {"prompt": "Sharp?", "options": ["yes", "no"]}, target="01.png")
|
||
page = browser.new_page(viewport={"width": 1400, "height": 900})
|
||
page.goto(f"{base}/b/g/view?f=01.png", wait_until="networkidle")
|
||
page.evaluate("document.getElementById('vstage').__mark = 1")
|
||
page.locator('.vrail input[type=radio]').first.focus()
|
||
page.keyboard.press("f")
|
||
page.wait_for_timeout(600)
|
||
assert page.locator(".vflag-btn.is-flagged").count() == 0, "F in a radio is not a flag"
|
||
page.locator(".vr-where").click()
|
||
page.keyboard.press("f")
|
||
page.wait_for_selector(".vflag-btn.is-flagged", timeout=10000)
|
||
same = page.evaluate("document.getElementById('vstage').__mark === 1")
|
||
page.close()
|
||
assert same, "the stage was replaced by the swap"
|
||
|
||
|
||
@pytest.mark.parametrize("js", [True, False])
|
||
def test_on_a_narrow_screen_flags_and_notes_fold_and_on_a_wide_one_they_show(browser, live, js):
|
||
"""C5 (Wren W1, 4/4): under 1000px the verdict stacks ABOVE the set, and
|
||
its flags and notes fold into <details> so the question is not buried —
|
||
with no script. Wide, they are simply shown. Checked with JS on and off."""
|
||
from booth.marks import set_flag, write_note
|
||
base, root = live
|
||
b = _set(root, 3)
|
||
set_flag(b, "02.png", True)
|
||
write_note(b, None, "a booth note")
|
||
for width, shown in ((390, False), (1400, True)):
|
||
ctx = browser.new_context(viewport={"width": width, "height": 900}, java_script_enabled=js)
|
||
page = ctx.new_page()
|
||
page.goto(f"{base}/b/g/", wait_until="networkidle")
|
||
tray = page.locator(".verdict .tray-item").first
|
||
note = page.locator(".verdict .mark-text", has_text="a booth note")
|
||
assert tray.is_visible() is shown, (width, js, "tray")
|
||
assert note.is_visible() is shown, (width, js, "note")
|
||
if not shown: # folded, but one tap away
|
||
page.locator(".verdict summary.v-fold-head").first.click()
|
||
assert tray.is_visible()
|
||
ctx.close()
|
||
|
||
|
||
# ---- fixups from the heid bug-hunt panel (round "Nyx") ------------------------
|
||
|
||
def test_the_link_board_still_confirms_before_removing_a_row(browser, live):
|
||
"""Nyx N1 (2/4): the R2 rewrite of booth.html's scripts deleted the board's
|
||
multi-select + confirmation script along with the handlers it replaced.
|
||
Removing a row is destructive; the confirm naming it must still stand in
|
||
front of the POST, and select-all must still select."""
|
||
base, root = live
|
||
board = root / "links"
|
||
board.mkdir()
|
||
(board / "links.md").write_text(
|
||
"- [one](http://x/1) <sub>· a · 2026-09-01 10:00</sub>\n"
|
||
"- [two](http://x/2) <sub>· a · 2026-09-01 10:01</sub>\n")
|
||
page = browser.new_page()
|
||
page.goto(f"{base}/b/links/", wait_until="networkidle")
|
||
dialogs = []
|
||
page.on("dialog", lambda d: (dialogs.append(d.message), d.dismiss()))
|
||
page.locator(".board-rm-btn").first.click()
|
||
page.wait_for_timeout(300)
|
||
page.locator("#board-selall").check()
|
||
ticked = page.eval_on_selector_all(".board-check", "els => els.filter(e => e.checked).length")
|
||
page.close()
|
||
assert dialogs and "Remove this link?" in dialogs[0]
|
||
assert ticked == 2
|
||
assert (board / "links.md").read_text().count("- [") == 2, "a dismissed confirm removed nothing"
|
||
|
||
|
||
def test_an_unsaved_choice_survives_a_save_elsewhere_and_a_double_click_writes_once(browser, live):
|
||
"""Nyx N5 (hulda, regin, groa): a picked-but-unsent radio was reset by any
|
||
other in-place save, drafts were matched by POSITION, and a double-click on
|
||
Add note wrote two notes. Now: dirty controls carry by identity, and a form
|
||
already in flight ignores a second submit."""
|
||
from booth.marks import declare_pick, marks_for
|
||
base, root = live
|
||
b = _set(root, 3)
|
||
declare_pick(b, "q", {"prompt": "Which?", "options": ["x", "y"]})
|
||
page = browser.new_page(viewport={"width": 1400, "height": 900})
|
||
page.goto(f"{base}/b/g/", wait_until="networkidle")
|
||
page.locator('.verdict input[type=radio][value="y"]').check()
|
||
page.locator('figure.item[data-item="02.png"] .flagtoggle button').click()
|
||
page.wait_for_selector('figure.item.is-flagged[data-item="02.png"]', timeout=10000)
|
||
assert page.locator('.verdict input[type=radio][value="y"]').is_checked()
|
||
|
||
page.locator(".verdict .mark-add textarea").fill("once")
|
||
page.locator(".verdict .mark-add button").dblclick()
|
||
page.wait_for_timeout(1500)
|
||
page.close()
|
||
assert [m.text for m in marks_for(b) if m.shape == "note"] == ["once"]
|
||
|
||
|
||
# The first page refresh after a save is held back 1s in the CLIENT: the server
|
||
# renders it at once (so it carries only the first flag) and the browser sees
|
||
# it late. Localhost alone never loses that race, so without the hold the test
|
||
# passed with sequencing deleted — it has to be forced to be a control.
|
||
_HOLD_FIRST_REFRESH = """
|
||
(function () {
|
||
var real = window.fetch, n = 0;
|
||
window.fetch = function (u, o) {
|
||
var p = real.apply(this, arguments);
|
||
if ((!o || !o.method || o.method === 'GET') && n++ === 0) {
|
||
return p.then(function (r) {
|
||
return new Promise(function (res) { setTimeout(function () { res(r); }, 1000); });
|
||
});
|
||
}
|
||
return p;
|
||
};
|
||
})();
|
||
"""
|
||
|
||
|
||
def test_quick_successive_flags_all_show(browser, live):
|
||
"""Nyx (hulda): with no sequencing, an older refresh landing after a newer
|
||
one showed the newer flag as gone. Saves are serialized."""
|
||
base, root = live
|
||
_set(root, 4)
|
||
page = browser.new_page(viewport={"width": 1400, "height": 900})
|
||
page.add_init_script(_HOLD_FIRST_REFRESH)
|
||
page.goto(f"{base}/b/g/", wait_until="networkidle")
|
||
for rel in ("01.png", "02.png", "03.png"):
|
||
page.locator(f'figure.item[data-item="{rel}"] .flagtoggle button').click()
|
||
page.wait_for_timeout(150)
|
||
page.wait_for_function(
|
||
"document.querySelectorAll('figure.item.is-flagged').length === 3", timeout=10000)
|
||
page.wait_for_timeout(1500)
|
||
n = page.locator("figure.item.is-flagged").count()
|
||
page.close()
|
||
assert n == 3
|
||
|
||
|
||
def test_the_standalone_marks_page_updates_in_place(browser, live):
|
||
"""Nyx (kimi): the marks page's forms are in-place, but the page had no
|
||
region, so an answer saved and the page never showed it."""
|
||
from booth.marks import declare_pick
|
||
base, root = live
|
||
b = _set(root, 1)
|
||
declare_pick(b, "q", {"prompt": "Which?", "options": ["x", "y"]})
|
||
page = browser.new_page()
|
||
page.goto(f"{base}/b/g/marks", wait_until="networkidle")
|
||
page.evaluate("window.__same_page = 1")
|
||
page.locator('input[type=radio][value="x"]').check()
|
||
page.locator(".mark-submit").click()
|
||
page.wait_for_selector(".mark.is-answered", timeout=10000)
|
||
# In place, not the reload fallback: the page's own window survived.
|
||
same = page.evaluate("window.__same_page === 1")
|
||
page.close()
|
||
assert same
|
||
|
||
|
||
def test_the_next_arrow_clears_the_rail_only_beside_it(browser, live):
|
||
"""Nyx: view.html's bare `.vnext{right:360px}` came later in the page than
|
||
base.html's narrow override and won it, parking the arrow 360px in from
|
||
the edge of a phone. Wide: it clears the rail. Narrow: it sits at the edge."""
|
||
base, root = live
|
||
_set(root, 3)
|
||
rights = {}
|
||
for w in (1400, 390):
|
||
page = browser.new_page(viewport={"width": w, "height": 900})
|
||
page.goto(f"{base}/b/g/view?f=01.png", wait_until="networkidle")
|
||
rights[w] = page.evaluate(
|
||
"getComputedStyle(document.querySelector('.vnav.vnext')).right")
|
||
page.close()
|
||
assert rights == {1400: "360px", 390: "0px"}
|
||
|
||
|
||
def test_the_desk_never_scrolls_sideways_at_any_width(browser, tmp_path):
|
||
"""The row-controls change made a Desk row a flex container, and a long
|
||
provenance line (nowrap, ellipsised) then set the Desk column's MINIMUM
|
||
width: at 390px the page scrolled sideways to 1029px. The column is capped
|
||
at the space it has; the ellipsis does the rest.
|
||
|
||
Slate (heid bug-hunt) widened it three ways: the invariant is PAGE-level,
|
||
so a long install path — printed in the footer and the empty state — must
|
||
wrap too (groa); the widths between the two first tested (700-1000px, a
|
||
non-wrapping flex line) are swept with the heaviest row the Desk draws
|
||
(regin); and the page is compared with its OWN client width, never the
|
||
viewport's, which a vertical scrollbar would make a false failure (kimi)."""
|
||
from booth.manifest import write_manifest
|
||
from booth.marks import declare_pick, set_flag
|
||
# ONE unbreakable run: a hyphen or a slash is a line-break opportunity, and
|
||
# the first draft of this fixture ("a-very-long-install-path-" * 9) wrapped
|
||
# all by itself — the test passed with the bug present.
|
||
root = tmp_path / ("averylonginstallpath" * 11)
|
||
root.mkdir()
|
||
over = {}
|
||
with _serving(root) as base:
|
||
for w in (390, 1400): # the empty Desk first
|
||
page = browser.new_page(viewport={"width": w, "height": 844})
|
||
page.goto(f"{base}/", wait_until="networkidle")
|
||
over[("empty", w)] = page.evaluate(
|
||
"document.documentElement.scrollWidth - document.documentElement.clientWidth")
|
||
page.close()
|
||
d = root / ("heavy-" + "x" * 60)
|
||
d.mkdir()
|
||
for i in range(12):
|
||
(d / f"{i:02d}.png").write_bytes(PNG)
|
||
set_flag(d, f"{i:02d}.png", True)
|
||
declare_pick(d, "q", {"prompt": "Which?", "options": ["x", "y"]})
|
||
(d / ".uploaded").write_bytes(b"")
|
||
write_manifest(d, "design-dev", title="A set with a long title " * 4,
|
||
why="a reason long enough to overflow any phone " * 6)
|
||
for w in (390, 720, 850, 1000, 1400):
|
||
page = browser.new_page(viewport={"width": w, "height": 844})
|
||
page.goto(f"{base}/", wait_until="networkidle")
|
||
over[("heavy", w)] = page.evaluate(
|
||
"document.documentElement.scrollWidth - document.documentElement.clientWidth")
|
||
page.close()
|
||
assert all(v <= 0 for v in over.values()), over
|
||
|
||
|
||
def test_the_wipe_dialog_shows_what_is_being_wiped_and_never_fails_open(browser, live):
|
||
"""Slate T4 (groa): the booth name travels as data, never into a script —
|
||
but the confirm TEXT showed it raw, so a name carrying a bidi override
|
||
(U+202E) or a newline rewrote what the operator reads before approving a
|
||
wipe. Controls and bidi formatting show as U+FFFD instead. And (seat S1)
|
||
a `data-confirm` word the page does not know submitted with NO prompt; an
|
||
unknown word now asks generically — fail closed, never open."""
|
||
import os
|
||
base, root = live
|
||
name = "safegnp.xe\nline2"
|
||
d = root / name
|
||
d.mkdir()
|
||
(d / "a.png").write_bytes(PNG)
|
||
past = time.time() - 10_000
|
||
os.utime(d / "a.png", (past, past))
|
||
(d / ".viewed").write_bytes(b"")
|
||
page = browser.new_page(viewport={"width": 1400, "height": 900})
|
||
said = []
|
||
page.on("dialog", lambda dlg: (said.append(dlg.message), dlg.dismiss()))
|
||
page.goto(f"{base}/", wait_until="networkidle")
|
||
# r2b D1: the row's controls appear on hover (operator ruling), so hover first
|
||
page.locator(".desk-row").first.hover()
|
||
page.locator("form.wipe button").first.click()
|
||
page.wait_for_timeout(300)
|
||
page.evaluate("""() => { const f = document.createElement('form');
|
||
f.method = 'post'; f.action = '/nowhere'; f.setAttribute('data-confirm', 'typo');
|
||
f.setAttribute('data-booth', 'x'); f.innerHTML = '<button>go</button>';
|
||
document.body.appendChild(f); f.querySelector('button').click(); }""")
|
||
page.wait_for_timeout(300)
|
||
page.close()
|
||
assert d.exists(), "a dismissed confirm must not wipe"
|
||
assert len(said) == 2, said
|
||
shown = said[0].split("\n\n")[0]
|
||
assert not any(c in shown for c in "\n"), repr(shown)
|
||
assert "safe�gnp.xe�line2" in shown, repr(shown)
|
||
|
||
|
||
_FILTER = "sel => { const e = document.querySelector(sel); return e ? getComputedStyle(e).filter : 'MISSING'; }"
|
||
|
||
|
||
def _blurred_set(root: pathlib.Path, name: str = "g", blur=("a.png",), flag=("a.png",)) -> pathlib.Path:
|
||
from booth.app import set_blurred
|
||
from booth.marks import set_flag
|
||
b = root / name
|
||
b.mkdir()
|
||
for rel in ("a.png", "b.png", "c.png"):
|
||
(b / rel).write_bytes(PNG)
|
||
for rel in blur:
|
||
set_blurred(b, rel, True)
|
||
for rel in flag:
|
||
set_flag(b, rel, True)
|
||
return b
|
||
|
||
|
||
def _settle(page) -> None:
|
||
page.wait_for_timeout(400) # the filter transition (--dur-2)
|
||
|
||
|
||
def test_reveal_all_reveals_every_blurred_surface_and_survives_the_next_page(browser, live):
|
||
"""r2b D2 (blur ruling A): one click lifts the blur on the tile, the tray,
|
||
the review stage and the filmstrip, and it holds on the next page of the
|
||
same tab. A fresh tab is blurred again — per tab, never persisted."""
|
||
base, root = live
|
||
_blurred_set(root)
|
||
ctx = browser.new_context(viewport={"width": 1400, "height": 900})
|
||
page = ctx.new_page()
|
||
page.goto(f"{base}/b/g/", wait_until="networkidle")
|
||
tile, tray = 'figure.item[data-item="a.png"] img', ".tray-item.is-blurred img"
|
||
before = [page.evaluate(_FILTER, tile), page.evaluate(_FILTER, tray)]
|
||
page.locator("[data-reveal-all]").click()
|
||
_settle(page)
|
||
after = [page.evaluate(_FILTER, tile), page.evaluate(_FILTER, tray)]
|
||
page.goto(f"{base}/b/g/view?f=a.png", wait_until="networkidle")
|
||
_settle(page)
|
||
review = [page.evaluate(_FILTER, "#vimg"), page.evaluate(_FILTER, ".film-f.is-blurred img"),
|
||
page.locator("[data-reveal-all]").inner_text()]
|
||
fresh = ctx.new_page() # a new tab: sessionStorage is per tab
|
||
fresh.goto(f"{base}/b/g/view?f=a.png", wait_until="networkidle")
|
||
_settle(fresh)
|
||
again = fresh.evaluate(_FILTER, "#vimg")
|
||
ctx.close()
|
||
assert all("blur" in f for f in before), before
|
||
assert after == ["none", "none"], after
|
||
assert review[:2] == ["none", "none"] and "blur again" in review[2], review
|
||
assert "blur" in again, again
|
||
|
||
|
||
def test_reveal_all_on_booth_a_does_not_reveal_booth_b_or_the_desk(browser, live):
|
||
"""r2b D2 + INV-4: the reveal is scoped to the booth you are in. Booth A's
|
||
cannot follow you into booth B, and nothing on the index is revealed."""
|
||
base, root = live
|
||
_blurred_set(root, "ga")
|
||
_blurred_set(root, "gb")
|
||
page = browser.new_page(viewport={"width": 1400, "height": 900})
|
||
page.goto(f"{base}/b/ga/", wait_until="networkidle")
|
||
page.locator("[data-reveal-all]").click()
|
||
page.goto(f"{base}/b/gb/", wait_until="networkidle")
|
||
_settle(page)
|
||
b_tile = page.evaluate(_FILTER, 'figure.item[data-item="a.png"] img')
|
||
page.goto(f"{base}/", wait_until="networkidle")
|
||
desk = page.evaluate("""() => [...document.querySelectorAll('.desk-strip img.blurred-thumb')]
|
||
.map(i => getComputedStyle(i).filter)""")
|
||
page.close()
|
||
assert b_tile == "blur(22px)", b_tile
|
||
assert desk and all(f == "blur(16px)" for f in desk), desk # exact: blur(0px) is not blurred
|
||
|
||
|
||
def test_reveal_all_survives_an_in_place_save(browser, live):
|
||
"""r2b D2: after an in-place save the blur is still lifted — the swapped-in
|
||
tile included — the control still says "blur again" and still works, and
|
||
the per-tile reveal buttons are still stood down."""
|
||
base, root = live
|
||
_blurred_set(root, blur=("a.png", "b.png"), flag=())
|
||
page = browser.new_page(viewport={"width": 1400, "height": 900})
|
||
page.goto(f"{base}/b/g/", wait_until="networkidle")
|
||
page.evaluate("window.__same_page = 1")
|
||
page.locator("[data-reveal-all]").click()
|
||
page.locator('figure.item[data-item="b.png"] .flagtoggle button').click()
|
||
page.wait_for_selector('figure.item.is-flagged[data-item="b.png"]', timeout=10000)
|
||
_settle(page)
|
||
got = {"same": page.evaluate("window.__same_page === 1"),
|
||
"b": page.evaluate(_FILTER, 'figure.item[data-item="b.png"] img'),
|
||
"label": page.locator("[data-reveal-all]").inner_text(),
|
||
"tile_btn": page.evaluate("""() => getComputedStyle(
|
||
document.querySelector('figure.item[data-item="b.png"] .reveal')).display""")}
|
||
page.locator("[data-reveal-all]").click()
|
||
_settle(page)
|
||
got["back"] = page.evaluate(_FILTER, 'figure.item[data-item="b.png"] img')
|
||
page.close()
|
||
assert got["same"] and got["b"] == "none" and "blur again" in got["label"], got
|
||
assert got["tile_btn"] == "none" and "blur" in got["back"], got
|
||
|
||
|
||
def test_blur_again_restores_each_items_own_reveal(browser, live):
|
||
"""r2b D2: Reveal all never touches an item's own reveal, so "blur again"
|
||
returns each item exactly as it was — one revealed on its own stays so."""
|
||
base, root = live
|
||
_blurred_set(root, blur=("a.png", "b.png"), flag=())
|
||
page = browser.new_page(viewport={"width": 1400, "height": 900})
|
||
page.goto(f"{base}/b/g/", wait_until="networkidle")
|
||
page.locator('figure.item[data-item="a.png"] .reveal').click()
|
||
page.locator("[data-reveal-all]").click()
|
||
page.locator("[data-reveal-all]").click()
|
||
_settle(page)
|
||
got = [page.evaluate(_FILTER, f'figure.item[data-item="{r}"] img') for r in ("a.png", "b.png")]
|
||
page.close()
|
||
assert got[0] == "none" and "blur" in got[1], got
|
||
|
||
|
||
def test_reveal_all_never_shows_without_js_and_a_storage_failure_still_applies_the_click(browser, live):
|
||
"""r2b D2: without JS the control is in the markup but never shown. With
|
||
sessionStorage throwing on write (a private window), the click still
|
||
applies to the page — only the memory is lost."""
|
||
base, root = live
|
||
_blurred_set(root)
|
||
ctx = browser.new_context(java_script_enabled=False)
|
||
page = ctx.new_page()
|
||
page.goto(f"{base}/b/g/", wait_until="networkidle")
|
||
nojs = page.locator("[data-reveal-all]").is_visible()
|
||
ctx.close()
|
||
page = browser.new_page(viewport={"width": 1400, "height": 900})
|
||
errors = []
|
||
page.on("pageerror", lambda e: errors.append(str(e)))
|
||
# READS and WRITES both throw: the pre-paint read must degrade to "not
|
||
# revealed" without raising, and the click must still apply.
|
||
page.add_init_script("""Storage.prototype.setItem = function () { throw new Error('quota'); };
|
||
Storage.prototype.getItem = function () { throw new Error('denied'); };""")
|
||
page.goto(f"{base}/b/g/", wait_until="networkidle")
|
||
_settle(page)
|
||
before = page.evaluate(_FILTER, 'figure.item[data-item="a.png"] img')
|
||
page.locator("[data-reveal-all]").click()
|
||
_settle(page)
|
||
lifted = page.evaluate(_FILTER, 'figure.item[data-item="a.png"] img')
|
||
page.close()
|
||
assert not nojs
|
||
assert before == "blur(22px)" and lifted == "none", (before, lifted)
|
||
assert errors == [], errors
|
||
|
||
|
||
|
||
def test_an_items_own_reveal_survives_an_in_place_save(browser, live):
|
||
"""heid code-review (groa, kimi): nothing pinned the swap carrying an item's
|
||
own `revealed` — deleting it from the carry list left every test green.
|
||
Reveal one tile, save something else in place: it stays revealed, and its
|
||
button still says so."""
|
||
base, root = live
|
||
_blurred_set(root, blur=("a.png", "b.png"), flag=())
|
||
page = browser.new_page(viewport={"width": 1400, "height": 900})
|
||
page.goto(f"{base}/b/g/", wait_until="networkidle")
|
||
page.locator('figure.item[data-item="b.png"] .reveal').click()
|
||
page.locator('figure.item[data-item="a.png"] .flagtoggle button').click()
|
||
page.wait_for_selector('figure.item.is-flagged[data-item="a.png"]', timeout=10000)
|
||
_settle(page)
|
||
got = [page.evaluate(_FILTER, 'figure.item[data-item="b.png"] img'),
|
||
page.locator('figure.item[data-item="b.png"] .reveal').inner_text()]
|
||
page.close()
|
||
assert got[0] == "none" and "hide" in got[1], got
|
||
|
||
|
||
def test_reveal_all_lifts_a_blurred_docs_own_page(browser, live):
|
||
"""The doc page's blur (heid code-review) obeys the same <html> class, and
|
||
its own reveal works."""
|
||
from booth.app import set_blurred
|
||
base, root = live
|
||
b = root / "g"
|
||
b.mkdir()
|
||
(b / "n.md").write_text("# secret\n\nbody")
|
||
set_blurred(b, "n.md", True)
|
||
page = browser.new_page(viewport={"width": 1200, "height": 800})
|
||
page.goto(f"{base}/b/g/view?f=n.md", wait_until="networkidle")
|
||
_settle(page)
|
||
at_rest = page.evaluate(_FILTER, "#docbody .markdown-body, #docbody .textview")
|
||
page.locator("#docreveal").click()
|
||
_settle(page)
|
||
own = page.evaluate(_FILTER, "#docbody .markdown-body, #docbody .textview")
|
||
page.close()
|
||
assert at_rest == "blur(22px)" and own == "none", (at_rest, own)
|
||
|
||
|
||
def test_space_on_a_focused_review_button_presses_it_and_does_not_move_on(browser, live):
|
||
"""heid bug-hunt (hulda): the review's document-level Space handler moved to
|
||
the next item before a focused button could take the key, so a keyboard
|
||
user could not press Reveal all or the fog control with Space."""
|
||
base, root = live
|
||
_blurred_set(root, flag=())
|
||
page = browser.new_page(viewport={"width": 1400, "height": 900})
|
||
page.goto(f"{base}/b/g/view?f=a.png", wait_until="networkidle")
|
||
page.locator("[data-reveal-all]").focus()
|
||
page.keyboard.press(" ")
|
||
_settle(page)
|
||
got = [page.url, page.evaluate("document.documentElement.classList.contains('reveal-all')")]
|
||
page.close()
|
||
assert got[0].endswith("/b/g/view?f=a.png") and got[1], got
|
||
|
||
|
||
def test_the_review_and_doc_top_bars_fit_a_phone(browser, live):
|
||
"""heid bug-hunt (hulda, groa; needs-repro): the top bar gained the fog
|
||
control and Reveal all beside the name, the fit toggle and the download.
|
||
At 390px no review or doc page scrolls sideways, even with a long name."""
|
||
from booth.app import set_blurred
|
||
base, root = live
|
||
b = _blurred_set(root, flag=())
|
||
long = "a-rather-long-picture-name-" * 3 + ".png"
|
||
(b / long).write_bytes(PNG)
|
||
set_blurred(b, long, True)
|
||
(b / "n.md").write_text("# n")
|
||
set_blurred(b, "n.md", True)
|
||
over = {}
|
||
for url in (f"/b/g/view?f={long}", "/b/g/view?f=n.md"):
|
||
page = browser.new_page(viewport={"width": 390, "height": 844})
|
||
page.goto(f"{base}{url}", wait_until="networkidle")
|
||
over[url] = page.evaluate(
|
||
"document.documentElement.scrollWidth - document.documentElement.clientWidth")
|
||
# and nothing squeezed into a stack: every top-bar control is one line
|
||
over[url + " tallest"] = page.evaluate("""() => Math.max(...[...document.querySelectorAll(
|
||
'.vbar button, .vbar .vbtn')].filter(e => e.offsetParent).map(e => e.getBoundingClientRect().height)) - 40""")
|
||
page.close()
|
||
assert all(v <= 0 for v in over.values()), over
|
||
|
||
|
||
def test_the_test_browser_has_no_internet(browser, live):
|
||
"""Positive control for OFFLINE (booth-dev's ask: see the fix in force,
|
||
don't assume it). An external host fails at once, and a Booth page — whose
|
||
fonts are external — still goes idle in well under the goto timeout."""
|
||
base, root = live
|
||
(root / "g").mkdir()
|
||
page = browser.new_page()
|
||
t = time.time()
|
||
with pytest.raises(Exception) as err:
|
||
page.goto("https://fonts.googleapis.com/css2?family=IBM+Plex+Sans", timeout=10000)
|
||
external = time.time() - t
|
||
page.close()
|
||
page = browser.new_page()
|
||
t = time.time()
|
||
page.goto(f"{base}/b/g/", wait_until="networkidle")
|
||
local = time.time() - t
|
||
page.close()
|
||
assert "ERR_NAME_NOT_RESOLVED" in str(err.value) and external < 3, (str(err.value)[:80], external)
|
||
assert local < 10, local
|
||
|
||
|
||
def _two_rows(root: pathlib.Path) -> None:
|
||
"""A kept and an ephemeral booth, both looked at since they landed (so no
|
||
'new' badge): the plainest rows the Desk draws."""
|
||
import os
|
||
past = time.time() - 10_000
|
||
for name, kept in (("kept1", True), ("loose", False)):
|
||
d = root / name
|
||
d.mkdir()
|
||
(d / "a.png").write_bytes(PNG)
|
||
os.utime(d / "a.png", (past, past))
|
||
(d / ".viewed").write_bytes(b"")
|
||
if kept:
|
||
(d / ".forever").write_bytes(b"")
|
||
|
||
|
||
_ROW_BOXES = """row => {
|
||
const box = e => { const r = e.getBoundingClientRect(); return [r.x, r.y, r.width, r.height].map(Math.round); };
|
||
const parts = [...row.querySelectorAll('.desk-strip, .desk-strip img, .desk-main, .desk-side, .life')];
|
||
return parts.map(box);
|
||
}"""
|
||
|
||
|
||
def test_the_row_controls_take_no_room_where_a_hover_exists(browser, live):
|
||
"""r2b D1 (operator: 'download, keep and release buttons only appear on
|
||
mouseover'; earlier: 'release and x take up space whether or not they're
|
||
visible'). Where a real hover exists the cluster floats over the preview
|
||
strip: at rest invisible AND unclickable; on hover visible AND clickable;
|
||
and every other box in the row is the same with the cluster removed. It
|
||
never covers the text or the side column, at any width."""
|
||
base, root = live
|
||
_two_rows(root)
|
||
over = {}
|
||
for w in (390, 720, 1000, 1400):
|
||
page = browser.new_page(viewport={"width": w, "height": 900})
|
||
page.goto(f"{base}/", wait_until="networkidle")
|
||
assert page.evaluate("matchMedia('(hover: hover) and (pointer: fine)').matches")
|
||
page.mouse.move(0, 0)
|
||
row = page.locator('.desk-row[data-booth="loose"]')
|
||
acts = row.locator(".desk-acts")
|
||
rest = acts.evaluate("a => [getComputedStyle(a).opacity, getComputedStyle(a).pointerEvents]")
|
||
with_acts = row.evaluate(_ROW_BOXES)
|
||
row.hover()
|
||
page.wait_for_timeout(350)
|
||
shown = acts.evaluate("a => [getComputedStyle(a).opacity, getComputedStyle(a).pointerEvents]")
|
||
over[w] = row.evaluate("""row => {
|
||
const a = row.querySelector('.desk-acts').getBoundingClientRect();
|
||
return [...row.querySelectorAll('.desk-main, .desk-side')].some(e => {
|
||
const r = e.getBoundingClientRect();
|
||
return a.left < r.right && r.left < a.right && a.top < r.bottom && r.top < a.bottom; }); }""")
|
||
acts.evaluate("a => a.remove()")
|
||
without = row.evaluate(_ROW_BOXES)
|
||
page.close()
|
||
assert rest == ["0", "none"], (w, rest)
|
||
assert shown == ["1", "auto"], (w, shown)
|
||
assert with_acts == without, (w, with_acts, without)
|
||
assert not any(over.values()), over
|
||
# and on hover a control is really pressable: keep reaches the server
|
||
page = browser.new_page(viewport={"width": 1400, "height": 900})
|
||
page.goto(f"{base}/", wait_until="networkidle")
|
||
row = page.locator('.desk-row[data-booth="loose"]')
|
||
row.hover()
|
||
page.wait_for_timeout(350)
|
||
with page.expect_navigation():
|
||
row.locator(".desk-acts form.keepit button").click()
|
||
page.close()
|
||
assert (root / "loose" / ".forever").exists()
|
||
|
||
|
||
def test_on_touch_the_row_controls_are_visible_in_flow_and_at_least_28px(browser, live):
|
||
"""r2b D1: hover-only would mean no controls at all on touch. Without a
|
||
real hover (here: a coarse, touch primary pointer) the cluster is visible,
|
||
in flow on its own line, and every control is at least the 28px floor
|
||
(Slate T2) — wipe clear of its neighbour."""
|
||
base, root = live
|
||
_two_rows(root)
|
||
ctx = browser.new_context(viewport={"width": 390, "height": 844}, has_touch=True, is_mobile=True)
|
||
page = ctx.new_page()
|
||
page.goto(f"{base}/", wait_until="networkidle")
|
||
coarse = page.evaluate("matchMedia('(pointer: coarse)').matches")
|
||
got = page.evaluate("""() => [...document.querySelectorAll('.desk-row')].map(row => {
|
||
const a = row.querySelector('.desk-acts'), cs = getComputedStyle(a);
|
||
const ctl = [...a.querySelectorAll('button, a')].map(b => b.getBoundingClientRect());
|
||
const main = row.querySelector('.desk-main').getBoundingClientRect();
|
||
const w = a.querySelector('form.wipe button').getBoundingClientRect();
|
||
const prev = ctl[ctl.length - 2];
|
||
return {opacity: cs.opacity, position: cs.position,
|
||
below: a.getBoundingClientRect().top >= main.bottom - 1,
|
||
small: ctl.filter(r => r.width < 28 || r.height < 28).length,
|
||
gap: Math.round(Math.max(w.left - prev.right, w.top - prev.bottom))}; })""")
|
||
ctx.close()
|
||
assert coarse, "the emulation must present a coarse pointer, or this test measures nothing"
|
||
for g in got:
|
||
assert g["opacity"] == "1" and g["position"] == "static" and g["below"], got
|
||
assert g["small"] == 0 and g["gap"] >= 8, got
|
||
|
||
|
||
def test_the_row_controls_run_zip_keep_or_release_then_wipe(browser, live):
|
||
"""r2b D1 (operator: 'the zip download button is in between keep/release and
|
||
wipe, and looks awkward'). Zip leads; release stays next to x."""
|
||
base, root = live
|
||
_two_rows(root)
|
||
page = browser.new_page(viewport={"width": 1400, "height": 900})
|
||
page.goto(f"{base}/", wait_until="networkidle")
|
||
order = page.evaluate("""() => Object.fromEntries([...document.querySelectorAll('.desk-row')].map(row =>
|
||
[row.dataset.booth, [...row.querySelectorAll('.desk-acts > *')].map(e => e.className.split(' ')[0])]))""")
|
||
page.close()
|
||
assert order == {"kept1": ["dl-link", "release", "wipe"], "loose": ["dl-link", "keepit", "wipe"]}, order
|
||
|
||
|
||
_VAR = "n => getComputedStyle(document.documentElement).getPropertyValue(n).trim()"
|
||
|
||
|
||
def test_the_theme_toggle_forces_light_and_dark_and_system_follows_the_os_live(browser, live):
|
||
"""r2b D3 (operator: 'light mode toggle at the top (dark, light, system)').
|
||
Light and Dark force the theme and survive a reload in the same browser
|
||
(localStorage). System hands the question back to the OS, and follows it
|
||
LIVE — an OS flip moves the page with no reload and no listener, because a
|
||
media query tracks the OS by construction."""
|
||
base, root = live
|
||
_set(root, 1)
|
||
ctx = browser.new_context(color_scheme="dark", viewport={"width": 1200, "height": 800})
|
||
page = ctx.new_page()
|
||
page.goto(f"{base}/b/g/", wait_until="networkidle")
|
||
dark = page.evaluate(_VAR, "--surface-base")
|
||
page.locator('.theme [data-theme-choice="light"]').click()
|
||
light = page.evaluate(_VAR, "--surface-base")
|
||
page.reload(wait_until="networkidle")
|
||
after_reload = page.evaluate(_VAR, "--surface-base")
|
||
pressed = page.locator('.theme [aria-pressed="true"]').get_attribute("data-theme-choice")
|
||
page.locator('.theme [data-theme-choice="system"]').click()
|
||
system_dark = page.evaluate(_VAR, "--surface-base")
|
||
page.emulate_media(color_scheme="light")
|
||
system_light = page.evaluate(_VAR, "--surface-base")
|
||
page.locator('.theme [data-theme-choice="dark"]').click()
|
||
forced_dark_on_light_os = page.evaluate(_VAR, "--surface-base")
|
||
ctx.close()
|
||
assert dark != light
|
||
assert after_reload == light and pressed == "light"
|
||
assert system_dark == dark and system_light == light, (system_dark, system_light)
|
||
assert forced_dark_on_light_os == dark
|
||
|
||
|
||
def test_a_forced_theme_follows_high_contrast(browser, live):
|
||
"""r2b D3: under prefers-contrast: more, a FORCED theme gets its own
|
||
high-contrast variant — forced dark resolves exactly what an OS-dark page
|
||
resolves, forced light exactly what an OS-light page does, whatever the OS
|
||
says about the scheme."""
|
||
base, root = live
|
||
_set(root, 1)
|
||
got = {}
|
||
for os_scheme in ("dark", "light"):
|
||
for forced in (None, "dark", "light"):
|
||
ctx = browser.new_context(color_scheme=os_scheme, reduced_motion="no-preference")
|
||
page = ctx.new_page()
|
||
page.emulate_media(color_scheme=os_scheme)
|
||
page.goto(f"{base}/b/g/", wait_until="networkidle")
|
||
page.evaluate("f => f ? document.documentElement.setAttribute('data-theme', f) : null", forced)
|
||
# contrast: more is emulated through CDP; Playwright has no option for it
|
||
cdp = ctx.new_cdp_session(page)
|
||
cdp.send("Emulation.setEmulatedMedia", {"features": [
|
||
{"name": "prefers-contrast", "value": "more"},
|
||
{"name": "prefers-color-scheme", "value": os_scheme}]})
|
||
# tokens that DIFFER between a theme and its high-contrast variant
|
||
# (--surface-card does not, so reading it saw nothing — heid, 2/4)
|
||
got[(os_scheme, forced)] = (page.evaluate(_VAR, "--text-faint"), page.evaluate(_VAR, "--border-default"))
|
||
if forced is None and os_scheme == "dark":
|
||
cdp.send("Emulation.setEmulatedMedia", {"features": [
|
||
{"name": "prefers-contrast", "value": "no-preference"},
|
||
{"name": "prefers-color-scheme", "value": os_scheme}]})
|
||
got["dark, no contrast"] = (page.evaluate(_VAR, "--text-faint"), page.evaluate(_VAR, "--border-default"))
|
||
ctx.close()
|
||
assert got[("light", "dark")] == got[("dark", None)] == got[("dark", "dark")]
|
||
assert got[("dark", "light")] == got[("light", None)] == got[("light", "light")]
|
||
assert got[("dark", None)] != got[("light", None)]
|
||
assert got[("dark", None)] != got["dark, no contrast"] # high contrast really applied
|
||
|
||
|
||
def test_the_theme_toggle_never_shows_without_js_and_a_storage_failure_still_applies(browser, live):
|
||
"""r2b D3: in the markup with `hidden`, never shown without JS (the page
|
||
follows the OS). With localStorage throwing, a click still applies to the
|
||
page; only the memory is lost."""
|
||
base, root = live
|
||
_set(root, 1)
|
||
ctx = browser.new_context(java_script_enabled=False)
|
||
page = ctx.new_page()
|
||
page.goto(f"{base}/", wait_until="networkidle")
|
||
nojs = page.locator(".theme").is_visible()
|
||
ctx.close()
|
||
ctx = browser.new_context(color_scheme="dark")
|
||
page = ctx.new_page()
|
||
errors = []
|
||
page.on("pageerror", lambda e: errors.append(str(e)))
|
||
page.add_init_script("""Storage.prototype.setItem = function () { throw new Error('quota'); };
|
||
Storage.prototype.getItem = function () { throw new Error('denied'); };""")
|
||
page.goto(f"{base}/", wait_until="networkidle")
|
||
before = page.evaluate(_VAR, "--surface-base")
|
||
page.locator('.theme [data-theme-choice="light"]').click()
|
||
after = page.evaluate(_VAR, "--surface-base")
|
||
ctx.close()
|
||
assert not nojs
|
||
assert before != after and errors == [], (before, after, errors)
|
||
|
||
|
||
def test_a_forced_theme_reaches_the_ask_chrome_inside_a_verbatim_page(browser, live):
|
||
"""r2b D3 (operator: 'theme toggle reaches inside'): the `.bk-ask` chrome
|
||
embed.js mounts in an author's page follows the stored choice, and a change
|
||
in another tab (the `storage` event) moves it live. The host page's own
|
||
<html> is never touched."""
|
||
from booth.marks import declare_pick
|
||
base, root = live
|
||
b = root / "rep"
|
||
b.mkdir()
|
||
declare_pick(b, "winner", {"prompt": "Which?", "options": ["A", "B"]})
|
||
(b / "index.html").write_text('<!doctype html><title>r</title><body><h1>R</h1>'
|
||
'<script src="/_booth/embed.js" defer></script></body>')
|
||
ctx = browser.new_context(color_scheme="dark")
|
||
page = ctx.new_page()
|
||
page.goto(f"{base}/b/rep/", wait_until="networkidle")
|
||
page.wait_for_selector(".bk-ask")
|
||
accent = lambda: page.evaluate("getComputedStyle(document.querySelector('.bk-ask')).getPropertyValue('--bk-accent').trim()")
|
||
os_dark = accent()
|
||
other = ctx.new_page() # the toggle, pressed in another tab
|
||
other.goto(f"{base}/", wait_until="networkidle")
|
||
other.locator('.theme [data-theme-choice="light"]').click()
|
||
page.wait_for_timeout(300)
|
||
forced_light = accent()
|
||
host_html = page.evaluate("document.documentElement.getAttribute('data-theme')")
|
||
page.reload(wait_until="networkidle")
|
||
page.wait_for_selector(".bk-ask")
|
||
after_reload = accent()
|
||
ctx.close()
|
||
assert os_dark == "#b2cd12" and forced_light == "#586519" and after_reload == "#586519", (os_dark, forced_light, after_reload)
|
||
assert host_html is None
|
||
|
||
|
||
def test_a_rows_booth_name_comes_before_its_controls_in_tab_order(browser, live):
|
||
"""heid bug-hunt (groa): the cluster sat before the text in the markup, so
|
||
the first tab stop on a row was zip, then keep, then WIPE — before the booth
|
||
it acts on — and with scripts off, wipe submits with no confirm. The name
|
||
is first; the controls follow, wipe last."""
|
||
base, root = live
|
||
_two_rows(root)
|
||
ctx = browser.new_context(viewport={"width": 390, "height": 844}, has_touch=True, is_mobile=True)
|
||
page = ctx.new_page()
|
||
page.goto(f"{base}/", wait_until="networkidle")
|
||
order = page.evaluate("""() => { const row = document.querySelector('.desk-row[data-booth="loose"]');
|
||
return [...row.querySelectorAll('a[href], button')].filter(e => e.tabIndex >= 0)
|
||
.map(e => e.classList.contains('desk-title') ? 'title' : e.closest('form') ? e.closest('form').className.split(' ')[0] : e.className.split(' ')[0]); }""")
|
||
ctx.close()
|
||
assert order == ["title", "dl-link", "keepit", "wipe"], order
|
||
|
||
|
||
def test_a_theme_chosen_in_one_tab_moves_the_others(browser, live):
|
||
"""heid bug-hunt (groa): the ask chrome followed a choice made in another
|
||
tab, but the Booth's own open pages did not until reloaded."""
|
||
base, root = live
|
||
_set(root, 1)
|
||
ctx = browser.new_context(color_scheme="dark")
|
||
a, b = ctx.new_page(), ctx.new_page()
|
||
a.goto(f"{base}/", wait_until="networkidle")
|
||
b.goto(f"{base}/b/g/", wait_until="networkidle")
|
||
a.locator('.theme [data-theme-choice="light"]').click()
|
||
b.wait_for_function("document.documentElement.getAttribute('data-theme') === 'light'", timeout=5000)
|
||
pressed = b.locator('.theme [aria-pressed="true"]').get_attribute("data-theme-choice")
|
||
a.locator('.theme [data-theme-choice="system"]').click()
|
||
b.wait_for_function("!document.documentElement.hasAttribute('data-theme')", timeout=5000)
|
||
ctx.close()
|
||
assert pressed == "light"
|
||
|
||
|
||
def test_the_theme_marks_only_the_ask_fragments_we_mounted(browser, live):
|
||
"""heid bug-hunt (regin): the theme mark went on every `.bk-ask` in the
|
||
page, the author's own included. Only fragments the embed mounted."""
|
||
from booth.marks import declare_pick
|
||
base, root = live
|
||
b = root / "rep"
|
||
b.mkdir()
|
||
declare_pick(b, "winner", {"prompt": "Which?", "options": ["A", "B"]})
|
||
(b / "index.html").write_text('<!doctype html><title>r</title><body><div class="bk-ask" id="authors">mine</div>'
|
||
'<script src="/_booth/embed.js" defer></script></body>')
|
||
ctx = browser.new_context()
|
||
page = ctx.new_page()
|
||
page.add_init_script("try { localStorage.setItem('booth.theme', 'light'); } catch (e) {}")
|
||
page.goto(f"{base}/b/rep/", wait_until="networkidle")
|
||
page.wait_for_selector(".bk-ask:not(#authors)")
|
||
got = page.evaluate("""() => [document.getElementById('authors').getAttribute('data-bk-theme'),
|
||
[...document.querySelectorAll('.bk-ask:not(#authors)')].map(e => e.getAttribute('data-bk-theme'))]""")
|
||
ctx.close()
|
||
assert got[0] is None and got[1] and all(t == "light" for t in got[1]), got
|
||
|
||
|
||
def test_the_pill_shows_at_rest_and_focus_reveals_the_controls(browser, live):
|
||
"""heid code-review: the pill's "visible with no hover" was never asserted
|
||
(an opacity-0 box keeps its geometry), and nothing pinned KEYBOARD focus
|
||
revealing the controls — `:focus-within` could go alone."""
|
||
base, root = live
|
||
_two_rows(root)
|
||
page = browser.new_page(viewport={"width": 1400, "height": 900})
|
||
page.goto(f"{base}/", wait_until="networkidle")
|
||
page.mouse.move(0, 0)
|
||
row = page.locator('.desk-row[data-booth="loose"]')
|
||
pill = row.locator(".life").evaluate("e => [getComputedStyle(e).opacity, getComputedStyle(e).visibility, e.offsetWidth > 0]")
|
||
row.locator(".desk-acts .dl-link").focus()
|
||
page.wait_for_timeout(350)
|
||
focused = row.locator(".desk-acts").evaluate("a => [getComputedStyle(a).opacity, getComputedStyle(a).pointerEvents]")
|
||
page.close()
|
||
assert pill == ["1", "visible", True], pill
|
||
assert focused == ["1", "auto"], focused
|
||
|
||
|
||
def test_with_scripts_off_a_rows_controls_still_act(browser, live):
|
||
"""r2b INV-2, never exercised with JS actually off (heid code-review): the
|
||
hover reveal is CSS, and keep is a plain form."""
|
||
base, root = live
|
||
_two_rows(root)
|
||
ctx = browser.new_context(java_script_enabled=False, viewport={"width": 1400, "height": 900})
|
||
page = ctx.new_page()
|
||
page.goto(f"{base}/", wait_until="networkidle")
|
||
row = page.locator('.desk-row[data-booth="loose"]')
|
||
row.hover()
|
||
page.wait_for_timeout(350)
|
||
with page.expect_navigation():
|
||
row.locator(".desk-acts form.keepit button").click()
|
||
ctx.close()
|
||
assert (root / "loose" / ".forever").exists()
|
||
|
||
|
||
def test_reveal_all_lifts_the_doc_page_it_reaches(browser, live):
|
||
"""heid code-review (regin, seat-settled): the doc page carries the rules,
|
||
but no test turned Reveal all on and looked there."""
|
||
from booth.app import set_blurred
|
||
base, root = live
|
||
b = root / "g"
|
||
b.mkdir()
|
||
(b / "a.png").write_bytes(PNG)
|
||
(b / "n.md").write_text("# secret\n\nbody")
|
||
set_blurred(b, "a.png", True)
|
||
set_blurred(b, "n.md", True)
|
||
page = browser.new_page(viewport={"width": 1200, "height": 800})
|
||
page.goto(f"{base}/b/g/", wait_until="networkidle")
|
||
page.locator("[data-reveal-all]").click()
|
||
page.goto(f"{base}/b/g/view?f=n.md", wait_until="networkidle")
|
||
_settle(page)
|
||
got = [page.evaluate(_FILTER, "#docbody .markdown-body, #docbody .textview"),
|
||
page.evaluate("getComputedStyle(document.getElementById('docreveal')).display")]
|
||
page.close()
|
||
assert got == ["none", "none"], got
|