92bf9eaa12
web/index.html: - мобильное меню после раскрытия не держит анимационную высоту Bootstrap: нижние пункты (Обзор/История/API-ключи) уезжали под .sidebar-footer и не нажимались - на десктопе рельс #nav скроллится сам, футер не сжимается; активный пункт доскролливается в область видимости - failure() принимает заголовок: ошибка валидации источника больше не подписана «Не удалось загрузить данные» tools/reachability.py: общая проверка «элемент виден, но перекрыт другим» — hit-test по центру с scrollIntoView, пропуск скрытых узлов и закрытых <details>. tools/panel_scenarios.py: 11 сквозных сценариев реального пользователя — deep-link фильтр, экспорт CSV/JSON по байтам, читалка и ссылка на оригинал, дайджест, поиск источников, Telegram-сессия, форма источника (отказ без записи в реестр), клавиатурный flow (/ ? Esc 1-9) со сверкой строк ленты с API, мобильное меню, адаптивность 320-1920 без горизонтального переполнения, зум. tools/ui_smoke.py: reachability-проверки десктопного рельса, контролов и мобильного меню. tests: +3 регрессии на CSS/заголовки ошибок; pytest 93 passed, smoke exit 0, сценарии exit 0, page_errors пуст.
575 lines
30 KiB
Python
575 lines
30 KiB
Python
"""End-to-end user scenarios for the OMNI panel (real clicks, real bytes, real geometry).
|
|
|
|
Complements tools/ui_smoke.py: instead of asserting that every route paints, it walks the
|
|
flows an operator actually performs - deep-link filters, exports, digest, reader download,
|
|
Telegram status, source search, mobile offcanvas - and fails loudly on any of them.
|
|
|
|
Every scenario runs under a hard wall-clock guard, so a stuck Playwright call becomes a
|
|
named failure instead of a silent hang.
|
|
|
|
Run: python tools/panel_scenarios.py [--url http://127.0.0.1:8078] [--shots DIR]
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import asyncio
|
|
import json
|
|
import pathlib
|
|
import sys
|
|
from typing import Any
|
|
from urllib.parse import quote
|
|
|
|
from playwright.async_api import Page, async_playwright
|
|
|
|
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))
|
|
from reachability import find_covered # noqa: E402
|
|
|
|
BASE = "http://127.0.0.1:8078"
|
|
T = 12000 # per-action guard; Playwright defaults proved unreliable on Windows
|
|
|
|
COLLISION_JS = """() => {
|
|
const painted = (el, x, y) => { const top = document.elementFromPoint(x, y); return !!top && (top === el || el.contains(top) || top.contains(el)); };
|
|
const boxes = [];
|
|
const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT);
|
|
let node;
|
|
while ((node = walker.nextNode())) {
|
|
if (!node.textContent.trim()) continue;
|
|
const el = node.parentElement;
|
|
const style = getComputedStyle(el);
|
|
if (style.display === 'none' || style.visibility === 'hidden' || Number(style.opacity) === 0) continue;
|
|
if (el.closest('#sug:not(.show), #drawer:not(.show), #modal:not(.show), .visually-hidden-focusable:not(:focus)')) continue;
|
|
const range = document.createRange();
|
|
range.selectNodeContents(node);
|
|
for (const rect of range.getClientRects()) {
|
|
if (rect.width < 4 || rect.height < 4) continue;
|
|
boxes.push({el, rect, text: node.textContent.trim().slice(0, 28)});
|
|
}
|
|
}
|
|
const found = [];
|
|
for (let i = 0; i < boxes.length; i++) for (let j = i + 1; j < boxes.length; j++) {
|
|
const a = boxes[i], b = boxes[j];
|
|
if (a.el === b.el || a.el.contains(b.el) || b.el.contains(a.el)) continue;
|
|
const x = Math.min(a.rect.right, b.rect.right) - Math.max(a.rect.left, b.rect.left);
|
|
const y = Math.min(a.rect.bottom, b.rect.bottom) - Math.max(a.rect.top, b.rect.top);
|
|
if (x <= 3 || y <= 3) continue;
|
|
const cx = (Math.max(a.rect.left, b.rect.left) + Math.min(a.rect.right, b.rect.right)) / 2;
|
|
const cy = (Math.max(a.rect.top, b.rect.top) + Math.min(a.rect.bottom, b.rect.bottom)) / 2;
|
|
if (painted(a.el, cx, cy) && painted(b.el, cx, cy)) found.push(a.text + ' <> ' + b.text);
|
|
}
|
|
return {collisions: found.slice(0, 5), scrollW: document.documentElement.scrollWidth, innerW: innerWidth};
|
|
}"""
|
|
|
|
|
|
class Runner:
|
|
"""Scenario context: one page, shared report, guarded steps."""
|
|
|
|
def __init__(self, page: Page, url: str, shots: pathlib.Path):
|
|
self.page = page
|
|
self.url = url.rstrip("/")
|
|
self.shots = shots
|
|
self.out: dict[str, Any] = {"url": self.url, "scenarios": {}}
|
|
self.errors: list[str] = []
|
|
|
|
async def settle(self):
|
|
try:
|
|
await self.page.wait_for_load_state("networkidle", timeout=5000)
|
|
except Exception:
|
|
pass
|
|
|
|
async def goto_hash(self, hash_part: str, selector: str | None = None):
|
|
"""Routing lives in location.hash; page.goto() would hang on a same-document change."""
|
|
await self.page.evaluate("h => { location.hash = h; }", hash_part)
|
|
if selector:
|
|
await self.page.wait_for_selector(selector, timeout=25000)
|
|
await self.settle()
|
|
|
|
async def no_collision(self, label: str):
|
|
res = await self.page.evaluate(COLLISION_JS)
|
|
assert not res["collisions"], f"{label}: text on text {res['collisions']}"
|
|
assert res["scrollW"] <= res["innerW"] + 1, (
|
|
f"{label}: horizontal overflow {res['scrollW']} > {res['innerW']}"
|
|
)
|
|
self.out["scenarios"].setdefault("no_collision", []).append(label)
|
|
|
|
# ---------------------------------------------------------------- scenarios
|
|
async def deep_link(self):
|
|
page = self.page
|
|
await page.goto(self.url + "/#/feed", wait_until="domcontentloaded", timeout=30000)
|
|
await page.wait_for_selector("#list .item", timeout=25000)
|
|
await self.settle()
|
|
rows_all = await page.locator("#list .item").count()
|
|
source = (
|
|
await page.locator("#list .item .feed-content .small > span:first-child")
|
|
.first.inner_text(timeout=T)
|
|
).strip()
|
|
assert source, "feed row has no source label"
|
|
await self.goto_hash("#/feed?src=" + quote(source), "#list .item")
|
|
rows_src = await page.locator("#list .item").count()
|
|
shown = await page.evaluate(
|
|
"""() => [...document.querySelectorAll('#list .item .feed-content .small > span:first-child')]
|
|
.slice(0, 25).map(e => e.textContent.trim())"""
|
|
)
|
|
mismatched = [s for s in shown if s != source]
|
|
self.out["scenarios"]["deep_link"] = {
|
|
"rows_all": rows_all,
|
|
"source": source[:40],
|
|
"rows_filtered": rows_src,
|
|
"mismatched_rows": len(mismatched),
|
|
}
|
|
assert rows_src > 0, f"src deep-link returned no rows for {source!r}"
|
|
assert not mismatched, f"src deep-link leaked other sources: {mismatched[:3]}"
|
|
# Resetting the filter must restore the full feed.
|
|
await self.goto_hash("#/feed", "#list .item")
|
|
rows_reset = await page.locator("#list .item").count()
|
|
self.out["scenarios"]["deep_link"]["rows_after_reset"] = rows_reset
|
|
assert rows_reset >= rows_src, "resetting the deep-link filter shrank the feed"
|
|
|
|
async def exports(self):
|
|
page = self.page
|
|
await self.goto_hash("#/feed", "#list .item")
|
|
csv_href = await page.locator("#export-csv").get_attribute("href", timeout=T)
|
|
json_href = await page.locator("#export-json").get_attribute("href", timeout=T)
|
|
sizes: dict[str, int] = {}
|
|
for key, href in (("csv", csv_href), ("json", json_href)):
|
|
assert href and href.startswith("/api/export"), f"export {key} href missing: {href}"
|
|
resp = await page.request.get(self.url + href, timeout=30000)
|
|
assert resp.status == 200, f"export {key} -> HTTP {resp.status}"
|
|
body = await resp.body()
|
|
sizes[key] = len(body)
|
|
assert len(body) > 200, f"export {key} suspiciously small: {len(body)} bytes"
|
|
payload = await page.evaluate(
|
|
"""async (href) => { const r = await fetch(href); const j = await r.json();
|
|
return {ok: j.ok, total: j.total, count: j.count,
|
|
first: (j.items && j.items[0]) ? Object.keys(j.items[0]).slice(0, 8) : []}; }""",
|
|
json_href,
|
|
)
|
|
assert payload["count"] > 0 and payload["first"], f"export json invalid: {payload}"
|
|
assert "title" in payload["first"], f"export json lost columns: {payload['first']}"
|
|
self.out["scenarios"]["exports"] = {"bytes": sizes, "json": payload, "csv_href": (csv_href or "")[:70]}
|
|
|
|
async def reader(self):
|
|
page = self.page
|
|
await self.goto_hash("#/feed", "#list .item")
|
|
opener = page.locator("#list .item").first.locator("[data-id]").first
|
|
item_id = await opener.get_attribute("data-id", timeout=T)
|
|
assert item_id, "feed row has no data-id"
|
|
async with page.expect_response(lambda r: f"/api/item/{item_id}" in r.url, timeout=25000) as detail:
|
|
await opener.click(timeout=T)
|
|
resp = await detail.value
|
|
await page.wait_for_selector("#drawer.show", timeout=15000)
|
|
body_len = await page.locator("#d-body").evaluate("el => el.textContent.trim().length")
|
|
title = (await page.locator("#d-title").inner_text(timeout=T)).strip()
|
|
payload = await resp.json()
|
|
api_url = (payload.get("item") or payload).get("url") or ""
|
|
link_href = await page.locator('#drawer a[target="_blank"]').first.get_attribute("href", timeout=T)
|
|
self.out["scenarios"]["reader"] = {
|
|
"id": item_id,
|
|
"api_status": resp.status,
|
|
"title": title[:60],
|
|
"body_chars": body_len,
|
|
"api_url": api_url[:70],
|
|
"original_link": (link_href or "")[:70],
|
|
}
|
|
assert resp.status == 200, f"item api -> HTTP {resp.status}"
|
|
assert title, "reader opened without a title"
|
|
assert body_len > 40, f"reader body empty for {item_id}"
|
|
if api_url:
|
|
assert link_href == api_url, f"original link {link_href!r} != api url {api_url!r}"
|
|
await page.keyboard.press("Escape")
|
|
await page.wait_for_timeout(600)
|
|
assert not await page.evaluate("document.querySelector('#drawer').classList.contains('show')"), \
|
|
"Escape did not close the reader"
|
|
await self.no_collision("reader closed")
|
|
|
|
async def digest(self):
|
|
page = self.page
|
|
await self.goto_hash("#/digest")
|
|
await page.locator('[data-act="digest"]').first.click(timeout=T)
|
|
await page.wait_for_timeout(4000)
|
|
html = await page.locator("#view").inner_html(timeout=T)
|
|
leaked = "ai_not_configured" in html and "ИИ не настроен" not in html
|
|
self.out["scenarios"]["digest"] = {
|
|
"rendered_chars": len(html),
|
|
"has_markdown": "```" in html or "<pre" in html,
|
|
"friendly_hint": "ИИ не настроен" in html,
|
|
"raw_error_leak": leaked,
|
|
}
|
|
assert not leaked, "digest leaked the raw backend error code to the operator"
|
|
assert len(html) > 200, "digest rendered nothing"
|
|
|
|
async def sources_and_telegram(self):
|
|
page = self.page
|
|
await self.goto_hash("#/sources", "#src-tbl")
|
|
# The table paints a placeholder row first; wait for the real registry.
|
|
await page.wait_for_function(
|
|
"document.querySelectorAll('#src-tbl tbody tr').length > 5", timeout=25000
|
|
)
|
|
rows_all = await page.locator("#src-tbl tbody tr").count()
|
|
needle = "telegram"
|
|
await page.locator("#s-q").fill(needle, timeout=T)
|
|
await page.wait_for_timeout(1800)
|
|
await self.settle()
|
|
rows_filtered = await page.locator("#src-tbl tbody tr").count()
|
|
visible = await page.evaluate(
|
|
"""() => [...document.querySelectorAll('#src-tbl tbody tr')]
|
|
.slice(0, 25).map(tr => tr.textContent.toLowerCase())"""
|
|
)
|
|
off_topic = [row[:40] for row in visible if needle not in row]
|
|
self.out["scenarios"]["source_search"] = {
|
|
"rows_all": rows_all,
|
|
"needle": needle,
|
|
"rows_filtered": rows_filtered,
|
|
"off_topic_rows": len(off_topic),
|
|
}
|
|
assert rows_all > 100, f"source registry looks empty: {rows_all} rows"
|
|
assert 0 < rows_filtered < rows_all, f"source search broken: {rows_all} -> {rows_filtered}"
|
|
assert not off_topic, f"source search returned unrelated rows: {off_topic[:3]}"
|
|
|
|
await self.goto_hash("#/tg", "#tg-search-form")
|
|
status = await page.evaluate(
|
|
"async () => { const r = await fetch('/api/tg/status'); return {status: r.status, body: await r.json()}; }"
|
|
)
|
|
body = status["body"]
|
|
me = body.get("me") or {}
|
|
text = (await page.locator("#view").inner_text(timeout=T)).strip()
|
|
self.out["scenarios"]["telegram"] = {
|
|
"http": status["status"],
|
|
"enabled": body.get("enabled"),
|
|
"error": body.get("error"),
|
|
"account": me.get("first_name"),
|
|
"account_id": me.get("id"),
|
|
"session": body.get("session"),
|
|
"rendered_chars": len(text),
|
|
}
|
|
assert status["status"] == 200, f"tg status -> HTTP {status['status']}"
|
|
assert body.get("enabled") is True and not body.get("error"), f"tg session degraded: {body}"
|
|
assert me.get("first_name") and me.get("id"), f"tg account missing: {body}"
|
|
# the tab mounts a "Загрузка данных…" stub first; a real render is far longer
|
|
assert len(text) > 200, f"Telegram tab rendered a stub: {len(text)} chars -> {text[:80]!r}"
|
|
|
|
async def mobile(self):
|
|
page = self.page
|
|
await page.set_viewport_size({"width": 390, "height": 860})
|
|
# A query before the hash forces a real document load; hash-only goto is same-document.
|
|
await page.goto(self.url + "/?v=mobile#/feed", wait_until="domcontentloaded", timeout=30000)
|
|
await page.wait_for_selector("#list .item", timeout=25000)
|
|
await self.settle()
|
|
await asyncio.wait_for(page.locator("#sidebar-toggle").click(timeout=T), 25)
|
|
await page.wait_for_selector("#sidebar-menu.show:not(.collapsing)", timeout=10000)
|
|
await page.wait_for_timeout(400)
|
|
# Everything painted must be tappable. find_covered skips hidden nodes and closed
|
|
# <details> groups, so a footer or overlay covering a real control fails the run.
|
|
covered = await find_covered(
|
|
page, "#sidebar-menu [data-nav], .sidebar-footer button, #sidebar-toggle", "nav"
|
|
)
|
|
geometry = await page.evaluate(
|
|
"""() => { const nav = document.querySelector('#nav').getBoundingClientRect();
|
|
const foot = document.querySelector('.sidebar-footer').getBoundingClientRect();
|
|
return {navBottom: Math.round(nav.bottom), footerTop: Math.round(foot.top),
|
|
menuHeight: Math.round(document.querySelector('#sidebar-menu').getBoundingClientRect().height),
|
|
menuInlineHeight: document.querySelector('#sidebar-menu').style.height || ''}; }"""
|
|
)
|
|
# «Обзор» lives in the collapsible «Система» group: open it the way a user would.
|
|
await asyncio.wait_for(page.locator("#system-nav > summary").click(timeout=T), 25)
|
|
await page.wait_for_function("document.querySelector('#system-nav').open", timeout=10000)
|
|
covered_system = await find_covered(page, "#system-nav [data-nav]", "nav")
|
|
labels = [t.strip() for t in await page.locator("#sidebar-menu [data-nav]").all_inner_texts()]
|
|
# A real click hangs forever when something is painted over the target - that is the point.
|
|
await asyncio.wait_for(page.locator('#sidebar-menu [data-nav="overview"]').click(timeout=T), 30)
|
|
await page.wait_for_timeout(1200)
|
|
hash_after = await page.evaluate("location.hash")
|
|
closed = await page.evaluate("!document.querySelector('#sidebar-menu').classList.contains('show')")
|
|
await self.no_collision("mobile overview")
|
|
self.out["scenarios"]["mobile"] = {
|
|
"nav_labels": labels[:12],
|
|
"covered_controls": covered,
|
|
"covered_system_group": covered_system,
|
|
"sidebar_geometry": geometry,
|
|
"hash_after": hash_after,
|
|
"menu_closed_after_nav": closed,
|
|
}
|
|
assert not covered, f"mobile menu has untappable controls: {covered}"
|
|
assert not covered_system, f"«Система» group has untappable items: {covered_system}"
|
|
assert geometry["navBottom"] <= geometry["footerTop"] + 1, f"nav overlaps footer: {geometry}"
|
|
assert "overview" in hash_after, f"mobile navigation did not route: {hash_after}"
|
|
assert closed, "offcanvas stayed open after navigation"
|
|
assert labels and all(labels), "mobile navigation lost its labels"
|
|
await page.screenshot(path=str(self.shots / "mobile_overview.png"))
|
|
await page.set_viewport_size({"width": 1440, "height": 960})
|
|
|
|
async def add_source(self):
|
|
"""Reject an invalid source through the real form: no mutation, friendly message."""
|
|
page = self.page
|
|
await page.set_viewport_size({"width": 1440, "height": 960})
|
|
await self.goto_hash("#/sources", "#src-tbl")
|
|
await page.wait_for_function(
|
|
"document.querySelectorAll('#src-tbl tbody tr').length > 5", timeout=25000
|
|
)
|
|
rows_before = await page.locator("#src-tbl tbody tr").count()
|
|
await asyncio.wait_for(page.locator('[data-act="add-src"]').click(timeout=T), 15)
|
|
await page.wait_for_selector("#modal.show #add-source-form", timeout=10000)
|
|
out = {"rows_before": rows_before}
|
|
# The submit button sits in the modal footer and is wired to the form by id,
|
|
# so "#add-source-form button[type=submit]" matches nothing.
|
|
submit = page.locator('#modal-box button[type="submit"][form="add-source-form"]')
|
|
out["covered_modal_controls"] = await find_covered(
|
|
page, "#modal.show button, #modal.show input, #modal.show select", None
|
|
)
|
|
# 1) empty required fields: native validation must block the write
|
|
await asyncio.wait_for(submit.click(timeout=T), 15)
|
|
await page.wait_for_timeout(600)
|
|
out["url_invalid_when_empty"] = await page.evaluate(
|
|
"!document.querySelector('#a-url').checkValidity()"
|
|
)
|
|
out["error_after_empty_submit"] = (
|
|
await page.locator("#add-source-error").inner_text()
|
|
).strip()
|
|
# 2) a non-http scheme passes type=url but must be refused by the app
|
|
await page.fill("#a-name", "scenario-probe-do-not-add")
|
|
await page.fill("#a-url", "ftp://example.invalid/feed")
|
|
await asyncio.wait_for(submit.click(timeout=T), 15)
|
|
await page.wait_for_function(
|
|
"document.querySelector('#add-source-error').textContent.trim().length > 0", timeout=10000
|
|
)
|
|
out["error_text"] = (await page.locator("#add-source-error").inner_text()).strip()[:160]
|
|
out["modal_still_open"] = await page.evaluate(
|
|
"document.querySelector('#modal').classList.contains('show')"
|
|
)
|
|
await page.keyboard.press("Escape")
|
|
await page.wait_for_function(
|
|
"!document.querySelector('#modal').classList.contains('show')", timeout=10000
|
|
)
|
|
await self.goto_hash("#/sources", "#src-tbl")
|
|
await page.wait_for_function(
|
|
"document.querySelectorAll('#src-tbl tbody tr').length > 5", timeout=25000
|
|
)
|
|
out["rows_after"] = await page.locator("#src-tbl tbody tr").count()
|
|
self.out["scenarios"]["add_source"] = out
|
|
assert out["url_invalid_when_empty"], "empty URL passed native validation"
|
|
assert not out["error_after_empty_submit"], "native validation leaked an app error"
|
|
assert "http" in out["error_text"].lower(), f"no friendly validation message: {out['error_text']!r}"
|
|
assert "не удалось загрузить" not in out["error_text"].lower(), (
|
|
f"validation error disguised as a load failure: {out['error_text']!r}"
|
|
)
|
|
assert out["modal_still_open"], "modal closed despite the rejected source"
|
|
assert not out["covered_modal_controls"], f"modal controls untappable: {out['covered_modal_controls']}"
|
|
assert out["rows_after"] == rows_before, (
|
|
f"rejected source leaked into the registry: {rows_before} -> {out['rows_after']}"
|
|
)
|
|
|
|
async def keyboard(self):
|
|
"""Keyboard-only user: / search, Esc, ? help, digit navigation."""
|
|
page = self.page
|
|
await page.set_viewport_size({"width": 1440, "height": 960})
|
|
await self.goto_hash("#/feed", "#list .item")
|
|
out = {"rows_before": await page.locator("#list .item").count()}
|
|
await page.keyboard.press("/")
|
|
out["slash_focus"] = await page.evaluate("document.activeElement?.id || ''")
|
|
needle = "telethon" # rare enough that a filtered page is smaller than the default one
|
|
await page.keyboard.type(needle, delay=40)
|
|
await page.wait_for_timeout(900)
|
|
out["suggestions"] = await page.evaluate("document.querySelectorAll('#sug button').length")
|
|
# Typing only fills the box: the list filters when the feed form is submitted.
|
|
await page.keyboard.press("Enter")
|
|
await page.wait_for_selector("#list .item", timeout=25000)
|
|
await page.wait_for_timeout(1200)
|
|
out["query"] = await page.input_value("#q")
|
|
out["hash_after_query"] = await page.evaluate("location.hash")
|
|
out["rows_after_query"] = await page.locator("#list .item").count()
|
|
# A match can live in the body text, so compare the rendered ids with the API answer
|
|
# instead of looking for the needle in visible text.
|
|
out["ui_ids"] = await page.evaluate(
|
|
"[...document.querySelectorAll('#list .item .reader-open')].map(b => Number(b.dataset.id))"
|
|
)
|
|
out["api_ids"] = await page.evaluate(
|
|
"""async q => {
|
|
const r = await fetch('/api/items?q=' + encodeURIComponent(q) + '&limit=40&sort=fresh');
|
|
const d = await r.json();
|
|
return (d.items || []).map(i => Number(i.id));
|
|
}""",
|
|
needle,
|
|
)
|
|
await page.keyboard.press("Escape")
|
|
await page.wait_for_timeout(600)
|
|
out["suggestions_hidden"] = await page.evaluate(
|
|
"const s=document.querySelector('#sug'); !s || s.classList.contains('d-none')"
|
|
)
|
|
await page.evaluate("document.activeElement && document.activeElement.blur()")
|
|
await page.keyboard.press("?")
|
|
await page.wait_for_selector("#modal.show", timeout=10000)
|
|
# Bootstrap drops Escape during the fade-in transition
|
|
await page.wait_for_timeout(450)
|
|
out["help_title"] = (await page.locator("#modal-title").inner_text()).strip()
|
|
await page.keyboard.press("Escape")
|
|
await page.wait_for_function(
|
|
"!document.querySelector('#modal').classList.contains('show')", timeout=10000
|
|
)
|
|
await page.keyboard.press("3")
|
|
await page.wait_for_timeout(1000)
|
|
out["hash_after_3"] = await page.evaluate("location.hash")
|
|
await page.keyboard.press("2")
|
|
await page.wait_for_timeout(1000)
|
|
out["hash_after_2"] = await page.evaluate("location.hash")
|
|
await self.no_collision("keyboard flow")
|
|
self.out["scenarios"]["keyboard"] = out
|
|
assert out["slash_focus"] == "q", f"/ did not focus search: {out['slash_focus']!r}"
|
|
assert out["query"] == needle, f"search box lost the query: {out}"
|
|
assert "q=" + needle in out["hash_after_query"], f"query did not reach the route: {out}"
|
|
assert 0 < out["rows_after_query"] < out["rows_before"], f"search did not filter: {out}"
|
|
assert out["ui_ids"] and set(out["ui_ids"]) == set(out["api_ids"]), (
|
|
f"rendered rows differ from the API answer: {out['ui_ids'][:6]} vs {out['api_ids'][:6]}"
|
|
)
|
|
assert out["suggestions_hidden"], "suggestions stayed open after Escape"
|
|
assert out["help_title"], "help modal opened without a title"
|
|
assert "abuse" in out["hash_after_3"], f"digit 3 did not switch section: {out['hash_after_3']}"
|
|
assert "feed" in out["hash_after_2"], f"digit 2 did not return to feed: {out['hash_after_2']}"
|
|
|
|
async def adaptivity(self):
|
|
"""Narrow and wide screens: no horizontal scrolling, no covered controls."""
|
|
page = self.page
|
|
routes = ("feed", "sources", "abuse", "overview")
|
|
results = {}
|
|
for width in (320, 390, 768, 1024, 1280, 1920):
|
|
await page.set_viewport_size({"width": width, "height": 900})
|
|
# query before the hash forces a real document load for this width
|
|
await page.goto(
|
|
f"{self.url}/?v=w{width}#/feed", wait_until="domcontentloaded", timeout=30000
|
|
)
|
|
await page.wait_for_selector("#list .item", timeout=25000)
|
|
per_route = {}
|
|
for route in routes:
|
|
await self.goto_hash(f"#/{route}")
|
|
await page.wait_for_timeout(900)
|
|
per_route[route] = await page.evaluate(
|
|
"""() => {
|
|
const contained = el => {
|
|
for (let p = el.parentElement; p && p !== document.body; p = p.parentElement) {
|
|
const ox = getComputedStyle(p).overflowX;
|
|
if ((ox === 'auto' || ox === 'scroll' || ox === 'hidden')
|
|
&& p.getBoundingClientRect().right <= window.innerWidth + 1) return true;
|
|
}
|
|
return false;
|
|
};
|
|
return {scrollW: document.documentElement.scrollWidth,
|
|
inner: window.innerWidth,
|
|
spilled: [...document.querySelectorAll('#view *')]
|
|
.filter(e => e.getBoundingClientRect().right > window.innerWidth + 1
|
|
&& !contained(e))
|
|
.slice(0, 3)
|
|
.map(e => (e.id ? '#' + e.id : '') + '.'
|
|
+ (e.className.toString().slice(0, 40)))};
|
|
}"""
|
|
)
|
|
results[width] = per_route
|
|
if width in (320, 768):
|
|
await self.goto_hash("#/feed", "#list .item")
|
|
results[f"covered@{width}"] = await find_covered(
|
|
page, "#page-actions .btn, #view .nav-tabs .nav-link, #q, #sidebar-toggle", None
|
|
)
|
|
self.out["scenarios"]["adaptivity"] = results
|
|
overflow = [
|
|
{"width": width, "route": route, **m}
|
|
for width, per_route in results.items()
|
|
if isinstance(per_route, dict)
|
|
for route, m in per_route.items()
|
|
if m["scrollW"] > m["inner"] + 1 or m["spilled"]
|
|
]
|
|
covered = {k: v for k, v in results.items() if str(k).startswith("covered@") and v}
|
|
assert not overflow, f"horizontal overflow: {overflow[:4]}"
|
|
assert not covered, f"untappable controls on narrow screens: {covered}"
|
|
await page.set_viewport_size({"width": 1440, "height": 960})
|
|
|
|
async def zoom(self):
|
|
page = self.page
|
|
await page.set_viewport_size({"width": 1440, "height": 960})
|
|
for zoom in ("1", "1.25", "1.5"):
|
|
await page.evaluate(f"document.documentElement.style.zoom='{zoom}'")
|
|
for route in ("feed", "sources", "abuse", "overview"):
|
|
await self.goto_hash(f"#/{route}")
|
|
await page.wait_for_timeout(700)
|
|
await self.no_collision(f"{route} @ zoom {zoom}")
|
|
await page.evaluate("document.documentElement.style.zoom=''")
|
|
|
|
async def screenshots(self):
|
|
page = self.page
|
|
await page.set_viewport_size({"width": 1440, "height": 960})
|
|
await self.goto_hash("#/feed", "#list .item")
|
|
await page.screenshot(path=str(self.shots / "scenarios_feed.png"))
|
|
await self.goto_hash("#/sources", "#src-tbl")
|
|
await page.screenshot(path=str(self.shots / "scenarios_sources.png"))
|
|
await self.goto_hash("#/overview")
|
|
await page.wait_for_timeout(1200)
|
|
await page.screenshot(path=str(self.shots / "scenarios_overview.png"))
|
|
await page.set_viewport_size({"width": 390, "height": 860})
|
|
await self.goto_hash("#/feed", "#list .item")
|
|
await page.screenshot(path=str(self.shots / "scenarios_mobile.png"))
|
|
await page.set_viewport_size({"width": 1440, "height": 960})
|
|
|
|
|
|
SCENARIOS = [
|
|
("deep_link", 90),
|
|
("exports", 90),
|
|
("reader", 90),
|
|
("digest", 90),
|
|
("sources_and_telegram", 90),
|
|
("add_source", 90),
|
|
("keyboard", 120),
|
|
("mobile", 90),
|
|
("adaptivity", 240),
|
|
("zoom", 150),
|
|
("screenshots", 90),
|
|
]
|
|
|
|
|
|
async def run(url: str, shots: pathlib.Path) -> dict:
|
|
shots.mkdir(parents=True, exist_ok=True)
|
|
async with async_playwright() as pw:
|
|
browser = await pw.chromium.launch()
|
|
runner: Runner | None = None
|
|
try:
|
|
page = await browser.new_page(viewport={"width": 1440, "height": 960})
|
|
page.set_default_timeout(T)
|
|
page.set_default_navigation_timeout(30000)
|
|
runner = Runner(page, url, shots)
|
|
page.on("pageerror", lambda e: runner.errors.append(f"pageerror: {e}"))
|
|
page.on(
|
|
"console",
|
|
lambda m: runner.errors.append(f"console: {m.text}") if m.type == "error" else None,
|
|
)
|
|
for name, budget in SCENARIOS:
|
|
runner.out["stage"] = name
|
|
print("[scenario]", name, flush=True)
|
|
await asyncio.wait_for(getattr(runner, name)(), budget)
|
|
runner.out["stage"] = "done"
|
|
runner.out["page_errors"] = runner.errors[:8]
|
|
assert not runner.errors, f"browser errors during scenarios: {runner.errors[:4]}"
|
|
except BaseException as exc: # keep the report even when a scenario blows up
|
|
if runner is not None:
|
|
runner.out["error"] = f"{type(exc).__name__}: {exc}"[:400]
|
|
runner.out["page_errors"] = runner.errors[:8]
|
|
raise
|
|
finally:
|
|
if runner is not None:
|
|
(shots / "report.json").write_text(
|
|
json.dumps(runner.out, ensure_ascii=False, indent=2), encoding="utf-8"
|
|
)
|
|
print(json.dumps(runner.out, ensure_ascii=False, indent=2))
|
|
try:
|
|
await asyncio.wait_for(browser.close(), timeout=20)
|
|
except Exception:
|
|
pass
|
|
return runner.out if runner else {}
|
|
|
|
|
|
def main() -> int:
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument("--url", default=BASE)
|
|
parser.add_argument("--shots", default="data/shots/scenarios")
|
|
args = parser.parse_args()
|
|
asyncio.run(run(args.url, pathlib.Path(args.shots)))
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|