"""Gateway internal report/finalize/trace route tests.""" import asyncio import base64 import json import time from types import SimpleNamespace from typing import Any from unittest.mock import AsyncMock, MagicMock import pytest from fastapi import BackgroundTasks, FastAPI from fastapi.responses import JSONResponse, StreamingResponse from fastapi.testclient import TestClient from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker from src.api.internal.gateway import ( CONTROL_ACTION_HEADER, CONTROL_ACTION_PROXY_PUBLIC, CONTROL_EXECUTED_HEADER, GatewayAuthContext, GatewayExecutionDecisionResponse, GatewayExecuteRequest, GatewayExecutionPlanResponse, GatewayResolveRequest, GatewayStreamReportRequest, GatewaySyncReportRequest, _dispatch_gateway_sync_telemetry, _build_gateway_sync_error_payload, _build_gateway_sync_telemetry_writer, _run_gateway_stream_report_background, _run_gateway_sync_report_background, _stream_executor_requires_python_rewrite, _build_claude_chat_sync_decision, _build_claude_chat_stream_decision, _build_claude_cli_sync_decision, _build_claude_cli_stream_decision, _build_gemini_files_download_stream_decision, _build_gemini_files_proxy_sync_decision, _build_gemini_chat_sync_decision, _build_gemini_chat_stream_decision, _build_gemini_cli_sync_decision, _build_gemini_cli_stream_decision, _build_openai_chat_sync_decision, _build_openai_chat_stream_decision, _build_openai_cli_stream_decision, _build_openai_video_content_stream_decision, _extract_gateway_sync_error_message, _record_gateway_direct_candidate_graph, _resolve_gateway_sync_error_status_code, _build_openai_chat_sync_plan, _build_openai_cli_sync_decision, _build_openai_cli_stream_plan, _build_openai_cli_sync_plan, _is_streaming_sync_payload, _resolve_auth_context, _resolve_gateway_sync_adapter, classify_gateway_route, router, ) from src.database import get_db from src.models.database import Base, RequestCandidate from src.services.orchestration.candidate_resolver import CandidateResolver from src.services.scheduling.schemas import PoolCandidate, ProviderCandidate from src.services.request.execution_runtime_plan import ExecutionPlan, ExecutionPlanBody, PreparedExecutionPlan def _wait_until(predicate: Any, *, timeout: float = 1.0, interval: float = 0.01) -> None: deadline = time.time() + timeout while time.time() < deadline: if predicate(): return time.sleep(interval) assert predicate() def _make_legacy_test_client(app: FastAPI) -> TestClient: return TestClient( app, base_url="http://127.0.0.1", headers={"x-aether-legacy-internal-gateway": "true"}, ) def test_finalize_sync_route_finalizes_openai_video_create_response( monkeypatch: pytest.MonkeyPatch, ) -> None: app = FastAPI() app.include_router(router) app.dependency_overrides[get_db] = lambda: object() monkeypatch.setattr("src.api.internal.gateway.ensure_loopback", lambda request: None) finalize_mock = AsyncMock( return_value=JSONResponse( content={ "id": "vid_local_123", "object": "video", "status": "submitted", } ) ) monkeypatch.setattr( "src.api.internal.gateway._finalize_gateway_openai_video_create_sync", finalize_mock, ) client = _make_legacy_test_client(app) response = client.post( "/api/internal/gateway/finalize-sync", json={ "trace_id": "trace-openai-video-finalize", "report_kind": "openai_video_create_sync_finalize", "report_context": { "user_id": "user-123", "api_key_id": "key-123", }, "status_code": 200, "headers": {"content-type": "application/json"}, "body_json": {"id": "ext-video-task-123", "status": "submitted"}, "telemetry": {"elapsed_ms": 42}, }, ) assert response.status_code == 200 assert response.headers[CONTROL_EXECUTED_HEADER] == "true" assert response.json() == { "id": "vid_local_123", "object": "video", "status": "submitted", } finalize_mock.assert_awaited_once() def test_finalize_sync_route_finalizes_openai_chat_response( monkeypatch: pytest.MonkeyPatch, ) -> None: app = FastAPI() app.include_router(router) app.dependency_overrides[get_db] = lambda: object() monkeypatch.setattr("src.api.internal.gateway.ensure_loopback", lambda request: None) finalize_mock = AsyncMock( return_value=JSONResponse( content={ "id": "chatcmpl-local-123", "object": "chat.completion", "choices": [], } ) ) monkeypatch.setattr( "src.api.internal.gateway._finalize_gateway_chat_sync", finalize_mock, ) client = _make_legacy_test_client(app) response = client.post( "/api/internal/gateway/finalize-sync", json={ "trace_id": "trace-openai-chat-finalize", "report_kind": "openai_chat_sync_finalize", "report_context": { "user_id": "user-123", "api_key_id": "key-123", "client_api_format": "openai:chat", }, "status_code": 200, "headers": {"content-type": "application/json"}, "body_json": {"id": "upstream-123"}, "telemetry": {"elapsed_ms": 12}, }, ) assert response.status_code == 200 assert response.headers[CONTROL_EXECUTED_HEADER] == "true" assert response.json() == { "id": "chatcmpl-local-123", "object": "chat.completion", "choices": [], } finalize_mock.assert_awaited_once() def test_finalize_sync_route_finalizes_openai_cli_response( monkeypatch: pytest.MonkeyPatch, ) -> None: app = FastAPI() app.include_router(router) app.dependency_overrides[get_db] = lambda: object() monkeypatch.setattr("src.api.internal.gateway.ensure_loopback", lambda request: None) finalize_mock = AsyncMock( return_value=JSONResponse( content={ "id": "resp_local_123", "object": "response", "output": [], } ) ) monkeypatch.setattr( "src.api.internal.gateway._finalize_gateway_cli_sync", finalize_mock, ) client = _make_legacy_test_client(app) response = client.post( "/api/internal/gateway/finalize-sync", json={ "trace_id": "trace-openai-cli-finalize", "report_kind": "openai_cli_sync_finalize", "report_context": { "user_id": "user-123", "api_key_id": "key-123", "client_api_format": "openai:cli", }, "status_code": 200, "headers": {"content-type": "application/json"}, "body_json": {"id": "upstream-resp-123"}, "telemetry": {"elapsed_ms": 23}, }, ) assert response.status_code == 200 assert response.headers[CONTROL_EXECUTED_HEADER] == "true" assert response.json() == { "id": "resp_local_123", "object": "response", "output": [], } finalize_mock.assert_awaited_once() @pytest.mark.asyncio @pytest.mark.asyncio async def test_finalize_gateway_chat_sync_uses_dispatch_helper_for_success( monkeypatch: pytest.MonkeyPatch, ) -> None: from src.api.internal import gateway as gateway_module class FakeQuery: def __init__(self, obj: object) -> None: self._obj = obj def filter(self, *args: object, **kwargs: object) -> "FakeQuery": return self def first(self) -> object: return self._obj class FakeDB: def __init__(self, mapping: dict[str, object]) -> None: self._mapping = mapping def query(self, model: object) -> FakeQuery: return FakeQuery(self._mapping[getattr(model, "__name__", "")]) fake_handler = SimpleNamespace( _prepare_provider_request=AsyncMock( return_value=SimpleNamespace( needs_conversion=False, envelope=None, upstream_is_stream=False, ) ), _normalize_response=lambda body: body, _extract_usage=lambda body: {"input_tokens": 1, "output_tokens": 2}, _extract_response_metadata=lambda body: {"finish_reason": "stop"}, telemetry=SimpleNamespace( record_success=AsyncMock(return_value=None), record_failure=AsyncMock(return_value=None), ), ) dispatch_mock = AsyncMock(return_value=None) fake_writer = SimpleNamespace( supports_background_submission=lambda: True, record_success=AsyncMock(return_value=None), ) monkeypatch.setattr( "src.api.handlers.openai.OpenAIChatAdapter._create_handler", lambda self, **kwargs: fake_handler, ) monkeypatch.setattr(gateway_module, "_dispatch_gateway_sync_telemetry", dispatch_mock) monkeypatch.setattr( gateway_module, "_build_gateway_sync_telemetry_writer", lambda **kwargs: fake_writer, ) db = FakeDB( { "User": SimpleNamespace(id="user-chat-finalize-dispatch-123"), "ApiKey": SimpleNamespace(id="api-key-chat-finalize-dispatch-123"), "Provider": SimpleNamespace( id="provider-chat-finalize-dispatch-123", name="openai", provider_type="openai", ), "ProviderEndpoint": SimpleNamespace(id="endpoint-chat-finalize-dispatch-123"), "ProviderAPIKey": SimpleNamespace(id="key-chat-finalize-dispatch-123"), } ) payload = GatewaySyncReportRequest( trace_id="trace-chat-finalize-dispatch-123", report_kind="openai_chat_sync_finalize", report_context={ "user_id": "user-chat-finalize-dispatch-123", "api_key_id": "api-key-chat-finalize-dispatch-123", "provider_id": "provider-chat-finalize-dispatch-123", "endpoint_id": "endpoint-chat-finalize-dispatch-123", "key_id": "key-chat-finalize-dispatch-123", "request_id": "req-chat-finalize-dispatch-123", "model": "gpt-5", "provider_name": "openai", "provider_api_format": "openai:chat", "client_api_format": "openai:chat", "mapped_model": "gpt-5", "original_headers": {"content-type": "application/json"}, "original_request_body": {"model": "gpt-5", "messages": []}, "provider_request_headers": {"content-type": "application/json"}, "provider_request_body": {"model": "gpt-5", "messages": []}, }, status_code=200, headers={"content-type": "application/json"}, body_json={ "id": "chatcmpl-finalize-dispatch-123", "object": "chat.completion", "choices": [], "usage": { "prompt_tokens": 1, "completion_tokens": 2, "total_tokens": 3, }, }, telemetry={"elapsed_ms": 11}, ) response = await gateway_module._finalize_gateway_chat_sync(payload, db=db) assert response.status_code == 200 dispatch_mock.assert_awaited_once() assert dispatch_mock.await_args.kwargs["telemetry_writer"] is fake_writer assert dispatch_mock.await_args.kwargs["operation"] == "record_success" fake_writer.record_success.assert_not_called() @pytest.mark.asyncio @pytest.mark.asyncio async def test_finalize_gateway_chat_sync_aggregates_upstream_stream_body_base64( monkeypatch: pytest.MonkeyPatch, ) -> None: from src.api.internal import gateway as gateway_module class FakeQuery: def __init__(self, obj: object) -> None: self._obj = obj def filter(self, *args: object, **kwargs: object) -> "FakeQuery": return self def first(self) -> object: return self._obj class FakeDB: def __init__(self, mapping: dict[str, object]) -> None: self._mapping = mapping def query(self, model: object) -> FakeQuery: return FakeQuery(self._mapping[getattr(model, "__name__", "")]) fake_handler = SimpleNamespace( _prepare_provider_request=AsyncMock( return_value=SimpleNamespace( needs_conversion=False, envelope=None, upstream_is_stream=True, provider_api_format="openai:chat", mapped_model="gpt-5", ) ), _normalize_response=lambda body: body, _extract_usage=lambda body: {"input_tokens": 1, "output_tokens": 2}, telemetry=SimpleNamespace( record_success=AsyncMock(return_value=None), record_failure=AsyncMock(return_value=None), ), ) seen_body: dict[str, bytes] = {} class FakeChatSyncExecutor: def __init__(self, handler: object) -> None: self._ctx = SimpleNamespace(provider_response_json=None) async def _finalize_rust_stream_sync_result( self, *, prepared_plan: object, provider: object, model: str, response_body_bytes: bytes, ) -> dict[str, object]: seen_body["body"] = response_body_bytes return { "id": "chatcmpl-direct-stream-123", "object": "chat.completion", "choices": [], "usage": { "prompt_tokens": 1, "completion_tokens": 2, "total_tokens": 3, }, } monkeypatch.setattr( "src.api.handlers.base.chat_sync_executor.ChatSyncExecutor", FakeChatSyncExecutor, ) monkeypatch.setattr( "src.api.handlers.openai.OpenAIChatAdapter._create_handler", lambda self, **kwargs: fake_handler, ) db = FakeDB( { "User": SimpleNamespace(id="user-chat-stream-finalize-123"), "ApiKey": SimpleNamespace(id="api-key-chat-stream-finalize-123"), "Provider": SimpleNamespace( id="provider-chat-stream-finalize-123", name="openai", provider_type="openai", ), "ProviderEndpoint": SimpleNamespace(id="endpoint-chat-stream-finalize-123"), "ProviderAPIKey": SimpleNamespace(id="key-chat-stream-finalize-123"), } ) payload = GatewaySyncReportRequest( trace_id="trace-chat-stream-sync-finalize-123", report_kind="openai_chat_sync_finalize", report_context={ "user_id": "user-chat-stream-finalize-123", "api_key_id": "api-key-chat-stream-finalize-123", "provider_id": "provider-chat-stream-finalize-123", "endpoint_id": "endpoint-chat-stream-finalize-123", "key_id": "key-chat-stream-finalize-123", "request_id": "req-chat-stream-sync-finalize-123", "model": "gpt-5", "provider_name": "openai", "provider_api_format": "openai:chat", "client_api_format": "openai:chat", "mapped_model": "gpt-5", "original_headers": {"content-type": "application/json"}, "original_request_body": {"model": "gpt-5", "messages": []}, "provider_request_headers": {"content-type": "application/json"}, "provider_request_body": {"model": "gpt-5", "messages": []}, }, status_code=200, headers={"content-type": "text/event-stream"}, body_base64=base64.b64encode(b"data: stub\n\n").decode("ascii"), telemetry={"elapsed_ms": 12}, ) response = await gateway_module._finalize_gateway_chat_sync(payload, db=db) assert response.status_code == 200 assert json.loads(response.body) == { "id": "chatcmpl-direct-stream-123", "object": "chat.completion", "choices": [], "usage": { "prompt_tokens": 1, "completion_tokens": 2, "total_tokens": 3, }, } assert seen_body["body"] == b"data: stub\n\n" fake_handler.telemetry.record_success.assert_awaited_once() @pytest.mark.asyncio @pytest.mark.asyncio async def test_finalize_gateway_cli_sync_aggregates_upstream_stream_body_base64( monkeypatch: pytest.MonkeyPatch, ) -> None: from src.api.internal import gateway as gateway_module from src.api.handlers.openai_cli import OpenAICliAdapter class FakeQuery: def __init__(self, obj: object) -> None: self._obj = obj def filter(self, *args: object, **kwargs: object) -> "FakeQuery": return self def first(self) -> object: return self._obj class FakeDB: def __init__(self, mapping: dict[str, object]) -> None: self._mapping = mapping def query(self, model: object) -> FakeQuery: return FakeQuery(self._mapping[getattr(model, "__name__", "")]) aggregate_mock = AsyncMock( return_value={ "id": "resp-direct-stream-123", "object": "response", "output": [], "usage": {"input_tokens": 1, "output_tokens": 2}, } ) class FakeCliHandler: def __init__(self, **kwargs: object) -> None: self.parser = SimpleNamespace( extract_usage_from_response=lambda body: { "input_tokens": 1, "output_tokens": 2, } ) self.telemetry = SimpleNamespace( record_success=AsyncMock(return_value=None), record_failure=AsyncMock(return_value=None), ) async def _build_upstream_request(self, **kwargs: object) -> SimpleNamespace: return SimpleNamespace( upstream_is_stream=True, envelope=None, ) async def _aggregate_upstream_stream_sync_response(self, **kwargs: object) -> dict[str, object]: return await aggregate_mock(**kwargs) def _extract_response_metadata(self, body: dict[str, object]) -> dict[str, object]: return {} monkeypatch.setattr( type(OpenAICliAdapter()), "HANDLER_CLASS", property(lambda self: FakeCliHandler), ) db = FakeDB( { "User": SimpleNamespace(id="user-cli-stream-finalize-123"), "ApiKey": SimpleNamespace(id="api-key-cli-stream-finalize-123"), "Provider": SimpleNamespace( id="provider-cli-stream-finalize-123", name="openai", provider_type="openai", ), "ProviderEndpoint": SimpleNamespace(id="endpoint-cli-stream-finalize-123"), "ProviderAPIKey": SimpleNamespace(id="key-cli-stream-finalize-123"), } ) payload = GatewaySyncReportRequest( trace_id="trace-cli-stream-sync-finalize-123", report_kind="openai_cli_sync_finalize", report_context={ "user_id": "user-cli-stream-finalize-123", "api_key_id": "api-key-cli-stream-finalize-123", "provider_id": "provider-cli-stream-finalize-123", "endpoint_id": "endpoint-cli-stream-finalize-123", "key_id": "key-cli-stream-finalize-123", "request_id": "req-cli-stream-sync-finalize-123", "model": "gpt-5", "provider_name": "openai", "provider_api_format": "openai:cli", "client_api_format": "openai:cli", "mapped_model": "gpt-5", "original_headers": {"content-type": "application/json"}, "original_request_body": {"model": "gpt-5", "input": "hello"}, "provider_request_headers": {"content-type": "application/json"}, "provider_request_body": {"model": "gpt-5", "input": "hello"}, }, status_code=200, headers={"content-type": "text/event-stream"}, body_base64=base64.b64encode(b"data: cli\n\n").decode("ascii"), telemetry={"elapsed_ms": 9}, ) response = await gateway_module._finalize_gateway_cli_sync(payload, db=db) assert response.status_code == 200 assert json.loads(response.body) == { "id": "resp-direct-stream-123", "object": "response", "output": [], "usage": {"input_tokens": 1, "output_tokens": 2}, } aggregate_mock.assert_awaited_once() @pytest.mark.asyncio @pytest.mark.asyncio async def test_finalize_gateway_chat_sync_fast_path_returns_before_db_lookup( monkeypatch: pytest.MonkeyPatch, ) -> None: from src.api.internal import gateway as gateway_module aggregate_mock = AsyncMock( return_value={ "id": "chatcmpl-fast-finalize-123", "object": "chat.completion", "choices": [], "usage": {"prompt_tokens": 1, "completion_tokens": 2, "total_tokens": 3}, } ) monkeypatch.setattr( gateway_module, "_aggregate_gateway_sync_response_bytes", aggregate_mock, ) class FailingDB: def query(self, model: object) -> object: raise AssertionError(f"db query should not happen for {getattr(model, '__name__', model)}") payload = GatewaySyncReportRequest( trace_id="trace-chat-fast-finalize-123", report_kind="openai_chat_sync_finalize", report_context={ "user_id": "user-chat-fast-finalize-123", "api_key_id": "api-key-chat-fast-finalize-123", "provider_id": "provider-chat-fast-finalize-123", "endpoint_id": "endpoint-chat-fast-finalize-123", "key_id": "key-chat-fast-finalize-123", "request_id": "req-chat-fast-finalize-123", "model": "gpt-5", "provider_name": "openai", "provider_api_format": "openai:chat", "client_api_format": "openai:chat", "mapped_model": "gpt-5", "original_headers": {"content-type": "application/json"}, "original_request_body": {"model": "gpt-5", "messages": []}, "provider_request_headers": {"content-type": "application/json"}, "provider_request_body": {"model": "gpt-5", "messages": []}, "has_envelope": False, "needs_conversion": False, }, status_code=200, headers={"content-type": "text/event-stream"}, body_base64=base64.b64encode(b"data: stub\n\n").decode("ascii"), telemetry={"elapsed_ms": 7}, ) background_tasks = BackgroundTasks() response = await gateway_module._finalize_gateway_chat_sync( payload, db=FailingDB(), background_tasks=background_tasks, ) assert response.status_code == 200 assert json.loads(response.body) == { "id": "chatcmpl-fast-finalize-123", "object": "chat.completion", "choices": [], "usage": {"prompt_tokens": 1, "completion_tokens": 2, "total_tokens": 3}, } aggregate_mock.assert_awaited_once() assert len(background_tasks.tasks) == 1 assert background_tasks.tasks[0].func is gateway_module._run_gateway_chat_sync_finalize_background @pytest.mark.asyncio @pytest.mark.asyncio async def test_finalize_gateway_cli_sync_fast_path_returns_before_db_lookup() -> None: from src.api.internal import gateway as gateway_module class FailingDB: def query(self, model: object) -> object: raise AssertionError(f"db query should not happen for {getattr(model, '__name__', model)}") payload = GatewaySyncReportRequest( trace_id="trace-cli-fast-finalize-123", report_kind="openai_cli_sync_finalize", report_context={ "user_id": "user-cli-fast-finalize-123", "api_key_id": "api-key-cli-fast-finalize-123", "provider_id": "provider-cli-fast-finalize-123", "endpoint_id": "endpoint-cli-fast-finalize-123", "key_id": "key-cli-fast-finalize-123", "request_id": "req-cli-fast-finalize-123", "model": "gpt-5", "provider_name": "openai", "provider_api_format": "openai:cli", "client_api_format": "openai:cli", "mapped_model": "gpt-5", "original_headers": {"content-type": "application/json"}, "original_request_body": {"model": "gpt-5", "input": "hello"}, "provider_request_headers": {"content-type": "application/json"}, "provider_request_body": {"model": "gpt-5", "input": "hello"}, "has_envelope": False, "needs_conversion": False, }, status_code=200, headers={"content-type": "application/json"}, body_json={ "id": "resp-fast-finalize-123", "object": "response", "output": [], "usage": {"input_tokens": 1, "output_tokens": 2}, }, telemetry={"elapsed_ms": 5}, ) background_tasks = BackgroundTasks() response = await gateway_module._finalize_gateway_cli_sync( payload, db=FailingDB(), background_tasks=background_tasks, ) assert response.status_code == 200 assert json.loads(response.body) == { "id": "resp-fast-finalize-123", "object": "response", "output": [], "usage": {"input_tokens": 1, "output_tokens": 2}, } assert len(background_tasks.tasks) == 1 assert background_tasks.tasks[0].func is gateway_module._run_gateway_cli_sync_finalize_background def test_finalize_sync_route_uses_chat_fast_path_without_db_session( monkeypatch: pytest.MonkeyPatch, ) -> None: app = FastAPI() app.include_router(router) monkeypatch.setattr("src.api.internal.gateway.ensure_loopback", lambda request: None) fast_mock = AsyncMock( return_value=JSONResponse( content={"id": "chat-fast-123", "object": "chat.completion", "choices": []} ) ) background_mock = AsyncMock(return_value=None) monkeypatch.setattr( "src.api.internal.gateway._maybe_build_gateway_core_sync_fast_success_response", fast_mock, ) monkeypatch.setattr( "src.api.internal.gateway._run_gateway_chat_sync_finalize_background_with_session", background_mock, ) monkeypatch.setattr( "src.api.internal.gateway.create_session", lambda: (_ for _ in ()).throw(AssertionError("create_session should not be called")), ) client = _make_legacy_test_client(app) response = client.post( "/api/internal/gateway/finalize-sync", json={ "trace_id": "trace-chat-fast-route-123", "report_kind": "openai_chat_sync_finalize", "report_context": { "provider_api_format": "openai:chat", "client_api_format": "openai:chat", "has_envelope": False, }, "status_code": 200, "headers": {"content-type": "application/json"}, "body_json": {"id": "chat-fast-123", "object": "chat.completion", "choices": []}, }, ) assert response.status_code == 200 assert response.headers[CONTROL_EXECUTED_HEADER] == "true" assert response.json()["id"] == "chat-fast-123" fast_mock.assert_awaited_once() background_mock.assert_awaited_once() def test_finalize_sync_route_uses_cli_fast_path_without_db_session( monkeypatch: pytest.MonkeyPatch, ) -> None: app = FastAPI() app.include_router(router) monkeypatch.setattr("src.api.internal.gateway.ensure_loopback", lambda request: None) fast_mock = AsyncMock( return_value=JSONResponse( content={"id": "resp-fast-123", "object": "response", "output": []} ) ) background_mock = AsyncMock(return_value=None) monkeypatch.setattr( "src.api.internal.gateway._maybe_build_gateway_core_sync_fast_success_response", fast_mock, ) monkeypatch.setattr( "src.api.internal.gateway._run_gateway_cli_sync_finalize_background_with_session", background_mock, ) monkeypatch.setattr( "src.api.internal.gateway.create_session", lambda: (_ for _ in ()).throw(AssertionError("create_session should not be called")), ) client = _make_legacy_test_client(app) response = client.post( "/api/internal/gateway/finalize-sync", json={ "trace_id": "trace-cli-fast-route-123", "report_kind": "openai_cli_sync_finalize", "report_context": { "provider_api_format": "openai:cli", "client_api_format": "openai:cli", "has_envelope": False, }, "status_code": 200, "headers": {"content-type": "application/json"}, "body_json": {"id": "resp-fast-123", "object": "response", "output": []}, }, ) assert response.status_code == 200 assert response.headers[CONTROL_EXECUTED_HEADER] == "true" assert response.json()["id"] == "resp-fast-123" fast_mock.assert_awaited_once() background_mock.assert_awaited_once() def test_finalize_sync_route_finalizes_openai_video_remix_response( monkeypatch: pytest.MonkeyPatch, ) -> None: app = FastAPI() app.include_router(router) app.dependency_overrides[get_db] = lambda: object() monkeypatch.setattr("src.api.internal.gateway.ensure_loopback", lambda request: None) finalize_mock = AsyncMock( return_value=JSONResponse( content={ "id": "vid_local_remix_123", "object": "video", "status": "submitted", } ) ) monkeypatch.setattr( "src.api.internal.gateway._finalize_gateway_openai_video_remix_sync", finalize_mock, ) client = _make_legacy_test_client(app) response = client.post( "/api/internal/gateway/finalize-sync", json={ "trace_id": "trace-openai-video-remix-finalize", "report_kind": "openai_video_remix_sync_finalize", "report_context": { "user_id": "user-123", "api_key_id": "key-123", "task_id": "task-123", }, "status_code": 200, "headers": {"content-type": "application/json"}, "body_json": {"id": "ext-remix-task-123", "status": "submitted"}, "telemetry": {"elapsed_ms": 55}, }, ) assert response.status_code == 200 assert response.headers[CONTROL_EXECUTED_HEADER] == "true" assert response.json() == { "id": "vid_local_remix_123", "object": "video", "status": "submitted", } finalize_mock.assert_awaited_once() def test_finalize_sync_route_finalizes_gemini_video_create_response( monkeypatch: pytest.MonkeyPatch, ) -> None: app = FastAPI() app.include_router(router) app.dependency_overrides[get_db] = lambda: object() monkeypatch.setattr("src.api.internal.gateway.ensure_loopback", lambda request: None) finalize_mock = AsyncMock( return_value=JSONResponse( content={ "name": "models/veo-3/operations/aev_123", "done": False, "metadata": {}, } ) ) monkeypatch.setattr( "src.api.internal.gateway._finalize_gateway_gemini_video_create_sync", finalize_mock, ) client = _make_legacy_test_client(app) response = client.post( "/api/internal/gateway/finalize-sync", json={ "trace_id": "trace-gemini-video-create-finalize", "report_kind": "gemini_video_create_sync_finalize", "report_context": { "user_id": "user-123", "api_key_id": "key-123", "model": "veo-3", }, "status_code": 200, "headers": {"content-type": "application/json"}, "body_json": {"name": "operations/ext-video-123"}, "telemetry": {"elapsed_ms": 48}, }, ) assert response.status_code == 200 assert response.headers[CONTROL_EXECUTED_HEADER] == "true" assert response.json() == { "name": "models/veo-3/operations/aev_123", "done": False, "metadata": {}, } finalize_mock.assert_awaited_once() def test_finalize_sync_route_finalizes_openai_video_delete_response( monkeypatch: pytest.MonkeyPatch, ) -> None: app = FastAPI() app.include_router(router) app.dependency_overrides[get_db] = lambda: object() monkeypatch.setattr("src.api.internal.gateway.ensure_loopback", lambda request: None) finalize_mock = AsyncMock( return_value=JSONResponse( content={ "id": "task-123", "object": "video", "deleted": True, } ) ) monkeypatch.setattr( "src.api.internal.gateway._finalize_gateway_openai_video_delete_sync", finalize_mock, ) client = _make_legacy_test_client(app) response = client.post( "/api/internal/gateway/finalize-sync", json={ "trace_id": "trace-openai-video-delete-finalize", "report_kind": "openai_video_delete_sync_finalize", "report_context": { "user_id": "user-123", "api_key_id": "key-123", "task_id": "task-123", }, "status_code": 404, "headers": {"content-type": "application/json"}, }, ) assert response.status_code == 200 assert response.headers[CONTROL_EXECUTED_HEADER] == "true" assert response.json() == { "id": "task-123", "object": "video", "deleted": True, } finalize_mock.assert_awaited_once() def test_finalize_sync_route_finalizes_openai_video_cancel_response( monkeypatch: pytest.MonkeyPatch, ) -> None: app = FastAPI() app.include_router(router) app.dependency_overrides[get_db] = lambda: object() monkeypatch.setattr("src.api.internal.gateway.ensure_loopback", lambda request: None) finalize_mock = AsyncMock(return_value=JSONResponse(content={})) monkeypatch.setattr( "src.api.internal.gateway._finalize_gateway_openai_video_cancel_sync", finalize_mock, ) client = _make_legacy_test_client(app) response = client.post( "/api/internal/gateway/finalize-sync", json={ "trace_id": "trace-openai-video-cancel-finalize", "report_kind": "openai_video_cancel_sync_finalize", "report_context": { "user_id": "user-123", "api_key_id": "key-123", "task_id": "task-123", }, "status_code": 204, "headers": {}, }, ) assert response.status_code == 200 assert response.headers[CONTROL_EXECUTED_HEADER] == "true" assert response.json() == {} finalize_mock.assert_awaited_once() def test_finalize_sync_route_finalizes_gemini_video_cancel_response( monkeypatch: pytest.MonkeyPatch, ) -> None: app = FastAPI() app.include_router(router) app.dependency_overrides[get_db] = lambda: object() monkeypatch.setattr("src.api.internal.gateway.ensure_loopback", lambda request: None) finalize_mock = AsyncMock(return_value=JSONResponse(content={})) monkeypatch.setattr( "src.api.internal.gateway._finalize_gateway_gemini_video_cancel_sync", finalize_mock, ) client = _make_legacy_test_client(app) response = client.post( "/api/internal/gateway/finalize-sync", json={ "trace_id": "trace-gemini-video-cancel-finalize", "report_kind": "gemini_video_cancel_sync_finalize", "report_context": { "user_id": "user-123", "api_key_id": "key-123", "task_id": "models/veo-3/operations/ext-123", }, "status_code": 200, "headers": {"content-type": "application/json"}, "body_json": {}, }, ) assert response.status_code == 200 assert response.headers[CONTROL_EXECUTED_HEADER] == "true" assert response.json() == {} finalize_mock.assert_awaited_once() @pytest.mark.asyncio async def test_finalize_gateway_openai_video_create_sync_reuses_rust_owned_task( monkeypatch: pytest.MonkeyPatch, ) -> None: from src.api.internal import gateway as gateway_module background_mock = AsyncMock(return_value=None) begin_pending_usage = MagicMock() class FakeQuery: def __init__(self, value: Any) -> None: self._value = value def filter(self, *args: Any, **kwargs: Any) -> "FakeQuery": return self def first(self) -> Any: return self._value class FakeDB: def __init__(self) -> None: self._mapping = { "User": SimpleNamespace(id="user-123"), "ApiKey": SimpleNamespace(id="key-123"), "VideoTask": SimpleNamespace(id="task-local-123"), } def query(self, model: Any) -> FakeQuery: return FakeQuery(self._mapping.get(getattr(model, "__name__", ""))) def add(self, obj: Any) -> None: raise AssertionError("legacy task creation should be skipped") class FakeOpenAIVideoHandler: FORMAT_ID = "openai:video" def __init__(self, **kwargs: Any) -> None: self._normalizer = SimpleNamespace( video_task_from_internal=lambda task: { "id": task["id"], "object": "video", "status": "submitted", } ) def _task_to_internal(self, task: Any) -> dict[str, Any]: return {"id": task.id} monkeypatch.setattr( "src.api.handlers.openai.video_handler.OpenAIVideoHandler", FakeOpenAIVideoHandler, ) monkeypatch.setattr( "src.api.internal.gateway._run_gateway_video_finalize_submitted_background", background_mock, ) monkeypatch.setattr( "src.services.usage.service.UsageService.begin_pending_usage", begin_pending_usage, ) payload = GatewaySyncReportRequest( trace_id="trace-openai-video-rust-owner-123", report_kind="openai_video_create_sync_success", report_context={ "user_id": "user-123", "api_key_id": "key-123", "provider_id": "provider-123", "endpoint_id": "endpoint-123", "key_id": "provider-key-123", "request_id": "req-openai-video-rust-owner-123", "local_task_id": "task-local-123", "provider_name": "openai", "provider_api_format": "openai:video", "rust_video_task_persisted": True, }, status_code=200, headers={"content-type": "application/json"}, body_json={"id": "ext-video-123", "status": "submitted"}, telemetry={"elapsed_ms": 42}, ) response = await gateway_module._finalize_gateway_openai_video_create_sync( payload, db=FakeDB(), ) assert response.status_code == 200 assert json.loads(response.body) == { "id": "task-local-123", "object": "video", "status": "submitted", } begin_pending_usage.assert_not_called() background_mock.assert_awaited_once() @pytest.mark.asyncio async def test_finalize_gateway_openai_video_remix_sync_reuses_rust_owned_task( monkeypatch: pytest.MonkeyPatch, ) -> None: from src.api.internal import gateway as gateway_module class FakeQuery: def __init__(self, value: Any) -> None: self._value = value def filter(self, *args: Any, **kwargs: Any) -> "FakeQuery": return self def first(self) -> Any: return self._value class FakeDB: def __init__(self) -> None: self._mapping = { "User": SimpleNamespace(id="user-123"), "ApiKey": SimpleNamespace(id="key-123"), "VideoTask": SimpleNamespace(id="task-local-remix-123"), } def query(self, model: Any) -> FakeQuery: return FakeQuery(self._mapping.get(getattr(model, "__name__", ""))) def add(self, obj: Any) -> None: raise AssertionError("legacy remix task creation should be skipped") class FakeOpenAIVideoHandler: def __init__(self, **kwargs: Any) -> None: self._normalizer = SimpleNamespace( video_task_from_internal=lambda task: { "id": task["id"], "object": "video", "status": "submitted", } ) def _task_to_internal(self, task: Any) -> dict[str, Any]: return {"id": task.id} def _get_task(self, task_id: str) -> Any: raise AssertionError("legacy remix source lookup should be skipped") monkeypatch.setattr( "src.api.handlers.openai.video_handler.OpenAIVideoHandler", FakeOpenAIVideoHandler, ) payload = GatewaySyncReportRequest( trace_id="trace-openai-video-remix-rust-owner-123", report_kind="openai_video_remix_sync_success", report_context={ "user_id": "user-123", "api_key_id": "key-123", "task_id": "task-source-123", "request_id": "req-openai-video-remix-rust-owner-123", "local_task_id": "task-local-remix-123", "rust_video_task_persisted": True, }, status_code=200, headers={"content-type": "application/json"}, body_json={"id": "ext-remix-task-123", "status": "submitted"}, ) response = await gateway_module._finalize_gateway_openai_video_remix_sync( payload, db=FakeDB(), ) assert response.status_code == 200 assert json.loads(response.body) == { "id": "task-local-remix-123", "object": "video", "status": "submitted", } @pytest.mark.asyncio async def test_finalize_gateway_gemini_video_create_sync_reuses_rust_owned_task( monkeypatch: pytest.MonkeyPatch, ) -> None: from src.api.internal import gateway as gateway_module background_mock = AsyncMock(return_value=None) begin_pending_usage = MagicMock() class FakeQuery: def __init__(self, value: Any) -> None: self._value = value def filter(self, *args: Any, **kwargs: Any) -> "FakeQuery": return self def first(self) -> Any: return self._value class FakeDB: def __init__(self) -> None: self._mapping = { "User": SimpleNamespace(id="user-123"), "ApiKey": SimpleNamespace(id="key-123"), "VideoTask": SimpleNamespace(short_id="short12345678"), } def query(self, model: Any) -> FakeQuery: return FakeQuery(self._mapping.get(getattr(model, "__name__", ""))) def add(self, obj: Any) -> None: raise AssertionError("legacy gemini task creation should be skipped") class FakeGeminiVeoHandler: FORMAT_ID = "gemini:video" def __init__(self, **kwargs: Any) -> None: self._normalizer = SimpleNamespace( video_task_from_internal=lambda task: { "name": f"models/veo-3/operations/{task['id']}", "done": False, "metadata": {}, } ) def _task_to_internal(self, task: Any) -> dict[str, Any]: return {"id": task.short_id} monkeypatch.setattr( "src.api.handlers.gemini.video_handler.GeminiVeoHandler", FakeGeminiVeoHandler, ) monkeypatch.setattr( "src.api.internal.gateway._run_gateway_video_finalize_submitted_background", background_mock, ) monkeypatch.setattr( "src.services.usage.service.UsageService.begin_pending_usage", begin_pending_usage, ) payload = GatewaySyncReportRequest( trace_id="trace-gemini-video-rust-owner-123", report_kind="gemini_video_create_sync_success", report_context={ "user_id": "user-123", "api_key_id": "key-123", "provider_id": "provider-123", "endpoint_id": "endpoint-123", "key_id": "provider-key-123", "request_id": "req-gemini-video-rust-owner-123", "model": "veo-3", "local_short_id": "short12345678", "provider_name": "gemini", "provider_api_format": "gemini:video", "rust_video_task_persisted": True, }, status_code=200, headers={"content-type": "application/json"}, body_json={"name": "operations/ext-video-123"}, telemetry={"elapsed_ms": 48}, ) response = await gateway_module._finalize_gateway_gemini_video_create_sync( payload, db=FakeDB(), ) assert response.status_code == 200 assert json.loads(response.body) == { "name": "models/veo-3/operations/short12345678", "done": False, "metadata": {}, } begin_pending_usage.assert_not_called() background_mock.assert_awaited_once()