nesquena-hermesandrumotoshino
5ea8b09b83
Clean rebase of rumotoshino's #5458 (rebase-first). Co-authored-by: rumotoshino <rumotoshino@users.noreply.github.com>
617 lines
22 KiB
Python
617 lines
22 KiB
Python
"""Behavioral tests for the extension gallery install/uninstall/registry feature."""
|
|
|
|
import hashlib
|
|
import io
|
|
import json
|
|
import socket
|
|
import zipfile
|
|
from pathlib import Path
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import pytest
|
|
|
|
|
|
def _make_zip(files: dict) -> bytes:
|
|
"""Build an in-memory zip containing the given {name: content} mapping."""
|
|
buf = io.BytesIO()
|
|
with zipfile.ZipFile(buf, "w") as zf:
|
|
for name, content in files.items():
|
|
zf.writestr(name, content)
|
|
return buf.getvalue()
|
|
|
|
|
|
def _setup_ext_env(monkeypatch, tmp_path):
|
|
"""Point extension root and state dir at tmp_path subdirectories."""
|
|
ext_dir = tmp_path / "extensions"
|
|
ext_dir.mkdir()
|
|
state_dir = tmp_path / "state"
|
|
state_dir.mkdir()
|
|
monkeypatch.setenv("HERMES_WEBUI_EXTENSION_DIR", str(ext_dir))
|
|
monkeypatch.setenv("HERMES_WEBUI_STATE_DIR", str(state_dir))
|
|
import api.extensions as ext_mod
|
|
monkeypatch.setattr(ext_mod, "_extension_state_dir", lambda: state_dir)
|
|
return ext_dir, state_dir
|
|
|
|
|
|
def test_install_valid(monkeypatch, tmp_path):
|
|
ext_dir, state_dir = _setup_ext_env(monkeypatch, tmp_path)
|
|
import api.extensions as ext_mod
|
|
|
|
files = {
|
|
"manifest.json": json.dumps({"version": "1.2.3"}),
|
|
"index.js": "console.log('hello');",
|
|
}
|
|
zip_bytes = _make_zip(files)
|
|
sha = hashlib.sha256(zip_bytes).hexdigest()
|
|
|
|
mock_resp = MagicMock()
|
|
mock_resp.read.return_value = zip_bytes
|
|
mock_resp.close = MagicMock()
|
|
monkeypatch.setattr(ext_mod, "_safe_download", lambda *a, **kw: zip_bytes)
|
|
|
|
result = ext_mod.install_extension(
|
|
"my-ext",
|
|
"https://hermes-webui.github.io/exts/my-ext.zip",
|
|
sha,
|
|
)
|
|
assert result["installed"] is True
|
|
assert result["id"] == "my-ext"
|
|
assert result["version"] == "1.2.3"
|
|
assert (ext_dir / "my-ext" / "index.js").exists()
|
|
manifest = ext_mod._load_install_manifest()
|
|
assert "my-ext" in manifest["installed"]
|
|
assert "index.js" in manifest["installed"]["my-ext"]["files"]
|
|
|
|
|
|
def test_install_prefixed_zip(monkeypatch, tmp_path):
|
|
"""Zip members rooted under <id>/ are stripped so files land at ext_dir/<id>/."""
|
|
ext_dir, state_dir = _setup_ext_env(monkeypatch, tmp_path)
|
|
import api.extensions as ext_mod
|
|
|
|
files = {
|
|
"my-ext/manifest.json": json.dumps({"version": "2.0.0"}),
|
|
"my-ext/index.js": "console.log('prefixed');",
|
|
"my-ext/sub/style.css": "body{}",
|
|
}
|
|
zip_bytes = _make_zip(files)
|
|
sha = hashlib.sha256(zip_bytes).hexdigest()
|
|
|
|
monkeypatch.setattr(ext_mod, "_safe_download", lambda *a, **kw: zip_bytes)
|
|
|
|
result = ext_mod.install_extension(
|
|
"my-ext",
|
|
"https://hermes-webui.github.io/exts/my-ext.zip",
|
|
sha,
|
|
)
|
|
assert result["installed"] is True
|
|
assert result["version"] == "2.0.0"
|
|
assert (ext_dir / "my-ext" / "manifest.json").exists()
|
|
assert (ext_dir / "my-ext" / "index.js").exists()
|
|
assert (ext_dir / "my-ext" / "sub" / "style.css").exists()
|
|
# Verify NO double-nested directory
|
|
assert not (ext_dir / "my-ext" / "my-ext").exists()
|
|
manifest = ext_mod._load_install_manifest()
|
|
assert "manifest.json" in manifest["installed"]["my-ext"]["files"]
|
|
|
|
|
|
def test_gallery_installed_extension_becomes_runtime_manifest(monkeypatch, tmp_path):
|
|
"""Installed gallery extensions are injected without a separate manifest env var."""
|
|
ext_dir, state_dir = _setup_ext_env(monkeypatch, tmp_path)
|
|
monkeypatch.delenv("HERMES_WEBUI_EXTENSION_MANIFEST", raising=False)
|
|
monkeypatch.delenv("HERMES_WEBUI_EXTENSION_SCRIPT_URLS", raising=False)
|
|
monkeypatch.delenv("HERMES_WEBUI_EXTENSION_STYLESHEET_URLS", raising=False)
|
|
import api.extensions as ext_mod
|
|
|
|
files = {
|
|
"my-ext/manifest.json": json.dumps(
|
|
{
|
|
"version": "1.0.0",
|
|
"extensions": [
|
|
{
|
|
"id": "my-ext",
|
|
"name": "My Extension",
|
|
"scripts": ["assets/app.js"],
|
|
"stylesheets": ["assets/app.css"],
|
|
}
|
|
],
|
|
}
|
|
),
|
|
"my-ext/assets/app.js": "console.log('gallery runtime');",
|
|
"my-ext/assets/app.css": "body{}",
|
|
}
|
|
zip_bytes = _make_zip(files)
|
|
sha = hashlib.sha256(zip_bytes).hexdigest()
|
|
|
|
monkeypatch.setattr(ext_mod, "_safe_download", lambda *a, **kw: zip_bytes)
|
|
|
|
ext_mod.install_extension(
|
|
"my-ext",
|
|
"https://hermes-webui.github.io/exts/my-ext.zip",
|
|
sha,
|
|
)
|
|
|
|
assert ext_mod.get_extension_config() == {
|
|
"enabled": True,
|
|
"script_urls": ["/extensions/my-ext/assets/app.js"],
|
|
"stylesheet_urls": ["/extensions/my-ext/assets/app.css"],
|
|
"extensions": [
|
|
{
|
|
"id": "my-ext",
|
|
"name": "My Extension",
|
|
"storage_owned": False,
|
|
"settings_schema": [],
|
|
}
|
|
],
|
|
}
|
|
status = ext_mod.get_extension_status()
|
|
assert status["manifest"]["status"] == "gallery_installed"
|
|
assert status["counts"]["manifest_extensions"] == 1
|
|
assert status["extensions"][0]["id"] == "my-ext"
|
|
|
|
|
|
def test_gallery_installed_settings_only_manifest_becomes_runtime_entry(monkeypatch, tmp_path):
|
|
"""Settings-only gallery installs still surface in status and runtime config."""
|
|
ext_dir, state_dir = _setup_ext_env(monkeypatch, tmp_path)
|
|
monkeypatch.delenv("HERMES_WEBUI_EXTENSION_MANIFEST", raising=False)
|
|
monkeypatch.delenv("HERMES_WEBUI_EXTENSION_SCRIPT_URLS", raising=False)
|
|
monkeypatch.delenv("HERMES_WEBUI_EXTENSION_STYLESHEET_URLS", raising=False)
|
|
import api.extensions as ext_mod
|
|
|
|
files = {
|
|
"my-ext/manifest.json": json.dumps(
|
|
{
|
|
"name": "Settings Only",
|
|
"version": "1.0.0",
|
|
"permissions": {"storage": {"owned": True}},
|
|
"settings_schema": [
|
|
{"key": "flag", "type": "boolean", "default": True},
|
|
],
|
|
}
|
|
),
|
|
}
|
|
zip_bytes = _make_zip(files)
|
|
sha = hashlib.sha256(zip_bytes).hexdigest()
|
|
|
|
monkeypatch.setattr(ext_mod, "_safe_download", lambda *a, **kw: zip_bytes)
|
|
|
|
ext_mod.install_extension(
|
|
"my-ext",
|
|
"https://hermes-webui.github.io/exts/my-ext.zip",
|
|
sha,
|
|
)
|
|
|
|
assert ext_mod.get_extension_config() == {
|
|
"enabled": True,
|
|
"script_urls": [],
|
|
"stylesheet_urls": [],
|
|
"extensions": [
|
|
{
|
|
"id": "my-ext",
|
|
"name": "Settings Only",
|
|
"storage_owned": True,
|
|
"settings_schema": [
|
|
{"key": "flag", "type": "boolean", "label": "flag", "description": "", "default": True},
|
|
],
|
|
}
|
|
],
|
|
}
|
|
status = ext_mod.get_extension_status()
|
|
assert status["manifest"]["status"] == "gallery_installed"
|
|
assert status["counts"]["manifest_extensions"] == 1
|
|
assert status["extensions"][0]["id"] == "my-ext"
|
|
assert status["extensions"][0]["storage_owned"] is True
|
|
assert status["extensions"][0]["settings_schema"] == [
|
|
{"key": "flag", "type": "boolean", "label": "flag", "description": "", "default": True},
|
|
]
|
|
|
|
|
|
def test_install_bootstraps_managed_default_root_without_env(monkeypatch, tmp_path):
|
|
"""Plug-and-play (#4933): one-click install works with NO env configured.
|
|
|
|
With HERMES_WEBUI_EXTENSION_DIR unset and no extension dir on disk, the
|
|
first install must bootstrap the WebUI-managed default
|
|
(STATE_DIR/extensions), land the files there, and make the extension load
|
|
via get_extension_config() — all without any environment setup.
|
|
"""
|
|
state_dir = tmp_path / "state"
|
|
state_dir.mkdir()
|
|
monkeypatch.delenv("HERMES_WEBUI_EXTENSION_DIR", raising=False)
|
|
monkeypatch.delenv("HERMES_WEBUI_EXTENSION_MANIFEST", raising=False)
|
|
monkeypatch.delenv("HERMES_WEBUI_EXTENSION_SCRIPT_URLS", raising=False)
|
|
monkeypatch.delenv("HERMES_WEBUI_EXTENSION_STYLESHEET_URLS", raising=False)
|
|
monkeypatch.setenv("HERMES_WEBUI_STATE_DIR", str(state_dir))
|
|
import api.extensions as ext_mod
|
|
|
|
monkeypatch.setattr(ext_mod, "_extension_state_dir", lambda: state_dir)
|
|
|
|
default_root = state_dir / "extensions"
|
|
# Pre-install: nothing exists yet, gallery is "configured" but not valid.
|
|
assert not default_root.exists()
|
|
pre = ext_mod.get_extension_status()
|
|
assert pre["enabled"] is False
|
|
assert pre["extension_dir_configured"] is True
|
|
assert pre["extension_dir_valid"] is False
|
|
assert pre["warnings"] == []
|
|
|
|
files = {
|
|
"plug-ext/manifest.json": json.dumps(
|
|
{
|
|
"version": "1.0.0",
|
|
"extensions": [
|
|
{
|
|
"id": "plug-ext",
|
|
"name": "Plug And Play",
|
|
"scripts": ["app.js"],
|
|
}
|
|
],
|
|
}
|
|
),
|
|
"plug-ext/app.js": "console.log('plug and play');",
|
|
}
|
|
zip_bytes = _make_zip(files)
|
|
sha = hashlib.sha256(zip_bytes).hexdigest()
|
|
monkeypatch.setattr(ext_mod, "_safe_download", lambda *a, **kw: zip_bytes)
|
|
|
|
result = ext_mod.install_extension(
|
|
"plug-ext",
|
|
"https://hermes-webui.github.io/exts/plug-ext.zip",
|
|
sha,
|
|
)
|
|
assert result["installed"] is True
|
|
|
|
# The managed default root was created on demand and holds the files.
|
|
assert default_root.is_dir()
|
|
assert (default_root / "plug-ext" / "app.js").exists()
|
|
|
|
# And the extension now loads with zero env configuration.
|
|
assert ext_mod.get_extension_config() == {
|
|
"enabled": True,
|
|
"script_urls": ["/extensions/plug-ext/app.js"],
|
|
"stylesheet_urls": [],
|
|
"extensions": [
|
|
{
|
|
"id": "plug-ext",
|
|
"name": "Plug And Play",
|
|
"storage_owned": False,
|
|
"settings_schema": [],
|
|
}
|
|
],
|
|
}
|
|
status = ext_mod.get_extension_status()
|
|
assert status["enabled"] is True
|
|
assert status["extension_dir_configured"] is True
|
|
assert status["extension_dir_valid"] is True
|
|
assert status["manifest"]["status"] == "gallery_installed"
|
|
assert status["extensions"][0]["id"] == "plug-ext"
|
|
|
|
|
|
def test_install_bad_hash(monkeypatch, tmp_path):
|
|
ext_dir, state_dir = _setup_ext_env(monkeypatch, tmp_path)
|
|
import api.extensions as ext_mod
|
|
|
|
zip_bytes = _make_zip({"index.js": "code"})
|
|
wrong_sha = "a" * 64
|
|
|
|
monkeypatch.setattr(ext_mod, "_safe_download", lambda *a, **kw: zip_bytes)
|
|
|
|
with pytest.raises(ext_mod.ExtensionInstallError, match="SHA-256"):
|
|
ext_mod.install_extension(
|
|
"bad-ext",
|
|
"https://hermes-webui.github.io/exts/bad-ext.zip",
|
|
wrong_sha,
|
|
)
|
|
assert not (ext_dir / "bad-ext").exists()
|
|
|
|
|
|
def test_install_zipslip(monkeypatch, tmp_path):
|
|
ext_dir, state_dir = _setup_ext_env(monkeypatch, tmp_path)
|
|
import api.extensions as ext_mod
|
|
|
|
buf = io.BytesIO()
|
|
with zipfile.ZipFile(buf, "w") as zf:
|
|
zf.writestr("../../evil.txt", "pwned")
|
|
zip_bytes = buf.getvalue()
|
|
sha = hashlib.sha256(zip_bytes).hexdigest()
|
|
|
|
monkeypatch.setattr(ext_mod, "_safe_download", lambda *a, **kw: zip_bytes)
|
|
|
|
with pytest.raises(ext_mod.ExtensionInstallError):
|
|
ext_mod.install_extension(
|
|
"slip-ext",
|
|
"https://hermes-webui.github.io/exts/slip-ext.zip",
|
|
sha,
|
|
)
|
|
assert not (tmp_path / "evil.txt").exists()
|
|
|
|
|
|
def test_uninstall(monkeypatch, tmp_path):
|
|
ext_dir, state_dir = _setup_ext_env(monkeypatch, tmp_path)
|
|
import api.extensions as ext_mod
|
|
|
|
files = {"index.js": "code", "style.css": "body{}"}
|
|
zip_bytes = _make_zip(files)
|
|
sha = hashlib.sha256(zip_bytes).hexdigest()
|
|
|
|
monkeypatch.setattr(ext_mod, "_safe_download", lambda *a, **kw: zip_bytes)
|
|
|
|
ext_mod.install_extension(
|
|
"rm-ext",
|
|
"https://hermes-webui.github.io/exts/rm-ext.zip",
|
|
sha,
|
|
)
|
|
assert (ext_dir / "rm-ext" / "index.js").exists()
|
|
|
|
result = ext_mod.uninstall_extension("rm-ext")
|
|
assert result["uninstalled"] is True
|
|
assert not (ext_dir / "rm-ext" / "index.js").exists()
|
|
assert not (ext_dir / "rm-ext" / "style.css").exists()
|
|
assert not (ext_dir / "rm-ext").exists()
|
|
manifest = ext_mod._load_install_manifest()
|
|
assert "rm-ext" not in manifest["installed"]
|
|
|
|
|
|
def test_uninstall_cleans_nested_dirs(monkeypatch, tmp_path):
|
|
"""Uninstall removes empty subdirectories left by nested files."""
|
|
ext_dir, state_dir = _setup_ext_env(monkeypatch, tmp_path)
|
|
import api.extensions as ext_mod
|
|
|
|
files = {
|
|
"deep-ext/manifest.json": "{}",
|
|
"deep-ext/sub/a/b.js": "code",
|
|
"deep-ext/sub/c.css": "body{}",
|
|
}
|
|
zip_bytes = _make_zip(files)
|
|
sha = hashlib.sha256(zip_bytes).hexdigest()
|
|
|
|
monkeypatch.setattr(ext_mod, "_safe_download", lambda *a, **kw: zip_bytes)
|
|
|
|
ext_mod.install_extension(
|
|
"deep-ext",
|
|
"https://hermes-webui.github.io/exts/deep-ext.zip",
|
|
sha,
|
|
)
|
|
assert (ext_dir / "deep-ext" / "sub" / "a" / "b.js").exists()
|
|
|
|
ext_mod.uninstall_extension("deep-ext")
|
|
assert not (ext_dir / "deep-ext").exists()
|
|
|
|
|
|
def test_install_rollback(monkeypatch, tmp_path):
|
|
ext_dir, state_dir = _setup_ext_env(monkeypatch, tmp_path)
|
|
import api.extensions as ext_mod
|
|
|
|
files = {"first.js": "a", "second.js": "b"}
|
|
zip_bytes = _make_zip(files)
|
|
sha = hashlib.sha256(zip_bytes).hexdigest()
|
|
|
|
monkeypatch.setattr(ext_mod, "_safe_download", lambda *a, **kw: zip_bytes)
|
|
|
|
write_count = [0]
|
|
original_write_bytes = Path.write_bytes
|
|
|
|
def patched_write_bytes(self, data):
|
|
write_count[0] += 1
|
|
if write_count[0] >= 2:
|
|
raise OSError("simulated write failure")
|
|
return original_write_bytes(self, data)
|
|
|
|
monkeypatch.setattr(Path, "write_bytes", patched_write_bytes)
|
|
|
|
with pytest.raises(ext_mod.ExtensionInstallError, match="Extraction failed"):
|
|
ext_mod.install_extension(
|
|
"roll-ext",
|
|
"https://hermes-webui.github.io/exts/roll-ext.zip",
|
|
sha,
|
|
)
|
|
remaining = list((ext_dir / "roll-ext").glob("**/*")) if (ext_dir / "roll-ext").exists() else []
|
|
assert remaining == []
|
|
|
|
|
|
def test_gallery_registry_list_format(monkeypatch, tmp_path):
|
|
"""Registry response as a top-level list (original format)."""
|
|
import api.extensions as ext_mod
|
|
|
|
registry_data = [
|
|
{"id": "ext-one", "name": "Extension One", "version": "0.1.0", "description": "First"},
|
|
{"id": "ext-two", "name": "Extension Two", "version": "0.2.0", "description": "Second"},
|
|
]
|
|
|
|
mock_resp = MagicMock()
|
|
mock_resp.read.return_value = json.dumps(registry_data).encode("utf-8")
|
|
|
|
ext_mod._REGISTRY_CACHE.clear()
|
|
monkeypatch.setattr(ext_mod, "_build_gallery_opener", lambda: MagicMock(open=lambda *a, **kw: mock_resp))
|
|
|
|
result = ext_mod.get_extension_registry()
|
|
assert "entries" in result
|
|
assert len(result["entries"]) == 2
|
|
assert result["entries"][0]["id"] == "ext-one"
|
|
assert result["entries"][1]["id"] == "ext-two"
|
|
|
|
|
|
def test_gallery_registry_extensions_format(monkeypatch, tmp_path):
|
|
"""Registry response wrapping extensions under {"extensions": [...]} (live format)."""
|
|
import api.extensions as ext_mod
|
|
|
|
registry_data = {
|
|
"version": 1,
|
|
"generated_at": "2026-06-24T18:30:40.265Z",
|
|
"extensions": [
|
|
{"id": "desktop-companion", "name": "Desktop Companion", "version": "0.1.0"},
|
|
],
|
|
}
|
|
|
|
mock_resp = MagicMock()
|
|
mock_resp.read.return_value = json.dumps(registry_data).encode("utf-8")
|
|
|
|
ext_mod._REGISTRY_CACHE.clear()
|
|
monkeypatch.setattr(ext_mod, "_build_gallery_opener", lambda: MagicMock(open=lambda *a, **kw: mock_resp))
|
|
|
|
result = ext_mod.get_extension_registry()
|
|
assert len(result["entries"]) == 1
|
|
assert result["entries"][0]["id"] == "desktop-companion"
|
|
|
|
|
|
def test_install_rejects_symlinked_ext_dir_outside_root(monkeypatch, tmp_path):
|
|
"""Installation rejects a symlinked extension directory pointing outside root."""
|
|
ext_dir, state_dir = _setup_ext_env(monkeypatch, tmp_path)
|
|
import api.extensions as ext_mod
|
|
|
|
target_dir = tmp_path / "symlink_target"
|
|
target_dir.mkdir()
|
|
link = ext_dir / "linked-ext"
|
|
try:
|
|
link.symlink_to(target_dir)
|
|
except (OSError, NotImplementedError):
|
|
pytest.skip("symlinks not supported")
|
|
|
|
files = {"index.js": "code"}
|
|
zip_bytes = _make_zip(files)
|
|
sha = hashlib.sha256(zip_bytes).hexdigest()
|
|
|
|
monkeypatch.setattr(ext_mod, "_safe_download", lambda *a, **kw: zip_bytes)
|
|
|
|
with pytest.raises(ext_mod.ExtensionInstallError):
|
|
ext_mod.install_extension(
|
|
"linked-ext",
|
|
"https://hermes-webui.github.io/exts/linked-ext.zip",
|
|
sha,
|
|
)
|
|
assert not (target_dir / "index.js").exists()
|
|
|
|
|
|
def test_install_rejects_symlinked_ext_dir_inside_root(monkeypatch, tmp_path):
|
|
"""Installation rejects a pre-existing symlink even when target is within root."""
|
|
ext_dir, state_dir = _setup_ext_env(monkeypatch, tmp_path)
|
|
import api.extensions as ext_mod
|
|
|
|
target_dir = ext_dir / "real-target"
|
|
target_dir.mkdir()
|
|
link = ext_dir / "linked-ext"
|
|
try:
|
|
link.symlink_to(target_dir)
|
|
except (OSError, NotImplementedError):
|
|
pytest.skip("symlinks not supported")
|
|
|
|
files = {"index.js": "code"}
|
|
zip_bytes = _make_zip(files)
|
|
sha = hashlib.sha256(zip_bytes).hexdigest()
|
|
|
|
monkeypatch.setattr(ext_mod, "_safe_download", lambda *a, **kw: zip_bytes)
|
|
|
|
with pytest.raises(ext_mod.ExtensionInstallError, match="symlink"):
|
|
ext_mod.install_extension(
|
|
"linked-ext",
|
|
"https://hermes-webui.github.io/exts/linked-ext.zip",
|
|
sha,
|
|
)
|
|
|
|
|
|
def test_install_rejects_redirect_to_disallowed_host(monkeypatch, tmp_path):
|
|
"""Download rejects redirects to disallowed hosts."""
|
|
import api.extensions as ext_mod
|
|
|
|
def fake_download(url, max_bytes, timeout=30):
|
|
raise ext_mod.ExtensionInstallError("Download redirected to disallowed host")
|
|
|
|
ext_dir, state_dir = _setup_ext_env(monkeypatch, tmp_path)
|
|
monkeypatch.setattr(ext_mod, "_safe_download", fake_download)
|
|
|
|
with pytest.raises(ext_mod.ExtensionInstallError, match="disallowed host"):
|
|
ext_mod.install_extension(
|
|
"redir-ext",
|
|
"https://hermes-webui.github.io/exts/redir-ext.zip",
|
|
"a" * 64,
|
|
)
|
|
|
|
|
|
def test_connect_ipv4_first_tries_inet_before_inet6(monkeypatch):
|
|
"""_connect_ipv4_first calls getaddrinfo with AF_INET before AF_INET6."""
|
|
import api.extensions as ext_mod
|
|
|
|
call_order = []
|
|
|
|
real_getaddrinfo = socket.getaddrinfo
|
|
|
|
def tracking_getaddrinfo(host, port, family, *args, **kwargs):
|
|
call_order.append(family)
|
|
return real_getaddrinfo(host, port, family, *args, **kwargs)
|
|
|
|
monkeypatch.setattr(socket, "getaddrinfo", tracking_getaddrinfo)
|
|
monkeypatch.setattr(socket, "getdefaulttimeout", lambda: None)
|
|
|
|
# We don't actually need to connect; just verify family ordering.
|
|
try:
|
|
ext_mod._connect_ipv4_first(("localhost", 80), timeout=None)
|
|
except OSError:
|
|
pass # connection failure is fine — we only care about call order
|
|
|
|
assert socket.AF_INET in call_order
|
|
if socket.AF_INET6 in call_order:
|
|
assert call_order.index(socket.AF_INET) < call_order.index(socket.AF_INET6)
|
|
|
|
|
|
def test_connect_ipv4_first_handles_global_default_timeout():
|
|
"""The _GLOBAL_DEFAULT_TIMEOUT sentinel is resolved correctly."""
|
|
import api.extensions as ext_mod
|
|
|
|
# Should not raise TypeError when passed the stdlib sentinel.
|
|
sentinel = socket._GLOBAL_DEFAULT_TIMEOUT
|
|
# Force default timeout to None so no actual timeout is set on the socket.
|
|
with patch.object(socket, "getdefaulttimeout", return_value=None):
|
|
try:
|
|
ext_mod._connect_ipv4_first(("127.0.0.1", 1), timeout=sentinel)
|
|
except OSError:
|
|
pass # connection refused is fine
|
|
except TypeError:
|
|
pytest.fail("TypeError — sentinel not resolved")
|
|
|
|
|
|
def test_gallery_opener_includes_ipv4_first_handler():
|
|
"""_build_gallery_opener produces an opener wired to the IPv4-first HTTPS handler."""
|
|
import api.extensions as ext_mod
|
|
|
|
opener = ext_mod._build_gallery_opener()
|
|
# build_opener instantiates handler classes internally; find the one whose
|
|
# https_open uses our IPv4-first connection class.
|
|
handler_classes = [type(h) for h in opener.handlers]
|
|
assert ext_mod._IPv4FirstHTTPSHandler in handler_classes
|
|
|
|
|
|
def test_safe_download_uses_gallery_opener(monkeypatch):
|
|
"""_safe_download routes through _build_gallery_opener (which is IPv4-first)."""
|
|
import api.extensions as ext_mod
|
|
|
|
fake_response = MagicMock()
|
|
fake_response.read.return_value = b"file-content"
|
|
fake_response.close = MagicMock()
|
|
fake_opener = MagicMock(open=lambda url, timeout=None: fake_response)
|
|
|
|
called = []
|
|
monkeypatch.setattr(ext_mod, "_build_gallery_opener", lambda: (called.append(True), fake_opener)[1])
|
|
|
|
result = ext_mod._safe_download("https://example.com/x.zip", 1024)
|
|
assert result == b"file-content"
|
|
assert called == [True]
|
|
|
|
|
|
def test_registry_fetch_uses_gallery_opener(monkeypatch):
|
|
"""get_extension_registry routes through _build_gallery_opener (IPv4-first)."""
|
|
import api.extensions as ext_mod
|
|
|
|
mock_resp = MagicMock()
|
|
mock_resp.read.return_value = json.dumps(
|
|
{"extensions": [{"id": "test-ext", "name": "Test"}]}
|
|
).encode("utf-8")
|
|
|
|
ext_mod._REGISTRY_CACHE.clear()
|
|
|
|
called = []
|
|
fake_opener = MagicMock(open=lambda *a, **kw: mock_resp)
|
|
monkeypatch.setattr(ext_mod, "_build_gallery_opener", lambda: (called.append(True), fake_opener)[1])
|
|
|
|
result = ext_mod.get_extension_registry()
|
|
assert len(result["entries"]) == 1
|
|
assert result["entries"][0]["id"] == "test-ext"
|
|
assert called == [True]
|