hud-python 0.4.52__py3-none-any.whl → 0.4.54__py3-none-any.whl

hud/cli/utils/tests/test_env_check.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+from typing import TYPE_CHECKING
+from unittest.mock import patch
+
+from hud.cli.utils.env_check import (
+    _collect_source_diffs,
+    _parse_generated_at,
+    ensure_built,
+    find_environment_dir,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def test_parse_generated_at_variants():
+    ts = _parse_generated_at({"build": {"generatedAt": datetime.now(UTC).isoformat()}})
+    assert isinstance(ts, float)
+    assert _parse_generated_at({}) is None
+
+
+def test_collect_source_diffs_basic(tmp_path: Path):
+    env = tmp_path / "env"
+    env.mkdir()
+    # simulate files
+    (env / "Dockerfile").write_text("FROM python:3.11")
+    (env / "pyproject.toml").write_text("[tool.hud]")
+    (env / "a.txt").write_text("x")
+
+    # stored file list includes a non-existent file and old time
+    built_time = (datetime.now(UTC) - timedelta(days=1)).isoformat()
+    lock = {"build": {"sourceFiles": ["a.txt", "b.txt"], "generatedAt": built_time}}
+
+    # Patch list_source_files to return current env files
+    with patch("hud.cli.utils.env_check.list_source_files") as mock_list:
+        mock_list.return_value = [env / "a.txt", env / "Dockerfile"]
+        diffs = _collect_source_diffs(env, lock)
+    assert "Dockerfile" in diffs["added"]
+    assert "b.txt" in diffs["removed"]
+    assert "a.txt" in diffs["modified"] or "a.txt" in diffs["added"]
+
+
+def test_find_environment_dir_prefers_lock(tmp_path: Path):
+    # Create env as a sibling to tasks, so it will be in the candidates list
+    parent = tmp_path / "parent"
+    parent.mkdir()
+    tasks = parent / "tasks.json"
+    tasks.write_text("[]")
+    env = tmp_path / "env"
+    env.mkdir()
+    (env / "hud.lock.yaml").write_text("version: 1.0")
+    # Set cwd to env so it's in the candidate list
+    with patch("pathlib.Path.cwd", return_value=env):
+        found = find_environment_dir(tasks)
+    # Should find env because cwd returns env and it has hud.lock.yaml
+    assert found == env
+
+
+def test_ensure_built_no_lock_noninteractive(tmp_path: Path):
+    env = tmp_path / "e"
+    env.mkdir()
+    # Non-interactive: returns empty dict and does not raise
+    result = ensure_built(env, interactive=False)
+    assert result == {}
+
+
+def test_ensure_built_interactive_build(tmp_path: Path):
+    env = tmp_path / "e"
+    env.mkdir()
+    # Simulate interactive=False path avoids prompts
+    result = ensure_built(env, interactive=False)
+    assert result == {}

hud/cli/utils/tests/test_environment.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from unittest.mock import MagicMock, patch
+
+from hud.cli.utils.environment import get_image_name, image_exists, is_environment_directory
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def test_get_image_name_override():
+    name, source = get_image_name(".", image_override="custom:dev")
+    assert name == "custom:dev" and source == "override"
+
+
+def test_get_image_name_auto(tmp_path: Path):
+    env = tmp_path / "my_env"
+    env.mkdir()
+    # Provide Dockerfile and pyproject to pass directory check later if used
+    (env / "Dockerfile").write_text("FROM python:3.11")
+    (env / "pyproject.toml").write_text("[tool.hud]\nimage='x'")
+    name, source = get_image_name(env)
+    # Because pyproject exists with image key, source should be cache
+    assert source == "cache"
+    assert name == "x"
+
+
+def test_is_environment_directory(tmp_path: Path):
+    d = tmp_path / "env"
+    d.mkdir()
+    assert is_environment_directory(d) is False
+    (d / "Dockerfile").write_text("FROM python:3.11")
+    assert is_environment_directory(d) is False
+    (d / "pyproject.toml").write_text("[tool.hud]")
+    assert is_environment_directory(d) is True
+
+
+@patch("subprocess.run")
+def test_image_exists_true(mock_run):
+    mock_run.return_value = MagicMock(returncode=0)
+    assert image_exists("img") is True

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.cli.utils.interactive.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"
+
+    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())
+    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"
+    mock_file2 = MagicMock(spec=Path)
+    mock_file2.__str__.return_value = "test2.jsonl"
+
+    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())
+    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"]

hud/cli/utils/version_check.py

@@ -171,11 +171,11 @@ def check_for_updates() -> VersionInfo | None:
 
     # Try to load from cache
     cached_info = _load_cache()
-    
+
     # If cache exists but current version has changed (user upgraded), invalidate cache
     if cached_info and cached_info.current != current:
         cached_info = None  # Force fresh check
-    
+
     if cached_info:
         # Update the current version in the cached info to reflect reality
         # but keep the cached latest version and timestamp