Skip to content

Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)

Python
8.6 KB
Raw Blame
"""Tests for Groq (OpenAI-compatible) provider."""

from unittest.mock import AsyncMock, MagicMock, patch

import pytest

from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.config.provider_catalog import GROQ_DEFAULT_BASE
from free_claude_code.providers.groq import GroqProvider
from tests.providers.request_factory import make_messages_request
from tests.providers.support import (
    SDKStreamDouble,
    immediate_admission,
    make_provider_config,
)


def make_request(**overrides):
    return make_messages_request("llama-3.3-70b-versatile", **overrides)


@pytest.fixture
def groq_config():
    return make_provider_config(
        api_key="test_groq_key",
        base_url=GROQ_DEFAULT_BASE,
    )


@pytest.fixture
def groq_provider(groq_config):
    return GroqProvider(groq_config, admission=immediate_admission())


def test_init(groq_config):
    """Test provider initialization."""
    with patch(
        "free_claude_code.providers.openai_chat.client.AsyncOpenAI"
    ) as mock_openai:
        provider = GroqProvider(groq_config, admission=immediate_admission())
        assert provider._api_key == "test_groq_key"
        assert provider._base_url == GROQ_DEFAULT_BASE
        mock_openai.assert_called_once()


def test_default_base_url_constant():
    assert GROQ_DEFAULT_BASE == "https://api.groq.com/openai/v1"


@pytest.mark.asyncio
async def test_model_catalog_extracts_documented_token_limits(groq_provider) -> None:
    with patch.object(
        groq_provider,
        "_list_models_payload",
        new=AsyncMock(
            return_value={
                "data": [
                    {
                        "id": "model",
                        "context_window": 131072,
                        "max_completion_tokens": 8192,
                    }
                ]
            }
        ),
    ):
        infos = await groq_provider.list_model_infos()

    assert infos == frozenset(
        {
            ProviderModelInfo(
                "model",
                context_window_tokens=131072,
                max_output_tokens=8192,
            )
        }
    )


def test_build_request_body_basic(groq_provider):
    """Basic request body conversion attaches system message from Claude request."""
    req = make_request()
    body = groq_provider._chat._build_request_body(req)

    assert body["model"] == "llama-3.3-70b-versatile"
    assert body["messages"][0]["role"] == "system"
    assert "max_completion_tokens" in body


def test_build_request_body_replays_reasoning_as_tagged_content(groq_provider):
    request = make_request(
        messages=[
            {"role": "user", "content": "Inspect the file."},
            {
                "role": "assistant",
                "content": [
                    {"type": "thinking", "thinking": "I need to read it first."},
                    {"type": "text", "text": "I will inspect the file."},
                    {
                        "type": "tool_use",
                        "id": "toolu_1",
                        "name": "read_file",
                        "input": {"path": "example.py"},
                    },
                ],
            },
            {
                "role": "user",
                "content": [
                    {
                        "type": "tool_result",
                        "tool_use_id": "toolu_1",
                        "content": "print('hello')",
                    }
                ],
            },
        ]
    )

    body = groq_provider._chat._build_request_body(request)

    assistant = next(
        message for message in body["messages"] if message["role"] == "assistant"
    )
    assert assistant["content"] == (
        "<think>\nI need to read it first.\n</think>\n\nI will inspect the file."
    )
    assert assistant["tool_calls"][0]["id"] == "toolu_1"
    assert body["messages"][-1] == {
        "role": "tool",
        "tool_call_id": "toolu_1",
        "content": "print('hello')",
    }
    assert all(
        "reasoning_content" not in message and "reasoning" not in message
        for message in body["messages"]
    )


def test_build_request_body_global_disable_blocks_reasoning_mapping():
    provider = GroqProvider(
        make_provider_config(
            api_key="test_groq_key",
            base_url=GROQ_DEFAULT_BASE,
        ),
        admission=immediate_admission(),
    )
    req = make_request()
    body = provider._chat._build_request_body(req)

    roles = [m.get("role") for m in body.get("messages", [])]
    assert "assistant_reasoning_content" not in roles


def test_build_request_body_sanitizes_and_remaps_via_mock_converter(groq_provider):
    with patch(
        "free_claude_code.providers.openai_chat.request_policy.build_base_request_body"
    ) as mock_convert:
        mock_convert.return_value = {
            "model": "llama-3.3-70b-versatile",
            "messages": [
                {"role": "user", "name": "bad", "content": "hello"},
                {
                    "role": "assistant",
                    "tool_calls": [],
                    "name": "nope",
                    "content": "ok",
                },
            ],
            "logprobs": True,
            "logit_bias": {"1": -100},
            "top_logprobs": 2,
            "max_tokens": 42,
            "n": 4,
        }
        req = make_request()
        body = groq_provider._chat._build_request_body(req)

    msgs = body["messages"]
    assert msgs[0].get("name") is None and msgs[1].get("name") is None
    for key in ("logprobs", "logit_bias", "top_logprobs"):
        assert key not in body
    assert body.get("max_tokens") is None
    assert body["max_completion_tokens"] == 42
    assert body["n"] == 1


def test_build_request_body_prefers_existing_max_completion_tokens(groq_provider):
    with patch(
        "free_claude_code.providers.openai_chat.request_policy.build_base_request_body"
    ) as mock_convert:
        mock_convert.return_value = {
            "model": "llama-3.3-70b-versatile",
            "messages": [{"role": "user", "content": "x"}],
            "max_completion_tokens": 77,
            "max_tokens": 999,
        }
        body = groq_provider._chat._build_request_body(make_request())

    assert body["max_completion_tokens"] == 77
    assert "max_tokens" not in body


def test_build_request_body_preserves_caller_extra_body(groq_provider):
    req = make_request(extra_body={"metadata": {"user": "u1"}})

    body = groq_provider._chat._build_request_body(req)

    eb = body.get("extra_body")
    assert isinstance(eb, dict)
    assert eb.get("metadata") == {"user": "u1"}


@pytest.mark.asyncio
async def test_stream_messages_text(groq_provider):
    """Text content deltas are emitted as text blocks."""
    req = make_request()

    mock_chunk = MagicMock()
    mock_chunk.choices = [
        MagicMock(
            delta=MagicMock(
                content="Hello back!",
                reasoning_content=None,
                tool_calls=None,
            ),
            finish_reason="stop",
        )
    ]
    mock_chunk.usage = MagicMock(completion_tokens=5, prompt_tokens=10)

    async def mock_stream():
        yield mock_chunk

    with patch.object(
        groq_provider._client.chat.completions, "create", new_callable=AsyncMock
    ) as mock_create:
        mock_create.return_value = SDKStreamDouble(mock_stream())

        events = [event async for event in groq_provider.stream_messages(req)]

        assert any(
            '"text_delta"' in event and "Hello back!" in event for event in events
        )


@pytest.mark.asyncio
async def test_stream_messages_reasoning_content(groq_provider):
    """reasoning_content deltas are emitted as thinking blocks."""
    req = make_request()

    mock_chunk = MagicMock()
    mock_chunk.choices = [
        MagicMock(
            delta=MagicMock(
                content=None,
                reasoning_content="Thinking...",
                tool_calls=None,
            ),
            finish_reason="stop",
        )
    ]
    mock_chunk.usage = MagicMock(completion_tokens=2, prompt_tokens=10)

    async def mock_stream():
        yield mock_chunk

    with patch.object(
        groq_provider._client.chat.completions, "create", new_callable=AsyncMock
    ) as mock_create:
        mock_create.return_value = SDKStreamDouble(mock_stream())

        events = [event async for event in groq_provider.stream_messages(req)]

        assert any(
            '"thinking_delta"' in event and "Thinking..." in event for event in events
        )


@pytest.mark.asyncio
async def test_cleanup(groq_provider):
    groq_provider._client = AsyncMock()

    await groq_provider.cleanup()

    groq_provider._client.close.assert_called_once()