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: missing endpoint test coverage (#7598)
Myles Scolnickc192611e6760
diff --git a/marimo/_server/api/endpoints/secrets.py b/marimo/_server/api/endpoints/secrets.pyindex f48b920d95..835c69eba1 100644--- a/marimo/_server/api/endpoints/secrets.py+++ b/marimo/_server/api/endpoints/secrets.py@@ -4,6 +4,7 @@ from __future__ import annotationsfrom typing import TYPE_CHECKINGfrom starlette.authentication import requires+from starlette.responses import JSONResponsefrom marimo import _loggersfrom marimo._secrets.secrets import write_secret@@ -84,7 +85,7 @@ async def create_secret(request: Request) -> BaseResponse:@router.post("/delete")@requires("edit")-async def delete_secret(request: Request) -> BaseResponse:+async def delete_secret(request: Request) -> JSONResponse:"""responses:200:@@ -95,4 +96,7 @@ async def delete_secret(request: Request) -> BaseResponse:$ref: "#/components/schemas/BaseResponse""""del request- raise NotImplementedError("Not implemented")+ return JSONResponse(+ content={"success": False, "message": "Not implemented"},+ status_code=501,+ )diff --git a/tests/_server/api/endpoints/test_ai.py b/tests/_server/api/endpoints/test_ai.pyindex dcb78e57d6..4efd58c962 100644--- a/tests/_server/api/endpoints/test_ai.py+++ b/tests/_server/api/endpoints/test_ai.py@@ -20,6 +20,7 @@ from marimo._server.ai.providers import (without_wrapping_backticks,)from marimo._server.ai.tools.types import ToolCallResult+from marimo._server.api.endpoints.ai import safe_stream_wrapperfrom tests._server.conftest import get_session_config_managerfrom tests._server.mocks import token_header, with_session@@ -1472,3 +1473,53 @@ class TestMCPEndpoints:assert data["toolName"] == "test_tool"assert data["result"]["message"] == "Tool executed with empty args"assert data["error"] is None++ @staticmethod+ @with_session(SESSION_ID)+ @patch("marimo._server.api.endpoints.ai.get_mcp_client")+ def test_mcp_status_states(+ client: TestClient, mock_get_client: Any+ ) -> None:+ """Test MCP status returns correct state based on server statuses."""+ from marimo._server.ai.mcp import MCPServerStatus++ mock_client = MagicMock()+ mock_get_client.return_value = mock_client++ # Test partial: some connected, some failed+ mock_client.get_all_server_statuses.return_value = {+ "server1": MCPServerStatus.CONNECTED,+ "server2": MCPServerStatus.ERROR,+ }+ response = client.get("/api/ai/mcp/status", headers=HEADERS)+ assert response.status_code == 200+ data = response.json()+ assert data["status"] == "partial"+ assert "server2" in data["error"]++ # Test error: all failed+ mock_client.get_all_server_statuses.return_value = {+ "server1": MCPServerStatus.ERROR,+ "server2": MCPServerStatus.DISCONNECTED,+ }+ response = client.get("/api/ai/mcp/status", headers=HEADERS)+ assert response.status_code == 200+ data = response.json()+ assert data["status"] == "error"+++async def test_safe_stream_wrapper_handles_errors() -> None:+ """Test safe_stream_wrapper catches and formats streaming errors."""++ async def failing_generator():+ yield "chunk1"+ raise ValueError("Stream failed")++ chunks = []+ async for chunk in safe_stream_wrapper(+ failing_generator(), text_only=True+ ):+ chunks.append(chunk)++ assert chunks[0] == "chunk1"+ assert "Stream failed" in chunks[1]diff --git a/tests/_server/api/endpoints/test_cache_endpoints.py b/tests/_server/api/endpoints/test_cache_endpoints.pynew file mode 100644index 0000000000..3442363ae7--- /dev/null+++ b/tests/_server/api/endpoints/test_cache_endpoints.py@@ -0,0 +1,42 @@+# Copyright 2024 Marimo. All rights reserved.+from __future__ import annotations++from typing import TYPE_CHECKING++from marimo._types.ids import SessionId+from tests._server.mocks import token_header, with_read_session, with_session++if TYPE_CHECKING:+ from starlette.testclient import TestClient++SESSION_ID = SessionId("session-123")+HEADERS = {+ "Marimo-Session-Id": SESSION_ID,+ **token_header("fake-token"),+}+++@with_session(SESSION_ID)+def test_clear_cache(client: TestClient) -> None:+ """Test cache clear operation."""+ response = client.post("/api/cache/clear", headers=HEADERS, json={})+ assert response.status_code == 200, response.text+ assert response.json()["success"] is True+++@with_session(SESSION_ID)+def test_get_cache_info(client: TestClient) -> None:+ """Test cache info retrieval."""+ response = client.post("/api/cache/info", headers=HEADERS, json={})+ assert response.status_code == 200, response.text+ assert response.json()["success"] is True+++@with_read_session(SESSION_ID)+def test_cache_forbidden_in_read_mode(client: TestClient) -> None:+ """Test that cache operations are forbidden in read mode."""+ response = client.post("/api/cache/clear", headers=HEADERS, json={})+ assert response.status_code == 401, response.text++ response = client.post("/api/cache/info", headers=HEADERS, json={})+ assert response.status_code == 401, response.textdiff --git a/tests/_server/api/endpoints/test_mpl_endpoints.py b/tests/_server/api/endpoints/test_mpl_endpoints.pynew file mode 100644index 0000000000..05bb8d6f3b--- /dev/null+++ b/tests/_server/api/endpoints/test_mpl_endpoints.py@@ -0,0 +1,122 @@+# Copyright 2024 Marimo. All rights reserved.+from __future__ import annotations++from typing import TYPE_CHECKING+from unittest.mock import AsyncMock, MagicMock, patch++from marimo._server.api.endpoints.mpl import figure_endpoints++if TYPE_CHECKING:+ from starlette.testclient import TestClient+++class TestMatplotlibProxyEndpoints:+ """Tests for matplotlib proxy endpoints."""++ def setup_method(self) -> None:+ """Clear figure_endpoints before each test."""+ figure_endpoints.clear()++ def teardown_method(self) -> None:+ """Clean up after each test."""+ figure_endpoints.clear()++ @staticmethod+ def test_unauthorized_figure_returns_403(client: TestClient) -> None:+ """Test that accessing unregistered figure returns 403."""+ response = client.get("/mpl/999/some_path")+ assert response.status_code == 403, response.text+ assert "Unauthorized" in response.text++ @staticmethod+ def test_connection_error_returns_503(client: TestClient) -> None:+ """Test connection failure returns 503."""+ figure_endpoints[1] = "8888"++ with patch("urllib.request.urlopen") as mock_urlopen:+ from urllib.error import URLError++ mock_urlopen.side_effect = URLError("Connection refused")+ response = client.get("/mpl/1/test_path")+ assert response.status_code == 503, response.text+ assert "Matplotlib server is not available" in response.text++ @staticmethod+ def test_successful_proxy(client: TestClient) -> None:+ """Test successful proxying to matplotlib server."""+ figure_endpoints[1] = "8888"++ with patch("urllib.request.urlopen") as mock_urlopen:+ mock_response = MagicMock()+ mock_response.status = 200+ mock_response.headers = {"content-type": "text/html"}+ mock_response.read.return_value = b"<html>Success</html>"+ mock_urlopen.return_value.__enter__.return_value = mock_response++ response = client.get("/mpl/1/test")+ assert response.status_code == 200, response.text+ assert response.text == "<html>Success</html>"++ @staticmethod+ def test_query_params_forwarded(client: TestClient) -> None:+ """Test query parameters are forwarded to matplotlib server."""+ figure_endpoints[1] = "8888"++ with patch("urllib.request.urlopen") as mock_urlopen:+ mock_response = MagicMock()+ mock_response.status = 200+ mock_response.headers = {}+ mock_response.read.return_value = b""+ mock_urlopen.return_value.__enter__.return_value = mock_response++ client.get("/mpl/1/test?param1=value1¶m2=value2")++ request_obj = mock_urlopen.call_args[0][0]+ assert "param1=value1" in request_obj.full_url+ assert "param2=value2" in request_obj.full_url++ @staticmethod+ def test_headers_filtered(client: TestClient) -> None:+ """Test that problematic headers (host, content-length) are filtered."""+ figure_endpoints[1] = "8888"++ with patch("urllib.request.urlopen") as mock_urlopen:+ mock_response = MagicMock()+ mock_response.status = 200+ mock_response.headers = {}+ mock_response.read.return_value = b""+ mock_urlopen.return_value.__enter__.return_value = mock_response++ client.get("/mpl/1/test")++ request_obj = mock_urlopen.call_args[0][0]+ assert "Host" not in request_obj.headers+ assert "Content-length" not in request_obj.headers++ @staticmethod+ def test_websocket_registers_figure(client: TestClient) -> None:+ """Test that WebSocket connection registers figure endpoint."""+ from starlette.websockets import WebSocketDisconnect++ with patch("websockets.connect") as mock_connect:+ mock_ws = MagicMock()+ mock_context = MagicMock()+ mock_context.__aenter__ = AsyncMock(return_value=mock_ws)+ mock_context.__aexit__ = AsyncMock(return_value=None)+ mock_connect.return_value = mock_context++ async def mock_iter():+ return+ yield++ mock_ws.__aiter__ = mock_iter++ try:+ with client.websocket_connect("/mpl/8888/ws?figure=123"):+ pass+ except WebSocketDisconnect:+ pass++ # Verify figure was registered+ assert 123 in figure_endpoints+ assert figure_endpoints[123] == "8888"diff --git a/tests/_server/api/endpoints/test_secrets_endpoints.py b/tests/_server/api/endpoints/test_secrets_endpoints.pynew file mode 100644index 0000000000..c5ba808f38--- /dev/null+++ b/tests/_server/api/endpoints/test_secrets_endpoints.py@@ -0,0 +1,104 @@+# Copyright 2024 Marimo. All rights reserved.+from __future__ import annotations++from typing import TYPE_CHECKING+from unittest.mock import patch++import pytest++from marimo._types.ids import SessionId+from tests._server.mocks import token_header, with_read_session, with_session++if TYPE_CHECKING:+ from starlette.testclient import TestClient++SESSION_ID = SessionId("session-123")+HEADERS = {+ "Marimo-Session-Id": SESSION_ID,+ **token_header("fake-token"),+}+++@with_session(SESSION_ID)+def test_list_secret_keys(client: TestClient) -> None:+ """Test secret keys listing."""+ response = client.post(+ "/api/secrets/keys",+ headers=HEADERS,+ json={"requestId": "test-request-id"},+ )+ assert response.status_code == 200, response.text+ assert "success" in response.json()+++@with_session(SESSION_ID)+def test_create_secret(client: TestClient) -> None:+ """Test secret creation and verify write_secret is called."""+ with patch(+ "marimo._server.api.endpoints.secrets.write_secret"+ ) as mock_write_secret:+ response = client.post(+ "/api/secrets/create",+ headers=HEADERS,+ json={+ "key": "TEST_SECRET",+ "value": "secret_value",+ "provider": "env",+ "name": "test_secret",+ },+ )+ assert response.status_code == 200, response.text+ assert response.json()["success"] is True+ assert mock_write_secret.called+++@with_session(SESSION_ID)+def test_delete_secret_not_implemented(client: TestClient) -> None:+ """Test that delete secret endpoint raises NotImplementedError."""+ response = client.post(+ "/api/secrets/delete", headers=HEADERS, json={"key": "test_secret"}+ )+ assert response.status_code == 501, response.text+++@with_read_session(SESSION_ID)+def test_secrets_forbidden_in_read_mode(client: TestClient) -> None:+ """Test that secret operations are forbidden in read mode."""+ response = client.post(+ "/api/secrets/keys",+ headers=HEADERS,+ json={"requestId": "test-request-id"},+ )+ assert response.status_code == 401, response.text++ response = client.post(+ "/api/secrets/create",+ headers=HEADERS,+ json={+ "key": "TEST_SECRET",+ "value": "test_value",+ "provider": "env",+ "name": "test",+ },+ )+ assert response.status_code == 401, response.text+++@with_session(SESSION_ID)+def test_create_secret_write_failure(client: TestClient) -> None:+ """Test handling when write_secret fails."""+ with patch(+ "marimo._server.api.endpoints.secrets.write_secret",+ side_effect=Exception("Write failed"),+ ):+ with pytest.raises(Exception, match="Write failed"):+ client.post(+ "/api/secrets/create",+ headers=HEADERS,+ json={+ "key": "TEST_SECRET",+ "value": "test_value",+ "provider": "env",+ "name": "test",+ },+ )diff --git a/tests/_server/api/endpoints/test_ws.py b/tests/_server/api/endpoints/test_ws.pyindex a7d7184bf8..926d608889 100644--- a/tests/_server/api/endpoints/test_ws.py+++ b/tests/_server/api/endpoints/test_ws.py@@ -571,3 +571,59 @@ async def test_rtc_config_with_loro_unavailable(client: TestClient) -> None:assert_kernel_ready_response(data)client.post("/api/kernel/shutdown", headers=HEADERS)+++# ============================================================================+# Advanced WebSocket State Machine Tests+# ============================================================================+++async def test_rapid_reconnection_cancels_ttl_cleanup(+ client: TestClient,+) -> None:+ """Test that rapid reconnection cancels the TTL cleanup timer."""+ with client.websocket_connect(WS_URL) as websocket:+ data = websocket.receive_json()+ assert_kernel_ready_response(data)++ # Disconnect and immediately reconnect (before TTL expires)+ await asyncio.sleep(0.1)++ with client.websocket_connect(WS_URL) as websocket:+ data = websocket.receive_json()+ assert data["op"] == "reconnected"+ data = websocket.receive_json()+ assert data["op"] == "alert"++ client.post("/api/kernel/shutdown", headers=HEADERS)+++async def test_multiple_rapid_reconnections(client: TestClient) -> None:+ """Test multiple rapid connect/disconnect cycles don't break session."""+ for i in range(5):+ with client.websocket_connect(WS_URL) as websocket:+ data = websocket.receive_json()+ if i == 0:+ assert_kernel_ready_response(data)+ else:+ assert data["op"] == "reconnected"++ client.post("/api/kernel/shutdown", headers=HEADERS)+++async def test_websocket_message_queue_delivery(client: TestClient) -> None:+ """Test that kernel messages are queued and delivered."""+ with client.websocket_connect(WS_URL) as websocket:+ data = websocket.receive_json()+ assert_kernel_ready_response(data)++ client.post(+ "/api/kernel/instantiate",+ headers=headers("123"),+ json={"objectIds": [], "values": [], "autoRun": True},+ )++ messages = flush_messages(websocket, at_least=1)+ assert len(messages) >= 1++ client.post("/api/kernel/shutdown", headers=HEADERS)