~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.
Python academiaanthropicarxivbravedeep-researchencryptionhome-automationhomeserverlocallocal-deep-researchlocal-llmmistralollamaopenaipubmedresearchresearch-toolretrieval-augmented-generationsearxngself-hosted
"""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)