mirror of
https://github.com/jxxghp/MoviePilot.git
synced 2026-08-14 18:24:42 +08:00
768 lines
28 KiB
Python
768 lines
28 KiB
Python
from types import SimpleNamespace
|
||
from typing import Any
|
||
|
||
import httpx
|
||
import pytest
|
||
from fastapi import FastAPI, HTTPException
|
||
from pydantic import BaseModel, ValidationError
|
||
from starlette.responses import StreamingResponse
|
||
|
||
from app.api.response import (
|
||
RAW_RESPONSE_OPENAPI_KEY,
|
||
ResponseAPIRoute,
|
||
ResponseAPIRouter,
|
||
)
|
||
from app.factory import (
|
||
localized_http_exception_handler,
|
||
localized_unhandled_exception_handler,
|
||
localized_validation_exception_handler,
|
||
)
|
||
from app.helper.locale import LocaleHelper
|
||
from app.schemas.common import JsonData
|
||
from app.schemas.response import Response
|
||
|
||
|
||
pytestmark = pytest.mark.anyio
|
||
|
||
|
||
class Item(BaseModel):
|
||
"""统一响应测试使用的业务数据模型。"""
|
||
|
||
id: int
|
||
|
||
|
||
@pytest.fixture()
|
||
def anyio_backend():
|
||
"""使用 asyncio 运行异步接口测试。"""
|
||
return "asyncio"
|
||
|
||
|
||
@pytest.fixture()
|
||
def api_app() -> FastAPI:
|
||
"""构造使用统一响应路由的最小测试应用。"""
|
||
app = FastAPI()
|
||
app.router.route_class = ResponseAPIRoute
|
||
app.add_exception_handler(HTTPException, localized_http_exception_handler)
|
||
from fastapi.exceptions import RequestValidationError
|
||
|
||
app.add_exception_handler(
|
||
RequestValidationError,
|
||
localized_validation_exception_handler,
|
||
)
|
||
app.add_exception_handler(Exception, localized_unhandled_exception_handler)
|
||
|
||
@app.middleware("http")
|
||
async def locale_middleware(request, call_next):
|
||
"""在测试应用中模拟生产环境的请求语言上下文。"""
|
||
token = LocaleHelper.set_current_locale(
|
||
LocaleHelper.get_locale_from_request(request)
|
||
)
|
||
try:
|
||
return await call_next(request)
|
||
finally:
|
||
LocaleHelper.reset_current_locale(token)
|
||
|
||
@app.get("/items", response_model=list[Item])
|
||
async def get_items() -> list[Item]:
|
||
"""返回需要自动封装的业务数据。"""
|
||
return [Item(id=1)]
|
||
|
||
@app.get("/wrapped", response_model=Response[Item])
|
||
async def get_wrapped_response() -> Response[Item]:
|
||
"""返回已经封装的响应。"""
|
||
return Response(success=True, message="模块不支持测试", data=Item(id=2))
|
||
|
||
@app.get(
|
||
"/oauth-token",
|
||
response_model=Item,
|
||
openapi_extra={RAW_RESPONSE_OPENAPI_KEY: True},
|
||
)
|
||
async def get_oauth_token() -> Item:
|
||
"""模拟必须保持顶层字段的标准协议响应。"""
|
||
return Item(id=3)
|
||
|
||
@app.get("/error")
|
||
async def get_error() -> None:
|
||
"""抛出需要统一处理的 HTTP 错误。"""
|
||
raise HTTPException(status_code=400, detail="用户名或密码错误")
|
||
|
||
@app.get("/validated/{item_id}", response_model=Item)
|
||
async def get_validated_item(item_id: int) -> Item:
|
||
"""返回带路径参数校验的业务数据。"""
|
||
return Item(id=item_id)
|
||
|
||
@app.get("/crash", response_model=Item)
|
||
async def get_crash() -> Item:
|
||
"""抛出需要隐藏内部细节的未捕获异常。"""
|
||
raise RuntimeError("private failure detail")
|
||
|
||
@app.get("/native", response_model=None)
|
||
async def get_native_response() -> dict[str, bool]:
|
||
"""返回显式旁路的原生 JSON 协议。"""
|
||
return {"native": True}
|
||
|
||
@app.get("/events", response_model=None)
|
||
async def get_events() -> StreamingResponse:
|
||
"""返回不应封装的事件流。"""
|
||
|
||
async def event_source():
|
||
"""生成一条测试事件。"""
|
||
yield "data: ok\n\n"
|
||
|
||
return StreamingResponse(event_source(), media_type="text/event-stream")
|
||
|
||
return app
|
||
|
||
|
||
def make_client(app: FastAPI) -> httpx.AsyncClient:
|
||
"""创建不访问真实网络的 ASGI 测试客户端。"""
|
||
return httpx.AsyncClient(
|
||
transport=httpx.ASGITransport(app=app),
|
||
base_url="http://testserver",
|
||
)
|
||
|
||
|
||
async def test_route_wraps_data_and_keeps_existing_response(api_app: FastAPI):
|
||
"""普通数据应自动封装，已经封装的响应不应重复套壳。"""
|
||
async with make_client(api_app) as client:
|
||
items_response = await client.get("/items")
|
||
wrapped_response = await client.get("/wrapped")
|
||
|
||
assert items_response.json() == {
|
||
"success": True,
|
||
"message": "",
|
||
"data": [{"id": 1}],
|
||
}
|
||
assert wrapped_response.json() == {
|
||
"success": True,
|
||
"message": "模块不支持测试",
|
||
"data": {"id": 2},
|
||
}
|
||
|
||
|
||
async def test_explicit_none_and_stream_keep_native_protocol(api_app: FastAPI):
|
||
"""显式无响应模型和流式响应应保持原生协议。"""
|
||
async with make_client(api_app) as client:
|
||
native_response = await client.get("/native")
|
||
stream_response = await client.get("/events")
|
||
|
||
assert native_response.json() == {"native": True}
|
||
assert stream_response.headers["content-type"].startswith("text/event-stream")
|
||
assert stream_response.text == "data: ok\n\n"
|
||
|
||
|
||
async def test_accept_language_localizes_success_and_http_error(api_app: FastAPI):
|
||
"""Accept-Language 应直接决定成功与 HTTP 错误响应的 message。"""
|
||
async with make_client(api_app) as client:
|
||
wrapped_response = await client.get(
|
||
"/wrapped", headers={"Accept-Language": "en-US"}
|
||
)
|
||
error_response = await client.get(
|
||
"/error", headers={"Accept-Language": "en-US"}
|
||
)
|
||
zh_error_response = await client.get(
|
||
"/error", headers={"Accept-Language": "zh-CN"}
|
||
)
|
||
|
||
assert wrapped_response.json()["message"] == "Module does not support testing"
|
||
assert error_response.status_code == 400
|
||
assert error_response.json() == {
|
||
"success": False,
|
||
"message": "Incorrect username or password",
|
||
"data": None,
|
||
}
|
||
assert zh_error_response.json()["message"] == "用户名或密码错误"
|
||
|
||
|
||
async def test_validation_error_uses_unified_model(api_app: FastAPI):
|
||
"""请求参数校验失败应返回统一协议和明确的错误项结构。"""
|
||
async with make_client(api_app) as client:
|
||
response = await client.get(
|
||
"/validated/not-an-integer",
|
||
headers={"Accept-Language": "en-US"},
|
||
)
|
||
zh_response = await client.get(
|
||
"/validated/not-an-integer",
|
||
headers={"Accept-Language": "zh-CN"},
|
||
)
|
||
|
||
payload = response.json()
|
||
assert response.status_code == 422
|
||
assert payload["success"] is False
|
||
assert payload["message"] == "Request parameters are incorrect"
|
||
assert payload["data"] == [
|
||
{
|
||
"location": ["path", "item_id"],
|
||
"message": "Input should be a valid integer, unable to parse string as an integer",
|
||
"error_type": "int_parsing",
|
||
}
|
||
]
|
||
assert zh_response.json()["message"] == "请求参数不正确"
|
||
|
||
|
||
async def test_unhandled_exception_uses_localized_unified_response(api_app: FastAPI):
|
||
"""未捕获异常应返回本地化统一响应且不泄露内部错误。"""
|
||
async with httpx.AsyncClient(
|
||
transport=httpx.ASGITransport(
|
||
app=api_app,
|
||
raise_app_exceptions=False,
|
||
),
|
||
base_url="http://testserver",
|
||
) as client:
|
||
response = await client.get(
|
||
"/crash",
|
||
headers={"Accept-Language": "en-US"},
|
||
)
|
||
|
||
assert response.status_code == 500
|
||
assert response.json() == {
|
||
"success": False,
|
||
"message": "Unknown error",
|
||
"data": None,
|
||
}
|
||
assert "private failure detail" not in response.text
|
||
|
||
|
||
def test_openapi_declares_generic_success_and_error_models(api_app: FastAPI):
|
||
"""OpenAPI 应展示业务数据类型及统一的 HTTP/422 错误响应结构。"""
|
||
schema = api_app.openapi()
|
||
operation = schema["paths"]["/items"]["get"]
|
||
success_ref = operation["responses"]["200"]["content"]["application/json"][
|
||
"schema"
|
||
]["$ref"]
|
||
validation_ref = operation["responses"]["422"]["content"][
|
||
"application/json"
|
||
]["schema"]["$ref"]
|
||
|
||
assert success_ref.endswith("/Response_list_Item__")
|
||
assert validation_ref.endswith("/Response_list_ValidationIssue__")
|
||
assert "HTTPValidationError" not in schema["components"]["schemas"]
|
||
success_schema = schema["components"]["schemas"][success_ref.rsplit("/", 1)[-1]]
|
||
assert success_schema["required"] == ["success", "message", "data"]
|
||
|
||
|
||
async def test_openapi_marker_keeps_oauth_payload_at_top_level(api_app: FastAPI):
|
||
"""显式原生标记应保留 OAuth 等标准协议的顶层字段及模型。"""
|
||
async with make_client(api_app) as client:
|
||
response = await client.get("/oauth-token")
|
||
|
||
operation = api_app.openapi()["paths"]["/oauth-token"]["get"]
|
||
schema_ref = operation["responses"]["200"]["content"]["application/json"][
|
||
"schema"
|
||
]["$ref"]
|
||
|
||
assert response.json() == {"id": 3}
|
||
assert schema_ref.endswith("/Item")
|
||
assert operation[RAW_RESPONSE_OPENAPI_KEY] is True
|
||
validation_ref = operation["responses"]["422"]["content"][
|
||
"application/json"
|
||
]["schema"]["$ref"]
|
||
assert validation_ref.endswith("/Response_list_ValidationIssue__")
|
||
|
||
|
||
def test_response_localizes_zh_en_and_falls_back_to_source():
|
||
"""Response 应支持中英文上下文，未知文案按原文回退。"""
|
||
zh_token = LocaleHelper.set_current_locale("zh-CN")
|
||
try:
|
||
zh_response = Response[None](success=False, message="用户名或密码错误")
|
||
finally:
|
||
LocaleHelper.reset_current_locale(zh_token)
|
||
|
||
en_token = LocaleHelper.set_current_locale("en-US")
|
||
try:
|
||
en_response = Response[None](success=False, message="用户名或密码错误")
|
||
fallback_response = Response[None](success=False, message="未登记的新错误文案")
|
||
finally:
|
||
LocaleHelper.reset_current_locale(en_token)
|
||
|
||
assert zh_response.message == "用户名或密码错误"
|
||
assert en_response.message == "Incorrect username or password"
|
||
assert fallback_response.message == "未登记的新错误文案"
|
||
|
||
|
||
def test_response_defaults_are_serialized_despite_required_openapi_fields():
|
||
"""省略默认值构造仍应在序列化结果中完整输出三块结构。"""
|
||
response = Response[None](success=True)
|
||
|
||
assert response.model_dump() == {
|
||
"success": True,
|
||
"message": "",
|
||
"data": None,
|
||
}
|
||
assert Response[None].model_json_schema()["required"] == [
|
||
"success",
|
||
"message",
|
||
"data",
|
||
]
|
||
|
||
|
||
def test_response_rejects_fields_outside_unified_protocol():
|
||
"""统一响应顶层只允许 success、message、data 三个字段。"""
|
||
with pytest.raises(ValidationError):
|
||
Response[None](success=True, message_i18n="unexpected")
|
||
|
||
|
||
def test_v1_routes_use_response_route_except_native_protocols():
|
||
"""v1 普通接口应使用统一路由，标准协议路由保持原生实现。"""
|
||
from fastapi.routing import APIRoute
|
||
|
||
from app.api.apiv1 import api_router
|
||
|
||
api_routes = [
|
||
route for route in api_router.routes if isinstance(route, APIRoute)
|
||
]
|
||
native_paths = {
|
||
"/openai/v1/models",
|
||
"/openai/v1/chat/completions",
|
||
"/openai/v1/responses",
|
||
"/anthropic/v1/messages",
|
||
}
|
||
|
||
assert all(
|
||
isinstance(route, ResponseAPIRoute) or route.path in native_paths
|
||
for route in api_routes
|
||
)
|
||
|
||
|
||
def test_v1_json_routes_have_concrete_data_models():
|
||
"""普通 v1 JSON 路由禁止未参数化、Any 或通用 JSON 顶层输出模型。"""
|
||
from fastapi.routing import APIRoute
|
||
|
||
from app.api.apiv1 import api_router
|
||
|
||
weak_routes = []
|
||
for route in api_router.routes:
|
||
if not isinstance(route, APIRoute):
|
||
continue
|
||
response_model = route.response_model
|
||
try:
|
||
is_response_model = issubclass(response_model, Response)
|
||
except TypeError:
|
||
is_response_model = False
|
||
if not is_response_model:
|
||
continue
|
||
generic_args = response_model.__pydantic_generic_metadata__.get("args")
|
||
if not generic_args or generic_args in ((Any,), (JsonData,)):
|
||
weak_routes.append((route.path, route.name, generic_args))
|
||
|
||
assert weak_routes == []
|
||
|
||
|
||
def test_v1_model_free_routes_match_audited_native_allowlist():
|
||
"""无响应模型仅允许固定的协议、流、文件、图片、HTML 与 204 路由。"""
|
||
from app.api.apiv1 import api_router
|
||
|
||
expected_routes = {
|
||
("/message/", "incoming_verify"),
|
||
("/message/agent/file/{file_id}", "download_web_agent_file"),
|
||
("/message/agent/stream", "web_agent_stream"),
|
||
("/search/media/{media_id}/stream", "search_by_id_stream"),
|
||
("/search/title/stream", "search_by_title_stream"),
|
||
("/search/subtitle/title/stream", "search_subtitle_by_title_stream"),
|
||
(
|
||
"/search/subtitle/media/{media_id}/stream",
|
||
"search_subtitle_by_id_stream",
|
||
),
|
||
("/system/img/{proxy}", "proxy_img"),
|
||
("/system/cache/image", "cache_img"),
|
||
("/system/progress/{process_type}", "get_progress"),
|
||
("/system/message", "get_message"),
|
||
("/system/logging", "get_logging"),
|
||
("/system/logging/download/{name}", "download_logging"),
|
||
(
|
||
"/llm/provider-auth/callback/{provider_id}",
|
||
"llm_provider_auth_callback",
|
||
),
|
||
("/plugin/file/{plugin_id}/{filepath:path}", "plugin_static_file"),
|
||
("/storage/download", "download"),
|
||
("/storage/image", "image"),
|
||
("/mcp", "delete_mcp_session"),
|
||
}
|
||
actual_routes = {
|
||
(route.path, route.name)
|
||
for route in api_router.routes
|
||
if isinstance(route, ResponseAPIRoute) and route.response_model is None
|
||
}
|
||
|
||
assert actual_routes == expected_routes
|
||
|
||
|
||
def test_native_protocol_openapi_has_explicit_response_schemas():
|
||
"""OpenAI、Anthropic 与 MCP 原生协议响应必须在 OpenAPI 中明确建模。"""
|
||
from app.factory import create_app
|
||
from app.startup.routers_initializer import init_routers
|
||
|
||
app = create_app()
|
||
init_routers(app)
|
||
schema = app.openapi()
|
||
operations = {
|
||
("/api/v1/openai/v1/models", "get"): "OpenAIErrorResponse",
|
||
("/api/v1/openai/v1/chat/completions", "post"): "OpenAIErrorResponse",
|
||
("/api/v1/openai/v1/responses", "post"): "OpenAIErrorResponse",
|
||
("/api/v1/anthropic/v1/messages", "post"): "AnthropicErrorResponse",
|
||
}
|
||
|
||
for (path, method), error_model in operations.items():
|
||
success_content = schema["paths"][path][method]["responses"]["200"][
|
||
"content"
|
||
]
|
||
response_schema = success_content["application/json"]["schema"]
|
||
assert response_schema
|
||
if path.endswith(("/chat/completions", "/messages")):
|
||
assert success_content["text/event-stream"]["schema"] == {
|
||
"type": "string"
|
||
}
|
||
for status_code in ("400", "401", "422", "500", "503"):
|
||
error_schema = schema["paths"][path][method]["responses"][status_code][
|
||
"content"
|
||
]["application/json"]["schema"]
|
||
assert error_schema["$ref"].endswith(f"/{error_model}")
|
||
|
||
mcp_schema = schema["paths"]["/api/v1/mcp"]["post"]["responses"]["200"][
|
||
"content"
|
||
]["application/json"]["schema"]
|
||
assert len(mcp_schema["anyOf"]) == 2
|
||
post_responses = schema["paths"]["/api/v1/mcp"]["post"]["responses"]
|
||
delete_responses = schema["paths"]["/api/v1/mcp"]["delete"]["responses"]
|
||
assert delete_responses["204"] == {"description": "MCP 会话已终止"}
|
||
for status_code in ("400", "401", "403", "404", "409", "422", "500"):
|
||
for responses in (post_responses, delete_responses):
|
||
error_ref = responses[status_code]["content"]["application/json"][
|
||
"schema"
|
||
]["$ref"]
|
||
assert error_ref.endswith("/McpJsonRpcError")
|
||
|
||
|
||
async def test_native_protocol_validation_errors_keep_native_shapes():
|
||
"""OpenAI 与 Anthropic 的请求校验错误应保持各自协议的错误结构。"""
|
||
from app.factory import create_app
|
||
from app.startup.routers_initializer import init_routers
|
||
|
||
app = create_app()
|
||
init_routers(app)
|
||
async with make_client(app) as client:
|
||
openai_response = await client.post(
|
||
"/api/v1/openai/v1/chat/completions",
|
||
json={"messages": "invalid"},
|
||
)
|
||
openai_responses_response = await client.post(
|
||
"/api/v1/openai/v1/responses",
|
||
json={},
|
||
)
|
||
anthropic_response = await client.post(
|
||
"/api/v1/anthropic/v1/messages",
|
||
json={"messages": "invalid"},
|
||
)
|
||
|
||
assert openai_response.status_code == 422
|
||
assert openai_response.json() == {
|
||
"error": {
|
||
"message": "Input should be a valid list",
|
||
"type": "invalid_request_error",
|
||
"param": "messages",
|
||
"code": "invalid_request_error",
|
||
}
|
||
}
|
||
assert openai_responses_response.status_code == 422
|
||
assert openai_responses_response.json()["error"]["type"] == (
|
||
"invalid_request_error"
|
||
)
|
||
assert openai_responses_response.json()["error"]["param"] == "input"
|
||
assert anthropic_response.status_code == 422
|
||
assert anthropic_response.json() == {
|
||
"type": "error",
|
||
"error": {
|
||
"type": "invalid_request_error",
|
||
"message": "messages: Input should be a valid list",
|
||
},
|
||
}
|
||
|
||
|
||
async def test_mcp_root_auth_error_keeps_jsonrpc_shape():
|
||
"""MCP 根端点的依赖异常应保持 JSON-RPC，REST 子端点仍由统一协议处理。"""
|
||
from app.factory import create_app
|
||
from app.startup.routers_initializer import init_routers
|
||
|
||
app = create_app()
|
||
init_routers(app)
|
||
async with make_client(app) as client:
|
||
response = await client.post(
|
||
"/api/v1/mcp",
|
||
json={"jsonrpc": "2.0", "id": 1, "method": "ping"},
|
||
)
|
||
|
||
payload = response.json()
|
||
assert response.status_code == 401
|
||
assert payload["jsonrpc"] == "2.0"
|
||
assert payload["id"] is None
|
||
assert payload["error"]["code"] == -32001
|
||
assert "success" not in payload
|
||
|
||
|
||
async def test_native_ai_http_and_unhandled_errors_keep_protocol_shapes():
|
||
"""兼容协议的依赖异常与未捕获异常都应返回原生错误体。"""
|
||
from starlette.requests import Request
|
||
|
||
def request_for(path: str) -> Request:
|
||
"""构造直接调用异常处理器所需的最小请求对象。"""
|
||
return Request(
|
||
{
|
||
"type": "http",
|
||
"method": "POST",
|
||
"path": path,
|
||
"headers": [],
|
||
"query_string": b"",
|
||
"server": ("testserver", 80),
|
||
"client": ("testclient", 123),
|
||
"scheme": "http",
|
||
}
|
||
)
|
||
|
||
openai_http = await localized_http_exception_handler(
|
||
request_for("/api/v1/openai/v1/chat/completions"),
|
||
HTTPException(status_code=401, detail="Invalid bearer token."),
|
||
)
|
||
anthropic_http = await localized_http_exception_handler(
|
||
request_for("/api/v1/anthropic/v1/messages"),
|
||
HTTPException(status_code=403, detail="invalid x-api-key"),
|
||
)
|
||
openai_crash = await localized_unhandled_exception_handler(
|
||
request_for("/api/v1/openai/v1/responses"),
|
||
RuntimeError("private openai failure"),
|
||
)
|
||
anthropic_crash = await localized_unhandled_exception_handler(
|
||
request_for("/api/v1/anthropic/v1/messages"),
|
||
RuntimeError("private anthropic failure"),
|
||
)
|
||
|
||
openai_http_payload = openai_http.body.decode()
|
||
anthropic_http_payload = anthropic_http.body.decode()
|
||
openai_crash_payload = openai_crash.body.decode()
|
||
anthropic_crash_payload = anthropic_crash.body.decode()
|
||
assert openai_http.status_code == 401
|
||
assert '"type":"authentication_error"' in openai_http_payload
|
||
assert '"success"' not in openai_http_payload
|
||
assert anthropic_http.status_code == 403
|
||
assert '"type":"authentication_error"' in anthropic_http_payload
|
||
assert '"success"' not in anthropic_http_payload
|
||
assert openai_crash.status_code == 500
|
||
assert '"type":"server_error"' in openai_crash_payload
|
||
assert "private openai failure" not in openai_crash_payload
|
||
assert anthropic_crash.status_code == 500
|
||
assert '"type":"api_error"' in anthropic_crash_payload
|
||
assert "private anthropic failure" not in anthropic_crash_payload
|
||
|
||
|
||
def test_servarr_and_cookiecloud_openapi_has_explicit_models():
|
||
"""兼容协议成功响应必须显式建模，错误响应必须声明统一结构。"""
|
||
from app.factory import create_app
|
||
from app.startup.routers_initializer import init_routers
|
||
|
||
app = create_app()
|
||
init_routers(app)
|
||
schema = app.openapi()
|
||
compatible_paths = [
|
||
path
|
||
for path in schema["paths"]
|
||
if path.startswith(("/api/v3", "/cookiecloud"))
|
||
]
|
||
|
||
assert compatible_paths
|
||
for path in compatible_paths:
|
||
for operation in schema["paths"][path].values():
|
||
success_response = operation["responses"].get("200")
|
||
if success_response:
|
||
success_schemas = [
|
||
content["schema"]
|
||
for content in success_response.get("content", {}).values()
|
||
]
|
||
assert success_schemas and all(success_schemas)
|
||
for status_code in ("400", "401", "403", "404", "409", "422", "500"):
|
||
error_response = operation["responses"][status_code]
|
||
error_schema = next(iter(error_response["content"].values()))[
|
||
"schema"
|
||
]
|
||
assert error_schema["$ref"].startswith(
|
||
"#/components/schemas/Response_"
|
||
)
|
||
|
||
|
||
def test_all_openapi_error_responses_use_json_schemas():
|
||
"""所有普通与原生协议错误响应都应在文档中声明 JSON 媒体类型和结构。"""
|
||
from app.factory import create_app
|
||
from app.startup.routers_initializer import init_routers
|
||
|
||
app = create_app()
|
||
init_routers(app)
|
||
schema = app.openapi()
|
||
methods = {"get", "post", "put", "patch", "delete", "options", "head"}
|
||
|
||
invalid_responses = []
|
||
for path, path_item in schema["paths"].items():
|
||
for method, operation in path_item.items():
|
||
if method not in methods:
|
||
continue
|
||
for status_code, response in operation["responses"].items():
|
||
if not str(status_code).startswith(("4", "5")):
|
||
continue
|
||
json_schema = response.get("content", {}).get(
|
||
"application/json", {}
|
||
).get("schema")
|
||
if not json_schema:
|
||
invalid_responses.append((path, method, status_code))
|
||
|
||
assert invalid_responses == []
|
||
|
||
|
||
def test_openapi_success_models_have_no_implicit_empty_nested_schemas():
|
||
"""2xx 响应可达模型不得包含裸 Any、裸数组或未声明值类型的开放映射。"""
|
||
from app.factory import create_app
|
||
from app.startup.routers_initializer import init_routers
|
||
|
||
app = create_app()
|
||
init_routers(app)
|
||
schema = app.openapi()
|
||
components = schema["components"]["schemas"]
|
||
allowed_open_components = {
|
||
# 三个外部兼容协议允许规范声明之外的请求扩展字段。
|
||
"AnthropicMessage",
|
||
"AnthropicMessagesRequest",
|
||
"OpenAIChatCompletionsRequest",
|
||
"OpenAIChatMessage",
|
||
"OpenAIResponsesRequest",
|
||
# 分类规则与 CookieCloud 解密载荷按设计接受扩展键。
|
||
"CategoryRule",
|
||
"CookieDecryptedPayload",
|
||
}
|
||
allowed_empty_components = {"McpJsonRpcEmptyResult"}
|
||
violations = []
|
||
|
||
def visit(node: Any, component: str, location: str) -> None:
|
||
"""递归检查单个组件节点中的隐式弱类型。"""
|
||
if not isinstance(node, dict):
|
||
return
|
||
if node == {} and component not in allowed_empty_components:
|
||
violations.append((component, location, "empty"))
|
||
if (
|
||
node.get("type") == "array"
|
||
and "items" not in node
|
||
and "prefixItems" not in node
|
||
):
|
||
violations.append((component, location, "untyped-array"))
|
||
if (
|
||
node.get("additionalProperties") is True
|
||
and component not in allowed_open_components
|
||
):
|
||
violations.append((component, location, "open-object"))
|
||
if (
|
||
node.get("type") == "object"
|
||
and not node.get("properties")
|
||
and "additionalProperties" not in node
|
||
and component not in allowed_empty_components
|
||
):
|
||
violations.append((component, location, "untyped-object"))
|
||
for key, value in node.items():
|
||
if key in {"default", "example", "examples"}:
|
||
continue
|
||
if isinstance(value, dict):
|
||
visit(value, component, f"{location}.{key}")
|
||
elif isinstance(value, list):
|
||
for index, item in enumerate(value):
|
||
visit(item, component, f"{location}.{key}[{index}]")
|
||
|
||
for component_name, component_schema in components.items():
|
||
visit(component_schema, component_name, component_name)
|
||
|
||
assert violations == []
|
||
|
||
|
||
def test_plugin_routes_only_register_v1(monkeypatch):
|
||
"""插件动态路由只应注册 v1 地址并由应用统一路由类处理。"""
|
||
from app.api.endpoints import plugin as plugin_endpoint
|
||
|
||
class FakeApp:
|
||
"""记录动态注册路径的应用桩。"""
|
||
|
||
def __init__(self):
|
||
self.routes = []
|
||
self.openapi_schema = None
|
||
|
||
def add_api_route(self, **kwargs):
|
||
"""记录新增的路由路径。"""
|
||
self.routes.append(SimpleNamespace(path=kwargs["path"]))
|
||
|
||
def setup(self):
|
||
"""模拟 FastAPI 路由重建。"""
|
||
|
||
class FakePluginManager:
|
||
"""返回单个测试插件 API 的管理器桩。"""
|
||
|
||
def get_plugin_apis(self, plugin_id):
|
||
"""返回测试插件 API。"""
|
||
assert plugin_id == "DemoPlugin"
|
||
return [
|
||
{
|
||
"path": "/DemoPlugin/health",
|
||
"endpoint": lambda: {"ok": True},
|
||
"methods": ["GET"],
|
||
}
|
||
]
|
||
|
||
fake_app = FakeApp()
|
||
monkeypatch.setattr(plugin_endpoint, "app", fake_app)
|
||
monkeypatch.setattr(plugin_endpoint, "PluginManager", FakePluginManager)
|
||
|
||
plugin_endpoint._update_plugin_api_routes("DemoPlugin", action="add")
|
||
assert [route.path for route in fake_app.routes] == [
|
||
"/api/v1/plugin/DemoPlugin/health"
|
||
]
|
||
|
||
plugin_endpoint._update_plugin_api_routes("DemoPlugin", action="remove")
|
||
assert fake_app.routes == []
|
||
|
||
|
||
def test_response_router_uses_response_route_class():
|
||
"""统一路由器应默认创建统一响应路由。"""
|
||
router = ResponseAPIRouter()
|
||
|
||
@router.get("/health", response_model=bool)
|
||
def health() -> bool:
|
||
"""返回测试健康状态。"""
|
||
return True
|
||
|
||
assert isinstance(router.routes[0], ResponseAPIRoute)
|
||
|
||
|
||
def test_dynamic_route_without_annotation_uses_recursive_json_model():
|
||
"""动态插件未声明模型时应以 OpenAPI 可递归展示的 JSON 类型约束 data。"""
|
||
app = FastAPI()
|
||
app.router.route_class = ResponseAPIRoute
|
||
|
||
def plugin_endpoint():
|
||
"""模拟未声明返回注解的插件动态接口。"""
|
||
return {"ok": True}
|
||
|
||
app.add_api_route("/plugin", plugin_endpoint, methods=["GET"])
|
||
route = app.routes[-1]
|
||
generic_args = route.response_model.__pydantic_generic_metadata__["args"]
|
||
|
||
assert generic_args == (JsonData,)
|
||
|
||
|
||
def test_dynamic_bare_response_uses_recursive_json_without_double_wrapping():
|
||
"""动态插件声明裸 Response 时应补齐递归 JSON 类型且不重复封装。"""
|
||
router = ResponseAPIRouter()
|
||
|
||
@router.get("/plugin", response_model=Response)
|
||
def plugin_endpoint() -> Response:
|
||
"""模拟返回统一响应但未参数化 data 的插件接口。"""
|
||
return Response(success=True, data={"ok": True})
|
||
|
||
route = router.routes[0]
|
||
generic_args = route.response_model.__pydantic_generic_metadata__["args"]
|
||
result = route.endpoint()
|
||
|
||
assert generic_args == (JsonData,)
|
||
assert isinstance(result, Response)
|
||
assert result.data == {"ok": True}
|