## Summary Follow-ups to #839 in the browser driver, the browser tools and the real-browser tests. **The touch note survives the end of an owner's binding (regression from #839).** #839 had the driver tell the tools' `_acted` store whenever it dropped an owner's tab binding, and the store then deleted that owner's last-act stamp. The readback promises `note: the user interacted with the browser since your last action` until the owner acts again, and the end of a binding is not the end of the owner: `Browser.release()` has no production caller, so the listener fired only on a reap after `OWNER_IDLE_S`, on the owner's tab closing and on the browser closing. When the reader closed an agent's tab from the panel, or the binding idled out, the agent's next read lost the note. The listener is removed and the driver's owner removal is back to its pre-#839 form; `_ACTED_MAX` still bounds the store. **A host missing a system library is told so.** The driver now answers `Chromium is installed but cannot start here: the system library libatk-1.0.so.0 is missing. Installing system libraries needs root, so it is the user's step: on Debian or Ubuntu, <python> -m playwright install-deps chromium`. Before, on x64 the loader's refusal came back as Playwright's whole launch log, after a throwaway relaunch that could not help; where Playwright's own dependency check runs (its linux-arm64 Chromium builds), its report suggests `playwright install-deps`, which the driver read as "Chromium is not installed". The message says whose step it is because tool results reach the model too. **Only failures a fresh profile cannot fix skip the throwaway relaunch.** The relaunch was gated on the substring "profile", and every Playwright launch failure quotes the command line, `--user-data-dir=<home>/.raven/browser-profile` included, so every failure relaunched and logged "profile is busy". Every failure is still retried once except a missing system library, Playwright's host check and a missing executable, and the warning says the launch failed rather than that the profile is busy. Matching Chromium's lock words instead would be narrower and wrong under another locale: with `LANG=zh_CN.UTF-8` a second headful launch on a held profile prints its line in Chinese, Playwright's English rewrite of it does not fire, and the error says only "Target page, context or browser has been closed". **The profile path is read at launch.** `PROFILE_DIR` was computed at import, before `tests/conftest.py` gives each test its own HOME, so the real-browser tests used the developer's own `~/.raven/browser-profile`, with parallel workers opening it at once; the cookie `test_browser_real_web.py` sets turned up in a developer's own cookie jar. `_profile_dir()` now resolves the path on each launch. **The real-browser suites skip on a host that cannot load Chromium.** `tests/_browser_cache.py` gains `chromium_launch_failure()`: one bare headless launch per process, with Playwright alone. When it fails for a missing system library, both `tests/integration/test_browser_*real_web.py` modules skip with the library named: the twelve `libatk-1.0.so.0` launch failures reported on #839 become twelve skips. Any other launch failure, such as an older build left in the cache or a timeout under load, is not a reason to skip, and the suites fail on it as before. `docs/browser-and-desktop.md` said a second process would get a throwaway profile. The headless shell takes no profile lock, so a second headless Chromium opens the same profile; the sentence now says so. Not in this PR: - `url_for` still predicts the landing page before the permission prompt, so whatever moves while a person decides moves the call (the binding-generation idea in the #600 discussion). - Two headless Ravens share one profile with no lock; documented above, not changed. - `tests/integration/test_browser_tools_real_web.py::test_two_owners_two_tabs_and_neither_takes_the_other` hung in 2 of 73 runs of both real-browser files on main's tree -- both times with one profile shared by every worker, never in the 24 runs with a profile per test -- and in none of 78 runs on this branch or 240 runs of that test alone. The cause is unknown, and counts this small cannot credit any change here with a fix. One of the first 45 branch runs, made before the profile change, also failed one test outright; it was not seen again and is not explained. ## Type - [x] Fix - [ ] Feature - [ ] Docs - [ ] CI / tooling - [ ] Refactor - [ ] Other ## Verification Python 3.12, the repo environment with all extras, run from this tree. - `python -m pytest tests/test_browser_driver.py tests/test_browser_tools.py tests/test_browser_cache.py -q`: 129 passed. With `raven/browser/driver.py` and `raven/agent/tools/browser.py` taken from origin/main, 15 of them fail: the touch-note test for a reader's close and for an idle binding, the launch-time profile test, the four host-library cases, the empty-message retry, and the seven probe tests, which call a helper main lacks. - Each guarded construct was mutated on its own (14 mutations, among them: no stamp after a close, a stamp pruned on a tab close, each of the three no-retry clauses dropped, the host-library check moved after the not-installed one, the profile path fixed at import, the probe skipping on any failure, the probe launching on the caller's loop); each turns at least one test red. - Full suite, `python -m pytest -q`: 27482 passed, 116 skipped, 2 failed. Both failures are local to this box and touch nothing this branch changes: `tests/test_install_script.py::test_resolve_node_dir_answers_each_case_it_exists_for` (an npm elsewhere on PATH leaks past the fixture) and `tests/test_subagent_node_runtime.py::test_what_cannot_be_read_names_nothing` (the suite runs as root, which reads the file the test makes unreadable). - `python -m pytest tests/integration/test_browser_real_web.py tests/integration/test_browser_tools_real_web.py -q` with a real Chromium: 12 passed in each of 3 runs. A guard around `_profile_dir()` logged 39 resolutions, none under the real home, and no file under `~/.raven/browser-profile` changed during the runs. - Report shapes: the host-library fixtures follow real launches against a binary built to need an absent library, with Playwright's dependency check both skipped (the loader's refusal) and forced (both of its Linux reports). Two headless launches on one profile: the second starts. Two headful launches on one profile under `xvfb-run`: with `LANG=en_US.UTF-8` the error says the profile "is already in use"; with `LANG=zh_CN.UTF-8` it carries none of Chromium's English lock words. - `ruff check`, `ruff format --check`, `lint-imports` (10 kept), `ty check raven`, `scripts/check_source_language.py`, `scripts/check_large_files.py`: all pass. - [x] Relevant tests pass locally - [x] Relevant lint / type checks pass locally - [x] User-facing docs or screenshots are updated when needed ## Risk User-visible: the touch note is reported again after the reader closes an agent's tab or the binding idles out; a launch that fails for a missing system library reads as one line naming it, with no throwaway relaunch; every other launch failure still gets one throwaway relaunch, under a different warning. - [x] Security impact considered: the new message names a root command, and it is worded as the user's step because tool results reach the model. - [x] Backward compatibility considered: `Browser.on_owner_released` (added in #839) and the module constant `PROFILE_DIR` are removed; `git grep` finds no reader of either outside the two files changed here. - [x] Rollback path is clear for risky changes: revert the squash commit; nothing persisted changes shape. ## Related Issues Follows up #839; refs #600. --------- Co-authored-by: Claude (claude-opus-5-5[1m]) <noreply@anthropic.com>
260 lines
9.9 KiB
Python
260 lines
9.9 KiB
Python
"""The Playwright browser-cache look-up the real-page suites share.
|
|
|
|
Those suites need the cache Playwright would use for the *login's* home: the
|
|
suite redirects ``HOME`` at a per-test tmp dir, and Playwright resolves the
|
|
cache from the home directory. Getting it wrong is quiet -- the run reports
|
|
Chromium missing and suggests an install that writes somewhere else again --
|
|
so the cases below are the branches of Playwright's own rule, not a list of
|
|
the platforms someone happened to test on.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
import sys
|
|
import types
|
|
from collections.abc import Iterator
|
|
|
|
import pytest
|
|
|
|
from tests import _browser_cache
|
|
from tests._browser_cache import (
|
|
browsers_dir,
|
|
chromium_installed,
|
|
chromium_launch_failure,
|
|
login_home,
|
|
playwright_cache,
|
|
point_at_login_cache,
|
|
)
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def _fresh_launch_probe() -> Iterator[None]:
|
|
"""The probe answers once per process; each test here asks it afresh."""
|
|
chromium_launch_failure.cache_clear()
|
|
yield
|
|
chromium_launch_failure.cache_clear()
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("platform", "env", "expected"),
|
|
[
|
|
pytest.param("linux", {}, ("<home>", ".cache", "ms-playwright"), id="linux"),
|
|
pytest.param("linux", {"XDG_CACHE_HOME": "/xdg"}, ("/xdg", "ms-playwright"), id="linux-xdg"),
|
|
pytest.param("darwin", {}, ("<home>", "Library", "Caches", "ms-playwright"), id="darwin"),
|
|
pytest.param("win32", {}, ("<home>", "AppData", "Local", "ms-playwright"), id="win32"),
|
|
pytest.param("win32", {"LOCALAPPDATA": "/lad"}, ("/lad", "ms-playwright"), id="win32-localappdata"),
|
|
pytest.param("sunos5", {}, None, id="a-platform-playwright-refuses"),
|
|
],
|
|
)
|
|
def test_the_default_cache_follows_playwright_s_rule(
|
|
monkeypatch: pytest.MonkeyPatch, platform: str, env: dict[str, str], expected: tuple[str, ...] | None
|
|
) -> None:
|
|
monkeypatch.setattr(sys, "platform", platform)
|
|
for name in ("XDG_CACHE_HOME", "LOCALAPPDATA"):
|
|
monkeypatch.delenv(name, raising=False)
|
|
for name, value in env.items():
|
|
monkeypatch.setenv(name, value)
|
|
|
|
got = playwright_cache("/h")
|
|
|
|
if expected is None:
|
|
assert got is None
|
|
else:
|
|
assert got == os.path.join(*("/h" if part == "<home>" else part for part in expected))
|
|
|
|
|
|
def test_an_explicit_cache_path_wins(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
monkeypatch.setenv("PLAYWRIGHT_BROWSERS_PATH", "/elsewhere/ms-playwright")
|
|
|
|
assert browsers_dir() == os.path.abspath("/elsewhere/ms-playwright")
|
|
|
|
|
|
def test_a_relative_cache_path_is_taken_from_init_cwd_or_the_working_directory(
|
|
monkeypatch: pytest.MonkeyPatch, tmp_path
|
|
) -> None:
|
|
monkeypatch.setenv("PLAYWRIGHT_BROWSERS_PATH", os.path.join("rel", "pw"))
|
|
monkeypatch.delenv("INIT_CWD", raising=False)
|
|
monkeypatch.chdir(tmp_path)
|
|
assert browsers_dir() == str(tmp_path / "rel" / "pw")
|
|
|
|
monkeypatch.setenv("INIT_CWD", str(tmp_path / "init"))
|
|
assert browsers_dir() == str(tmp_path / "init" / "rel" / "pw")
|
|
|
|
|
|
def test_a_hermetic_install_is_looked_for_inside_the_package(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
playwright = pytest.importorskip("playwright")
|
|
monkeypatch.setenv("PLAYWRIGHT_BROWSERS_PATH", "0")
|
|
|
|
assert browsers_dir() == os.path.join(
|
|
os.path.dirname(playwright.__file__), "driver", "package", ".local-browsers"
|
|
), "a literal '0' is a directory name to nothing but Playwright"
|
|
|
|
|
|
def test_the_login_home_sees_past_a_sandboxed_home(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
pwd = pytest.importorskip("pwd")
|
|
try:
|
|
real = pwd.getpwuid(os.getuid()).pw_dir
|
|
except KeyError:
|
|
pytest.skip("this account has no passwd entry, so HOME is all there is to read")
|
|
monkeypatch.setenv("HOME", "/tmp/sandboxed")
|
|
|
|
assert login_home() == real
|
|
|
|
|
|
def test_the_fixture_aims_playwright_at_the_login_cache_unless_already_aimed(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
monkeypatch.delenv("PLAYWRIGHT_BROWSERS_PATH", raising=False)
|
|
point_at_login_cache(monkeypatch)
|
|
assert os.environ["PLAYWRIGHT_BROWSERS_PATH"] == playwright_cache(login_home())
|
|
|
|
monkeypatch.setenv("PLAYWRIGHT_BROWSERS_PATH", "/chosen")
|
|
point_at_login_cache(monkeypatch)
|
|
assert os.environ["PLAYWRIGHT_BROWSERS_PATH"] == "/chosen", "a caller's own choice is left alone"
|
|
|
|
|
|
def test_a_chromium_directory_is_what_counts_as_installed(tmp_path) -> None:
|
|
"""The old skip asked ``Browser.probe()``, which only tests the package,
|
|
so a missing binary failed the real-page tests instead of skipping them."""
|
|
cache = tmp_path / "ms-playwright"
|
|
cache.mkdir()
|
|
(cache / "ffmpeg-1011").mkdir()
|
|
assert chromium_installed(str(cache)) is False, "another download is not a browser"
|
|
|
|
(cache / "chromium_headless_shell-1234").mkdir()
|
|
assert chromium_installed(str(cache)) is True
|
|
|
|
assert chromium_installed(str(tmp_path / "absent")) is False
|
|
|
|
|
|
def test_a_platform_playwright_refuses_counts_as_not_installed(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
monkeypatch.setattr(sys, "platform", "sunos5")
|
|
monkeypatch.delenv("PLAYWRIGHT_BROWSERS_PATH", raising=False)
|
|
|
|
assert chromium_installed() is False
|
|
point_at_login_cache(monkeypatch)
|
|
assert "PLAYWRIGHT_BROWSERS_PATH" not in os.environ
|
|
|
|
|
|
def _launches(monkeypatch: pytest.MonkeyPatch, *, raising: str | None = None) -> list[str | None]:
|
|
"""Stand in for the bare launch; record the cache each one was aimed at."""
|
|
seen: list[str | None] = []
|
|
|
|
def launch() -> None:
|
|
seen.append(os.environ.get("PLAYWRIGHT_BROWSERS_PATH"))
|
|
if raising is not None:
|
|
raise RuntimeError(raising)
|
|
|
|
monkeypatch.setattr(_browser_cache, "_bare_launch", launch)
|
|
return seen
|
|
|
|
|
|
# The shape a host missing a system library reports: the loader's own refusal
|
|
# inside Playwright's launch error, whose first line only says the browser
|
|
# closed.
|
|
_LOADER_REFUSAL = (
|
|
"BrowserType.launch: Target page, context or browser has been closed\n"
|
|
"[pid=7][err] /cache/chrome-headless-shell: error while loading shared libraries: "
|
|
"libatk-1.0.so.0: cannot open shared object file: No such file or directory"
|
|
)
|
|
|
|
|
|
def test_a_browser_that_cannot_load_a_library_is_skipped_with_the_library_named(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
_launches(monkeypatch, raising=_LOADER_REFUSAL)
|
|
|
|
assert chromium_launch_failure() == "the system library libatk-1.0.so.0 is missing"
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"failure",
|
|
[
|
|
"BrowserType.launch: Executable doesn't exist at /cache/chromium_headless_shell-1240/chrome-headless-shell",
|
|
"BrowserType.launch: Timeout 180000ms exceeded.",
|
|
],
|
|
ids=["older-build-in-the-cache", "launch-under-load"],
|
|
)
|
|
def test_any_other_failure_is_left_for_the_suites_to_report(monkeypatch: pytest.MonkeyPatch, failure: str) -> None:
|
|
"""Only a host's lack is a reason to skip. An older build left in the
|
|
cache is promised a loud failure (``chromium_installed``), and a launch
|
|
that failed under load is not the host's either; a skip would turn both
|
|
into a green exit for every test in the file."""
|
|
seen = _launches(monkeypatch, raising=failure)
|
|
|
|
assert chromium_launch_failure() is None
|
|
assert len(seen) == 1, "the launch really was attempted"
|
|
|
|
|
|
def test_a_browser_that_starts_is_no_reason_to_skip(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
seen = _launches(monkeypatch)
|
|
|
|
assert chromium_launch_failure() is None
|
|
assert len(seen) == 1, "the launch really was attempted"
|
|
|
|
|
|
def test_the_probe_looks_where_the_suites_will_and_restores_the_environment(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""It runs before the suites' own fixture aims Playwright, so it aims the
|
|
launch itself, at the same cache -- and hands the environment back as it
|
|
found it, unset or set."""
|
|
monkeypatch.delenv("PLAYWRIGHT_BROWSERS_PATH", raising=False)
|
|
seen = _launches(monkeypatch)
|
|
chromium_launch_failure()
|
|
assert seen == [playwright_cache(login_home())]
|
|
assert "PLAYWRIGHT_BROWSERS_PATH" not in os.environ
|
|
|
|
chromium_launch_failure.cache_clear()
|
|
monkeypatch.setenv("PLAYWRIGHT_BROWSERS_PATH", "/chosen/ms-playwright")
|
|
chromium_launch_failure()
|
|
assert seen[-1] == os.path.abspath("/chosen/ms-playwright")
|
|
assert os.environ["PLAYWRIGHT_BROWSERS_PATH"] == "/chosen/ms-playwright"
|
|
|
|
|
|
async def test_the_probe_answers_from_inside_a_running_event_loop(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
"""An async fixture or test may be the one asking, and ``asyncio.run``
|
|
refuses to start inside a running loop. The probe would then never launch
|
|
at all, and a host missing a library would fail every test rather than
|
|
skip them. That refusal is not something the host lacks, so the probe
|
|
answers None either way -- which is why the launch itself is asserted."""
|
|
launched: list[str] = []
|
|
|
|
class _Browser:
|
|
async def close(self) -> None:
|
|
pass
|
|
|
|
class _Chromium:
|
|
async def launch(self, **kwargs: object) -> _Browser:
|
|
launched.append("headless" if kwargs.get("headless") else "headful")
|
|
return _Browser()
|
|
|
|
class _Playwright:
|
|
chromium = _Chromium()
|
|
|
|
async def __aenter__(self) -> _Playwright:
|
|
return self
|
|
|
|
async def __aexit__(self, *exc: object) -> None:
|
|
pass
|
|
|
|
fake_api = types.ModuleType("playwright.async_api")
|
|
fake_api.async_playwright = _Playwright # type: ignore[attr-defined]
|
|
fake_pkg = types.ModuleType("playwright")
|
|
fake_pkg.async_api = fake_api # type: ignore[attr-defined]
|
|
monkeypatch.setitem(sys.modules, "playwright", fake_pkg)
|
|
monkeypatch.setitem(sys.modules, "playwright.async_api", fake_api)
|
|
|
|
assert chromium_launch_failure() is None
|
|
assert launched == ["headless"]
|
|
|
|
|
|
def test_the_probe_starts_a_browser_once_per_process(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
seen = _launches(monkeypatch, raising=_LOADER_REFUSAL)
|
|
|
|
first, second = chromium_launch_failure(), chromium_launch_failure()
|
|
|
|
assert first == second == "the system library libatk-1.0.so.0 is missing"
|
|
assert len(seen) == 1
|