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

hud/cli/tests/test_analyze_module.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from hud.cli.analyze import (
+    analyze_environment,
+    analyze_environment_from_config,
+    analyze_environment_from_mcp_config,
+    display_interactive,
+    display_markdown,
+    parse_docker_command,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+# Mark entire module as asyncio to ensure async tests run with pytest-asyncio
+pytestmark = pytest.mark.asyncio
+
+
+def test_parse_docker_command():
+    cmd = ["docker", "run", "--rm", "-i", "img"]
+    cfg = parse_docker_command(cmd)
+    assert cfg == {"local": {"command": "docker", "args": ["run", "--rm", "-i", "img"]}}
+
+
+@pytest.mark.asyncio
+@patch("hud.cli.analyze.MCPClient")
+@patch("hud.cli.analyze.console")
+async def test_analyze_environment_success_json(mock_console, MockClient):
+    client = AsyncMock()
+    client.initialize.return_value = None
+    client.analyze_environment.return_value = {"tools": [], "resources": []}
+    client.shutdown.return_value = None
+    MockClient.return_value = client
+
+    await analyze_environment(["docker", "run", "img"], output_format="json", verbose=False)
+    assert client.initialize.awaited
+    assert client.analyze_environment.awaited
+    assert client.shutdown.awaited
+    assert mock_console.print_json.called
+
+
+@pytest.mark.asyncio
+@patch("hud.cli.analyze.MCPClient")
+@patch("hud.cli.analyze.console")
+async def test_analyze_environment_failure(mock_console, MockClient):
+    client = AsyncMock()
+    client.initialize.side_effect = RuntimeError("boom")
+    client.shutdown.return_value = None
+    MockClient.return_value = client
+
+    # Should swallow exception and return without raising
+    await analyze_environment(["docker", "run", "img"], output_format="json", verbose=True)
+    assert client.shutdown.awaited
+    assert mock_console.print_json.called is False
+
+
+def test_display_interactive_metadata_only(monkeypatch):
+    import hud.cli.analyze as mod
+
+    monkeypatch.setattr(mod, "console", MagicMock(), raising=False)
+    monkeypatch.setattr(mod, "hud_console", MagicMock(), raising=False)
+
+    analysis = {
+        "image": "img:latest",
+        "status": "cached",
+        "tool_count": 2,
+        "tools": [
+            {"name": "t1", "description": "d1", "inputSchema": {"type": "object"}},
+            {"name": "t2", "description": "d2"},
+        ],
+        "resources": [],
+    }
+    display_interactive(analysis)
+
+
+def test_display_markdown_both_paths(capsys):
+    # metadata-only
+    md_only = {"image": "img:latest", "tool_count": 0, "tools": [], "resources": []}
+    display_markdown(md_only)
+
+    # live metadata
+    live = {"metadata": {"servers": ["s1"], "initialized": True}, "tools": [], "resources": []}
+    display_markdown(live)
+
+    # Check that output was generated
+    captured = capsys.readouterr()
+    assert "MCP Environment Analysis" in captured.out
+
+
+@patch("hud.cli.analyze.MCPClient")
+async def test_analyze_environment_from_config(MockClient, tmp_path: Path):
+    client = AsyncMock()
+    client.initialize.return_value = None
+    client.analyze_environment.return_value = {"tools": [], "resources": []}
+    client.shutdown.return_value = None
+    MockClient.return_value = client
+
+    cfg = tmp_path / "mcp.json"
+    cfg.write_text('{"local": {"command": "docker", "args": ["run", "img"]}}')
+    await analyze_environment_from_config(cfg, output_format="json", verbose=False)
+    assert client.initialize.awaited and client.shutdown.awaited
+
+
+@patch("hud.cli.analyze.MCPClient")
+async def test_analyze_environment_from_mcp_config(MockClient):
+    client = AsyncMock()
+    client.initialize.return_value = None
+    client.analyze_environment.return_value = {"tools": [], "resources": []}
+    client.shutdown.return_value = None
+    MockClient.return_value = client
+
+    mcp_config = {"local": {"command": "docker", "args": ["run", "img"]}}
+    await analyze_environment_from_mcp_config(mcp_config, output_format="json", verbose=False)
+    assert client.initialize.awaited and client.shutdown.awaited

hud/cli/tests/test_build.py

@@ -219,6 +219,17 @@ class TestAnalyzeMcpEnvironment:
         mock_tool.description = "Test tool"
         mock_tool.inputSchema = {"type": "object"}
 
+        # Prefer analyze_environment path (aligns with analyze CLI tests)
+        mock_client.analyze_environment = mock.AsyncMock(
+            return_value={
+                "metadata": {"servers": ["local"], "initialized": True},
+                "tools": [{"name": "test_tool", "description": "Test tool"}],
+                "hub_tools": {},
+                "resources": [],
+                "telemetry": {},
+            }
+        )
+        # Fallback still defined for completeness
         mock_client.list_tools.return_value = [mock_tool]
 
         result = await analyze_mcp_environment("test:latest")
@@ -237,7 +248,9 @@ class TestAnalyzeMcpEnvironment:
         mock_client_class.return_value = mock_client
         mock_client.initialize.side_effect = ConnectionError("Connection failed")
 
-        with pytest.raises(ConnectionError):
+        from hud.shared.exceptions import HudException
+
+        with pytest.raises(HudException, match="Connection failed"):
             await analyze_mcp_environment("test:latest")
 
     @mock.patch("hud.cli.build.MCPClient")
@@ -245,6 +258,15 @@ class TestAnalyzeMcpEnvironment:
         """Test analysis in verbose mode."""
         mock_client = mock.AsyncMock()
         mock_client_class.return_value = mock_client
+        mock_client.analyze_environment = mock.AsyncMock(
+            return_value={
+                "metadata": {"servers": ["local"], "initialized": True},
+                "tools": [],
+                "hub_tools": {},
+                "resources": [],
+                "telemetry": {},
+            }
+        )
         mock_client.list_tools.return_value = []
 
         # Just test that it runs without error in verbose mode
@@ -363,7 +385,7 @@ ENV API_KEY
         mock_run.return_value = mock_result
 
         # Run build
-        build_environment(str(env_dir), "test/env:latest")
+        build_environment(str(env_dir), "test-env:latest")
 
         # Check lock file was created
         lock_file = env_dir / "hud.lock.yaml"

hud/cli/tests/test_build_failure.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from unittest.mock import patch
+
+import pytest
+import typer
+
+from hud.cli.build import build_environment
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@patch("hud.cli.build.compute_source_hash", return_value="deadbeef")
+@patch(
+    "hud.cli.build.analyze_mcp_environment",
+    return_value={"initializeMs": 10, "toolCount": 0, "tools": []},
+)
+@patch("hud.cli.build.build_docker_image", return_value=True)
+def test_build_label_rebuild_failure(_bd, _an, _hash, tmp_path: Path, monkeypatch):
+    # Minimal environment dir
+    env = tmp_path / "env"
+    env.mkdir()
+    (env / "Dockerfile").write_text("FROM python:3.11")
+
+    # Ensure subprocess.run returns non-zero for the second build (label build)
+    import types
+
+    def run_side_effect(cmd, *a, **k):
+        # Return 0 for first docker build, 1 for label build
+        if isinstance(cmd, list) and cmd[:2] == ["docker", "build"] and "--label" in cmd:
+            return types.SimpleNamespace(returncode=1, stderr="boom")
+        return types.SimpleNamespace(returncode=0, stdout="")
+
+    monkeypatch.setenv("FASTMCP_DISABLE_BANNER", "1")
+    with (
+        patch("hud.cli.build.subprocess.run", side_effect=run_side_effect),
+        pytest.raises(typer.Exit),
+    ):
+        build_environment(str(env), verbose=False)

hud/cli/tests/test_build_module.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from unittest import mock
+
+from hud.cli.build import (
+    extract_env_vars_from_dockerfile,
+    get_docker_image_digest,
+    get_docker_image_id,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def test_extract_env_vars_from_dockerfile_complex(tmp_path: Path):
+    dockerfile = tmp_path / "Dockerfile"
+    dockerfile.write_text(
+        """
+FROM python:3.11
+ARG BUILD_TOKEN
+ARG DEFAULTED=1
+ENV RUNTIME_KEY
+ENV FROM_ARG=$BUILD_TOKEN
+ENV WITH_DEFAULT=val
+"""
+    )
+    required, optional = extract_env_vars_from_dockerfile(dockerfile)
+    # BUILD_TOKEN required (ARG without default)
+    assert "BUILD_TOKEN" in required
+    # RUNTIME_KEY required (ENV without value)
+    assert "RUNTIME_KEY" in required
+    # FROM_ARG references BUILD_TOKEN -> required
+    assert "FROM_ARG" in required
+    # DEFAULTED and WITH_DEFAULT should not be marked required by default
+    assert "DEFAULTED" not in required
+    assert "WITH_DEFAULT" not in required
+    assert optional == []
+
+
+@mock.patch("subprocess.run")
+def test_get_docker_image_digest_none(mock_run):
+    mock_run.return_value = mock.Mock(stdout="[]", returncode=0)
+    assert get_docker_image_digest("img") is None
+
+
+@mock.patch("subprocess.run")
+def test_get_docker_image_id_ok(mock_run):
+    mock_run.return_value = mock.Mock(stdout="sha256:abc", returncode=0)
+    assert get_docker_image_id("img") == "sha256:abc"

hud/cli/tests/test_cli_more_wrappers.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import hud.cli as cli
+
+
+def test_version_does_not_crash():
+    # Just ensure it runs without raising
+    cli.version()
+
+
+@patch("hud.cli.list_module.list_command")
+def test_list_environments_wrapper(mock_list):
+    cli.list_environments(filter_name=None, json_output=False, show_all=False, verbose=False)
+    assert mock_list.called
+
+
+@patch("hud.cli.clone_repository", return_value=(True, "/tmp/repo"))
+@patch("hud.cli.get_clone_message", return_value={})
+@patch("hud.cli.print_tutorial")
+def test_clone_wrapper(mock_tutorial, _msg, _clone):
+    cli.clone("https://example.com/repo.git")
+    assert mock_tutorial.called
+
+
+@patch("hud.cli.remove_command")
+def test_remove_wrapper(mock_remove):
+    cli.remove(target="all", yes=True, verbose=False)
+    assert mock_remove.called

hud/cli/tests/test_cli_root.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+import hud.cli as cli
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@patch("hud.cli.utils.metadata.analyze_from_metadata", new_callable=AsyncMock)
+@patch("asyncio.run")
+def test_analyze_params_metadata(mock_run, mock_analyze):
+    # image only -> metadata path
+    cli.analyze(params=["img:latest"], output_format="json", verbose=False)
+    assert mock_run.called
+
+
+@patch("hud.cli.analyze.analyze_environment", new_callable=AsyncMock)
+@patch("hud.cli.utils.docker.build_run_command")
+@patch("asyncio.run")
+def test_analyze_params_live(mock_run, mock_build_cmd, mock_analyze_env):
+    mock_build_cmd.return_value = ["docker", "run", "img", "-e", "K=V"]
+    # docker args trigger live path
+    cli.analyze(params=["img:latest", "-e", "K=V"], output_format="json", verbose=True)
+    assert mock_run.called
+
+
+def test_analyze_no_params_errors():
+    import typer
+
+    # When no params provided, analyze prints help and exits(1)
+    with pytest.raises(typer.Exit):
+        cli.analyze(params=None, config=None, cursor=None, output_format="json", verbose=False)  # type: ignore
+
+
+@patch("hud.cli.analyze.analyze_environment_from_config", new_callable=AsyncMock)
+@patch("asyncio.run")
+def test_analyze_from_config(mock_run, mock_func, tmp_path: Path):
+    cfg = tmp_path / "cfg.json"
+    cfg.write_text("{}")
+    cli.analyze(params=None, config=cfg, cursor=None, output_format="json", verbose=False)  # type: ignore
+    assert mock_run.called
+
+
+@patch("hud.cli.parse_cursor_config")
+@patch("hud.cli.analyze.analyze_environment_from_mcp_config", new_callable=AsyncMock)
+@patch("asyncio.run")
+def test_analyze_from_cursor(mock_run, mock_analyze, mock_parse):
+    mock_parse.return_value = (["cmd", "arg"], None)
+    cli.analyze(params=None, config=None, cursor="server", output_format="json", verbose=False)  # type: ignore
+    assert mock_run.called
+
+
+@patch("hud.cli.build_command")
+def test_build_env_var_parsing(mock_build):
+    cli.build(
+        params=[".", "-e", "A=B", "--env=C=D", "--env", "E=F"],
+        tag=None,
+        no_cache=False,
+        verbose=False,
+        platform=None,
+    )
+    assert mock_build.called
+    # args: directory, tag, no_cache, verbose, env_vars, platform
+    env_vars = mock_build.call_args[0][4]
+    assert env_vars == {"A": "B", "C": "D", "E": "F"}
+
+
+@patch("hud.cli.utils.runner.run_mcp_server")
+def test_run_local_calls_runner(mock_runner):
+    cli.run(
+        params=["img:latest"],
+        local=True,
+        transport="stdio",
+        port=1234,
+        url=None,  # type: ignore
+        api_key=None,
+        run_id=None,
+        verbose=False,
+    )
+    assert mock_runner.called
+
+
+@patch("hud.cli.utils.remote_runner.run_remote_server")
+def test_run_remote_calls_remote(mock_remote):
+    cli.run(
+        params=["img:latest"],
+        local=False,
+        transport="http",
+        port=8765,
+        url="https://x",
+        api_key=None,
+        run_id=None,
+        verbose=True,
+    )
+    assert mock_remote.called
+
+
+def test_run_no_params_errors():
+    import typer
+
+    with pytest.raises(typer.Exit):
+        cli.run(params=None)  # type: ignore
+
+
+@patch("hud.cli.run_mcp_dev_server")
+def test_dev_calls_runner(mock_dev):
+    cli.dev(
+        params=["server.main"],
+        docker=False,
+        stdio=False,
+        port=9000,
+        verbose=False,
+        inspector=False,
+        interactive=False,
+        watch=None,  # type: ignore
+    )
+    assert mock_dev.called
+
+
+@patch("hud.cli.pull_command")
+def test_pull_command_wrapper(mock_pull):
+    cli.pull(target="org/name:tag", lock_file=None, yes=True, verify_only=True, verbose=False)
+    assert mock_pull.called
+
+
+@patch("hud.cli.push_command")
+def test_push_command_wrapper(mock_push, tmp_path: Path):
+    cli.push(directory=str(tmp_path), image=None, tag=None, sign=False, yes=True, verbose=True)
+    assert mock_push.called

hud/cli/tests/test_mcp_server.py

@@ -15,22 +15,23 @@ class TestRunMCPDevServer:
     """Test the main server runner."""
 
     def test_run_dev_server_image_not_found(self) -> None:
-        """Test handling when Docker image doesn't exist."""
-        import click
+        """When using Docker mode without a lock file, exits with typer.Exit(1)."""
+        import typer
 
         with (
-            patch("hud.cli.utils.environment.image_exists", return_value=False),
-            patch("click.confirm", return_value=False),
-            pytest.raises(click.Abort),
+            patch("hud.cli.dev.should_use_docker_mode", return_value=True),
+            patch("hud.cli.dev.Path.cwd"),
+            patch("hud.cli.dev.hud_console"),
+            pytest.raises(typer.Exit),
         ):
             run_mcp_dev_server(
-                module=".",
+                module=None,
                 stdio=False,
                 port=8765,
                 verbose=False,
                 inspector=False,
                 interactive=False,
                 watch=[],
-                docker=False,
+                docker=True,
                 docker_args=[],
             )

hud/cli/tests/test_push_happy.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+from typing import TYPE_CHECKING
+from unittest.mock import patch
+
+from hud.cli.push import push_environment
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@patch("hud.cli.push.get_docker_username", return_value="tester")
+@patch(
+    "hud.cli.push.get_docker_image_labels",
+    return_value={"org.hud.manifest.head": "abc", "org.hud.version": "0.1.0"},
+)
+@patch("hud.cli.push.requests.post")
+@patch("hud.cli.push.subprocess.Popen")
+@patch("hud.cli.push.subprocess.run")
+def test_push_happy_path(
+    mock_run, mock_popen, mock_post, _labels, _user, tmp_path: Path, monkeypatch
+):
+    # Prepare minimal environment with lock file
+    env_dir = tmp_path
+    (env_dir / "hud.lock.yaml").write_text(
+        "images:\n  local: org/env:latest\nbuild:\n  version: 0.1.0\n"
+    )
+
+    # Provide API key via main settings module
+    monkeypatch.setattr("hud.settings.settings.api_key", "sk-test", raising=False)
+
+    # ensure_built noop - patch from the right module
+    monkeypatch.setattr("hud.cli.utils.env_check.ensure_built", lambda *_a, **_k: {})
+
+    # Mock subprocess.run behavior depending on command
+    def run_side_effect(args, *a, **k):
+        cmd = list(args)
+        # docker inspect checks
+        if cmd[:2] == ["docker", "inspect"]:
+            # For label digest query at end
+            if "--format" in cmd and "{{index .RepoDigests 0}}" in cmd:
+                return SimpleNamespace(returncode=0, stdout="org/env@sha256:deadbeef")
+            # Existence checks succeed
+            return SimpleNamespace(returncode=0, stdout="")
+        # docker tag success
+        if cmd[:2] == ["docker", "tag"]:
+            return SimpleNamespace(returncode=0, stdout="")
+        return SimpleNamespace(returncode=0, stdout="")
+
+    mock_run.side_effect = run_side_effect
+
+    # Mock Popen push pipeline
+    class _Proc:
+        def __init__(self):
+            self.stdout = ["digest: sha256:deadbeef\n", "pushed\n"]
+            self.returncode = 0
+
+        def wait(self):
+            return 0
+
+    mock_popen.return_value = _Proc()
+
+    # Mock registry POST success
+    mock_post.return_value = SimpleNamespace(status_code=201, json=lambda: {"ok": True}, text="")
+
+    # Execute
+    push_environment(
+        directory=str(env_dir), image=None, tag=None, sign=False, yes=True, verbose=False
+    )
+
+    # Lock file updated with pushed entry
+    data = (env_dir / "hud.lock.yaml").read_text()
+    assert "pushed:" in data

hud/cli/tests/test_push_wrapper.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from unittest.mock import patch
+
+import pytest
+import typer
+
+from hud.cli.push import push_environment
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@patch("hud.cli.push.ensure_built")
+@patch("hud.cli.push.HUDConsole")
+@patch("hud.cli.push.subprocess.run")
+def test_push_environment_missing_lock_raises(mock_run, mock_console, _ensure, tmp_path: Path):
+    # No hud.lock.yaml → Exit(1)
+    with pytest.raises(typer.Exit):
+        push_environment(
+            directory=str(tmp_path), image=None, tag=None, sign=False, yes=True, verbose=False
+        )