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.

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

import asyncio
import sys
import threading
from contextlib import contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
from typing import TYPE_CHECKING

import pytest
import uvicorn
from starlette.testclient import TestClient

from marimo._config.manager import MarimoConfigManager, UserConfigStore
from marimo._config.utils import CONFIG_FILENAME
from marimo._server.api.deps import AppState
from marimo._server.config import StarletteServerStateInit
from marimo._server.main import create_starlette_app
from marimo._server.session_manager import SessionManager
from marimo._server.utils import initialize_asyncio
from marimo._session.queue import ProcessLike
from marimo._session.session import SessionImpl
from tests._server.mocks import get_mock_session_manager

if TYPE_CHECKING:
    from collections.abc import Generator, Iterator

    from websockets.sync.server import Server as WebSocketServer

# Module-level app only for client_with_lifespans fixture
_module_app = create_starlette_app(base_url="", enable_auth=True)


@contextmanager
def serve_in_thread(server: WebSocketServer) -> Iterator[None]:
    error: BaseException | None = None

    def serve() -> None:
        nonlocal error
        try:
            server.serve_forever()
        except BaseException as exc:
            error = exc

    thread = threading.Thread(target=serve)
    thread.start()
    try:
        yield
    finally:
        try:
            server.shutdown()
        finally:
            thread.join(timeout=5)
            assert not thread.is_alive(), (
                "WebSocket server thread did not stop"
            )
            if error is not None:
                raise error


def get_kernel_tasks(
    session_manager: SessionManager,
) -> list[threading.Thread | ProcessLike]:
    kernel_tasks = []
    for session in session_manager.sessions.values():
        assert isinstance(session, SessionImpl)
        kernel_task = session._kernel_manager.kernel_task
        if kernel_task is not None:
            kernel_tasks.append(kernel_task)
    return kernel_tasks


async def join_kernel_thread_tasks(session_manager: SessionManager) -> None:
    # Kernels started in run mode run in their own threads; if these kernels
    # execute code, they may patch and restore their own main modules.
    # To ensure that this fixture correctly restores the original saved
    # main module, we wait for threads to finish before restoring the module.
    kernel_tasks = get_kernel_tasks(session_manager)
    await session_manager.shutdown()
    for task in kernel_tasks:
        # At least some tests are flaky with processes (edit tasks)
        # not joining for a long time; orphaned edit tasks
        # won't affect other tests, but they are somewhat concerning
        # ...
        if isinstance(task, threading.Thread):
            await asyncio.to_thread(task.join)


@pytest.fixture(scope="session", autouse=True)
def init() -> bool:
    initialize_asyncio()
    return True


@pytest.fixture(scope="module")
def client_with_lifespans() -> Generator[TestClient, None, None]:
    with TestClient(_module_app) as c:
        yield c


@pytest.fixture
def user_config_manager() -> Iterator[UserConfigStore]:
    tmp = TemporaryDirectory()
    config_path = Path(tmp.name) / CONFIG_FILENAME
    config_path.write_text("")

    class TestUserConfigManager(UserConfigStore):
        def __init__(self) -> None:
            super().__init__()

        def get_config_path(self) -> str:
            return str(config_path)

    yield TestUserConfigManager()

    tmp.cleanup()


@pytest.fixture
def client(user_config_manager: UserConfigStore) -> Iterator[TestClient]:
    main = sys.modules["__main__"]

    # Create fresh app for this test to avoid shared state issues
    app = create_starlette_app(base_url="", enable_auth=True)
    client = TestClient(app)
    StarletteServerStateInit(
        port=1234,
        host="localhost",
        base_url="",
        asset_url=None,
        headless=False,
        quiet=False,
        session_manager=get_mock_session_manager(),
        config_manager=MarimoConfigManager(user_config_manager),
        remote_url=None,
        mcp_server_enabled=False,
        skew_protection=False,
        enable_auth=True,
    ).apply(app.state)

    # Mock out the server
    uvicorn_server = uvicorn.Server(uvicorn.Config(app))
    uvicorn_server.servers = []
    app.state.server = uvicorn_server

    yield client

    try:
        asyncio.run(join_kernel_thread_tasks(client.app.state.session_manager))
    finally:
        sys.modules["__main__"] = main


def get_session_config_manager(client: TestClient) -> MarimoConfigManager:
    """Assumes only one active session."""
    sessions = list(
        AppState.from_app(client.app).session_manager.sessions.values()
    )
    assert len(sessions) == 1
    return sessions[0].config_manager  # type: ignore


def get_user_config_manager(client: TestClient) -> MarimoConfigManager:
    return client.app.state.config_manager  # type: ignore