akadmin/headroom
1
0
Fork 0
mirror of https://github.com/headroomlabs-ai/headroom.git synced 2026-08-27 14:17:10 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions
headroom/tests/test_providers_opencode_config.py
Parideboy 487aa71a3c
ci: restore green lint (reformat for ruff 0.15.17, fix mypy no-any-return, pin linters) (#1295) 
## Description

The CI lint job (`ruff check .` → `ruff format --check .` → `mypy
headroom`) was red on `main`
and therefore on every open PR, for two unrelated reasons that the early
ruff failure was masking:

1. **ruff**: the lint job installs `ruff` unpinned, and ruff 0.15.17
began enforcing import-block
sorting (`I001`) and formatting that older ruff accepted → `ruff check
.` / `ruff format --check .`
   fail on files nobody touched.
2. **mypy**: `headroom/providers/opencode/config.py` had two `return
json.loads(...)` statements in
a function declared `-> dict[str, Any]`; `json.loads` is typed `Any`, so
`mypy headroom` fails
with `no-any-return` (reproduced on mypy 1.20.2 — not a version-specific
quirk).

This restores a green lint baseline and pins both linters so a future
release can't silently break
CI again.

## Type of Change

- [x] Bug fix (non-breaking change that fixes an issue)

## Changes Made

- `.github/workflows/ci.yml`: pin `ruff==0.15.17` and `mypy==1.20.2` in
the lint job.
- Applied `ruff check --fix .` (6 `I001` import-sort fixes) and `ruff
format .` (10 files) across
  the repo — import ordering and whitespace only, no behavior change.
- `headroom/providers/opencode/config.py`: narrow both
`_parse_json_loose` return sites with an
`isinstance(parsed, dict)` guard, so the `dict[str, Any]` annotation is
true at runtime
(non-dict JSON falls back to `{}`) and mypy's `no-any-return` is
resolved.

## Testing

- [x] Unit tests pass (`pytest`)
- [x] Linting passes (`ruff check .`, `ruff format --check .`, `mypy
headroom --ignore-missing-imports`)

### Test Output

```text
$ python -m ruff check .
All checks passed!

$ python -m ruff format --check .
913 files already formatted

$ python -m mypy headroom/providers/opencode/config.py --ignore-missing-imports
Success: no issues found in 1 source file

$ python -m pytest tests/test_providers_opencode_config.py -q
37 passed
```

## Real Behavior Proof

- Environment: Windows 11, Python 3.13, ruff 0.15.17, mypy 1.20.2,
branch ci/fix-ruff-lint off
  headroomlabs-ai/main
- Exact command / steps: reproduced the red lint (latest ruff: 6 `I001`
+ 10 unformatted files;
the mypy failure was read from the #1295 CI lint log —
`config.py:125,133 no-any-return`, and
re-confirmed locally on mypy 1.20.2). Applied the ruff auto-fix/format,
added the dict guard,
  pinned both linters, and re-ran each lint step.
- Observed result: `ruff check .` → "All checks passed!"; `ruff format
--check .` → "913 files
already formatted"; `mypy` on the fixed file → "Success: no issues
found"; full `mypy headroom`
reports only Unix `fcntl` attributes that don't exist on this Windows
box (present on the Linux
CI runner, where the prior run showed exactly the two now-fixed errors).
37 opencode-config
  tests pass.
- Not tested: did not run the full OS/Python test matrix — the change is
formatting + two CI
dependency pins + a two-line type-narrowing guard, with no runtime
behavior change for dict JSON.

## Review Readiness

- [x] I have performed a self-review
- [x] This PR is ready for human review

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
2026-06-22 15:14:40 -05:00

471 lines
17 KiB
Python
Raw Blame History

"""Tests for OpenCode config file helpers."""
from __future__ import annotations
import json
from pathlib import Path
import pytest
from headroom.providers.opencode.config import (
HEADROOM_OPENCODE_PLUGIN,
_inject_key_into_json,
_parse_json_loose,
append_headroom_plugin,
inject_opencode_provider_config,
opencode_config_paths,
snapshot_opencode_config_if_unwrapped,
strip_opencode_headroom_blocks,
)
def _set_test_home(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
home = str(tmp_path)
monkeypatch.setenv("HOME", home)
monkeypatch.setenv("USERPROFILE", home)
monkeypatch.delenv("OPENCODE_HOME", raising=False)
monkeypatch.delenv("OPENCODE_CONFIG", raising=False)
# ---------------------------------------------------------------------------
# Config paths
# ---------------------------------------------------------------------------
def test_opencode_config_paths_default(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
"""Default config path resolves to ~/.config/opencode/opencode.json."""
_set_test_home(monkeypatch, tmp_path)
config_file, backup_file = opencode_config_paths()
assert config_file == tmp_path / ".config" / "opencode" / "opencode.json"
assert backup_file == tmp_path / ".config" / "opencode" / "opencode.json.headroom-backup"
def test_opencode_config_paths_from_env(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
"""OPENCODE_CONFIG env var overrides the default path."""
custom_path = tmp_path / "custom" / "opencode.json"
monkeypatch.setenv("OPENCODE_CONFIG", str(custom_path))
config_file, backup_file = opencode_config_paths()
assert config_file == custom_path
assert backup_file == tmp_path / "custom" / "opencode.json.headroom-backup"
# ---------------------------------------------------------------------------
# Snapshot
# ---------------------------------------------------------------------------
def test_snapshot_creates_backup(tmp_path: Path) -> None:
"""snapshot creates a backup copy of the config file."""
config_file = tmp_path / "opencode.json"
backup_file = tmp_path / "opencode.json.headroom-backup"
config_file.write_text('{"model": "openai/gpt-4o"}')
snapshot_opencode_config_if_unwrapped(config_file, backup_file)
assert backup_file.exists()
assert backup_file.read_text() == config_file.read_text()
def test_snapshot_skips_if_backup_exists(tmp_path: Path) -> None:
"""snapshot is a no-op when the backup already exists."""
config_file = tmp_path / "opencode.json"
backup_file = tmp_path / "opencode.json.headroom-backup"
config_file.write_text('{"model": "a"}')
backup_file.write_text('{"model": "b"}')
snapshot_opencode_config_if_unwrapped(config_file, backup_file)
assert backup_file.read_text() == '{"model": "b"}'
def test_snapshot_skips_if_markers_present(tmp_path: Path) -> None:
"""snapshot skips if the config already contains Headroom markers."""
config_file = tmp_path / "opencode.json"
backup_file = tmp_path / "opencode.json.headroom-backup"
config_file.write_text("// --- Headroom proxy provider ---\n{}")
snapshot_opencode_config_if_unwrapped(config_file, backup_file)
assert not backup_file.exists()
# ---------------------------------------------------------------------------
# Strip blocks
# ---------------------------------------------------------------------------
def test_strip_blocks_removes_provider_and_mcp() -> None:
"""strip removes both provider and MCP blocks."""
content = (
"// --- Headroom proxy provider ---\n"
'{"provider": {}}\n'
"// --- end Headroom proxy provider ---\n"
"// --- Headroom MCP server ---\n"
'{"mcp": {}}\n'
"// --- end Headroom MCP server ---\n"
'{"model": "openai/gpt-4o"}'
)
cleaned = strip_opencode_headroom_blocks(content)
assert "Headroom" not in cleaned
assert '{"model": "openai/gpt-4o"}' in cleaned
def test_strip_blocks_preserves_user_content() -> None:
"""strip leaves user content untouched when no blocks are present."""
content = '{"model": "openai/gpt-4o", "provider": {"openai": {}}}'
cleaned = strip_opencode_headroom_blocks(content)
assert cleaned == content
# ---------------------------------------------------------------------------
# Parse JSON loose
# ---------------------------------------------------------------------------
def test_parse_json_loose_strips_comments() -> None:
"""_parse_json_loose ignores // comments."""
text = '{\n "model": "gpt-4o", // default model\n "provider": {}\n}'
data = _parse_json_loose(text)
assert data["model"] == "gpt-4o"
assert "provider" in data
def test_parse_json_loose_returns_empty_on_invalid() -> None:
"""_parse_json_loose returns empty dict for invalid JSON."""
assert _parse_json_loose("not json") == {}
# ---------------------------------------------------------------------------
# Inject key
# ---------------------------------------------------------------------------
def test_inject_key_merges_dicts() -> None:
"""_inject_key_into_json merges nested dicts."""
data = {"provider": {"openai": {}}}
data = _inject_key_into_json(data, "provider", {"headroom": {}})
assert "openai" in data["provider"]
assert "headroom" in data["provider"]
def test_inject_key_overwrites_non_dict() -> None:
"""_inject_key_into_json overwrites when existing value is not a dict."""
data = {"model": "gpt-4o"}
data = _inject_key_into_json(data, "model", "headroom/claude-sonnet-4-6")
assert data["model"] == "headroom/claude-sonnet-4-6"
# ---------------------------------------------------------------------------
# Inject provider config
# ---------------------------------------------------------------------------
def test_inject_provider_config_creates_file(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
"""inject_opencode_provider_config creates the config file when missing."""
_set_test_home(monkeypatch, tmp_path)
inject_opencode_provider_config(port=8787)
config_file = tmp_path / ".config" / "opencode" / "opencode.json"
assert config_file.exists()
config = _parse_json_loose(config_file.read_text())
assert config["provider"]["headroom"]["npm"] == "@ai-sdk/openai-compatible"
assert "model" not in config # headroom provider is a transparent pass-through
def test_inject_provider_config_idempotent(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
"""inject_opencode_provider_config is safe to call multiple times."""
_set_test_home(monkeypatch, tmp_path)
inject_opencode_provider_config(port=8787)
inject_opencode_provider_config(port=9999)
config_file = tmp_path / ".config" / "opencode" / "opencode.json"
config = _parse_json_loose(config_file.read_text())
assert config["provider"]["headroom"]["options"]["baseURL"] == "http://127.0.0.1:9999/v1"
# ---------------------------------------------------------------------------
# Edge cases — JSON parsing
# ---------------------------------------------------------------------------
def test_parse_json_loose_handles_valid_json() -> None:
"""_parse_json_loose returns correct dict for valid JSON without comments."""
data = _parse_json_loose('{"model": "gpt-4o", "key": "value"}')
assert data == {"model": "gpt-4o", "key": "value"}
def test_parse_json_loose_handles_jsonc_with_comments() -> None:
"""_parse_json_loose strips comments and returns valid data."""
text = '{\n "model": "gpt-4o",\n // this is a comment\n "provider": {}\n}'
data = _parse_json_loose(text)
assert data["model"] == "gpt-4o"
assert data["provider"] == {}
def test_parse_json_loose_handles_urls_in_json() -> None:
"""_parse_json_loose does NOT corrupt URLs containing //."""
text = '{"baseURL": "http://127.0.0.1:8787/v1"}'
data = _parse_json_loose(text)
assert data["baseURL"] == "http://127.0.0.1:8787/v1"
def test_parse_json_loose_handles_comments_and_urls() -> None:
"""_parse_json_loose handles both comments and URLs in the same file."""
text = (
"{\n"
" // proxy configuration\n"
' "baseURL": "http://127.0.0.1:8787/v1",\n'
' "name": "Headroom // Proxy"\n'
"}"
)
data = _parse_json_loose(text)
assert data["baseURL"] == "http://127.0.0.1:8787/v1"
assert data["name"] == "Headroom // Proxy"
def test_parse_json_loose_returns_empty_on_empty_string() -> None:
"""_parse_json_loose returns {} for empty input."""
assert _parse_json_loose("") == {}
def test_parse_json_loose_returns_empty_on_whitespace() -> None:
"""_parse_json_loose returns {} for whitespace-only input."""
assert _parse_json_loose(" \n \t ") == {}
def test_parse_json_loose_returns_empty_on_trailing_comma() -> None:
"""_parse_json_loose returns {} for malformed JSON (trailing comma)."""
assert _parse_json_loose('{"model": "gpt-4o",}') == {}
def test_parse_json_loose_returns_empty_on_unclosed_brace() -> None:
"""_parse_json_loose returns {} for malformed JSON (unclosed brace)."""
assert _parse_json_loose('{"model": "gpt-4o"') == {}
# ---------------------------------------------------------------------------
# Edge cases — strip blocks
# ---------------------------------------------------------------------------
def test_strip_blocks_handles_empty_string() -> None:
"""strip_opencode_headroom_blocks returns empty string for empty input."""
assert strip_opencode_headroom_blocks("") == ""
def test_strip_blocks_handles_whitespace_only() -> None:
"""strip_opencode_headroom_blocks returns empty string for whitespace input."""
assert strip_opencode_headroom_blocks(" \n ") == ""
def test_strip_blocks_preserves_non_headroom_jsonc() -> None:
"""strip_opencode_headroom_blocks preserves JSONC comments not from Headroom."""
content = '// user comment\n{"model": "gpt-4o"}\n// another user comment\n'
cleaned = strip_opencode_headroom_blocks(content)
assert "// user comment" in cleaned
assert '{"model": "gpt-4o"}' in cleaned
def test_strip_blocks_removes_only_one_of_two_identical_blocks() -> None:
"""strip_opencode_headroom_blocks removes all provider blocks, not just the first."""
from headroom.providers.opencode.config import _PROVIDER_MARKER_END, _PROVIDER_MARKER_START
content = (
_PROVIDER_MARKER_START
+ "\nblock1\n"
+ _PROVIDER_MARKER_END
+ "\n"
+ _PROVIDER_MARKER_START
+ "\nblock2\n"
+ _PROVIDER_MARKER_END
)
cleaned = strip_opencode_headroom_blocks(content)
assert _PROVIDER_MARKER_START not in cleaned
assert "block1" not in cleaned
assert "block2" not in cleaned
def test_strip_blocks_handles_only_mcp_markers() -> None:
"""strip_opencode_headroom_blocks also strips MCP markers."""
from headroom.providers.opencode.config import _MCP_MARKER_END, _MCP_MARKER_START
content = _MCP_MARKER_START + "\nmcp data\n" + _MCP_MARKER_END
cleaned = strip_opencode_headroom_blocks(content)
assert _MCP_MARKER_START not in cleaned
# ---------------------------------------------------------------------------
# Edge cases — inject config
# ---------------------------------------------------------------------------
def test_inject_provider_config_merges_with_existing_mcp(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
"""inject_opencode_provider_config merges headroom MCP with existing MCP servers."""
_set_test_home(monkeypatch, tmp_path)
config_file = tmp_path / ".config" / "opencode" / "opencode.json"
config_file.parent.mkdir(parents=True, exist_ok=True)
config_file.write_text(
'{"mcp": {"existing-server": {"type": "remote", "url": "https://example.com"}}}'
)
inject_opencode_provider_config(port=8787)
config = json.loads(config_file.read_text())
assert "existing-server" in config["mcp"]
assert "headroom" in config["mcp"]
def test_inject_provider_config_idempotent_with_complex_config(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
"""inject_opencode_provider_config is idempotent on complex configs."""
_set_test_home(monkeypatch, tmp_path)
config_file = tmp_path / ".config" / "opencode" / "opencode.json"
config_file.parent.mkdir(parents=True, exist_ok=True)
config_file.write_text(
json.dumps(
{
"model": "openai/gpt-4o",
"provider": {"openai": {"models": {"gpt-4o": {}}}},
"mcp": {"myserver": {"type": "local", "command": ["echo"]}},
}
)
)
inject_opencode_provider_config(port=8787)
inject_opencode_provider_config(port=8787)
config = json.loads(config_file.read_text())
assert "openai" in config["provider"]
assert "headroom" in config["provider"]
assert "myserver" in config["mcp"]
assert "headroom" in config["mcp"]
def test_inject_provider_config_preserves_unrelated_top_level_keys(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
"""inject_opencode_provider_config preserves top-level keys like plugin, permission, etc."""
_set_test_home(monkeypatch, tmp_path)
config_file = tmp_path / ".config" / "opencode" / "opencode.json"
config_file.parent.mkdir(parents=True, exist_ok=True)
config_file.write_text(
json.dumps(
{
"plugin": ["some-plugin"],
"permission": {"bash": {"*": "ask"}},
"model": "openai/gpt-4o",
}
)
)
inject_opencode_provider_config(port=8787)
config = json.loads(config_file.read_text())
assert config["plugin"] == ["some-plugin"]
assert config["permission"] == {"bash": {"*": "ask"}}
assert "headroom" in config.get("provider", {})
def test_append_headroom_plugin_adds_plugin_once() -> None:
config: dict[str, object] = {"plugin": ["some-plugin"]}
assert append_headroom_plugin(config) is True
assert append_headroom_plugin(config) is False
assert config["plugin"] == ["some-plugin", HEADROOM_OPENCODE_PLUGIN]
def test_append_headroom_plugin_preserves_configured_tuple_entry() -> None:
config: dict[str, object] = {
"plugin": [[HEADROOM_OPENCODE_PLUGIN, {"proxyUrl": "http://127.0.0.1:8787"}]]
}
assert append_headroom_plugin(config) is False
assert config["plugin"] == [[HEADROOM_OPENCODE_PLUGIN, {"proxyUrl": "http://127.0.0.1:8787"}]]
def test_inject_provider_config_no_crash_on_unwriteable_dir(
monkeypatch: pytest.MonkeyPatch,
) -> None:
"""inject_opencode_provider_config raises click.ClickException on OSError."""
import click as click_mod
monkeypatch.setenv("HOME", "/nonexistent/path/that/cannot/be/created")
try:
inject_opencode_provider_config(port=8787)
except click_mod.ClickException:
pass
except OSError:
pass
# ---------------------------------------------------------------------------
# Runtime module coverage: build_opencode_config_content, build_launch_env
# ---------------------------------------------------------------------------
def test_build_opencode_config_content_without_mcp() -> None:
from headroom.providers.opencode.runtime import build_opencode_config_content
config = build_opencode_config_content(port=8787, include_mcp=False)
assert "provider" in config
assert "mcp" not in config
assert "model" not in config
assert config["plugin"] == [["headroom-opencode", {"proxyUrl": "http://127.0.0.1:8787/v1"}]]
def test_build_launch_env_with_project(monkeypatch: pytest.MonkeyPatch) -> None:
from headroom.providers.opencode.runtime import build_launch_env
monkeypatch.delenv("HEADROOM_PROJECT", raising=False)
monkeypatch.delenv("OPENAI_BASE_URL", raising=False)
monkeypatch.delenv("ANTHROPIC_BASE_URL", raising=False)
env, display = build_launch_env(
port=8787,
project="test-proj",
include_mcp=False,
)
assert env["HEADROOM_PROJECT"] == "test-proj"
assert "headroom-opencode" in env["OPENCODE_CONFIG_CONTENT"]
assert "OPENAI_BASE_URL" not in env
assert "ANTHROPIC_BASE_URL" not in env
def test_build_launch_env_with_custom_environ() -> None:
from headroom.providers.opencode.runtime import build_launch_env
custom = {
"EXISTING_VAR": "keep-me",
"OPENAI_BASE_URL": "https://deepseek.example/v1",
"ANTHROPIC_BASE_URL": "https://anthropic.example",
}
env, display = build_launch_env(
port=8787,
environ=custom,
include_mcp=False,
)
assert env["EXISTING_VAR"] == "keep-me"
assert env["OPENAI_BASE_URL"] == "https://deepseek.example/v1"
assert env["ANTHROPIC_BASE_URL"] == "https://anthropic.example"
def test_proxy_base_url() -> None:
from headroom.providers.opencode.runtime import proxy_base_url
assert proxy_base_url(9000) == "http://127.0.0.1:9000/v1"
def test_inject_provider_config_strips_existing_markers(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
_set_test_home(monkeypatch, tmp_path)
config_file = tmp_path / ".config" / "opencode" / "opencode.json"
config_file.parent.mkdir(parents=True, exist_ok=True)
inject_opencode_provider_config(port=9000)
first = config_file.read_text()
assert "headroom" in first
inject_opencode_provider_config(port=9001)
second = config_file.read_text()
assert "headroom" in second
assert second.count("headroom") == first.count("headroom")
Reference in a new issue View git blame Copy permalink