refactor(cli): remove test-only and dead helpers from wrap, proxy and mcp

Remove private CLI helpers whose live callers were rewritten away, so only their own unit tests still called them:

- wrap.py: _wrap_marker_proxy_is_dead (the self-heal now probes _wrap_proxy_alive inline), _agent_savings_config_mismatches and _AGENT_SAVINGS_TARGET_AGENTS (the live restart check compares savings_profile only), the _normalize_openclaw_gateway_provider_ids forwarder (the provider function is tested directly), a dead copy of _opencode_home_dir, and the unused _CONTEXT_1M_SUFFIX / _OPENCLAUDE_INSTRUCTIONS_FILE constants.
- proxy.py: _get_env_float_optional, which nothing calls.
- mcp.py: get_headroom_command, load_mcp_config, save_mcp_config, find_headroom_registration and their path constants. mcp install/status/uninstall all go through headroom.mcp_registry now.

Evidence: rg over headroom, tests, crates, plugins, sdk, examples, scripts, e2e, docs, wiki, .github and the consumer repos finds only the definitions and the deleted tests.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Tejas Chopra
2026-10-09 16:48:32 -07:00
co-authored by Claude Opus 5.5
parent a9815bbb5f
commit 5f450556d1
8 changed files with 5 additions and 467 deletions
-62
View File
@@ -5,78 +5,16 @@ Claude Code subscription users to use CCR (Compress-Cache-Retrieve) without
needing API key access.
"""
import json
from pathlib import Path
from typing import Any
import click
from .main import main
# Default paths
CLAUDE_CONFIG_DIR = Path.home() / ".claude"
MCP_CONFIG_PATH = CLAUDE_CONFIG_DIR / "mcp.json"
# Servers registered via `claude mcp add` (user scope) live in ~/.claude.json,
# NOT in ~/.claude/mcp.json. Status must check both to avoid a false negative.
CLAUDE_JSON_PATH = Path.home() / ".claude.json"
DEFAULT_PROXY_URL = "http://127.0.0.1:8787"
DEFAULT_HTTP_HOST = "127.0.0.1"
DEFAULT_HTTP_PORT = 8788
DEFAULT_HTTP_PATH = "/mcp"
def get_headroom_command() -> list[str]:
"""Get the command to run headroom MCP server.
Returns the CLI invocation used by Claude Code config.
"""
return ["headroom", "mcp", "serve"]
def load_mcp_config() -> dict[str, Any]:
"""Load existing MCP config or return empty structure."""
if MCP_CONFIG_PATH.exists():
try:
with open(MCP_CONFIG_PATH, encoding="utf-8") as f:
result: dict[str, Any] = json.load(f)
return result
except (json.JSONDecodeError, OSError):
return {"mcpServers": {}}
return {"mcpServers": {}}
def save_mcp_config(config: dict) -> None:
"""Save MCP config, creating directory if needed."""
CLAUDE_CONFIG_DIR.mkdir(parents=True, exist_ok=True)
with open(MCP_CONFIG_PATH, "w", encoding="utf-8") as f:
json.dump(config, f, indent=2)
f.write("\n") # Trailing newline
def find_headroom_registration() -> tuple[Path, dict[str, Any]] | None:
"""Locate an existing 'headroom' MCP server registration.
Claude Code stores servers registered with `claude mcp add` (user scope) in
~/.claude.json under "mcpServers". Headroom's own `mcp install` fallback
writes ~/.claude/mcp.json, and a project may define ./.mcp.json. Check all of
them so `status` reflects reality instead of only looking at mcp.json.
Returns (config_path, server_config) for the first match, else None.
"""
for path in (CLAUDE_JSON_PATH, MCP_CONFIG_PATH, Path.cwd() / ".mcp.json"):
if not path.exists():
continue
try:
with open(path) as f:
data = json.load(f)
except (json.JSONDecodeError, OSError):
continue
servers = data.get("mcpServers", {})
if isinstance(servers, dict) and "headroom" in servers:
return path, servers["headroom"]
return None
@main.group()
def mcp() -> None:
"""MCP server for Claude Code integration.
-10
View File
@@ -195,16 +195,6 @@ def _get_env_int(name: str, default: int) -> int:
return default if value is None else value
def _get_env_float_optional(name: str) -> float | None:
val = os.environ.get(name)
if val is None or val == "":
return None
try:
return float(val)
except ValueError:
raise click.ClickException(f"{name} must be a number, got {val!r}") from None
@main.command()
@click.option(
"--port",
-117
View File
@@ -87,7 +87,6 @@ from headroom.providers.antigravity import (
render_setup_lines as _render_antigravity_setup_lines,
)
from headroom.providers.claude import (
CONTEXT_1M_SUFFIX,
DEFAULT_1M_MODEL,
HEADROOM_1M_MODEL_ENV,
REMOTE_CONTROL_BASE_URL_ENV,
@@ -193,9 +192,6 @@ from headroom.providers.openclaw import (
from headroom.providers.openclaw import (
decode_entry_json as _decode_openclaw_entry_json_impl,
)
from headroom.providers.openclaw import (
normalize_gateway_provider_ids as _normalize_openclaw_gateway_provider_ids_impl,
)
from headroom.providers.opencode import build_launch_env as _build_opencode_launch_env
from headroom.providers.opencode.config import (
_MCP_MARKER_END, # noqa: F401
@@ -331,15 +327,6 @@ def _append_text(path: Path, content: str) -> None:
fsutil.append_text(path, content)
_AGENT_SAVINGS_TARGET_AGENTS = {
"antigravity",
"claude",
"codex",
"cursor",
"grok",
"grok_build",
"opencode",
}
_WRAP_PROXY_TIMEOUT_ENV = "HEADROOM_WRAP_PROXY_TIMEOUT"
_WRAP_PROXY_TIMEOUT_DEFAULT_SECONDS = 45
_WRAP_PROXY_TIMEOUT_ML_DEFAULT_SECONDS = 90
@@ -373,10 +360,8 @@ _CLAUDE_PROJECT_SETTINGS_ENV = "HEADROOM_CLAUDE_PROJECT_SETTINGS"
_ANTHROPIC_MODEL_ENV = "ANTHROPIC_MODEL"
# Private aliases preserve the standalone wrapper's existing test and import
# surface while the provider runtime owns the 1M selection contract.
_CONTEXT_1M_SUFFIX = CONTEXT_1M_SUFFIX
_1M_MODEL_ENV = HEADROOM_1M_MODEL_ENV
_DEFAULT_1M_MODEL = DEFAULT_1M_MODEL
_OPENCLAUDE_INSTRUCTIONS_FILE = "CONVENTIONS.md"
_resolve_1m_model = resolve_1m_model
@@ -1703,25 +1688,6 @@ def _wrap_proxy_alive(port: int, *, attempts: int = 3, delay: float = 0.25) -> b
return False
def _wrap_marker_proxy_is_dead(marker: dict[str, Any]) -> bool:
"""True if ``marker`` records a proxy ``port`` that no longer accepts
connections.
Port liveness is the authoritative signal for a wrap session that vanished
without running its cleanup (hard reboot / SIGKILL, issue #2221): the
recorded PID is unreliable because a reboot can recycle it onto an
unrelated live process, so a PID that still looks alive does not prove the
proxy is up. A marker with no recorded port returns False here (fall back
to PID-based staleness); a marker whose port IS responding is a live
session and must never be treated as dead. Uses the retry-hardened
``_wrap_proxy_alive`` so a momentary blip never reads as dead.
"""
port = marker.get("port")
if not isinstance(port, int):
return False
return not _wrap_proxy_alive(port)
def _clear_wrap_marker(settings_path: Path, *, key: str) -> None:
marker = _read_wrap_marker(settings_path)
if marker is not None and marker.get("key") == key:
@@ -4069,76 +4035,6 @@ def _env_bool_value(value: str) -> bool:
return value.strip().lower() in {"1", "true", "yes", "on"}
def _agent_savings_config_mismatches(
running_config: dict[str, Any],
agent_type: str,
) -> list[str]:
"""Return restart reasons when a running proxy lacks target agent savings."""
if agent_type not in _AGENT_SAVINGS_TARGET_AGENTS:
return []
if _wrap_agent_savings_profile(agent_type) is None:
return []
desired_env = os.environ.copy()
apply_agent_savings_env_defaults(desired_env)
checks: tuple[tuple[str, str, str, str], ...] = (
("HEADROOM_SAVINGS_PROFILE", "savings_profile", "savings-profile", "str"),
("HEADROOM_TARGET_RATIO", "target_ratio", "target-ratio", "float"),
(
"HEADROOM_COMPRESS_USER_MESSAGES",
"compress_user_messages",
"compress-user-messages",
"bool",
),
(
"HEADROOM_COMPRESS_SYSTEM_MESSAGES",
"compress_system_messages",
"compress-system-messages",
"bool",
),
("HEADROOM_PROTECT_RECENT", "protect_recent", "protect-recent", "int"),
(
"HEADROOM_PROTECT_ANALYSIS_CONTEXT",
"protect_analysis_context",
"protect-analysis-context",
"bool",
),
("HEADROOM_MIN_TOKENS", "min_tokens_to_crush", "min-tokens", "int"),
("HEADROOM_MAX_ITEMS", "max_items_after_crush", "max-items", "int"),
(
"HEADROOM_SMART_CRUSHER_COMPACTION",
"smart_crusher_with_compaction",
"smart-crusher-compaction",
"bool",
),
("HEADROOM_ACCURACY_GUARD", "accuracy_guard", "accuracy-guard", "str"),
)
mismatches: list[str] = []
for env_key, config_key, label, value_type in checks:
expected = desired_env.get(env_key)
if expected is None:
continue
actual = running_config.get(config_key)
try:
if value_type == "float":
matches = actual is not None and abs(float(actual) - float(expected)) < 1e-9
elif value_type == "int":
matches = actual is not None and int(actual) == int(expected)
elif value_type == "bool":
matches = actual is not None and bool(actual) is _env_bool_value(expected)
else:
matches = str(actual or "").strip().lower() == expected.strip().lower()
except (TypeError, ValueError):
matches = False
if not matches:
mismatches.append(label)
return mismatches
def _proxy_active_session_count(payload: dict[str, Any] | None) -> int:
"""Return active session count from /health runtime metadata."""
if payload is None:
@@ -5642,11 +5538,6 @@ def _resolve_openclaw_extensions_dir(openclaw_bin: str) -> Path:
return config_path.parent / "extensions"
def _normalize_openclaw_gateway_provider_ids(provider_ids: tuple[str, ...] | None) -> list[str]:
"""Normalize configured OpenClaw provider ids, defaulting to openai-codex."""
return _normalize_openclaw_gateway_provider_ids_impl(provider_ids)
def _read_openclaw_config_value(openclaw_bin: str, path: str) -> Any | None:
"""Read an OpenClaw config value when present, returning None on missing paths."""
result = run(
@@ -8738,14 +8629,6 @@ def opencode(
_opencode_proxy.kill()
def _opencode_home_dir() -> Path:
"""Return the OpenCode home/config directory."""
env_path = os.environ.get("OPENCODE_HOME", "").strip()
if env_path:
return Path(env_path).expanduser()
return Path.home() / ".config" / "opencode"
# =============================================================================
# OpenCode (unwrap)
# =============================================================================
-77
View File
@@ -341,12 +341,6 @@ def test_wrap_agent_savings_profile_is_opt_in(monkeypatch) -> None:
assert wrap_module._wrap_agent_savings_profile("codex") == AGENT_90_PROFILE
def test_agent_savings_config_mismatches_requires_explicit_profile(monkeypatch) -> None:
monkeypatch.delenv("HEADROOM_SAVINGS_PROFILE", raising=False)
assert wrap_module._agent_savings_config_mismatches({}, "claude") == []
def test_start_proxy_does_not_inject_agent_savings_by_default(monkeypatch, tmp_path) -> None:
captured_env: dict[str, str] = {}
@@ -397,77 +391,6 @@ def test_start_proxy_injects_explicit_agent_savings_profile(monkeypatch, tmp_pat
assert captured_env["HEADROOM_TARGET_RATIO"] == "0.10"
def test_agent_savings_config_mismatches_returns_specific_labels(monkeypatch) -> None:
monkeypatch.setenv("HEADROOM_SAVINGS_PROFILE", AGENT_90_PROFILE)
profile = get_agent_savings_profile(AGENT_90_PROFILE)
running_config = {
"savings_profile": profile.name,
"target_ratio": 0.20,
"compress_user_messages": profile.compress_user_messages,
"compress_system_messages": profile.compress_system_messages,
"protect_recent": profile.protect_recent,
"protect_analysis_context": profile.protect_analysis_context,
"min_tokens_to_crush": profile.min_tokens_to_compress,
"max_items_after_crush": profile.max_items_after_crush,
"smart_crusher_with_compaction": profile.smart_crusher_with_compaction,
"accuracy_guard": profile.accuracy_guard,
}
assert wrap_module._agent_savings_config_mismatches(running_config, "codex") == ["target-ratio"]
def test_agent_savings_config_mismatches_ignores_non_target_agents() -> None:
assert wrap_module._agent_savings_config_mismatches({}, "openhands") == []
def test_agent_savings_config_mismatches_accepts_matching_runtime_config(monkeypatch) -> None:
monkeypatch.setenv("HEADROOM_SAVINGS_PROFILE", AGENT_90_PROFILE)
profile = get_agent_savings_profile(AGENT_90_PROFILE)
running_config = {
"savings_profile": profile.name,
"target_ratio": "0.10",
"compress_user_messages": True,
"compress_system_messages": True,
"protect_recent": "2",
"protect_analysis_context": True,
"min_tokens_to_crush": "120",
"max_items_after_crush": "8",
"smart_crusher_with_compaction": False,
"accuracy_guard": "strict",
}
assert wrap_module._agent_savings_config_mismatches(running_config, "cursor") == []
def test_agent_savings_config_mismatches_reports_unparseable_values(monkeypatch) -> None:
monkeypatch.setenv("HEADROOM_SAVINGS_PROFILE", AGENT_90_PROFILE)
running_config = {
"savings_profile": None,
"target_ratio": "not-a-float",
"compress_user_messages": None,
"compress_system_messages": None,
"protect_recent": "not-an-int",
"protect_analysis_context": None,
"min_tokens_to_crush": object(),
"max_items_after_crush": object(),
"smart_crusher_with_compaction": None,
"accuracy_guard": None,
}
assert wrap_module._agent_savings_config_mismatches(running_config, "claude") == [
"savings-profile",
"target-ratio",
"compress-user-messages",
"compress-system-messages",
"protect-recent",
"protect-analysis-context",
"min-tokens",
"max-items",
"smart-crusher-compaction",
"accuracy-guard",
]
def test_agent_90_profile_applies_to_proxy_config_runtime_kwargs() -> None:
config = ProxyConfig(savings_profile="agent-90")
+5 -88
View File
@@ -6,7 +6,6 @@ These are real tests that:
- Test MCP server initialization (when MCP SDK is available)
"""
import json
import sys
from unittest.mock import AsyncMock, MagicMock, patch
@@ -14,11 +13,6 @@ import pytest
from click.testing import CliRunner
from headroom.cli.main import main
from headroom.cli.mcp import (
get_headroom_command,
load_mcp_config,
save_mcp_config,
)
from headroom.mcp_registry.base import ServerSpec
# Check if MCP SDK is available
@@ -30,23 +24,6 @@ except ImportError:
MCP_AVAILABLE = False
@pytest.fixture
def temp_claude_dir(tmp_path):
"""Create a temporary .claude directory for testing."""
claude_dir = tmp_path / ".claude"
claude_dir.mkdir()
return claude_dir
@pytest.fixture
def mock_claude_config_path(temp_claude_dir):
"""Patch the MCP config path to use temp directory."""
config_path = temp_claude_dir / "mcp.json"
with patch("headroom.cli.mcp.MCP_CONFIG_PATH", config_path):
with patch("headroom.cli.mcp.CLAUDE_CONFIG_DIR", temp_claude_dir):
yield config_path
@pytest.fixture
def mock_mcp_available():
"""Mock MCP SDK as available for testing install/uninstall commands."""
@@ -79,70 +56,10 @@ class FakeRegistrar:
return False
class TestMCPConfigFunctions:
"""Test config file handling functions."""
def test_get_headroom_command_returns_list(self):
"""Command should be a list suitable for subprocess."""
cmd = get_headroom_command()
assert isinstance(cmd, list)
assert len(cmd) >= 1
# Should end with mcp serve args
assert "mcp" in cmd or "-m" in cmd
def test_load_mcp_config_empty_when_no_file(self, mock_claude_config_path):
"""Loading non-existent config returns empty structure."""
config = load_mcp_config()
assert config == {"mcpServers": {}}
def test_save_and_load_config(self, mock_claude_config_path):
"""Config can be saved and loaded back."""
test_config = {
"mcpServers": {
"headroom": {
"command": "headroom",
"args": ["mcp", "serve"],
}
}
}
save_mcp_config(test_config)
# File should exist
assert mock_claude_config_path.exists()
# Load it back
loaded = load_mcp_config()
assert loaded == test_config
def test_save_config_creates_directory(self, tmp_path):
"""save_mcp_config creates parent directory if needed."""
claude_dir = tmp_path / "new_dir" / ".claude"
config_path = claude_dir / "mcp.json"
with patch("headroom.cli.mcp.MCP_CONFIG_PATH", config_path):
with patch("headroom.cli.mcp.CLAUDE_CONFIG_DIR", claude_dir):
save_mcp_config({"mcpServers": {}})
assert config_path.exists()
def test_load_config_preserves_other_servers(self, mock_claude_config_path):
"""Loading preserves other MCP servers in config."""
# Write config with another server
existing_config = {
"mcpServers": {
"other-server": {"command": "other", "args": []},
}
}
mock_claude_config_path.write_text(json.dumps(existing_config))
loaded = load_mcp_config()
assert "other-server" in loaded["mcpServers"]
#
# Note: Tests for the 'mcp install' command's writes/idempotency/CLI-vs-file
# fallback used to live here, but they were tightly coupled to private
# globals (MCP_CONFIG_PATH, shutil.which) and exercised the same surface
# module globals (config paths, shutil.which) and exercised the same surface
# already covered by:
# - tests/test_mcp_registry/test_claude_registrar.py (file/CLI behavior
# with proper constructor injection — no patches)
@@ -179,7 +96,7 @@ class TestMCPUninstallCommand:
assert result.exit_code == 0
assert registrar.removed == ["headroom"]
def test_uninstall_no_config_file(self, mock_claude_config_path):
def test_uninstall_no_config_file(self):
"""Uninstall with no config file exits cleanly."""
runner = CliRunner()
with patch("headroom.mcp_registry.get_all_registrars", return_value=[]):
@@ -188,7 +105,7 @@ class TestMCPUninstallCommand:
assert result.exit_code == 0
assert "nothing to uninstall" in result.output.lower()
def test_uninstall_not_configured(self, mock_claude_config_path):
def test_uninstall_not_configured(self):
"""Uninstall when headroom not in config exits cleanly."""
registrar = FakeRegistrar(configured=False)
@@ -230,7 +147,7 @@ class TestMCPUninstallCommand:
class TestMCPStatusCommand:
"""Test 'headroom mcp status' command."""
def test_status_not_configured(self, mock_claude_config_path):
def test_status_not_configured(self):
"""Status shows not configured when no config."""
runner = CliRunner()
registrar = FakeRegistrar(configured=False)
@@ -246,7 +163,7 @@ class TestMCPStatusCommand:
or "No config" in result.output
)
def test_status_configured(self, mock_claude_config_path, mock_mcp_available):
def test_status_configured(self, mock_mcp_available):
"""Status reports configured when a registrar has headroom."""
registrar = FakeRegistrar(configured=True)
-89
View File
@@ -1,89 +0,0 @@
from __future__ import annotations
import json
from pathlib import Path
import pytest
from headroom.cli import mcp as mcp_cli
def _write_servers(path: Path, servers: dict) -> None:
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(json.dumps({"mcpServers": servers}), encoding="utf-8")
def test_find_registration_in_claude_json(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
claude_json = tmp_path / ".claude.json"
_write_servers(
claude_json,
{
"headroom": {
"command": "headroom",
"args": ["mcp", "serve"],
"env": {"HEADROOM_PROXY_URL": "http://x:1"},
}
},
)
monkeypatch.setattr(mcp_cli, "CLAUDE_JSON_PATH", claude_json)
monkeypatch.setattr(mcp_cli, "MCP_CONFIG_PATH", tmp_path / ".claude" / "mcp.json")
monkeypatch.chdir(tmp_path)
found = mcp_cli.find_headroom_registration()
assert found is not None
path, cfg = found
assert path == claude_json
assert cfg["env"]["HEADROOM_PROXY_URL"] == "http://x:1"
def test_find_registration_falls_back_to_mcp_json(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
mcp_json = tmp_path / "mcp.json"
_write_servers(mcp_json, {"headroom": {"command": "headroom"}})
monkeypatch.setattr(mcp_cli, "CLAUDE_JSON_PATH", tmp_path / ".claude.json") # absent
monkeypatch.setattr(mcp_cli, "MCP_CONFIG_PATH", mcp_json)
monkeypatch.chdir(tmp_path)
found = mcp_cli.find_headroom_registration()
assert found is not None and found[0] == mcp_json
def test_find_registration_prefers_claude_json(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
claude_json = tmp_path / ".claude.json"
mcp_json = tmp_path / "mcp.json"
_write_servers(claude_json, {"headroom": {"command": "a"}})
_write_servers(mcp_json, {"headroom": {"command": "b"}})
monkeypatch.setattr(mcp_cli, "CLAUDE_JSON_PATH", claude_json)
monkeypatch.setattr(mcp_cli, "MCP_CONFIG_PATH", mcp_json)
monkeypatch.chdir(tmp_path)
found = mcp_cli.find_headroom_registration()
assert found is not None and found[0] == claude_json # ~/.claude.json takes precedence
def test_find_registration_none_when_absent(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
monkeypatch.setattr(mcp_cli, "CLAUDE_JSON_PATH", tmp_path / ".claude.json")
monkeypatch.setattr(mcp_cli, "MCP_CONFIG_PATH", tmp_path / "mcp.json")
monkeypatch.chdir(tmp_path)
assert mcp_cli.find_headroom_registration() is None
def test_find_registration_skips_malformed_json(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
claude_json = tmp_path / ".claude.json"
claude_json.write_text("{ not valid json", encoding="utf-8")
mcp_json = tmp_path / "mcp.json"
_write_servers(mcp_json, {"headroom": {"command": "ok"}})
monkeypatch.setattr(mcp_cli, "CLAUDE_JSON_PATH", claude_json)
monkeypatch.setattr(mcp_cli, "MCP_CONFIG_PATH", mcp_json)
monkeypatch.chdir(tmp_path)
found = mcp_cli.find_headroom_registration()
assert found is not None and found[0] == mcp_json # malformed file skipped, next match used
@@ -49,23 +49,6 @@ def _listening_port() -> Iterator[int]:
s.close()
# --- _wrap_marker_proxy_is_dead -------------------------------------------
def test_proxy_is_dead_when_port_not_listening() -> None:
assert wrap_cli._wrap_marker_proxy_is_dead({"port": _closed_port()}) is True
def test_proxy_is_not_dead_when_port_listening() -> None:
with _listening_port() as port:
assert wrap_cli._wrap_marker_proxy_is_dead({"port": port}) is False
def test_proxy_is_not_dead_when_no_port_recorded() -> None:
# No port → fall back to PID-based staleness, so not "dead" by port here.
assert wrap_cli._wrap_marker_proxy_is_dead({}) is False
# --- _check_and_clear_dead_wrap_marker ------------------------------------
-7
View File
@@ -432,13 +432,6 @@ def test_wrap_openclaw_accepts_repeatable_gateway_provider_ids(runner: CliRunner
assert payload["config"]["gatewayProviderIds"] == ["openai-codex", "anthropic"]
def test_normalize_openclaw_gateway_provider_ids_dedupes_blanks_and_defaults() -> None:
assert wrap_cli._normalize_openclaw_gateway_provider_ids(
(" openai-codex ", "", "anthropic", "openai-codex", " ")
) == ["openai-codex", "anthropic"]
assert wrap_cli._normalize_openclaw_gateway_provider_ids(None) == ["openai-codex"]
def test_read_openclaw_config_value_handles_missing_and_raw_strings() -> None:
missing = MagicMock(returncode=1, stdout="", stderr="missing")
raw_string = MagicMock(returncode=0, stdout="plain-text-value\n", stderr="")