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.

refactor: Add `kernel_session()` as context manager, DRY up tests (#9554)

Myles Scolnickc4181105d78f
diff --git a/marimo/_pyodide/pyodide_session.py b/marimo/_pyodide/pyodide_session.py
index 4c39f16908..7c2965e953 100644
--- a/marimo/_pyodide/pyodide_session.py
+++ b/marimo/_pyodide/pyodide_session.py
@@ -438,6 +438,7 @@ def _launch_pyodide_kernel(
) -> RestartableTask:
from marimo._output.formatters.formatters import register_formatters
from marimo._runtime.kernel_lifecycle import (
+ KernelArgs,
asyncio_queue_reader,
create_kernel,
listen_messages,
@@ -462,20 +463,21 @@ def _launch_pyodide_kernel(
debugger = MarimoPdb(stdout=stdout, stdin=stdin) if is_edit_mode else None
kernel, ctx = create_kernel(
- stream=stream,
- stdout=stdout,
- stderr=stderr,
- stdin=stdin,
- debugger=debugger,
- configs=configs,
- app_metadata=app_metadata,
- user_config=user_config,
- is_edit_mode=is_edit_mode,
- control_queue=control_queue,
- set_ui_element_queue=set_ui_element_queue,
- virtual_file_storage=None,
- mode=session_mode,
- print_override_fn=None,
+ KernelArgs(
+ stream=stream,
+ stdout=stdout,
+ stderr=stderr,
+ stdin=stdin,
+ debugger=debugger,
+ configs=configs,
+ app_metadata=app_metadata,
+ user_config=user_config,
+ mode=session_mode,
+ control_queue=control_queue,
+ set_ui_element_queue=set_ui_element_queue,
+ virtual_file_storage=None,
+ print_override_fn=None,
+ )
)
if is_edit_mode:
diff --git a/marimo/_runtime/kernel_lifecycle.py b/marimo/_runtime/kernel_lifecycle.py
index dfd4725871..7b2264dd6a 100644
--- a/marimo/_runtime/kernel_lifecycle.py
+++ b/marimo/_runtime/kernel_lifecycle.py
@@ -8,6 +8,8 @@ subprocess bootstrap, the outer task driver) stay at the call site.
from __future__ import annotations
import asyncio
+import contextlib
+import dataclasses
from typing import TYPE_CHECKING, Any, TypeVar
from marimo import _loggers
@@ -31,9 +33,10 @@ from marimo._runtime.runner.hooks import (
from marimo._runtime.utils.set_ui_element_request_manager import (
SetUIElementRequestManager,
)
+from marimo._session.model import SessionMode
if TYPE_CHECKING:
- from collections.abc import Awaitable, Callable
+ from collections.abc import Awaitable, Callable, Iterator
from marimo._ast.cell import CellConfig
from marimo._config.config import MarimoConfig
@@ -46,7 +49,6 @@ if TYPE_CHECKING:
)
from marimo._runtime.runtime import Kernel
from marimo._runtime.virtual_file import VirtualFileStorageType
- from marimo._session.model import SessionMode
from marimo._session.queue import QueueType
from marimo._types.ids import CellId_t
@@ -55,6 +57,30 @@ if TYPE_CHECKING:
QueueType[BatchableCommand] | asyncio.Queue[BatchableCommand]
)
+
[email protected](kw_only=True)
+class KernelArgs:
+ """All inputs needed to construct a `Kernel` and its runtime context."""
+
+ stream: Stream
+ stdout: Stdout | None
+ stderr: Stderr | None
+ stdin: Stdin | None
+ debugger: marimo_pdb.MarimoPdb | None
+ configs: dict[CellId_t, CellConfig]
+ app_metadata: AppMetadata
+ user_config: MarimoConfig
+ mode: SessionMode
+ control_queue: ControlQueue
+ set_ui_element_queue: UIElementQueue
+ virtual_file_storage: VirtualFileStorageType | None
+ print_override_fn: Callable[[Any], None] | None
+
+ @property
+ def is_edit_mode(self) -> bool:
+ return self.mode == SessionMode.EDIT
+
+
LOGGER = _loggers.marimo_logger()
# Lets each caller pin listen_messages and its reader to the same queue type
@@ -81,65 +107,64 @@ def _build_hooks(
def create_kernel(
- *,
- stream: Stream,
- stdout: Stdout | None,
- stderr: Stderr | None,
- stdin: Stdin | None,
- debugger: marimo_pdb.MarimoPdb | None,
- configs: dict[CellId_t, CellConfig],
- app_metadata: AppMetadata,
- user_config: MarimoConfig,
- is_edit_mode: bool,
- control_queue: ControlQueue,
- set_ui_element_queue: UIElementQueue,
- virtual_file_storage: VirtualFileStorageType | None,
- mode: SessionMode,
- print_override_fn: Callable[[Any], None] | None,
+ args: KernelArgs,
) -> tuple[Kernel, KernelRuntimeContext]:
+ user_config = args.user_config
# Run mode forces autorun and disables the module autoreloader.
- if not is_edit_mode:
+ if not args.is_edit_mode:
user_config = user_config.copy()
user_config["runtime"]["on_cell_change"] = "autorun"
user_config["runtime"]["auto_reload"] = "off"
def _enqueue_control_request(req: CommandMessage) -> None:
- control_queue.put_nowait(req)
+ args.control_queue.put_nowait(req)
if isinstance(req, (UpdateUIElementCommand, ModelCommand)):
- set_ui_element_queue.put_nowait(req)
+ args.set_ui_element_queue.put_nowait(req)
# Deferred to break the runtime.py <-> kernel_lifecycle.py import cycle.
from marimo._runtime.runtime import Kernel
kernel = Kernel(
- cell_configs=configs,
- app_metadata=app_metadata,
- stream=stream,
- stdout=stdout,
- stderr=stderr,
- stdin=stdin,
+ cell_configs=args.configs,
+ app_metadata=args.app_metadata,
+ stream=args.stream,
+ stdout=args.stdout,
+ stderr=args.stderr,
+ stdin=args.stdin,
module=patches.patch_main_module(
- file=app_metadata.filename,
+ file=args.app_metadata.filename,
input_override=input_override,
- print_override=print_override_fn,
- doc=app_metadata.docstring,
+ print_override=args.print_override_fn,
+ doc=args.app_metadata.docstring,
),
- debugger_override=debugger,
+ debugger_override=args.debugger,
user_config=user_config,
enqueue_control_request=_enqueue_control_request,
- hooks=_build_hooks(is_edit_mode, user_config),
+ hooks=_build_hooks(args.is_edit_mode, user_config),
)
ctx = initialize_kernel_context(
kernel=kernel,
- stream=stream,
- stdout=stdout,
- stderr=stderr,
- virtual_file_storage=virtual_file_storage,
- mode=mode,
+ stream=args.stream,
+ stdout=args.stdout,
+ stderr=args.stderr,
+ virtual_file_storage=args.virtual_file_storage,
+ mode=args.mode,
)
return kernel, ctx
+def kernel_session(
+ args: KernelArgs,
+) -> Iterator[tuple[Kernel, KernelRuntimeContext]]:
+ """Create a kernel + context, yield it, tear it down on exit."""
+ kernel, ctx = create_kernel(args)
+ try:
+ yield kernel, ctx
+ finally:
+ teardown_kernel(kernel, ctx)
+
+
async def threaded_queue_reader(
queue: QueueType[CommandMessage],
) -> CommandMessage | None:
diff --git a/marimo/_runtime/runtime.py b/marimo/_runtime/runtime.py
index f42a8bdcaa..be56a50c32 100644
--- a/marimo/_runtime/runtime.py
+++ b/marimo/_runtime/runtime.py
@@ -3753,9 +3753,9 @@ def launch_kernel(
parent_pid: int | None = None,
) -> None:
from marimo._runtime.kernel_lifecycle import (
- create_kernel,
+ KernelArgs,
+ kernel_session,
listen_messages,
- teardown_kernel,
threaded_queue_reader,
)
@@ -3780,50 +3780,50 @@ def launch_kernel(
if streams is None:
return
- kernel, ctx = create_kernel(
- stream=streams.stream,
- stdout=streams.stdout,
- stderr=streams.stderr,
- stdin=streams.stdin,
- debugger=streams.debugger,
- configs=configs,
- app_metadata=app_metadata,
- user_config=user_config,
- is_edit_mode=is_edit_mode,
- control_queue=control_queue,
- set_ui_element_queue=set_ui_element_queue,
- virtual_file_storage=virtual_file_storage,
- mode=SessionMode.EDIT if is_edit_mode else SessionMode.RUN,
- print_override_fn=print_override,
- )
-
- if is_edit_mode:
- # completions only provided in edit mode
- kernel.start_completion_worker(completion_queue)
-
- if is_subprocess:
- # Read theme from kernel.user_config — create_kernel may have
- # mutated it for run mode (autorun + auto_reload off).
- _install_subprocess_handlers(
- kernel, ctx, kernel.user_config, interrupt_queue
- )
-
- # The control loop is asynchronous so that (a) user code can use
- # top-level await, and (b) background asyncio tasks created by user
- # code (via create_task / ensure_future) are not starved by a
- # blocking queue.get(). The queue read is offloaded to a thread via
- # run_in_executor; avoid adding further async primitives elsewhere
- # in the runtime unless there is a very good reason.
- coro = listen_messages(
- kernel,
- control_queue,
- set_ui_element_queue,
- threaded_queue_reader,
- )
- if loop_factory is not None:
- asyncio.run(coro, loop_factory=loop_factory)
- else:
- asyncio.run(coro)
+ with kernel_session(
+ KernelArgs(
+ stream=streams.stream,
+ stdout=streams.stdout,
+ stderr=streams.stderr,
+ stdin=streams.stdin,
+ debugger=streams.debugger,
+ configs=configs,
+ app_metadata=app_metadata,
+ user_config=user_config,
+ mode=SessionMode.EDIT if is_edit_mode else SessionMode.RUN,
+ control_queue=control_queue,
+ set_ui_element_queue=set_ui_element_queue,
+ virtual_file_storage=virtual_file_storage,
+ print_override_fn=print_override,
+ )
+ ) as (kernel, ctx):
+ if is_edit_mode:
+ # completions only provided in edit mode
+ kernel.start_completion_worker(completion_queue)
+
+ if is_subprocess:
+ # Read theme from kernel.user_config — create_kernel may have
+ # mutated it for run mode (autorun + auto_reload off).
+ _install_subprocess_handlers(
+ kernel, ctx, kernel.user_config, interrupt_queue
+ )
+
+ # The control loop is asynchronous so that (a) user code can use
+ # top-level await, and (b) background asyncio tasks created by
+ # user code (via create_task / ensure_future) are not starved by
+ # a blocking queue.get(). The queue read is offloaded to a
+ # thread via run_in_executor; avoid adding further async
+ # primitives elsewhere in the runtime unless there is a very
+ # good reason.
+ coro = listen_messages(
+ kernel,
+ control_queue,
+ set_ui_element_queue,
+ threaded_queue_reader,
+ )
+ if loop_factory is not None:
+ asyncio.run(coro, loop_factory=loop_factory)
+ else:
+ asyncio.run(coro)
- teardown_kernel(kernel, ctx)
streams.close(use_fd_redirect)
diff --git a/tests/_runtime/_helpers/factories.py b/tests/_runtime/_helpers/factories.py
new file mode 100644
index 0000000000..f7a8c78baf
--- /dev/null
+++ b/tests/_runtime/_helpers/factories.py
@@ -0,0 +1,22 @@
+# Copyright 2026 Marimo. All rights reserved.
+"""Default-builders for boilerplate runtime test values."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from marimo._ast.app_config import _AppConfig
+from marimo._runtime.commands import AppMetadata
+
+
+def default_app_metadata(**overrides: Any) -> AppMetadata:
+ """`AppMetadata` with empty defaults; overrides win."""
+ base: dict[str, Any] = {
+ "query_params": {},
+ "filename": None,
+ "cli_args": {},
+ "argv": None,
+ "app_config": _AppConfig(),
+ }
+ base.update(overrides)
+ return AppMetadata(**base)
diff --git a/tests/_runtime/_helpers/session.py b/tests/_runtime/_helpers/session.py
new file mode 100644
index 0000000000..1a30eb9851
--- /dev/null
+++ b/tests/_runtime/_helpers/session.py
@@ -0,0 +1,119 @@
+# Copyright 2026 Marimo. All rights reserved.
+"""Test-flavored wrapper around production `kernel_session()`.
+
+Tests use `mocked_kernel_session()` as a context manager to get a fully wired
+kernel with mock streams, sensible default config, and automatic teardown.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import dataclasses
+import sys
+from typing import TYPE_CHECKING
+
+from marimo._config.config import DEFAULT_CONFIG
+from marimo._messaging.print_override import print_override
+from marimo._runtime.kernel_lifecycle import KernelArgs, kernel_session
+from marimo._runtime.marimo_pdb import MarimoPdb
+from marimo._runtime.virtual_file import VirtualFileStorageType
+from marimo._session.model import SessionMode
+from tests._runtime._helpers.factories import default_app_metadata
+from tests._runtime._helpers.streams import (
+ MockStderr,
+ MockStdin,
+ MockStdout,
+ MockStream,
+)
+
+if TYPE_CHECKING:
+ from collections.abc import Iterator
+
+ from marimo._ast.cell import CellConfig
+ from marimo._config.config import ExecutionType, MarimoConfig
+ from marimo._runtime.commands import AppMetadata
+ from marimo._runtime.context.kernel_context import KernelRuntimeContext
+ from marimo._runtime.runtime import Kernel
+ from marimo._types.ids import CellId_t
+
+
+class TestKernel:
+ """A live kernel + its mocked I/O surface, bound for the test's lifetime."""
+
+ kernel: Kernel
+ ctx: KernelRuntimeContext
+ stream: MockStream
+ stdout: MockStdout
+ stderr: MockStderr
+ stdin: MockStdin
+
+
+def mocked_kernel_session(
+ *,
+ app_metadata: AppMetadata | None = None,
+ user_config: MarimoConfig | None = None,
+ configs: dict[CellId_t, CellConfig] | None = None,
+ mode: SessionMode = SessionMode.EDIT,
+ execution_type: ExecutionType | None = None,
+ reactive_mode: str | None = None,
+ with_debugger: bool = True,
+) -> Iterator[TestKernel]:
+ """Yield a fully wired `TestKernel`; tear it down on exit.
+
+ Wraps production `kernel_session()` and supplies test defaults: mock
+ streams, dummy queues (the kernel doesn't drive a real loop here), an
+ optional in-process debugger, and edit-mode by default. Restores
+ `sys.modules["__main__"]` on exit since `patch_main_module` swaps it.
+ """
+ stream = MockStream()
+ stdout = MockStdout(stream)
+ stderr = MockStderr(stream)
+ stdin = MockStdin(stream)
+ debugger = MarimoPdb(stdout=stdout, stdin=stdin) if with_debugger else None
+
+ saved_main = sys.modules.get("__main__")
+ # Kernel.teardown() clears the kernel module's __dict__, which breaks
+ # any sys.meta_path entries installed by patches.patch_micropip (their
+ # closures reference module globals) for subsequent tests.
+ saved_meta_path = sys.meta_path[:]
+ virtual_file_storage: VirtualFileStorageType = (
+ "shared_memory" if mode == SessionMode.EDIT else "in_memory"
+ )
+
+ args = KernelArgs(
+ stream=stream,
+ stdout=stdout,
+ stderr=stderr,
+ stdin=stdin,
+ debugger=debugger,
+ configs=configs or {},
+ app_metadata=app_metadata or default_app_metadata(),
+ user_config=user_config or DEFAULT_CONFIG,
+ mode=mode,
+ control_queue=asyncio.Queue(),
+ set_ui_element_queue=asyncio.Queue(),
+ virtual_file_storage=virtual_file_storage,
+ print_override_fn=print_override,
+ )
+
+ try:
+ with kernel_session(args) as (kernel, ctx):
+ if execution_type is not None:
+ kernel.execution_type = execution_type
+ if reactive_mode is not None:
+ kernel.reactive_execution_mode = reactive_mode # type: ignore[assignment]
+ yield TestKernel(
+ kernel=kernel,
+ ctx=ctx,
+ stream=stream,
+ stdout=stdout,
+ stderr=stderr,
+ stdin=stdin,
+ )
+ finally:
+ sys.meta_path[:] = saved_meta_path
+ if saved_main is not None:
+ sys.modules["__main__"] = saved_main
diff --git a/tests/_runtime/_helpers/streams.py b/tests/_runtime/_helpers/streams.py
new file mode 100644
index 0000000000..6c0d62a76a
--- /dev/null
+++ b/tests/_runtime/_helpers/streams.py
@@ -0,0 +1,123 @@
+# Copyright 2026 Marimo. All rights reserved.
+"""Mock streams for runtime tests.
+
+`MockStream` inherits the production `ThreadSafe*` types so it slots into
+anywhere a real stream is expected.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import TYPE_CHECKING, Any, cast
+
+from marimo._messaging.notification import (
+ CellNotification,
+ NotificationMessage,
+)
+from marimo._messaging.serde import deserialize_kernel_message
+from marimo._messaging.streams import (
+ ThreadSafeStderr,
+ ThreadSafeStdin,
+ ThreadSafeStdout,
+ ThreadSafeStream,
+)
+from marimo._messaging.types import KernelMessage
+
+if TYPE_CHECKING:
+ from marimo._messaging.mimetypes import ConsoleMimeType
+
+
+class MockStream(ThreadSafeStream):
+ """Captures `KernelMessage`s written to it and exposes useful views."""
+
+ def __init__(
+ self,
+ pipe: Any = None,
+ input_queue: Any = None,
+ redirect_console: bool = False,
+ cell_id: Any = None,
+ ) -> None:
+ # Bypass `ThreadSafeStream.__init__`: no real pipe/input queue and
+ # we don't want a buffered-console thread. Accept the same kwargs so
+ # callers that clone via `type(stream)(pipe=..., ...)` keep working
+ # (e.g. `marimo.Thread`).
+ self.pipe = cast(Any, pipe)
+ self.input_queue = cast(Any, input_queue)
+ self.redirect_console = redirect_console
+ self.cell_id = cell_id
+ self.messages: list[KernelMessage] = []
+ import threading
+
+ self.stream_lock = threading.Lock()
+
+ def write(self, data: KernelMessage) -> None:
+ self.messages.append(data)
+ deserialize_kernel_message(data)
+
+ @property
+ def raw_operations(self) -> list[dict[str, Any]]:
+ return [json.loads(op) for op in self.messages]
+
+ @property
+ def operations(self) -> list[NotificationMessage]:
+ return [deserialize_kernel_message(op) for op in self.messages]
+
+ # Back-compat alias: tests/_messaging/mocks.py:MockStream exposed this name.
+ parsed_operations = operations
+
+ @property
+ def cell_notifications(self) -> list[CellNotification]:
+ return [
+ op for op in self.operations if isinstance(op, CellNotification)
+ ]
+
+
+class MockStdout(ThreadSafeStdout):
+ """Captures stdout writes as a list of strings."""
+
+ def __init__(self, stream: MockStream) -> None:
+ super().__init__(stream)
+ self.messages: list[str] = []
+
+ def _write_with_mimetype(
+ self, data: str, mimetype: ConsoleMimeType
+ ) -> int:
+ del mimetype
+ self.messages.append(data)
+ return len(data)
+
+ def __repr__(self) -> str:
+ return "".join(self.messages)
+
+
+class MockStderr(ThreadSafeStderr):
+ """Captures stderr writes; `repr` strips HTML for plain-text comparison."""
+
+ def __init__(self, stream: MockStream) -> None:
+ super().__init__(stream)
+ self.messages: list[str] = []
+
+ def _write_with_mimetype(
+ self, data: str, mimetype: ConsoleMimeType
+ ) -> int:
+ del mimetype
+ self.messages.append(data)
+ return len(data)
+
+ def __repr__(self) -> str:
+ return re.sub(r"<.*?>", "", "".join(self.messages))
+
+
+class MockStdin(ThreadSafeStdin):
+ """Echoes the prompt back so input() calls don't hang."""
+
+ def __init__(self, stream: MockStream) -> None:
+ super().__init__(stream)
+ self.messages: list[str] = []
+
+ def _readline_with_prompt(
+ self, prompt: str = "", password: bool = False
+ ) -> str:
+ del password
+ return prompt
diff --git a/tests/_runtime/test_runtime.py b/tests/_runtime/test_runtime.py
index 6dd9e75230..537b529735 100644
--- a/tests/_runtime/test_runtime.py
+++ b/tests/_runtime/test_runtime.py
@@ -12,7 +12,6 @@ from unittest.mock import MagicMock, Mock, patch
import pytest
-from marimo._ast.app_config import _AppConfig
from marimo._config.config import DEFAULT_CONFIG
from marimo._dependencies.dependencies import DependencyManager
from marimo._messaging.cell_output import CellChannel
@@ -30,22 +29,16 @@ from marimo._messaging.notification import (
VariablesNotification,
)
from marimo._messaging.serde import deserialize_kernel_message
-from marimo._messaging.types import NoopStream
from marimo._plugins.ui._core.ids import IDProvider
from marimo._plugins.ui._core.ui_element import UIElement
from marimo._runtime.commands import (
- AppMetadata,
CreateNotebookCommand,
DeleteCellCommand,
ExecuteCellCommand,
UpdateCellConfigCommand,
UpdateUIElementCommand,
)
-from marimo._runtime.context.kernel_context import initialize_kernel_context
-from marimo._runtime.context.types import teardown_context
from marimo._runtime.dataflow import EdgeWithVar
-from marimo._runtime.patches import create_main_module
-from marimo._runtime.runner.hooks import create_default_hooks
from marimo._runtime.runtime import (
Kernel,
launch_kernel,
@@ -53,9 +46,10 @@ from marimo._runtime.runtime import (
notebook_location,
)
from marimo._runtime.scratch import SCRATCH_CELL_ID
-from marimo._session.model import SessionMode
from marimo._utils.parse_dataclass import parse_raw
from tests._messaging.mocks import MockStderr, MockStream
+from tests._runtime._helpers.factories import default_app_metadata
+from tests._runtime._helpers.session import mocked_kernel_session
from tests.conftest import ExecReqProvider, MockedKernel, mock_pyodide
if TYPE_CHECKING:
@@ -1367,44 +1361,19 @@ except NameError:
async def test_notebook_dir_for_unnamed_notebook(
self, tmp_path: pathlib.Path, exec_req: ExecReqProvider
) -> None:
+ filename = str(tmp_path / "notebook.py")
try:
- filename = str(tmp_path / "notebook.py")
- k = Kernel(
- stream=NoopStream(),
- stdout=None,
- stderr=None,
- stdin=None,
- cell_configs={},
- user_config=DEFAULT_CONFIG,
- app_metadata=AppMetadata(
- query_params={},
- filename=filename,
- cli_args={},
- argv=None,
- app_config=_AppConfig(),
- ),
- enqueue_control_request=lambda _: None,
- module=create_main_module(None, None, None),
- hooks=create_default_hooks(),
- )
- initialize_kernel_context(
- kernel=k,
- stream=k.stream,
- stdout=k.stdout,
- stderr=k.stderr,
- virtual_file_storage="shared_memory",
- mode=SessionMode.EDIT,
- )
-
- await k.run(
- [
- exec_req.get("import marimo as mo"),
- exec_req.get("x = mo.notebook_dir() / 'foo.csv'"),
- ]
- )
- assert str(k.globals["x"]).endswith("foo.csv")
+ with mocked_kernel_session(
+ app_metadata=default_app_metadata(filename=filename),
+ ) as tk:
+ await tk.kernel.run(
+ [
+ exec_req.get("import marimo as mo"),
+ exec_req.get("x = mo.notebook_dir() / 'foo.csv'"),
+ ]
+ )
+ assert str(tk.kernel.globals["x"]).endswith("foo.csv")
finally:
- teardown_context()
if str(tmp_path) in sys.path:
sys.path.remove(str(tmp_path))
@@ -1433,59 +1402,30 @@ except NameError:
assert k.globals["pickle_output"] is not None
def test_sys_path_updated(self, tmp_path: pathlib.Path) -> None:
+ filename = str(tmp_path / "notebook.py")
try:
- filename = str(tmp_path / "notebook.py")
- Kernel(
- stream=NoopStream(),
- stdout=None,
- stderr=None,
- stdin=None,
- cell_configs={},
- user_config=DEFAULT_CONFIG,
- app_metadata=AppMetadata(
- query_params={},
- filename=filename,
- cli_args={},
- argv=None,
- app_config=_AppConfig(),
- ),
- enqueue_control_request=lambda _: None,
- module=create_main_module(None, None, None),
- hooks=create_default_hooks(),
- )
- assert str(tmp_path) in sys.path
- assert str(tmp_path) == sys.path[0]
+ with mocked_kernel_session(
+ app_metadata=default_app_metadata(filename=filename),
+ ):
+ assert str(tmp_path) in sys.path
+ assert str(tmp_path) == sys.path[0]
finally:
if str(tmp_path) in sys.path:
sys.path.remove(str(tmp_path))
def test_sys_argv_updated(self, tmp_path: pathlib.Path) -> None:
old_argv = sys.argv
+ filename = str(tmp_path / "notebook.py")
try:
- filename = str(tmp_path / "notebook.py")
- Kernel(
- stream=NoopStream(),
- stdout=None,
- stderr=None,
- stdin=None,
- cell_configs={},
- user_config=DEFAULT_CONFIG,
- app_metadata=AppMetadata(
- query_params={},
- filename=filename,
- cli_args={},
- argv=["foo", "bar"],
- app_config=_AppConfig(),
+ with mocked_kernel_session(
+ app_metadata=default_app_metadata(
+ filename=filename, argv=["foo", "bar"]
),
- enqueue_control_request=lambda _: None,
- module=create_main_module(None, None, None),
- hooks=create_default_hooks(),
- )
-
- assert len(sys.argv) == 3
- assert filename == sys.argv[0]
- assert sys.argv[1] == "foo"
- assert sys.argv[2] == "bar"
+ ):
+ assert len(sys.argv) == 3
+ assert filename == sys.argv[0]
+ assert sys.argv[1] == "foo"
+ assert sys.argv[2] == "bar"
finally:
sys.argv = old_argv
if str(tmp_path) in sys.path:
@@ -1495,27 +1435,12 @@ except NameError:
self, tmp_path: pathlib.Path
) -> None:
argv = sys.argv
+ filename = str(tmp_path / "notebook.py")
try:
- filename = str(tmp_path / "notebook.py")
- Kernel(
- stream=NoopStream(),
- stdout=None,
- stderr=None,
- stdin=None,
- cell_configs={},
- user_config=DEFAULT_CONFIG,
- app_metadata=AppMetadata(
- query_params={},
- filename=filename,
- cli_args={},
- argv=None,
- app_config=_AppConfig(),
- ),
- enqueue_control_request=lambda _: None,
- module=create_main_module(None, None, None),
- hooks=create_default_hooks(),
- )
- assert argv == sys.argv
+ with mocked_kernel_session(
+ app_metadata=default_app_metadata(filename=filename),
+ ):
+ assert argv == sys.argv
finally:
# restore argv in case test failed or accidentally mutated it
sys.argv = argv
@@ -1529,51 +1454,26 @@ except NameError:
filename = tmp_path / "notebook.py"
try:
- k = Kernel(
- stream=NoopStream(),
- stdout=None,
- stderr=None,
- stdin=None,
- cell_configs={},
- user_config={
- **DEFAULT_CONFIG,
- "runtime": {
- **DEFAULT_CONFIG["runtime"],
- "pythonpath": [str(custom_path)],
- },
+ user_config = {
+ **DEFAULT_CONFIG,
+ "runtime": {
+ **DEFAULT_CONFIG["runtime"],
+ "pythonpath": [str(custom_path)],
},
- app_metadata=AppMetadata(
- query_params={},
- filename=str(filename),
- cli_args={},
- argv=None,
- app_config=_AppConfig(),
- ),
- enqueue_control_request=lambda _: None,
- module=create_main_module(None, None, None),
- hooks=create_default_hooks(),
- )
- initialize_kernel_context(
- kernel=k,
- stream=k.stream,
- stdout=k.stdout,
- stderr=k.stderr,
- virtual_file_storage="shared_memory",
- mode=SessionMode.EDIT,
- )
-
- # Verify the path was added using exec_req
- await k.run(
- [
- exec_req.get("import sys"),
- exec_req.get("paths = list(sys.path)"),
- ]
- )
-
- assert str(custom_path) in k.globals["paths"]
- assert str(filename.parent) in k.globals["paths"]
+ }
+ with mocked_kernel_session(
+ app_metadata=default_app_metadata(filename=str(filename)),
+ user_config=user_config, # type: ignore[arg-type]
+ ) as tk:
+ await tk.kernel.run(
+ [
+ exec_req.get("import sys"),
+ exec_req.get("paths = list(sys.path)"),
+ ]
+ )
+ assert str(custom_path) in tk.kernel.globals["paths"]
+ assert str(filename.parent) in tk.kernel.globals["paths"]
finally:
- teardown_context()
if str(tmp_path) in sys.path:
sys.path.remove(str(tmp_path))
if str(custom_path) in sys.path:
@@ -4239,9 +4139,7 @@ class TestLaunchKernelEventLoop:
socket_addr=None,
is_edit_mode=is_edit_mode,
configs={},
- app_metadata=AppMetadata(
- query_params={}, cli_args={}, app_config=_AppConfig()
- ),
+ app_metadata=default_app_metadata(),
user_config=DEFAULT_CONFIG,
virtual_file_storage=None,
redirect_console_to_browser=False,
diff --git a/tests/conftest.py b/tests/conftest.py
index 0b8699c807..d92158950b 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -5,7 +5,6 @@ import contextlib
import dataclasses
import functools
import inspect
-import re
import shutil
import sys
import textwrap
@@ -17,38 +16,25 @@ import pytest
from _pytest import runner
from marimo._ast.app import App
-from marimo._ast.app_config import _AppConfig
from marimo._ast.cell_manager import CellManager
-from marimo._config.config import DEFAULT_CONFIG
from marimo._dependencies.dependencies import DependencyManager
-from marimo._messaging.mimetypes import ConsoleMimeType
-from marimo._messaging.notification import (
- CellNotification,
- NotificationMessage,
-)
-from marimo._messaging.print_override import print_override
-from marimo._messaging.serde import deserialize_kernel_message
-from marimo._messaging.streams import (
- ThreadSafeStderr,
- ThreadSafeStdin,
- ThreadSafeStdout,
- ThreadSafeStream,
-)
-from marimo._messaging.types import KernelMessage
from marimo._output.formatters.formatters import register_formatters
-from marimo._runtime import patches
-from marimo._runtime.commands import AppMetadata, ExecuteCellCommand
-from marimo._runtime.context import teardown_context
-from marimo._runtime.context.kernel_context import initialize_kernel_context
-from marimo._runtime.input_override import input_override
-from marimo._runtime.marimo_pdb import MarimoPdb
-from marimo._runtime.runner.hooks import create_default_hooks
-from marimo._runtime.runtime import Kernel
+from marimo._runtime.commands import ExecuteCellCommand
from marimo._save.stubs.module_stub import ModuleStub
from marimo._server.utils import initialize_mimetypes
from marimo._session.model import SessionMode
from marimo._session.state.session_view import SessionView
from marimo._types.ids import CellId_t
+from tests._runtime._helpers.session import TestKernel, mocked_kernel_session
+from tests._runtime._helpers.streams import (
+ MockStderr,
+ MockStdin,
+ MockStdout,
+ MockStream,
+)
+
+# Back-compat alias: tests/_runtime/test_redirect_streams.py still imports this.
+_MockStream = MockStream
if TYPE_CHECKING:
from collections.abc import Generator
@@ -56,6 +42,8 @@ if TYPE_CHECKING:
from typing_extensions import Self
+ from marimo._runtime.runtime import Kernel
+
# register import hooks for third-party module formatters
register_formatters()
@@ -265,178 +253,71 @@ def patch_random_seed(monkeypatch: pytest.MonkeyPatch) -> None:
@dataclasses.dataclass
-class _MockStream(ThreadSafeStream):
- """Captures the ops sent through the stream"""
-
- cell_id: int | None = None
- input_queue: None = None
- pipe: None = None
- redirect_console: bool = False
+class MockedKernel:
+ """Should only be created in fixtures b/c inits a runtime context."""
- messages: list[KernelMessage] = dataclasses.field(default_factory=list)
+ _tk: TestKernel
+ _cm: contextlib.AbstractContextManager[TestKernel]
- def write(self, data: KernelMessage) -> None:
- self.messages.append(data)
- # Attempt to deserialize the message to ensure it is valid
- deserialize_kernel_message(data)
+ @classmethod
+ def open(cls, **kwargs: Any) -> MockedKernel:
+ cm = mocked_kernel_session(**kwargs)
+ tk = cm.__enter__()
+ return cls(_tk=tk, _cm=cm)
@property
- def operations(self) -> list[NotificationMessage]:
- return [
- deserialize_kernel_message(op_data) for op_data in self.messages
- ]
+ def k(self) -> Kernel:
+ return self._tk.kernel
@property
- def cell_notifications(self) -> list[CellNotification]:
- return [
- op for op in self.operations if isinstance(op, CellNotification)
- ]
-
-
-class MockStdout(ThreadSafeStdout):
- """Captures the output sent through the stream"""
-
- def __init__(self, stream: _MockStream) -> None:
- super().__init__(stream)
- self.messages: list[str] = []
-
- def _write_with_mimetype(
- self, data: str, mimetype: ConsoleMimeType
- ) -> int:
- del mimetype
- self.messages.append(data)
- return len(data)
-
- def __repr__(self) -> str:
- return "".join(self.messages)
-
-
-class MockStderr(ThreadSafeStderr):
- """Captures the output sent through the stream"""
-
- messages: list[str] = dataclasses.field(default_factory=list)
-
- def __init__(self, stream: _MockStream) -> None:
- super().__init__(stream)
- self.messages: list[str] = []
-
- def _write_with_mimetype(
- self, data: str, mimetype: ConsoleMimeType
- ) -> int:
- del mimetype
- self.messages.append(data)
- return len(data)
+ def stream(self) -> MockStream:
+ return self._tk.stream
- def __repr__(self) -> str:
- # Error messages are commonly formatted for output in HTML
- return re.sub(r"<.*?>", "", "".join(self.messages))
-
-
-class MockStdin(ThreadSafeStdin):
- """Echoes the prompt."""
-
- def __init__(self, stream: _MockStream) -> None:
- super().__init__(stream)
- self.messages: list[str] = []
-
- def _readline_with_prompt(
- self, prompt: str = "", password: bool = False
- ) -> str:
- del password
- return prompt
-
-
-class MockedKernel:
- """Should only be created in fixtures b/c inits a runtime context"""
-
- stream: _MockStream = dataclasses.field(default_factory=_MockStream)
- session_mode: SessionMode = SessionMode.EDIT
-
- def __post_init__(self) -> None:
- self.stdout = MockStdout(self.stream)
- self.stderr = MockStderr(self.stream)
- self.stdin = MockStdin(self.stream)
- self._main = sys.modules["__main__"]
- module = patches.patch_main_module(
- file=None,
- input_override=input_override,
- print_override=print_override,
- )
+ @property
+ def stdout(self) -> MockStdout:
+ return self._tk.stdout
- self.k = Kernel(
- stream=self.stream,
- stdout=self.stdout,
- stderr=self.stderr,
- stdin=self.stdin,
- cell_configs={},
- user_config=DEFAULT_CONFIG,
- app_metadata=AppMetadata(
- query_params={},
- filename=None,
- cli_args={},
- argv=None,
- app_config=_AppConfig(),
- ),
- debugger_override=MarimoPdb(stdout=self.stdout, stdin=self.stdin),
- enqueue_control_request=lambda _: None,
- module=module,
- hooks=create_default_hooks(),
- )
+ @property
+ def stderr(self) -> MockStderr:
+ return self._tk.stderr
- initialize_kernel_context(
- kernel=self.k,
- stream=self.stream, # type: ignore
- stdout=self.stdout, # type: ignore
- stderr=self.stderr, # type: ignore
- virtual_file_storage=(
- "shared_memory"
- if self.session_mode == SessionMode.EDIT
- else "in_memory"
- ),
- mode=self.session_mode,
- )
+ @property
+ def stdin(self) -> MockStdin:
+ return self._tk.stdin
def teardown(self) -> None:
- # must be called by fixtures that instantiate this
- teardown_context()
- self.stdout._watcher.stop()
- self.stderr._watcher.stop()
- if self.k.module_watcher is not None:
- self.k.module_watcher.stop()
- sys.modules["__main__"] = self._main
+ self._cm.__exit__(None, None, None)
# fixture that provides a kernel (and tears it down)
@pytest.fixture
def k() -> Generator[Kernel, None, None]:
- mocked = MockedKernel()
- yield mocked.k
- mocked.teardown()
+ with mocked_kernel_session() as tk:
+ yield tk.kernel
# kernel configured with runtime=lazy
@pytest.fixture
-def lazy_kernel(k: Kernel) -> Kernel:
- k.execution_type = "relaxed"
- k.reactive_execution_mode = "lazy"
- return k
+def lazy_kernel() -> Generator[Kernel, None, None]:
+ with mocked_kernel_session(
+ execution_type="relaxed", reactive_mode="lazy"
+ ) as tk:
+ yield tk.kernel
# kernel configured with strict execution
@pytest.fixture
def strict_kernel() -> Generator[Kernel, None, None]:
- mocked = MockedKernel()
- mocked.k.execution_type = "strict"
- mocked.k.reactive_execution_mode = "autorun"
- yield mocked.k
- mocked.teardown()
+ with mocked_kernel_session(
+ execution_type="strict", reactive_mode="autorun"
+ ) as tk:
+ yield tk.kernel
# kernel configured in SessionMode.RUN mode
@pytest.fixture
def run_mode_kernel() -> Generator[MockedKernel, None, None]:
- mocked = MockedKernel(session_mode=SessionMode.RUN)
+ mocked = MockedKernel.open(mode=SessionMode.RUN)
yield mocked
mocked.teardown()
@@ -454,7 +335,7 @@ def any_kernel(request: Any) -> Kernel:
# fixture that wraps a kernel and other mocked objects
@pytest.fixture
def mocked_kernel() -> Generator[MockedKernel, None, None]:
- mocked = MockedKernel()
+ mocked = MockedKernel.open()
yield mocked
mocked.teardown()
@@ -462,7 +343,7 @@ def mocked_kernel() -> Generator[MockedKernel, None, None]:
# Installs an execution context without stream redirection
@pytest.fixture
def executing_kernel() -> Generator[Kernel, None, None]:
- mocked = MockedKernel()
+ mocked = MockedKernel.open()
mocked.k.stdout = None
mocked.k.stderr = None
mocked.k.stdin = None