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

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
             )

hud/cli/tests/test_push.py

@@ -5,12 +5,9 @@ from __future__ import annotations
 import base64
 import json
 import subprocess
-from datetime import datetime
-from pathlib import Path
 from unittest import mock
 
 import pytest
-import requests
 import typer
 import yaml
 
@@ -30,7 +27,7 @@ class TestGetDockerUsername:
         # Create mock Docker config
         docker_dir = tmp_path / ".docker"
         docker_dir.mkdir()
-        
+
         config_file = docker_dir / "config.json"
         config = {
             "auths": {
@@ -40,37 +37,31 @@ class TestGetDockerUsername:
             }
         }
         config_file.write_text(json.dumps(config))
-        
+
         with mock.patch("pathlib.Path.home", return_value=tmp_path):
             username = get_docker_username()
-        
+
         assert username == "testuser"
 
     def test_get_username_no_config(self, tmp_path):
         """Test when no Docker config exists."""
         with mock.patch("pathlib.Path.home", return_value=tmp_path):
             username = get_docker_username()
-        
+
         assert username is None
 
     def test_get_username_token_auth(self, tmp_path):
         """Test skipping token-based auth."""
         docker_dir = tmp_path / ".docker"
         docker_dir.mkdir()
-        
+
         config_file = docker_dir / "config.json"
-        config = {
-            "auths": {
-                "docker.io": {
-                    "auth": base64.b64encode(b"token:xyz").decode()
-                }
-            }
-        }
+        config = {"auths": {"docker.io": {"auth": base64.b64encode(b"token:xyz").decode()}}}
         config_file.write_text(json.dumps(config))
-        
+
         with mock.patch("pathlib.Path.home", return_value=tmp_path):
             username = get_docker_username()
-        
+
         assert username is None
 
     @mock.patch("subprocess.run")
@@ -78,20 +69,20 @@ class TestGetDockerUsername:
         """Test getting username from credential helper."""
         docker_dir = tmp_path / ".docker"
         docker_dir.mkdir()
-        
+
         config_file = docker_dir / "config.json"
         config = {"credsStore": "desktop"}
         config_file.write_text(json.dumps(config))
-        
+
         # Mock credential helper calls
         mock_run.side_effect = [
             mock.Mock(returncode=0, stdout='{"https://index.docker.io/v1/": "creds"}'),
-            mock.Mock(returncode=0, stdout='{"Username": "helperuser", "Secret": "pass"}')
+            mock.Mock(returncode=0, stdout='{"Username": "helperuser", "Secret": "pass"}'),
         ]
-        
+
         with mock.patch("pathlib.Path.home", return_value=tmp_path):
             username = get_docker_username()
-        
+
         assert username == "helperuser"
 
 
@@ -101,16 +92,9 @@ class TestGetDockerImageLabels:
     @mock.patch("subprocess.run")
     def test_get_labels_success(self, mock_run):
         """Test successfully getting image labels."""
-        labels = {
-            "org.hud.manifest.head": "abc123",
-            "org.hud.version": "1.0.0"
-        }
-        mock_run.return_value = mock.Mock(
-            returncode=0,
-            stdout=json.dumps(labels),
-            stderr=""
-        )
-        
+        labels = {"org.hud.manifest.head": "abc123", "org.hud.version": "1.0.0"}
+        mock_run.return_value = mock.Mock(returncode=0, stdout=json.dumps(labels), stderr="")
+
         result = get_docker_image_labels("test:latest")
         assert result == labels
 
@@ -118,7 +102,7 @@ class TestGetDockerImageLabels:
     def test_get_labels_failure(self, mock_run):
         """Test handling failure to get labels."""
         mock_run.side_effect = Exception("Command failed")
-        
+
         result = get_docker_image_labels("test:latest")
         assert result == {}
 
@@ -131,10 +115,10 @@ class TestPushEnvironment:
         """Test pushing when no lock file exists."""
         mock_design = mock.Mock()
         mock_design_class.return_value = mock_design
-        
+
         with pytest.raises(typer.Exit) as exc_info:
             push_environment(str(tmp_path))
-        
+
         assert exc_info.value.exit_code == 1
         mock_design.error.assert_called()
 
@@ -145,14 +129,14 @@ class TestPushEnvironment:
         mock_design = mock.Mock()
         mock_design_class.return_value = mock_design
         mock_settings.api_key = None
-        
+
         # Create lock file
         lock_file = tmp_path / "hud.lock.yaml"
         lock_file.write_text(yaml.dump({"image": "test:latest"}))
-        
+
         with pytest.raises(typer.Exit) as exc_info:
             push_environment(str(tmp_path))
-        
+
         assert exc_info.value.exit_code == 1
 
     @mock.patch("requests.post")
@@ -162,8 +146,14 @@ class TestPushEnvironment:
     @mock.patch("hud.cli.push.settings")
     @mock.patch("hud.cli.push.HUDDesign")
     def test_push_auto_detect_username(
-        self, mock_design_class, mock_settings, mock_get_username,
-        mock_run, mock_popen, mock_post, tmp_path
+        self,
+        mock_design_class,
+        mock_settings,
+        mock_get_username,
+        mock_run,
+        mock_popen,
+        mock_post,
+        tmp_path,
     ):
         """Test auto-detecting Docker username and pushing."""
         # Setup mocks
@@ -172,15 +162,12 @@ class TestPushEnvironment:
         mock_settings.api_key = "test-key"
         mock_settings.hud_telemetry_url = "https://api.hud.test"
         mock_get_username.return_value = "testuser"
-        
+
         # Create lock file
-        lock_data = {
-            "image": "original/image:v1.0",
-            "build": {"version": "0.1.0"}
-        }
+        lock_data = {"image": "original/image:v1.0", "build": {"version": "0.1.0"}}
         lock_file = tmp_path / "hud.lock.yaml"
         lock_file.write_text(yaml.dump(lock_data))
-        
+
         # Mock docker commands
         def mock_run_impl(*args, **kwargs):
             cmd = args[0]
@@ -192,50 +179,48 @@ class TestPushEnvironment:
             elif cmd[1] == "tag":
                 return mock.Mock(returncode=0)
             return mock.Mock(returncode=0)
-        
+
         mock_run.side_effect = mock_run_impl
-        
+
         # Mock docker push
         mock_process = mock.Mock()
         mock_process.stdout = ["Pushing image...", "Push complete"]
         mock_process.wait.return_value = None
         mock_process.returncode = 0
         mock_popen.return_value = mock_process
-        
+
         # Mock registry upload
         mock_post.return_value = mock.Mock(status_code=201)
-        
+
         # Run push
         push_environment(str(tmp_path), yes=True)
-        
+
         # Verify docker commands
         assert mock_run.call_count >= 2
         mock_popen.assert_called_once()
-        
+
         # Verify registry upload
         mock_post.assert_called_once()
         call_args = mock_post.call_args
-        assert "testuser/image:0.1.0" in call_args[0][0]
+        assert "testuser/image%3A0.1.0" in call_args[0][0]
 
     @mock.patch("subprocess.run")
     @mock.patch("hud.cli.push.settings")
     @mock.patch("hud.cli.push.HUDDesign")
-    def test_push_explicit_image(
-        self, mock_design_class, mock_settings, mock_run, tmp_path
-    ):
+    def test_push_explicit_image(self, mock_design_class, mock_settings, mock_run, tmp_path):
         """Test pushing with explicit image name."""
         mock_design = mock.Mock()
         mock_design_class.return_value = mock_design
         mock_settings.api_key = "test-key"
-        
+
         # Create lock file
         lock_data = {"image": "local:latest"}
         lock_file = tmp_path / "hud.lock.yaml"
         lock_file.write_text(yaml.dump(lock_data))
-        
+
         # Mock docker inspect for non-existent local image
         mock_run.side_effect = subprocess.CalledProcessError(1, "docker")
-        
+
         with pytest.raises(typer.Exit):
             push_environment(str(tmp_path), image="myrepo/myimage:v2")
 
@@ -243,19 +228,17 @@ class TestPushEnvironment:
     @mock.patch("subprocess.run")
     @mock.patch("hud.cli.push.settings")
     @mock.patch("hud.cli.push.HUDDesign")
-    def test_push_with_tag(
-        self, mock_design_class, mock_settings, mock_run, mock_popen, tmp_path
-    ):
+    def test_push_with_tag(self, mock_design_class, mock_settings, mock_run, mock_popen, tmp_path):
         """Test pushing with explicit tag."""
         mock_design = mock.Mock()
         mock_design_class.return_value = mock_design
         mock_settings.api_key = "test-key"
-        
+
         # Create lock file
         lock_data = {"image": "test:latest"}
         lock_file = tmp_path / "hud.lock.yaml"
         lock_file.write_text(yaml.dump(lock_data))
-        
+
         # Mock docker commands
         def mock_run_impl(*args, **kwargs):
             cmd = args[0]
@@ -267,19 +250,19 @@ class TestPushEnvironment:
             elif cmd[1] == "tag":
                 return mock.Mock(returncode=0)
             return mock.Mock(returncode=0)
-        
+
         mock_run.side_effect = mock_run_impl
-        
+
         # Mock docker push
         mock_process = mock.Mock()
         mock_process.stdout = []
         mock_process.wait.return_value = None
         mock_process.returncode = 0
         mock_popen.return_value = mock_process
-        
+
         # Run push
         push_environment(str(tmp_path), image="user/test", tag="v2.0", yes=True)
-        
+
         # Verify tag was used
         tag_call = [c for c in mock_run.call_args_list if c[0][0][1] == "tag"]
         assert len(tag_call) > 0
@@ -291,19 +274,21 @@ class TestPushEnvironment:
         """Test handling Docker push failure."""
         mock_design = mock.Mock()
         mock_design_class.return_value = mock_design
-        
+
         # Mock docker push failure
         mock_process = mock.Mock()
         mock_process.stdout = ["Error: access denied"]
         mock_process.wait.return_value = None
         mock_process.returncode = 1
         mock_popen.return_value = mock_process
-        
+
         with mock.patch("hud.cli.push.settings") as mock_settings:
             mock_settings.api_key = "test-key"
-            with mock.patch("subprocess.run"):
-                with pytest.raises(typer.Exit):
-                    push_environment(".", image="test:latest", yes=True)
+            with (
+                mock.patch("subprocess.run"),
+                pytest.raises(typer.Exit),
+            ):
+                push_environment(".", image="test:latest", yes=True)
 
     @mock.patch("hud.cli.push.get_docker_image_labels")
     @mock.patch("subprocess.run")
@@ -316,18 +301,18 @@ class TestPushEnvironment:
         mock_design = mock.Mock()
         mock_design_class.return_value = mock_design
         mock_settings.api_key = "test-key"
-        
+
         # Create lock file
         lock_data = {"image": "test:latest"}
         lock_file = tmp_path / "hud.lock.yaml"
         lock_file.write_text(yaml.dump(lock_data))
-        
+
         # Mock labels
         mock_get_labels.return_value = {
             "org.hud.manifest.head": "abc123def456",
-            "org.hud.version": "1.2.3"
+            "org.hud.version": "1.2.3",
         }
-        
+
         # Mock docker commands - first inspect succeeds to get to label check
         # Provide explicit image to bypass username check
         def mock_run_impl(*args, **kwargs):
@@ -339,13 +324,13 @@ class TestPushEnvironment:
                 # Fail on tag to exit after labels are checked
                 raise subprocess.CalledProcessError(1, cmd)
             return mock.Mock(returncode=0)
-        
+
         mock_run.side_effect = mock_run_impl
-        
+
         # Provide explicit image to ensure we reach label check
         with pytest.raises(subprocess.CalledProcessError):
             push_environment(str(tmp_path), image="test:v2", verbose=True)
-        
+
         # Verify labels were checked
         mock_get_labels.assert_called_once_with("test:latest")
 
@@ -357,10 +342,8 @@ class TestPushCommand:
         """Test basic push command."""
         with mock.patch("hud.cli.push.push_environment") as mock_push:
             push_command()
-            
-            mock_push.assert_called_once_with(
-                ".", None, None, False, False, False
-            )
+
+            mock_push.assert_called_once_with(".", None, None, False, False, False)
 
     def test_push_command_with_options(self):
         """Test push command with all options."""
@@ -371,9 +354,7 @@ class TestPushCommand:
                 tag="v1.0",
                 sign=True,
                 yes=True,
-                verbose=True
-            )
-            
-            mock_push.assert_called_once_with(
-                "./myenv", "myrepo/myimage", "v1.0", True, True, True
+                verbose=True,
             )
+
+            mock_push.assert_called_once_with("./myenv", "myrepo/myimage", "v1.0", True, True, True)