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.

39.4 KB
Raw Blame
# Copyright 2026 Marimo. All rights reserved.
from __future__ import annotations

import asyncio
import json
import unittest.mock
from pathlib import Path
from textwrap import dedent
from types import SimpleNamespace
from typing import TYPE_CHECKING, Any
from unittest.mock import MagicMock, Mock, patch

import msgspec
import pytest

from marimo._ast.app_config import _AppConfig
from marimo._config.config import DEFAULT_CONFIG, merge_config
from marimo._dependencies.dependencies import DependencyManager
from marimo._messaging.types import KernelMessage
from marimo._pyodide.pyodide_session import (
    AsyncQueueManager,
    PyodideBridge,
    PyodideSession,
    _launch_pyodide_kernel,
    parse_command,
)
from marimo._runtime.commands import (
    AppMetadata,
    ClearCacheCommand,
    CreateNotebookCommand,
    DebugCellCommand,
    DeleteCellCommand,
    ExecuteCellsCommand,
    ExecuteScratchpadCommand,
    ExecuteStaleCellsCommand,
    GetCacheInfoCommand,
    InstallPackagesCommand,
    InvokeFunctionCommand,
    ListDataSourceConnectionCommand,
    ListSecretKeysCommand,
    ListSQLTablesCommand,
    ModelCommand,
    PreviewDatasetColumnCommand,
    PreviewSQLTableCommand,
    RefreshSecretsCommand,
    RenameNotebookCommand,
    StopKernelCommand,
    SyncGraphCommand,
    UpdateCellConfigCommand,
    UpdateUIElementCommand,
    UpdateUserConfigCommand,
    ValidateSQLCommand,
)
from marimo._runtime.context.types import teardown_context
from marimo._session.model import SessionMode
from marimo._session.notebook import AppFileManager
from marimo._types.ids import CellId_t, UIElementId
from tests._server.templates.utils import parse_mount_config

if TYPE_CHECKING:
    from collections.abc import AsyncGenerator, Generator


@pytest.fixture
def pyodide_app_file(tmp_path: Path) -> Path:
    filename = tmp_path / "test.py"
    filename.write_text(
        """
import marimo

app = marimo.App()

@app.cell
def _():
    "Hello, world!"
    return
"""
    )
    return filename


@pytest.fixture
def mock_pyodide_http() -> Generator[MagicMock, None, None]:
    import sys

    mock = MagicMock()
    sys.modules["pyodide_http"] = mock
    mock.patch_all.return_value = None
    yield mock
    del sys.modules["pyodide_http"]


@pytest.fixture
def mock_pyodide() -> Generator[MagicMock, None, None]:
    import sys
    from types import ModuleType

    # Create a proper module structure for pyodide
    mock = MagicMock(spec=ModuleType)
    mock.code = MagicMock(spec=ModuleType)
    mock.code.find_imports = MagicMock(
        return_value=["numpy", "pandas", "sklearn", "matplotlib.pyplot"]
    )

    # Save original module if it exists
    original_module = sys.modules.get("pyodide", None)

    # Install our mock
    sys.modules["pyodide"] = mock
    sys.modules["pyodide.code"] = mock

    yield mock

    # Restore original state
    if original_module is not None:
        sys.modules["pyodide"] = original_module
    else:
        del sys.modules["pyodide"]


@pytest.fixture
async def pyodide_session(
    pyodide_app_file: Path,
) -> AsyncGenerator[PyodideSession, None]:
    session = PyodideSession(
        app=AppFileManager(filename=str(pyodide_app_file)),
        mode=SessionMode.EDIT,
        app_metadata=AppMetadata(
            query_params={},
            cli_args={},
            app_config=_AppConfig(),
            filename=str(pyodide_app_file),
        ),
        user_config=DEFAULT_CONFIG,
    )
    yield session
    teardown_context()


async def test_async_queue_manager() -> None:
    async_queue_manager = AsyncQueueManager()
    # Test putting and getting from queues
    stop_request = StopKernelCommand()
    set_ui_element_request = UpdateUIElementCommand(
        object_ids=[UIElementId("test")], values=["test"]
    )

    async_queue_manager.control_queue.put_nowait(stop_request)
    async_queue_manager.set_ui_element_queue.put_nowait(set_ui_element_request)

    assert await async_queue_manager.control_queue.get() == stop_request
    assert (
        await async_queue_manager.set_ui_element_queue.get()
        == set_ui_element_request
    )


async def test_pyodide_session_start(
    pyodide_session: PyodideSession,
    mock_pyodide_http: MagicMock,
) -> None:
    # Test starting the session
    start_task = asyncio.create_task(pyodide_session.start())
    await asyncio.sleep(0)  # Let the task start
    assert pyodide_session.kernel_task is not None
    mock_pyodide_http.patch_all.assert_called_once()
    pyodide_session.kernel_task.stop()
    start_task.cancel()
    try:
        await start_task
    except asyncio.CancelledError:
        pass


async def test_pyodide_kernel_teardown_runs_on_stop(
    pyodide_app_file: Path,
) -> None:
    """Stopping the kernel task must trigger teardown_kernel via the listen()
    finally block (previously absent for the pyodide path)."""
    fake_kernel = MagicMock()
    cleanup_order: list[str] = []

    class FakeLifecycleItem:
        def dispose(self, context: Any, deletion: bool) -> bool:
            assert context is fake_ctx
            assert deletion is True
            cleanup_order.append("dispose")
            return True

    lifecycle_item = FakeLifecycleItem()
    fake_ctx = SimpleNamespace(
        cell_lifecycle_registry=SimpleNamespace(
            registry={"cell": {lifecycle_item}}
        )
    )
    teardown_calls: list[tuple[Any, Any]] = []

    async def block_until_cancelled(*_args: Any, **_kwargs: Any) -> None:
        await asyncio.Event().wait()

    async def wait_for_wasm_runtime_work(*_args: Any, **_kwargs: Any) -> bool:
        cleanup_order.append("wait")
        return True

    async def shutdown_wasm_runtime_work(*_args: Any, **_kwargs: Any) -> None:
        cleanup_order.append("shutdown")

    with (
        patch(
            "marimo._runtime.kernel_lifecycle.create_kernel",
            return_value=(fake_kernel, fake_ctx),
        ),
        patch(
            "marimo._runtime.kernel_lifecycle.listen_messages",
            side_effect=block_until_cancelled,
        ),
        patch(
            "marimo._runtime.kernel_lifecycle.teardown_kernel",
            side_effect=lambda k, c: (
                cleanup_order.append("teardown"),
                teardown_calls.append((k, c)),
            ),
        ),
        patch(
            "marimo._runtime._wasm.wait_for_wasm_runtime_work_async",
            side_effect=wait_for_wasm_runtime_work,
        ),
        patch(
            "marimo._runtime._wasm.shutdown_wasm_runtime_work_async",
            side_effect=shutdown_wasm_runtime_work,
        ),
        patch("marimo._pyodide.pyodide_session.signal"),
        patch("marimo._output.formatters.formatters.register_formatters"),
        patch(
            "marimo._pyodide.pyodide_session.patches.patch_pyodide_networking"
        ),
        patch("marimo._pyodide.pyodide_session.patches.patch_recursion_limit"),
    ):
        kernel_task = _launch_pyodide_kernel(
            control_queue=asyncio.Queue(),
            set_ui_element_queue=asyncio.Queue(),
            completion_queue=asyncio.Queue(),
            input_queue=asyncio.Queue(),
            on_message=lambda _msg: None,
            session_mode=SessionMode.EDIT,
            configs={},
            app_metadata=AppMetadata(
                query_params={},
                cli_args={},
                app_config=_AppConfig(),
                filename=str(pyodide_app_file),
            ),
            user_config=DEFAULT_CONFIG,
        )
        start_task = asyncio.create_task(kernel_task.start())
        # Yield enough times for: outer task → RestartableTask.start → inner
        # task creation → listen() → asyncio.gather → child tasks suspended.
        for _ in range(5):
            await asyncio.sleep(0)
        kernel_task.stop()
        try:
            await start_task
        except asyncio.CancelledError:
            pass

    assert teardown_calls == [(fake_kernel, fake_ctx)]
    assert cleanup_order == ["dispose", "wait", "shutdown", "teardown"]
    assert fake_ctx.cell_lifecycle_registry.registry == {}


async def test_pyodide_kernel_teardown_logs_wasm_shutdown_timeout(
    pyodide_app_file: Path,
) -> None:
    fake_kernel = MagicMock()
    fake_ctx = SimpleNamespace(
        cell_lifecycle_registry=SimpleNamespace(registry={})
    )
    teardown_calls: list[tuple[Any, Any]] = []

    async def block_until_cancelled(*_args: Any, **_kwargs: Any) -> None:
        await asyncio.Event().wait()

    async def wait_for_wasm_runtime_work(*_args: Any, **_kwargs: Any) -> bool:
        return False

    async def shutdown_wasm_runtime_work(*_args: Any, **_kwargs: Any) -> None:
        raise RuntimeError("WASM runtime work did not shut down in time")

    with (
        patch(
            "marimo._runtime.kernel_lifecycle.create_kernel",
            return_value=(fake_kernel, fake_ctx),
        ),
        patch(
            "marimo._runtime.kernel_lifecycle.listen_messages",
            side_effect=block_until_cancelled,
        ),
        patch(
            "marimo._runtime.kernel_lifecycle.teardown_kernel",
            side_effect=lambda k, c: teardown_calls.append((k, c)),
        ),
        patch(
            "marimo._runtime._wasm.wait_for_wasm_runtime_work_async",
            side_effect=wait_for_wasm_runtime_work,
        ),
        patch(
            "marimo._runtime._wasm.shutdown_wasm_runtime_work_async",
            side_effect=shutdown_wasm_runtime_work,
        ),
        patch("marimo._pyodide.pyodide_session.LOGGER") as logger,
        patch("marimo._pyodide.pyodide_session.signal"),
        patch("marimo._output.formatters.formatters.register_formatters"),
        patch(
            "marimo._pyodide.pyodide_session.patches.patch_pyodide_networking"
        ),
        patch("marimo._pyodide.pyodide_session.patches.patch_recursion_limit"),
    ):
        kernel_task = _launch_pyodide_kernel(
            control_queue=asyncio.Queue(),
            set_ui_element_queue=asyncio.Queue(),
            completion_queue=asyncio.Queue(),
            input_queue=asyncio.Queue(),
            on_message=lambda _msg: None,
            session_mode=SessionMode.EDIT,
            configs={},
            app_metadata=AppMetadata(
                query_params={},
                cli_args={},
                app_config=_AppConfig(),
                filename=str(pyodide_app_file),
            ),
            user_config=DEFAULT_CONFIG,
        )
        start_task = asyncio.create_task(kernel_task.start())
        for _ in range(5):
            await asyncio.sleep(0)
        kernel_task.stop()
        try:
            await start_task
        except asyncio.CancelledError:
            pass

    logger.exception.assert_called_with(
        "Failed to shut down Pyodide WASM runtime work"
    )
    assert teardown_calls == [(fake_kernel, fake_ctx)]


async def test_pyodide_session_put_control_request(
    pyodide_session: PyodideSession,
) -> None:
    # Test putting control requests
    execution_request = ExecuteCellsCommand(
        cell_ids=[CellId_t("test")],
        codes=["test"],
    )
    set_ui_element_request = UpdateUIElementCommand(
        object_ids=[UIElementId("test")], values=["test"]
    )

    pyodide_session.put_control_request(execution_request)
    pyodide_session.put_control_request(set_ui_element_request)

    assert not pyodide_session._queue_manager.control_queue.empty()
    assert not pyodide_session._queue_manager.set_ui_element_queue.empty()


async def test_pyodide_session_find_packages(
    pyodide_session: PyodideSession,
    mock_pyodide: MagicMock,
) -> None:
    # We don't use `pyodide.code.find_imports`
    # because this returns imports not in the lockfile (and potentially not trusted).
    code = dedent(
        """
        import numpy as np
        import pandas as pd
        import matplotlib.pyplot as plt
        from sklearn.linear_model import LinearRegression
        """
    )

    packages = pyodide_session.find_packages(code)
    assert sorted(packages) == sorted([])
    mock_pyodide.code.find_imports.assert_not_called()


async def test_pyodide_session_find_packages_with_script_metadata(
    pyodide_session: PyodideSession,
    mock_pyodide: MagicMock,
) -> None:
    # Test finding packages in code
    code = dedent(
        """
        # /// script
        # dependencies = [
        #     "foo",
        #     "bar==1.0.0",
        #     "baz>=2.0.0",
        # ]
        # ///

        import numpy as np
        import pandas as pd
        """
    )

    packages = pyodide_session.find_packages(code)
    # Specifiers are preserved: these go to micropip, which resolves them.
    assert sorted(packages) == sorted(["foo", "bar==1.0.0", "baz>=2.0.0"])
    mock_pyodide.code.find_imports.assert_not_called()


async def test_find_packages_keeps_a_pinned_prerelease(
    pyodide_session: PyodideSession,
) -> None:
    """A pin is the only thing that selects a pre-release.

    Dropping it does not just lose precision -- an unpinned name resolves to
    the newest *stable* release, so the notebook silently gets a different
    version than it asked for, and one that may not run in Pyodide at all.
    """
    code = dedent(
        """
        # /// script
        # dependencies = ["somepkg==1.0.0.dev2"]
        # ///

        import somepkg
        """
    )

    assert pyodide_session.find_packages(code) == ["somepkg==1.0.0.dev2"]


@pytest.mark.parametrize(
    ("python_version", "expected_package"),
    [
        ("3.12", "older-python; python_version < '3.13'"),
        ("3.13", "newer-python; python_version >= '3.13'"),
    ],
)
async def test_find_packages_from_island_notebook(
    pyodide_session: PyodideSession,
    mock_pyodide: MagicMock,
    python_version: str,
    expected_package: str,
) -> None:
    from packaging.markers import default_environment

    # Generated by the frontend from a Python-rendered island payload.
    code = (
        Path(__file__).parent.parent
        / "_islands/snapshots/notebook-dependencies.txt"
    ).read_text(encoding="utf-8")

    environment = {
        **default_environment(),
        "python_version": python_version,
        "python_full_version": f"{python_version}.0",
    }
    with patch(
        "packaging.markers.default_environment", return_value=environment
    ):
        assert pyodide_session.find_packages(code) == [
            'cowsay==6.1; sys_platform == "emscripten"',
            "rich[jupyter]>=13",
            expected_package,
        ]
    mock_pyodide.code.find_imports.assert_not_called()


async def test_complex_find_packages(pyodide_session: PyodideSession) -> None:
    code = dedent(
        """
        # /// script
        # requires-python = ">=3.12"
        # dependencies = [
        #     "plotly[express]==6.5.0",
        #     "polars==1.36.1",
        # ]
        # ///

        import marimo

        app = marimo.App()


        @app.cell
        def _():
            import marimo as mo
            return (mo,)
        """
    )
    packages = pyodide_session.find_packages(code)
    assert sorted(packages) == sorted(
        ["plotly[express]==6.5.0", "polars==1.36.1"]
    )


async def test_strip_version_resilience(
    pyodide_session: PyodideSession,
) -> None:
    """find_packages keeps each requirement as written.

    Specifiers reach micropip, which resolves them. Environment markers are
    still applied (a non-emscripten requirement drops out), and URL forms are
    unchanged. `strip_requirement_name` keeps its own tests in
    tests/_runtime/packages/test_package_utils.py.
    """
    code_templates = [
        # Basic version specifiers
        ('dependencies = ["package==1.0.0"]', ["package==1.0.0"]),
        ('dependencies = ["package>=1.0.0"]', ["package>=1.0.0"]),
        ('dependencies = ["package<=2.0.0"]', ["package<=2.0.0"]),
        ('dependencies = ["package~=1.4"]', ["package~=1.4"]),
        ('dependencies = ["package!=1.5.0"]', ["package!=1.5.0"]),
        ('dependencies = ["package>1.0"]', ["package>1.0"]),
        ('dependencies = ["package<2.0"]', ["package<2.0"]),
        ('dependencies = ["package===1.0.0"]', ["package===1.0.0"]),
        # With extras
        (
            'dependencies = ["package[extra]==1.0.0"]',
            ["package[extra]==1.0.0"],
        ),
        (
            'dependencies = ["package[extra1,extra2]>=1.0.0"]',
            ["package[extra1,extra2]>=1.0.0"],
        ),
        # With whitespace
        ('dependencies = ["package >= 1.0.0"]', ["package >= 1.0.0"]),
        ('dependencies = ["  package==1.0.0  "]', ["package==1.0.0"]),
        # With environment markers
        (
            'dependencies = ["package>=1.0.0; python_version>=\\"3.8\\""]',
            ['package>=1.0.0; python_version>="3.8"'],
        ),
        (
            'dependencies = ["package[extra]>=1.0; sys_platform==\\"linux\\""]',
            [],
        ),
        (
            'dependencies = ["native>=1.0; sys_platform!=\\"emscripten\\"", "pure-python>=1.0"]',
            ["pure-python>=1.0"],
        ),
        (
            'dependencies = ["wasm-only; sys_platform==\\"emscripten\\"", "linux-only; sys_platform==\\"linux\\""]',
            ['wasm-only; sys_platform=="emscripten"'],
        ),
        # URL dependencies - left as-is
        (
            'dependencies = ["package @ https://github.com/user/repo.git"]',
            ["package @ https://github.com/user/repo.git"],
        ),
        (
            'dependencies = ["package @ git+https://github.com/user/repo.git"]',
            ["package @ git+https://github.com/user/repo.git"],
        ),
        (
            'dependencies = ["package @ git+ssh://[email protected]/user/repo.git"]',
            ["package @ git+ssh://[email protected]/user/repo.git"],
        ),
        (
            'dependencies = ["package @ file:///path/to/local/package"]',
            ["package @ file:///path/to/local/package"],
        ),
        # Multiple packages with various specifiers
        (
            'dependencies = ["foo==1.0", "bar>=2.0", "baz~=3.0", "qux[extra]>=4.0"]',
            ["foo==1.0", "bar>=2.0", "baz~=3.0", "qux[extra]>=4.0"],
        ),
        # No version specifier
        ('dependencies = ["package"]', ["package"]),
    ]

    for deps_str, expected in code_templates:
        code = dedent(
            f"""
            # /// script
            # {deps_str}
            # ///

            import marimo
            """
        )
        packages = pyodide_session.find_packages(code)
        assert sorted(packages) == sorted(expected), (
            f"Failed for {deps_str}: expected {expected}, got {packages}"
        )


async def test_pyodide_session_put_input(
    pyodide_session: PyodideSession,
) -> None:
    # Test putting input
    input_text = "test input"
    pyodide_session.put_input(input_text)

    assert not pyodide_session._queue_manager.input_queue.empty()
    assert await pyodide_session._queue_manager.input_queue.get() == input_text


@pytest.mark.parametrize(
    ("json_payload", "expected_type"),
    [
        # Notebook operations
        (
            (
                '{"type": "create-notebook", "executionRequests": [{"cellId": "cell-1", "code": "print(1)", "type": "execute-cell"}], '
                '"cellIds": ["cell-1"], "setUiElementValueRequest": {"objectIds": [], "values": [], "type": "update-ui-element"}, '
                '"autoRun": true}'
            ),
            CreateNotebookCommand,
        ),
        (
            '{"type": "rename-notebook", "filename": "test.py"}',
            RenameNotebookCommand,
        ),
        # Cell execution and management
        (
            '{"type": "execute-cells", "cellIds": ["cell-1"], "codes": ["print(1)"]}',
            ExecuteCellsCommand,
        ),
        (
            '{"type": "execute-cells", "cellIds": ["cell-1", "cell-2"], "codes": ["x=1", "y=2"]}',
            ExecuteCellsCommand,
        ),
        (
            '{"type": "execute-scratchpad", "code": "print(1)"}',
            ExecuteScratchpadCommand,
        ),
        ('{"type": "execute-stale-cells"}', ExecuteStaleCellsCommand),
        ('{"type": "debug-cell", "cellId": "cell-1"}', DebugCellCommand),
        ('{"type": "delete-cell", "cellId": "cell-1"}', DeleteCellCommand),
        (
            '{"type": "sync-graph", "cells": {"cell-1": "x=1"}, "runIds": ["cell-1"], "deleteIds": []}',
            SyncGraphCommand,
        ),
        (
            '{"type": "update-cell-config", "configs": {"cell-1": {"hide_code": true}}}',
            UpdateCellConfigCommand,
        ),
        # Package management
        (
            '{"type": "install-packages", "manager": "pip", "versions": {}}',
            InstallPackagesCommand,
        ),
        (
            '{"type": "install-packages", "manager": "pip", "versions": {"numpy": "1.24.0"}}',
            InstallPackagesCommand,
        ),
        # UI element and widget model operations
        (
            '{"type": "update-ui-element", "objectIds": ["test-1"], "values": [42], "token": "test-token"}',
            UpdateUIElementCommand,
        ),
        (
            '{"type": "update-ui-element", "objectIds": ["test-1"], "values": [42]}',
            UpdateUIElementCommand,
        ),
        (
            '{"type": "update-ui-element", "objectIds": [], "values": []}',
            UpdateUIElementCommand,
        ),
        (
            '{"type": "model", "modelId": "model-1", "message": {"method": "update", "state": {}, "bufferPaths": []}, "buffers": []}',
            ModelCommand,
        ),
        (
            '{"type": "invoke-function", "functionCallId": "fc-1", "namespace": "test", "functionName": "foo", "args": {}}',
            InvokeFunctionCommand,
        ),
        # Data/SQL operations
        (
            '{"type": "preview-dataset-column", "sourceType": "duckdb", "source": "test.db", "tableName": "users", "columnName": "id"}',
            PreviewDatasetColumnCommand,
        ),
        (
            (
                '{"type": "preview-sql-table", "requestId": "req-1", "engine": "duckdb", "database": "test.db", '
                '"schema": "main", "tableName": "users"}'
            ),
            PreviewSQLTableCommand,
        ),
        (
            '{"type": "list-sql-tables", "requestId": "req-2", "engine": "duckdb", "database": "test.db", "schema": "main"}',
            ListSQLTablesCommand,
        ),
        (
            '{"type": "validate-sql", "requestId": "req-3", "query": "SELECT * FROM users", "onlyParse": false}',
            ValidateSQLCommand,
        ),
        (
            '{"type": "validate-sql", "requestId": "req-4", "query": "SELECT * FROM users", "onlyParse": true, "dialect": "postgres"}',
            ValidateSQLCommand,
        ),
        (
            '{"type": "list-data-source-connection", "engine": "duckdb"}',
            ListDataSourceConnectionCommand,
        ),
        # Secrets management
        (
            '{"type": "list-secret-keys", "requestId": "req-1"}',
            ListSecretKeysCommand,
        ),
        ('{"type": "refresh-secrets"}', RefreshSecretsCommand),
        # Cache management
        ('{"type": "clear-cache"}', ClearCacheCommand),
        ('{"type": "get-cache-info"}', GetCacheInfoCommand),
        # Kernel operations
        ('{"type": "stop-kernel"}', StopKernelCommand),
    ],
)
def test_command_parsing_with_discriminator(
    json_payload: str, expected_type: type
) -> None:
    """Test that Command types are parsed correctly using the type discriminator."""

    parsed = parse_command(json_payload)
    assert type(parsed) is expected_type, (
        f"Expected {expected_type.__name__} but got {type(parsed).__name__} "
        f"for payload: {json_payload}"
    )


def test_control_request_parsing_invalid() -> None:
    """Test that invalid JSON raises DecodeError."""
    with pytest.raises(msgspec.DecodeError):
        parse_command("invalid json")


async def test_async_queue_manager_close() -> None:
    """Test closing queues puts a StopRequest."""
    manager = AsyncQueueManager()
    manager.close_queues()

    request = await manager.control_queue.get()
    assert isinstance(request, StopKernelCommand)


async def test_pyodide_session_on_message(
    pyodide_session: PyodideSession,
) -> None:
    """Test that _on_message calls all consumers."""
    mock_consumer1 = Mock()
    mock_consumer2 = Mock()

    pyodide_session.consumers = [mock_consumer1, mock_consumer2]

    test_msg: KernelMessage = {
        "op": "completed-run",
        "cell_id": CellId_t("test"),
    }
    pyodide_session._on_message(test_msg)

    mock_consumer1.assert_called_once_with(test_msg)
    mock_consumer2.assert_called_once_with(test_msg)


async def test_pyodide_session_on_message_isolates_consumers(
    pyodide_session: PyodideSession,
) -> None:
    """A failing or departing consumer does not keep the message from others."""
    received: list[str] = []

    def failing(_msg: KernelMessage) -> None:
        raise RuntimeError("receiver is gone")

    def departing(_msg: KernelMessage) -> None:
        received.append("departing")
        pyodide_session.consumers.remove(departing)

    pyodide_session.consumers = [
        failing,
        departing,
        lambda _msg: received.append("last"),
    ]
    pyodide_session._on_message(b"{}")
    assert received == ["departing", "last"]


async def test_pyodide_session_put_completion_request(
    pyodide_session: PyodideSession,
) -> None:
    """Test putting completion requests."""
    from marimo._runtime.commands import CodeCompletionCommand

    completion_request = CodeCompletionCommand(
        id="test",
        document="test code",
        cell_id=CellId_t("test"),
    )

    pyodide_session.put_completion_request(completion_request)

    assert not pyodide_session._queue_manager.completion_queue.empty()
    result = await pyodide_session._queue_manager.completion_queue.get()
    assert result == completion_request


# ===== PyodideBridge Tests =====


@pytest.fixture
def pyodide_bridge(
    pyodide_session: PyodideSession,
) -> PyodideBridge:
    """Create a PyodideBridge instance for testing."""
    return PyodideBridge(session=pyodide_session)


def test_pyodide_bridge_init(pyodide_bridge: PyodideBridge) -> None:
    """Test PyodideBridge initialization."""
    assert pyodide_bridge.session is not None
    assert pyodide_bridge.file_system is not None


def test_pyodide_bridge_put_control_request(
    pyodide_bridge: PyodideBridge,
) -> None:
    """Test putting control requests through the bridge."""
    request_json = '{"type": "execute-cells", "cellIds": ["cell-1"], "codes": ["print(1)"]}'
    pyodide_bridge.put_control_request(request_json)

    assert not pyodide_bridge.session._queue_manager.control_queue.empty()


def test_pyodide_bridge_put_input(pyodide_bridge: PyodideBridge) -> None:
    """Test putting input through the bridge."""
    test_input = "test input"
    pyodide_bridge.put_input(test_input)

    assert not pyodide_bridge.session._queue_manager.input_queue.empty()


def test_pyodide_bridge_code_complete(pyodide_bridge: PyodideBridge) -> None:
    """Test code completion through the bridge."""
    request_json = '{"id": "test", "document": "test code", "cellId": "test"}'
    pyodide_bridge.code_complete(request_json)

    assert not pyodide_bridge.session._queue_manager.completion_queue.empty()


def test_pyodide_bridge_read_code(
    pyodide_bridge: PyodideBridge,
    pyodide_app_file: Path,
) -> None:
    """Test reading code through the bridge."""
    del pyodide_app_file
    result = pyodide_bridge.read_code()
    response = json.loads(result)

    assert "contents" in response
    assert "marimo.App()" in response["contents"]


@pytest.mark.skipif(
    not (DependencyManager.ruff.has() or DependencyManager.black.has()),
    reason="ruff or black not installed",
)
async def test_pyodide_bridge_format(pyodide_bridge: PyodideBridge) -> None:
    """Test formatting code through the bridge."""
    request_json = json.dumps(
        {
            "codes": {"cell-1": "x=1+2"},
            "lineLength": 79,
        }
    )

    result = await pyodide_bridge.format(request_json)
    response = json.loads(result)

    assert "codes" in response
    assert "cell-1" in response["codes"]


async def test_pyodide_bridge_document_export(
    pyodide_bridge: PyodideBridge,
) -> None:
    result = json.loads(
        await pyodide_bridge.notebook.call(
            json.dumps(
                {
                    "operation": "notebook.edit",
                    "params": {"notebook_id": pyodide_bridge.notebook.id},
                    "headers": {"idempotency-key": "edit-1"},
                    "body": {
                        "changes": [
                            {
                                "kind": "put_cell",
                                "base_etag": None,
                                "cell": {
                                    "id": "test",
                                    "code": 'message = "NEW"',
                                },
                            }
                        ]
                    },
                }
            )
        )
    )
    assert result["status"] == 200, result

    request = json.dumps({"download": False})
    script = json.loads(pyodide_bridge.export_script(request))
    markdown = json.loads(pyodide_bridge.export_markdown(request))
    assert 'message = "NEW"' in script["contents"]
    assert 'message = "NEW"' in markdown["contents"]


def test_pyodide_bridge_save_user_config(
    pyodide_bridge: PyodideBridge,
) -> None:
    pyodide_bridge.session._initial_user_config = merge_config(
        DEFAULT_CONFIG,
        {
            "ai": {
                "open_ai": {"api_key": "configured-key"},
                "mode": "manual",
            }
        },
    )
    request_json = json.dumps(
        {
            "config": {
                "ai": {"models": {"chat_model": "openai/gpt-4o"}},
            }
        }
    )

    pyodide_bridge.save_user_config(request_json)

    command = pyodide_bridge.session._queue_manager.control_queue.get_nowait()
    assert isinstance(command, UpdateUserConfigCommand)
    assert command.config["ai"]["open_ai"]["api_key"] == "configured-key"
    assert command.config["ai"]["mode"] == "manual"
    assert command.config["ai"]["models"]["chat_model"] == "openai/gpt-4o"

    pyodide_bridge.save_user_config(
        json.dumps({"config": {"ai": {"mode": "agent"}}})
    )

    command = pyodide_bridge.session._queue_manager.control_queue.get_nowait()
    assert isinstance(command, UpdateUserConfigCommand)
    assert command.config["ai"]["open_ai"]["api_key"] == "configured-key"
    assert command.config["ai"]["mode"] == "agent"
    assert command.config["ai"]["models"]["chat_model"] == "openai/gpt-4o"


def test_pyodide_bridge_rename_file(
    pyodide_bridge: PyodideBridge,
    tmp_path: Path,
) -> None:
    """Test renaming file through the bridge."""
    new_filename = str(tmp_path / "renamed.py")
    pyodide_bridge.rename_file(new_filename)

    assert pyodide_bridge.session.app_manager.filename == new_filename


def test_pyodide_bridge_list_files(
    pyodide_bridge: PyodideBridge,
    tmp_path: Path,
) -> None:
    """Test listing files through the bridge."""
    # Create some test files
    (tmp_path / "test1.py").write_text("# test1")
    (tmp_path / "test2.py").write_text("# test2")

    request_json = json.dumps({"path": str(tmp_path)})
    result = pyodide_bridge.list_files(request_json)
    response = json.loads(result)

    assert "files" in response
    assert "root" in response
    assert response["root"] == str(tmp_path)


def test_pyodide_bridge_file_roots(
    pyodide_bridge: PyodideBridge,
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """Test listing configured file-browser roots through the bridge."""
    primary = tmp_path / "project"
    shared = tmp_path / "shared"
    primary.mkdir()
    shared.mkdir()
    monkeypatch.setattr(
        pyodide_bridge.file_system, "get_root", lambda: str(primary)
    )
    monkeypatch.setitem(
        pyodide_bridge.session._initial_user_config,
        "file_browser",
        {"folders": [{"path": str(shared), "name": "Shared"}]},
    )

    response = json.loads(pyodide_bridge.file_roots())

    assert response == {
        "roots": [
            {
                "path": str(primary.resolve()),
                "name": "project",
                "isPrimary": True,
            },
            {
                "path": str(shared.resolve()),
                "name": "Shared",
                "isPrimary": False,
            },
        ]
    }


def test_pyodide_bridge_file_details(
    pyodide_bridge: PyodideBridge,
    tmp_path: Path,
) -> None:
    """Test getting file details through the bridge."""
    test_file = tmp_path / "test.py"
    test_file.write_text("# test")

    request_json = json.dumps({"path": str(test_file)})
    result = pyodide_bridge.file_details(request_json)
    response = json.loads(result)

    assert "file" in response
    assert "contents" in response
    assert response["file"]["path"] == str(test_file)


def test_pyodide_bridge_toml_file_details(
    pyodide_bridge: PyodideBridge,
    tmp_path: Path,
) -> None:
    test_file = tmp_path / "pyproject.toml"
    test_file.write_text('[project]\nname = "demo"')

    request_json = json.dumps({"path": str(test_file)})
    response = json.loads(pyodide_bridge.file_details(request_json))

    assert response["mimeType"] == "application/toml"


def test_pyodide_bridge_file_details_honors_limit(
    pyodide_bridge: PyodideBridge,
    tmp_path: Path,
) -> None:
    test_file = tmp_path / "large.txt"
    test_file.write_bytes(b"12345")

    request_json = json.dumps({"path": str(test_file), "maxBytes": 4})
    response = json.loads(pyodide_bridge.file_details(request_json))

    assert response["contents"] is None
    assert response["isTooLarge"] is True


def test_pyodide_bridge_file_details_without_limit_is_unrestricted(
    pyodide_bridge: PyodideBridge,
    tmp_path: Path,
) -> None:
    test_file = tmp_path / "download.bin"
    test_file.write_bytes(b"12345")

    request_json = json.dumps({"path": str(test_file)})
    response = json.loads(pyodide_bridge.file_details(request_json))

    assert response["contents"] == "12345"
    assert response["isTooLarge"] is False


def test_pyodide_bridge_create_file(
    pyodide_bridge: PyodideBridge,
    tmp_path: Path,
) -> None:
    """Test creating file through the bridge."""
    import base64

    test_content = b"# new file"
    encoded_content = base64.b64encode(test_content).decode()

    request_json = json.dumps(
        {
            "path": str(tmp_path),
            "type": "file",
            "name": "new_file.py",
            "contents": encoded_content,
        }
    )

    result = pyodide_bridge.create_file_or_directory(request_json)
    response = json.loads(result)

    assert response["success"] is True
    assert (tmp_path / "new_file.py").exists()


def test_pyodide_bridge_delete_file(
    pyodide_bridge: PyodideBridge,
    tmp_path: Path,
) -> None:
    """Test deleting file through the bridge."""
    test_file = tmp_path / "to_delete.py"
    test_file.write_text("# delete me")

    request_json = json.dumps({"path": str(test_file)})
    result = pyodide_bridge.delete_file_or_directory(request_json)
    response = json.loads(result)

    assert response["success"] is True
    assert not test_file.exists()


def test_pyodide_bridge_move_file(
    pyodide_bridge: PyodideBridge,
    tmp_path: Path,
) -> None:
    """Test moving file through the bridge."""
    test_file = tmp_path / "old.py"
    test_file.write_text("# move me")
    new_path = tmp_path / "new.py"

    request_json = json.dumps(
        {
            "path": str(test_file),
            "newPath": str(new_path),
        }
    )

    result = pyodide_bridge.move_file_or_directory(request_json)
    response = json.loads(result)

    assert response["success"] is True
    assert not test_file.exists()
    assert new_path.exists()


def test_pyodide_bridge_copy_file(
    pyodide_bridge: PyodideBridge,
    tmp_path: Path,
) -> None:
    """Test copying file through the bridge."""
    test_file = tmp_path / "original.py"
    test_file.write_text("# copy me")
    new_path = tmp_path / "copied.py"

    request_json = json.dumps(
        {
            "path": str(test_file),
            "newPath": str(new_path),
        }
    )

    result = pyodide_bridge.copy_file_or_directory(request_json)
    response = json.loads(result)

    assert response["success"] is True
    assert test_file.exists()
    assert new_path.exists()
    assert new_path.read_text() == "# copy me"


def test_pyodide_bridge_update_file(
    pyodide_bridge: PyodideBridge,
    tmp_path: Path,
) -> None:
    """Test updating file through the bridge."""
    test_file = tmp_path / "update.py"
    test_file.write_text("# old content")

    new_content = "# new content"
    request_json = json.dumps(
        {
            "path": str(test_file),
            "contents": new_content,
        }
    )

    result = pyodide_bridge.update_file(request_json)
    response = json.loads(result)

    assert response["success"] is True
    assert test_file.read_text() == new_content


def test_pyodide_bridge_export_html(
    pyodide_bridge: PyodideBridge,
) -> None:
    """Test exporting HTML through the bridge."""
    request_json = json.dumps(
        {
            "download": False,
            "files": [],
            "includeCode": True,
            "layout": {
                "type": "slides",
                "data": {"deck": {"transition": "fade"}},
            },
        }
    )

    result = pyodide_bridge.export_html(request_json)
    exported_file = json.loads(result)

    assert exported_file["filename"] == "test.html"
    assert exported_file["mediaType"] == "text/html; charset=utf-8"
    assert parse_mount_config(exported_file["contents"])["layout"] == {
        "type": "slides",
        "data": {"deck": {"transition": "fade"}},
    }


@pytest.mark.parametrize(
    ("flavor", "expected_filename", "expected_fence"),
    [
        (None, "test.md", "```python {.marimo}"),
        ("qmd", "test.qmd", "```{marimo .python"),
    ],
)
def test_pyodide_bridge_export_markdown(
    pyodide_bridge: PyodideBridge,
    flavor: str | None,
    expected_filename: str,
    expected_fence: str,
) -> None:
    """Test exporting markdown through the bridge."""
    request = {"download": False}
    if flavor is not None:
        request["flavor"] = flavor

    result = pyodide_bridge.export_markdown(json.dumps(request))
    exported_file = json.loads(result)

    assert exported_file["filename"] == expected_filename
    assert exported_file["mediaType"] == "text/plain; charset=utf-8"
    assert expected_fence in exported_file["contents"]


@pytest.mark.parametrize(
    ("filename", "expected_filename"),
    [
        ("renamed.py", "renamed.script.py"),
        (None, "notebook.script.py"),
    ],
)
def test_pyodide_bridge_export_script(
    pyodide_bridge: PyodideBridge,
    filename: str | None,
    expected_filename: str,
) -> None:
    pyodide_bridge.session.app_manager.filename = filename
    result = pyodide_bridge.export_script(
        json.dumps(
            {
                "download": False,
            }
        )
    )
    exported_file = json.loads(result)

    assert exported_file["filename"] == expected_filename
    assert exported_file["mediaType"] == "text/plain; charset=utf-8"
    assert '# %%\n"Hello, world!"' in exported_file["contents"]


async def test_pyodide_bridge_read_snippets(
    pyodide_bridge: PyodideBridge,
    default_snippets: Any,
) -> None:
    """Test reading snippets through the bridge."""
    with unittest.mock.patch(
        "marimo._pyodide.pyodide_session.read_snippets",
        return_value=default_snippets,
    ):
        result = await pyodide_bridge.read_snippets()
    data = json.loads(result)

    assert isinstance(data, dict)
    assert "snippets" in data
    assert isinstance(data["snippets"], list)