hud-python 0.4.45__py3-none-any.whl → 0.5.1__py3-none-any.whl

hud/cli/utils/tests/test_git.py

@@ -0,0 +1,142 @@
+"""Tests for git utilities."""
+
+from __future__ import annotations
+
+from unittest import mock
+
+from hud.cli.utils.git import get_git_info, get_git_remote_url, normalize_github_url
+
+
+class TestNormalizeGithubUrl:
+    """Test GitHub URL normalization."""
+
+    def test_normalize_ssh_url(self):
+        """Test normalizing SSH format URL."""
+        url = "git@github.com:user/repo.git"
+        result = normalize_github_url(url)
+        assert result == "https://github.com/user/repo"
+
+    def test_normalize_https_with_git_suffix(self):
+        """Test normalizing HTTPS URL with .git suffix."""
+        url = "https://github.com/user/repo.git"
+        result = normalize_github_url(url)
+        assert result == "https://github.com/user/repo"
+
+    def test_normalize_git_protocol(self):
+        """Test normalizing git:// protocol URL."""
+        url = "git://github.com/user/repo.git"
+        result = normalize_github_url(url)
+        assert result == "https://github.com/user/repo"
+
+    def test_normalize_already_clean(self):
+        """Test URL that's already normalized."""
+        url = "https://github.com/user/repo"
+        result = normalize_github_url(url)
+        assert result == "https://github.com/user/repo"
+
+    def test_normalize_with_github_com_colon(self):
+        """Test URL with github.com: format."""
+        url = "ssh://github.com:user/repo.git"
+        result = normalize_github_url(url)
+        assert result == "https://github.com/user/repo"
+
+
+class TestGetGitRemoteUrl:
+    """Test getting git remote URL."""
+
+    @mock.patch("subprocess.run")
+    def test_get_remote_url_success(self, mock_run):
+        """Test successfully getting remote URL."""
+        # First call checks if we're in a git repo
+        mock_run.side_effect = [
+            mock.Mock(returncode=0),  # git rev-parse --git-dir
+            mock.Mock(returncode=0, stdout="git@github.com:user/repo.git\n"),  # git config
+        ]
+
+        result = get_git_remote_url()
+        assert result == "https://github.com/user/repo"
+
+    @mock.patch("subprocess.run")
+    def test_get_remote_url_not_git_repo(self, mock_run):
+        """Test when not in a git repository."""
+        from subprocess import CalledProcessError
+
+        mock_run.side_effect = CalledProcessError(128, "git")
+
+        result = get_git_remote_url()
+        assert result is None
+
+    @mock.patch("subprocess.run")
+    def test_get_remote_url_no_remote(self, mock_run):
+        """Test when no remote origin exists."""
+        from subprocess import CalledProcessError
+
+        mock_run.side_effect = [
+            mock.Mock(returncode=0),  # git rev-parse --git-dir
+            CalledProcessError(1, "git"),  # git config fails
+        ]
+
+        result = get_git_remote_url()
+        assert result is None
+
+    @mock.patch("subprocess.run")
+    def test_get_remote_url_empty(self, mock_run):
+        """Test when remote URL is empty."""
+        mock_run.side_effect = [
+            mock.Mock(returncode=0),
+            mock.Mock(returncode=0, stdout=""),
+        ]
+
+        result = get_git_remote_url()
+        assert result is None
+
+
+class TestGetGitInfo:
+    """Test getting comprehensive git info."""
+
+    @mock.patch("hud.cli.utils.git.get_git_remote_url")
+    @mock.patch("subprocess.run")
+    def test_get_git_info_success(self, mock_run, mock_get_url):
+        """Test successfully getting all git info."""
+        mock_get_url.return_value = "https://github.com/user/repo"
+        mock_run.side_effect = [
+            mock.Mock(returncode=0, stdout="main\n"),  # branch
+            mock.Mock(returncode=0, stdout="abc1234\n"),  # commit
+        ]
+
+        result = get_git_info()
+
+        assert result["remote_url"] == "https://github.com/user/repo"
+        assert result["branch"] == "main"
+        assert result["commit"] == "abc1234"
+
+    @mock.patch("hud.cli.utils.git.get_git_remote_url")
+    @mock.patch("subprocess.run")
+    def test_get_git_info_no_remote(self, mock_run, mock_get_url):
+        """Test git info when no remote exists."""
+        mock_get_url.return_value = None
+        mock_run.side_effect = [
+            mock.Mock(returncode=0, stdout="feature-branch\n"),
+            mock.Mock(returncode=0, stdout="def5678\n"),
+        ]
+
+        result = get_git_info()
+
+        assert result["remote_url"] is None
+        assert result["branch"] == "feature-branch"
+        assert result["commit"] == "def5678"
+
+    @mock.patch("hud.cli.utils.git.get_git_remote_url")
+    @mock.patch("subprocess.run")
+    def test_get_git_info_subprocess_error(self, mock_run, mock_get_url):
+        """Test git info when subprocess fails."""
+        from subprocess import CalledProcessError
+
+        mock_get_url.return_value = "https://github.com/user/repo"
+        mock_run.side_effect = CalledProcessError(1, "git")
+
+        result = get_git_info()
+
+        assert result["remote_url"] == "https://github.com/user/repo"
+        assert "branch" not in result
+        assert "commit" not in result

hud/cli/utils/tests/test_interactive_module.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from hud.cli.utils.interactive import InteractiveMCPTester
+
+
+@pytest.mark.asyncio
+@patch("hud.clients.MCPClient")
+async def test_connect_and_disconnect(MockClient):
+    client = AsyncMock()
+    client.initialize.return_value = None
+    client.list_tools.return_value = []
+    client.shutdown.return_value = None
+    MockClient.return_value = client
+
+    tester = InteractiveMCPTester("http://localhost:8765/mcp", verbose=False)
+    ok = await tester.connect()
+    assert ok is True
+    assert tester.tools == []
+    await tester.disconnect()
+
+
+def test_display_tools_handles_empty(capfd):
+    tester = InteractiveMCPTester("http://x")
+    tester.tools = []
+    tester.display_tools()  # prints warning
+
+
+@pytest.mark.asyncio
+@patch("hud.cli.utils.interactive.questionary")
+async def test_select_tool_quit(mock_questionary):
+    tester = InteractiveMCPTester("http://x")
+    tester.tools = [SimpleNamespace(name="a", description="")]
+    # Simulate ESC/quit
+    mock_questionary.select.return_value.unsafe_ask_async.return_value = "❌ Quit"
+    sel = await tester.select_tool()
+    assert sel is None
+
+
+@pytest.mark.asyncio
+@patch("hud.cli.utils.interactive.console")
+async def test_get_tool_arguments_no_schema(mock_console):
+    tester = InteractiveMCPTester("http://x")
+    args = await tester.get_tool_arguments(SimpleNamespace(name="t", inputSchema=None))
+    assert args == {}
+
+
+@pytest.mark.asyncio
+@patch("hud.cli.utils.interactive.console")
+async def test_call_tool_success(mock_console):
+    tester = InteractiveMCPTester("http://x")
+    fake_result = SimpleNamespace(isError=False, content=[SimpleNamespace(text="ok")])
+    tester.client = AsyncMock()
+    tester.client.call_tool.return_value = fake_result
+    await tester.call_tool(SimpleNamespace(name="t"), {"a": 1})
+    assert tester.client.call_tool.awaited

hud/cli/utils/tests/test_local_runner.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import sys
+from unittest import mock
+
+import pytest
+
+from hud.cli.utils.local_runner import run_local_server, run_with_reload
+
+pytestmark = pytest.mark.skipif(
+    sys.platform == "win32", reason="Prefers Linux (signal/stdio nuances)"
+)
+
+
+@mock.patch("subprocess.run")
+def test_run_local_server_no_reload_http(mock_run, monkeypatch):
+    mock_run.return_value = mock.Mock(returncode=0)
+    # Ensure sys.exit is raised with code 0
+    with pytest.raises(SystemExit) as exc:
+        run_local_server("server:app", transport="http", port=8765, verbose=True, reload=False)
+    assert exc.value.code == 0
+    # Verify the command contained port and no-banner
+    args = mock_run.call_args[0][0]
+    assert "--port" in args and "--no-banner" in args
+
+
+@mock.patch("hud.cli.utils.local_runner.run_with_reload")
+def test_run_local_server_reload_calls_reload(mock_reload):
+    run_local_server("server:app", transport="stdio", port=None, verbose=False, reload=True)
+    mock_reload.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_run_with_reload_import_error(monkeypatch):
+    # Force ImportError for watchfiles
+    import builtins as _builtins
+
+    real_import = _builtins.__import__
+
+    def _imp(name, *args, **kwargs):
+        if name == "watchfiles":
+            raise ImportError("nope")
+        return real_import(name, *args, **kwargs)
+
+    monkeypatch.setattr(_builtins, "__import__", _imp)
+
+    with pytest.raises(SystemExit) as exc:
+        # run_with_reload is async in this module; await it
+        await run_with_reload("server:app", transport="stdio", verbose=False)
+    assert exc.value.code == 1

hud/cli/utils/tests/test_logging_utils.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from hud.cli.utils.logging import CaptureLogger, analyze_error_for_hints, is_port_free
+
+
+def test_capture_logger_basic(capfd):
+    logger = CaptureLogger(print_output=True)
+    logger.success("done")
+    logger.error("oops")
+    logger.info("info")
+    out = logger.get_output()
+    assert "done" in out and "oops" in out and "info" in out
+
+
+def test_analyze_error_for_hints_matches():
+    hint = analyze_error_for_hints("ModuleNotFoundError: x")
+    assert hint and "dependencies" in hint
+
+
+def test_is_port_free_returns_bool():
+    # Probe a high port; we only assert the function returns a boolean
+    free = is_port_free(65500)
+    assert isinstance(free, bool)

hud/cli/utils/tests/test_metadata.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from hud.cli.utils.metadata import (
+    analyze_from_metadata,
+    check_local_cache,
+    fetch_lock_from_registry,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@patch("hud.cli.utils.metadata.settings")
+@patch("requests.get")
+def test_fetch_lock_from_registry_success(mock_get, mock_settings):
+    mock_settings.hud_telemetry_url = "https://api.example.com"
+    mock_settings.api_key = None
+    resp = MagicMock(status_code=200)
+    resp.json.return_value = {"lock": "image: img\n"}
+    mock_get.return_value = resp
+    lock = fetch_lock_from_registry("org/name:tag")
+    assert lock is not None and lock["image"] == "img"
+
+
+def test_check_local_cache_not_found(tmp_path: Path, monkeypatch):
+    # Point registry to empty dir
+    from hud.cli.utils import registry as reg
+
+    monkeypatch.setattr(reg, "get_registry_dir", lambda: tmp_path)
+    assert check_local_cache("org/name:tag") is None
+
+
+@pytest.mark.asyncio
+@patch("hud.cli.utils.metadata.console")
+@patch("hud.cli.utils.metadata.list_registry_entries")
+@patch("hud.cli.utils.metadata.load_from_registry")
+@patch("hud.cli.utils.metadata.extract_digest_from_image")
+async def test_analyze_from_metadata_local(mock_extract, mock_load, mock_list, mock_console):
+    mock_extract.return_value = "abcd"
+    mock_load.return_value = {"image": "img", "environment": {"toolCount": 0}}
+    mock_list.return_value = []
+    await analyze_from_metadata("img@sha256:abcd", "json", verbose=False)
+    # Should print JSON
+    assert mock_console.print_json.called

hud/cli/utils/tests/test_package_runner.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest import mock
+
+import pytest
+
+from hud.cli.utils.package_runner import run_package_as_mcp
+
+
+@pytest.mark.asyncio
+@mock.patch("hud.cli.utils.package_runner.FastMCP")
+async def test_run_package_as_external_command(MockFastMCP):
+    proxy = mock.AsyncMock()
+    MockFastMCP.as_proxy.return_value = proxy
+    await run_package_as_mcp(["python", "-m", "server"], transport="http", port=9999)
+    assert proxy.run_async.awaited
+
+
+@pytest.mark.asyncio
+@mock.patch("hud.cli.utils.package_runner.importlib.import_module")
+async def test_run_package_import_module(mock_import):
+    server = SimpleNamespace(name="test", run_async=mock.AsyncMock())
+    mod = SimpleNamespace(mcp=server)
+    mock_import.return_value = mod
+    await run_package_as_mcp("module_name", transport="stdio")
+    assert server.run_async.awaited
+
+
+@pytest.mark.asyncio
+@mock.patch("hud.cli.utils.package_runner.importlib.import_module")
+async def test_run_package_import_missing_attr(mock_import):
+    mock_import.return_value = SimpleNamespace()
+    with pytest.raises(SystemExit):
+        await run_package_as_mcp("module_name", transport="stdio")

hud/cli/utils/tests/test_registry_utils.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from hud.cli.utils.registry import (
+    extract_digest_from_image,
+    extract_name_and_tag,
+    list_registry_entries,
+    load_from_registry,
+    save_to_registry,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def test_extract_digest_from_image_variants():
+    assert extract_digest_from_image("repo/name@sha256:abcdef1234567890") == "abcdef123456"
+    assert extract_digest_from_image("sha256:deadbeefcafebabe") == "deadbeefcafe"
+    assert extract_digest_from_image("org/name:tag") == "tag"
+    assert extract_digest_from_image("org/name") == "latest"
+
+
+def test_extract_name_and_tag():
+    assert extract_name_and_tag("docker.io/hudpython/test_init:latest@sha256:abc") == (
+        "hudpython/test_init",
+        "latest",
+    )
+    assert extract_name_and_tag("myorg/myenv:v1.0") == ("myorg/myenv", "v1.0")
+    assert extract_name_and_tag("myorg/myenv") == ("myorg/myenv", "latest")
+
+
+def test_save_load_list_registry(tmp_path: Path, monkeypatch):
+    # Redirect registry dir to temp
+    from hud.cli.utils import registry as mod
+
+    monkeypatch.setattr(mod, "get_registry_dir", lambda: tmp_path)
+
+    data = {"image": "org/name:tag", "build": {"version": "0.1.0"}}
+    saved = save_to_registry(data, "org/name:tag@sha256:abcdef0123456789", verbose=True)
+    assert saved is not None and saved.exists()
+
+    # Digest directory was created
+    entries = list_registry_entries()
+    assert len(entries) == 1
+
+    digest, _ = entries[0]
+    loaded = load_from_registry(digest)
+    assert loaded and loaded.get("image") == "org/name:tag"

hud/cli/utils/tests/test_remote_runner.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import pytest
+
+from hud.cli.utils.remote_runner import run_remote_server
+
+
+def test_run_remote_server_requires_api_key(monkeypatch):
+    # Ensure settings.api_key is None and no api_key provided
+    from hud.cli.utils import remote_runner as mod
+
+    monkeypatch.setattr(mod.settings, "api_key", None, raising=True)
+
+    with pytest.raises(SystemExit) as exc:
+        run_remote_server(
+            image="img:latest",
+            docker_args=[],
+            transport="stdio",
+            port=8765,
+            url="https://api.example.com/mcp",
+            api_key=None,
+            run_id=None,
+            verbose=False,
+        )
+    assert exc.value.code == 1

hud/cli/utils/tests/test_runner_modules.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from unittest import mock
+
+import pytest
+
+from hud.cli.utils.remote_runner import build_remote_headers, parse_env_vars, parse_headers
+from hud.cli.utils.runner import run_mcp_server
+
+
+def test_parse_headers_and_env_vars():
+    assert parse_headers(["A:B", "C=D"]) == {"A": "B", "C": "D"}
+    assert parse_env_vars(["API_KEY=xxx"]) == {"Env-Api-Key": "xxx"}
+
+
+def test_build_remote_headers_combines():
+    headers = build_remote_headers(
+        image="img:latest", env_args=["X=1"], header_args=["H:V"], api_key="k", run_id="r"
+    )
+    assert headers["Mcp-Image"] == "img:latest"
+    assert headers["Authorization"].startswith("Bearer ")
+    assert headers["Run-Id"] == "r"
+    assert headers["Env-X"] == "1"
+    assert headers["H"] == "V"
+
+
+@mock.patch("hud.cli.utils.runner.run_stdio_server")
+def test_run_mcp_server_stdio(mock_stdio):
+    run_mcp_server("img", [], "stdio", 8765, verbose=False, interactive=False)
+    assert mock_stdio.called
+
+
+def test_run_mcp_server_stdio_interactive_fails():
+    with pytest.raises(SystemExit):
+        run_mcp_server("img", [], "stdio", 8765, verbose=False, interactive=True)
+
+
+@mock.patch("hud.cli.utils.runner.run_http_server")
+def test_run_mcp_server_http(mock_http):
+    run_mcp_server("img", [], "http", 8765, verbose=True, interactive=False)
+    assert mock_http.called
+
+
+@mock.patch("hud.cli.utils.runner.run_http_server_interactive")
+def test_run_mcp_server_http_interactive(mock_http_int):
+    run_mcp_server("img", [], "http", 8765, verbose=False, interactive=True)
+    assert mock_http_int.called
+
+
+def test_run_mcp_server_unknown():
+    with pytest.raises(SystemExit):
+        run_mcp_server("img", [], "bad", 8765, verbose=False)

hud/cli/utils/tests/test_source_hash.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from hud.cli.utils.source_hash import compute_source_hash, list_source_files
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def test_source_hash_changes_with_content(tmp_path: Path):
+    env = tmp_path / "env"
+    env.mkdir()
+    (env / "Dockerfile").write_text("FROM python:3.11")
+    (env / "pyproject.toml").write_text("[tool.hud]\n")
+    (env / "server").mkdir()
+    (env / "server" / "main.py").write_text("print('hi')\n")
+
+    h1 = compute_source_hash(env)
+    # Change file content
+    (env / "server" / "main.py").write_text("print('bye')\n")
+    h2 = compute_source_hash(env)
+    assert h1 != h2
+
+
+def test_list_source_files_sorted(tmp_path: Path):
+    env = tmp_path / "env"
+    env.mkdir()
+    (env / "Dockerfile").write_text("FROM python:3.11")
+    (env / "environment").mkdir()
+    (env / "environment" / "a.py").write_text("a")
+    (env / "environment" / "b.py").write_text("b")
+
+    files = list_source_files(env)
+    rels = [str(p.resolve().relative_to(env)).replace("\\", "/") for p in files]
+    assert rels == ["Dockerfile", "environment/a.py", "environment/b.py"]

hud/cli/utils/tests/test_tasks.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from hud.cli.utils.tasks import find_tasks_file
+
+
+@patch("pathlib.Path.cwd")
+def test_find_tasks_file_with_arg(mock_cwd):
+    """Test that when a tasks file is provided, it's returned as-is."""
+    assert find_tasks_file("some/path.json") == "some/path.json"
+    mock_cwd.assert_not_called()
+
+
+@patch("pathlib.Path.cwd")
+def test_find_tasks_file_no_files(mock_cwd):
+    """Test that FileNotFoundError is raised when no task files exist."""
+    mock_path = MagicMock(spec=Path)
+    mock_path.glob.return_value = []
+    mock_cwd.return_value = mock_path
+
+    with pytest.raises(FileNotFoundError, match="No task JSON or JSONL files found"):
+        find_tasks_file(None)
+
+
+@patch("hud.cli.utils.tasks.hud_console")
+@patch("pathlib.Path.cwd")
+def test_find_tasks_file_single_file(mock_cwd, mock_console):
+    """Test that when only one file exists, it's returned without prompting."""
+    mock_path = MagicMock(spec=Path)
+    mock_file = MagicMock(spec=Path)
+    mock_file.__str__.return_value = "test.json"  # type: ignore
+
+    def glob_side_effect(pattern):
+        if pattern == "*.json":
+            return [mock_file]
+        return []
+
+    mock_path.glob.side_effect = glob_side_effect
+    mock_path.__str__.return_value = str(Path.cwd())  # type: ignore
+    mock_cwd.return_value = mock_path
+
+    result = find_tasks_file(None)
+    assert result == "test.json"
+    mock_console.select.assert_not_called()
+
+
+@patch("hud.cli.utils.tasks.hud_console")
+@patch("pathlib.Path.cwd")
+def test_find_tasks_file_multiple_files(mock_cwd, mock_console):
+    """Test that when multiple files exist, user is prompted to select one."""
+    mock_path = MagicMock(spec=Path)
+    mock_file1 = MagicMock(spec=Path)
+    mock_file1.__str__.return_value = "test1.json"  # type: ignore
+    mock_file2 = MagicMock(spec=Path)
+    mock_file2.__str__.return_value = "test2.jsonl"  # type: ignore
+
+    def glob_side_effect(pattern):
+        if pattern == "*.json":
+            return [mock_file1]
+        if pattern == "*.jsonl":
+            return [mock_file2]
+        return []
+
+    mock_path.glob.side_effect = glob_side_effect
+    mock_path.__str__.return_value = str(Path.cwd())  # type: ignore
+    mock_cwd.return_value = mock_path
+    mock_console.select.return_value = "test2.jsonl"
+
+    result = find_tasks_file(None)
+
+    assert result == "test2.jsonl"
+    mock_console.select.assert_called_once()
+    call_args = mock_console.select.call_args
+    assert call_args[0][0] == "Select a tasks file"
+    assert "test1.json" in call_args[1]["choices"]
+    assert "test2.jsonl" in call_args[1]["choices"]