Files
archived-camoufox/python/tests/test_browser_pin.py
T
Jake WriterandClaude Opus 5.5 0bb4f14b74 Keep the caller's launch inputs unchanged, and claim the avail screen and touch points baseline protection reports
launch_options/launchOptions filled the caller's config, prefs, args and
addons in place. A config reused for a second launch then carried the first
identity's webGl:vendor in, which read as a GPU the caller named: the second
launch covered its canvas while claiming the host's GPU. The TypeScript
end-to-end test caught it through its Python probe, which calls
launch_options before Camoufox with the same kwargs. Both launchers now work
on copies.

Firefox's baseline fingerprinting protection reports the available screen as
the screen less a fixed taskbar for the claimed OS (48px Windows, 76px macOS,
none on Linux) and collapses more than one touch point to 5, and the browser
applies that to the spoofed values. The launchers still claimed fpgen's
recorded avail rect, adjusted by fix_screen_no_taskbar, so a Linux identity's
config said availHeight 1053 while the page read 1080. follow_baseline_protection
/ followBaselineProtection replaces it and claims what the browser reports.

The end-to-end test now compares a covered canvas by being covered (its
readback is random on every read, so its size was too), launches the
NewContext scenario with canvas_noise, since an uncovered browser binds its
contexts to the host, and checks a headful launch against its own config,
because Xvfb can render on another device than headless.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 13:39:02 -06:00

244 lines
11 KiB
Python

"""A released library runs the browser it was released with, and nothing else by default.
Each published package is stamped with `browser-pin.json` naming the browser
release built from the same sources. These tests hold the three places that
decide which build is used -- the active install at launch, the asset the
fetcher accepts, and the explicit-choice escape hatch -- to that pairing.
"""
import json
import warnings
import pytest
from camoufox import browser_pin, multiversion, pkgman, utils
from camoufox.exceptions import CamoufoxNotInstalled, UnsupportedVersion
PIN = {
"tag": "v156.0.1-beta.33",
"repo": "daijro/camoufox",
"repo_name": "Official",
"version": "156.0.1",
"build": "beta.33",
}
def _setup(tmp_path, monkeypatch, *, pin, installed, config):
root = tmp_path / "cache"
root.mkdir()
(root / ".0.5_FLAG").write_text("")
(root / "repo_cache.json").write_text("{}")
(root / "config.json").write_text(json.dumps(config))
for spec in installed:
version, build = spec.split("-", 1)
d = root / "browsers" / "official" / spec
d.mkdir(parents=True)
(d / "version.json").write_text(json.dumps({"version": version, "build": build}))
pin_file = tmp_path / "browser-pin.json"
pin_file.write_text(json.dumps(pin))
monkeypatch.setattr(browser_pin, "PIN_FILE", pin_file)
monkeypatch.setattr(browser_pin, "_warned", False)
for module in (pkgman, multiversion):
monkeypatch.setattr(module, "INSTALL_DIR", root)
monkeypatch.setattr(multiversion, "BROWSERS_DIR", root / "browsers")
monkeypatch.setattr(multiversion, "CONFIG_FILE", root / "config.json")
monkeypatch.setattr(multiversion, "COMPAT_FLAG", root / ".0.5_FLAG")
return root
@pytest.mark.parametrize("content", ["{}", '{"tag": null}', "", "not json"])
def test_an_empty_or_missing_pin_pins_nothing(tmp_path, content):
f = tmp_path / "browser-pin.json"
f.write_text(content)
assert browser_pin.load_pin(f) is None
assert browser_pin.load_pin(tmp_path / "absent.json") is None
def test_the_checked_in_pin_is_empty():
"""main pins nothing; only the release workflow writes a real pin."""
assert json.loads(browser_pin.PIN_FILE.read_text()) == {}
def test_launch_uses_the_paired_build_even_when_another_is_marked_active(tmp_path, monkeypatch):
root = _setup(
tmp_path, monkeypatch, pin=PIN,
installed=["156.0.1-beta.33", "157.0-beta.34"],
config={"active_version": "browsers/official/157.0-beta.34"},
)
assert multiversion.get_active_path() == root / "browsers/official/156.0.1-beta.33"
assert pkgman.installed_verstr() == "156.0.1-beta.33"
def test_a_newer_build_is_not_used_when_the_paired_one_is_missing(tmp_path, monkeypatch):
_setup(tmp_path, monkeypatch, pin=PIN, installed=["157.0-beta.34"], config={})
assert multiversion.get_active_path() is None
with pytest.raises(CamoufoxNotInstalled, match="156.0.1-beta.33"):
pkgman.installed_verstr()
def test_an_explicit_choice_is_kept_and_warned_about(tmp_path, monkeypatch):
root = _setup(
tmp_path, monkeypatch, pin=PIN,
installed=["156.0.1-beta.33", "157.0-beta.34"],
config={"channel": "official/stable", "active_version": "browsers/official/157.0-beta.34"},
)
assert multiversion.get_active_path() == root / "browsers/official/157.0-beta.34"
with pytest.warns(RuntimeWarning, match="v156.0.1-beta.33"):
assert pkgman.installed_verstr() == "157.0-beta.34"
with warnings.catch_warnings():
warnings.simplefilter("error")
pkgman.installed_verstr() # once per process, not per launch
def test_an_explicit_choice_of_the_paired_build_does_not_warn(tmp_path, monkeypatch):
_setup(
tmp_path, monkeypatch, pin=PIN, installed=["156.0.1-beta.33"],
config={"pinned": "156.0.1-beta.33", "channel": "official/prerelease",
"active_version": "browsers/official/156.0.1-beta.33"},
)
with warnings.catch_warnings():
warnings.simplefilter("error")
assert pkgman.installed_verstr() == "156.0.1-beta.33"
def test_without_a_pin_the_channel_logic_is_unchanged(tmp_path, monkeypatch):
root = _setup(
tmp_path, monkeypatch, pin={}, installed=["156.0.1-beta.33", "157.0-beta.34"],
config={"active_version": "browsers/official/157.0-beta.34"},
)
assert multiversion.get_active_path() == root / "browsers/official/157.0-beta.34"
@pytest.mark.parametrize("config,accepts_newer", [({}, False), ({"channel": "official/stable"}, True)])
def test_the_fetcher_accepts_only_the_paired_asset_by_default(tmp_path, monkeypatch, config, accepts_newer):
_setup(tmp_path, monkeypatch, pin=PIN, installed=[], config=config)
fetcher = pkgman.CamoufoxFetcher.__new__(pkgman.CamoufoxFetcher)
fetcher.repo_config = pkgman.RepoConfig.get_default()
fetcher.pattern = fetcher.repo_config.build_pattern(spoof_os="lin", spoof_arch="x86_64")
fetcher.installed_sha256 = None
fetcher.installed_created_at = None
def asset(version, build):
return {"name": f"camoufox-{version}-{build}-lin.x86_64.zip",
"browser_download_url": f"https://example.invalid/{version}-{build}.zip"}
assert fetcher.check_asset(asset("156.0.1", "beta.33"), {"prerelease": True}) is not None
newer = fetcher.check_asset(asset("157.0", "beta.34"), {"prerelease": False})
assert (newer is not None) is accepts_newer
@pytest.mark.parametrize("raw,expected", [
("0.5.8", (0, 5, 8)),
("0.5.8b1", (0, 5, 8)),
("0.5.8rc2", (0, 5, 8)),
("0.5.8.dev3", (0, 5, 8)),
("0.5.8-beta.1", (0, 5, 8)),
("^0.5.0", (0, 5, 0)),
("1", (1, 0, 0)),
])
def test_prerelease_library_versions_parse_as_their_release(raw, expected):
assert pkgman._parse_semver(raw) == expected
def test_a_missing_paired_build_is_reported_as_not_installed_not_outdated(tmp_path, monkeypatch):
_setup(tmp_path, monkeypatch, pin=PIN, installed=["157.0-beta.34"], config={})
with pytest.raises(CamoufoxNotInstalled, match="pairs with"):
pkgman.camoufox_path(download_if_missing=False)
# Where a build keeps its executable and application.ini on each OS.
BUILD_LAYOUTS = {
"lin": ("camoufox-bin", "application.ini"),
"mac": ("Camoufox.app/Contents/MacOS/camoufox", "Camoufox.app/Contents/Resources/application.ini"),
}
@pytest.fixture(params=sorted(BUILD_LAYOUTS))
def selected_build(request, tmp_path, monkeypatch):
"""The paired build is missing and another is installed; the launch's
identity steps are stubbed so only build resolution is exercised."""
root = _setup(tmp_path, monkeypatch, pin=PIN, installed=["152.0.4-beta.31"], config={})
build = root / "browsers" / "official" / "152.0.4-beta.31"
executable, ini = (build / part for part in BUILD_LAYOUTS[request.param])
for path in (executable, ini):
path.parent.mkdir(parents=True, exist_ok=True)
executable.write_text("")
ini.write_text("[App]\nVersion=152.0.4\n")
monkeypatch.setattr(pkgman, "OS_NAME", request.param)
monkeypatch.delenv("CAMOUFOX_EXECUTABLE_PATH", raising=False)
def download(*_args, **_kwargs):
raise AssertionError("resolved or downloaded the paired build despite `browser`")
# The one way to the paired build: everything else runs for real.
monkeypatch.setattr(pkgman, "camoufox_path", download)
seen = {}
def from_fpgen(_fingerprint, ff_version, *_args, **_kwargs):
seen["ff_version"] = ff_version
return {}
monkeypatch.setattr(utils, "generate_fingerprint", lambda *args, **kwargs: object())
monkeypatch.setattr(utils, "from_fpgen", from_fpgen)
for name in ("add_default_addons", "get_screen_cons", "fix_navigator_arch",
"follow_baseline_protection", "clamp_window_dimensions",
"set_media_devices_defaults"):
monkeypatch.setattr(utils, name, lambda *args, **kwargs: None)
monkeypatch.setattr(utils, "_generate_random_font_subset", lambda *args, **kwargs: [])
monkeypatch.setattr(utils, "_generate_random_voice_subset", lambda *args, **kwargs: [])
monkeypatch.setattr(utils, "validate_config", lambda _config, path: seen.setdefault("properties", path))
def get_env_vars(_config, _os, path):
seen["bundle"] = path
return {}
monkeypatch.setattr(utils, "get_env_vars", get_env_vars)
return executable, seen
@pytest.mark.parametrize("specifier", ["152.0.4-beta.31", "official/beta.31", "beta.31"])
def test_the_browser_option_launches_the_selected_build(selected_build, specifier):
"""#843: `browser=` named an installed build, yet the launch fetched the paired one."""
binary, seen = selected_build
with warnings.catch_warnings(record=True) as caught:
warnings.simplefilter("always")
options = utils.launch_options(
browser=specifier, os="linux", canvas_noise=False, block_webgl=True,
headless=True, i_know_what_im_doing=True,
)
assert options["executable_path"] == str(binary)
assert seen["properties"] == seen["bundle"] == binary
assert seen["ff_version"] == "152"
assert any("selected explicitly" in str(w.message) for w in caught)
def test_the_browser_option_refuses_a_build_it_cannot_drive(selected_build, tmp_path):
build = tmp_path / "cache" / "browsers" / "official" / "152.0.4-beta.31"
(build / "version.json").write_text(json.dumps(
{"version": "152.0.4", "build": "beta.31", "interface": pkgman.CONSTRAINTS.INTERFACE + 1}
))
with pytest.raises(UnsupportedVersion, match="pip install -U camoufox"):
utils.launch_options(browser="beta.31", os="linux", headless=True, i_know_what_im_doing=True)
def test_the_browser_option_refuses_an_executable_path_too(tmp_path, monkeypatch):
monkeypatch.delenv("CAMOUFOX_EXECUTABLE_PATH", raising=False)
with pytest.raises(ValueError, match="executable_path"):
utils.launch_options(
browser="beta.31", executable_path=str(tmp_path / "other"), os="linux", i_know_what_im_doing=True
)
def test_the_browser_option_refuses_camoufox_executable_path_too(tmp_path, monkeypatch):
monkeypatch.setenv("CAMOUFOX_EXECUTABLE_PATH", str(tmp_path / "other"))
with pytest.raises(ValueError, match="CAMOUFOX_EXECUTABLE_PATH"):
utils.launch_options(browser="beta.31", os="linux", i_know_what_im_doing=True)
def test_a_named_executable_without_application_ini_raises(tmp_path, monkeypatch):
"""Its version is never borrowed from the installed release (#843)."""
monkeypatch.setattr(utils, "installed_verstr", lambda: "156.0.1-beta.33")
with pytest.raises(FileNotFoundError, match="application.ini"):
utils.resolve_verstr(tmp_path / "camoufox-bin")