chore: import upstream snapshot with attribution

tests/api_tests/test_all_endpoints.py

@@ -0,0 +1,453 @@
+#!/usr/bin/env python3
+"""
+Comprehensive test suite that tests ALL API endpoints in the codebase.
+This ensures we have coverage for every single endpoint.
+"""
+
+import json
+import time
+
+import pytest
+from loguru import logger
+
+
+class TestAllEndpoints:
+    """Comprehensive API test suite using Flask test client."""
+
+    def test_all_auth_endpoints(self, authenticated_client):
+        """Test ALL authentication endpoints."""
+        logger.info("\n=== Testing ALL Authentication Endpoints ===")
+
+        # Test endpoints
+        endpoints = [
+            ("GET", "/auth/check", None, 200),
+            ("GET", "/auth/integrity-check", None, 200),
+        ]
+
+        for method, endpoint, data, expected_status in endpoints:
+            if method == "GET":
+                response = authenticated_client.get(endpoint)
+            else:
+                response = authenticated_client.post(
+                    endpoint,
+                    json=data,
+                    content_type="application/json",
+                )
+            assert response.status_code == expected_status, (
+                f"{endpoint} failed: {response.data}"
+            )
+
+        logger.info("✅ All Auth endpoints tested")
+
+    def test_all_settings_endpoints(self, authenticated_client):
+        """Test ALL settings endpoints."""
+        logger.info("\n=== Testing ALL Settings Endpoints ===")
+
+        # Basic GET endpoints
+        get_endpoints = [
+            "/settings/api",
+            "/settings/api/categories",
+            "/settings/api/types",
+            "/settings/api/ui_elements",
+            "/settings/api/available-models",
+            "/settings/api/available-search-engines",
+            "/settings/api/warnings",
+            "/settings/api/ollama-status",
+            "/settings/api/rate-limiting/status",
+            "/settings/api/data-location",
+        ]
+
+        for endpoint in get_endpoints:
+            response = authenticated_client.get(endpoint)
+            assert response.status_code == 200, (
+                f"{endpoint} failed: {response.data}"
+            )
+
+        # Test bulk get
+        response = authenticated_client.get(
+            "/settings/api/bulk?keys=llm.provider,llm.model"
+        )
+        assert response.status_code == 200, f"Bulk get failed: {response.data}"
+
+        # Test setting CRUD (use an allow-listed prefix so the
+        # namespace gate permits creation of this throwaway key).
+        test_key = "llm.endpoint_test_value"
+        test_value = {"value": "test_endpoint_123", "editable": True}
+
+        # Create/Update
+        response = authenticated_client.put(
+            f"/settings/api/{test_key}",
+            json=test_value,
+            content_type="application/json",
+        )
+        assert response.status_code in [200, 201], (
+            f"Create setting failed: {response.data}"
+        )
+
+        # Get specific setting
+        data = json.loads(response.data)
+        if isinstance(data, dict) and "setting" in data:
+            actual_key = data["setting"].get("key", test_key)
+        else:
+            actual_key = test_key
+
+        response = authenticated_client.get(f"/settings/api/{actual_key}")
+        assert response.status_code == 200, (
+            f"Get setting failed: {response.data}"
+        )
+
+        # Delete
+        response = authenticated_client.delete(f"/settings/api/{actual_key}")
+        assert response.status_code in [200, 204, 404], (
+            f"Delete setting failed: {response.data}"
+        )
+
+        # Test rate limiting reset
+        response = authenticated_client.post(
+            "/settings/api/rate-limiting/engines/test/reset"
+        )
+        assert response.status_code in [200, 404], (
+            f"Rate limit reset failed: {response.data}"
+        )
+
+        # Test cleanup
+        response = authenticated_client.post(
+            "/settings/api/rate-limiting/cleanup"
+        )
+        assert response.status_code == 200, (
+            f"Rate limit cleanup failed: {response.data}"
+        )
+
+        logger.info("✅ All Settings endpoints tested")
+
+    def test_all_research_endpoints(self, authenticated_client):
+        """Test ALL research-related endpoints."""
+        # audit: PUNCHLIST reviewed 2026-05 — issue resolved by prior PR (recommendation: REFACTOR_SPLIT).
+        logger.info("\n=== Testing ALL Research Endpoints ===")
+
+        # Set up logging.
+        try:
+            logger.level("MILESTONE", no=26, color="<magenta><bold>")
+        except (TypeError, ValueError):
+            pass  # Level already registered
+
+        # Test history endpoint first
+        response = authenticated_client.get("/history/api")
+        assert response.status_code == 200, (
+            f"History API failed: {response.data}"
+        )
+
+        # Start research via main endpoint
+        research_data = {
+            "query": "Test all endpoints comprehensive",
+            "mode": "quick",
+            "model_provider": "OLLAMA",
+            "model": "llama2",
+            "search_engine": "searxng",
+            "max_results": 5,
+            "time_period": "y",
+            "iterations": 1,
+            "questions_per_iteration": 2,
+            "strategy": "rapid",
+        }
+
+        # Test /api/start_research endpoint
+        response = authenticated_client.post(
+            "/api/start_research",
+            json=research_data,
+            content_type="application/json",
+        )
+        assert response.status_code == 200, (
+            f"Start research failed: {response.data}"
+        )
+        data = json.loads(response.data)
+        assert "research_id" in data
+        research_id = data["research_id"]
+
+        # Give it a moment to start
+        time.sleep(0.5)  # allow: unmarked-sleep
+
+        # Test various research endpoints
+        research_endpoints = [
+            ("GET", f"/api/research/{research_id}", None, 200),
+            ("GET", f"/api/research/{research_id}/status", None, 200),
+            ("GET", f"/research/api/status/{research_id}", None, 200),
+            ("GET", f"/history/status/{research_id}", None, 200),
+            ("GET", f"/history/details/{research_id}", None, 200),
+            ("GET", f"/history/log_count/{research_id}", None, 200),
+        ]
+
+        for method, endpoint, req_data, expected_status in research_endpoints:
+            if method == "GET":
+                response = authenticated_client.get(endpoint)
+            else:
+                response = authenticated_client.post(
+                    endpoint,
+                    json=req_data,
+                    content_type="application/json",
+                )
+            # Some endpoints might return 404 if research is still initializing
+            assert response.status_code in [expected_status, 404], (
+                f"{endpoint} failed: {response.data}"
+            )
+
+        # Test research API routes
+        response = authenticated_client.get(
+            "/research/api/settings/current-config"
+        )
+        assert response.status_code == 200, (
+            f"Current config failed: {response.data}"
+        )
+
+        # Test Ollama checks
+        response = authenticated_client.get("/research/api/check/ollama_status")
+        assert response.status_code == 200, (
+            f"Ollama status check failed: {response.data}"
+        )
+
+        # Terminate research
+        response = authenticated_client.post(f"/api/terminate/{research_id}")
+        assert response.status_code in [200, 400, 404], (
+            f"Terminate research failed: {response.data}"
+        )
+
+        # Test alternate terminate endpoint
+        response = authenticated_client.post(
+            f"/research/api/terminate/{research_id}"
+        )
+        assert response.status_code in [200, 400, 404], (
+            f"API terminate research failed: {response.data}"
+        )
+
+        logger.info("✅ All Research endpoints tested")
+
+        return research_id
+
+    def test_all_metrics_endpoints(self, authenticated_client):
+        """Test ALL metrics endpoints."""
+        logger.info("\n=== Testing ALL Metrics Endpoints ===")
+
+        # Basic metrics endpoints
+        metrics_endpoints = [
+            "/metrics/api/metrics",
+            "/metrics/api/metrics/enhanced",
+            "/metrics/api/pricing",
+            "/metrics/api/cost-analytics",
+            "/metrics/api/star-reviews",
+            "/metrics/api/rate-limiting",
+            "/metrics/api/rate-limiting/current",
+        ]
+
+        for endpoint in metrics_endpoints:
+            response = authenticated_client.get(endpoint)
+            assert response.status_code == 200, (
+                f"{endpoint} failed: {response.data}"
+            )
+
+        # Test specific model pricing
+        response = authenticated_client.get(
+            "/metrics/api/pricing/gpt-3.5-turbo"
+        )
+        assert response.status_code in [200, 404], (
+            f"Model pricing failed: {response.data}"
+        )
+
+        # Test cost calculation
+        cost_data = {
+            "model_name": "gpt-3.5-turbo",
+            "prompt_tokens": 1000,
+            "completion_tokens": 500,
+        }
+        response = authenticated_client.post(
+            "/metrics/api/cost-calculation",
+            json=cost_data,
+            content_type="application/json",
+        )
+        assert response.status_code == 200, (
+            f"Cost calculation failed: {response.data}"
+        )
+
+        logger.info("✅ All Metrics endpoints tested")
+
+    def test_all_benchmark_endpoints(self, authenticated_client):
+        """Test ALL benchmark endpoints."""
+        logger.info("\n=== Testing ALL Benchmark Endpoints ===")
+
+        # Basic benchmark endpoints
+        benchmark_endpoints = [
+            "/benchmark/api/history",
+            "/benchmark/api/configs",
+            "/benchmark/api/running",
+            "/benchmark/api/search-quality",
+        ]
+
+        for endpoint in benchmark_endpoints:
+            response = authenticated_client.get(endpoint)
+            assert response.status_code == 200, (
+                f"{endpoint} failed: {response.data}"
+            )
+
+        # Test config validation
+        test_config = {
+            "name": "Test Benchmark Config",
+            "queries": ["test query 1", "test query 2"],
+            "models": ["gpt-3.5-turbo"],
+            "search_engines": ["searxng"],
+            "iterations": 1,
+        }
+
+        response = authenticated_client.post(
+            "/benchmark/api/validate-config",
+            json=test_config,
+            content_type="application/json",
+        )
+        assert response.status_code == 200, (
+            f"Validate config failed: {response.data}"
+        )
+
+        # Test simple benchmark start (but don't actually run it)
+        simple_benchmark = {
+            "query": "test benchmark",
+            "models": ["gpt-3.5-turbo"],
+            "search_engines": ["searxng"],
+        }
+
+        # Note: We won't actually start a benchmark as it's resource intensive
+        # Just verify the endpoint exists
+        response = authenticated_client.post(
+            "/benchmark/api/start-simple",
+            json=simple_benchmark,
+            content_type="application/json",
+        )
+        # Accept 409 (conflict) if another benchmark is running
+        assert response.status_code in [200, 409, 400], (
+            f"Start simple benchmark status: {response.status_code}, {response.data}"
+        )
+
+        logger.info("✅ All Benchmark endpoints tested")
+
+    def test_all_history_endpoints(self, authenticated_client):
+        """Test ALL history endpoints."""
+        logger.info("\n=== Testing ALL History Endpoints ===")
+
+        # Basic history endpoint
+        response = authenticated_client.get("/history/api")
+        assert response.status_code == 200, (
+            f"History API failed: {response.data}"
+        )
+
+        logger.info("✅ All History endpoints tested")
+
+    @pytest.mark.requires_llm
+    def test_all_api_v1_endpoints(self, authenticated_client):
+        """Test ALL API v1 endpoints."""
+        logger.info("\n=== Testing ALL API v1 Endpoints ===")
+
+        # Health check (doesn't require auth)
+        response = authenticated_client.get("/api/v1/health")
+        assert response.status_code == 200, (
+            f"Health check failed: {response.data}"
+        )
+
+        # API documentation
+        response = authenticated_client.get("/api/v1/")
+        assert response.status_code == 200, f"API docs failed: {response.data}"
+
+        # Quick summary
+        summary_data = {"query": "What is machine learning?", "max_tokens": 100}
+        response = authenticated_client.post(
+            "/api/v1/quick_summary",
+            json=summary_data,
+            content_type="application/json",
+        )
+        assert response.status_code in [200, 404, 500], (
+            f"Quick summary status: {response.status_code}"
+        )
+
+        # Generate report
+        report_data = {
+            "query": "Test report generation",
+            "research_type": "comprehensive",
+        }
+        response = authenticated_client.post(
+            "/api/v1/generate_report",
+            json=report_data,
+            content_type="application/json",
+        )
+        assert response.status_code in [200, 404, 500], (
+            f"Generate report status: {response.status_code}"
+        )
+
+        # Analyze documents. The endpoint searches a named local collection;
+        # it does not accept an inline "documents" key (that now yields a 400).
+        doc_data = {
+            "query": "Summarize this document",
+            "collection_name": "test_collection",
+        }
+        response = authenticated_client.post(
+            "/api/v1/analyze_documents",
+            json=doc_data,
+            content_type="application/json",
+        )
+        assert response.status_code in [200, 404, 500], (
+            f"Analyze documents status: {response.status_code}"
+        )
+
+        logger.info("✅ All API v1 endpoints tested")
+
+    def test_miscellaneous_endpoints(self, authenticated_client):
+        """Test miscellaneous endpoints not covered in other categories."""
+        logger.info("\n=== Testing Miscellaneous Endpoints ===")
+
+        # Test static file serving
+        response = authenticated_client.get("/static/css/style.css")
+        assert response.status_code in [200, 404], "Static file endpoint failed"
+
+        # Test favicon
+        response = authenticated_client.get("/favicon.ico")
+        assert response.status_code in [200, 404], "Favicon endpoint failed"
+
+        # Test pages that should exist
+        page_endpoints = [
+            "/",  # Home page
+            "/history",  # History page
+            "/settings",  # Settings page
+            "/metrics/",  # Metrics dashboard
+            "/benchmark/",  # Benchmark dashboard
+        ]
+
+        for endpoint in page_endpoints:
+            response = authenticated_client.get(endpoint)
+            assert response.status_code == 200, (
+                f"Page {endpoint} failed with status {response.status_code}"
+            )
+
+        logger.info("✅ All miscellaneous endpoints tested")
+
+    def test_error_handling(self, authenticated_client):
+        """Test error handling for invalid endpoints and methods."""
+        logger.info("\n=== Testing Error Handling ===")
+
+        # Test non-existent endpoint
+        response = authenticated_client.get("/api/does-not-exist")
+        assert response.status_code == 404, (
+            f"Non-existent endpoint should return 404, got {response.status_code}"
+        )
+
+        # Test wrong method
+        response = authenticated_client.delete("/auth/check")
+        assert response.status_code in [404, 405], (
+            f"Wrong method should return 404/405, got {response.status_code}"
+        )
+
+        # Test invalid JSON
+        response = authenticated_client.post(
+            "/api/start_research",
+            data="invalid json",
+            content_type="application/json",
+        )
+        assert response.status_code in [400, 500], (
+            f"Invalid JSON should return 400/500, got {response.status_code}"
+        )
+
+        logger.info("✅ Error handling tested")