mirror of
https://github.com/daijro/camoufox.git
synced 2026-11-19 00:07:28 +00:00
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>
244 lines
11 KiB
Python
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")
|