Download tests/api/test_api.py from sshinmen/shin: direct link, hf CLI and curl.
- Browser
- Download file 15.4 kB
-
https://huggingface.co/spaces/sshinmen/shin/resolve/main/tests/api/test_api.py
- Command line
-
hf download hf://spaces/sshinmen/shin/tests/api/test_api.py
-
curl -L -o test_api.py https://huggingface.co/spaces/sshinmen/shin/resolve/main/tests/api/test_api.py
15.4 kB
| from unittest.mock import MagicMock, patch | |
| import pytest | |
| from fastapi.testclient import TestClient | |
| from free_claude_code.core.failures import ExecutionFailure, FailureKind | |
| from free_claude_code.core.reasoning import ReasoningPolicy | |
| from free_claude_code.providers.nvidia_nim import NvidiaNimProvider | |
| from tests.api.support import create_test_app | |
| app = create_test_app() | |
| # Mock provider | |
| mock_provider = MagicMock(spec=NvidiaNimProvider) | |
| # Track stream_response calls for test_model_mapping | |
| _stream_response_calls: list = [] | |
| async def _mock_stream_response(*args, **kwargs): | |
| """Minimal async generator for streaming tests.""" | |
| _stream_response_calls.append((args, kwargs)) | |
| yield "event: message_start\ndata: {}\n\n" | |
| yield "[DONE]\n\n" | |
| async def _mock_pre_start_rate_limit(*args, **kwargs): | |
| """Provider stream that fails before any downstream-visible SSE chunk.""" | |
| _stream_response_calls.append((args, kwargs)) | |
| raise ExecutionFailure( | |
| kind=FailureKind.RATE_LIMIT, | |
| status_code=429, | |
| message="upstream is busy", | |
| retryable=True, | |
| ) | |
| yield "unreachable" | |
| async def _mock_empty_stream(*args, **kwargs): | |
| """Provider stream that completes without a protocol frame.""" | |
| _stream_response_calls.append((args, kwargs)) | |
| if False: | |
| yield "unreachable" | |
| def _terminal_json_error(response, *, status_code: int): | |
| assert response.status_code == status_code | |
| assert response.headers["content-type"].startswith("application/json") | |
| assert response.headers["x-should-retry"] == "false" | |
| request_id = response.headers["request-id"] | |
| payload = response.json() | |
| assert payload["request_id"] == request_id | |
| return payload["error"] | |
| mock_provider.stream_response = _mock_stream_response | |
| def client(): | |
| """HTTP client with provider resolution stubbed; patch only for this file.""" | |
| with ( | |
| patch( | |
| "free_claude_code.api.routes.resolve_provider", | |
| return_value=mock_provider, | |
| ), | |
| TestClient(app) as test_client, | |
| ): | |
| yield test_client | |
| def test_root(client: TestClient): | |
| response = client.get("/") | |
| assert response.status_code == 200 | |
| assert response.json()["status"] == "ok" | |
| assert response.headers["request-id"].startswith("req_") | |
| def test_health(client: TestClient): | |
| response = client.get("/health") | |
| assert response.status_code == 200 | |
| assert response.json()["status"] == "healthy" | |
| assert response.headers["request-id"].startswith("req_") | |
| def test_models_list(client: TestClient): | |
| response = client.get("/v1/models") | |
| assert response.status_code == 200 | |
| data = response.json() | |
| assert data["has_more"] is False | |
| ids = [item["id"] for item in data["data"]] | |
| assert "claude-sonnet-4-20250514" in ids | |
| assert data["first_id"] == ids[0] | |
| assert data["last_id"] == ids[-1] | |
| assert response.headers["x-request-id"] == response.headers["request-id"] | |
| def test_probe_endpoints_return_204_with_allow_headers(client: TestClient): | |
| responses = [ | |
| client.head("/"), | |
| client.options("/"), | |
| client.head("/health"), | |
| client.options("/health"), | |
| client.head("/v1/messages"), | |
| client.options("/v1/messages"), | |
| client.head("/v1/messages/count_tokens"), | |
| client.options("/v1/messages/count_tokens"), | |
| ] | |
| for response in responses: | |
| assert response.status_code == 204 | |
| assert "Allow" in response.headers | |
| def test_create_message_stream(client: TestClient): | |
| """Create message returns streaming response.""" | |
| _stream_response_calls.clear() | |
| payload = { | |
| "model": "claude-3-sonnet", | |
| "messages": [{"role": "user", "content": "Hi"}], | |
| "max_tokens": 100, | |
| "stream": True, | |
| } | |
| response = client.post("/v1/messages", json=payload) | |
| assert response.status_code == 200 | |
| assert "text/event-stream" in response.headers.get("content-type", "") | |
| content = b"".join(response.iter_bytes()) | |
| assert b"message_start" in content or b"event:" in content | |
| assert _stream_response_calls[0][1]["request_id"] == response.headers["request-id"] | |
| def test_auto_mode_classifier_without_stream_returns_json(client: TestClient): | |
| """Claude side queries omit stream and require one complete Message object.""" | |
| _stream_response_calls.clear() | |
| payload = { | |
| "model": "claude-opus-4-8", | |
| "max_tokens": 64, | |
| "system": ( | |
| "You are a security monitor. Respond with <block>yes</block> " | |
| "or <block>no</block>." | |
| ), | |
| "messages": [ | |
| { | |
| "role": "user", | |
| "content": "<transcript>\nBash curl example.com\n</transcript>", | |
| } | |
| ], | |
| } | |
| response = client.post("/v1/messages?beta=true", json=payload) | |
| assert response.status_code == 200 | |
| assert response.headers["content-type"].startswith("application/json") | |
| body = response.json() | |
| assert body["type"] == "message" | |
| assert body["usage"] == {"input_tokens": 0, "output_tokens": 0} | |
| routed_request = _stream_response_calls[0][0][0] | |
| assert routed_request.stream is False | |
| assert _stream_response_calls[0][1]["reasoning"] == ReasoningPolicy.off() | |
| def test_create_message_ingress_error_has_request_id_without_terminal_header( | |
| client: TestClient, | |
| ): | |
| response = client.post( | |
| "/v1/messages", | |
| json={"model": "test", "messages": [], "max_tokens": 10, "stream": True}, | |
| ) | |
| assert response.status_code == 400 | |
| assert "x-should-retry" not in response.headers | |
| assert response.json()["request_id"] == response.headers["request-id"] | |
| def test_create_message_schema_validation_has_request_id_without_terminal_header( | |
| client: TestClient, | |
| ): | |
| response = client.post( | |
| "/v1/messages", | |
| json={"model": "test", "messages": "not-a-list"}, | |
| ) | |
| assert response.status_code == 422 | |
| assert response.headers["request-id"].startswith("req_") | |
| assert "x-should-retry" not in response.headers | |
| def test_create_message_pre_start_provider_error_returns_terminal_json( | |
| client: TestClient, | |
| ): | |
| """Pre-start provider failures keep status without enabling client retries.""" | |
| mock_provider.stream_response = _mock_pre_start_rate_limit | |
| _stream_response_calls.clear() | |
| payload = { | |
| "model": "claude-3-sonnet", | |
| "messages": [{"role": "user", "content": "Hi"}], | |
| "max_tokens": 100, | |
| "stream": True, | |
| } | |
| with ( | |
| patch("free_claude_code.api.response_streams.trace_event") as trace, | |
| patch("free_claude_code.application.execution.trace_event") as execution_trace, | |
| ): | |
| response = client.post("/v1/messages", json=payload) | |
| error = _terminal_json_error(response, status_code=429) | |
| assert error == {"type": "rate_limit_error", "message": "upstream is busy"} | |
| request_id = response.headers["request-id"] | |
| assert _stream_response_calls[0][1]["request_id"] == request_id | |
| route_trace = next( | |
| call.kwargs | |
| for call in execution_trace.call_args_list | |
| if call.kwargs.get("event") == "free_claude_code.api.route.resolved" | |
| ) | |
| assert route_trace["request_id"] == request_id | |
| terminal_trace = next( | |
| call.kwargs | |
| for call in trace.call_args_list | |
| if call.kwargs.get("event") | |
| == "free_claude_code.api.response.terminal_execution_error" | |
| ) | |
| assert terminal_trace == { | |
| "stage": "egress", | |
| "event": "free_claude_code.api.response.terminal_execution_error", | |
| "source": "api", | |
| "wire_api": "messages", | |
| "request_id": request_id, | |
| "status_code": 429, | |
| "error_type": "rate_limit_error", | |
| "client_should_retry": False, | |
| "exc_type": "ExecutionFailure", | |
| "failure_kind": "rate_limit", | |
| "provider_retryable": True, | |
| } | |
| mock_provider.stream_response = _mock_stream_response | |
| def test_create_message_preserves_system_role_messages(client: TestClient): | |
| """Create message preserves latest-client system message placement.""" | |
| mock_provider.stream_response = _mock_stream_response | |
| _stream_response_calls.clear() | |
| payload = { | |
| "model": "claude-3-sonnet", | |
| "messages": [ | |
| {"role": "user", "content": "context"}, | |
| {"role": "system", "content": "system prompt"}, | |
| {"role": "user", "content": "Hi"}, | |
| ], | |
| "max_tokens": 100, | |
| "stream": True, | |
| } | |
| response = client.post("/v1/messages", json=payload) | |
| assert response.status_code == 200 | |
| routed_request = _stream_response_calls[0][0][0] | |
| assert [message.role for message in routed_request.messages] == [ | |
| "user", | |
| "system", | |
| "user", | |
| ] | |
| assert routed_request.messages[1].content == "system prompt" | |
| assert routed_request.system is None | |
| def test_model_mapping(client: TestClient): | |
| # Test Haiku mapping | |
| _stream_response_calls.clear() | |
| payload_haiku = { | |
| "model": "claude-3-haiku-20240307", | |
| "messages": [{"role": "user", "content": "Hi"}], | |
| "max_tokens": 100, | |
| "stream": True, | |
| } | |
| client.post("/v1/messages", json=payload_haiku) | |
| assert len(_stream_response_calls) == 1 | |
| args = _stream_response_calls[0][0] | |
| kwargs = _stream_response_calls[0][1] | |
| assert args[0].model != "claude-3-haiku-20240307" | |
| assert kwargs["reasoning"] == ReasoningPolicy.provider_default() | |
| def test_provider_execution_errors_preserve_status_and_type( | |
| client: TestClient, | |
| failure: ExecutionFailure, | |
| expected_type: str, | |
| ): | |
| base_payload = { | |
| "model": "test", | |
| "messages": [{"role": "user", "content": "Hi"}], | |
| "max_tokens": 10, | |
| "stream": True, | |
| } | |
| def _raise_provider_error(*args, **kwargs): | |
| raise failure | |
| try: | |
| mock_provider.stream_response = _raise_provider_error | |
| response = client.post("/v1/messages", json=base_payload) | |
| error = _terminal_json_error(response, status_code=failure.status_code) | |
| assert error["type"] == expected_type | |
| assert "SECRET" not in error["message"] | |
| if expected_type == "invalid_request_error": | |
| assert "useful detail" in error["message"] | |
| finally: | |
| mock_provider.stream_response = _mock_stream_response | |
| def test_empty_provider_stream_returns_terminal_json(client: TestClient): | |
| mock_provider.stream_response = _mock_empty_stream | |
| try: | |
| response = client.post( | |
| "/v1/messages", | |
| json={ | |
| "model": "test", | |
| "messages": [{"role": "user", "content": "Hi"}], | |
| "max_tokens": 10, | |
| "stream": True, | |
| }, | |
| ) | |
| error = _terminal_json_error(response, status_code=500) | |
| assert error["type"] == "api_error" | |
| assert error["message"] == "Stream ended before emitting a response." | |
| finally: | |
| mock_provider.stream_response = _mock_stream_response | |
| def test_generic_stream_exception_returns_terminal_json(client: TestClient): | |
| """Unexpected provider execution failures return detailed terminal JSON.""" | |
| def _raise_runtime(*args, **kwargs): | |
| raise RuntimeError("unexpected crash") | |
| mock_provider.stream_response = _raise_runtime | |
| response = client.post( | |
| "/v1/messages", | |
| json={ | |
| "model": "test", | |
| "messages": [{"role": "user", "content": "Hi"}], | |
| "max_tokens": 10, | |
| "stream": True, | |
| }, | |
| ) | |
| error = _terminal_json_error(response, status_code=500) | |
| assert error["type"] == "api_error" | |
| assert error["message"] == "unexpected crash" | |
| mock_provider.stream_response = _mock_stream_response | |
| def test_generic_stream_exception_with_status_code_returns_terminal_json( | |
| client: TestClient, | |
| ): | |
| """Ad-hoc status_code attrs do not become retryable HTTP responses.""" | |
| class ExceptionWithStatus(RuntimeError): | |
| def __init__(self, msg: str, status_code: int = 500): | |
| super().__init__(msg) | |
| self.status_code = status_code | |
| def _raise_with_status(*args, **kwargs): | |
| raise ExceptionWithStatus("bad gateway", 502) | |
| mock_provider.stream_response = _raise_with_status | |
| response = client.post( | |
| "/v1/messages", | |
| json={ | |
| "model": "test", | |
| "messages": [{"role": "user", "content": "Hi"}], | |
| "max_tokens": 10, | |
| "stream": True, | |
| }, | |
| ) | |
| error = _terminal_json_error(response, status_code=500) | |
| assert error["type"] == "api_error" | |
| assert error["message"] == "bad gateway" | |
| mock_provider.stream_response = _mock_stream_response | |
| def test_generic_stream_exception_empty_message_returns_non_empty_error( | |
| client: TestClient, | |
| ): | |
| """Exceptions with empty __str__ still return a readable HTTP detail.""" | |
| class SilentError(RuntimeError): | |
| def __str__(self): | |
| return "" | |
| def _raise_silent(*args, **kwargs): | |
| raise SilentError() | |
| mock_provider.stream_response = _raise_silent | |
| response = client.post( | |
| "/v1/messages", | |
| json={ | |
| "model": "test", | |
| "messages": [{"role": "user", "content": "Hi"}], | |
| "max_tokens": 10, | |
| "stream": True, | |
| }, | |
| ) | |
| error = _terminal_json_error(response, status_code=500) | |
| assert error["type"] == "api_error" | |
| assert error["message"] != "" | |
| mock_provider.stream_response = _mock_stream_response | |
| def test_count_tokens_endpoint(client: TestClient): | |
| """count_tokens endpoint returns token count.""" | |
| response = client.post( | |
| "/v1/messages/count_tokens", | |
| json={"model": "test", "messages": [{"role": "user", "content": "Hello"}]}, | |
| ) | |
| assert response.status_code == 200 | |
| assert "input_tokens" in response.json() | |
| assert response.headers["request-id"].startswith("req_") | |
| def test_stop_endpoint_no_workflow_no_cli_503(client: TestClient): | |
| """POST /stop without messaging workflow or cli_manager returns 503.""" | |
| # Ensure no messaging workflow or cli_manager on app state | |
| if hasattr(app.state, "messaging_workflow"): | |
| delattr(app.state, "messaging_workflow") | |
| if hasattr(app.state, "cli_manager"): | |
| delattr(app.state, "cli_manager") | |
| response = client.post("/stop") | |
| assert response.status_code == 503 | |