Files
jpmschweitzerandClaude 78066fab1b style: apply ruff's automatic fixes and formatter
Mechanical only, and separated from the judgment calls that follow so the
reviewable changes are not buried in a 98-file whitespace diff.

227 automatic fixes: 60 blank lines carrying whitespace, 60 unsorted import
blocks, 34 Optional[X] to X | None, 28 unused imports, 16 deprecated typing
imports, 12 datetime.timezone.utc to datetime.UTC, and assorted smaller
modernisations. Then `ruff format` over src and tests: 98 files reformatted,
35 already conforming.

No file among the unused-import findings defines __all__ or is an __init__.py,
so nothing here removes a re-export.

`make test`: 658 passed, unchanged from HEAD.

Two things observed while verifying, neither addressed here:

`pytest tests/` cannot collect — tests/e2e/test_orchestration_e2e.py uses an
`e2e` marker that is not registered, and the config is strict about markers.
This fails identically at HEAD, so it predates this change; `make test` passes
because it ignores tests/e2e, tests/integration and tests/contracts.

test_tatlock_tool_call_logging_calculator is flaky. It failed once in a full run
with these changes and passed on the next, passes in isolation with them, and
fails in isolation at HEAD. It is order- or timing-dependent, not a regression
from this commit — established by running the full suite both ways rather than
by reasoning about which change could have caused it.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-08-11 17:25:18 +02:00

125 lines
3.6 KiB
Python

"""
Tests for model registry.
"""
import pytest
from src.agents.lorem_tester import LoremTesterAgent
from src.agents.registry import ModelRegistry
from src.agents.tatlock import TatlockAgent
from src.core.exceptions import ModelNotFoundError
@pytest.mark.unit
@pytest.mark.asyncio
async def test_list_models():
"""Test listing all available models."""
models = await ModelRegistry.list_models()
# Should have both models
assert len(models) == 2
# Check model IDs
model_ids = [m["id"] for m in models]
assert "lorem-tester" in model_ids
assert "Tatlock" in model_ids
# Check structure
for model in models:
assert "id" in model
assert "object" in model
assert model["object"] == "model"
assert "created" in model
assert "owned_by" in model
assert "capabilities" in model
assert "description" in model
@pytest.mark.unit
@pytest.mark.asyncio
async def test_lorem_tester_capabilities():
"""Test lorem-tester model capabilities."""
models = await ModelRegistry.list_models()
lorem_model = next(m for m in models if m["id"] == "lorem-tester")
capabilities = lorem_model["capabilities"]
# Lorem Tester should have all features
assert capabilities["streaming"] is True
assert capabilities["reasoning"] is True
assert capabilities["tools"] is True
assert capabilities["vision"] is False
assert capabilities["audio"] is False
@pytest.mark.unit
@pytest.mark.asyncio
async def test_tatlock_capabilities():
"""Test tatlock model capabilities."""
models = await ModelRegistry.list_models()
tatlock_model = next(m for m in models if m["id"] == "Tatlock")
capabilities = tatlock_model["capabilities"]
# Tatlock Phase 1 - basic streaming, reasoning, and permanent tools
assert capabilities["streaming"] is True
assert capabilities["reasoning"] is True # Basic reasoning summaries
assert capabilities["tools"] is True # Permanent tools: calculator, date/time, search
assert capabilities["vision"] is False # Future
assert capabilities["audio"] is False # Future
@pytest.mark.unit
def test_get_agent_lorem_tester():
"""Test getting lorem-tester agent instance."""
agent = ModelRegistry.get_agent("lorem-tester")
assert isinstance(agent, LoremTesterAgent)
@pytest.mark.unit
def test_get_agent_tatlock():
"""Test getting tatlock agent instance."""
agent = ModelRegistry.get_agent("Tatlock")
assert isinstance(agent, TatlockAgent)
@pytest.mark.unit
def test_get_agent_not_found():
"""Test getting non-existent agent raises error."""
with pytest.raises(ModelNotFoundError) as exc_info:
ModelRegistry.get_agent("nonexistent-model")
assert "nonexistent-model" in str(exc_info.value)
@pytest.mark.unit
def test_model_exists():
"""Test checking if model exists."""
assert ModelRegistry.model_exists("lorem-tester") is True
assert ModelRegistry.model_exists("Tatlock") is True
assert ModelRegistry.model_exists("nonexistent") is False
@pytest.mark.unit
@pytest.mark.asyncio
async def test_get_model_info():
"""Test getting detailed model information."""
info = await ModelRegistry.get_model_info("lorem-tester")
assert info["id"] == "lorem-tester"
assert info["object"] == "model"
assert "created" in info
assert "owned_by" in info
assert "capabilities" in info
assert "description" in info
@pytest.mark.unit
@pytest.mark.asyncio
async def test_get_model_info_not_found():
"""Test getting info for non-existent model raises error."""
with pytest.raises(ModelNotFoundError):
await ModelRegistry.get_model_info("nonexistent-model")