forked from 0xWheatyz/SPARC
agent-company
5d11f514c0
Reject unsupported LLM model identifiers with HTTP 400 on all analysis endpoints (single, batch, async batch). The SUPPORTED_MODELS list was already defined for the /models endpoint but not enforced on incoming requests. This completes the multi-model support feature by adding the missing server-side validation. Closes leeworks-agents/SPARC#1013 Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
229 lines
7.4 KiB
Python
229 lines
7.4 KiB
Python
"""Tests for FastAPI web service endpoints."""
|
|
|
|
from datetime import datetime
|
|
from unittest.mock import Mock
|
|
|
|
import pytest
|
|
from fastapi.testclient import TestClient
|
|
|
|
from SPARC.api import app
|
|
from SPARC.types import BatchAnalysisResult, CompanyAnalysisResult
|
|
|
|
|
|
@pytest.fixture
|
|
def client():
|
|
"""Create test client."""
|
|
return TestClient(app)
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_analyzer(mocker):
|
|
"""Mock the global analyzer."""
|
|
mock = Mock()
|
|
mocker.patch("SPARC.api._analyzer", mock)
|
|
return mock
|
|
|
|
|
|
class TestHealthEndpoint:
|
|
"""Test health check endpoint."""
|
|
|
|
def test_health_returns_ok(self, client):
|
|
"""Test health endpoint returns healthy status."""
|
|
response = client.get("/health")
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["status"] == "healthy"
|
|
assert data["version"] == "1.0.0"
|
|
assert "timestamp" in data
|
|
|
|
|
|
class TestAnalyzeCompanyEndpoint:
|
|
"""Test single company analysis endpoint."""
|
|
|
|
def test_analyze_company_success(self, client, mock_analyzer):
|
|
"""Test successful company analysis."""
|
|
mock_result = CompanyAnalysisResult(
|
|
company_name="nvidia",
|
|
analysis="Strong AI patent portfolio",
|
|
patent_count=5,
|
|
success=True,
|
|
timestamp=datetime.now(),
|
|
)
|
|
mock_analyzer._analyze_company_safe.return_value = mock_result
|
|
|
|
response = client.get("/analyze/nvidia")
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["company_name"] == "nvidia"
|
|
assert data["analysis"] == "Strong AI patent portfolio"
|
|
assert data["patent_count"] == 5
|
|
assert data["success"] is True
|
|
|
|
def test_analyze_company_failure(self, client, mock_analyzer):
|
|
"""Test company analysis with error."""
|
|
mock_result = CompanyAnalysisResult(
|
|
company_name="unknown",
|
|
analysis="",
|
|
patent_count=0,
|
|
success=False,
|
|
error="No patents found",
|
|
timestamp=datetime.now(),
|
|
)
|
|
mock_analyzer._analyze_company_safe.return_value = mock_result
|
|
|
|
response = client.get("/analyze/unknown")
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["success"] is False
|
|
assert data["error"] == "No patents found"
|
|
|
|
|
|
class TestBatchAnalysisEndpoint:
|
|
"""Test batch analysis endpoint."""
|
|
|
|
def test_batch_analysis_success(self, client, mock_analyzer):
|
|
"""Test successful batch analysis."""
|
|
results = [
|
|
CompanyAnalysisResult(
|
|
company_name="nvidia",
|
|
analysis="Strong portfolio",
|
|
patent_count=5,
|
|
success=True,
|
|
timestamp=datetime.now(),
|
|
),
|
|
CompanyAnalysisResult(
|
|
company_name="amd",
|
|
analysis="Growing portfolio",
|
|
patent_count=3,
|
|
success=True,
|
|
timestamp=datetime.now(),
|
|
),
|
|
]
|
|
mock_batch = BatchAnalysisResult(
|
|
results=results,
|
|
total_companies=2,
|
|
successful=2,
|
|
failed=0,
|
|
timestamp=datetime.now(),
|
|
)
|
|
mock_analyzer.analyze_companies.return_value = mock_batch
|
|
|
|
response = client.post(
|
|
"/analyze/batch",
|
|
json={"companies": ["nvidia", "amd"], "max_workers": 2},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["total_companies"] == 2
|
|
assert data["successful"] == 2
|
|
assert data["failed"] == 0
|
|
assert len(data["results"]) == 2
|
|
|
|
def test_batch_analysis_validation(self, client):
|
|
"""Test batch analysis request validation."""
|
|
# Empty companies list
|
|
response = client.post("/analyze/batch", json={"companies": []})
|
|
assert response.status_code == 422
|
|
|
|
# Too many companies
|
|
response = client.post(
|
|
"/analyze/batch",
|
|
json={"companies": [f"company{i}" for i in range(25)]},
|
|
)
|
|
assert response.status_code == 422
|
|
|
|
# Invalid max_workers
|
|
response = client.post(
|
|
"/analyze/batch",
|
|
json={"companies": ["nvidia"], "max_workers": 10},
|
|
)
|
|
assert response.status_code == 422
|
|
|
|
|
|
class TestAsyncBatchEndpoint:
|
|
"""Test async batch analysis endpoint."""
|
|
|
|
def test_async_batch_creates_job(self, client, mock_analyzer):
|
|
"""Test async endpoint creates a job."""
|
|
response = client.post(
|
|
"/analyze/batch/async",
|
|
json={"companies": ["nvidia", "amd"]},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert "job_id" in data
|
|
assert data["status"] == "pending"
|
|
assert data["total_companies"] == 2
|
|
assert data["progress"] == 0
|
|
|
|
|
|
class TestJobEndpoints:
|
|
"""Test job management endpoints."""
|
|
|
|
def test_get_job_not_found(self, client):
|
|
"""Test getting nonexistent job."""
|
|
response = client.get("/jobs/nonexistent")
|
|
assert response.status_code == 404
|
|
|
|
def test_list_jobs(self, client, mocker):
|
|
"""Test listing jobs."""
|
|
# Clear existing jobs
|
|
mocker.patch.dict("SPARC.api._jobs", {}, clear=True)
|
|
|
|
response = client.get("/jobs")
|
|
assert response.status_code == 200
|
|
assert isinstance(response.json(), list)
|
|
|
|
def test_list_jobs_with_filter(self, client, mocker):
|
|
"""Test listing jobs with status filter."""
|
|
response = client.get("/jobs?status=completed")
|
|
assert response.status_code == 200
|
|
|
|
|
|
class TestModelValidation:
|
|
"""Test that unsupported model identifiers are rejected."""
|
|
|
|
def test_analyze_rejects_unsupported_model(self, client, mock_analyzer):
|
|
"""GET /analyze/{company} with unsupported model returns 400."""
|
|
response = client.get("/analyze/nvidia?model=fake/nonexistent-model")
|
|
assert response.status_code == 400
|
|
assert "Unsupported model" in response.json()["detail"]
|
|
|
|
def test_analyze_accepts_supported_model(self, client, mock_analyzer):
|
|
"""GET /analyze/{company} with a supported model succeeds."""
|
|
mock_result = CompanyAnalysisResult(
|
|
company_name="nvidia",
|
|
analysis="test",
|
|
patent_count=1,
|
|
success=True,
|
|
timestamp=datetime.now(),
|
|
model="anthropic/claude-3.5-sonnet",
|
|
)
|
|
mock_analyzer._analyze_company_safe.return_value = mock_result
|
|
|
|
response = client.get("/analyze/nvidia?model=anthropic/claude-3.5-sonnet")
|
|
assert response.status_code == 200
|
|
|
|
def test_batch_rejects_unsupported_model(self, client, mock_analyzer):
|
|
"""POST /analyze/batch with unsupported model returns 400."""
|
|
response = client.post(
|
|
"/analyze/batch",
|
|
json={"companies": ["nvidia"], "model": "fake/nonexistent-model"},
|
|
)
|
|
assert response.status_code == 400
|
|
assert "Unsupported model" in response.json()["detail"]
|
|
|
|
def test_list_models_returns_supported(self, client):
|
|
"""GET /models returns the allow-list."""
|
|
response = client.get("/models")
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert "models" in data
|
|
assert "default" in data
|
|
assert len(data["models"]) > 0
|
|
assert all("id" in m and "name" in m and "provider" in m for m in data["models"])
|