Add API tests for export endpoints (CSV and PDF)

Covers GET /export/{company_name} and /export/{company_name}/pdf with
13 test cases: successful export, 404 on missing data, auth enforcement,
filename sanitization, XML-special character handling in PDF, and
multi-row output validation.

Closes leeworks-agents/SPARC#1655

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

ROADMAP.md

@@ -7,131 +7,86 @@ Semiconductor Patent & Analytics Report Core -- development priorities.
 SPARC is a patent analysis platform with a working end-to-end pipeline:
 Python/FastAPI backend, React/TypeScript frontend, PostgreSQL for persistence
 and caching, Docker Compose for local development, and Gitea Actions CI/CD for
-image builds and testing. Core features include patent retrieval via SerpAPI,
+image builds. Core features (patent retrieval via SerpAPI, PDF parsing, LLM
-PDF parsing, LLM analysis via OpenRouter (multi-model: Claude, GPT-4o, Gemini,
+analysis via OpenRouter/Claude, batch processing, JWT authentication, analytics
-Llama), batch processing, JWT authentication, analytics dashboard with patent
+dashboard) are all implemented and functional.
-trend charts, scheduled recurring analysis with alerting, webhook notifications
-(Slack/Discord), CSV and PDF export, S3/MinIO storage, side-by-side company
-comparison, and dark mode.
-
----
-
-## Completed
-
-Items that have been implemented and merged into main.
-
-### Security hardening
-
-- ~~Rotate default JWT secret.~~ Startup check refuses to start with the
-  default secret in non-development environments.
-- ~~CORS allow-origins are hardcoded.~~ Allowed origins are now configurable
-  via environment variable.
-- ~~Database credentials in docker-compose.yml.~~ Compose references `.env`
-  for sensitive values.
-
-### Error handling and resilience
-
-- ~~`get_db_client()` creates a new `DatabaseClient` on every call.~~ Refactored
-  to a shared pooled singleton initialized at startup.
-- ~~No rate limiting on auth endpoints.~~ Rate limiting middleware added to
-  `/auth/login` and `/auth/register`.
-
-### Test coverage
-
-- ~~API tests bypass authentication.~~ JWT auth integration tests added (33
-  cases covering registration, login, protected routes, token refresh, and
-  admin-only endpoints).
-- ~~No test stage in CI.~~ Gitea Actions workflow now runs `pytest` and gates
-  the build.
-- ~~No linting or type checking in CI.~~ `ruff` (Python) and `tsc --noEmit`
-  (TypeScript) added to CI pipeline.
-
-### Backend
-
-- ~~Add structured logging.~~ Python `logging` module used throughout.
-- ~~Make LLM model configurable.~~ `MODEL` environment variable accepted;
-  multi-model support with per-analysis selection (GPT-4o, Gemini, Claude,
-  Llama).
-- ~~SERP cache TTL hardcoded.~~ `SERP_CACHE_TTL_HOURS` exposed as env var.
-- ~~Patent PDF storage.~~ S3/MinIO object storage backend added alongside
-  local filesystem. Volume mount requirement documented.
-- ~~`analyze_single_patent` assumes local file.~~ Auto-download from cached
-  metadata link integrated.
-- ~~`Patent.patent_id` typed as `int`.~~ Fixed to `str`.
-
-### Frontend
-
-- ~~No loading/error states.~~ Skeleton loaders and error states added to
-  Batch and Analytics pages.
-- ~~No dark mode.~~ Full dark mode support with theme-aware chart colors.
-- ~~Missing lockfile.~~ `package-lock.json` committed.
-
-### Features (formerly P3)
-
-- ~~Export analysis reports.~~ CSV and PDF export endpoints implemented.
-- ~~Comparison view.~~ Side-by-side company patent portfolio comparison added.
-- ~~Scheduled/recurring analysis.~~ APScheduler-based periodic re-analysis
-  with configurable interval and change-threshold alerting.
-- ~~Webhook/notification support.~~ Slack, Discord, and generic HTTP POST
-  webhooks with retry logic.
-- ~~Multi-model support.~~ Model picker in Analysis and Batch pages; backend
-  allow-list validation.
-- ~~Patent trend charts.~~ Filing frequency and category distribution
-  visualizations added to Analytics page.
-- ~~OpenAPI client generation.~~ TypeScript API client auto-generated from
-  FastAPI spec with CI freshness check.
 
 ---
 
 ## P1 -- High Priority
 
-These items address correctness, reliability, and coverage gaps that should be
+These items address correctness, security, and reliability gaps that should be
 resolved before broader production use.
 
-### Resilience
+### Security hardening
 
-- **`_jobs` dict is in-memory only.** Job state is lost on API restart.
+- **Rotate default JWT secret.** `auth.py` ships a fallback
-  Persist job status in PostgreSQL or Redis so async batch results survive
+  `sparc-secret-key-change-in-production` that will be used if `JWT_SECRET` is
-  restarts.
+  unset. Add a startup check that refuses to start with the default secret in
+  non-development environments.
+- **CORS allow-origins are hardcoded.** `api.py` only permits
+  `localhost:3000` and `localhost:5173`. Make the allowed origins configurable
+  via environment variable so the dashboard works when deployed behind a real
+  domain.
+- **Database credentials in docker-compose.yml.** The compose file embeds
+  `postgres:postgres` in plain text. Reference a `.env` file or Docker secrets
+  instead.
 
-### Test coverage gaps
+### Error handling and resilience
 
-- **Export endpoint tests.** The CSV and PDF export endpoints (`/export/`)
+- **`get_db_client()` in `auth.py` creates a new `DatabaseClient` on every
-  lack test coverage. Add tests covering auth, success, 404, and edge cases.
+  call.** This bypasses the connection pool and can exhaust database
-  *(Issue #1655)*
+  connections under load. Refactor to share a single pooled client.
-- **Tracked company admin endpoint tests.** The `/admin/tracked` CRUD
+- **`_jobs` dict is in-memory only.** Job state is lost on API restart. Persist
-  endpoints and scheduler integration lack test coverage. *(Issue #1656)*
+  job status in PostgreSQL or Redis so async batch results survive restarts.
+- **No rate limiting on auth endpoints.** `/auth/login` and `/auth/register`
+  are unprotected against brute-force or abuse. Add rate limiting middleware.
+
+### Test coverage for auth and admin
+
+- The existing API tests (`tests/test_api.py`) bypass authentication entirely.
+  Add tests that exercise the JWT flow: registration, login, protected-route
+  access, token refresh, and admin-only endpoints.
 
 ---
 
 ## P2 -- Medium Priority
 
-Improvements to reliability, test coverage, and code quality.
+Improvements to usability, performance, and developer experience.
 
-### Test coverage
+### Backend
 
-- **Webhook integration tests.** The retry logic, Slack/Discord payload
+- **Add structured logging.** Replace `print()` calls throughout `analyzer.py`,
-  format, and multi-URL dispatch in `webhooks.py` need test coverage.
+  `serp_api.py`, and `llm.py` with Python `logging` so log levels and
-  *(Issue #1657)*
+  formatting are consistent.
-- **S3/MinIO storage backend tests.** `storage.py` has local filesystem tests
+- **Make LLM model configurable.** `llm.py` hardcodes
-  but no unit tests for the S3 backend (read, write, exists, delete,
+  `anthropic/claude-3.5-sonnet`. Accept a `MODEL` environment variable to allow
-  error handling). *(Issue #1660)*
+  switching models without code changes.
-- **`analyze_single_patent` auto-download path tests.** The auto-download
+- **SERP cache TTL is hardcoded to 24 hours.** Expose `SERP_CACHE_TTL_HOURS`
-  fallback (cache lookup, PDF download, FileNotFoundError) in
+  as an environment variable in `config.py`.
-  `analyzer.py` lacks test coverage. *(Issue #1661)*
+- **Patent PDF storage.** PDFs are saved to a local `patents/` directory. For
+  containerized deployments, consider object storage (S3/MinIO) or at minimum
+  document the volume mount requirement more prominently.
+- **`analyze_single_patent` assumes local file path.** The method constructs
+  `patents/{patent_id}.pdf` and reads from disk, but does not download the PDF
+  first. Either integrate the download step or document the prerequisite.
+- **`Patent.patent_id` typed as `int` in `types.py` but used as `str`
+  everywhere.** Fix the type annotation to `str`.
 
-### Code quality
+### Frontend
 
-- **Scheduler creates its own DatabaseClient.** `scheduler.py` bypasses the
+- **No loading/error states on several pages.** The Batch and Analytics pages
-  application-level pooled client, creating a new connection on every tick.
+  would benefit from skeleton loaders and user-friendly error messages.
-  Refactor to use `get_db_client()`. *(Issue #1658)*
+- **No dark mode.** Tailwind is configured but no dark variant is applied.
+- **Missing `package-lock.json` or `pnpm-lock.yaml`.** The frontend has no
+  lockfile committed, leading to non-reproducible builds.
 
-### API improvements
+### CI/CD
 
-- **API pagination.** The `/analyze/batch` and `/jobs` endpoints could benefit
+- **No test stage in the Gitea Actions workflow.** `build.yaml` builds and
-  from cursor-based pagination for large result sets.
+  pushes images but never runs `pytest`. Add a test job that gates the build.
-- **Request validation improvements.** Add stricter input validation for
+- **No linting or type checking.** Add `ruff` (Python) and `tsc --noEmit`
-  company names (disallow special characters, enforce length limits).
+  (TypeScript) to CI.
 
 ---
 
@@ -139,20 +94,23 @@ Improvements to reliability, test coverage, and code quality.
 
 Lower-urgency enhancements and future features.
 
-- **Historical analysis diffing.** Show what changed between two analysis runs
+- **Export analysis reports.** Allow users to download analysis results as PDF
-  for the same company, highlighting new patents and score shifts.
+  or CSV from the dashboard.
-- **Patent classification tagging.** Automatically tag patents by technology
+- **Comparison view.** Side-by-side comparison of two companies' patent
-  domain (AI, semiconductors, materials science) using LLM classification.
+  portfolios.
-- **User-level API keys.** Allow users to generate personal API keys for
+- **Scheduled/recurring analysis.** Periodically re-analyze tracked companies
-  programmatic access without JWT token refresh.
+  and alert on significant changes.
-- **Batch export.** Export analysis results for multiple companies at once as
+- **Webhook/notification support.** Send alerts (Slack, Discord, email) when
-  a ZIP archive.
+  batch jobs complete or when a company's innovation score changes
-- **Rate limiting dashboard.** Surface rate limit status and usage statistics
+  significantly.
-  in the admin panel.
+- **Multi-model support.** Let users choose between LLM providers per analysis
-- **Async webhook delivery.** Move webhook delivery to a background task queue
+  (e.g., GPT-4o, Gemini, Claude) and compare outputs.
-  (e.g., Celery, arq) to avoid blocking the scheduler.
+- **Patent trend charts.** Visualize patent filing frequency and technology
-- **Multi-tenant support.** Scope analysis results and tracked companies per
+  category distribution over time in the Analytics page.
-  user or organization.
+- **API pagination.** The `/analyze/batch` and `/jobs` endpoints could benefit
+  from cursor-based pagination for large result sets.
+- **OpenAPI client generation.** Auto-generate the TypeScript API client from
+  the FastAPI OpenAPI spec to keep frontend types in sync.
 
 ---
 

tests/test_export.py

@@ -0,0 +1,224 @@
+"""Tests for export endpoints: CSV and PDF export of analysis results.
+
+Covers issue #1655:
+- GET /export/{company_name} (CSV export)
+- GET /export/{company_name}/pdf (PDF export)
+
+All tests mock the database layer and use JWT auth fixtures from test_auth patterns.
+"""
+
+from datetime import datetime, timezone
+from unittest.mock import MagicMock, patch
+
+import pytest
+from fastapi.testclient import TestClient
+
+from SPARC.api import app
+from SPARC.auth import create_access_token
+
+
+@pytest.fixture
+def client():
+    """Create test client."""
+    return TestClient(app)
+
+
+@pytest.fixture(autouse=True)
+def mock_db():
+    """Mock the database client used by export and auth endpoints."""
+    db = MagicMock()
+
+    # Default: user exists for auth
+    db.get_user_by_id.return_value = {
+        "id": 1,
+        "email": "user@test.com",
+        "role": "user",
+        "created_at": datetime(2025, 1, 1, tzinfo=timezone.utc),
+    }
+
+    # Mock get_conn for export queries
+    mock_cursor = MagicMock()
+    mock_conn = MagicMock()
+    mock_conn.cursor.return_value.__enter__ = MagicMock(return_value=mock_cursor)
+    mock_conn.cursor.return_value.__exit__ = MagicMock(return_value=False)
+    db.get_conn.return_value.__enter__ = MagicMock(return_value=mock_conn)
+    db.get_conn.return_value.__exit__ = MagicMock(return_value=False)
+    db._mock_cursor = mock_cursor
+
+    with patch("SPARC.api.get_db_client", return_value=db), \
+         patch("SPARC.auth.get_db_client", return_value=db):
+        yield db
+
+
+def _auth_header():
+    """Create an Authorization header with a valid access token."""
+    token = create_access_token(1, "user@test.com", "user")
+    return {"Authorization": f"Bearer {token}"}
+
+
+def _sample_rows():
+    """Return sample llm_messages rows as tuples (matching cursor.fetchall format)."""
+    return [
+        (
+            "NVIDIA",
+            "company_analysis",
+            "anthropic/claude-3.5-sonnet",
+            "Strong AI patent portfolio with focus on GPU architectures.",
+            datetime(2025, 6, 15, 10, 30, 0),
+        ),
+        (
+            "NVIDIA",
+            "patent_analysis",
+            "openai/gpt-4o",
+            "Patent US-12345678-B2 covers novel tensor core design.",
+            datetime(2025, 6, 14, 9, 0, 0),
+        ),
+    ]
+
+
+class TestCSVExport:
+    """GET /export/{company_name} -- CSV export."""
+
+    def test_csv_export_success(self, client, mock_db):
+        """Valid company with results returns a CSV file."""
+        mock_db._mock_cursor.fetchall.return_value = _sample_rows()
+
+        response = client.get("/export/NVIDIA", headers=_auth_header())
+
+        assert response.status_code == 200
+        assert response.headers["content-type"].startswith("text/csv")
+        assert "attachment" in response.headers.get("content-disposition", "")
+        assert "sparc_nvidia_export.csv" in response.headers["content-disposition"]
+
+        # Verify CSV content (CSV uses \r\n line endings)
+        lines = response.text.strip().split("\n")
+        assert len(lines) == 3  # header + 2 data rows
+        assert lines[0].strip() == "company_name,analysis_type,model,analysis,timestamp"
+        assert "NVIDIA" in lines[1]
+        assert "company_analysis" in lines[1]
+
+    def test_csv_export_no_results_returns_404(self, client, mock_db):
+        """Unknown company returns 404."""
+        mock_db._mock_cursor.fetchall.return_value = []
+
+        response = client.get("/export/nonexistent", headers=_auth_header())
+
+        assert response.status_code == 404
+        assert "No analysis results found" in response.json()["detail"]
+
+    def test_csv_export_unauthenticated_returns_401(self, client):
+        """Request without token returns 401."""
+        response = client.get("/export/NVIDIA")
+        assert response.status_code == 401
+
+    def test_csv_export_invalid_token_returns_401(self, client):
+        """Request with invalid token returns 401."""
+        response = client.get(
+            "/export/NVIDIA",
+            headers={"Authorization": "Bearer invalid.token.here"},
+        )
+        assert response.status_code == 401
+
+    def test_csv_export_filename_sanitization(self, client, mock_db):
+        """Company names with spaces get sanitized in the filename."""
+        mock_db._mock_cursor.fetchall.return_value = [
+            (
+                "Tesla Motors",
+                "company_analysis",
+                "anthropic/claude-3.5-sonnet",
+                "EV patent portfolio analysis.",
+                datetime(2025, 6, 15, 10, 0, 0),
+            ),
+        ]
+
+        response = client.get("/export/Tesla Motors", headers=_auth_header())
+
+        assert response.status_code == 200
+        assert "tesla_motors" in response.headers["content-disposition"]
+
+    def test_csv_export_single_row(self, client, mock_db):
+        """Single analysis result produces valid CSV with one data row."""
+        mock_db._mock_cursor.fetchall.return_value = [_sample_rows()[0]]
+
+        response = client.get("/export/NVIDIA", headers=_auth_header())
+
+        assert response.status_code == 200
+        lines = response.text.strip().split("\n")
+        assert len(lines) == 2  # header + 1 data row
+
+
+class TestPDFExport:
+    """GET /export/{company_name}/pdf -- PDF report export."""
+
+    def test_pdf_export_success(self, client, mock_db):
+        """Valid company with results returns a PDF file."""
+        mock_db._mock_cursor.fetchall.return_value = _sample_rows()
+
+        response = client.get("/export/NVIDIA/pdf", headers=_auth_header())
+
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "application/pdf"
+        assert "attachment" in response.headers.get("content-disposition", "")
+        # PDF files start with %PDF
+        assert response.content[:4] == b"%PDF"
+
+    def test_pdf_export_no_results_returns_404(self, client, mock_db):
+        """Unknown company returns 404."""
+        mock_db._mock_cursor.fetchall.return_value = []
+
+        response = client.get("/export/nonexistent/pdf", headers=_auth_header())
+
+        assert response.status_code == 404
+        assert "No analysis results found" in response.json()["detail"]
+
+    def test_pdf_export_unauthenticated_returns_401(self, client):
+        """Request without token returns 401."""
+        response = client.get("/export/NVIDIA/pdf")
+        assert response.status_code == 401
+
+    def test_pdf_export_invalid_token_returns_401(self, client):
+        """Request with invalid token returns 401."""
+        response = client.get(
+            "/export/NVIDIA/pdf",
+            headers={"Authorization": "Bearer invalid.token.here"},
+        )
+        assert response.status_code == 401
+
+    def test_pdf_export_filename_contains_date(self, client, mock_db):
+        """PDF filename includes the analysis date."""
+        mock_db._mock_cursor.fetchall.return_value = _sample_rows()
+
+        response = client.get("/export/NVIDIA/pdf", headers=_auth_header())
+
+        assert response.status_code == 200
+        disposition = response.headers["content-disposition"]
+        assert "nvidia-analysis-" in disposition
+        assert ".pdf" in disposition
+
+    def test_pdf_export_special_chars_in_response(self, client, mock_db):
+        """Analysis text with XML-special chars (<, >, &) does not break PDF generation."""
+        rows = [
+            (
+                "TestCo",
+                "company_analysis",
+                "anthropic/claude-3.5-sonnet",
+                "Revenue > $1B & growth <20% for Q4. Test <html> escaping.",
+                datetime(2025, 6, 15, 10, 0, 0),
+            ),
+        ]
+        mock_db._mock_cursor.fetchall.return_value = rows
+
+        response = client.get("/export/TestCo/pdf", headers=_auth_header())
+
+        assert response.status_code == 200
+        assert response.content[:4] == b"%PDF"
+
+    def test_pdf_export_multiple_analyses(self, client, mock_db):
+        """Multiple analysis records produce a valid PDF with content."""
+        mock_db._mock_cursor.fetchall.return_value = _sample_rows()
+
+        response = client.get("/export/NVIDIA/pdf", headers=_auth_header())
+
+        assert response.status_code == 200
+        # PDF should have reasonable size (more than just headers)
+        assert len(response.content) > 500