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

hud/cli/tests/test_list_func.py

@@ -0,0 +1,288 @@
+"""Tests for list_func.py - List HUD environments from local registry."""
+
+from __future__ import annotations
+
+import json
+import tempfile
+import time
+from datetime import datetime, timedelta
+from pathlib import Path
+from unittest import mock
+
+import pytest
+import yaml
+
+from hud.cli.list_func import format_timestamp, list_environments, list_command
+
+
+class TestFormatTimestamp:
+    """Test timestamp formatting functionality."""
+
+    def test_format_timestamp_just_now(self):
+        """Test formatting for very recent timestamps."""
+        now = time.time()
+        assert format_timestamp(now) == "just now"
+
+    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"
+
+    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"
+
+    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"
+
+    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"
+
+    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"
+
+    def test_format_timestamp_none(self):
+        """Test formatting when timestamp is None."""
+        assert format_timestamp(None) == "unknown"
+
+
+class TestListEnvironments:
+    """Test listing environments functionality."""
+
+    @pytest.fixture
+    def mock_registry_dir(self, tmp_path):
+        """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"]
+            }
+        }))
+        # 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"]
+            }
+        }))
+        
+        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() == "[]"
+
+    @mock.patch("hud.cli.list_func.get_registry_dir")
+    @mock.patch("hud.cli.list_func.list_registry_entries")
+    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):
+        """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):
+        """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
+        assert len(data) == 1
+        assert "env1" in data[0]["name"]
+
+    @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):
+        """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):
+        """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),
+            ("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
+        
+        # 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
+        assert len(data) == 2  # Only the 2 valid ones
+
+    @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):
+        """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  
+        list_environments(filter_name="nonexistent")
+        
+        # Just test it runs without error
+
+
+class TestListCommand:
+    """Test the CLI command wrapper."""
+
+    def test_list_command_basic(self):
+        """Test basic list command runs without error."""
+        # Just test it doesn't crash
+        # Note: we can't easily test the exact arguments because Typer
+        # passes OptionInfo objects as defaults
+        list_command()
+
+    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
+        )

hud/cli/tests/test_pull.py

@@ -0,0 +1,400 @@
+"""Tests for pull.py - Pull HUD environments from registry."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+from unittest import mock
+
+import pytest
+import typer
+import yaml
+
+from hud.cli.pull import (
+    fetch_lock_from_registry,
+    format_size,
+    get_docker_manifest,
+    get_image_size_from_manifest,
+    pull_command,
+    pull_environment,
+)
+
+
+class TestGetDockerManifest:
+    """Test getting Docker manifest."""
+
+    @mock.patch("subprocess.run")
+    def test_get_docker_manifest_success(self, mock_run):
+        """Test successfully getting Docker manifest."""
+        manifest_data = {
+            "schemaVersion": 2,
+            "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
+            "layers": [
+                {"size": 1024},
+                {"size": 2048}
+            ]
+        }
+        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
+        )
+
+    @mock.patch("subprocess.run")
+    def test_get_docker_manifest_failure(self, mock_run):
+        """Test failed Docker manifest fetch."""
+        mock_run.return_value = mock.Mock(returncode=1, stdout="")
+
+        result = get_docker_manifest("test:latest")
+        assert result is None
+
+    @mock.patch("subprocess.run")
+    def test_get_docker_manifest_exception(self, mock_run):
+        """Test Docker manifest fetch with exception."""
+        mock_run.side_effect = Exception("Command failed")
+
+        result = get_docker_manifest("test:latest")
+        assert result is None
+
+
+class TestGetImageSizeFromManifest:
+    """Test extracting image size from manifest."""
+
+    def test_get_size_v2_manifest(self):
+        """Test getting size from v2 manifest with layers."""
+        manifest = {
+            "layers": [
+                {"size": 1024},
+                {"size": 2048},
+                {"size": 512}
+            ]
+        }
+        
+        size = get_image_size_from_manifest(manifest)
+        assert size == 3584  # Sum of all layers
+
+    def test_get_size_manifest_list(self):
+        """Test getting size from manifest list."""
+        manifest = {
+            "manifests": [
+                {"size": 5120, "platform": {"os": "linux"}},
+                {"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
+
+
+class TestFetchLockFromRegistry:
+    """Test fetching lock data from HUD registry."""
+
+    @mock.patch("requests.get")
+    def test_fetch_lock_success(self, mock_get):
+        """Test successful lock file fetch."""
+        lock_data = {"test": "data"}
+        mock_response = mock.Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"lock": yaml.dump(lock_data)}
+        mock_get.return_value = mock_response
+
+        result = fetch_lock_from_registry("org/env:latest")
+        assert result == lock_data
+
+    @mock.patch("requests.get")
+    def test_fetch_lock_adds_latest_tag(self, mock_get):
+        """Test that :latest is added if missing."""
+        mock_response = mock.Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"lock_data": {"test": "data"}}
+        mock_get.return_value = mock_response
+
+        fetch_lock_from_registry("org/env")
+        
+        # Check URL includes :latest
+        call_args = mock_get.call_args
+        assert "org/env:latest" 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"
+
+    @mock.patch("requests.get")
+    def test_fetch_lock_failure(self, mock_get):
+        """Test failed lock file fetch."""
+        mock_response = mock.Mock()
+        mock_response.status_code = 404
+        mock_get.return_value = mock_response
+
+        result = fetch_lock_from_registry("org/env:latest")
+        assert result is None
+
+
+class TestFormatSize:
+    """Test size formatting."""
+
+    def test_format_bytes(self):
+        """Test formatting bytes."""
+        assert format_size(512) == "512.0 B"
+        assert format_size(1023) == "1023.0 B"
+
+    def test_format_kilobytes(self):
+        """Test formatting kilobytes."""
+        assert format_size(1024) == "1.0 KB"
+        assert format_size(2048) == "2.0 KB"
+
+    def test_format_megabytes(self):
+        """Test formatting megabytes."""
+        assert format_size(1024 * 1024) == "1.0 MB"
+        assert format_size(5 * 1024 * 1024) == "5.0 MB"
+
+    def test_format_gigabytes(self):
+        """Test formatting gigabytes."""
+        assert format_size(1024 * 1024 * 1024) == "1.0 GB"
+        assert format_size(2 * 1024 * 1024 * 1024) == "2.0 GB"
+
+    def test_format_terabytes(self):
+        """Test formatting terabytes."""
+        assert format_size(1024 * 1024 * 1024 * 1024) == "1.0 TB"
+
+
+class TestPullEnvironment:
+    """Test the main pull_environment function."""
+
+    @mock.patch("hud.cli.pull.HUDDesign")
+    @mock.patch("hud.cli.pull.save_to_registry")
+    @mock.patch("subprocess.Popen")
+    def test_pull_with_lock_file(self, mock_popen, mock_save, mock_design_class, tmp_path):
+        """Test pulling with a lock file."""
+        # Create mock design instance
+        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"}
+            ]
+        }
+        lock_file = tmp_path / "hud.lock.yaml"
+        lock_file.write_text(yaml.dump(lock_data))
+
+        # Mock docker pull
+        mock_process = mock.Mock()
+        mock_process.stdout = ["Pulling test/env:latest...\n", "Pull complete\n"]
+        mock_process.wait.return_value = None
+        mock_process.returncode = 0
+        mock_popen.return_value = mock_process
+
+        # Run pull
+        pull_environment(str(lock_file), yes=True)
+
+        # Verify docker pull was called
+        mock_popen.assert_called_once()
+        call_args = mock_popen.call_args[0][0]
+        assert call_args == ["docker", "pull", "test/env:latest@sha256:abc123"]
+
+        # Verify lock was saved to registry
+        mock_save.assert_called_once()
+
+    @mock.patch("hud.cli.pull.HUDDesign")
+    @mock.patch("hud.cli.pull.fetch_lock_from_registry")
+    @mock.patch("subprocess.Popen")
+    def test_pull_from_registry(self, mock_popen, mock_fetch, mock_design_class):
+        """Test pulling from HUD registry."""
+        # Create mock design instance
+        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": []
+        }
+        mock_fetch.return_value = lock_data
+
+        # Mock docker pull
+        mock_process = mock.Mock()
+        mock_process.stdout = []
+        mock_process.wait.return_value = None
+        mock_process.returncode = 0
+        mock_popen.return_value = mock_process
+
+        # Run pull
+        pull_environment("org/env:latest", yes=True)
+
+        # Verify registry was checked
+        mock_fetch.assert_called_once_with("org/env:latest")
+
+        # Verify docker pull was called with registry image
+        mock_popen.assert_called_once()
+        call_args = mock_popen.call_args[0][0]
+        assert "docker.io/org/env:latest@sha256:def456" in call_args
+
+    @mock.patch("hud.cli.pull.HUDDesign")
+    @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):
+        """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 docker pull
+        mock_process = mock.Mock()
+        mock_process.stdout = []
+        mock_process.wait.return_value = None
+        mock_process.returncode = 0
+        mock_popen.return_value = mock_process
+
+        # Run pull
+        pull_environment("ubuntu:latest", yes=True)
+
+        # Verify docker pull was called
+        mock_popen.assert_called_once()
+        call_args = mock_popen.call_args[0][0]
+        assert call_args == ["docker", "pull", "ubuntu:latest"]
+
+    @mock.patch("hud.cli.pull.HUDDesign")
+    def test_pull_verify_only(self, mock_design_class):
+        """Test verify-only mode."""
+        # Create mock design instance
+        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)
+
+        # Check success message
+        mock_design.success.assert_called_with("Verification complete")
+
+    @mock.patch("hud.cli.pull.HUDDesign")
+    @mock.patch("subprocess.Popen")
+    def test_pull_docker_failure(self, mock_popen, mock_design_class):
+        """Test handling Docker pull failure."""
+        # Create mock design instance
+        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"]
+        mock_process.wait.return_value = None
+        mock_process.returncode = 1
+        mock_popen.return_value = mock_process
+
+        # Run pull
+        with pytest.raises(typer.Exit):
+            pull_environment("invalid:image", yes=True)
+
+        mock_design.error.assert_called_with("Pull failed")
+
+    @mock.patch("hud.cli.pull.HUDDesign")
+    @mock.patch("typer.confirm")
+    def test_pull_user_cancels(self, mock_confirm, mock_design_class):
+        """Test when user cancels pull."""
+        # Create mock design instance
+        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:
+            pull_environment("test:latest", yes=False)
+
+        assert exc_info.value.exit_code == 0
+        mock_design.info.assert_called_with("Aborted")
+
+    @mock.patch("hud.cli.pull.HUDDesign")
+    def test_pull_nonexistent_lock_file(self, mock_design_class):
+        """Test pulling with non-existent lock file."""
+        # Create mock design instance
+        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")
+
+
+class TestPullCommand:
+    """Test the CLI command wrapper."""
+
+    def test_pull_command_basic(self):
+        """Test basic pull command runs without error."""
+        # Just test it doesn't crash
+        # Note: we can't easily test the exact arguments because Typer
+        # passes OptionInfo objects as defaults
+        with mock.patch("hud.cli.pull.pull_environment"):
+            pull_command("test:latest")
+
+    def test_pull_command_with_options(self):
+        """Test pull command with options runs without error."""
+        # 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
+            )