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

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),
         ):

hud/cli/tests/test_pull.py

@@ -3,8 +3,6 @@
 from __future__ import annotations
 
 import json
-import subprocess
-from pathlib import Path
 from unittest import mock
 
 import pytest
@@ -30,22 +28,14 @@ class TestGetDockerManifest:
         manifest_data = {
             "schemaVersion": 2,
             "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
-            "layers": [
-                {"size": 1024},
-                {"size": 2048}
-            ]
+            "layers": [{"size": 1024}, {"size": 2048}],
         }
-        mock_run.return_value = mock.Mock(
-            returncode=0,
-            stdout=json.dumps(manifest_data)
-        )
+        mock_run.return_value = mock.Mock(returncode=0, stdout=json.dumps(manifest_data))
 
         result = get_docker_manifest("test:latest")
         assert result == manifest_data
         mock_run.assert_called_once_with(
-            ["docker", "manifest", "inspect", "test:latest"],
-            capture_output=True,
-            text=True
+            ["docker", "manifest", "inspect", "test:latest"], capture_output=True, text=True
         )
 
     @mock.patch("subprocess.run")
@@ -70,14 +60,8 @@ class TestGetImageSizeFromManifest:
 
     def test_get_size_v2_manifest(self):
         """Test getting size from v2 manifest with layers."""
-        manifest = {
-            "layers": [
-                {"size": 1024},
-                {"size": 2048},
-                {"size": 512}
-            ]
-        }
-        
+        manifest = {"layers": [{"size": 1024}, {"size": 2048}, {"size": 512}]}
+
         size = get_image_size_from_manifest(manifest)
         assert size == 3584  # Sum of all layers
 
@@ -86,24 +70,24 @@ class TestGetImageSizeFromManifest:
         manifest = {
             "manifests": [
                 {"size": 5120, "platform": {"os": "linux"}},
-                {"size": 4096, "platform": {"os": "windows"}}
+                {"size": 4096, "platform": {"os": "windows"}},
             ]
         }
-        
+
         size = get_image_size_from_manifest(manifest)
         assert size == 5120  # First manifest size
 
     def test_get_size_empty_manifest(self):
         """Test getting size from empty manifest."""
         manifest = {}
-        
+
         size = get_image_size_from_manifest(manifest)
         assert size is None
 
     def test_get_size_invalid_manifest(self):
         """Test getting size from invalid manifest."""
         manifest = {"invalid": "data"}
-        
+
         size = get_image_size_from_manifest(manifest)
         assert size is None
 
@@ -132,24 +116,24 @@ class TestFetchLockFromRegistry:
         mock_get.return_value = mock_response
 
         fetch_lock_from_registry("org/env")
-        
-        # Check URL includes :latest
+
+        # Check URL includes :latest (URL-encoded)
         call_args = mock_get.call_args
-        assert "org/env:latest" in call_args[0][0]
+        assert "org/env%3Alatest" in call_args[0][0]
 
     @mock.patch("hud.cli.pull.settings")
     @mock.patch("requests.get")
     def test_fetch_lock_with_auth(self, mock_get, mock_settings):
         """Test fetching with API key."""
         mock_settings.api_key = "test-key"
-        
+
         mock_response = mock.Mock()
         mock_response.status_code = 200
         mock_response.json.return_value = {"test": "data"}
         mock_get.return_value = mock_response
 
         fetch_lock_from_registry("org/env:latest")
-        
+
         # Check auth header was set
         call_kwargs = mock_get.call_args[1]
         assert call_kwargs["headers"]["Authorization"] == "Bearer test-key"
@@ -205,21 +189,13 @@ class TestPullEnvironment:
         mock_design = mock.Mock()
         mock_design.console = mock.Mock()
         mock_design_class.return_value = mock_design
-        
+
         # Create lock file
         lock_data = {
             "image": "test/env:latest@sha256:abc123",
-            "build": {
-                "generatedAt": "2024-01-01T00:00:00Z",
-                "hudVersion": "1.0.0"
-            },
-            "environment": {
-                "toolCount": 5,
-                "initializeMs": 1500
-            },
-            "tools": [
-                {"name": "tool1", "description": "Tool 1"}
-            ]
+            "build": {"generatedAt": "2024-01-01T00:00:00Z", "hudVersion": "1.0.0"},
+            "environment": {"toolCount": 5, "initializeMs": 1500},
+            "tools": [{"name": "tool1", "description": "Tool 1"}],
         }
         lock_file = tmp_path / "hud.lock.yaml"
         lock_file.write_text(yaml.dump(lock_data))
@@ -251,12 +227,9 @@ class TestPullEnvironment:
         mock_design = mock.Mock()
         mock_design.console = mock.Mock()
         mock_design_class.return_value = mock_design
-        
+
         # Mock registry response
-        lock_data = {
-            "image": "docker.io/org/env:latest@sha256:def456",
-            "tools": []
-        }
+        lock_data = {"image": "docker.io/org/env:latest@sha256:def456", "tools": []}
         mock_fetch.return_value = lock_data
 
         # Mock docker pull
@@ -281,20 +254,20 @@ class TestPullEnvironment:
     @mock.patch("hud.cli.pull.get_docker_manifest")
     @mock.patch("hud.cli.pull.fetch_lock_from_registry")
     @mock.patch("subprocess.Popen")
-    def test_pull_docker_image_direct(self, mock_popen, mock_fetch, mock_manifest, mock_design_class):
+    def test_pull_docker_image_direct(
+        self, mock_popen, mock_fetch, mock_manifest, mock_design_class
+    ):
         """Test pulling Docker image directly."""
         # Create mock design instance
         mock_design = mock.Mock()
         mock_design.console = mock.Mock()
         mock_design_class.return_value = mock_design
-        
+
         # Mock no registry data
         mock_fetch.return_value = None
 
         # Mock manifest
-        mock_manifest.return_value = {
-            "layers": [{"size": 1024}]
-        }
+        mock_manifest.return_value = {"layers": [{"size": 1024}]}
 
         # Mock docker pull
         mock_process = mock.Mock()
@@ -318,7 +291,7 @@ class TestPullEnvironment:
         mock_design = mock.Mock()
         mock_design.console = mock.Mock()
         mock_design_class.return_value = mock_design
-        
+
         # Should not actually pull
         pull_environment("test:latest", verify_only=True)
 
@@ -333,7 +306,7 @@ class TestPullEnvironment:
         mock_design = mock.Mock()
         mock_design.console = mock.Mock()
         mock_design_class.return_value = mock_design
-        
+
         # Mock docker pull failure
         mock_process = mock.Mock()
         mock_process.stdout = ["Error: manifest unknown\n"]
@@ -355,7 +328,7 @@ class TestPullEnvironment:
         mock_design = mock.Mock()
         mock_design.console = mock.Mock()
         mock_design_class.return_value = mock_design
-        
+
         mock_confirm.return_value = False
 
         with pytest.raises(typer.Exit) as exc_info:
@@ -371,7 +344,7 @@ class TestPullEnvironment:
         mock_design = mock.Mock()
         mock_design.console = mock.Mock()
         mock_design_class.return_value = mock_design
-        
+
         with pytest.raises(typer.Exit):
             pull_environment("nonexistent.yaml")
 
@@ -392,9 +365,5 @@ class TestPullCommand:
         # Just test it doesn't crash with explicit values
         with mock.patch("hud.cli.pull.pull_environment"):
             pull_command(
-                "org/env:v1.0",
-                lock_file="lock.yaml",
-                yes=True,
-                verify_only=True,
-                verbose=True
+                "org/env:v1.0", lock_file="lock.yaml", yes=True, verify_only=True, verbose=True
             )