mirror of
https://github.com/headroomlabs-ai/headroom.git
synced 2026-11-22 15:10:00 +08:00
## Description Fixes #3976. On `uv tool` installs and other environments where certifi is not wired into the stdlib OpenSSL trust path, `headroom update` and bundled-binary downloads can fail behind corporate TLS inspection. These urllib calls now use the configured Headroom trust context, matching the proxy's TLS policy. The lazy helper import still falls back to urllib's default when the optional trust module cannot be imported. Errors while constructing an explicitly configured context now propagate instead of silently replacing the requested trust roots with stdlib defaults. The update checker retains its outer error-handling behavior and returns no update on failure. ## Type of Change - [x] Bug fix (non-breaking change that fixes an issue) - [ ] New feature - [ ] Breaking change - [ ] Documentation update - [ ] Performance improvement - [ ] Code refactoring ## Changes Made - Pass `build_urlopen_context()` to the PyPI version check and release-binary download paths. - Catch only `ImportError` around the lazy helper import; let trust-context construction errors reach the caller. - Add valid and invalid replacement-bundle tests for both helpers and verify the update check still handles the error through its existing outer handler. - Update mocked `urlopen` functions to accept the `context` keyword used by the production call path. ## Testing - [x] Targeted unit tests pass - [ ] Full test suite run - [x] Ruff lint and format checks pass for changed files - [x] New tests added for the requested behavior - [ ] Type checking run - [ ] Manual live-network testing performed ### Test Output ```text python -m pytest --disable-plugin-autoload -p pytest_asyncio.plugin tests/test_ssl_context.py tests/test_binaries.py tests/test_update_check.py 95 passed in 5.10s python -m ruff check headroom/binaries.py headroom/update_check.py tests/test_ssl_context.py tests/test_binaries.py All checks passed! python -m ruff format --check headroom/binaries.py headroom/update_check.py tests/test_ssl_context.py tests/test_binaries.py 4 files already formatted git diff --check passed ``` ## Real Behavior Proof **Original reproduction:** On macOS behind a corporate TLS-inspecting network, `headroom update` failed with `CERTIFICATE_VERIFY_FAILED` when the inspection root was present in the OS trust store but absent from Python's stdlib OpenSSL bundle. The same machine's proxy reached its upstream through the configured root. The original fix routed the direct urllib calls through `build_urlopen_context()`. **Review regression checks:** On Windows with Python 3.13.13, tests using a valid `REQUESTS_CA_BUNDLE` confirm both helpers return a verifying `SSLContext`. With an existing file containing invalid PEM, both helpers now raise `ssl.SSLError`; the update-check caller still returns `None` through its outer error handler. All 95 tests in the affected TLS, binary-download, and update-check suites pass. **Not tested:** A live corporate TLS-inspection connection, Windows `uv tool` end-to-end behavior behind such a network, the full repository test suite, and the separate eval dataset download path. ## Runtime Rollout Safety - Rollout-managed feature(s): None. - Minimum rollout channel: Not applicable. - Stable/default behavior changed: An invalid explicitly configured trust bundle now fails visibly rather than silently falling back to stdlib roots; unconfigured default behavior is unchanged. - Kill switch / disable path: No new switch; existing TLS environment settings remain available. - Unsafe override required: No. - Qualification impact: None. - Rollback path: Revert this PR's changes. ## Review Readiness - [x] I have performed a self-review. - [x] This PR is ready for human review. ## Checklist - [x] My code follows the project's style guidelines. - [x] I have performed a self-review of my code. - [ ] I have added comments where the code needs additional explanation. - [ ] I have made corresponding documentation changes (none needed for this internal error-handling change). - [x] The changed files pass Ruff checks and the focused tests add no warnings. - [x] I have added tests that prove the requested behavior. - [ ] The full repository unit-test suite was run. - [x] I did not edit `CHANGELOG.md`. --------- Co-authored-by: dajiaohuang <dajiaohuang@users.noreply.github.com> Co-authored-by: JD Davis <mxjerrett@gmail.com>
337 lines
11 KiB
Python
337 lines
11 KiB
Python
from __future__ import annotations
|
|
|
|
import sys
|
|
from pathlib import Path
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
from click.testing import CliRunner
|
|
|
|
from headroom import binaries
|
|
from headroom.cli import tools as cli_tools
|
|
from headroom.cli.main import main
|
|
|
|
|
|
@pytest.fixture
|
|
def runner() -> CliRunner:
|
|
return CliRunner()
|
|
|
|
|
|
class FakeTable:
|
|
def __init__(self, **kwargs) -> None: # noqa: ANN003
|
|
self.columns: list[str] = []
|
|
self.rows: list[tuple[object, ...]] = []
|
|
|
|
def add_column(self, name: str) -> None:
|
|
self.columns.append(name)
|
|
|
|
def add_row(self, *values: object) -> None:
|
|
self.rows.append(values)
|
|
|
|
|
|
class FakeConsole:
|
|
instances: list[FakeConsole] = []
|
|
|
|
def __init__(self) -> None:
|
|
self.printed: list[object] = []
|
|
FakeConsole.instances.append(self)
|
|
|
|
def print(self, value: object) -> None:
|
|
self.printed.append(value)
|
|
|
|
|
|
def install_fake_rich(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
FakeConsole.instances.clear()
|
|
monkeypatch.setitem(sys.modules, "rich.console", SimpleNamespace(Console=FakeConsole))
|
|
monkeypatch.setitem(sys.modules, "rich.table", SimpleNamespace(Table=FakeTable))
|
|
monkeypatch.setitem(
|
|
sys.modules, "rich.markup", SimpleNamespace(escape=lambda value: f"escaped:{value}")
|
|
)
|
|
|
|
|
|
def test_exec_tool_windows_and_posix_paths(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
monkeypatch.setattr(cli_tools.binaries, "resolve", lambda tool: Path("C:\\bin\\sg.exe"))
|
|
monkeypatch.setattr(cli_tools.sys, "platform", "win32")
|
|
captured: dict[str, object] = {}
|
|
|
|
def fake_run(cmd, check=False): # noqa: ANN001
|
|
captured["cmd"] = cmd
|
|
return SimpleNamespace(returncode=7)
|
|
|
|
monkeypatch.setattr(cli_tools.subprocess, "run", fake_run)
|
|
with pytest.raises(SystemExit) as excinfo:
|
|
cli_tools._exec_tool("ast-grep", ["--json"])
|
|
assert excinfo.value.code == 7
|
|
assert captured["cmd"] == ["C:\\bin\\sg.exe", "--json"]
|
|
|
|
monkeypatch.setattr(cli_tools.sys, "platform", "linux")
|
|
|
|
def fake_execv(path: str, cmd: list[str]) -> None:
|
|
raise SystemExit((path, cmd))
|
|
|
|
monkeypatch.setattr(cli_tools.os, "execv", fake_execv)
|
|
with pytest.raises(SystemExit) as posix_exit:
|
|
cli_tools._exec_tool("ast-grep", ["--help"])
|
|
assert posix_exit.value.code == (str(Path("C:\\bin\\sg.exe")), ["C:\\bin\\sg.exe", "--help"])
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("error", "expected"),
|
|
[
|
|
(binaries.PlatformNotSupported("unsupported"), "error: unsupported"),
|
|
(binaries.OfflineError("offline"), "Hint: run `headroom tools install`"),
|
|
(binaries.Sha256Mismatch("bad sha"), "error: bad sha"),
|
|
(binaries.BinaryFetchError("fetch failed"), "error: fetch failed"),
|
|
],
|
|
)
|
|
def test_sg_command_reports_resolution_errors(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
runner: CliRunner,
|
|
error: Exception,
|
|
expected: str,
|
|
) -> None:
|
|
monkeypatch.setattr(cli_tools.binaries, "resolve", lambda tool: (_ for _ in ()).throw(error))
|
|
result = runner.invoke(main, ["sg", "--version"])
|
|
assert result.exit_code == 2
|
|
assert expected in result.output
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("args", "expected", "exit_code"),
|
|
[
|
|
(("diff", "--version"), "error: failed to configure TLS trust", 2),
|
|
(("tools", "install", "--tool", "difft"), "difft: failed to configure TLS trust", 1),
|
|
],
|
|
)
|
|
def test_invalid_configured_ca_bundle_is_reported_without_fetching(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
runner: CliRunner,
|
|
tmp_path: Path,
|
|
args: tuple[str, ...],
|
|
expected: str,
|
|
exit_code: int,
|
|
) -> None:
|
|
invalid_bundle = tmp_path / "invalid.pem"
|
|
invalid_bundle.write_text("not a PEM certificate", encoding="ascii")
|
|
monkeypatch.setenv("REQUESTS_CA_BUNDLE", str(invalid_bundle))
|
|
for variable in (
|
|
"SSL_CERT_FILE",
|
|
"NODE_EXTRA_CA_CERTS",
|
|
"HEADROOM_CA_BUNDLE",
|
|
"HEADROOM_TLS_STRICT",
|
|
):
|
|
monkeypatch.delenv(variable, raising=False)
|
|
monkeypatch.setenv("HEADROOM_CERT_STORE", "bundled")
|
|
monkeypatch.setattr(cli_tools.binaries, "cache_dir", lambda: tmp_path / "cache")
|
|
monkeypatch.setattr(cli_tools.binaries, "_path_lookup", lambda _name: None)
|
|
monkeypatch.setattr(
|
|
cli_tools.binaries,
|
|
"detect_platform",
|
|
lambda: binaries.PlatformKey("linux", "x86_64", "gnu"),
|
|
)
|
|
monkeypatch.setattr(
|
|
cli_tools.binaries,
|
|
"_registry",
|
|
lambda: {
|
|
"tools": {
|
|
"difft": {
|
|
"version": "test",
|
|
"source": "github",
|
|
"assets": {
|
|
"linux-x86_64-gnu": {
|
|
"url": "https://example.invalid/difft.tar.gz",
|
|
"member": "difft",
|
|
"sha256": "0" * 64,
|
|
}
|
|
},
|
|
}
|
|
}
|
|
},
|
|
)
|
|
urlopen_calls: list[object] = []
|
|
|
|
def unexpected_urlopen(*call_args, **call_kwargs):
|
|
urlopen_calls.append((call_args, call_kwargs))
|
|
raise AssertionError("invalid configured trust must fail before urlopen")
|
|
|
|
monkeypatch.setattr(cli_tools.binaries.urllib.request, "urlopen", unexpected_urlopen)
|
|
|
|
result = runner.invoke(main, list(args))
|
|
|
|
assert result.exit_code == exit_code
|
|
assert expected in result.output
|
|
assert "NO_CERTIFICATE_OR_CRL_FOUND" in result.output
|
|
assert urlopen_calls == []
|
|
|
|
|
|
def test_tools_list_renders_registry(monkeypatch: pytest.MonkeyPatch, runner: CliRunner) -> None:
|
|
install_fake_rich(monkeypatch)
|
|
monkeypatch.setattr(
|
|
cli_tools.binaries,
|
|
"detect_platform",
|
|
lambda: SimpleNamespace(key=lambda: "windows-x86_64"),
|
|
)
|
|
monkeypatch.setattr(cli_tools.binaries, "cache_dir", lambda: Path("C:\\cache"))
|
|
monkeypatch.setattr(
|
|
cli_tools.binaries,
|
|
"_registry",
|
|
lambda: {
|
|
"tools": {
|
|
"ast-grep": {
|
|
"version": "1.2.3",
|
|
"source": "github",
|
|
"assets": {"windows-x86_64": {}, "linux-x86_64-gnu": {}},
|
|
},
|
|
"python-tool": {"version": "0.1.0", "source": "pypi", "assets": {}},
|
|
}
|
|
},
|
|
)
|
|
|
|
result = runner.invoke(main, ["tools", "list"])
|
|
assert result.exit_code == 0
|
|
console = FakeConsole.instances[-1]
|
|
assert console.printed[0] == "[dim]platform:[/dim] windows-x86_64"
|
|
assert console.printed[1] == "[dim]cache:[/dim] C:\\cache"
|
|
table = console.printed[2]
|
|
assert isinstance(table, FakeTable)
|
|
assert ("ast-grep", "1.2.3", "github", "linux-x86_64-gnu, windows-x86_64") in table.rows
|
|
assert ("python-tool", "0.1.0", "pypi", "(pypi)") in table.rows
|
|
|
|
|
|
def test_tools_doctor_json_and_table_modes(
|
|
monkeypatch: pytest.MonkeyPatch, runner: CliRunner
|
|
) -> None:
|
|
rows = [
|
|
{
|
|
"tool": "ast-grep",
|
|
"state": "cached",
|
|
"version": "1.0",
|
|
"platform": "win",
|
|
"path": "C:\\bin\\sg.exe",
|
|
},
|
|
{
|
|
"tool": "difft",
|
|
"state": "missing",
|
|
"version": "2.0",
|
|
"platform": "win",
|
|
"path": None,
|
|
"detail": "download needed <soon>",
|
|
},
|
|
]
|
|
monkeypatch.setattr(cli_tools.binaries, "status", lambda: rows)
|
|
|
|
json_result = runner.invoke(main, ["tools", "doctor", "--json"])
|
|
assert json_result.exit_code == 1
|
|
assert '"tool": "ast-grep"' in json_result.output
|
|
assert '"state": "missing"' in json_result.output
|
|
|
|
install_fake_rich(monkeypatch)
|
|
table_result = runner.invoke(main, ["tools", "doctor"])
|
|
assert table_result.exit_code == 1
|
|
console = FakeConsole.instances[-1]
|
|
table = console.printed[0]
|
|
assert isinstance(table, FakeTable)
|
|
assert ("ast-grep", "[green]cached[/green]", "1.0", "win", "C:\\bin\\sg.exe") in table.rows
|
|
assert ("difft", "[yellow]missing[/yellow]", "2.0", "win", "-") in table.rows
|
|
assert console.printed[1] == "[dim]difft:[/dim] escaped:download needed <soon>"
|
|
|
|
|
|
def test_tools_install_covers_unknown_pypi_force_and_failures(
|
|
monkeypatch: pytest.MonkeyPatch, runner: CliRunner, tmp_path: Path
|
|
) -> None:
|
|
cached_path = tmp_path / "cached-tool.exe"
|
|
cached_path.write_text("x", encoding="utf-8")
|
|
monkeypatch.setattr(
|
|
cli_tools.binaries,
|
|
"_registry",
|
|
lambda: {
|
|
"tools": {
|
|
"known": {"version": "1.0"},
|
|
"pypi_tool": {"version": "2.0"},
|
|
"broken": {"version": "3.0"},
|
|
}
|
|
},
|
|
)
|
|
monkeypatch.setattr(cli_tools.binaries, "_is_pypi_tool", lambda name: name == "pypi_tool")
|
|
monkeypatch.setattr(
|
|
cli_tools.binaries,
|
|
"_path_lookup",
|
|
lambda name: Path("C:\\Python\\Scripts\\pypi_tool.exe") if name == "pypi_tool" else None,
|
|
)
|
|
monkeypatch.setattr(
|
|
cli_tools.binaries,
|
|
"detect_platform",
|
|
lambda: SimpleNamespace(key=lambda: "windows-x86_64"),
|
|
)
|
|
monkeypatch.setattr(cli_tools.binaries, "_cached_path", lambda name, version, plat: cached_path)
|
|
monkeypatch.setattr(
|
|
cli_tools.binaries,
|
|
"resolve",
|
|
lambda name: (
|
|
(_ for _ in ()).throw(binaries.OfflineError("offline"))
|
|
if name == "broken"
|
|
else Path(f"C:\\cache\\{name}.exe")
|
|
),
|
|
)
|
|
|
|
result = runner.invoke(
|
|
main,
|
|
[
|
|
"tools",
|
|
"install",
|
|
"--tool",
|
|
"missing",
|
|
"--tool",
|
|
"pypi_tool",
|
|
"--tool",
|
|
"known",
|
|
"--tool",
|
|
"broken",
|
|
"--force",
|
|
],
|
|
)
|
|
|
|
assert result.exit_code == 1
|
|
assert "unknown tool 'missing'; skipping" in result.output
|
|
assert "pypi_tool: on PATH at C:\\Python\\Scripts\\pypi_tool.exe (pypi wheel)" in result.output
|
|
assert "known: installed" in result.output
|
|
assert "broken: offline" in result.output
|
|
assert not cached_path.exists()
|
|
|
|
|
|
def test_tools_install_reports_missing_pypi_and_cached_unlink_failure(
|
|
monkeypatch: pytest.MonkeyPatch, runner: CliRunner
|
|
) -> None:
|
|
problem_path = Path("C:\\cache\\locked.exe")
|
|
monkeypatch.setattr(
|
|
cli_tools.binaries,
|
|
"_registry",
|
|
lambda: {"tools": {"pypi_tool": {"version": "1.0"}, "known": {"version": "2.0"}}},
|
|
)
|
|
monkeypatch.setattr(cli_tools.binaries, "_is_pypi_tool", lambda name: name == "pypi_tool")
|
|
monkeypatch.setattr(cli_tools.binaries, "_path_lookup", lambda name: None)
|
|
monkeypatch.setattr(
|
|
cli_tools.binaries,
|
|
"detect_platform",
|
|
lambda: SimpleNamespace(key=lambda: "windows-x86_64"),
|
|
)
|
|
monkeypatch.setattr(
|
|
cli_tools.binaries, "_cached_path", lambda name, version, plat: problem_path
|
|
)
|
|
monkeypatch.setattr(Path, "exists", lambda self: self == problem_path)
|
|
|
|
def fake_unlink(self) -> None:
|
|
raise OSError("locked")
|
|
|
|
monkeypatch.setattr(Path, "unlink", fake_unlink)
|
|
monkeypatch.setattr(cli_tools.binaries, "resolve", lambda name: Path(f"C:\\cache\\{name}.exe"))
|
|
|
|
result = runner.invoke(
|
|
main,
|
|
["tools", "install", "--tool", "pypi_tool", "--tool", "known", "--force"],
|
|
)
|
|
|
|
assert result.exit_code == 1
|
|
assert "pypi_tool: not on PATH" in result.output
|
|
assert "known: failed to remove cached binary: locked" in result.output
|