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: missing endpoint test coverage (#7598)

Myles Scolnickc192611e6760
diff --git a/marimo/_server/api/endpoints/secrets.py b/marimo/_server/api/endpoints/secrets.py
index f48b920d95..835c69eba1 100644
--- a/marimo/_server/api/endpoints/secrets.py
+++ b/marimo/_server/api/endpoints/secrets.py
@@ -4,6 +4,7 @@ from __future__ import annotations
from typing import TYPE_CHECKING
from starlette.authentication import requires
+from starlette.responses import JSONResponse
from marimo import _loggers
from 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.py
index 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_wrapper
from tests._server.conftest import get_session_config_manager
from 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.py
new file mode 100644
index 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.text
diff --git a/tests/_server/api/endpoints/test_mpl_endpoints.py b/tests/_server/api/endpoints/test_mpl_endpoints.py
new file mode 100644
index 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&param2=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.py
new file mode 100644
index 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.py
index 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)