hatch-xclam 0.7.0__py3-none-any.whl

tests/run_environment_tests.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+import sys
+import unittest
+import logging
+from pathlib import Path
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler("environment_test_results.log")
+    ]
+)
+logger = logging.getLogger("hatch.test_runner")
+
+if __name__ == "__main__":
+    # Add parent directory to path for imports
+    sys.path.insert(0, str(Path(__file__).parent.parent))
+    
+    # Discover and run tests
+    test_loader = unittest.TestLoader()
+    if len(sys.argv) > 1 and sys.argv[1] == "--env-only":
+        # Run only environment tests
+        logger.info("Running environment tests only...")
+        test_suite = test_loader.loadTestsFromName("test_env_manip.PackageEnvironmentTests")
+    elif len(sys.argv) > 1 and sys.argv[1] == "--remote-only":
+        # Run only remote integration tests
+        logger.info("Running remote integration tests only...")
+        test_suite = test_loader.loadTestsFromName("test_registry_retriever.RegistryRetrieverTests")
+        test_suite = test_loader.loadTestsFromName("test_online_package_loader.OnlinePackageLoaderTests")
+
+    elif len(sys.argv) > 1 and sys.argv[1] == "--registry-online":
+        # Run only registry online mode tests
+        logger.info("Running registry retriever online mode tests...")
+        test_suite = test_loader.loadTestsFromName("test_registry_retriever.RegistryRetrieverTests")
+    elif len(sys.argv) > 1 and sys.argv[1] == "--package-online":
+        # Run only package loader online mode tests
+        logger.info("Running package loader online mode tests...")
+        test_suite = test_loader.loadTestsFromName("test_online_package_loader.OnlinePackageLoaderTests")
+    elif len(sys.argv) > 1 and sys.argv[1] == "--installer-only":
+        # Run only installer interface tests
+        logger.info("Running installer interface tests only...")
+        test_suite = test_loader.loadTestsFromName("test_installer_base.BaseInstallerTests")
+    elif len(sys.argv) > 1 and sys.argv[1] == "--hatch-installer-only":
+        # Run only HatchInstaller tests
+        logger.info("Running HatchInstaller tests only...")
+        test_suite = test_loader.loadTestsFromName("test_hatch_installer.TestHatchInstaller")
+    elif len(sys.argv) > 1 and sys.argv[1] == "--python-installer-only":
+        # Run only PythonInstaller tests
+        logger.info("Running PythonInstaller tests only...")
+        test_mocking = test_loader.loadTestsFromName("test_python_installer.TestPythonInstaller")
+        test_integration = test_loader.loadTestsFromName("test_python_installer.TestPythonInstallerIntegration")
+        test_suite = unittest.TestSuite([test_mocking, test_integration])
+    elif len(sys.argv) > 1 and sys.argv[1] == "--python-env-manager-only":
+        # Run only PythonEnvironmentManager tests (mocked)
+        logger.info("Running PythonEnvironmentManager mocked tests only...")
+        test_suite = test_loader.loadTestsFromName("test_python_environment_manager.TestPythonEnvironmentManager")
+    elif len(sys.argv) > 1 and sys.argv[1] == "--python-env-manager-integration":
+        # Run only PythonEnvironmentManager integration tests (requires conda/mamba)
+        logger.info("Running PythonEnvironmentManager integration tests only...")
+        test_integration = test_loader.loadTestsFromName("test_python_environment_manager.TestPythonEnvironmentManagerIntegration")
+        test_enhanced = test_loader.loadTestsFromName("test_python_environment_manager.TestPythonEnvironmentManagerEnhancedFeatures")
+        test_suite = unittest.TestSuite([test_integration, test_enhanced])
+    elif len(sys.argv) > 1 and sys.argv[1] == "--python-env-manager-all":
+        # Run all PythonEnvironmentManager tests
+        logger.info("Running all PythonEnvironmentManager tests...")
+        test_mocked = test_loader.loadTestsFromName("test_python_environment_manager.TestPythonEnvironmentManager")
+        test_integration = test_loader.loadTestsFromName("test_python_environment_manager.TestPythonEnvironmentManagerIntegration")
+        test_enhanced = test_loader.loadTestsFromName("test_python_environment_manager.TestPythonEnvironmentManagerEnhancedFeatures")
+        test_suite = unittest.TestSuite([test_mocked, test_integration, test_enhanced])
+    elif len(sys.argv) > 1 and sys.argv[1] == "--system-installer-only":
+        # Run only SystemInstaller tests
+        logger.info("Running SystemInstaller tests only...")
+        test_mocking = test_loader.loadTestsFromName("test_system_installer.TestSystemInstaller")
+        test_integration = test_loader.loadTestsFromName("test_system_installer.TestSystemInstallerIntegration")
+        test_suite = unittest.TestSuite([test_mocking, test_integration])
+    elif len(sys.argv) > 1 and sys.argv[1] == "--docker-installer-only":
+        # Run only DockerInstaller tests
+        logger.info("Running DockerInstaller tests only...")
+        test_mocking = test_loader.loadTestsFromName("test_docker_installer.TestDockerInstaller")
+        test_integration = test_loader.loadTestsFromName("test_docker_installer.TestDockerInstallerIntegration")
+        test_suite = unittest.TestSuite([test_mocking, test_integration])
+    elif len(sys.argv) > 1 and sys.argv[1] == "--all-installers":
+        # Run all installer tests
+        logger.info("Running all installer tests...")
+        hatch_tests = test_loader.loadTestsFromName("test_hatch_installer.TestHatchInstaller")
+        python_tests_mocking = test_loader.loadTestsFromName("test_python_installer.TestPythonInstaller")
+        python_tests_integration = test_loader.loadTestsFromName("test_python_installer.TestPythonInstallerIntegration")
+        system_tests = test_loader.loadTestsFromName("test_system_installer.TestSystemInstaller")
+        system_tests_integration = test_loader.loadTestsFromName("test_system_installer.TestSystemInstallerIntegration")
+        docker_tests = test_loader.loadTestsFromName("test_docker_installer.TestDockerInstaller")
+        docker_tests_integration = test_loader.loadTestsFromName("test_docker_installer.TestDockerInstallerIntegration")
+
+        test_suite = unittest.TestSuite([
+            hatch_tests, 
+            python_tests_mocking, 
+            python_tests_integration, 
+            system_tests, 
+            system_tests_integration,
+            docker_tests,
+            docker_tests_integration
+        ])
+    elif len(sys.argv) > 1 and sys.argv[1] == "--registry-only":
+        # Run only installer registry tests
+        logger.info("Running installer registry tests only...")
+        test_suite = test_loader.loadTestsFromName("test_registry.TestInstallerRegistry")
+    else:
+        # Run all tests
+        logger.info("Running all package environment tests...")
+        test_suite = test_loader.discover('.', pattern='test_*.py')
+
+    # Run the tests
+    test_runner = unittest.TextTestRunner(verbosity=2)
+    result = test_runner.run(test_suite)
+    
+    # Log test results summary
+    logger.info(f"Tests run: {result.testsRun}")
+    logger.info(f"Errors: {len(result.errors)}")
+    logger.info(f"Failures: {len(result.failures)}")
+    
+    # Exit with appropriate status code
+    sys.exit(not result.wasSuccessful())

tests/test_cli_version.py

@@ -0,0 +1,122 @@
+"""
+Test suite for hatch --version command implementation.
+
+This module tests the version command functionality:
+- Version retrieval from importlib.metadata
+- Error handling for PackageNotFoundError
+- CLI version display format
+- Import safety after removing __version__
+- No conflicts with existing flags
+
+Tests follow CrackingShells testing standards using wobble framework.
+"""
+
+import unittest
+import sys
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+from io import StringIO
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from hatch.cli_hatch import main, get_hatch_version
+
+try:
+    from wobble.decorators import regression_test, integration_test
+except ImportError:
+    # Fallback decorators if wobble not available
+    def regression_test(func):
+        return func
+    
+    def integration_test(scope="component"):
+        def decorator(func):
+            return func
+        return decorator
+
+
+class TestVersionCommand(unittest.TestCase):
+    """Test suite for hatch --version command implementation."""
+    
+    @regression_test
+    def test_get_hatch_version_retrieves_from_metadata(self):
+        """Test get_hatch_version() retrieves version from importlib.metadata."""
+        with patch('hatch.cli_hatch.version', return_value='0.7.0-dev.3') as mock_version:
+            result = get_hatch_version()
+
+            self.assertEqual(result, '0.7.0-dev.3')
+            mock_version.assert_called_once_with('hatch')
+
+    @regression_test
+    def test_get_hatch_version_handles_package_not_found(self):
+        """Test get_hatch_version() handles PackageNotFoundError gracefully."""
+        from importlib.metadata import PackageNotFoundError
+
+        with patch('hatch.cli_hatch.version', side_effect=PackageNotFoundError()):
+            result = get_hatch_version()
+
+            self.assertEqual(result, 'unknown (development mode)')
+    
+    @integration_test(scope="component")
+    def test_version_command_displays_correct_format(self):
+        """Test version command displays correct format via CLI."""
+        test_args = ['hatch', '--version']
+        
+        with patch('sys.argv', test_args):
+            with patch('hatch.cli_hatch.get_hatch_version', return_value='0.7.0-dev.3'):
+                with patch('sys.stdout', new_callable=StringIO) as mock_stdout:
+                    with self.assertRaises(SystemExit) as cm:
+                        main()
+                    
+                    # argparse action='version' exits with code 0
+                    self.assertEqual(cm.exception.code, 0)
+                    
+                    # Verify output format: "hatch 0.7.0-dev.3"
+                    output = mock_stdout.getvalue().strip()
+                    self.assertRegex(output, r'hatch\s+0\.7\.0-dev\.3')
+    
+    @integration_test(scope="component")
+    def test_import_hatch_without_version_attribute(self):
+        """Test that importing hatch module works without __version__ attribute."""
+        try:
+            import hatch
+            
+            # Import should succeed
+            self.assertIsNotNone(hatch)
+            
+            # __version__ should not exist (removed in implementation)
+            self.assertFalse(hasattr(hatch, '__version__'),
+                            "hatch.__version__ should not exist after cleanup")
+            
+        except ImportError as e:
+            self.fail(f"Failed to import hatch module: {e}")
+    
+    @regression_test
+    def test_no_conflict_with_package_version_flag(self):
+        """Test that --version (Hatch) doesn't conflict with -v (package version)."""
+        # Test package add command with -v flag (package version specification)
+        test_args = ['hatch', 'package', 'add', 'test-package', '-v', '1.0.0']
+        
+        with patch('sys.argv', test_args):
+            with patch('hatch.cli_hatch.HatchEnvironmentManager') as mock_env:
+                mock_env_instance = MagicMock()
+                mock_env.return_value = mock_env_instance
+                mock_env_instance.add_package_to_environment.return_value = True
+                
+                try:
+                    main()
+                except SystemExit as e:
+                    # Should execute successfully (exit code 0)
+                    self.assertEqual(e.code, 0)
+                
+                # Verify package add was called with version argument
+                mock_env_instance.add_package_to_environment.assert_called_once()
+                call_args = mock_env_instance.add_package_to_environment.call_args
+                
+                # Version argument should be '1.0.0'
+                self.assertEqual(call_args[0][2], '1.0.0')  # Third positional arg is version
+
+
+if __name__ == '__main__':
+    unittest.main()
+

tests/test_data/packages/basic/base_pkg/hatch_mcp_server.py

@@ -0,0 +1,18 @@
+"""
+HatchMCP wrapper for base_pkg.
+"""
+import sys
+from pathlib import Path
+
+# Add package directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from mcp_server import mcp
+
+def main():
+    """Main entry point for HatchMCP wrapper."""
+    print("Starting base_pkg via HatchMCP wrapper")
+    mcp.run()
+
+if __name__ == "__main__":
+    main()

tests/test_data/packages/basic/base_pkg/mcp_server.py

@@ -0,0 +1,21 @@
+"""
+FastMCP server implementation for base_pkg.
+"""
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("base_pkg", log_level="WARNING")
+
+@mcp.tool()
+def base_pkg_tool(param: str) -> str:
+    """Example tool function for base_pkg.
+
+    Args:
+        param (str): Example parameter.
+
+    Returns:
+        str: Example result.
+    """
+    return f"Processed by base_pkg: {param}"
+
+if __name__ == "__main__":
+    mcp.run()

tests/test_data/packages/basic/base_pkg_v2/hatch_mcp_server.py

@@ -0,0 +1,18 @@
+"""
+HatchMCP wrapper for base_pkg_v2.
+"""
+import sys
+from pathlib import Path
+
+# Add package directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from mcp_server import mcp
+
+def main():
+    """Main entry point for HatchMCP wrapper."""
+    print("Starting base_pkg_v2 via HatchMCP wrapper")
+    mcp.run()
+
+if __name__ == "__main__":
+    main()

tests/test_data/packages/basic/base_pkg_v2/mcp_server.py

@@ -0,0 +1,21 @@
+"""
+FastMCP server implementation for base_pkg_v2.
+"""
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("base_pkg_v2", log_level="WARNING")
+
+@mcp.tool()
+def base_pkg_v2_tool(param: str) -> str:
+    """Example tool function for base_pkg_v2.
+
+    Args:
+        param (str): Example parameter.
+
+    Returns:
+        str: Example result.
+    """
+    return f"Processed by base_pkg_v2: {param}"
+
+if __name__ == "__main__":
+    mcp.run()

tests/test_data/packages/basic/utility_pkg/hatch_mcp_server.py

@@ -0,0 +1,18 @@
+"""
+HatchMCP wrapper for utility_pkg.
+"""
+import sys
+from pathlib import Path
+
+# Add package directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from mcp_server import mcp
+
+def main():
+    """Main entry point for HatchMCP wrapper."""
+    print("Starting utility_pkg via HatchMCP wrapper")
+    mcp.run()
+
+if __name__ == "__main__":
+    main()

tests/test_data/packages/basic/utility_pkg/mcp_server.py

@@ -0,0 +1,21 @@
+"""
+FastMCP server implementation for utility_pkg.
+"""
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("utility_pkg", log_level="WARNING")
+
+@mcp.tool()
+def utility_pkg_tool(param: str) -> str:
+    """Example tool function for utility_pkg.
+
+    Args:
+        param (str): Example parameter.
+
+    Returns:
+        str: Example result.
+    """
+    return f"Processed by utility_pkg: {param}"
+
+if __name__ == "__main__":
+    mcp.run()

tests/test_data/packages/dependencies/complex_dep_pkg/hatch_mcp_server.py

@@ -0,0 +1,18 @@
+"""
+HatchMCP wrapper for complex_dep_pkg.
+"""
+import sys
+from pathlib import Path
+
+# Add package directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from mcp_server import mcp
+
+def main():
+    """Main entry point for HatchMCP wrapper."""
+    print("Starting complex_dep_pkg via HatchMCP wrapper")
+    mcp.run()
+
+if __name__ == "__main__":
+    main()

tests/test_data/packages/dependencies/complex_dep_pkg/mcp_server.py

@@ -0,0 +1,21 @@
+"""
+FastMCP server implementation for complex_dep_pkg.
+"""
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("complex_dep_pkg", log_level="WARNING")
+
+@mcp.tool()
+def complex_dep_pkg_tool(param: str) -> str:
+    """Example tool function for complex_dep_pkg.
+
+    Args:
+        param (str): Example parameter.
+
+    Returns:
+        str: Example result.
+    """
+    return f"Processed by complex_dep_pkg: {param}"
+
+if __name__ == "__main__":
+    mcp.run()

tests/test_data/packages/dependencies/docker_dep_pkg/hatch_mcp_server.py

@@ -0,0 +1,18 @@
+"""
+HatchMCP wrapper for docker_dep_pkg.
+"""
+import sys
+from pathlib import Path
+
+# Add package directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from mcp_server import mcp
+
+def main():
+    """Main entry point for HatchMCP wrapper."""
+    print("Starting docker_dep_pkg via HatchMCP wrapper")
+    mcp.run()
+
+if __name__ == "__main__":
+    main()

tests/test_data/packages/dependencies/docker_dep_pkg/mcp_server.py

@@ -0,0 +1,21 @@
+"""
+FastMCP server implementation for docker_dep_pkg.
+"""
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("docker_dep_pkg", log_level="WARNING")
+
+@mcp.tool()
+def docker_dep_pkg_tool(param: str) -> str:
+    """Example tool function for docker_dep_pkg.
+
+    Args:
+        param (str): Example parameter.
+
+    Returns:
+        str: Example result.
+    """
+    return f"Processed by docker_dep_pkg: {param}"
+
+if __name__ == "__main__":
+    mcp.run()

tests/test_data/packages/dependencies/mixed_dep_pkg/hatch_mcp_server.py

@@ -0,0 +1,18 @@
+"""
+HatchMCP wrapper for mixed_dep_pkg.
+"""
+import sys
+from pathlib import Path
+
+# Add package directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from mcp_server import mcp
+
+def main():
+    """Main entry point for HatchMCP wrapper."""
+    print("Starting mixed_dep_pkg via HatchMCP wrapper")
+    mcp.run()
+
+if __name__ == "__main__":
+    main()

tests/test_data/packages/dependencies/mixed_dep_pkg/mcp_server.py

@@ -0,0 +1,21 @@
+"""
+FastMCP server implementation for mixed_dep_pkg.
+"""
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("mixed_dep_pkg", log_level="WARNING")
+
+@mcp.tool()
+def mixed_dep_pkg_tool(param: str) -> str:
+    """Example tool function for mixed_dep_pkg.
+
+    Args:
+        param (str): Example parameter.
+
+    Returns:
+        str: Example result.
+    """
+    return f"Processed by mixed_dep_pkg: {param}"
+
+if __name__ == "__main__":
+    mcp.run()

tests/test_data/packages/dependencies/python_dep_pkg/hatch_mcp_server.py

@@ -0,0 +1,18 @@
+"""
+HatchMCP wrapper for python_dep_pkg.
+"""
+import sys
+from pathlib import Path
+
+# Add package directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from mcp_server import mcp
+
+def main():
+    """Main entry point for HatchMCP wrapper."""
+    print("Starting python_dep_pkg via HatchMCP wrapper")
+    mcp.run()
+
+if __name__ == "__main__":
+    main()

tests/test_data/packages/dependencies/python_dep_pkg/mcp_server.py

@@ -0,0 +1,21 @@
+"""
+FastMCP server implementation for python_dep_pkg.
+"""
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("python_dep_pkg", log_level="WARNING")
+
+@mcp.tool()
+def python_dep_pkg_tool(param: str) -> str:
+    """Example tool function for python_dep_pkg.
+
+    Args:
+        param (str): Example parameter.
+
+    Returns:
+        str: Example result.
+    """
+    return f"Processed by python_dep_pkg: {param}"
+
+if __name__ == "__main__":
+    mcp.run()

tests/test_data/packages/dependencies/simple_dep_pkg/hatch_mcp_server.py

@@ -0,0 +1,18 @@
+"""
+HatchMCP wrapper for simple_dep_pkg.
+"""
+import sys
+from pathlib import Path
+
+# Add package directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from mcp_server import mcp
+
+def main():
+    """Main entry point for HatchMCP wrapper."""
+    print("Starting simple_dep_pkg via HatchMCP wrapper")
+    mcp.run()
+
+if __name__ == "__main__":
+    main()

tests/test_data/packages/dependencies/simple_dep_pkg/mcp_server.py

@@ -0,0 +1,21 @@
+"""
+FastMCP server implementation for simple_dep_pkg.
+"""
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("simple_dep_pkg", log_level="WARNING")
+
+@mcp.tool()
+def simple_dep_pkg_tool(param: str) -> str:
+    """Example tool function for simple_dep_pkg.
+
+    Args:
+        param (str): Example parameter.
+
+    Returns:
+        str: Example result.
+    """
+    return f"Processed by simple_dep_pkg: {param}"
+
+if __name__ == "__main__":
+    mcp.run()

tests/test_data/packages/dependencies/system_dep_pkg/hatch_mcp_server.py

@@ -0,0 +1,18 @@
+"""
+HatchMCP wrapper for system_dep_pkg.
+"""
+import sys
+from pathlib import Path
+
+# Add package directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from mcp_server import mcp
+
+def main():
+    """Main entry point for HatchMCP wrapper."""
+    print("Starting system_dep_pkg via HatchMCP wrapper")
+    mcp.run()
+
+if __name__ == "__main__":
+    main()

tests/test_data/packages/dependencies/system_dep_pkg/mcp_server.py

@@ -0,0 +1,21 @@
+"""
+FastMCP server implementation for system_dep_pkg.
+"""
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("system_dep_pkg", log_level="WARNING")
+
+@mcp.tool()
+def system_dep_pkg_tool(param: str) -> str:
+    """Example tool function for system_dep_pkg.
+
+    Args:
+        param (str): Example parameter.
+
+    Returns:
+        str: Example result.
+    """
+    return f"Processed by system_dep_pkg: {param}"
+
+if __name__ == "__main__":
+    mcp.run()

tests/test_data/packages/error_scenarios/circular_dep_pkg/hatch_mcp_server.py

@@ -0,0 +1,18 @@
+"""
+HatchMCP wrapper for circular_dep_pkg.
+"""
+import sys
+from pathlib import Path
+
+# Add package directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from mcp_server import mcp
+
+def main():
+    """Main entry point for HatchMCP wrapper."""
+    print("Starting circular_dep_pkg via HatchMCP wrapper")
+    mcp.run()
+
+if __name__ == "__main__":
+    main()

tests/test_data/packages/error_scenarios/circular_dep_pkg/mcp_server.py

@@ -0,0 +1,21 @@
+"""
+FastMCP server implementation for circular_dep_pkg.
+"""
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("circular_dep_pkg", log_level="WARNING")
+
+@mcp.tool()
+def circular_dep_pkg_tool(param: str) -> str:
+    """Example tool function for circular_dep_pkg.
+
+    Args:
+        param (str): Example parameter.
+
+    Returns:
+        str: Example result.
+    """
+    return f"Processed by circular_dep_pkg: {param}"
+
+if __name__ == "__main__":
+    mcp.run()