File size: 5,394 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
"""Numbered fallback credentials reach actual HTTP requests across transports."""

import json

import httpx
import httpx2
import pytest
from fastapi.testclient import TestClient

from free_claude_code.config.constants import PROVIDER_MAX_ATTEMPTS_DEFAULT
from free_claude_code.config.settings import Settings
from free_claude_code.providers.admission import ProviderAdmissionController
from tests.api.support import create_test_app
from tests.api.test_delivered_stream_recovery import text_events
from tests.providers.test_anthropic_messages_transport import _sse

KEYS = ["synthetic-first", "synthetic-second", "synthetic-third"]
CUSTOM_ID = "custom_" + "d" * 32


@pytest.fixture(params=[403, 429], ids=["permission-rejection", "rate-limit"])
def upstream(monkeypatch, request):
    calls = []
    failure_status = request.param
    build = ProviderAdmissionController.__init__

    def fast_backoff(self, **kwargs):
        build(self, **kwargs, base_delay=0.1, max_delay=0.1, jitter=0.0)

    monkeypatch.setattr(ProviderAdmissionController, "__init__", fast_backoff)

    def payload(request):
        if request.method == "GET":
            return 200, {"id": "same-model", "data": []}
        token = request.headers.get("x-api-key") or request.headers.get(
            "authorization", ""
        ).removeprefix("Bearer ")
        body = json.loads(request.content)
        calls.append((token, body))
        if token != "synthetic-third":
            return failure_status, {
                "error": {
                    "type": "rate_limit_error"
                    if failure_status == 429
                    else "permission_error",
                    "message": "No quota",
                }
            }
        protocol = (
            "messages"
            if request.url.path.endswith("/messages")
            else "responses"
            if request.url.path.endswith("/responses")
            else "chat"
        )
        events = text_events(protocol, "selected key worked")
        raw = (
            "".join(f"data: {json.dumps(event)}\n\n" for event in events).encode()
            if protocol == "chat"
            else _sse(*events)
        )
        return 200, raw

    def response(request, library):
        status, value = payload(request)
        if isinstance(value, dict):
            return library.Response(status, json=value)
        return library.Response(
            status, headers={"content-type": "text/event-stream"}, content=value
        )

    init = httpx.AsyncClient.__init__
    init2 = httpx2.AsyncClient.__init__

    def local_http(self, *args, **kwargs):
        kwargs["transport"] = httpx.MockTransport(
            lambda request: response(request, httpx)
        )
        init(self, *args, **kwargs)

    def local_http2(self, *args, **kwargs):
        kwargs["transport"] = httpx2.MockTransport(
            lambda request: response(request, httpx2)
        )
        init2(self, *args, **kwargs)

    monkeypatch.setattr(httpx.AsyncClient, "__init__", local_http)
    monkeypatch.setattr(httpx2.AsyncClient, "__init__", local_http2)
    return calls, failure_status


@pytest.mark.parametrize("wire", ["messages", "responses"])
@pytest.mark.parametrize(
    ("provider", "api_format"),
    [
        ("groq", "openai_chat"),
        ("openai_api", "openai_responses"),
        ("anthropic", "anthropic_messages"),
        (CUSTOM_ID, "openai_chat"),
        (CUSTOM_ID, "openai_responses"),
        (CUSTOM_ID, "anthropic_messages"),
    ],
)
def test_fallback_sequence_uses_each_rows_selected_key(
    upstream, provider, api_format, wire
):
    calls, failure_status = upstream
    model = f"{provider}/same-model"
    custom = (
        [
            {
                "provider_id": CUSTOM_ID,
                "display_name": "Gateway",
                "base_url": "https://gateway.example/v1",
                "api_format": api_format,
                "api_keys": KEYS,
            }
        ]
        if provider == CUSTOM_ID
        else []
    )
    settings = Settings(
        MODEL=model,
        GROQ_API_KEY=KEYS,
        OPENAI_API_KEY=KEYS,
        ANTHROPIC_API_KEY=KEYS,
        PROVIDER_RATE_LIMIT=1000,
        PROVIDER_RATE_WINDOW=1,
        FCC_CUSTOM_PROVIDERS=custom,
        MODEL_FALLBACKS=[
            {"model": model, "reasoning": "off", "api_key_number": 2},
            {"model": model, "reasoning": "off", "api_key_number": 3},
        ],
    )
    body = (
        {"messages": [{"role": "user", "content": "hello"}], "max_tokens": 64}
        if wire == "messages"
        else {"input": "hello"}
    )
    app = create_test_app(settings)
    with TestClient(app) as client:
        result = client.post(
            f"/v1/{wire}", json={"model": model, "stream": True, **body}
        )
    assert result.status_code == 200, result.text
    assert "selected key worked" in result.text
    tokens = [token for token, _ in calls]
    assert [
        token
        for index, token in enumerate(tokens)
        if not index or token != tokens[index - 1]
    ] == KEYS
    if failure_status == 429:
        assert tokens == (
            [KEYS[0]] * PROVIDER_MAX_ATTEMPTS_DEFAULT
            + [KEYS[1]] * PROVIDER_MAX_ATTEMPTS_DEFAULT
            + [KEYS[2]]
        )
    assert all(body["model"] == "same-model" for _, body in calls)
    assert all(key not in result.text for key in KEYS)