hud-python 0.4.10__py3-none-any.whl → 0.4.12__py3-none-any.whl

hud/cli/tests/test_build.py

@@ -3,9 +3,6 @@
 from __future__ import annotations
 
 import subprocess
-import tempfile
-from datetime import datetime
-from pathlib import Path
 from unittest import mock
 
 import pytest
@@ -81,11 +78,7 @@ class TestGetExistingVersion:
 
     def test_get_version_from_lock(self, tmp_path):
         """Test extracting version from lock file."""
-        lock_data = {
-            "build": {
-                "version": "1.2.3"
-            }
-        }
+        lock_data = {"build": {"version": "1.2.3"}}
         lock_path = tmp_path / "hud.lock.yaml"
         lock_path.write_text(yaml.dump(lock_data))
 
@@ -119,8 +112,7 @@ class TestGetDockerImageDigest:
         """Test successfully getting image digest."""
         # Note: The function expects to parse a list from the string representation
         mock_run.return_value = mock.Mock(
-            stdout="['docker.io/library/test@sha256:abc123']",
-            returncode=0
+            stdout="['docker.io/library/test@sha256:abc123']", returncode=0
         )
 
         result = get_docker_image_digest("test:latest")
@@ -149,10 +141,7 @@ class TestGetDockerImageId:
     @mock.patch("subprocess.run")
     def test_get_id_success(self, mock_run):
         """Test successfully getting image ID."""
-        mock_run.return_value = mock.Mock(
-            stdout="sha256:abc123def456",
-            returncode=0
-        )
+        mock_run.return_value = mock.Mock(stdout="sha256:abc123def456", returncode=0)
 
         result = get_docker_image_id("test:latest")
         assert result == "sha256:abc123def456"
@@ -223,13 +212,13 @@ class TestAnalyzeMcpEnvironment:
         # Setup mock client
         mock_client = mock.AsyncMock()
         mock_client_class.return_value = mock_client
-        
+
         # Mock tool
         mock_tool = mock.Mock()
         mock_tool.name = "test_tool"
         mock_tool.description = "Test tool"
         mock_tool.inputSchema = {"type": "object"}
-        
+
         mock_client.list_tools.return_value = [mock_tool]
 
         result = await analyze_mcp_environment("test:latest")
@@ -264,7 +253,7 @@ class TestAnalyzeMcpEnvironment:
 
         # Just test that it runs without error in verbose mode
         result = await analyze_mcp_environment("test:latest", verbose=True)
-        
+
         assert result["success"] is True
         assert "initializeMs" in result
 
@@ -272,35 +261,31 @@ class TestAnalyzeMcpEnvironment:
 class TestBuildDockerImage:
     """Test building Docker images."""
 
-    @mock.patch("subprocess.Popen")
-    def test_build_success(self, mock_popen, tmp_path):
+    @mock.patch("subprocess.run")
+    def test_build_success(self, mock_run, tmp_path):
         """Test successful Docker build."""
         # Create Dockerfile
         dockerfile = tmp_path / "Dockerfile"
         dockerfile.write_text("FROM python:3.11")
 
         # Mock successful process
-        mock_process = mock.Mock()
-        mock_process.stdout = ["Step 1/1 : FROM python:3.11\n", "Successfully built abc123\n"]
-        mock_process.wait.return_value = None
-        mock_process.returncode = 0
-        mock_popen.return_value = mock_process
+        mock_result = mock.Mock()
+        mock_result.returncode = 0
+        mock_run.return_value = mock_result
 
         result = build_docker_image(tmp_path, "test:latest")
         assert result is True
 
-    @mock.patch("subprocess.Popen")
-    def test_build_failure(self, mock_popen, tmp_path):
+    @mock.patch("subprocess.run")
+    def test_build_failure(self, mock_run, tmp_path):
         """Test failed Docker build."""
         dockerfile = tmp_path / "Dockerfile"
         dockerfile.write_text("FROM python:3.11")
 
         # Mock failed process
-        mock_process = mock.Mock()
-        mock_process.stdout = ["Error: failed to build\n"]
-        mock_process.wait.return_value = None
-        mock_process.returncode = 1
-        mock_popen.return_value = mock_process
+        mock_result = mock.Mock()
+        mock_result.returncode = 1
+        mock_run.return_value = mock_result
 
         result = build_docker_image(tmp_path, "test:latest")
         assert result is False
@@ -310,22 +295,20 @@ class TestBuildDockerImage:
         result = build_docker_image(tmp_path, "test:latest")
         assert result is False
 
-    @mock.patch("subprocess.Popen")
-    def test_build_with_no_cache(self, mock_popen, tmp_path):
+    @mock.patch("subprocess.run")
+    def test_build_with_no_cache(self, mock_run, tmp_path):
         """Test build with --no-cache flag."""
         dockerfile = tmp_path / "Dockerfile"
         dockerfile.write_text("FROM python:3.11")
 
-        mock_process = mock.Mock()
-        mock_process.stdout = []
-        mock_process.wait.return_value = None
-        mock_process.returncode = 0
-        mock_popen.return_value = mock_process
+        mock_result = mock.Mock()
+        mock_result.returncode = 0
+        mock_run.return_value = mock_result
 
         build_docker_image(tmp_path, "test:latest", no_cache=True)
 
         # Check that --no-cache was included
-        call_args = mock_popen.call_args[0][0]
+        call_args = mock_run.call_args[0][0]
         assert "--no-cache" in call_args
 
 
@@ -336,12 +319,10 @@ class TestBuildEnvironment:
     @mock.patch("hud.cli.build.analyze_mcp_environment")
     @mock.patch("hud.cli.build.save_to_registry")
     @mock.patch("hud.cli.build.get_docker_image_id")
-    @mock.patch("subprocess.Popen")
     @mock.patch("subprocess.run")
     def test_build_environment_success(
         self,
         mock_run,
-        mock_popen,
         mock_get_id,
         mock_save_registry,
         mock_analyze,
@@ -352,14 +333,14 @@ class TestBuildEnvironment:
         # Setup directory structure
         env_dir = tmp_path / "test-env"
         env_dir.mkdir()
-        
+
         # Create pyproject.toml
         pyproject = env_dir / "pyproject.toml"
         pyproject.write_text("""
 [tool.hud]
 image = "test/env:dev"
 """)
-        
+
         # Create Dockerfile
         dockerfile = env_dir / "Dockerfile"
         dockerfile.write_text("""
@@ -379,16 +360,11 @@ ENV API_KEY
             ],
         }
         mock_get_id.return_value = "sha256:abc123"
-        
+
         # Mock final rebuild
-        mock_process = mock.Mock()
-        # Create a mock file-like object with read method
-        mock_stdout = mock.Mock()
-        mock_stdout.read.return_value = ""
-        mock_process.stdout = mock_stdout
-        mock_process.wait.return_value = None
-        mock_process.returncode = 0
-        mock_popen.return_value = mock_process
+        mock_result = mock.Mock()
+        mock_result.returncode = 0
+        mock_run.return_value = mock_result
 
         # Run build
         build_environment(str(env_dir), "test/env:latest")

hud/cli/tests/test_cursor.py

@@ -9,7 +9,7 @@ from unittest.mock import mock_open, patch
 
 import pytest
 
-from hud.cli.cursor import get_cursor_config_path, list_cursor_servers, parse_cursor_config
+from hud.cli.utils.cursor import get_cursor_config_path, list_cursor_servers, parse_cursor_config
 
 
 class TestParseCursorConfig:

hud/cli/tests/test_debug.py

@@ -8,7 +8,7 @@ from unittest.mock import AsyncMock, MagicMock, Mock, patch
 import pytest
 
 from hud.cli.debug import debug_mcp_stdio
-from hud.cli.utils import CaptureLogger
+from hud.cli.utils.logging import CaptureLogger
 
 
 class TestDebugMCPStdio:

hud/cli/tests/test_list_func.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import json
-import tempfile
 import time
 from datetime import datetime, timedelta
 from pathlib import Path
@@ -12,7 +11,7 @@ from unittest import mock
 import pytest
 import yaml
 
-from hud.cli.list_func import format_timestamp, list_environments, list_command
+from hud.cli.list_func import format_timestamp, list_command, list_environments
 
 
 class TestFormatTimestamp:
@@ -26,11 +25,11 @@ class TestFormatTimestamp:
     def test_format_timestamp_minutes(self):
         """Test formatting for timestamps in minutes."""
         now = datetime.now()
-        
+
         # 5 minutes ago
         timestamp = (now - timedelta(minutes=5)).timestamp()
         assert format_timestamp(timestamp) == "5m ago"
-        
+
         # 45 minutes ago
         timestamp = (now - timedelta(minutes=45)).timestamp()
         assert format_timestamp(timestamp) == "45m ago"
@@ -38,11 +37,11 @@ class TestFormatTimestamp:
     def test_format_timestamp_hours(self):
         """Test formatting for timestamps in hours."""
         now = datetime.now()
-        
+
         # 2 hours ago
         timestamp = (now - timedelta(hours=2)).timestamp()
         assert format_timestamp(timestamp) == "2h ago"
-        
+
         # 23 hours ago
         timestamp = (now - timedelta(hours=23)).timestamp()
         assert format_timestamp(timestamp) == "23h ago"
@@ -50,11 +49,11 @@ class TestFormatTimestamp:
     def test_format_timestamp_days(self):
         """Test formatting for timestamps in days."""
         now = datetime.now()
-        
+
         # 3 days ago
         timestamp = (now - timedelta(days=3)).timestamp()
         assert format_timestamp(timestamp) == "3d ago"
-        
+
         # 29 days ago
         timestamp = (now - timedelta(days=29)).timestamp()
         assert format_timestamp(timestamp) == "29d ago"
@@ -62,11 +61,11 @@ class TestFormatTimestamp:
     def test_format_timestamp_months(self):
         """Test formatting for timestamps in months."""
         now = datetime.now()
-        
+
         # 2 months ago
         timestamp = (now - timedelta(days=60)).timestamp()
         assert format_timestamp(timestamp) == "2mo ago"
-        
+
         # 11 months ago
         timestamp = (now - timedelta(days=335)).timestamp()
         assert format_timestamp(timestamp) == "11mo ago"
@@ -74,11 +73,11 @@ class TestFormatTimestamp:
     def test_format_timestamp_years(self):
         """Test formatting for timestamps in years."""
         now = datetime.now()
-        
+
         # 1 year ago
         timestamp = (now - timedelta(days=400)).timestamp()
         assert format_timestamp(timestamp) == "1y ago"
-        
+
         # 3 years ago
         timestamp = (now - timedelta(days=1100)).timestamp()
         assert format_timestamp(timestamp) == "3y ago"
@@ -96,52 +95,59 @@ class TestListEnvironments:
         """Create a mock registry directory with sample environments."""
         registry_dir = tmp_path / ".hud" / "envs"
         registry_dir.mkdir(parents=True)
-        
+
         # Create sample environments (use underscore instead of colon for Windows compatibility)
         env1_dir = registry_dir / "sha256_abc123"
         env1_dir.mkdir()
         lock1 = env1_dir / "hud.lock.yaml"
-        lock1.write_text(yaml.dump({
-            "image": "test/env1:latest",
-            "metadata": {
-                "description": "Test environment 1",
-                "tools": ["tool1", "tool2", "tool3"]
-            }
-        }))
+        lock1.write_text(
+            yaml.dump(
+                {
+                    "image": "test/env1:latest",
+                    "metadata": {
+                        "description": "Test environment 1",
+                        "tools": ["tool1", "tool2", "tool3"],
+                    },
+                }
+            )
+        )
         # Set modification time to 1 hour ago
-        old_time = time.time() - 3600
         lock1.touch()
-        
+
         env2_dir = registry_dir / "sha256_def456"
         env2_dir.mkdir()
         lock2 = env2_dir / "hud.lock.yaml"
-        lock2.write_text(yaml.dump({
-            "image": "test/env2:v1.0",
-            "metadata": {
-                "description": "Test environment 2 with a much longer description that should be truncated",
-                "tools": ["tool1"]
-            }
-        }))
-        
+        lock2.write_text(
+            yaml.dump(
+                {
+                    "image": "test/env2:v1.0",
+                    "metadata": {
+                        "description": "Test environment 2 with a much longer description that should be truncated",  # noqa: E501
+                        "tools": ["tool1"],
+                    },
+                }
+            )
+        )
+
         return registry_dir
 
     @mock.patch("hud.cli.list_func.get_registry_dir")
     def test_list_no_registry(self, mock_get_registry):
         """Test listing when registry doesn't exist."""
         mock_get_registry.return_value = Path("/nonexistent")
-        
+
         # Just test it runs without error
         list_environments()
-        
+
         # The design messages will be printed but we don't need to test them
 
     @mock.patch("hud.cli.list_func.get_registry_dir")
     def test_list_json_no_registry(self, mock_get_registry, capsys):
         """Test JSON output when registry doesn't exist."""
         mock_get_registry.return_value = Path("/nonexistent")
-        
+
         list_environments(json_output=True)
-        
+
         captured = capsys.readouterr()
         assert captured.out.strip() == "[]"
 
@@ -150,55 +156,59 @@ class TestListEnvironments:
     def test_list_environments_basic(self, mock_list_entries, mock_get_registry, mock_registry_dir):
         """Test basic environment listing."""
         mock_get_registry.return_value = mock_registry_dir
-        
+
         # Mock registry entries
         entries = [
             ("sha256_abc123", mock_registry_dir / "sha256_abc123" / "hud.lock.yaml"),
             ("sha256_def456", mock_registry_dir / "sha256_def456" / "hud.lock.yaml"),
         ]
         mock_list_entries.return_value = entries
-        
+
         # Just test it runs without error
         list_environments()
 
     @mock.patch("hud.cli.list_func.get_registry_dir")
     @mock.patch("hud.cli.list_func.list_registry_entries")
-    def test_list_environments_json(self, mock_list_entries, mock_get_registry, mock_registry_dir, capsys):
+    def test_list_environments_json(
+        self, mock_list_entries, mock_get_registry, mock_registry_dir, capsys
+    ):
         """Test JSON output format."""
         mock_get_registry.return_value = mock_registry_dir
-        
+
         # Mock registry entries
         entries = [
             ("sha256_abc123", mock_registry_dir / "sha256_abc123" / "hud.lock.yaml"),
             ("sha256_def456", mock_registry_dir / "sha256_def456" / "hud.lock.yaml"),
         ]
         mock_list_entries.return_value = entries
-        
+
         list_environments(json_output=True)
-        
+
         captured = capsys.readouterr()
         data = json.loads(captured.out)
-        
+
         assert len(data) == 2
         # Check we have the expected structure
         assert all(key in data[0] for key in ["name", "tag", "tools_count", "digest"])
 
     @mock.patch("hud.cli.list_func.get_registry_dir")
     @mock.patch("hud.cli.list_func.list_registry_entries")
-    def test_list_environments_filter(self, mock_list_entries, mock_get_registry, mock_registry_dir, capsys):
+    def test_list_environments_filter(
+        self, mock_list_entries, mock_get_registry, mock_registry_dir, capsys
+    ):
         """Test filtering environments by name."""
         mock_get_registry.return_value = mock_registry_dir
-        
+
         # Mock registry entries
         entries = [
             ("sha256_abc123", mock_registry_dir / "sha256_abc123" / "hud.lock.yaml"),
             ("sha256_def456", mock_registry_dir / "sha256_def456" / "hud.lock.yaml"),
         ]
         mock_list_entries.return_value = entries
-        
+
         # Filter for env1 and check JSON output
         list_environments(filter_name="env1", json_output=True)
-        
+
         captured = capsys.readouterr()
         data = json.loads(captured.out)
         # Should only have env1
@@ -207,31 +217,35 @@ class TestListEnvironments:
 
     @mock.patch("hud.cli.list_func.get_registry_dir")
     @mock.patch("hud.cli.list_func.list_registry_entries")
-    def test_list_environments_verbose(self, mock_list_entries, mock_get_registry, mock_registry_dir):
+    def test_list_environments_verbose(
+        self, mock_list_entries, mock_get_registry, mock_registry_dir
+    ):
         """Test verbose output."""
         mock_get_registry.return_value = mock_registry_dir
-        
+
         # Mock registry entries
         entries = [
             ("sha256_abc123", mock_registry_dir / "sha256_abc123" / "hud.lock.yaml"),
         ]
         mock_list_entries.return_value = entries
-        
+
         # Just test it runs in verbose mode
         list_environments(verbose=True)
 
     @mock.patch("hud.cli.list_func.get_registry_dir")
     @mock.patch("hud.cli.list_func.list_registry_entries")
-    def test_list_environments_with_errors(self, mock_list_entries, mock_get_registry, mock_registry_dir, capsys):
+    def test_list_environments_with_errors(
+        self, mock_list_entries, mock_get_registry, mock_registry_dir, capsys
+    ):
         """Test handling of corrupted lock files."""
         mock_get_registry.return_value = mock_registry_dir
-        
+
         # Create a bad lock file
         bad_dir = mock_registry_dir / "sha256_bad"
         bad_dir.mkdir()
         bad_lock = bad_dir / "hud.lock.yaml"
         bad_lock.write_text("invalid: yaml: content:")
-        
+
         # Mock registry entries including the bad one
         entries = [
             ("sha256_bad", bad_lock),
@@ -239,10 +253,10 @@ class TestListEnvironments:
             ("sha256_def456", mock_registry_dir / "sha256_def456" / "hud.lock.yaml"),
         ]
         mock_list_entries.return_value = entries
-        
+
         # Should handle error gracefully in verbose mode
         list_environments(verbose=True, json_output=True)
-        
+
         captured = capsys.readouterr()
         data = json.loads(captured.out)
         # Should still list the valid environments
@@ -250,20 +264,22 @@ class TestListEnvironments:
 
     @mock.patch("hud.cli.list_func.get_registry_dir")
     @mock.patch("hud.cli.list_func.list_registry_entries")
-    def test_list_environments_no_matches(self, mock_list_entries, mock_get_registry, mock_registry_dir):
+    def test_list_environments_no_matches(
+        self, mock_list_entries, mock_get_registry, mock_registry_dir
+    ):
         """Test when no environments match the filter."""
         mock_get_registry.return_value = mock_registry_dir
-        
+
         # Mock registry entries
         entries = [
             ("sha256_abc123", mock_registry_dir / "sha256_abc123" / "hud.lock.yaml"),
             ("sha256_def456", mock_registry_dir / "sha256_def456" / "hud.lock.yaml"),
         ]
         mock_list_entries.return_value = entries
-        
-        # Filter for non-existent env  
+
+        # Filter for non-existent env
         list_environments(filter_name="nonexistent")
-        
+
         # Just test it runs without error
 
 
@@ -280,9 +296,4 @@ class TestListCommand:
     def test_list_command_with_options(self):
         """Test list command with options runs without error."""
         # Just test it doesn't crash with explicit values
-        list_command(
-            filter_name="test",
-            json_output=True,
-            show_all=True,
-            verbose=True
-        )
+        list_command(filter_name="test", json_output=True, show_all=True, verbose=True)

hud/cli/tests/test_main_module.py

@@ -0,0 +1,30 @@
+"""Tests for hud.cli.__main__ module."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+
+
+class TestMainModule:
+    """Tests for the CLI __main__ module."""
+
+    def test_main_module_imports_correctly(self):
+        """Test that __main__.py imports correctly."""
+        # Simply importing the module should work without errors
+        import hud.cli.__main__
+
+        # Verify the module has the expected attributes
+        assert hasattr(hud.cli.__main__, "main")
+
+    def test_main_module_executes(self):
+        """Test that running the module as main executes correctly."""
+        # Use subprocess to run the module as __main__ and check it doesn't crash
+        # We expect it to show help/error since we're not providing arguments
+        result = subprocess.run(
+            [sys.executable, "-m", "hud.cli"], capture_output=True, text=True, timeout=10
+        )
+
+        # Should exit with an error code but not crash
+        # (The actual main function will show help or error for missing args)
+        assert result.returncode != 0  # CLI should exit with error for no args

hud/cli/tests/test_mcp_server.py

@@ -1,4 +1,4 @@
-"""Tests for hud.cli.mcp_server module."""
+"""Tests for hud.cli.dev module."""
 
 from __future__ import annotations
 
@@ -7,7 +7,7 @@ from unittest.mock import MagicMock, patch
 
 import pytest
 
-from hud.cli.mcp_server import (
+from hud.cli.dev import (
     create_proxy_server,
     get_docker_cmd,
     get_image_name,
@@ -119,7 +119,7 @@ class TestRunMCPDevServer:
         import click
 
         with (
-            patch("hud.cli.mcp_server.image_exists", return_value=False),
+            patch("hud.cli.dev.image_exists", return_value=False),
             patch("click.confirm", return_value=False),
             pytest.raises(click.Abort),
         ):