Skip to content

Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.

17.7 KB
Raw Blame
"""Unit tests for OpenCodeProvider.

All tests mock the opencode subprocess; no real opencode CLI calls are made.
"""

from __future__ import annotations

import asyncio
import json
import re
from typing import Any

import pytest

from repowise.core.providers.llm.base import GeneratedResponse, ProviderError
from repowise.core.providers.llm.opencode import (
    OpenCodeProvider,
    _parse_models_output,
    _validate_model_name,
)


class FakeProcess:
    def __init__(
        self,
        *,
        returncode: int = 0,
        stdout: str = "",
        stderr: str = "",
        on_communicate: Any | None = None,
        transport: Any | None = None,
    ) -> None:
        self.returncode = returncode
        self._stdout = stdout
        self._stderr = stderr
        self._on_communicate = on_communicate
        self._transport = transport
        self.stdin_input: bytes | None = None
        self.killed = False

    async def communicate(self, input: bytes | None = None) -> tuple[bytes, bytes]:
        self.stdin_input = input
        if self._on_communicate is not None:
            await self._on_communicate()
        return self._stdout.encode("utf-8"), self._stderr.encode("utf-8")

    def kill(self) -> None:
        self.killed = True

    async def wait(self) -> int:
        return self.returncode


class FakeTransport:
    def __init__(self) -> None:
        self.closed = False

    def close(self) -> None:
        self.closed = True


def _jsonl(*events: dict[str, Any], noise: bool = False) -> str:
    lines = [json.dumps(event) for event in events]
    if noise:
        lines.insert(1, "warning: this is not JSON")
    return "\n".join(lines) + "\n"


def _success_jsonl(text: str = "OK") -> str:
    return _jsonl(
        {"type": "step_start", "sessionID": "s1"},
        {"type": "text", "part": {"text": text}},
        {
            "type": "step_finish",
            "part": {
                "tokens": {
                    "total": 100,
                    "input": 80,
                    "output": 10,
                    "reasoning": 10,
                    "cache": {"write": 0, "read": 20},
                },
            },
        },
        noise=True,
    )


# ---------------------------------------------------------------------------
# Model name validation
# ---------------------------------------------------------------------------


def test_validate_model_name_accepts_valid_names():
    for name in ["big-pickle", "deepseek-v4-pro", "provider/model", "abc.123_x/y-z"]:
        _validate_model_name(name)


def test_validate_model_name_rejects_shell_metacharacters():
    for name in ["bad; ls", "name$(whoami)", "name|cat", "`evil`"]:
        with pytest.raises(ProviderError, match="Invalid model name"):
            _validate_model_name(name)


def test_validate_model_name_rejects_empty():
    with pytest.raises(ProviderError, match="Invalid model name"):
        _validate_model_name("")


def test_validate_model_name_rejects_leading_space():
    with pytest.raises(ProviderError, match="Invalid model name"):
        _validate_model_name(" model")


def test_parse_models_output_extracts_provider_model_pairs():
    output = """
deepseek/deepseek-v4-pro
openai/gpt-5
anthropic/claude-sonnet-4-6
"""
    models = _parse_models_output(output)
    assert models == [
        "deepseek/deepseek-v4-pro",
        "openai/gpt-5",
        "anthropic/claude-sonnet-4-6",
    ]


def test_parse_models_output_ignores_invalid_lines():
    output = """
deepseek/deepseek-v4-pro
some random text
openai/gpt-5

another invalid line
"""
    models = _parse_models_output(output)
    assert models == ["deepseek/deepseek-v4-pro", "openai/gpt-5"]


def test_parse_models_output_empty():
    assert _parse_models_output("") == []
    assert _parse_models_output("   \n  \n") == []


# ---------------------------------------------------------------------------
# Provider metadata
# ---------------------------------------------------------------------------


def test_provider_name_and_default_model(monkeypatch, tmp_path):
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")

    provider = OpenCodeProvider(repo_path=tmp_path)

    assert provider.provider_name == "opencode"
    assert provider.model_name == "opencode/default"


def test_custom_model_is_normalized(monkeypatch, tmp_path):
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")

    assert (
        OpenCodeProvider(model="opencode/deepseek/deepseek-v4-pro", repo_path=tmp_path).model_name
        == "opencode/deepseek/deepseek-v4-pro"
    )
    assert (
        OpenCodeProvider(model="opencode/default", repo_path=tmp_path).model_name
        == "opencode/default"
    )


def test_invalid_model_name_raises(monkeypatch, tmp_path):
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")

    with pytest.raises(ProviderError, match="Invalid model name"):
        OpenCodeProvider(model="bad;name", repo_path=tmp_path)


def test_missing_cli_raises(monkeypatch, tmp_path):
    monkeypatch.setattr("shutil.which", lambda _cmd: None)

    with pytest.raises(ProviderError, match=r"OpenCode CLI not found.*opencode.ai/install"):
        OpenCodeProvider(repo_path=tmp_path)


# ---------------------------------------------------------------------------
# Generation
# ---------------------------------------------------------------------------


async def test_generate_invokes_opencode_with_stdin(monkeypatch, tmp_path):
    opencode_cmd = str(tmp_path / "bin" / "opencode")
    monkeypatch.setattr("shutil.which", lambda _cmd: opencode_cmd)
    captured: dict[str, Any] = {}
    proc = FakeProcess(stdout=_success_jsonl("Hello from OpenCode"))

    async def fake_exec(*args: str, **kwargs: Any) -> FakeProcess:
        captured["args"] = args
        captured["kwargs"] = kwargs
        return proc

    monkeypatch.setattr("asyncio.create_subprocess_exec", fake_exec)

    provider = OpenCodeProvider(model="opencode/deepseek/deepseek-v4-pro", repo_path=tmp_path)
    result = await provider.generate("system rules", "user context")

    assert isinstance(result, GeneratedResponse)
    assert result.content == "Hello from OpenCode"
    assert proc.stdin_input is not None
    prompt = proc.stdin_input.decode("utf-8")
    assert "system rules" in prompt
    assert "user context" in prompt
    args = list(captured["args"])
    assert args[:4] == [opencode_cmd, "run", "--format", "json"]
    # OpenCode CLI v2 removed --dir; the repo is the subprocess cwd instead.
    assert "--dir" not in args
    assert "--dangerously-skip-permissions" not in args
    assert captured["kwargs"]["cwd"] == str(tmp_path.resolve())
    assert args[args.index("--model") + 1] == "deepseek/deepseek-v4-pro"
    assert re.fullmatch(r"repowise_auto_[0-9a-f]{32}", args[args.index("--title") + 1])
    assert captured["kwargs"]["stdin"] == asyncio.subprocess.PIPE
    env = captured["kwargs"].get("env", {})
    assert "OPENCODE_CONFIG_CONTENT" in env
    assert env.get("OPENCODE_DISABLE_PROJECT_CONFIG") == "true"
    config = json.loads(env["OPENCODE_CONFIG_CONTENT"])
    assert config["permission"]["edit"] == "deny"
    assert config["permission"]["bash"] == "deny"


async def test_generate_default_model_omits_model_flag(monkeypatch, tmp_path):
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")
    captured: dict[str, Any] = {}

    async def fake_exec(*args: str, **kwargs: Any) -> FakeProcess:
        captured["args"] = args
        return FakeProcess(stdout=_success_jsonl("OK"))

    monkeypatch.setattr("asyncio.create_subprocess_exec", fake_exec)

    await OpenCodeProvider(repo_path=tmp_path).generate("sys", "user")

    args = list(captured["args"])
    assert "--model" not in args


def test_build_command_omits_dir_flag(monkeypatch, tmp_path):
    """OpenCode CLI v2 rejects ``--dir`` with "Unrecognized flag" (issue #3571)."""
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")

    cmd = OpenCodeProvider(
        model="opencode/deepseek/deepseek-v4-pro", repo_path=tmp_path
    ).build_command("sys", "auto")

    assert "--dir" not in cmd
    assert cmd[1:3] == ["run", "--format"]


async def test_generate_runs_in_repo_path_as_cwd(monkeypatch, tmp_path):
    """The repo is passed as the subprocess cwd, since ``--dir`` is gone."""
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")
    captured: dict[str, Any] = {}

    async def fake_exec(*_args: str, **kwargs: Any) -> FakeProcess:
        captured["kwargs"] = kwargs
        return FakeProcess(stdout=_success_jsonl("OK"))

    monkeypatch.setattr("asyncio.create_subprocess_exec", fake_exec)

    await OpenCodeProvider(repo_path=tmp_path).generate("sys", "user")

    assert captured["kwargs"]["cwd"] == str(tmp_path.resolve())


async def test_generate_parses_jsonl_tokens(monkeypatch, tmp_path):
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")

    async def fake_exec(*_args: str, **_kwargs: Any) -> FakeProcess:
        return FakeProcess(stdout=_success_jsonl("OK"))

    monkeypatch.setattr("asyncio.create_subprocess_exec", fake_exec)

    result = await OpenCodeProvider(repo_path=tmp_path).generate("sys", "user")

    assert result.content == "OK"
    assert result.input_tokens == 80
    assert result.output_tokens == 10
    assert result.cached_tokens == 20
    assert result.usage["source"] == "opencode_run"
    assert "estimated" not in result.usage


async def test_generate_handles_jsonl_noise(monkeypatch, tmp_path):
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")

    async def fake_exec(*_args: str, **_kwargs: Any) -> FakeProcess:
        return FakeProcess(stdout=_success_jsonl("Documentation here"))

    monkeypatch.setattr("asyncio.create_subprocess_exec", fake_exec)

    result = await OpenCodeProvider(repo_path=tmp_path).generate("sys", "user")

    assert result.content == "Documentation here"


async def test_generate_marks_missing_usage_as_estimated(monkeypatch, tmp_path):
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")

    async def fake_exec(*_args: str, **_kwargs: Any) -> FakeProcess:
        return FakeProcess(
            stdout=_jsonl(
                {"type": "step_start"},
                {"type": "text", "part": {"text": "OK"}},
            )
        )

    monkeypatch.setattr("asyncio.create_subprocess_exec", fake_exec)

    result = await OpenCodeProvider(repo_path=tmp_path).generate("sys", "user")

    assert result.input_tokens == 0
    assert result.output_tokens == 0
    assert result.usage["estimated"] is True


async def test_generate_raises_on_nonzero_exit(monkeypatch, tmp_path):
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")

    async def fake_exec(*_args: str, **_kwargs: Any) -> FakeProcess:
        return FakeProcess(returncode=1, stdout="", stderr="not authenticated")

    monkeypatch.setattr("asyncio.create_subprocess_exec", fake_exec)

    with pytest.raises(ProviderError, match="not authenticated"):
        await OpenCodeProvider(repo_path=tmp_path).generate("sys", "user")


async def test_generate_raises_when_jsonl_has_no_text(monkeypatch, tmp_path):
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")

    async def fake_exec(*_args: str, **_kwargs: Any) -> FakeProcess:
        return FakeProcess(stdout=_jsonl({"type": "step_finish", "part": {"tokens": {}}}))

    monkeypatch.setattr("asyncio.create_subprocess_exec", fake_exec)

    with pytest.raises(ProviderError, match="no text was found"):
        await OpenCodeProvider(repo_path=tmp_path).generate("sys", "user")


async def _max_concurrent_generates(monkeypatch, tmp_path, calls: int) -> int:
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")
    active = 0
    max_active = 0

    async def on_communicate() -> None:
        nonlocal active, max_active
        active += 1
        max_active = max(max_active, active)
        await asyncio.sleep(0.01)
        active -= 1

    async def fake_exec(*_args: str, **_kwargs: Any) -> FakeProcess:
        return FakeProcess(stdout=_success_jsonl("OK"), on_communicate=on_communicate)

    monkeypatch.setattr("asyncio.create_subprocess_exec", fake_exec)
    provider = OpenCodeProvider(repo_path=tmp_path)

    await asyncio.gather(*[provider.generate("sys", f"user {i}") for i in range(calls)])
    return max_active


async def test_generate_fans_out_to_the_default_concurrency(monkeypatch, tmp_path):
    monkeypatch.delenv("REPOWISE_OPENCODE_CONCURRENCY", raising=False)
    assert await _max_concurrent_generates(monkeypatch, tmp_path, 6) == 4


async def test_generate_respects_configured_concurrency(monkeypatch, tmp_path):
    monkeypatch.setenv("REPOWISE_OPENCODE_CONCURRENCY", "2")
    assert await _max_concurrent_generates(monkeypatch, tmp_path, 4) == 2


async def test_generate_treats_zero_concurrency_as_one(monkeypatch, tmp_path):
    monkeypatch.setenv("REPOWISE_OPENCODE_CONCURRENCY", "0")
    assert await _max_concurrent_generates(monkeypatch, tmp_path, 3) == 1


async def test_generate_falls_back_to_default_on_invalid_concurrency(monkeypatch, tmp_path):
    monkeypatch.setenv("REPOWISE_OPENCODE_CONCURRENCY", "many")
    assert await _max_concurrent_generates(monkeypatch, tmp_path, 6) == 4


async def test_generate_times_out_and_kills_process(monkeypatch, tmp_path):
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")
    monkeypatch.setattr(
        "repowise.core.providers.llm.opencode._EXEC_TIMEOUT_SECONDS",
        0.01,
    )

    async def on_communicate() -> None:
        await asyncio.sleep(1)

    proc = FakeProcess(stdout="", on_communicate=on_communicate)

    async def fake_exec(*_args: str, **_kwargs: Any) -> FakeProcess:
        return proc

    monkeypatch.setattr("asyncio.create_subprocess_exec", fake_exec)

    with pytest.raises(ProviderError, match="timed out"):
        await OpenCodeProvider(repo_path=tmp_path).generate("sys", "user")

    assert proc.killed


async def test_generate_closes_subprocess_transport(monkeypatch, tmp_path):
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")
    transport = FakeTransport()

    async def fake_exec(*_args: str, **_kwargs: Any) -> FakeProcess:
        return FakeProcess(stdout=_success_jsonl("OK"), transport=transport)

    monkeypatch.setattr("asyncio.create_subprocess_exec", fake_exec)

    await OpenCodeProvider(repo_path=tmp_path).generate("sys", "user")

    assert transport.closed is True


async def test_generate_accepts_cache_hints(monkeypatch, tmp_path):
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")

    async def fake_exec(*_args: str, **_kwargs: Any) -> FakeProcess:
        return FakeProcess(stdout=_success_jsonl("OK"))

    monkeypatch.setattr("asyncio.create_subprocess_exec", fake_exec)

    result = await OpenCodeProvider(repo_path=tmp_path).generate(
        "sys",
        "user",
        cache_hints=(),
    )

    assert result.content == "OK"


async def test_generate_handles_error_jsonl(monkeypatch, tmp_path):
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")

    async def fake_exec(*_args: str, **_kwargs: Any) -> FakeProcess:
        return FakeProcess(
            returncode=1,
            stdout=_jsonl(
                {
                    "type": "error",
                    "error": {"name": "APIError", "data": {"message": "Model is disabled"}},
                }
            ),
            stderr="",
        )

    monkeypatch.setattr("asyncio.create_subprocess_exec", fake_exec)

    with pytest.raises(ProviderError, match="Model is disabled"):
        await OpenCodeProvider(repo_path=tmp_path).generate("sys", "user")


async def test_generate_handles_file_not_found(monkeypatch, tmp_path):
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")

    async def fake_exec(*_args: str, **_kwargs: Any) -> FakeProcess:
        raise FileNotFoundError("No such file")

    monkeypatch.setattr("asyncio.create_subprocess_exec", fake_exec)

    with pytest.raises(ProviderError, match="curl -fsSL"):
        await OpenCodeProvider(repo_path=tmp_path).generate("sys", "user")


async def test_available_model_options_with_catalog(monkeypatch, tmp_path):
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")
    monkeypatch.setattr(
        "repowise.core.providers.llm.opencode._load_opencode_model_catalog",
        lambda _cmd: ["deepseek/deepseek-v4-pro", "openai/gpt-5"],
    )

    options = OpenCodeProvider(repo_path=tmp_path).available_model_options()

    assert len(options) == 3
    assert options[0].model == "opencode/default"
    assert options[0].recommended is True
    assert options[0].source == "local"
    assert options[1].model == "opencode/deepseek/deepseek-v4-pro"
    assert options[1].label == "deepseek/deepseek-v4-pro"
    assert options[1].source == "local"
    assert options[2].model == "opencode/openai/gpt-5"
    assert options[2].label == "openai/gpt-5"


async def test_available_model_options_fallback(monkeypatch, tmp_path):
    monkeypatch.setattr("shutil.which", lambda _cmd: "opencode")
    monkeypatch.setattr(
        "repowise.core.providers.llm.opencode._load_opencode_model_catalog",
        lambda _cmd: None,
    )

    options = OpenCodeProvider(repo_path=tmp_path).available_model_options()

    assert len(options) == 1
    assert options[0].model == "opencode/default"
    assert options[0].recommended is True
    assert options[0].source == "fallback"


def test_model_catalog_probe_never_inherits_stdin(monkeypatch):
    """Inside a stdio MCP server stdin is the JSON-RPC pipe."""
    import subprocess

    from repowise.core.providers.llm import opencode

    seen: dict[str, Any] = {}

    def fake_run(_args, **kwargs):
        seen.update(kwargs)
        return subprocess.CompletedProcess(_args, 1, "", "")

    monkeypatch.setattr(opencode.subprocess, "run", fake_run)
    opencode._load_opencode_model_catalog.cache_clear()
    assert opencode._load_opencode_model_catalog("opencode-stdin-probe") is None
    assert seen["stdin"] is subprocess.DEVNULL