hud-python 0.4.11__py3-none-any.whl → 0.4.13__py3-none-any.whl

hud/cli/tests/test_analyze_metadata.py

@@ -3,20 +3,17 @@
 from __future__ import annotations
 
 import json
-import os
-import tempfile
-from pathlib import Path
 from unittest import mock
 
 import pytest
 import yaml
 
-from hud.cli.analyze_metadata import (
+from hud.cli.utils.metadata import (
     analyze_from_metadata,
     check_local_cache,
     fetch_lock_from_registry,
 )
-from hud.cli.registry import save_to_registry
+from hud.cli.utils.registry import save_to_registry
 
 
 @pytest.fixture
@@ -79,9 +76,7 @@ class TestFetchLockFromRegistry:
         """Test successful fetch from registry."""
         mock_response = mock.Mock()
         mock_response.status_code = 200
-        mock_response.json.return_value = {
-            "lock": yaml.dump({"test": "data"})
-        }
+        mock_response.json.return_value = {"lock": yaml.dump({"test": "data"})}
         mock_get.return_value = mock_response
 
         result = fetch_lock_from_registry("test/env:latest")
@@ -93,9 +88,7 @@ class TestFetchLockFromRegistry:
         """Test fetch when response has lock_data key."""
         mock_response = mock.Mock()
         mock_response.status_code = 200
-        mock_response.json.return_value = {
-            "lock_data": {"test": "data"}
-        }
+        mock_response.json.return_value = {"lock_data": {"test": "data"}}
         mock_get.return_value = mock_response
 
         result = fetch_lock_from_registry("test/env:latest")
@@ -120,10 +113,10 @@ class TestFetchLockFromRegistry:
         mock_get.return_value = mock_response
 
         fetch_lock_from_registry("test/env")
-        
-        # Check that the URL includes :latest
+
+        # Check that the URL includes :latest (URL-encoded)
         call_args = mock_get.call_args
-        assert "test/env:latest" in call_args[0][0]
+        assert "test/env%3Alatest" in call_args[0][0]
 
     @mock.patch("requests.get")
     def test_fetch_lock_failure(self, mock_get):
@@ -150,11 +143,11 @@ class TestCheckLocalCache:
     def test_check_local_cache_found(self, mock_registry_dir, sample_lock_data, monkeypatch):
         """Test finding lock data in local cache."""
         # Mock registry directory
-        monkeypatch.setattr("hud.cli.registry.get_registry_dir", lambda: mock_registry_dir)
-        
+        monkeypatch.setattr("hud.cli.utils.registry.get_registry_dir", lambda: mock_registry_dir)
+
         # Save sample data to registry
         save_to_registry(sample_lock_data, "test/environment:latest", verbose=False)
-        
+
         # Check cache
         result = check_local_cache("test/environment:latest")
         assert result is not None
@@ -162,21 +155,21 @@ class TestCheckLocalCache:
 
     def test_check_local_cache_not_found(self, mock_registry_dir, monkeypatch):
         """Test when lock data not in local cache."""
-        monkeypatch.setattr("hud.cli.registry.get_registry_dir", lambda: mock_registry_dir)
-        
+        monkeypatch.setattr("hud.cli.utils.registry.get_registry_dir", lambda: mock_registry_dir)
+
         result = check_local_cache("nonexistent/env:latest")
         assert result is None
 
     def test_check_local_cache_invalid_yaml(self, mock_registry_dir, monkeypatch):
         """Test when lock file has invalid YAML."""
-        monkeypatch.setattr("hud.cli.registry.get_registry_dir", lambda: mock_registry_dir)
-        
+        monkeypatch.setattr("hud.cli.utils.registry.get_registry_dir", lambda: mock_registry_dir)
+
         # Create invalid lock file
-        digest = "sha256:invalid"
+        digest = "invalid"
         lock_file = mock_registry_dir / digest / "hud.lock.yaml"
         lock_file.parent.mkdir(parents=True)
         lock_file.write_text("invalid: yaml: content:")
-        
+
         result = check_local_cache("test/invalid:latest")
         assert result is None
 
@@ -189,60 +182,60 @@ class TestCheckLocalCache:
 class TestAnalyzeFromMetadata:
     """Test the main analyze_from_metadata function."""
 
-    @mock.patch("hud.cli.analyze_metadata.check_local_cache")
-    @mock.patch("hud.cli.analyze_metadata.console")
+    @mock.patch("hud.cli.utils.metadata.check_local_cache")
+    @mock.patch("hud.cli.utils.metadata.console")
     async def test_analyze_from_local_cache(self, mock_console, mock_check, sample_lock_data):
         """Test analyzing from local cache."""
         mock_check.return_value = sample_lock_data
-        
+
         await analyze_from_metadata("test/env:latest", "json", verbose=False)
-        
+
         mock_check.assert_called_once_with("test/env:latest")
         # Should output JSON
         mock_console.print_json.assert_called_once()
 
-    @mock.patch("hud.cli.analyze_metadata.check_local_cache")
-    @mock.patch("hud.cli.analyze_metadata.fetch_lock_from_registry")
-    @mock.patch("hud.cli.analyze_metadata.save_to_registry")
-    @mock.patch("hud.cli.analyze_metadata.console")
+    @mock.patch("hud.cli.utils.metadata.check_local_cache")
+    @mock.patch("hud.cli.utils.metadata.fetch_lock_from_registry")
+    @mock.patch("hud.cli.utils.registry.save_to_registry")
+    @mock.patch("hud.cli.utils.metadata.console")
     async def test_analyze_from_registry(
         self, mock_console, mock_save, mock_fetch, mock_check, sample_lock_data
     ):
         """Test analyzing from registry when not in cache."""
         mock_check.return_value = None
         mock_fetch.return_value = sample_lock_data
-        
+
         await analyze_from_metadata("test/env:latest", "json", verbose=False)
-        
+
         mock_check.assert_called_once()
         mock_fetch.assert_called_once()
         mock_save.assert_called_once()  # Should save to cache
         mock_console.print_json.assert_called_once()
 
-    @mock.patch("hud.cli.analyze_metadata.check_local_cache")
-    @mock.patch("hud.cli.analyze_metadata.fetch_lock_from_registry")
-    @mock.patch("hud.cli.analyze_metadata.design")
-    @mock.patch("hud.cli.analyze_metadata.console")
+    @mock.patch("hud.cli.utils.metadata.check_local_cache")
+    @mock.patch("hud.cli.utils.metadata.fetch_lock_from_registry")
+    @mock.patch("hud.cli.utils.metadata.design")
+    @mock.patch("hud.cli.utils.metadata.console")
     async def test_analyze_not_found(self, mock_console, mock_design, mock_fetch, mock_check):
         """Test when environment not found anywhere."""
         mock_check.return_value = None
         mock_fetch.return_value = None
-        
+
         await analyze_from_metadata("test/notfound:latest", "json", verbose=False)
-        
+
         # Should show error
         mock_design.error.assert_called_with("Environment metadata not found")
         # Should print suggestions
         mock_console.print.assert_called()
 
-    @mock.patch("hud.cli.analyze_metadata.check_local_cache")
-    @mock.patch("hud.cli.analyze_metadata.console")
+    @mock.patch("hud.cli.utils.metadata.check_local_cache")
+    @mock.patch("hud.cli.utils.metadata.console")
     async def test_analyze_verbose_mode(self, mock_console, mock_check, sample_lock_data):
         """Test verbose mode includes input schemas."""
         mock_check.return_value = sample_lock_data
-        
+
         await analyze_from_metadata("test/env:latest", "json", verbose=True)
-        
+
         # In verbose mode, the JSON output should include input schemas
         mock_console.print_json.assert_called_once()
         # Get the JSON string that was printed
@@ -250,13 +243,13 @@ class TestAnalyzeFromMetadata:
         output_data = json.loads(call_args)
         assert "inputSchema" in output_data["tools"][0]
 
-    @mock.patch("hud.cli.analyze_metadata.check_local_cache")
-    @mock.patch("hud.cli.analyze_metadata.fetch_lock_from_registry")
+    @mock.patch("hud.cli.utils.metadata.check_local_cache")
+    @mock.patch("hud.cli.utils.metadata.fetch_lock_from_registry")
     async def test_analyze_registry_reference_parsing(self, mock_fetch, mock_check):
         """Test parsing of different registry reference formats."""
         mock_check.return_value = None
         mock_fetch.return_value = {"test": "data"}
-        
+
         # Test different reference formats
         test_cases = [
             ("docker.io/org/name:tag", "org/name:tag"),
@@ -265,13 +258,13 @@ class TestAnalyzeFromMetadata:
             ("org/name", "org/name"),
             ("name:tag", "name:tag"),
         ]
-        
+
         for input_ref, expected_call in test_cases:
             await analyze_from_metadata(input_ref, "json", verbose=False)
-            
+
             # Check what was passed to fetch_lock_from_registry
             calls = mock_fetch.call_args_list
             last_call = calls[-1][0][0]
-            
+
             # The function might add :latest, so check base name
             assert expected_call.split(":")[0] in last_call

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: