"""Unit tests for the LLM client's transient-error retry."""

from __future__ import annotations

import types

import anthropic

import httpx

import pytest

from felderize import llm

def _make_client():

"""Build an AnthropicClient without constructing a real Anthropic SDK client."""

client = llm.AnthropicClient.__new__(llm.AnthropicClient)

client.model = "test-model"

client.max_tokens = 16

client.verbose = False

return client

def _ok_message(text="OK"):

usage = types.SimpleNamespace(input_tokens=1, output_tokens=1)

return types.SimpleNamespace(

usage=usage, content=[types.SimpleNamespace(text=text)]

)

class _FakeStream:

def __init__(self, behavior):

self._behavior = behavior

def __enter__(self):

return self

def __exit__(self, *a):

return False

def get_final_message(self):

return self._behavior()

def test_retries_on_transient_connection_error(monkeypatch):

monkeypatch.setattr(llm.time, "sleep", lambda s: None) # no real backoff

calls = {"n": 0}

def behavior():

calls["n"] += 1

if calls["n"] == 1:

raise httpx.RemoteProtocolError("peer closed connection")

return _ok_message("recovered")

client = _make_client()

client.client = types.SimpleNamespace(

messages=types.SimpleNamespace(stream=lambda **kw: _FakeStream(behavior))

)

out = client.translate("sys", "user")

assert out == "recovered"

assert calls["n"] == 2 # failed once, succeeded on retry

def test_gives_up_after_max_retries(monkeypatch):

monkeypatch.setattr(llm.time, "sleep", lambda s: None)

def behavior():

raise httpx.ConnectError("refused")

client = _make_client()

client.client = types.SimpleNamespace(

messages=types.SimpleNamespace(stream=lambda **kw: _FakeStream(behavior))

)

with pytest.raises(httpx.ConnectError):

client.translate("sys", "user")

# ---------------------------------------------------------------------------

# Context-window overflow handling

# ---------------------------------------------------------------------------

@pytest.mark.parametrize(

"message, expected",

[

("prompt is too long: 250000 tokens > 200000 maximum", True),

("input length exceeds the context window", True),

("requested 300000 tokens exceeds the maximum allowed", True),

("invalid model: claude-bogus", False),

("credit balance is too low", False),

],

)

def test_is_context_length_error_classification(message, expected):

err = _bad_request(message)

assert llm._is_context_length_error(err) is expected

def _bad_request(message):

response = httpx.Response(400, request=httpx.Request("POST", "http://test"))

return anthropic.BadRequestError(message, response=response, body=None)

def test_translate_raises_prompt_too_large_on_overflow():

def behavior():

raise _bad_request("prompt is too long: 250000 tokens > 200000 maximum")

client = _make_client()

client.client = types.SimpleNamespace(

messages=types.SimpleNamespace(stream=lambda **kw: _FakeStream(behavior))

)

with pytest.raises(llm.PromptTooLargeError):

client.translate("sys", "user")

def test_translate_propagates_other_bad_requests():

def behavior():

raise _bad_request("invalid model: claude-bogus")

client = _make_client()

client.client = types.SimpleNamespace(

messages=types.SimpleNamespace(stream=lambda **kw: _FakeStream(behavior))

)

with pytest.raises(anthropic.BadRequestError):

client.translate("sys", "user")

# ---------------------------------------------------------------------------

# Rate-limit retry + client construction

# ---------------------------------------------------------------------------

def _rate_limit_error():

response = httpx.Response(429, request=httpx.Request("POST", "http://test"))

return anthropic.RateLimitError("slow down", response=response, body=None)

def test_retries_on_rate_limit_then_succeeds(monkeypatch):

monkeypatch.setattr(llm.time, "sleep", lambda s: None)

calls = {"n": 0}

def behavior():

calls["n"] += 1

if calls["n"] == 1:

raise _rate_limit_error()

return _ok_message("recovered")

client = _make_client()

client.client = types.SimpleNamespace(

messages=types.SimpleNamespace(stream=lambda **kw: _FakeStream(behavior))

)

assert client.translate("sys", "user") == "recovered"

assert calls["n"] == 2

def test_create_client_builds_anthropic_client():

from felderize.config import Config

config = Config(model="m", api_key="k", feldera_compiler=None)

client = llm.create_client(config)

assert isinstance(client, llm.AnthropicClient)

assert client.model == "m"

assert client.max_tokens == config.max_tokens