model-router-cli 1.0.0__py3-none-any.whl

tests/test_e2e.py

@@ -0,0 +1,127 @@
+import pytest
+from httpx import AsyncClient, ASGITransport
+from main import app
+from app.storage.database import init_db
+
+
+@pytest.fixture(autouse=True)
+async def setup_db():
+    await init_db()
+
+
+@pytest.mark.asyncio
+async def test_api_health():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as client:
+        res = await client.get("/api/health")
+        assert res.status_code == 200
+        data = res.json()
+        assert data["status"] == "healthy"
+
+
+@pytest.mark.asyncio
+async def test_api_route_only():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as client:
+        payload = {"prompt": "Write a Python script to benchmark models", "policy": "balanced"}
+        res = await client.post("/api/route", json=payload)
+        assert res.status_code == 200
+        data = res.json()
+        assert "decision" in data
+        assert "analysis" in data
+        assert data["analysis"]["task_type"] == "CODING"
+
+
+@pytest.mark.asyncio
+async def test_api_generate_end_to_end():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as client:
+        payload = {"prompt": "Debug this memory leak in python subprocess", "policy": "balanced"}
+        res = await client.post("/api/generate", json=payload)
+        assert res.status_code == 200
+        data = res.json()
+        assert "response" in data
+        assert "metrics" in data
+        assert len(data["response"]["content"]) > 0
+
+
+@pytest.mark.asyncio
+async def test_api_models_list():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as client:
+        res = await client.get("/api/models")
+        assert res.status_code == 200
+        models = res.json()
+        assert len(models) >= 3
+
+
+@pytest.mark.asyncio
+async def test_api_analytics():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as client:
+        res = await client.get("/api/analytics")
+        assert res.status_code == 200
+        data = res.json()
+        assert "total_requests" in data
+        assert "savings" in data
+
+
+@pytest.mark.asyncio
+async def test_api_traffic_export_json_contains_audit_fields():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as client:
+        generate_res = await client.post(
+            "/api/generate",
+            json={"prompt": "Write a Python function for a traffic export"},
+        )
+        assert generate_res.status_code == 200
+
+        export_res = await client.get("/api/traffic/export?format=json")
+
+    assert export_res.status_code == 200
+    assert export_res.headers["content-type"].startswith("application/json")
+    assert "attachment" in export_res.headers["content-disposition"]
+    records = export_res.json()
+    assert records
+    assert {
+        "timestamp",
+        "request_id",
+        "prompt_preview",
+        "task_type",
+        "complexity",
+        "selected_model",
+        "input_tokens",
+        "output_tokens",
+        "total_tokens",
+        "cost_saved",
+        "total_latency_ms",
+    }.issubset(records[0])
+
+
+@pytest.mark.asyncio
+async def test_api_traffic_export_csv_returns_downloadable_rows():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as client:
+        generate_res = await client.post(
+            "/api/generate",
+            json={"prompt": "Summarize this traffic record"},
+        )
+        assert generate_res.status_code == 200
+
+        export_res = await client.get("/api/traffic/export?format=csv")
+
+    assert export_res.status_code == 200
+    assert export_res.headers["content-type"].startswith("text/csv")
+    assert "traffic-export.csv" in export_res.headers["content-disposition"]
+    lines = export_res.text.splitlines()
+    assert lines[0].startswith("timestamp,request_id,prompt_preview,")
+    assert len(lines) >= 2
+
+
+@pytest.mark.asyncio
+async def test_api_traffic_export_rejects_unknown_format():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as client:
+        export_res = await client.get("/api/traffic/export?format=xml")
+
+    assert export_res.status_code == 422

tests/test_providers.py

@@ -0,0 +1,21 @@
+import pytest
+from app.providers.mock_provider import MockProvider
+
+
+@pytest.mark.asyncio
+async def test_mock_provider_generate():
+    provider = MockProvider()
+    resp = await provider.generate("Write a quick Python sort function", model_id="mock-fast")
+    assert resp.is_mock is True
+    assert "DEMO/MOCK" in resp.content
+    assert resp.input_tokens > 0
+    assert resp.output_tokens > 0
+    assert resp.provider_latency_ms > 0
+
+
+@pytest.mark.asyncio
+async def test_mock_provider_health():
+    provider = MockProvider()
+    health = await provider.check_health()
+    assert health["status"] == "CONNECTED"
+    assert "mock-fast" in health["models_available"]

tests/test_router.py

@@ -0,0 +1,78 @@
+import pytest
+from app.models.schemas import ModelMetadata, ModelTier, RequestAnalysis, TaskType, PriorityLevel
+from app.router.scoring import filter_candidate_models, compute_candidate_score
+from app.router.engine import route_request
+
+
+@pytest.fixture
+def sample_models():
+    return [
+        ModelMetadata(
+            id="mock-fast",
+            name="Mock Fast",
+            provider="mock",
+            tier=ModelTier.FAST,
+            context_window=8192,
+            supports_coding=True,
+            supports_reasoning=False,
+            quality_score=0.75,
+            speed_score=0.98,
+            cost_per_input_token=0.0,
+            cost_per_output_token=0.0,
+        ),
+        ModelMetadata(
+            id="mock-power",
+            name="Mock Power",
+            provider="mock",
+            tier=ModelTier.POWER,
+            context_window=128000,
+            supports_coding=True,
+            supports_reasoning=True,
+            quality_score=0.98,
+            speed_score=0.60,
+            cost_per_input_token=0.000005,
+            cost_per_output_token=0.000015,
+        ),
+    ]
+
+
+def test_candidate_filtering_context_overflow(sample_models):
+    large_analysis = RequestAnalysis(
+        task_type=TaskType.LONG_CONTEXT,
+        complexity=0.7,
+        context_size=15000,  # exceeds mock-fast 8192
+    )
+    eligible, rejected = filter_candidate_models(sample_models, large_analysis)
+    assert len(eligible) == 1
+    assert eligible[0].id == "mock-power"
+    assert "mock-fast" in rejected
+
+
+def test_scoring_weights(sample_models):
+    analysis = RequestAnalysis(
+        task_type=TaskType.CODING,
+        complexity=0.3,
+        latency_priority=PriorityLevel.HIGH,
+        cost_sensitivity=PriorityLevel.HIGH,
+    )
+    weights = {"quality_weight": 0.1, "cost_weight": 0.5, "speed_weight": 0.4, "capability_weight": 0.0, "reliability_weight": 0.0}
+    score_fast = compute_candidate_score(sample_models[0], analysis, weights)
+    score_power = compute_candidate_score(sample_models[1], analysis, weights)
+    assert score_fast.overall_score > score_power.overall_score
+
+
+def test_routing_decision_explainability(sample_models):
+    analysis = RequestAnalysis(
+        task_type=TaskType.DEBUGGING,
+        complexity=0.85,
+        complexity_label=PriorityLevel.HIGH,
+        reasoning_required=True,
+        coding_required=True,
+        quality_requirement=PriorityLevel.HIGH,
+    )
+    weights = {"quality_weight": 0.6, "cost_weight": 0.1, "speed_weight": 0.1, "capability_weight": 0.1, "reliability_weight": 0.1}
+    decision = route_request(analysis, sample_models, weights, policy_name="highest_quality")
+    assert decision.selected_model == "mock-power"
+    assert decision.confidence > 0.70
+    assert len(decision.reasons) > 0
+    assert any("DEBUGGING" in r for r in decision.reasons)