1
0

feat: code quality audit + autoresearch integration + infra hardening (#150)

This commit is contained in:
Alexander Whitestone
2026-03-08 12:50:44 -04:00
committed by GitHub
parent fd0ede0d51
commit ae3bb1cc21
186 changed files with 5129 additions and 3289 deletions

View File

@@ -10,17 +10,17 @@ from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from infrastructure.router.cascade import CascadeRouter, Provider, ProviderStatus, CircuitState
from infrastructure.router.cascade import CascadeRouter, CircuitState, Provider, ProviderStatus
class TestCascadeRouterFunctional:
"""Functional tests for Cascade Router with mocked providers."""
@pytest.fixture
def router(self):
"""Create a router with no config file."""
return CascadeRouter(config_path=Path("/nonexistent"))
@pytest.fixture
def mock_healthy_provider(self):
"""Create a mock healthy provider."""
@@ -32,7 +32,7 @@ class TestCascadeRouterFunctional:
models=[{"name": "test-model", "default": True}],
)
return provider
@pytest.fixture
def mock_failing_provider(self):
"""Create a mock failing provider."""
@@ -44,12 +44,12 @@ class TestCascadeRouterFunctional:
models=[{"name": "test-model", "default": True}],
)
return provider
@pytest.mark.asyncio
async def test_successful_completion_single_provider(self, router, mock_healthy_provider):
"""Test successful completion with a single working provider."""
router.providers = [mock_healthy_provider]
# Mock the provider's call method
with patch.object(router, "_try_provider") as mock_try:
mock_try.return_value = {
@@ -57,16 +57,16 @@ class TestCascadeRouterFunctional:
"model": "test-model",
"latency_ms": 100.0,
}
result = await router.complete(
messages=[{"role": "user", "content": "Hi"}],
)
assert result["content"] == "Hello, world!"
assert result["provider"] == "test-healthy"
assert result["model"] == "test-model"
assert result["latency_ms"] == 100.0
@pytest.mark.asyncio
async def test_failover_to_second_provider(self, router):
"""Test failover when first provider fails."""
@@ -85,23 +85,23 @@ class TestCascadeRouterFunctional:
models=[{"name": "model", "default": True}],
)
router.providers = [provider1, provider2]
call_count = [0]
async def side_effect(*args, **kwargs):
call_count[0] += 1
if call_count[0] <= router.config.max_retries_per_provider:
raise RuntimeError("Connection failed")
return {"content": "Backup works!", "model": "model"}
with patch.object(router, "_try_provider", side_effect=side_effect):
result = await router.complete(
messages=[{"role": "user", "content": "Hi"}],
)
assert result["content"] == "Backup works!"
assert result["provider"] == "backup"
@pytest.mark.asyncio
async def test_all_providers_fail_raises_error(self, router):
"""Test that RuntimeError is raised when all providers fail."""
@@ -113,15 +113,15 @@ class TestCascadeRouterFunctional:
models=[{"name": "model", "default": True}],
)
router.providers = [provider]
with patch.object(router, "_try_provider") as mock_try:
mock_try.side_effect = RuntimeError("Always fails")
with pytest.raises(RuntimeError) as exc_info:
await router.complete(messages=[{"role": "user", "content": "Hi"}])
assert "All providers failed" in str(exc_info.value)
@pytest.mark.asyncio
async def test_circuit_breaker_opens_after_failures(self, router):
"""Test circuit breaker opens after threshold failures."""
@@ -134,14 +134,14 @@ class TestCascadeRouterFunctional:
)
router.providers = [provider]
router.config.circuit_breaker_failure_threshold = 3
# Record 3 failures
for _ in range(3):
router._record_failure(provider)
assert provider.circuit_state == CircuitState.OPEN
assert provider.status == ProviderStatus.UNHEALTHY
def test_metrics_tracking(self, router):
"""Test that metrics are tracked correctly."""
provider = Provider(
@@ -151,14 +151,14 @@ class TestCascadeRouterFunctional:
priority=1,
)
router.providers = [provider]
# Record some successes and failures
router._record_success(provider, 100.0)
router._record_success(provider, 200.0)
router._record_failure(provider)
metrics = router.get_metrics()
assert len(metrics["providers"]) == 1
p_metrics = metrics["providers"][0]
assert p_metrics["metrics"]["total_requests"] == 3
@@ -166,7 +166,7 @@ class TestCascadeRouterFunctional:
assert p_metrics["metrics"]["failed"] == 1
# Average latency is over ALL requests (including failures with 0 latency)
assert p_metrics["metrics"]["avg_latency_ms"] == 100.0 # (100+200+0)/3
@pytest.mark.asyncio
async def test_skips_disabled_providers(self, router):
"""Test that disabled providers are skipped."""
@@ -185,23 +185,23 @@ class TestCascadeRouterFunctional:
models=[{"name": "model", "default": True}],
)
router.providers = [disabled, enabled]
# The router should try enabled provider
with patch.object(router, "_try_provider") as mock_try:
mock_try.return_value = {"content": "Success", "model": "model"}
result = await router.complete(messages=[{"role": "user", "content": "Hi"}])
assert result["provider"] == "enabled"
class TestProviderAvailability:
"""Test provider availability checking."""
@pytest.fixture
def router(self):
return CascadeRouter(config_path=Path("/nonexistent"))
def test_openai_available_with_key(self, router):
"""Test OpenAI provider is available when API key is set."""
provider = Provider(
@@ -211,9 +211,9 @@ class TestProviderAvailability:
priority=1,
api_key="sk-test123",
)
assert router._check_provider_available(provider) is True
def test_openai_unavailable_without_key(self, router):
"""Test OpenAI provider is unavailable without API key."""
provider = Provider(
@@ -223,9 +223,9 @@ class TestProviderAvailability:
priority=1,
api_key=None,
)
assert router._check_provider_available(provider) is False
def test_anthropic_available_with_key(self, router):
"""Test Anthropic provider is available when API key is set."""
provider = Provider(
@@ -235,17 +235,17 @@ class TestProviderAvailability:
priority=1,
api_key="sk-test123",
)
assert router._check_provider_available(provider) is True
class TestRouterConfigLoading:
"""Test router configuration loading."""
def test_loads_timeout_from_config(self, tmp_path):
"""Test that timeout is loaded from config."""
import yaml
config = {
"cascade": {
"timeout_seconds": 60,
@@ -253,18 +253,18 @@ class TestRouterConfigLoading:
},
"providers": [],
}
config_path = tmp_path / "providers.yaml"
config_path.write_text(yaml.dump(config))
router = CascadeRouter(config_path=config_path)
assert router.config.timeout_seconds == 60
assert router.config.max_retries_per_provider == 3
def test_uses_defaults_without_config(self):
"""Test that defaults are used when config file doesn't exist."""
router = CascadeRouter(config_path=Path("/nonexistent"))
assert router.config.timeout_seconds == 30
assert router.config.max_retries_per_provider == 2