test_packager.py

import os
from unittest import TestCase
from unittest.mock import Mock, patch

from aws_lambda_builders.architecture import X86_64
from aws_lambda_builders.workflows.python_uv.exceptions import MissingUvError, UvBuildError, UvInstallationError
from aws_lambda_builders.workflows.python_uv.packager import PythonUvDependencyBuilder, SubprocessUv, UvRunner
from aws_lambda_builders.workflows.python_uv.utils import UvConfig


class TestSubprocessUv(TestCase):
    @patch("aws_lambda_builders.workflows.python_uv.packager.OSUtils")
    def test_subprocess_uv_init_success(self, mock_osutils_class):
        mock_osutils = Mock()
        mock_osutils.which.return_value = "/usr/bin/uv"
        mock_osutils_class.return_value = mock_osutils

        subprocess_uv = SubprocessUv()
        self.assertEqual(subprocess_uv.uv_executable, "/usr/bin/uv")

    @patch("aws_lambda_builders.workflows.python_uv.packager.OSUtils")
    def test_subprocess_uv_init_success_windows_path(self, mock_osutils_class):
        """Test SubprocessUv initialization with Windows-style path."""
        mock_osutils = Mock()
        mock_osutils.which.return_value = "C:\\Users\\user\\AppData\\Local\\uv\\uv.exe"
        mock_osutils_class.return_value = mock_osutils

        subprocess_uv = SubprocessUv()
        self.assertEqual(subprocess_uv.uv_executable, "C:\\Users\\user\\AppData\\Local\\uv\\uv.exe")

    @patch("aws_lambda_builders.workflows.python_uv.packager.OSUtils")
    def test_subprocess_uv_init_missing_uv(self, mock_osutils_class):
        mock_osutils = Mock()
        mock_osutils.which.return_value = None
        mock_osutils_class.return_value = mock_osutils

        with self.assertRaises(MissingUvError):
            SubprocessUv()

    @patch("aws_lambda_builders.workflows.python_uv.packager.OSUtils")
    def test_run_uv_command_success(self, mock_osutils_class):
        mock_osutils = Mock()
        mock_osutils.which.return_value = "/usr/bin/uv"
        mock_osutils.run_subprocess.return_value = (0, "success", "")
        mock_osutils_class.return_value = mock_osutils

        subprocess_uv = SubprocessUv()
        rc, stdout, stderr = subprocess_uv.run_uv_command(["--version"])

        self.assertEqual(rc, 0)
        self.assertEqual(stdout, "success")
        self.assertEqual(stderr, "")
        mock_osutils.run_subprocess.assert_called_once_with(["/usr/bin/uv", "--version"], cwd=None, env=None)

    @patch("aws_lambda_builders.workflows.python_uv.packager.OSUtils")
    def test_run_uv_command_success_windows_path(self, mock_osutils_class):
        """Test run_uv_command with Windows-style path."""
        mock_osutils = Mock()
        windows_uv_path = "C:\\Users\\user\\AppData\\Local\\uv\\uv.exe"
        mock_osutils.which.return_value = windows_uv_path
        mock_osutils.run_subprocess.return_value = (0, "success", "")
        mock_osutils_class.return_value = mock_osutils

        subprocess_uv = SubprocessUv()
        rc, stdout, stderr = subprocess_uv.run_uv_command(["--version"])

        self.assertEqual(rc, 0)
        mock_osutils.run_subprocess.assert_called_once_with([windows_uv_path, "--version"], cwd=None, env=None)

    @patch("aws_lambda_builders.workflows.python_uv.packager.OSUtils")
    def test_get_uv_version_success(self, mock_osutils_class):
        mock_osutils = Mock()
        mock_osutils.which.return_value = "/usr/bin/uv"
        mock_osutils.run_subprocess.return_value = (0, "uv 0.6.16", "")
        mock_osutils_class.return_value = mock_osutils

        subprocess_uv = SubprocessUv()
        version = subprocess_uv.get_uv_version()

        self.assertEqual(version, "0.6.16")

    @patch("aws_lambda_builders.workflows.python_uv.packager.OSUtils")
    def test_get_uv_version_failure(self, mock_osutils_class):
        mock_osutils = Mock()
        mock_osutils.which.return_value = "/usr/bin/uv"
        mock_osutils.run_subprocess.return_value = (1, "", "error")
        mock_osutils_class.return_value = mock_osutils

        subprocess_uv = SubprocessUv()
        version = subprocess_uv.get_uv_version()

        self.assertIsNone(version)


class TestUvRunner(TestCase):
    def setUp(self):
        self.mock_subprocess_uv = Mock()
        self.mock_subprocess_uv.uv_executable = "/usr/bin/uv"
        self.mock_osutils = Mock()
        self.uv_runner = UvRunner(uv_subprocess=self.mock_subprocess_uv, osutils=self.mock_osutils)

    def test_uv_version_property(self):
        self.mock_subprocess_uv.get_uv_version.return_value = "0.6.16"

        version = self.uv_runner.uv_version
        self.assertEqual(version, "0.6.16")
        self.mock_subprocess_uv.get_uv_version.assert_called_once()

    def test_install_requirements_success(self):
        self.mock_subprocess_uv.run_uv_command.return_value = (0, "success", "")

        self.uv_runner.install_requirements(
            requirements_path="/path/to/requirements.txt",
            target_dir="/target",
            scratch_dir="/scratch",
            python_version="3.9",
            platform="linux",
            architecture=X86_64,
        )

        # Verify UV pip install command was called
        args_called = self.mock_subprocess_uv.run_uv_command.call_args[0][0]
        self.assertIn("pip", args_called)
        self.assertIn("install", args_called)
        self.assertIn("-r", args_called)
        self.assertIn("/path/to/requirements.txt", args_called)

    def test_install_requirements_failure(self):
        self.mock_subprocess_uv.run_uv_command.return_value = (1, "", "error message")

        with self.assertRaises(UvInstallationError):
            self.uv_runner.install_requirements(
                requirements_path="/path/to/requirements.txt", target_dir="/target", scratch_dir="/scratch"
            )


class TestPythonUvDependencyBuilder(TestCase):
    def setUp(self):
        self.mock_osutils = Mock()
        self.mock_uv_runner = Mock()
        self.builder = PythonUvDependencyBuilder(
            osutils=self.mock_osutils, runtime="python3.9", uv_runner=self.mock_uv_runner
        )

    def test_extract_python_version(self):
        self.assertEqual(self.builder._extract_python_version("python3.9"), "3.9")
        self.assertEqual(self.builder._extract_python_version("python3.11"), "3.11")
        self.assertEqual(self.builder._extract_python_version("3.10"), "3.10")

        # Runtime is required - should raise error when None
        with self.assertRaises(UvBuildError) as context:
            self.builder._extract_python_version(None)
        self.assertIn("Runtime is required", str(context.exception))

        # Empty string should also raise error
        with self.assertRaises(UvBuildError) as context:
            self.builder._extract_python_version("")
        self.assertIn("Runtime is required", str(context.exception))

    def test_build_from_lock_file(self):
        # Mock the uv command for export
        self.mock_uv_runner._uv.run_uv_command.return_value = (0, b"", b"")

        self.builder._build_from_lock_file(
            lock_path="/path/to/uv.lock",
            target_dir="/target",
            scratch_dir="/scratch",
            python_version="3.9",
            architecture=X86_64,
            config=UvConfig(),
        )

        # Should call export then install_requirements
        self.mock_uv_runner._uv.run_uv_command.assert_called_once()
        self.mock_uv_runner.install_requirements.assert_called_once()

    def test_build_from_requirements(self):
        self.builder._build_from_requirements(
            requirements_path="/path/to/requirements.txt",
            target_dir="/target",
            scratch_dir="/scratch",
            python_version="3.9",
            architecture=X86_64,
            config=UvConfig(),
        )

        self.mock_uv_runner.install_requirements.assert_called_once()

    def test_build_dependencies_with_requirements_txt(self):
        with patch("os.path.basename", return_value="requirements.txt"):
            self.builder.build_dependencies(
                artifacts_dir_path="/artifacts",
                scratch_dir_path="/scratch",
                manifest_path="/path/to/requirements.txt",
                architecture=X86_64,
            )

        self.mock_uv_runner.install_requirements.assert_called_once()

    def test_build_dependencies_with_uv_lock_standalone_fails(self):
        """Test that uv.lock as standalone manifest fails (requires pyproject.toml)."""
        with patch("os.path.basename", return_value="uv.lock"):
            with self.assertRaises(UvBuildError) as context:
                self.builder.build_dependencies(
                    artifacts_dir_path="/artifacts",
                    scratch_dir_path="/scratch",
                    manifest_path="/path/to/uv.lock",
                    architecture=X86_64,
                )

            self.assertIn("Unsupported manifest file: uv.lock", str(context.exception))

        # Should not call any UV operations for unsupported manifest
        self.mock_uv_runner.sync_dependencies.assert_not_called()
        self.mock_uv_runner.install_requirements.assert_not_called()

    def test_build_dependencies_pyproject_with_uv_lock(self):
        """Test that pyproject.toml with uv.lock present uses lock-based build."""
        # Mock the uv export command
        self.mock_uv_runner._uv.run_uv_command.return_value = (0, b"", b"")

        with patch("os.path.basename", return_value="pyproject.toml"), patch(
            "os.path.dirname", return_value=os.path.join("path", "to")
        ), patch("os.path.exists") as mock_exists:

            # Mock that uv.lock exists alongside pyproject.toml
            mock_exists.return_value = True

            self.builder.build_dependencies(
                artifacts_dir_path="/artifacts",
                scratch_dir_path="/scratch",
                manifest_path="/path/to/pyproject.toml",
                architecture=X86_64,
            )

        # Should use export + install_requirements (for cross-platform support)
        self.mock_uv_runner._uv.run_uv_command.assert_called_once()  # export
        self.mock_uv_runner.install_requirements.assert_called_once()

        # Verify it checked for uv.lock in the right location
        mock_exists.assert_called_with(os.path.join("path", "to", "uv.lock"))

    def test_build_dependencies_pyproject_without_uv_lock(self):
        """Test that pyproject.toml without uv.lock uses standard pyproject build."""
        with patch("os.path.basename", return_value="pyproject.toml"), patch(
            "os.path.dirname", return_value=os.path.join("path", "to")
        ), patch("os.path.exists") as mock_exists:
            # Mock that uv.lock does NOT exist alongside pyproject.toml
            mock_exists.return_value = False

            self.mock_uv_runner._uv.run_uv_command.return_value = (0, b"", b"")
            self.builder.build_dependencies(
                artifacts_dir_path="/artifacts",
                scratch_dir_path="/scratch",
                manifest_path="/path/to/pyproject.toml",
                architecture=X86_64,
            )

        # Should use install_requirements (standard pyproject build)
        self.mock_uv_runner.install_requirements.assert_called_once()
        self.mock_uv_runner.sync_dependencies.assert_not_called()

        # Verify it checked for uv.lock in the right location
        mock_exists.assert_called_with(os.path.join("path", "to", "uv.lock"))

    def test_build_dependencies_passes_scratch_dir(self):
        """Test that build_dependencies passes scratch_dir to UvRunner for cache configuration."""
        with patch("os.path.basename", return_value="requirements.txt"):
            self.builder.build_dependencies(
                artifacts_dir_path="/artifacts",
                scratch_dir_path="/scratch",
                manifest_path="/path/to/requirements.txt",
                architecture=X86_64,
            )

        # Verify that install_requirements was called with scratch_dir
        # UvRunner._ensure_cache_dir() will use this to configure the cache
        call_args = self.mock_uv_runner.install_requirements.call_args
        self.assertEqual(call_args[1]["scratch_dir"], "/scratch")

    def test_build_dependencies_respects_existing_cache_dir(self):
        """Test that existing cache_dir in config is respected."""
        config = UvConfig(cache_dir="/custom/cache")

        with patch("os.path.basename", return_value="requirements.txt"):
            self.builder.build_dependencies(
                artifacts_dir_path="/artifacts",
                scratch_dir_path="/scratch",
                manifest_path="/path/to/requirements.txt",
                architecture=X86_64,
                config=config,
            )

        # Verify that the custom cache directory is preserved
        call_args = self.mock_uv_runner.install_requirements.call_args
        passed_config = call_args[1]["config"]
        self.assertEqual(passed_config.cache_dir, "/custom/cache")

    def test_is_requirements_file_standard_names(self):
        # Test standard requirements file name
        self.assertTrue(self.builder._is_requirements_file("requirements.txt"))

    def test_is_requirements_file_environment_specific(self):
        # Test environment-specific requirements files
        self.assertTrue(self.builder._is_requirements_file("requirements-dev.txt"))
        self.assertTrue(self.builder._is_requirements_file("requirements-test.txt"))
        self.assertTrue(self.builder._is_requirements_file("requirements-prod.txt"))
        self.assertTrue(self.builder._is_requirements_file("requirements-staging.txt"))

    def test_is_requirements_file_invalid_names(self):
        # Test invalid requirements file names
        self.assertFalse(self.builder._is_requirements_file("requirements"))
        self.assertFalse(self.builder._is_requirements_file("requirements.in"))
        self.assertFalse(self.builder._is_requirements_file("requirements.py"))
        self.assertFalse(self.builder._is_requirements_file("my-requirements.txt"))
        self.assertFalse(self.builder._is_requirements_file("requirements.txt.bak"))
        self.assertFalse(self.builder._is_requirements_file("requirements-"))
        self.assertFalse(self.builder._is_requirements_file("requirements-.txt"))