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.

tests: test extensions (#7600)

Myles Scolnicka3a3b7fd7ade
diff --git a/tests/_server/sessions/extensions/test_extensions.py b/tests/_server/sessions/extensions/test_extensions.py
new file mode 100644
index 0000000000..a2d4ac32c3
--- /dev/null
+++ b/tests/_server/sessions/extensions/test_extensions.py
@@ -0,0 +1,253 @@
+# Copyright 2024 Marimo. All rights reserved.
+"""Tests for session extensions."""
+
+from __future__ import annotations
+
+import asyncio
+from unittest.mock import Mock, patch
+
+import pytest
+
+from marimo._server.model import ConnectionState, SessionMode
+from marimo._server.sessions.events import SessionEventBus
+from marimo._server.sessions.extensions.extensions import (
+ CachingExtension,
+ HeartbeatExtension,
+ LoggingExtension,
+ NotificationListenerExtension,
+)
+from marimo._server.sessions.types import KernelState
+from marimo._types.ids import SessionId
+
+
+def mock_session():
+ """Create a mock session."""
+ session = Mock()
+ session.initialization_id = "test-session-id"
+ session.kernel_state = Mock(return_value=KernelState.RUNNING)
+ session.connection_state = Mock(return_value=ConnectionState.OPEN)
+ session.close = Mock()
+ session.ttl_seconds = 60
+ session.session_view = Mock()
+
+ # Mock app_file_manager
+ session.app_file_manager = Mock()
+ session.app_file_manager.filename = "test.py"
+ session.app_file_manager.path = "/path/to/test.py"
+ session.app_file_manager.app.cell_manager.cell_data = Mock(return_value=[])
+ session.app_file_manager.app.cell_manager.cell_ids = Mock(return_value=[])
+
+ return session
+
+
+def event_bus():
+ """Create event bus for testing."""
+ return SessionEventBus()
+
+
+class TestHeartbeatExtension:
+ """Tests for HeartbeatExtension."""
+
+ async def test_lifecycle(self, mock_session, event_bus) -> None:
+ """Test heartbeat start, stop, and cleanup on detach."""
+ extension = HeartbeatExtension()
+ extension.on_attach(mock_session, event_bus)
+
+ assert extension.heartbeat_task is not None
+
+ task = extension.heartbeat_task
+ extension.on_detach()
+ await asyncio.sleep(0.1)
+
+ assert task.cancelled()
+
+ async def test_detects_dead_kernel(self, mock_session, event_bus) -> None:
+ """Test that heartbeat detects when kernel dies and closes session."""
+ mock_session.kernel_state.return_value = KernelState.STOPPED
+ extension = HeartbeatExtension()
+ extension.on_attach(mock_session, event_bus)
+
+ await asyncio.sleep(1.5)
+
+ mock_session.close.assert_called_once()
+ extension.on_detach()
+
+
+class TestCachingExtension:
+ """Tests for CachingExtension."""
+
+ def test_disabled(self, mock_session, event_bus) -> None:
+ """Test that disabled caching does nothing."""
+ extension = CachingExtension(enabled=False)
+ extension.on_attach(mock_session, event_bus)
+
+ assert extension.session_cache_manager is None
+
+ @patch("marimo._server.sessions.extensions.extensions.SessionCacheManager")
+ def test_lifecycle(self, mock_cache_cls, mock_session, event_bus) -> None:
+ """Test cache manager creation, start, and stop."""
+ mock_cache = Mock()
+ mock_cache_cls.return_value = mock_cache
+ mock_cache.read_session_view = Mock(
+ return_value=mock_session.session_view
+ )
+
+ extension = CachingExtension(enabled=True)
+ extension.on_attach(mock_session, event_bus)
+
+ mock_cache.start.assert_called_once()
+
+ extension.on_detach()
+
+ mock_cache.stop.assert_called_once()
+
+ @patch("marimo._server.sessions.extensions.extensions.SessionCacheManager")
+ async def test_rename_updates_path(
+ self, mock_cache_cls, mock_session, event_bus
+ ) -> None:
+ """Test that renaming updates cache manager path."""
+ mock_cache = Mock()
+ mock_cache_cls.return_value = mock_cache
+ mock_cache.read_session_view = Mock(
+ return_value=mock_session.session_view
+ )
+
+ extension = CachingExtension(enabled=True)
+ extension.on_attach(mock_session, event_bus)
+
+ mock_session.app_file_manager.path = "/new/path.py"
+ await extension.on_session_notebook_renamed(
+ mock_session, "/old/path.py"
+ )
+
+ mock_cache.rename_path.assert_called_once_with("/new/path.py")
+ extension.on_detach()
+
+
+class TestNotificationListenerExtension:
+ """Tests for NotificationListenerExtension."""
+
+ @pytest.fixture
+ def kernel_manager(self):
+ manager = Mock()
+ manager.mode = SessionMode.EDIT
+ manager.kernel_connection = Mock()
+ manager.kernel_connection.fileno = Mock(return_value=1)
+ return manager
+
+ @pytest.fixture
+ def queue_manager(self):
+ manager = Mock()
+ manager.stream_queue = asyncio.Queue()
+ return manager
+
+ @patch(
+ "marimo._server.sessions.extensions.extensions.ConnectionDistributor"
+ )
+ def test_lifecycle(
+ self, mock_dist, mock_session, event_bus, kernel_manager, queue_manager
+ ) -> None:
+ """Test distributor creation, start, and stop."""
+ mock_distributor = Mock()
+ mock_dist.return_value = mock_distributor
+
+ extension = NotificationListenerExtension(
+ kernel_manager, queue_manager
+ )
+ extension.on_attach(mock_session, event_bus)
+
+ assert extension.distributor is not None
+ mock_distributor.start.assert_called_once()
+
+ extension.on_detach()
+
+ mock_distributor.stop.assert_called_once()
+ assert extension.distributor is None
+
+ def test_uses_correct_distributor_type(
+ self, kernel_manager, queue_manager
+ ) -> None:
+ """Test that correct distributor type is used based on mode."""
+ from marimo._utils.distributor import (
+ ConnectionDistributor,
+ QueueDistributor,
+ )
+
+ extension = NotificationListenerExtension(
+ kernel_manager, queue_manager
+ )
+
+ # EDIT mode uses ConnectionDistributor
+ kernel_manager.mode = SessionMode.EDIT
+ distributor = extension._create_distributor(
+ kernel_manager, queue_manager
+ )
+ assert isinstance(distributor, ConnectionDistributor)
+
+ # RUN mode uses QueueDistributor
+ kernel_manager.mode = SessionMode.RUN
+ distributor = extension._create_distributor(
+ kernel_manager, queue_manager
+ )
+ assert isinstance(distributor, QueueDistributor)
+
+
+class TestLoggingExtension:
+ """Tests for LoggingExtension."""
+
+ def test_lifecycle(self, mock_session, event_bus) -> None:
+ """Test event subscription and logging on attach/detach."""
+ mock_logger = Mock()
+ extension = LoggingExtension(logger=mock_logger)
+
+ extension.on_attach(mock_session, event_bus)
+
+ assert extension in event_bus._listeners
+ mock_logger.debug.assert_called_with("Attaching extensions")
+
+ extension.on_detach()
+
+ assert extension not in event_bus._listeners
+ assert mock_logger.debug.call_count >= 2
+
+ async def test_session_events_logging(
+ self, mock_session, event_bus
+ ) -> None:
+ """Test that session events are logged correctly."""
+ mock_logger = Mock()
+ extension = LoggingExtension(logger=mock_logger)
+ extension.on_attach(mock_session, event_bus)
+
+ # Test session created
+ await extension.on_session_created(mock_session)
+ mock_logger.debug.assert_any_call(
+ "Session created: %s", mock_session.initialization_id
+ )
+
+ # Test session closed
+ await extension.on_session_closed(mock_session)
+ mock_logger.debug.assert_any_call(
+ "Session closed: %s", mock_session.initialization_id
+ )
+
+ # Test session resumed
+ await extension.on_session_resumed(mock_session, SessionId("old-id"))
+ mock_logger.debug.assert_any_call(
+ "Session resumed: %s (old id: %s)",
+ mock_session.initialization_id,
+ "old-id",
+ )
+
+ # Test notebook renamed
+ await extension.on_session_notebook_renamed(
+ mock_session, "/old/path.py"
+ )
+ mock_logger.debug.assert_any_call(
+ "Session file renamed: %s (new path: %s)",
+ mock_session.initialization_id,
+ "/old/path.py",
+ )
+
+ extension.on_detach()