Skip to content

A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.

22.9 KB
Raw Blame
from __future__ import annotations

import os
import sys
from typing import Any
from unittest.mock import AsyncMock, MagicMock, patch

import pytest

from marimo._dependencies.dependencies import DependencyManager
from marimo._environments import script_metadata
from marimo._environments.uv import UvNotFoundError
from marimo._runtime.packages.package_manager import LogCallback
from marimo._runtime.packages.package_managers import create_package_manager
from marimo._runtime.packages.pypi_package_manager import (
    PY_EXE,
    MicropipPackageManager,
    PipPackageManager,
    RyePackageManager,
    UvPackageManager,
    VersionMap,
)

# Metadata edits absolutize the --script target.
NB_ABSPATH = os.path.abspath("nb.py")


def test_create_package_managers() -> None:
    assert isinstance(create_package_manager("pip"), PipPackageManager)
    assert isinstance(
        create_package_manager("micropip"), MicropipPackageManager
    )
    assert isinstance(create_package_manager("rye"), RyePackageManager)
    assert isinstance(create_package_manager("uv"), UvPackageManager)

    with pytest.raises(RuntimeError) as e:
        create_package_manager("foobar")
    assert "Unknown package manager" in str(e)


def test_create_package_manager_with_python_exe() -> None:
    """Test that create_package_manager passes python_exe to package managers."""
    custom_python = "/path/to/custom/python"

    pip_mgr = create_package_manager("pip", python_exe=custom_python)
    assert isinstance(pip_mgr, PipPackageManager)
    assert pip_mgr._python_exe == custom_python

    uv_mgr = create_package_manager("uv", python_exe=custom_python)
    assert isinstance(uv_mgr, UvPackageManager)
    assert uv_mgr._python_exe == custom_python


def test_create_package_manager_without_python_exe() -> None:
    """Test that create_package_manager defaults python_exe to PY_EXE."""
    pip_mgr = create_package_manager("pip")
    assert isinstance(pip_mgr, PipPackageManager)
    assert pip_mgr._python_exe == PY_EXE

    uv_mgr = create_package_manager("uv")
    assert isinstance(uv_mgr, UvPackageManager)
    assert uv_mgr._python_exe == PY_EXE


def test_sandbox_backend_overrides_configured_package_manager() -> None:
    from marimo._runtime.packages.sandbox_package_manager import (
        SandboxPackageManager,
    )

    manager = create_package_manager(
        "pip",
        script_path="nb.py",
        sandbox_backend="pixi",
    )

    assert isinstance(manager, SandboxPackageManager)
    assert manager.name == "pixi"


async def test_sandbox_package_manager_splits_package_operations() -> None:
    from marimo._runtime.packages.sandbox_package_manager import (
        SandboxPackageManager,
    )

    sandbox = MagicMock()
    sandbox.backend = "uv"
    sandbox.environment = None
    manager = SandboxPackageManager(sandbox)

    assert await manager._install(
        "foo==1.0 bar[extra]",
        upgrade=True,
        log_callback=None,
    )
    assert await manager.uninstall("foo bar")

    assert [call.args[0] for call in sandbox.add.call_args_list] == [
        "foo==1.0",
        "bar[extra]",
    ]
    assert [call.args[0] for call in sandbox.remove.call_args_list] == [
        "foo",
        "bar",
    ]


@pytest.fixture
def uv_calls(monkeypatch: pytest.MonkeyPatch) -> list[list[str]]:
    """Capture uv invocations made through the script_metadata verbs."""
    calls: list[list[str]] = []

    def fake_uv(args: list[str], **kwargs: Any) -> MagicMock:
        target = args[args.index("--script") + 1]
        assert os.path.isabs(target)
        assert kwargs["cwd"] == os.path.dirname(target)
        calls.append(["uv", *args])
        return MagicMock()

    monkeypatch.setattr(script_metadata, "uv", fake_uv)
    return calls


def test_update_script_metadata(uv_calls: list[list[str]]) -> None:
    runs_calls = uv_calls

    class MockUvPackageManager(UvPackageManager):
        def _get_version_map(self) -> VersionMap:
            return VersionMap({"foo": "1.0", "bar": "2.0"})

    pm = MockUvPackageManager()
    pm.update_notebook_script_metadata(
        "nb.py",
        packages_to_add=["foo"],
        packages_to_remove=["bar"],
        upgrade=False,
    )
    assert runs_calls == [
        ["uv", "--quiet", "add", "--script", NB_ABSPATH, "foo==1.0"],
        ["uv", "--quiet", "remove", "--script", NB_ABSPATH, "bar"],
    ]

    runs_calls.clear()


@pytest.mark.parametrize("failures", [{"add"}, {"remove"}, {"add", "remove"}])
def test_metadata_updates_attempt_both_operations_on_failure(
    monkeypatch: pytest.MonkeyPatch, failures: set[str]
) -> None:
    manager = UvPackageManager()
    monkeypatch.setattr(
        manager, "_get_version_map", lambda: VersionMap({"foo": "1.0"})
    )
    operations: list[str] = []

    def run(args: list[str], **kwargs: Any) -> MagicMock:
        del kwargs
        operation = args[1]
        operations.append(operation)
        if operation in failures:
            raise UvNotFoundError()
        return MagicMock()

    monkeypatch.setattr(script_metadata, "uv", run)

    assert not manager.update_notebook_script_metadata(
        "nb.py",
        packages_to_add=["foo"],
        packages_to_remove=["bar"],
        upgrade=False,
    )
    assert operations == ["add", "remove"]


def test_update_script_metadata_with_version_map(
    uv_calls: list[list[str]],
) -> None:
    runs_calls = uv_calls

    class MockUvPackageManager(UvPackageManager):
        def _get_version_map(self) -> VersionMap:
            return VersionMap({"foo": "1.0", "bar": "2.0"})

    pm = MockUvPackageManager()
    # It should ignore when not in the version map
    # as this implies it failed to install
    pm.update_notebook_script_metadata(
        "nb.py", packages_to_add=["baz"], upgrade=False
    )
    assert runs_calls == []

    # It will attempt to uninstall even if not in the version map
    pm.update_notebook_script_metadata(
        "nb.py", packages_to_remove=["baz"], upgrade=False
    )
    assert runs_calls == [
        ["uv", "--quiet", "remove", "--script", NB_ABSPATH, "baz"],
    ]


def test_update_script_metadata_with_mapping(
    uv_calls: list[list[str]],
) -> None:
    runs_calls = uv_calls

    class MockUvPackageManager(UvPackageManager):
        def _get_version_map(self) -> VersionMap:
            return VersionMap(
                {"ibis": "2.0", "ibis-framework": "2.0", "pyyaml": "1.0"}
            )

    pm = MockUvPackageManager()
    # It should not canonicalize when passed explicitly
    pm.update_notebook_script_metadata(
        "nb.py", packages_to_add=["ibis"], upgrade=False
    )
    assert runs_calls == [
        ["uv", "--quiet", "add", "--script", NB_ABSPATH, "ibis==2.0"],
    ]
    runs_calls.clear()

    # It should not canonicalize when passed as an import name
    # case-insensitive
    pm.update_notebook_script_metadata(
        "nb.py", import_namespaces_to_add=["yaml"], upgrade=False
    )
    assert runs_calls == [
        ["uv", "--quiet", "add", "--script", NB_ABSPATH, "pyyaml==1.0"],
    ]
    runs_calls.clear()

    # It should not canonicalize when passed as an import name
    # and works with brackets
    pm.update_notebook_script_metadata(
        "nb.py", import_namespaces_to_add=["ibis"], upgrade=False
    )
    assert runs_calls == [
        [
            "uv",
            "--quiet",
            "add",
            "--script",
            NB_ABSPATH,
            "ibis-framework[duckdb]==2.0",
        ],
    ]


def test_update_script_metadata_marimo_packages(
    uv_calls: list[list[str]],
) -> None:
    runs_calls = uv_calls

    class MockUvPackageManager(UvPackageManager):
        def _get_version_map(self) -> VersionMap:
            return VersionMap(
                {
                    "marimo": "0.1.0",
                    "marimo-ai": "0.2.0",
                    "pandas": "2.0.0",
                }
            )

    pm = MockUvPackageManager()

    # Test 1: Basic package handling
    pm.update_notebook_script_metadata(
        filepath="nb.py",
        packages_to_add=[
            "marimo-ai",  # Should have version (different package)
            "pandas",  # Should have version
        ],
        upgrade=False,
    )
    assert runs_calls == [
        [
            "uv",
            "--quiet",
            "add",
            "--script",
            NB_ABSPATH,
            "marimo-ai==0.2.0",
            "pandas==2.0.0",
        ]
    ]
    runs_calls.clear()

    # Test 2: Marimo package consolidation - should prefer marimo[ai] over marimo
    pm.update_notebook_script_metadata(
        filepath="nb.py",
        packages_to_add=[
            "marimo",
            "marimo[sql]",
            "pandas",
        ],
        upgrade=False,
    )
    assert runs_calls == [
        [
            "uv",
            "--quiet",
            "add",
            "--script",
            NB_ABSPATH,
            "marimo",
            "marimo[sql]",
            "pandas==2.0.0",
        ]
    ]
    runs_calls.clear()

    # Test 3: Multiple marimo extras - should use first one
    pm.update_notebook_script_metadata(
        filepath="nb.py",
        packages_to_add=[
            "marimo",
            "marimo[sql]",
            "marimo[recommended]",
            "pandas",
        ],
        upgrade=False,
    )
    assert runs_calls == [
        [
            "uv",
            "--quiet",
            "add",
            "--script",
            NB_ABSPATH,
            "marimo",
            "marimo[sql]",
            "marimo[recommended]",
            "pandas==2.0.0",
        ]
    ]
    runs_calls.clear()

    # Test 4: Only plain marimo
    pm.update_notebook_script_metadata(
        filepath="nb.py",
        packages_to_add=[
            "marimo",
            "pandas",
        ],
        upgrade=False,
    )
    assert runs_calls == [
        [
            "uv",
            "--quiet",
            "add",
            "--script",
            NB_ABSPATH,
            "marimo",
            "pandas==2.0.0",
        ]
    ]
    runs_calls.clear()

    # Test 5: Upgrade
    pm.update_notebook_script_metadata(
        filepath="nb.py",
        packages_to_add=["pandas"],
        upgrade=True,
    )
    assert runs_calls == [
        [
            "uv",
            "--quiet",
            "add",
            "--script",
            NB_ABSPATH,
            "--upgrade",
            "pandas==2.0.0",
        ],
    ]
    runs_calls.clear()


async def test_uv_pip_install() -> None:
    runs_calls: list[list[str]] = []

    with (
        patch(
            "marimo._runtime.packages.pypi_package_manager.UvPackageManager.is_in_uv_project",
            new=property(lambda _: False),
        ),
        patch(
            "marimo._runtime.packages.pypi_package_manager.UvPackageManager._uv_bin",
            new=property(lambda _: "uv"),
        ),
        patch("marimo._utils.subprocess.subprocess.Popen") as mock_popen,
        patch("sys.stdout.buffer.write"),
    ):
        mock_proc = MagicMock()
        mock_proc.stdout.readline.return_value = b""
        mock_proc.wait.return_value = 0
        mock_popen.return_value = mock_proc

        def capture_command(*args: Any, **kwargs: Any):
            del kwargs
            runs_calls.append(args[0])
            return mock_proc

        mock_popen.side_effect = capture_command

        pm = UvPackageManager()
        await pm._install("foo", upgrade=False, group=None)

        assert runs_calls == [
            ["uv", "pip", "install", "foo", "-p", PY_EXE],
        ]


async def test_package_manager_run_without_callback() -> None:
    """Test PackageManager.run without log callback (backward compatibility)."""
    pm = PipPackageManager()

    with (
        patch("subprocess.run") as mock_run,
        patch.object(pm, "is_manager_installed", return_value=True),
    ):
        mock_run.return_value.returncode = 0
        result = await pm.run(["echo", "test"], log_callback=None)

        assert result is True
        mock_run.assert_called_once_with(
            ["echo", "test"], start_new_session=True
        )


async def test_package_manager_run_with_callback() -> None:
    """Test PackageManager.run with log callback streams output."""
    pm = PipPackageManager()
    captured_logs = []

    def log_callback(log_line: str) -> None:
        captured_logs.append(log_line)

    mock_stdout_lines = [
        b"Installing package...\n",
        b"Successfully installed!\n",
    ]

    with (
        patch("marimo._utils.subprocess.subprocess.Popen") as mock_popen,
        patch("sys.stdout.buffer.write") as mock_buffer_write,
        patch.object(pm, "is_manager_installed", return_value=True),
    ):
        # Mock the subprocess.Popen to return our test output
        mock_proc = MagicMock()
        mock_proc.stdout.readline.side_effect = mock_stdout_lines + [
            b""
        ]  # End with empty bytes
        mock_proc.wait.return_value = 0
        mock_popen.return_value = mock_proc

        result = await pm.run(["echo", "test"], log_callback=log_callback)

        assert result is True
        assert captured_logs == [
            "Installing package...\n",
            "Successfully installed!\n",
        ]

        # Verify buffer write was called for terminal output
        assert mock_buffer_write.call_count == len(mock_stdout_lines)
        mock_buffer_write.assert_any_call(b"Installing package...\n")
        mock_buffer_write.assert_any_call(b"Successfully installed!\n")


async def test_package_manager_run_with_callback_failure() -> None:
    """Test PackageManager.run with log callback handles failure."""
    pm = PipPackageManager()
    captured_logs = []

    def log_callback(log_line: str) -> None:
        captured_logs.append(log_line)

    with (
        patch("marimo._utils.subprocess.subprocess.Popen") as mock_popen,
        patch.object(pm, "is_manager_installed", return_value=True),
    ):
        mock_proc = MagicMock()
        mock_proc.stdout.readline.side_effect = [
            b"Error occurred\n",
            b"",
        ]  # End with empty bytes
        mock_proc.wait.return_value = 1  # Non-zero return code
        mock_popen.return_value = mock_proc

        result = await pm.run(["failing_command"], log_callback=log_callback)

        assert result is False
        assert captured_logs == ["Error occurred\n"]


async def test_pip_install_with_log_callback() -> None:
    """Test PipPackageManager._install with log callback."""
    captured_logs = []

    def log_callback(log_line: str) -> None:
        captured_logs.append(log_line)

    class MockPipPackageManager(PipPackageManager):
        async def run(
            self,
            command: list[str],
            log_callback: LogCallback | None = None,
        ) -> bool:
            del command
            if log_callback:
                log_callback("Installing numpy...\n")
                log_callback("Successfully installed numpy\n")
            return True

    pm = MockPipPackageManager()
    result = await pm._install(
        "numpy", upgrade=False, group=None, log_callback=log_callback
    )

    assert result is True
    assert captured_logs == [
        "Installing numpy...\n",
        "Successfully installed numpy\n",
    ]


async def test_uv_install_with_log_callback() -> None:
    """Test UvPackageManager._install with log callback."""
    captured_logs = []

    def log_callback(log_line: str) -> None:
        captured_logs.append(log_line)

    mock_stdout_lines = [
        b"Resolving dependencies...\n",
        b"Installing packages...\n",
    ]

    with (
        patch("marimo._utils.subprocess.subprocess.Popen") as mock_popen,
        patch("sys.stdout.buffer.write"),
    ):
        mock_proc = MagicMock()
        mock_proc.stdout.readline.side_effect = mock_stdout_lines + [b""]
        mock_proc.wait.return_value = 0
        mock_popen.return_value = mock_proc

        pm = UvPackageManager()
        result = await pm._install(
            "pandas", upgrade=False, group=None, log_callback=log_callback
        )

        assert result is True
        assert captured_logs == [
            "Resolving dependencies...\n",
            "Installing packages...\n",
        ]


async def test_micropip_install_with_log_callback() -> None:
    """Test MicropipPackageManager._install with log callback."""
    captured_logs = []

    def log_callback(log_line: str) -> None:
        captured_logs.append(log_line)

    pm = MicropipPackageManager()

    mock_micropip = MagicMock()
    mock_micropip.install = AsyncMock(return_value=None)

    with (
        patch("marimo._utils.platform.is_pyodide", return_value=True),
        patch(
            "marimo._runtime.packages.pypi_package_manager.is_pyodide",
            return_value=True,
        ),
        patch.dict(sys.modules, {"micropip": mock_micropip}),
    ):
        result = await pm._install(
            "requests", upgrade=False, group=None, log_callback=log_callback
        )

        assert result is True
        assert len(captured_logs) == 2
        assert "Installing requests with micropip" in captured_logs[0]
        assert "Successfully installed requests" in captured_logs[1]


async def test_package_manager_install_method_with_callback() -> None:
    """Test PackageManager.install method passes log_callback to _install."""
    captured_logs = []

    def log_callback(log_line: str) -> None:
        captured_logs.append(log_line)

    class MockPackageManager(PipPackageManager):
        async def _install(
            self,
            package: str,
            *,
            upgrade: bool,
            group: str | None = None,
            log_callback: LogCallback | None = None,
        ) -> bool:
            del group
            del upgrade
            if log_callback:
                log_callback(f"Installing {package}...\n")
            return True

    pm = MockPackageManager()
    result = await pm.install(
        "test-package", version="1.0.0", log_callback=log_callback
    )

    assert result is True
    assert captured_logs == ["Installing test-package==1.0.0...\n"]


def test_update_script_metadata_with_git_dependencies(
    uv_calls: list[list[str]],
) -> None:
    """Test that git dependencies are passed through to uv add --script."""
    runs_calls = uv_calls

    class MockUvPackageManager(UvPackageManager):
        def _get_version_map(self) -> VersionMap:
            # Git dependencies won't be in the version map with their git+ prefix
            return VersionMap({"python-gcode": "0.1.0"})

    pm = MockUvPackageManager()

    # Test 1: Git dependency with https
    pm.update_notebook_script_metadata(
        "nb.py",
        packages_to_add=["git+https://github.com/fetlab/python_gcode"],
        upgrade=False,
    )
    # Should pass through git URL even though not in version map
    assert runs_calls == [
        [
            "uv",
            "--quiet",
            "add",
            "--script",
            NB_ABSPATH,
            "git+https://github.com/fetlab/python_gcode",
        ],
    ]
    runs_calls.clear()

    # Test 2: Git dependency with ssh
    pm.update_notebook_script_metadata(
        "nb.py",
        packages_to_add=["git+ssh://[email protected]/user/repo.git"],
        upgrade=False,
    )
    assert runs_calls == [
        [
            "uv",
            "--quiet",
            "add",
            "--script",
            NB_ABSPATH,
            "git+ssh://[email protected]/user/repo.git",
        ],
    ]
    runs_calls.clear()

    # Test 3: Direct URL reference with @
    pm.update_notebook_script_metadata(
        "nb.py",
        packages_to_add=["package @ https://example.com/package.whl"],
        upgrade=False,
    )
    assert runs_calls == [
        [
            "uv",
            "--quiet",
            "add",
            "--script",
            NB_ABSPATH,
            "package @ https://example.com/package.whl",
        ],
    ]
    runs_calls.clear()

    # Test 4: Local path reference with @
    pm.update_notebook_script_metadata(
        "nb.py",
        packages_to_add=["mypackage @ file:///path/to/package"],
        upgrade=False,
    )
    assert runs_calls == [
        [
            "uv",
            "--quiet",
            "add",
            "--script",
            NB_ABSPATH,
            "mypackage @ file:///path/to/package",
        ],
    ]
    runs_calls.clear()

    # Test 5: Mix of regular and git dependencies
    pm.update_notebook_script_metadata(
        "nb.py",
        packages_to_add=[
            "python-gcode",  # Regular package, should get version
            "git+https://github.com/user/repo.git",  # Git dep, no version
        ],
        upgrade=False,
    )
    assert runs_calls == [
        [
            "uv",
            "--quiet",
            "add",
            "--script",
            NB_ABSPATH,
            "python-gcode==0.1.0",
            "git+https://github.com/user/repo.git",
        ],
    ]


async def test_package_manager_run_manager_not_installed() -> None:
    """Test PackageManager.run when manager is not installed."""
    pm = PipPackageManager()

    with patch.object(pm, "is_manager_installed", return_value=False):
        result = await pm.run(["test", "command"], log_callback=None)
        assert result is False

        # Should also return False with log callback
        result = await pm.run(["test", "command"], log_callback=lambda _: None)
        assert result is False


# Encoding tests for Windows compatibility


@pytest.mark.skipif(
    not DependencyManager.which("poetry"), reason="poetry not installed"
)
@patch("subprocess.run")
def test_poetry_list_packages_uses_utf8_encoding(mock_run: MagicMock):
    """Test that poetry list uses UTF-8 encoding to handle non-ASCII characters"""
    from marimo._runtime.packages.pypi_package_manager import (
        PoetryPackageManager,
    )

    mock_output = "package-中文    1.0.0\npакет    2.0.0\n"
    mock_run.return_value = MagicMock(returncode=0, stdout=mock_output)
    mgr = PoetryPackageManager()

    packages = mgr.list_packages()

    # Verify encoding='utf-8' is passed (PoetryPackageManager does multiple subprocess calls)
    encoding_calls = [
        kwargs
        for _, kwargs in mock_run.call_args_list
        if kwargs.get("encoding") == "utf-8"
    ]
    assert encoding_calls, "Expected at least one call with encoding='utf-8'"
    assert all(call.get("text") is True for call in encoding_calls)


@pytest.mark.skipif(
    not DependencyManager.which("pixi"), reason="pixi not installed"
)
@patch("subprocess.run")
def test_pixi_list_packages_uses_utf8_encoding(mock_run: MagicMock):
    """Test that pixi list uses UTF-8 encoding to handle non-ASCII characters"""
    import json

    from marimo._runtime.packages.conda_package_manager import (
        PixiPackageManager,
    )

    mock_output = json.dumps(
        [
            {"name": "package-中文", "version": "1.0.0"},
            {"name": "пакет", "version": "2.0.0"},
        ]
    )
    mock_run.return_value = MagicMock(returncode=0, stdout=mock_output)
    mgr = PixiPackageManager()

    packages = mgr.list_packages()

    # Verify encoding='utf-8' is passed
    mock_run.assert_called_once()
    call_kwargs = mock_run.call_args[1]
    assert call_kwargs.get("encoding") == "utf-8"
    assert call_kwargs.get("text") is True