Skip to content

Graph-Native Infrastructure for Context and Accountable AI Systems

3.3 KB
Raw Blame
"""Tests for the Groq LLM provider wrapper (semantica.llms.Groq)."""

from unittest.mock import MagicMock

import pytest

from semantica.llms import Groq
from semantica.utils.exceptions import ProcessingError


def test_construction_stores_model_and_api_key():
    llm = Groq(model="llama-3.1-8b-instant", api_key="fake-key")
    assert llm.model == "llama-3.1-8b-instant"
    assert llm.api_key == "fake-key"


def test_is_available_false_with_no_key(monkeypatch):
    monkeypatch.delenv("GROQ_API_KEY", raising=False)
    llm = Groq(api_key=None)
    assert llm.is_available() is False


def test_generate_raises_clear_error_when_unavailable(monkeypatch):
    monkeypatch.delenv("GROQ_API_KEY", raising=False)
    llm = Groq(api_key=None)
    with pytest.raises(ProcessingError, match="Groq provider not available"):
        llm.generate("hello")


def test_generate_forwards_to_the_real_provider_when_available():
    llm = Groq(api_key="fake-key")
    llm.provider = MagicMock()
    llm.provider.is_available.return_value = True
    llm.provider.generate.return_value = "a fake response"

    result = llm.generate("hello", temperature=0.5)

    assert result == "a fake response"
    llm.provider.generate.assert_called_once_with("hello", temperature=0.5)


def test_generate_structured_forwards_to_the_real_provider():
    llm = Groq(api_key="fake-key")
    llm.provider = MagicMock()
    llm.provider.is_available.return_value = True
    llm.provider.generate_structured.return_value = {"key": "value"}

    result = llm.generate_structured("hello")

    assert result == {"key": "value"}
    llm.provider.generate_structured.assert_called_once_with("hello")


def test_generate_typed_forwards_schema_max_retries_and_extra_kwargs():
    """Also verifies the **kwargs contract: anything beyond schema/max_retries
    (e.g. temperature) must reach the underlying provider unchanged."""
    llm = Groq(api_key="fake-key")
    llm.provider = MagicMock()
    llm.provider.is_available.return_value = True
    fake_schema = object()
    llm.provider.generate_typed.return_value = "typed result"

    result = llm.generate_typed("hello", fake_schema, max_retries=5, temperature=0.5)

    assert result == "typed result"
    llm.provider.generate_typed.assert_called_once_with(
        "hello", fake_schema, max_retries=5, temperature=0.5
    )


def test_generate_structured_raises_clear_error_when_unavailable(monkeypatch):
    monkeypatch.delenv("GROQ_API_KEY", raising=False)
    llm = Groq(api_key=None)
    with pytest.raises(ProcessingError, match="Groq provider not available"):
        llm.generate_structured("hello")


def test_generate_typed_raises_clear_error_when_unavailable(monkeypatch):
    monkeypatch.delenv("GROQ_API_KEY", raising=False)
    llm = Groq(api_key=None)
    with pytest.raises(ProcessingError, match="Groq provider not available"):
        llm.generate_typed("hello", object())


def test_generate_structured_passes_through_list_return():
    """generate_structured() must propagate a top-level JSON array unchanged."""
    llm = Groq(api_key="fake-key")
    llm.provider = MagicMock()
    llm.provider.is_available.return_value = True
    llm.provider.generate_structured.return_value = [{"id": 1}, {"id": 2}]

    result = llm.generate_structured("return a list")

    assert result == [{"id": 1}, {"id": 2}]
    assert isinstance(result, list)