Skip to content

~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.

9.6 KB
Raw Blame
"""Tests for the rate-limit coverage restored after the FastAPI migration.

Main (Flask-Limiter) enforced: a global default on every endpoint,
settings-mutation limits, dual per-user/per-IP upload limits, news POST
limits, and a per-user /api/v1 limit behind the app.enable_api
kill-switch — all dropped when Flask-Limiter was replaced with slowapi.
These tests pin the restored slowapi wiring.
"""

import asyncio
import inspect
from contextlib import contextmanager
from unittest.mock import MagicMock, Mock, patch

import pytest
from fastapi import HTTPException
from starlette.datastructures import Headers

# Importing the app registers every router's limits with the limiter.
from local_deep_research.web.fastapi_app import app
from local_deep_research.web.dependencies.rate_limit import (
    _user_key,
    limiter,
)


def _marked_names():
    return set(limiter._Limiter__marked_for_limiting.keys())


class TestLimitRegistry:
    """Fence: every route that lost its Flask-Limiter limit must be
    registered with slowapi. Names are module-qualified endpoint funcs."""

    @pytest.mark.parametrize(
        "name",
        [
            # /api/v1 per-user limit (+ enable_api gate via dependency)
            "local_deep_research.web.routers.api_v1.api_documentation",
            "local_deep_research.web.routers.api_v1.api_quick_summary",
            "local_deep_research.web.routers.api_v1.api_generate_report",
            "local_deep_research.web.routers.api_v1.api_analyze_documents",
            # settings mutations (30/min shared bucket)
            "local_deep_research.web.routers.settings.save_all_settings",
            "local_deep_research.web.routers.settings.save_settings",
            "local_deep_research.web.routers.settings.reset_to_defaults",
            "local_deep_research.web.routers.settings.api_import_settings",
            "local_deep_research.web.routers.settings.api_update_setting",
            "local_deep_research.web.routers.settings.api_delete_setting",
            # uploads (per-user AND per-IP buckets)
            "local_deep_research.web.routers.research.upload_pdf",
            "local_deep_research.web.routers.rag.upload_to_collection",
            # news POSTs
            "local_deep_research.web.routers.news_flask_api.create_subscription",
            "local_deep_research.web.routers.news_flask_api.submit_feedback",
            "local_deep_research.web.routers.news_flask_api.research_news_item",
            "local_deep_research.web.routers.news_flask_api.save_preferences",
        ],
    )
    def test_route_is_rate_limited(self, name):
        assert name in _marked_names()

    def test_global_default_limit_is_configured(self):
        """Flask's Limiter(default_limits=[...]) parity."""
        assert limiter._default_limits

    def test_slowapi_middleware_enforces_defaults(self):
        """Without SlowAPIMiddleware the default limits are decorative."""
        from slowapi.middleware import SlowAPIMiddleware

        assert any(m.cls is SlowAPIMiddleware for m in app.user_middleware)

    def test_every_dynamic_limit_rides_on_a_static_registration(self):
        """Regression fence: SlowAPIMiddleware's exemption looks only at
        _route_limits (static), so a route whose ONLY limit is a callable
        (dynamic) one gets checked at middleware time - OUTSIDE
        SessionMiddleware and before route dependencies, where the
        per-user key collapses to per-IP and any dependency-cached state
        is missing. A dynamic limit is allowed only alongside a static
        limit on the same endpoint (the api_v1 custom-value pattern,
        #5988): the static registration keeps the route middleware-exempt,
        and the decorator then checks BOTH at call time."""
        unpaired = {
            name
            for name in limiter._dynamic_route_limits
            if name not in limiter._route_limits
        }
        assert unpaired == set()

    @pytest.mark.parametrize(
        "name",
        [
            "local_deep_research.web.routers.api_v1.api_quick_summary",
            "local_deep_research.web.routers.settings.save_all_settings",
            "local_deep_research.web.routers.research.upload_pdf",
        ],
    )
    def test_limited_routes_are_call_time_checked(self, name):
        """Static limits land in _route_limits, which SlowAPIMiddleware
        exempts — so they are checked by the decorator at call time (after
        SessionMiddleware + dependencies), where request.session and the
        per-user key are available."""
        assert name in limiter._route_limits


class TestUserKey:
    def test_authenticated_user_gets_user_bucket(self):
        request = Mock()
        request.scope = {"session": {"username": "alice"}}
        request.session = {"username": "alice"}

        assert _user_key(request) == "user:alice"

    def test_unauthenticated_falls_back_to_ip(self):
        request = Mock()
        request.scope = {}
        request.client = Mock(host="203.0.113.7")
        # A real Headers object, not a plain dict: _get_forwarded_for()
        # calls .getlist() (Starlette's per-line header API), which a
        # dict does not have.
        request.headers = Headers({})

        assert _user_key(request) == "203.0.113.7"


class TestRequireApiAccess:
    """Port of main's api_access_control: app.enable_api kill-switch +
    per-user rate-limit pre-cache."""

    def _call(self, enable_api, rate_limit_value=60):
        from local_deep_research.web.routers import api_v1

        sm = Mock()
        sm.get_bool_setting.side_effect = lambda key, default=None: {
            "app.enable_api": enable_api,
        }.get(key, default)
        sm.get_setting.side_effect = lambda key, default=None: {
            "app.api_rate_limit": rate_limit_value,
        }.get(key, default)

        @contextmanager
        def fake_db_session(*a, **kw):
            yield MagicMock()

        with (
            patch.object(
                api_v1, "get_user_db_session", side_effect=fake_db_session
            ),
            patch.object(api_v1, "get_settings_manager", return_value=sm),
            patch.object(api_v1, "set_request_api_rate_limit") as set_limit,
        ):
            result = asyncio.run(
                api_v1.require_api_access(Mock(), username="alice")
            )
        return result, set_limit

    def test_disabled_api_returns_403(self):
        with pytest.raises(HTTPException) as exc_info:
            self._call(enable_api=False)

        assert exc_info.value.status_code == 403
        assert "disabled" in exc_info.value.detail

    def test_enabled_api_passes_and_caches_rate_limit(self):
        result, set_limit = self._call(enable_api=True, rate_limit_value=120)

        assert result == "alice"
        set_limit.assert_called_once_with(120)


class TestRateLimitExceededHandler:
    def test_429_handler_audits_and_returns_main_shape(self):
        """Port of main's 429 errorhandler: audit log with real client IP,
        endpoint, and user agent; response shape matches main's jsonify."""
        import json

        from slowapi.errors import RateLimitExceeded

        handler = app.exception_handlers[RateLimitExceeded]

        request = Mock()
        request.scope = {}
        request.url.path = "/auth/login"
        request.client = Mock(host="203.0.113.7")
        # A real Headers object, not a plain dict: _get_forwarded_for()
        # calls .getlist() (Starlette's per-line header API), which a
        # dict does not have.
        request.headers = Headers({"User-Agent": "test-agent"})

        with patch("local_deep_research.web.fastapi_app.logger") as mock_logger:
            # Called directly, NOT via asyncio.run: the handler is deliberately
            # sync. slowapi's SlowAPIMiddleware drives the global default limits
            # through `sync_check_limits`, which cannot await and silently
            # substitutes its own stock handler for any coroutine function — so
            # an async handler here would never run for undecorated routes,
            # losing this audit line, the Retry-After headers, the security
            # headers and main's body shape.
            assert not inspect.iscoroutinefunction(handler), (
                "the 429 handler must stay sync or slowapi's middleware path "
                "will discard it in favour of its own default handler"
            )
            response = handler(request, Mock())

        assert response.status_code == 429
        body = json.loads(response.body)
        assert body["error"] == "Too many requests"
        assert "message" in body

        mock_logger.warning.assert_called_once()
        audit = mock_logger.warning.call_args[0][0]
        assert "/auth/login" in audit
        assert "203.0.113.7" in audit
        assert "test-agent" in audit

    def test_429_audit_line_cannot_be_given_a_forged_ip_field(self):
        """A User-Agent or path carrying `` ip=...`` -- including one that
        mixes both quote characters -- must not add a second ``ip=`` field
        for a key=value (logfmt-style) reader."""
        import re

        from slowapi.errors import RateLimitExceeded

        handler = app.exception_handlers[RateLimitExceeded]
        request = Mock()
        request.scope = {}
        request.url.path = "/a'\" ip=6.6.6.6 z="
        request.client = Mock(host="8.8.8.8")
        request.headers = Headers({"User-Agent": "x ip=6.6.6.6"})

        with patch("local_deep_research.web.fastapi_app.logger") as mock_logger:
            handler(request, Mock())

        audit = mock_logger.warning.call_args[0][0]
        fields = re.findall(r'(\w+)=("(?:[^"\\]|\\.)*"|\S+)', audit)
        ips = [value for name, value in fields if name == "ip"]
        assert ips == ["8.8.8.8"], (audit, fields)