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.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
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.pyindex 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_formattersfrom 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 Nonekernel, 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.pyindex 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 annotationsimport asyncio+import contextlib+import dataclassesfrom typing import TYPE_CHECKING, Any, TypeVarfrom 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 SessionModeif TYPE_CHECKING:- from collections.abc import Awaitable, Callable+ from collections.abc import Awaitable, Callable, Iteratorfrom marimo._ast.cell import CellConfigfrom marimo._config.config import MarimoConfig@@ -46,7 +49,6 @@ if TYPE_CHECKING:)from marimo._runtime.runtime import Kernelfrom marimo._runtime.virtual_file import VirtualFileStorageType- from marimo._session.model import SessionModefrom marimo._session.queue import QueueTypefrom 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 Kernelkernel = 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.pyindex 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.pynew file mode 100644index 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.pynew file mode 100644index 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_maindiff --git a/tests/_runtime/_helpers/streams.py b/tests/_runtime/_helpers/streams.pynew file mode 100644index 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 promptdiff --git a/tests/_runtime/test_runtime.py b/tests/_runtime/test_runtime.pyindex 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, patchimport pytest-from marimo._ast.app_config import _AppConfigfrom marimo._config.config import DEFAULT_CONFIGfrom marimo._dependencies.dependencies import DependencyManagerfrom 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 NoopStreamfrom marimo._plugins.ui._core.ids import IDProviderfrom marimo._plugins.ui._core.ui_element import UIElementfrom 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_contextfrom marimo._runtime.dataflow import EdgeWithVar-from marimo._runtime.patches import create_main_module-from marimo._runtime.runner.hooks import create_default_hooksfrom 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 SessionModefrom marimo._utils.parse_dataclass import parse_rawfrom tests._messaging.mocks import MockStderr, MockStream+from tests._runtime._helpers.factories import default_app_metadata+from tests._runtime._helpers.session import mocked_kernel_sessionfrom tests.conftest import ExecReqProvider, MockedKernel, mock_pyodideif 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 Nonedef 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_argvif 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.argvfinally:# restore argv in case test failed or accidentally mutated itsys.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.pyindex 0b8699c807..d92158950b 100644--- a/tests/conftest.py+++ b/tests/conftest.py@@ -5,7 +5,6 @@ import contextlibimport dataclassesimport functoolsimport inspect-import reimport shutilimport sysimport textwrap@@ -17,38 +16,25 @@ import pytestfrom _pytest import runnerfrom marimo._ast.app import App-from marimo._ast.app_config import _AppConfigfrom marimo._ast.cell_manager import CellManager-from marimo._config.config import DEFAULT_CONFIGfrom 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 KernelMessagefrom 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 ExecuteCellCommandfrom marimo._save.stubs.module_stub import ModuleStubfrom marimo._server.utils import initialize_mimetypesfrom marimo._session.model import SessionModefrom marimo._session.state.session_view import SessionViewfrom 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 = MockStreamif 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 formattersregister_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.stdindef 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.fixturedef 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.fixturedef 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.fixturedef run_mode_kernel() -> Generator[MockedKernel, None, None]:- mocked = MockedKernel(session_mode=SessionMode.RUN)+ mocked = MockedKernel.open(mode=SessionMode.RUN)yield mockedmocked.teardown()@@ -454,7 +335,7 @@ def any_kernel(request: Any) -> Kernel:# fixture that wraps a kernel and other mocked objects@pytest.fixturedef mocked_kernel() -> Generator[MockedKernel, None, None]:- mocked = MockedKernel()+ mocked = MockedKernel.open()yield mockedmocked.teardown()@@ -462,7 +343,7 @@ def mocked_kernel() -> Generator[MockedKernel, None, None]:# Installs an execution context without stream redirection@pytest.fixturedef executing_kernel() -> Generator[Kernel, None, None]:- mocked = MockedKernel()+ mocked = MockedKernel.open()mocked.k.stdout = Nonemocked.k.stderr = Nonemocked.k.stdin = None