hud-python 0.3.5__py3-none-any.whl → 0.4.0__py3-none-any.whl

hud/cli/tests/test_cli_init.py

@@ -0,0 +1,265 @@
+"""Tests for hud.cli.__init__ module."""
+
+from __future__ import annotations
+
+import json
+import logging
+import tempfile
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+from typer.testing import CliRunner
+
+from hud.cli import app, main
+
+runner = CliRunner()
+
+logger = logging.getLogger(__name__)
+
+
+class TestCLICommands:
+    """Test CLI command handling."""
+
+    def test_main_shows_help_when_no_args(self) -> None:
+        """Test that main() shows help when no arguments provided."""
+        result = runner.invoke(app)
+        # When no args, typer shows help but exits with code 2 (usage error)
+        assert result.exit_code == 2
+        assert "Usage:" in result.output
+
+    def test_analyze_docker_image(self) -> None:
+        """Test analyze command with Docker image."""
+        with patch("hud.cli.asyncio.run") as mock_run:
+            result = runner.invoke(app, ["analyze", "test-image:latest"])
+            assert result.exit_code == 0
+            mock_run.assert_called_once()
+            # Get the coroutine that was passed to asyncio.run
+            coro = mock_run.call_args[0][0]
+            assert coro.__name__ == "analyze_from_metadata"
+
+    def test_analyze_with_docker_args(self) -> None:
+        """Test analyze command with additional Docker arguments."""
+        with patch("hud.cli.asyncio.run") as mock_run:
+            # Docker args need to come after -- to avoid being parsed as CLI options
+            result = runner.invoke(
+                app, ["analyze", "test-image", "--", "-e", "KEY=value", "-p", "8080:8080"]
+            )
+            assert result.exit_code == 0
+            mock_run.assert_called_once()
+
+    def test_analyze_with_config_file(self) -> None:
+        """Test analyze command with config file."""
+        import os
+
+        fd, temp_path = tempfile.mkstemp(suffix=".json")
+        try:
+            with os.fdopen(fd, "w") as f:
+                json.dump({"test": {"command": "python", "args": ["server.py"]}}, f)
+
+            with patch("hud.cli.asyncio.run") as mock_run:
+                # Need to provide a dummy positional arg since params is required
+                result = runner.invoke(app, ["analyze", "dummy", "--config", temp_path])
+                assert result.exit_code == 0
+                mock_run.assert_called_once()
+                coro = mock_run.call_args[0][0]
+                assert coro.__name__ == "analyze_environment_from_config"
+        finally:
+            try:
+                os.unlink(temp_path)
+            except Exception:
+                logger.exception("Error deleting temp file")
+
+    def test_analyze_with_cursor_server(self) -> None:
+        """Test analyze command with Cursor server."""
+        with patch("hud.cli.parse_cursor_config") as mock_parse:
+            mock_parse.return_value = (["python", "server.py"], None)
+            with patch("hud.cli.asyncio.run") as mock_run:
+                # Need to provide a dummy positional arg since params is required
+                result = runner.invoke(app, ["analyze", "dummy", "--cursor", "test-server"])
+                assert result.exit_code == 0
+                mock_run.assert_called_once()
+
+    def test_analyze_cursor_server_not_found(self) -> None:
+        """Test analyze with non-existent Cursor server."""
+        with patch("hud.cli.parse_cursor_config") as mock_parse:
+            mock_parse.return_value = (None, "Server 'test' not found")
+            result = runner.invoke(app, ["analyze", "--cursor", "test"])
+            assert result.exit_code == 1
+            assert "Server 'test' not found" in result.output
+
+    def test_analyze_no_arguments_shows_error(self) -> None:
+        """Test analyze without arguments shows error."""
+        result = runner.invoke(app, ["analyze"])
+        assert result.exit_code == 1
+        assert "Error" in result.output
+
+    def test_analyze_output_formats(self) -> None:
+        """Test analyze with different output formats."""
+        for format_type in ["interactive", "json", "markdown"]:
+            with patch("hud.cli.asyncio.run"):
+                result = runner.invoke(app, ["analyze", "test-image", "--format", format_type])
+                assert result.exit_code == 0
+
+    def test_debug_docker_image(self) -> None:
+        """Test debug command with Docker image."""
+        with patch("hud.cli.asyncio.run") as mock_run:
+            mock_run.return_value = 5  # All phases completed
+            result = runner.invoke(app, ["debug", "test-image:latest"])
+            assert result.exit_code == 0
+            mock_run.assert_called_once()
+
+    def test_debug_with_max_phase(self) -> None:
+        """Test debug command with max phase limit."""
+        with patch("hud.cli.asyncio.run") as mock_run:
+            mock_run.return_value = 3  # Completed 3 phases
+            result = runner.invoke(app, ["debug", "test-image", "--max-phase", "3"])
+            assert result.exit_code == 0  # Exit code 0 when phases_completed == max_phase
+
+    def test_debug_with_config_file(self) -> None:
+        """Test debug command with config file."""
+        import os
+
+        fd, temp_path = tempfile.mkstemp(suffix=".json")
+        try:
+            with os.fdopen(fd, "w") as f:
+                json.dump({"test": {"command": "python", "args": ["server.py"]}}, f)
+
+            with patch("hud.cli.asyncio.run") as mock_run:
+                mock_run.return_value = 5
+                # Need to provide a dummy positional arg since params is required
+                result = runner.invoke(app, ["debug", "dummy", "--config", temp_path])
+                assert result.exit_code == 0
+        finally:
+            try:
+                os.unlink(temp_path)
+            except Exception:
+                logger.exception("Error deleting temp file")
+
+    def test_debug_with_cursor_server(self) -> None:
+        """Test debug command with Cursor server."""
+        with patch("hud.cli.parse_cursor_config") as mock_parse:
+            mock_parse.return_value = (["python", "server.py"], None)
+            with patch("hud.cli.asyncio.run") as mock_run:
+                mock_run.return_value = 5
+                # Need to provide a dummy positional arg since params is required
+                result = runner.invoke(app, ["debug", "dummy", "--cursor", "test-server"])
+                assert result.exit_code == 0
+
+    def test_debug_no_arguments_shows_error(self) -> None:
+        """Test debug without arguments shows error."""
+        result = runner.invoke(app, ["debug"])
+        assert result.exit_code == 1
+        assert "Error" in result.output
+
+    def test_cursor_list_command(self) -> None:
+        """Test cursor-list command."""
+        with patch("hud.cli.list_cursor_servers") as mock_list:
+            mock_list.return_value = (["server1", "server2"], None)
+            with patch("hud.cli.get_cursor_config_path") as mock_path:
+                mock_path.return_value = Path("/home/user/.cursor/mcp.json")
+                with patch("pathlib.Path.exists") as mock_exists:
+                    mock_exists.return_value = True
+                    with patch("builtins.open", create=True) as mock_open:
+                        mock_open.return_value.__enter__.return_value.read.return_value = (
+                            json.dumps(
+                                {
+                                    "mcpServers": {
+                                        "server1": {"command": "python", "args": ["srv1.py"]},
+                                        "server2": {"command": "node", "args": ["srv2.js"]},
+                                    }
+                                }
+                            )
+                        )
+                        result = runner.invoke(app, ["cursor-list"])
+                        assert result.exit_code == 0
+                        assert "Available Servers" in result.output
+
+    def test_cursor_list_no_servers(self) -> None:
+        """Test cursor-list with no servers."""
+        with patch("hud.cli.list_cursor_servers") as mock_list:
+            mock_list.return_value = ([], None)
+            result = runner.invoke(app, ["cursor-list"])
+            assert result.exit_code == 0
+            assert "No servers found" in result.output
+
+    def test_cursor_list_error(self) -> None:
+        """Test cursor-list with error."""
+        with patch("hud.cli.list_cursor_servers") as mock_list:
+            mock_list.return_value = (None, "Config not found")
+            result = runner.invoke(app, ["cursor-list"])
+            assert result.exit_code == 1
+            assert "Config not found" in result.output
+
+    def test_version_command(self) -> None:
+        """Test version command."""
+        with patch("hud.__version__", "1.2.3"):
+            result = runner.invoke(app, ["version"])
+            assert result.exit_code == 0
+            assert "1.2.3" in result.output
+
+    def test_version_import_error(self) -> None:
+        """Test version command when version unavailable."""
+        # Patch the specific import of __version__ from hud
+        with patch.dict("sys.modules", {"hud": None}):
+            result = runner.invoke(app, ["version"])
+            assert result.exit_code == 0
+            assert "HUD CLI version: unknown" in result.output
+
+    def test_mcp_command(self) -> None:
+        """Test mcp server command."""
+        # MCP command has been removed from the CLI
+        result = runner.invoke(app, ["mcp"])
+        assert result.exit_code == 2  # Command not found
+
+    def test_help_command(self) -> None:
+        """Test help command shows proper info."""
+        result = runner.invoke(app, ["--help"])
+        assert result.exit_code == 0
+        assert "HUD CLI for MCP environment analysis" in result.output
+        assert "analyze" in result.output
+        assert "debug" in result.output
+        # assert "mcp" in result.output  # mcp command has been removed
+
+
+class TestMainFunction:
+    """Test the main() function specifically."""
+
+    def test_main_with_help_flag(self) -> None:
+        """Test main() with --help flag."""
+        import sys
+
+        original_argv = sys.argv
+        try:
+            sys.argv = ["hud", "--help"]
+            with (
+                patch("hud.cli.console") as mock_console,
+                patch("hud.cli.app") as mock_app,
+            ):
+                main()
+                # Should print the header panel
+                # Check that either console was used or app was called
+                assert mock_console.print.called or mock_app.called
+        finally:
+            sys.argv = original_argv
+
+    def test_main_with_no_args(self) -> None:
+        """Test main() with no arguments."""
+        import sys
+
+        original_argv = sys.argv
+        try:
+            sys.argv = ["hud"]
+            with patch("hud.cli.console") as mock_console:
+                with pytest.raises(SystemExit) as exc_info:
+                    main()
+                # Should exit with code 2 (missing command)
+                assert exc_info.value.code == 2
+                # Should print Quick Start guide before exiting
+                assert any("Quick Start" in str(call) for call in mock_console.print.call_args_list)
+        finally:
+            sys.argv = original_argv
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])

hud/cli/tests/test_cli_main.py

@@ -0,0 +1,27 @@
+"""Tests for hud.cli.__main__ module."""
+
+from __future__ import annotations
+
+import pytest
+
+
+class TestCLIMain:
+    """Test the __main__ module."""
+
+    def test_main_module_exists(self) -> None:
+        """Test that __main__.py exists and can be imported."""
+        # Just verify the module can be imported
+        import hud.cli.__main__
+
+        assert hud.cli.__main__ is not None
+
+    def test_main_module_has_main_import(self) -> None:
+        """Test that __main__.py imports main from the package."""
+        import hud.cli.__main__
+
+        # The module should have imported main
+        assert hasattr(hud.cli.__main__, "main")
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])

hud/cli/tests/test_clone.py

@@ -0,0 +1,142 @@
+"""Tests for the clone command."""
+
+from __future__ import annotations
+
+import subprocess
+from unittest.mock import MagicMock, mock_open, patch
+
+from hud.cli.clone import clone_repository, get_clone_message
+
+
+def test_clone_repository_success():
+    """Test successful repository cloning."""
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+
+        success, result = clone_repository("https://github.com/user/repo.git")
+
+        assert success is True
+        assert "repo" in result
+        mock_run.assert_called_once()
+
+        # Check command includes quiet flag
+        cmd = mock_run.call_args[0][0]
+        assert "git" in cmd
+        assert "clone" in cmd
+        assert "--quiet" in cmd
+        assert "https://github.com/user/repo.git" in cmd
+
+
+def test_clone_repository_failure():
+    """Test failed repository cloning."""
+    with patch("subprocess.run") as mock_run:
+        mock_run.side_effect = subprocess.CalledProcessError(
+            128, ["git", "clone"], stderr="fatal: repository not found"
+        )
+
+        success, result = clone_repository("https://github.com/user/nonexistent.git")
+
+        assert success is False
+        assert "repository not found" in result
+
+
+def test_get_clone_message_from_pyproject():
+    """Test reading clone message from pyproject.toml."""
+    toml_content = """
+[tool.hud.clone]
+title = "Test Project"
+message = "Welcome to the test project!"
+"""
+
+    with (
+        patch("pathlib.Path.exists") as mock_exists,
+        patch("builtins.open", mock_open(read_data=toml_content.encode())),
+        patch("tomllib.load") as mock_load,
+    ):
+        mock_exists.return_value = True
+        mock_load.return_value = {
+            "tool": {
+                "hud": {
+                    "clone": {"title": "Test Project", "message": "Welcome to the test project!"}
+                }
+            }
+        }
+
+        config = get_clone_message("/path/to/repo")
+
+        assert config is not None
+        assert config["title"] == "Test Project"
+        assert config["message"] == "Welcome to the test project!"
+
+
+def test_get_clone_message_from_hud_toml():
+    """Test reading clone message from .hud.toml."""
+    toml_content = """
+[clone]
+title = "HUD Project"
+markdown = "## Welcome!"
+style = "cyan"
+"""
+
+    with (
+        patch("pathlib.Path.exists") as mock_exists,
+        patch("builtins.open", mock_open(read_data=toml_content.encode())),
+        patch("tomllib.load") as mock_load,
+    ):
+        # First call for pyproject.toml returns False
+        # Second call for .hud.toml returns True
+        mock_exists.side_effect = [False, True]
+        mock_load.return_value = {
+            "clone": {"title": "HUD Project", "markdown": "## Welcome!", "style": "cyan"}
+        }
+
+        config = get_clone_message("/path/to/repo")
+
+        assert config is not None
+        assert config["title"] == "HUD Project"
+        assert config["markdown"] == "## Welcome!"
+        assert config["style"] == "cyan"
+
+
+def test_get_clone_message_none():
+    """Test when no clone message configuration exists."""
+    with patch("pathlib.Path.exists") as mock_exists:
+        mock_exists.return_value = False
+
+        config = get_clone_message("/path/to/repo")
+
+        assert config is None
+
+
+# The following tests are commented out as print_success and print_error
+# functions are no longer part of the clone module
+
+# def test_print_success(capsys):
+#     """Test success message printing."""
+#     print_success("https://github.com/user/repo.git", "/home/user/repo")
+
+#     captured = capsys.readouterr()
+#     assert "Successfully cloned" in captured.out
+#     assert "repo" in captured.out
+#     assert "/home/user/repo" in captured.out
+
+
+# def test_print_success_with_config(capsys):
+#     """Test success message with configuration."""
+#     config = {"title": "My Project", "message": "Thanks for cloning!"}
+
+#     print_success("https://github.com/user/repo.git", "/home/user/repo", config)
+
+#     captured = capsys.readouterr()
+#     assert "Successfully cloned" in captured.out
+#     assert "My Project" in captured.out
+#     assert "Thanks for cloning!" in captured.out
+
+
+# def test_print_error(capsys):
+#     """Test error message printing."""
+#     print_error("Repository not found")
+
+#     captured = capsys.readouterr()
+#     assert "Repository not found" in captured.out
+#     assert "Clone Failed" in captured.out

hud/cli/tests/test_cursor.py

@@ -0,0 +1,253 @@
+"""Tests for hud.cli.cursor module."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from unittest.mock import mock_open, patch
+
+import pytest
+
+from hud.cli.cursor import get_cursor_config_path, list_cursor_servers, parse_cursor_config
+
+
+class TestParseCursorConfig:
+    """Test Cursor config parsing."""
+
+    def test_parse_cursor_config_success(self) -> None:
+        """Test successful parsing of Cursor config."""
+        config_data = {
+            "mcpServers": {
+                "test-server": {
+                    "command": "python",
+                    "args": ["server.py", "--port", "8080"],
+                    "env": {"KEY": "value"},
+                }
+            }
+        }
+
+        with (
+            patch("pathlib.Path.exists", return_value=True),
+            patch("builtins.open", mock_open(read_data=json.dumps(config_data))),
+        ):
+            command, error = parse_cursor_config("test-server")
+            assert error is None
+            assert command == ["python", "server.py", "--port", "8080"]
+
+    def test_parse_cursor_config_not_found(self) -> None:
+        """Test parsing when config file doesn't exist."""
+        with patch("pathlib.Path.exists", return_value=False):
+            command, error = parse_cursor_config("test-server")
+            assert command is None
+            assert error is not None
+            assert "Cursor config not found" in error
+
+    def test_parse_cursor_config_server_not_found(self) -> None:
+        """Test parsing when server doesn't exist in config."""
+        config_data = {"mcpServers": {"other-server": {"command": "node", "args": ["server.js"]}}}
+
+        with (
+            patch("pathlib.Path.exists", return_value=True),
+            patch("builtins.open", mock_open(read_data=json.dumps(config_data))),
+        ):
+            command, error = parse_cursor_config("test-server")
+            assert command is None
+            assert error is not None
+            assert "Server 'test-server' not found" in error
+            assert "Available: other-server" in error
+
+    def test_parse_cursor_config_reloaderoo(self) -> None:
+        """Test parsing config with reloaderoo wrapper."""
+        config_data = {
+            "mcpServers": {
+                "test-server": {
+                    "command": "npx",
+                    "args": ["reloaderoo", "--watch", "src", "--", "python", "server.py"],
+                }
+            }
+        }
+
+        with (
+            patch("pathlib.Path.exists", return_value=True),
+            patch("builtins.open", mock_open(read_data=json.dumps(config_data))),
+        ):
+            command, error = parse_cursor_config("test-server")
+            assert error is None
+            # Should extract command after --
+            assert command == ["python", "server.py"]
+
+    def test_parse_cursor_config_reloaderoo_no_dash(self) -> None:
+        """Test parsing reloaderoo without -- separator."""
+        config_data = {
+            "mcpServers": {
+                "test-server": {"command": "npx", "args": ["reloaderoo", "python", "server.py"]}
+            }
+        }
+
+        with (
+            patch("pathlib.Path.exists", return_value=True),
+            patch("builtins.open", mock_open(read_data=json.dumps(config_data))),
+        ):
+            command, error = parse_cursor_config("test-server")
+            assert error is None
+            # Should return full command since no -- found
+            assert command == ["npx", "reloaderoo", "python", "server.py"]
+
+    def test_parse_cursor_config_windows_path(self) -> None:
+        """Test parsing with Windows user profile path."""
+        config_data = {"mcpServers": {"test": {"command": "cmd"}}}
+
+        # First path doesn't exist, try Windows path
+        with (
+            patch("pathlib.Path.exists", side_effect=[False, True]),
+            patch.dict(os.environ, {"USERPROFILE": "C:\\Users\\Test"}),
+            patch("builtins.open", mock_open(read_data=json.dumps(config_data))),
+        ):
+            command, error = parse_cursor_config("test")
+            assert error is None
+            assert command == ["cmd"]
+
+    def test_parse_cursor_config_json_error(self) -> None:
+        """Test parsing with invalid JSON."""
+        with (
+            patch("pathlib.Path.exists", return_value=True),
+            patch("builtins.open", mock_open(read_data="invalid json")),
+        ):
+            command, error = parse_cursor_config("test-server")
+            assert command is None
+            assert error is not None
+            assert "Error reading config" in error
+
+    def test_parse_cursor_config_no_command(self) -> None:
+        """Test parsing server with no command."""
+        config_data = {"mcpServers": {"test-server": {"args": ["--port", "8080"]}}}
+
+        with (
+            patch("pathlib.Path.exists", return_value=True),
+            patch("builtins.open", mock_open(read_data=json.dumps(config_data))),
+        ):
+            command, error = parse_cursor_config("test-server")
+            assert error is None
+            assert command == ["", "--port", "8080"]  # Empty command
+
+
+class TestListCursorServers:
+    """Test listing Cursor servers."""
+
+    def test_list_cursor_servers_success(self) -> None:
+        """Test successful listing of servers."""
+        config_data = {
+            "mcpServers": {
+                "server1": {"command": "python"},
+                "server2": {"command": "node"},
+                "server3": {"command": "ruby"},
+            }
+        }
+
+        with (
+            patch("pathlib.Path.exists", return_value=True),
+            patch("builtins.open", mock_open(read_data=json.dumps(config_data))),
+        ):
+            servers, error = list_cursor_servers()
+            assert error is None
+            assert servers == ["server1", "server2", "server3"]
+
+    def test_list_cursor_servers_empty(self) -> None:
+        """Test listing when no servers configured."""
+        config_data = {"mcpServers": {}}
+
+        with (
+            patch("pathlib.Path.exists", return_value=True),
+            patch("builtins.open", mock_open(read_data=json.dumps(config_data))),
+        ):
+            servers, error = list_cursor_servers()
+            assert error is None
+            assert servers == []
+
+    def test_list_cursor_servers_no_mcp_section(self) -> None:
+        """Test listing when mcpServers section missing."""
+        config_data = {"otherConfig": {}}
+
+        with (
+            patch("pathlib.Path.exists", return_value=True),
+            patch("builtins.open", mock_open(read_data=json.dumps(config_data))),
+        ):
+            servers, error = list_cursor_servers()
+            assert error is None
+            assert servers == []
+
+    def test_list_cursor_servers_file_not_found(self) -> None:
+        """Test listing when config file doesn't exist."""
+        with patch("pathlib.Path.exists", return_value=False):
+            servers, error = list_cursor_servers()
+            assert servers is None
+            assert error is not None
+            assert "Cursor config not found" in error
+
+    def test_list_cursor_servers_windows_path(self) -> None:
+        """Test listing with Windows path fallback."""
+        config_data = {"mcpServers": {"winserver": {"command": "cmd"}}}
+
+        # First path doesn't exist, second (Windows) does
+        with (
+            patch("pathlib.Path.exists", side_effect=[False, True]),
+            patch.dict(os.environ, {"USERPROFILE": "C:\\Users\\Test"}),
+            patch("builtins.open", mock_open(read_data=json.dumps(config_data))),
+        ):
+            servers, error = list_cursor_servers()
+            assert error is None
+            assert servers == ["winserver"]
+
+    def test_list_cursor_servers_read_error(self) -> None:
+        """Test listing with file read error."""
+        with (
+            patch("pathlib.Path.exists", return_value=True),
+            patch("builtins.open", side_effect=PermissionError("Access denied")),
+        ):
+            servers, error = list_cursor_servers()
+            assert servers is None
+            assert error is not None
+            assert "Error reading config" in error
+            assert "Access denied" in error
+
+
+class TestGetCursorConfigPath:
+    """Test getting Cursor config path."""
+
+    def test_get_cursor_config_path_unix(self) -> None:
+        """Test getting config path on Unix-like systems."""
+        with (
+            patch("pathlib.Path.home", return_value=Path("/home/user")),
+            patch("pathlib.Path.exists", return_value=True),
+        ):
+            path = get_cursor_config_path()
+            assert str(path) == str(Path("/home/user/.cursor/mcp.json"))
+
+    def test_get_cursor_config_path_windows(self) -> None:
+        """Test getting config path on Windows."""
+        with (
+            patch("pathlib.Path.home", return_value=Path("/home/user")),
+            patch("pathlib.Path.exists", return_value=False),
+            patch.dict(os.environ, {"USERPROFILE": "C:\\Users\\Test"}),
+        ):
+            path = get_cursor_config_path()
+            assert "Test" in str(path)
+            assert ".cursor" in str(path)
+            assert "mcp.json" in str(path)
+
+    def test_get_cursor_config_path_no_userprofile(self) -> None:
+        """Test getting config path when USERPROFILE not set."""
+        with (
+            patch("pathlib.Path.home", return_value=Path("/home/user")),
+            patch("pathlib.Path.exists", return_value=False),
+            patch.dict(os.environ, {}, clear=True),
+        ):
+            path = get_cursor_config_path()
+            # Should still return something based on empty USERPROFILE
+            assert ".cursor" in str(path)
+            assert "mcp.json" in str(path)
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])