hatch-xclam 0.7.0__py3-none-any.whl

tests/test_python_installer.py

@@ -0,0 +1,327 @@
+import subprocess
+import unittest
+import tempfile
+import shutil
+import sys
+from pathlib import Path
+from unittest import mock
+
+# Import wobble decorators for test categorization
+from wobble.decorators import regression_test, integration_test, slow_test
+
+from hatch.installers.python_installer import PythonInstaller
+from hatch.installers.installation_context import InstallationContext, InstallationStatus
+from hatch.installers.installer_base import InstallationError
+
+class DummyContext(InstallationContext):
+    def __init__(self, env_path=None, env_name=None, simulation_mode=False, extra_config=None):
+        self.simulation_mode = simulation_mode
+        self.extra_config = extra_config or {}
+        self.environment_path = env_path
+        self.environment_name = env_name
+
+    def get_config(self, key, default=None):
+        return self.extra_config.get(key, default)
+
+class TestPythonInstaller(unittest.TestCase):
+    """Tests for the PythonInstaller class covering validation, installation, and error handling."""
+
+    def setUp(self):
+        """Set up a temporary directory and PythonInstaller instance for each test."""
+        
+        self.temp_dir = tempfile.mkdtemp()
+        self.env_path = Path(self.temp_dir) / "test_env"
+
+        # make the directory
+        self.env_path.mkdir(parents=True, exist_ok=True)
+
+        # assert the virtual environment was created successfully
+        self.assertTrue(self.env_path.exists() and self.env_path.is_dir())
+        
+        self.installer = PythonInstaller()
+        self.dummy_context = DummyContext(self.env_path, env_name="test_env", extra_config={
+            "target_dir": str(self.env_path)
+        })
+
+    def tearDown(self):
+        """Clean up the temporary directory after each test."""
+        shutil.rmtree(self.temp_dir)
+
+    @regression_test
+    def test_validate_dependency_valid(self):
+        """Test validate_dependency returns True for valid dependency dict."""
+        dep = {"name": "requests", "version_constraint": ">=2.0.0"}
+        self.assertTrue(self.installer.validate_dependency(dep))
+
+    @regression_test
+    def test_validate_dependency_invalid_missing_fields(self):
+        """Test validate_dependency returns False if required fields are missing."""
+        dep = {"name": "requests"}
+        self.assertFalse(self.installer.validate_dependency(dep))
+
+    @regression_test
+    def test_validate_dependency_invalid_package_manager(self):
+        """Test validate_dependency returns False for unsupported package manager."""
+        dep = {"name": "requests", "version_constraint": ">=2.0.0", "package_manager": "unknown"}
+        self.assertFalse(self.installer.validate_dependency(dep))
+
+    @regression_test
+    def test_can_install_python_type(self):
+        """Test can_install returns True for type 'python'."""
+        dep = {"type": self.installer.installer_type}
+        self.assertTrue(self.installer.can_install(dep))
+
+    @regression_test
+    def test_can_install_wrong_type(self):
+        """Test can_install returns False for non-python type."""
+        dep = {"type": "hatch"}
+        self.assertFalse(self.installer.can_install(dep))
+
+    @regression_test
+    @mock.patch("hatch.installers.python_installer.subprocess.Popen", side_effect=Exception("fail"))
+    def test_run_pip_subprocess_exception(self, mock_popen):
+        """Test _run_pip_subprocess raises InstallationError on exception."""
+        cmd = [sys.executable, "-m", "pip", "--version"]
+        with self.assertRaises(InstallationError):
+            self.installer._run_pip_subprocess(cmd)
+
+    @regression_test
+    def test_install_simulation_mode(self):
+        """Test install returns COMPLETED immediately in simulation mode."""
+        dep = {"name": "requests", "version_constraint": ">=2.0.0"}
+        context = DummyContext(simulation_mode=True)
+        result = self.installer.install(dep, context)
+        self.assertEqual(result.status, InstallationStatus.COMPLETED)
+
+    @regression_test
+    @mock.patch.object(PythonInstaller, "_run_pip_subprocess", return_value=0)
+    def test_install_success(self, mock_run):
+        """Test install returns COMPLETED on successful pip install."""
+        dep = {"name": "requests", "version_constraint": ">=2.0.0"}
+        context = DummyContext()
+        result = self.installer.install(dep, context)
+        self.assertEqual(result.status, InstallationStatus.COMPLETED)
+
+    @regression_test
+    @mock.patch.object(PythonInstaller, "_run_pip_subprocess", return_value=1)
+    def test_install_failure(self, mock_run):
+        """Test install raises InstallationError on pip failure."""
+        dep = {"name": "requests", "version_constraint": ">=2.0.0"} # The content don't matter here given the mock
+        context = DummyContext()
+        with self.assertRaises(InstallationError):
+            self.installer.install(dep, context)
+
+    @regression_test
+    @mock.patch.object(PythonInstaller, "_run_pip_subprocess", return_value=0)
+    def test_uninstall_success(self, mock_run):
+        """Test uninstall returns COMPLETED on successful pip uninstall."""
+        dep = {"name": "requests", "version_constraint": ">=2.0.0"}
+        context = DummyContext()
+        result = self.installer.uninstall(dep, context)
+        self.assertEqual(result.status, InstallationStatus.COMPLETED)
+
+    @regression_test
+    @mock.patch.object(PythonInstaller, "_run_pip_subprocess", return_value=1)
+    def test_uninstall_failure(self, mock_run):
+        """Test uninstall raises InstallationError on pip uninstall failure."""
+        dep = {"name": "requests", "version_constraint": ">=2.0.0"}
+        context = DummyContext()
+        with self.assertRaises(InstallationError):
+            self.installer.uninstall(dep, context)
+
+class TestPythonInstallerIntegration(unittest.TestCase):
+
+    """Integration tests for PythonInstaller that perform actual package installations."""
+
+    def setUp(self):
+        """Set up a temporary directory and PythonInstaller instance for each test."""
+        
+        self.temp_dir = tempfile.mkdtemp()
+        self.env_path = Path(self.temp_dir) / "test_env"
+        
+        # Use pip to create a virtual environment
+        subprocess.check_call([sys.executable, "-m", "venv", str(self.env_path)])
+
+        # assert the virtual environment was created successfully
+        self.assertTrue(self.env_path.exists() and self.env_path.is_dir())
+
+        # Get the Python executable in the virtual environment
+        if sys.platform == "win32":
+            self.python_executable = self.env_path / "Scripts" / "python.exe"
+        else:
+            self.python_executable = self.env_path / "bin" / "python"
+        
+        self.installer = PythonInstaller()
+        self.dummy_context = DummyContext(self.env_path, env_name="test_env", extra_config={
+            "python_executable": self.python_executable,
+            "target_dir": str(self.env_path)
+        })
+
+    def tearDown(self):
+        """Clean up the temporary directory after each test."""
+        shutil.rmtree(self.temp_dir)
+
+    @integration_test(scope="component")
+    @slow_test
+    def test_install_actual_package_success(self):
+        """Test actual installation of a real Python package without mocking.
+        
+        Uses a lightweight package that's commonly available and installs quickly.
+        This validates the entire installation pipeline including subprocess handling.
+        """
+        # Use a lightweight, commonly available package for testing
+        dep = {
+            "name": "wheel", 
+            "version_constraint": "*",
+            "type": "python"
+        }
+        
+        # Create a virtual environment context to avoid polluting system packages
+        context = DummyContext(
+            env_path=self.env_path,
+            env_name="test_env",
+            extra_config={
+                "python_executable": self.python_executable,
+                "target_dir": str(self.env_path)
+            }
+        )
+        result = self.installer.install(dep, context)
+        self.assertEqual(result.status, InstallationStatus.COMPLETED)
+        self.assertIn("wheel", result.dependency_name)
+
+    @integration_test(scope="component")
+    @slow_test
+    def test_install_package_with_version_constraint(self):
+        """Test installation with specific version constraint.
+
+        Validates that version constraints are properly passed to pip
+        and that the installation succeeds with real package resolution.
+        """
+        dep = {
+            "name": "setuptools",
+            "version_constraint": ">=40.0.0",
+            "type": "python"
+        }
+        
+        context = DummyContext(
+            env_path=self.env_path,
+            env_name="test_env",
+            extra_config={
+            "python_executable": self.python_executable
+        })
+
+        result = self.installer.install(dep, context)
+        self.assertEqual(result.status, InstallationStatus.COMPLETED)
+        # Verify the dependency was processed correctly
+        self.assertIsNotNone(result.metadata)
+
+    @integration_test(scope="component")
+    @slow_test
+    def test_install_package_with_extras(self):
+        """Test installation of a package with extras specification.
+        
+        Tests the extras handling functionality with a real package installation.
+        """
+        dep = {
+            "name": "requests",
+            "version_constraint": "*",
+            "type": "python",
+            "extras": ["security"]  # pip[security] if available
+        }
+        
+        context = DummyContext(
+            env_path=self.env_path,
+            env_name="test_env",
+            extra_config={
+            "python_executable": self.python_executable
+        })
+        
+        result = self.installer.install(dep, context)
+        self.assertEqual(result.status, InstallationStatus.COMPLETED)
+
+    @integration_test(scope="component")
+    @slow_test
+    def test_uninstall_actual_package(self):
+        """Test actual uninstallation of a Python package.
+        
+        First installs a package, then uninstalls it to test the complete cycle.
+        This validates both installation and uninstallation without mocking.
+        """
+        dep = {
+            "name": "wheel",
+            "version_constraint": "*", 
+            "type": "python"
+        }
+        
+        context = DummyContext(
+            env_path=self.env_path,
+            env_name="test_env",
+            extra_config={
+            "python_executable": self.python_executable
+        })
+        
+        # First install the package
+        install_result = self.installer.install(dep, context)
+        self.assertEqual(install_result.status, InstallationStatus.COMPLETED)
+        
+        # Then uninstall it
+        uninstall_result = self.installer.uninstall(dep, context)
+        self.assertEqual(uninstall_result.status, InstallationStatus.COMPLETED)
+
+    @integration_test(scope="component")
+    @slow_test
+    def test_install_nonexistent_package_failure(self):
+        """Test that installation fails appropriately for non-existent packages.
+        
+        This validates error handling when pip encounters a package that doesn't exist,
+        without using mocks to simulate the failure.
+        """
+        dep = {
+            "name": "this-package-definitely-does-not-exist-12345",
+            "version_constraint": "*",
+            "type": "python"
+        }
+        
+        context = DummyContext(
+            env_path=self.env_path,
+            env_name="test_env",
+            extra_config={
+            "python_executable": self.python_executable
+        })
+        
+        with self.assertRaises(InstallationError) as cm:
+            self.installer.install(dep, context)
+        
+        # Verify the error contains useful information
+        error_msg = str(cm.exception)
+        self.assertIn("this-package-definitely-does-not-exist-12345", error_msg)
+
+    @integration_test(scope="component")
+    @slow_test
+    def test_get_installation_info_for_installed_package(self):
+        """Test retrieval of installation info for an actually installed package.
+        
+        This tests the get_installation_info method with a real package
+        that should be available in most Python environments.
+        """
+        dep = {
+            "name": "pip",  # pip should be available in most environments
+            "version_constraint": "*",
+            "type": "python"
+        }
+        
+        context = DummyContext(
+            env_path=self.env_path,
+            env_name="test_env",
+            extra_config={
+            "python_executable": self.python_executable
+        })
+        
+        info = self.installer.get_installation_info(dep, context)
+        self.assertIsInstance(info, dict)
+        # Basic checks for expected info structure
+        if info:  # Only check if info was returned (some implementations might return empty dict)
+            self.assertIn("dependency_name", info)
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_registry.py

@@ -0,0 +1,51 @@
+"""Basic test for installer registry functionality.
+
+This test verifies that all installers are properly registered and can be
+retrieved from the registry.
+"""
+
+import sys
+from pathlib import Path
+import unittest
+
+from wobble.decorators import regression_test, integration_test, slow_test
+
+# Import path management removed - using test_data_utils for test dependencies
+
+# It is mandatory to import the installer classes to ensure they are registered
+from hatch.installers.hatch_installer import HatchInstaller
+from hatch.installers.python_installer import PythonInstaller
+from hatch.installers.system_installer import SystemInstaller
+from hatch.installers.docker_installer import DockerInstaller
+from hatch.installers import installer_registry, DependencyInstaller
+
+class TestInstallerRegistry(unittest.TestCase):
+    """Test suite for the installer registry."""
+    @regression_test
+    def test_registered_types(self):
+        """Test that all expected installer types are registered."""
+        registered_types = installer_registry.get_registered_types()
+        expected_types = ["hatch", "python", "system", "docker"]
+        for expected_type in expected_types:
+            self.assertIn(expected_type, registered_types, f"{expected_type} installer should be registered")
+    @regression_test
+    def test_get_installer_instance(self):
+        """Test that the registry returns a valid installer instance for each type."""
+        for dep_type in ["hatch", "python", "system", "docker"]:
+            installer = installer_registry.get_installer(dep_type)
+            self.assertIsInstance(installer, DependencyInstaller)
+            self.assertEqual(installer.installer_type, dep_type)
+    @regression_test
+    def test_error_on_unknown_type(self):
+        """Test that requesting an unknown type raises ValueError."""
+        with self.assertRaises(ValueError):
+            installer_registry.get_installer("unknown_type")
+    @regression_test
+    def test_registry_repr_and_len(self):
+        """Test __repr__ and __len__ methods for coverage."""
+        repr_str = repr(installer_registry)
+        self.assertIn("InstallerRegistry", repr_str)
+        self.assertGreaterEqual(len(installer_registry), 4)
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_registry_retriever.py

@@ -0,0 +1,250 @@
+import sys
+import unittest
+import tempfile
+import shutil
+import logging
+import json
+import datetime
+import os
+from pathlib import Path
+
+from wobble.decorators import regression_test, integration_test, slow_test
+
+# Import path management removed - using test_data_utils for test dependencies
+
+from hatch.registry_retriever import RegistryRetriever
+
+# Configure logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger("hatch.registry_tests")
+
+class RegistryRetrieverTests(unittest.TestCase):
+    """Tests for Registry Retriever functionality."""
+
+    def setUp(self):
+        """Set up test environment before each test."""
+        # Create temporary directories
+        self.temp_dir = tempfile.mkdtemp()
+        self.cache_dir = Path(self.temp_dir) / "cache"
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Path to the registry file (using the one in project data) - for fallback/reference only
+        self.registry_path = Path(__file__).parent.parent.parent / "data" / "hatch_packages_registry.json"
+        if not self.registry_path.exists():
+            # Try alternate location
+            self.registry_path = Path(__file__).parent.parent.parent / "Hatch-Registry" / "data" / "hatch_packages_registry.json"
+        
+        # We're testing online mode, but keep a local copy for comparison and backup
+        self.local_registry_path = Path(self.temp_dir) / "hatch_packages_registry.json"
+        if self.registry_path.exists():
+            shutil.copy(self.registry_path, self.local_registry_path)
+        
+    def tearDown(self):
+        """Clean up test environment after each test."""
+        # Remove temporary directory
+        shutil.rmtree(self.temp_dir)
+    @regression_test
+    def test_registry_init(self):
+        """Test initialization of registry retriever."""
+        # Test initialization in online mode (primary test focus)
+        online_retriever = RegistryRetriever(
+            local_cache_dir=self.cache_dir,
+            simulation_mode=False
+        )
+
+        # Verify URL format for online mode
+        self.assertTrue(online_retriever.registry_url.startswith("https://"))
+        self.assertTrue("github.com" in online_retriever.registry_url)
+
+        # Verify cache path is set correctly
+        self.assertEqual(
+            online_retriever.registry_cache_path,
+            self.cache_dir / "registry" / "hatch_packages_registry.json"
+        )
+
+        # Also test initialization with local file in simulation mode (for reference)
+        sim_retriever = RegistryRetriever(
+            local_cache_dir=self.cache_dir,
+            simulation_mode=True,
+            local_registry_cache_path=self.local_registry_path
+        )
+
+        # Verify registry cache path is set correctly in simulation mode
+        self.assertEqual(sim_retriever.registry_cache_path, self.local_registry_path)
+        self.assertTrue(sim_retriever.registry_url.startswith("file://"))
+
+    @integration_test(scope="component")
+    def test_registry_cache_management(self):
+        """Test registry cache management."""
+        # Initialize retriever with a short TTL in online mode
+        retriever = RegistryRetriever(
+            cache_ttl=5,  # 5 seconds TTL
+            local_cache_dir=self.cache_dir
+        )
+
+        # Get registry data (first fetch from online)
+        registry_data1 = retriever.get_registry()
+        self.assertIsNotNone(registry_data1)
+
+        # Verify in-memory cache works (should not read from disk)
+        registry_data2 = retriever.get_registry()
+        self.assertIs(registry_data1, registry_data2)  # Should be the same object in memory
+
+        # Force refresh and verify it gets loaded again (potentially from online)
+        registry_data3 = retriever.get_registry(force_refresh=True)
+        self.assertIsNotNone(registry_data3)
+
+        # Verify the cache file was created
+        self.assertTrue(retriever.registry_cache_path.exists(), "Cache file was not created")
+
+        # Modify the persistent timestamp to test cache invalidation
+        # We need to manipulate the persistent timestamp file, not just the cache file mtime
+        timestamp_file = retriever._last_fetch_time_path
+        if timestamp_file.exists():
+            # Write an old timestamp to the persistent timestamp file
+            yesterday = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(days=1)
+            old_timestamp_str = yesterday.isoformat().replace('+00:00', 'Z')
+            with open(timestamp_file, 'w', encoding='utf-8') as f:
+                f.write(old_timestamp_str)
+            # Reload the timestamp from file
+            retriever._load_last_fetch_time()
+        
+        # Check if cache is outdated - should be since we modified the persistent timestamp
+        self.assertTrue(retriever.is_cache_outdated())
+        
+        # Force refresh and verify new data is loaded (should fetch from online)
+        registry_data4 = retriever.get_registry(force_refresh=True)
+        self.assertIsNotNone(registry_data4)
+        self.assertIn("repositories", registry_data4)
+        self.assertIn("last_updated", registry_data4)
+    @integration_test(scope="service")
+    def test_online_mode(self):
+        """Test registry retriever in online mode."""
+        # Initialize in online mode
+        retriever = RegistryRetriever(
+            local_cache_dir=self.cache_dir,
+            simulation_mode=False
+        )
+
+        # Get registry and verify it contains expected data
+        registry = retriever.get_registry()
+        self.assertIn("repositories", registry)
+        self.assertIn("last_updated", registry)
+
+        # Verify registry structure
+        self.assertIsInstance(registry.get("repositories"), list)
+        self.assertGreater(len(registry.get("repositories", [])), 0, "Registry should contain repositories")
+
+        # Get registry again with force refresh (should fetch from online)
+        registry2 = retriever.get_registry(force_refresh=True)
+        self.assertIn("repositories", registry2)
+
+        # Test error handling with an existing cache
+        # First ensure we have a valid cache file
+        self.assertTrue(retriever.registry_cache_path.exists(), "Cache file should exist after previous calls")
+
+        # Create a new retriever with invalid URL but using the same cache
+        bad_retriever = RegistryRetriever(
+            local_cache_dir=self.cache_dir,
+            simulation_mode=False
+        )
+        # Mock the URL to be invalid
+        bad_retriever.registry_url = "https://nonexistent.example.com/registry.json"
+
+        # First call should use the cache that was created by the earlier tests
+        registry_data = bad_retriever.get_registry()
+        self.assertIsNotNone(registry_data)
+
+        # Verify an attempt to force refresh with invalid URL doesn't break the test
+        try:
+            bad_retriever.get_registry(force_refresh=True)
+        except Exception:
+            pass  # Expected to fail, that's OK
+    
+    @regression_test
+    def test_persistent_timestamp_across_cli_invocations(self):
+        """Test that persistent timestamp works across separate CLI invocations."""
+        # First "CLI invocation" - create retriever and fetch registry
+        retriever1 = RegistryRetriever(
+            cache_ttl=300,  # 5 minutes TTL
+            local_cache_dir=self.cache_dir,
+            simulation_mode=False
+        )
+
+        # Get registry (should fetch from online)
+        registry1 = retriever1.get_registry()
+        self.assertIsNotNone(registry1)
+
+        # Verify timestamp file was created
+        self.assertTrue(retriever1._last_fetch_time_path.exists(), "Timestamp file should be created")
+
+        # Get the timestamp from the first fetch
+        first_fetch_time = retriever1._last_fetch_time
+        self.assertGreater(first_fetch_time, 0, "First fetch time should be set")
+
+        # Second "CLI invocation" - create new retriever with same cache directory
+        retriever2 = RegistryRetriever(
+            cache_ttl=300,  # 5 minutes TTL
+            local_cache_dir=self.cache_dir,
+            simulation_mode=False
+        )
+
+        # Verify the timestamp was loaded from disk
+        self.assertGreater(retriever2._last_fetch_time, 0, "Timestamp should be loaded from disk")
+
+        # Get registry (should use cache since timestamp is recent)
+        registry2 = retriever2.get_registry()
+        self.assertIsNotNone(registry2)
+
+        # Verify cache was used and not a new fetch (timestamp should be same or very close)
+        time_diff = abs(retriever2._last_fetch_time - first_fetch_time)
+        self.assertLess(time_diff, 2.0, "Should use cached registry, not fetch new one")
+
+    @regression_test
+    def test_persistent_timestamp_edge_cases(self):
+        """Test edge cases for persistent timestamp handling."""
+        retriever = RegistryRetriever(
+            cache_ttl=300,  # 5 minutes TTL
+            local_cache_dir=self.cache_dir,
+            simulation_mode=False
+        )
+
+        # Test 1: Corrupt timestamp file
+        timestamp_file = retriever._last_fetch_time_path
+        timestamp_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # Write corrupt data to timestamp file
+        with open(timestamp_file, 'w', encoding='utf-8') as f:
+            f.write("invalid_timestamp_data")
+
+        # Should handle gracefully and treat as no timestamp
+        retriever._load_last_fetch_time()
+        self.assertEqual(retriever._last_fetch_time, 0, "Corrupt timestamp should be treated as no timestamp")
+
+        # Test 2: Future timestamp (clock skew scenario)
+        future_time = datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(hours=1)
+        future_timestamp_str = future_time.isoformat().replace('+00:00', 'Z')
+        with open(timestamp_file, 'w', encoding='utf-8') as f:
+            f.write(future_timestamp_str)
+        
+        retriever._load_last_fetch_time()
+        # Should handle future timestamps gracefully (treat as valid but check TTL normally)
+        self.assertGreater(retriever._last_fetch_time, 0, "Future timestamp should be loaded")
+        
+        # Test 3: Empty timestamp file
+        with open(timestamp_file, 'w', encoding='utf-8') as f:
+            f.write("")
+        
+        retriever._load_last_fetch_time()
+        self.assertEqual(retriever._last_fetch_time, 0, "Empty timestamp file should be treated as no timestamp")
+        
+        # Test 4: Missing timestamp file
+        timestamp_file.unlink()
+        retriever._load_last_fetch_time()
+        self.assertEqual(retriever._last_fetch_time, 0, "Missing timestamp file should be treated as no timestamp")
+
+if __name__ == "__main__":
+    unittest.main()