File size: 5,878 Bytes
a9e27c0
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
"""Request startup retains the conversion it validates before generation."""

from dataclasses import replace
from unittest.mock import AsyncMock, patch

import httpx2
import pytest
from openai import AsyncOpenAI

from free_claude_code.application.execution import ProviderExecutor
from free_claude_code.core.anthropic import ReasoningReplayMode
from free_claude_code.providers.openai_chat import (
    NO_REASONING,
    OpenAIChatProfile,
    OpenAIChatProvider,
    OpenAIChatRequestPolicy,
)
from tests.application.test_execution import _routed_request, _routed_responses_request
from tests.providers.support import immediate_admission, make_provider_config
from tests.providers.test_openai_chat_transport import _success
from tests.providers.test_openai_codex_provider import (
    OpenAICodexProvider,
    _complete_stream,
    _config,
    _FakeAuth,
)
from tests.providers.test_opencode import (
    _catalog_payload,
    _provider_with_wire_transports,
)


@pytest.mark.asyncio
@pytest.mark.parametrize("wire", ["messages", "responses"])
async def test_executor_converts_chat_request_once(wire):
    generation_calls = []

    def reply(request):
        generation_calls.append(request)
        return _success()

    async with AsyncOpenAI(
        api_key="test",
        base_url="https://provider.invalid/v1",
        max_retries=0,
        http_client=httpx2.AsyncClient(transport=httpx2.MockTransport(reply)),
    ) as client:
        provider = OpenAIChatProvider(
            make_provider_config(
                api_key="test", base_url="https://provider.invalid/v1"
            ),
            profile=OpenAIChatProfile(
                OpenAIChatRequestPolicy("TEST", ReasoningReplayMode.REASONING_CONTENT),
                NO_REASONING,
            ),
            admission=immediate_admission(),
            client=client,
        )
        executor = ProviderExecutor(
            AsyncMock(side_effect=lambda _, _api_key_number: provider),
        )
        builder_name = (
            "_build_request_body"
            if wire == "messages"
            else "_build_responses_request_body"
        )
        routed = (
            _routed_request() if wire == "messages" else _routed_responses_request()
        )
        with patch.object(
            provider._chat, builder_name, wraps=getattr(provider._chat, builder_name)
        ) as build:
            stream = getattr(executor, f"stream_{wire}")(
                routed, raw_log_payload=dict, request_id="conversion-once"
            )
            output = "".join(
                [frame async for event in stream for frame in event.frames]
            )
        assert "hello" in output
        assert len(generation_calls) == 1
        assert build.call_count == 1


@pytest.mark.asyncio
@pytest.mark.parametrize("wire", ["messages", "responses"])
@pytest.mark.parametrize("egress", ["chat", "responses"])
@pytest.mark.parametrize("warm", [False, True])
async def test_executor_converts_selected_opencode_route_once(wire, egress, warm):
    provider, generation, catalog = _provider_with_wire_transports(_catalog_payload())
    transport = provider._chat if egress == "chat" else provider._responses
    builders = {
        ("chat", "messages"): "_build_request_body",
        ("chat", "responses"): "_build_responses_request_body",
        ("responses", "messages"): "_build_messages_body",
        ("responses", "responses"): "_build_native_body",
    }
    name = builders[egress, wire]
    routed = _routed_request() if wire == "messages" else _routed_responses_request()
    routed = replace(
        routed,
        request=routed.request.model_copy(update={"model": f"{egress}-selector"}),
    )
    try:
        if warm:
            await provider.list_model_infos()
        with patch.object(transport, name, wraps=getattr(transport, name)) as build:
            executor = ProviderExecutor(
                AsyncMock(side_effect=lambda _, _api_key_number: provider),
            )
            stream = getattr(executor, f"stream_{wire}")(
                routed, raw_log_payload=dict, request_id="opencode-conversion-once"
            )
            assert f"{egress}-ok" in "".join(
                [frame async for event in stream for frame in event.frames]
            )
        assert build.call_count == 1
        assert len(generation) == len(catalog) == 1
    finally:
        await provider.cleanup()


@pytest.mark.asyncio
@pytest.mark.parametrize("wire", ["messages", "responses"])
async def test_executor_converts_subscription_request_once(wire):
    generation = []

    def reply(request):
        generation.append(request)
        return httpx2.Response(
            200,
            headers={"content-type": "text/event-stream"},
            text=_complete_stream("hello"),
        )

    auth = _FakeAuth()
    provider = OpenAICodexProvider(
        _config(),
        auth=auth,
        admission=immediate_admission(),
        transport=httpx2.MockTransport(reply),
    )
    name = "_build_messages_body" if wire == "messages" else "_build_native_body"
    routed = _routed_request() if wire == "messages" else _routed_responses_request()
    try:
        with patch.object(
            provider._responses, name, wraps=getattr(provider._responses, name)
        ) as build:
            executor = ProviderExecutor(
                AsyncMock(side_effect=lambda _, _api_key_number: provider),
            )
            stream = getattr(executor, f"stream_{wire}")(
                routed, raw_log_payload=dict, request_id="subscription-conversion-once"
            )
            assert auth.access_calls == 0
            assert "hello" in "".join(
                [frame async for event in stream for frame in event.frames]
            )
        assert build.call_count == len(generation) == auth.access_calls == 1
    finally:
        await provider.cleanup()