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.

9.6 KB
Raw Blame
from __future__ import annotations

import sys
from unittest.mock import patch

import pytest

from marimo._dependencies.dependencies import (
    Dependency,
    DependencyManager,
    DependencyRequirement,
    _version_check,
)
from marimo._dependencies.errors import ManyModulesNotFoundError


def test_dependencies() -> None:
    # Only testing 2 random dependencies
    if DependencyManager.altair.has():
        import altair

        assert altair is not None
        DependencyManager.altair.require("for testing")
        assert DependencyManager.altair.imported()
        assert DependencyManager.imported("altair")

    if DependencyManager.pandas.has():
        import pandas

        assert pandas is not None
        DependencyManager.pandas.require("for testing")
        assert DependencyManager.pandas.imported()
        assert DependencyManager.imported("pandas")


def test_without_dependencies() -> None:
    missing = Dependency("missing")
    assert missing is not None
    assert not missing.has()

    with pytest.raises(ModuleNotFoundError) as excinfo:
        missing.require("for testing")

    assert excinfo.value.name == "missing"

    assert "for testing" in str(excinfo.value)


def test_package_name_defaults_to_pkg() -> None:
    """Test that package_name defaults to pkg when not specified."""
    dep = Dependency("some_module")
    assert dep.pkg_name_to_install == "some_module"


def test_package_name_used_in_require() -> None:
    """Test that package_name is used in ModuleNotFoundError."""
    # When package_name differs from pkg, the error should use package_name
    missing = Dependency(
        "missing_module", pkg_name_to_install="missing-package"
    )
    assert not missing.has()

    with pytest.raises(ModuleNotFoundError) as excinfo:
        missing.require("for testing")

    # The error name should be the package_name, not the pkg
    assert excinfo.value.name == "missing-package"


def test_subpackage_cache_invalidation() -> None:
    """Test that subpackage dependencies properly invalidate importlib cache."""
    # Create a dependency for a missing subpackage
    missing_subpackage = Dependency("google.missing_package")

    with patch("importlib.invalidate_caches") as mock_invalidate:
        with pytest.raises(ModuleNotFoundError) as excinfo:
            missing_subpackage.require("for testing subpackage handling")

        # Verify the behavior
        assert excinfo.value.name == "google.missing_package"
        assert "for testing subpackage handling" in str(excinfo.value)

        # Verify that invalidate_caches was called for subpackage
        mock_invalidate.assert_called_once()

        # Verify that the module was removed from sys.modules
        assert "google.missing_package" not in sys.modules


def test_regular_package_no_cache_invalidation() -> None:
    """Test that regular packages (no dot) don't trigger cache invalidation."""

    # Create a dependency for a missing regular package
    missing_package = Dependency("missing_regular_package")

    with patch("importlib.invalidate_caches") as mock_invalidate:
        with pytest.raises(ModuleNotFoundError) as excinfo:
            missing_package.require("for testing regular package")

        # Verify the behavior
        assert excinfo.value.name == "missing_regular_package"
        assert "for testing regular package" in str(excinfo.value)

        # Verify that invalidate_caches was NOT called for regular package
        mock_invalidate.assert_not_called()


@pytest.mark.skipif(
    not DependencyManager.altair.has(),
    reason="altair is not installed",
)
def test_versions():
    assert (
        DependencyManager.altair.require_version(
            min_version="0.0.0", max_version="10.0.0"
        )
        is None
    )

    with pytest.raises(RuntimeError) as excinfo:
        DependencyManager.altair.require_version(min_version="10.0.0")

    version = DependencyManager.altair.get_version()
    assert (
        str(excinfo.value)
        == f"Mismatched version of altair: expected >=10.0.0, got {version}"
    )

    # Override version
    assert (
        DependencyManager.altair.has_at_version(
            min_version="0.0.0", max_version="10.0.0"
        )
        is True
    )
    assert (
        DependencyManager.altair.has_at_version(min_version="10.0.0") is False
    )

    with pytest.raises(RuntimeError) as excinfo:
        DependencyManager.altair.require_at_version(
            why="for testing", min_version="10.0.0"
        )

    assert (
        str(excinfo.value)
        == f"Mismatched version of altair: expected >=10.0.0, got {version}"
    )

    assert (
        DependencyManager.altair.require_at_version(
            why="for testing", min_version="2.0.0"
        )
        is None
    )


def test_has_as_version_when_not_installed():
    missing = Dependency("missing")
    assert missing is not None
    assert missing.has() is False
    assert missing.has_at_version(min_version="2.0.0") is False


def test_version_check():
    # within range
    assert (
        _version_check(pkg="test", v="1.0.0", min_v="0.0.0", max_v="2.0.0")
        is True
    )
    assert (
        _version_check(pkg="test", v="1.0.0", min_v="1.0.0", max_v="2.0.0")
        is True
    )

    # outside range
    assert (
        _version_check(pkg="test", v="0.4.0", min_v="1.0.0", max_v="2.0.0")
        is False
    )
    assert (
        _version_check(pkg="test", v="2.0.0", min_v="1.0.0", max_v="2.0.0")
        is False
    )

    # does not raise
    assert (
        _version_check(
            pkg="test",
            v="1.0.0",
            min_v="1.0.0",
            max_v="2.0.0",
            raise_error=True,
        )
        is True
    )
    assert (
        _version_check(
            pkg="test",
            v="1.5.0",
            min_v="1.0.0",
            max_v="2.0.0",
            raise_error=True,
        )
        is True
    )

    # too low
    with pytest.raises(RuntimeError) as excinfo:
        _version_check(
            pkg="test",
            v="1.0.0",
            min_v="2.0.0",
            max_v="3.0.0",
            raise_error=True,
        )

    assert (
        str(excinfo.value)
        == "Mismatched version of test: expected >=2.0.0, got 1.0.0"
    )

    with pytest.raises(RuntimeError) as excinfo:
        _version_check(
            pkg="test",
            v="3.0.0",
            min_v="2.0.0",
            max_v="3.0.0",
            raise_error=True,
        )

    # too high
    assert (
        str(excinfo.value)
        == "Mismatched version of test: expected <3.0.0, got 3.0.0"
    )


def test_require_many() -> None:
    """Test that require_many correctly raises ManyModulesNotFoundError."""

    missing1 = Dependency("missing1")
    missing2 = Dependency("missing2")

    # Test with all missing dependencies
    with pytest.raises(ManyModulesNotFoundError) as excinfo:
        DependencyManager.require_many(
            "for testing multiple dependencies",
            missing1,
            missing2,
            source="kernel",
        )

    assert excinfo.value.package_names == ["missing1", "missing2"]
    assert "for testing multiple dependencies" in str(excinfo.value)


def test_missing_packages_returns_unique_install_names() -> None:
    missing1 = Dependency(
        "missing_module1", pkg_name_to_install="missing-package"
    )
    missing2 = Dependency(
        "missing_module2", pkg_name_to_install="missing-package"
    )
    available = Dependency("available")

    with (
        patch.object(missing1, "has", return_value=False),
        patch.object(missing2, "has", return_value=False),
        patch.object(available, "has", return_value=True),
    ):
        assert DependencyManager.missing_packages(
            missing1,
            available,
            missing2,
        ) == ["missing-package"]


def test_missing_packages_supports_grouped_requirement() -> None:
    available = Dependency("available")
    missing = Dependency("missing")
    requirement = DependencyRequirement(
        package="feature[extra]",
        dependencies=(available, missing),
    )

    with (
        patch.object(available, "has", return_value=True),
        patch.object(missing, "has", return_value=False),
    ):
        assert DependencyManager.missing_packages(requirement) == [
            "feature[extra]"
        ]


def test_require_many_uses_package_name() -> None:
    """Test that require_many uses package_name when specified."""
    missing1 = Dependency(
        "missing_module1", pkg_name_to_install="missing-package-1"
    )
    missing2 = Dependency(
        "missing_module2", pkg_name_to_install="missing-package-2"
    )

    with pytest.raises(ManyModulesNotFoundError) as excinfo:
        DependencyManager.require_many(
            "for testing package names",
            missing1,
            missing2,
            source="kernel",
        )

    # Should use package_name, not pkg
    assert excinfo.value.package_names == [
        "missing-package-1",
        "missing-package-2",
    ]

    # Test with some dependencies available (if pandas is installed)
    if DependencyManager.pandas.has():
        with pytest.raises(ManyModulesNotFoundError) as excinfo:
            DependencyManager.require_many(
                "for testing mixed dependencies",
                DependencyManager.pandas,
                missing1,
                source="kernel",
            )

        assert excinfo.value.package_names == ["missing-package-1"]
        assert "for testing mixed dependencies" in str(excinfo.value)

        # Test with all dependencies available
        result = DependencyManager.require_many(
            "for testing available dependencies",
            DependencyManager.pandas,
            source="kernel",
        )
        assert result is None