Files
archived-camoufox/python/tests/test_addons.py
T
Jake WriterandClaude Opus 5.5 8f06d85bf5 Keep a complete addon another process installed first
The atomic extraction removed the target before renaming into it. With two
processes downloading at once, the second could delete the first's finished
addon while its browser was loading it. If the first renamed in between, the
second's rename failed on the non-empty directory, and its error handler then
deleted the good copy, so it launched without uBlock Origin.

Rename first. If the target is not empty and already holds a manifest.json,
keep it and drop the temp dir; only an incomplete target is replaced. The
TypeScript port mirrors this and gains the atomic-extraction test, and both
gain a regression test for an addon installed during extraction.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 12:34:58 -06:00

162 lines
5.2 KiB
Python

"""
Tests for camoufox.addons default-addon download/caching.
Regression guard for #308: a partial/failed first download leaves an empty
addon directory behind. The old "already downloaded" check was a bare
os.path.exists(dir), so that empty dir was trusted forever and every later
launch raised InvalidAddonPath ("manifest.json is missing"), unrecoverable
short of manually deleting the cache.
Run with:
cd python && python -m pytest tests/test_addons.py -v
"""
import os
import threading
import time
import pytest
from camoufox import addons as addons_mod
from camoufox.addons import DefaultAddons, add_default_addons, maybe_download_addons
UBO = DefaultAddons.UBO.name
@pytest.fixture
def addons_dir(tmp_path, monkeypatch):
# Point the addon store at a throwaway dir so no real cache is touched.
root = tmp_path / "addons"
monkeypatch.setattr(addons_mod, "get_addon_path", lambda name: str(root / name))
return root
def _write_manifest(url, extract_path, name):
os.makedirs(extract_path, exist_ok=True)
with open(os.path.join(extract_path, "manifest.json"), "w") as f:
f.write("{}")
def test_partial_dir_is_redownloaded(addons_dir, monkeypatch):
# Leftover empty dir from a failed first download.
partial = addons_dir / UBO
partial.mkdir(parents=True)
assert not (partial / "manifest.json").exists()
calls = []
def fake(url, extract_path, name):
calls.append(name)
_write_manifest(url, extract_path, name)
monkeypatch.setattr(addons_mod, "download_and_extract", fake)
out = []
maybe_download_addons([DefaultAddons.UBO], out)
# An empty dir must trigger a re-download, not be trusted.
assert calls == [UBO]
assert (partial / "manifest.json").exists()
assert out == [str(partial)]
def test_extracted_addon_is_not_redownloaded(addons_dir, monkeypatch):
path = addons_dir / UBO
path.mkdir(parents=True)
(path / "manifest.json").write_text("{}")
def boom(*a, **k):
raise AssertionError("must not re-download an already-extracted addon")
monkeypatch.setattr(addons_mod, "download_and_extract", boom)
out = []
maybe_download_addons([DefaultAddons.UBO], out)
assert out == [str(path)]
def test_failed_download_removes_partial_dir(addons_dir, monkeypatch):
path = addons_dir / UBO
def fail(url, extract_path, name):
os.makedirs(extract_path, exist_ok=True) # partial write, then die
raise RuntimeError("network died mid-download")
monkeypatch.setattr(addons_mod, "download_and_extract", fail)
out = []
maybe_download_addons([DefaultAddons.UBO], out)
# The partial dir must be gone so the next run re-downloads instead of
# trusting an addon that has no manifest.json.
assert not path.exists()
assert out == []
def test_concurrent_launches_download_once(addons_dir, monkeypatch):
# Two launches in one process share the check-then-extract. A lock created
# per call guarded nothing, so both saw no manifest and both downloaded.
calls = []
def slow(url, extract_path, name):
calls.append(name)
time.sleep(0.2)
_write_manifest(url, extract_path, name)
monkeypatch.setattr(addons_mod, "download_and_extract", slow)
outs = [[], []]
threads = [threading.Thread(target=add_default_addons, args=(out,)) for out in outs]
for t in threads:
t.start()
for t in threads:
t.join()
assert calls == [UBO]
assert outs == [[str(addons_dir / UBO)]] * 2
def test_extraction_appears_complete_or_not_at_all(tmp_path, monkeypatch):
# Another process checks for manifest.json without the lock, so the addon
# directory must never hold a manifest while its other files are missing.
target = tmp_path / UBO
target.mkdir()
seen = []
def fake_unzip(buffer, extract_path, desc=None, bar=True):
seen.append((target / "manifest.json").exists())
_write_manifest(None, extract_path, UBO)
with open(os.path.join(extract_path, "background.js"), "w") as f:
f.write("")
seen.append((target / "manifest.json").exists())
monkeypatch.setattr(addons_mod, "webdl", lambda *a, **k: b"")
monkeypatch.setattr(addons_mod, "unzip", fake_unzip)
addons_mod.download_and_extract("url", str(target), UBO)
assert seen == [False, False]
assert sorted(os.listdir(target)) == ["background.js", "manifest.json"]
assert os.listdir(tmp_path) == [UBO]
def test_complete_addon_installed_meanwhile_is_kept(tmp_path, monkeypatch):
# Another process can finish installing the addon while this one extracts.
# Its copy may already be loading in a browser, so it must not be deleted.
target = tmp_path / UBO
target.mkdir()
def fake_unzip(buffer, extract_path, desc=None, bar=True):
_write_manifest(None, extract_path, UBO)
_write_manifest(None, str(target), UBO)
with open(target / "theirs.js", "w") as f:
f.write("")
monkeypatch.setattr(addons_mod, "webdl", lambda *a, **k: b"")
monkeypatch.setattr(addons_mod, "unzip", fake_unzip)
addons_mod.download_and_extract("url", str(target), UBO)
assert sorted(os.listdir(target)) == ["manifest.json", "theirs.js"]
assert os.listdir(tmp_path) == [UBO]