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