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
tests: test extensions (#7600)
Myles Scolnicka3a3b7fd7ade
diff --git a/tests/_server/sessions/extensions/test_extensions.py b/tests/_server/sessions/extensions/test_extensions.pynew file mode 100644index 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()