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.

16.0 KB
Raw Blame
"""Release assertions for note AI concurrency, without external model calls.

Run serially with LDR_TESTING_WITH_MOCKS=false. The real notes router,
SlowAPI middleware, registry and model wrappers are exercised. Only DB reads
and the model/network boundary are controlled. Deadlines are escape hatches;
success requires an independent request to finish BEFORE a held operation
is released, not a machine-dependent latency target.
"""

import asyncio
import threading
from concurrent.futures import TimeoutError as FutureTimeout
from contextlib import asynccontextmanager
from types import SimpleNamespace

import httpx
import pytest
from fastapi import FastAPI, Request
from langchain_core.language_models import BaseChatModel
from langchain_core.messages import AIMessage
from langchain_core.outputs import ChatGeneration, ChatResult
from limits.storage import MemoryStorage
from limits.strategies import MovingWindowRateLimiter
from pydantic import PrivateAttr
from slowapi import _rate_limit_exceeded_handler
from slowapi.errors import RateLimitExceeded
from slowapi.middleware import SlowAPIMiddleware
from starlette.middleware.sessions import SessionMiddleware

from local_deep_research.llm import register_llm, unregister_llm
from local_deep_research.llm.providers.implementations.ollama import (
    OllamaProvider,
)
from local_deep_research.research_library.notes.services.note_ai_service import (
    NoteAIService,
)
from local_deep_research.web.dependencies.auth import require_auth
from local_deep_research.web.routers import notes

pytestmark = [pytest.mark.integration, pytest.mark.asyncio]

DEADLINE = 10.0
PROVIDER = "release-concurrency-probe"
SUMMARY_URL = "/notes/api/notes/release-note/summarize"
# The constructor the built-in Ollama provider builds its model with.
OLLAMA_CHAT = (
    "local_deep_research.llm.providers.implementations.ollama.ChatOllama"
)


class _HeldOperation:
    """An external watchdog releases even a synchronously blocked loop.

    The watchdog stores its result before releasing the held operation.
    A health response arriving after a timeout cannot turn failure into
    success. Assertions live outside provider cleanup, which swallows errors.
    """

    def __init__(self, progress_timeout=DEADLINE):
        self.progress_timeout = progress_timeout
        self.entered = threading.Event()
        self.release = threading.Event()
        self.finished = threading.Event()
        self.progress = False
        self.expired = False
        self.error = None
        self.calls = 0
        # Set as soon as the operation returns, even when a later assertion
        # in this method raises -- lets a caller inspect what the operation
        # actually produced (e.g. its status code) instead of only the
        # AssertionError text.
        self.result = None

    def hold(self):
        self.calls += 1
        self.entered.set()
        try:
            if not self.release.wait(DEADLINE + self.progress_timeout * 2):
                self.expired = True
        finally:
            self.finished.set()

    async def run(self, client, operation):
        loop = asyncio.get_running_loop()

        def watch():
            pending = None
            try:
                if not self.entered.wait(DEADLINE):
                    self.error = "held operation never started"
                    return
                pending = asyncio.run_coroutine_threadsafe(
                    client.get("/release-probe"), loop
                )
                response = pending.result(timeout=self.progress_timeout)
                self.progress = (
                    response.status_code == 200
                    and response.json() == {"ok": True}
                    and not self.finished.is_set()
                )
            except FutureTimeout:
                self.error = "event loop did not serve the independent request"
            except Exception as exc:
                self.error = f"independent request failed: {type(exc).__name__}"
            finally:
                if pending is not None and not pending.done():
                    pending.cancel()
                self.release.set()

        watchdog = threading.Thread(target=watch, daemon=True)
        watchdog.start()
        try:
            result = await operation()
            self.result = result
            # Record this before joining the watchdog: joining can otherwise
            # let detached cleanup finish after the request already returned.
            finished_before_return = self.finished.is_set()
            await asyncio.to_thread(watchdog.join, DEADLINE * 2)
            assert not watchdog.is_alive(), "watchdog did not finish"
            assert self.entered.is_set(), "held operation never started"
            assert self.progress, (
                self.error or "independent request ran too late"
            )
            assert finished_before_return, (
                "request completed before held operation finished"
            )
            assert not self.expired, "held operation escaped on its own timeout"
            return result
        finally:
            self.release.set()
            await asyncio.to_thread(watchdog.join, DEADLINE * 2)


class _LocalModel(BaseChatModel):
    _gate = PrivateAttr(default=None)
    _mode = PrivateAttr(default="success")
    _started = PrivateAttr(default=None)
    _closed = PrivateAttr(default=False)
    _close_calls = PrivateAttr(default=0)
    _invoke_calls = PrivateAttr(default=0)

    @property
    def _llm_type(self):
        return "release-local-model"

    def _generate(self, messages, stop=None, run_manager=None, **kwargs):
        raise AssertionError("notes unexpectedly used synchronous inference")

    async def _agenerate(self, messages, stop=None, run_manager=None, **kwargs):
        assert not self._closed, "a closed model was reused"
        self._invoke_calls += 1
        self._started.set()
        if self._mode == "cancel":
            await asyncio.Event().wait()
        if self._mode == "error":
            raise RuntimeError("release-probe model failure")
        return ChatResult(
            generations=[ChatGeneration(message=AIMessage(content="summary"))]
        )

    def close(self):
        self._close_calls += 1
        if self._gate is not None:
            self._gate.hold()
        self._closed = True


@pytest.fixture
def harness(monkeypatch):
    # Use a fresh real storage backend while retaining the production
    # registrations and key functions. Simulated latency is added at the
    # same acquire_entry boundary that network-backed storage implements.
    storage = MemoryStorage()
    limiter = notes.limiter
    assert limiter.enabled, "release checks require rate limiting enabled"
    monkeypatch.setattr(limiter, "_storage", storage)
    monkeypatch.setattr(limiter, "_limiter", MovingWindowRateLimiter(storage))
    monkeypatch.setattr(limiter, "_exempt_routes", set(limiter._exempt_routes))
    app = FastAPI()
    app.include_router(notes.router)
    app.state.limiter = limiter
    app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
    app.add_middleware(SessionMiddleware, secret_key="release-suite-session")
    app.add_middleware(SlowAPIMiddleware)

    async def authenticated_user(request: Request):
        return request.session["username"]

    app.dependency_overrides[require_auth] = authenticated_user

    @app.get("/release-probe")
    @limiter.exempt
    async def health():
        return {"ok": True}

    @app.post("/release-session/{username}")
    @limiter.exempt
    async def session(request: Request, username: str):
        request.session["username"] = username
        return {"ok": True}

    monkeypatch.setattr(
        NoteAIService, "_get_note_content", lambda self, note_id: "note text"
    )
    monkeypatch.setattr(
        NoteAIService,
        "_build_settings_snapshot",
        lambda self: {
            "llm.provider": PROVIDER,
            "llm.model": "local-test",
            "llm.ollama.url": "http://127.0.0.1:11434",
            "search.tool": "searxng",
            "_username": self.username,
        },
    )

    def install_model(gate=None, mode="success", registration="built-in"):
        """Register the probe model as PROVIDER.

        ``"built-in"`` registers a built-in provider's factory and has it
        build the probe model instead of a ``ChatOllama``, so each request
        gets a new model that LDR owns and closes. ``"instance"`` and
        ``"singleton factory"`` register one model that every request
        shares and that LDR must leave open.
        """
        state = SimpleNamespace(models=[], started=asyncio.Event())

        def build(**kwargs):
            model = _LocalModel()
            model._gate = gate
            model._mode = mode
            model._started = state.started
            state.models.append(model)
            return model

        if registration == "built-in":
            monkeypatch.setattr(OLLAMA_CHAT, build)
            register_llm(PROVIDER, OllamaProvider.create_llm)
        elif registration == "instance":
            register_llm(PROVIDER, build())
        else:
            singleton = build()
            register_llm(PROVIDER, lambda **kwargs: singleton)
        return state

    @asynccontextmanager
    async def connect(username="alice"):
        async with httpx.AsyncClient(
            transport=httpx.ASGITransport(app=app),
            base_url="http://testserver",
        ) as client:
            response = await client.post(f"/release-session/{username}")
            assert response.status_code == 200
            yield client

    yield SimpleNamespace(
        app=app,
        connect=connect,
        install_model=install_model,
        limiter=limiter,
        storage=storage,
    )
    unregister_llm(PROVIDER)
    storage.reset()


@pytest.mark.parametrize("outcome", ["success", "error", "cancel"])
async def test_owned_cleanup_preserves_responsiveness(harness, outcome):
    gate = _HeldOperation()
    state = harness.install_model(gate=gate, mode=outcome)
    async with harness.connect() as client:

        async def request():
            if outcome != "cancel":
                return await client.post(SUMMARY_URL, json={})
            task = asyncio.create_task(client.post(SUMMARY_URL, json={}))
            try:
                await asyncio.wait_for(state.started.wait(), DEADLINE)
                task.cancel()
                with pytest.raises(asyncio.CancelledError):
                    await task
            finally:
                if not task.done():
                    task.cancel()
                    await asyncio.gather(task, return_exceptions=True)

        response = await gate.run(client, request)

    if outcome == "success":
        assert response.status_code == 200
        assert response.json() == {"success": True, "summary": "summary"}
    elif outcome == "error":
        assert response.status_code == 500
        assert response.json()["success"] is False
    assert len(state.models) == 1, "model factory was bypassed"
    model = state.models[0]
    assert model._invoke_calls == 1
    assert model._close_calls == 1, "owned cleanup was removed or duplicated"
    assert model._closed, "request completed before cleanup finished"


@pytest.mark.parametrize("registration", ["instance", "singleton factory"])
async def test_shared_model_remains_usable_after_consumer_cleanup(
    harness, registration
):
    state = harness.install_model(registration=registration)
    async with harness.connect() as client:
        for _ in range(2):
            response = await client.post(SUMMARY_URL, json={})
            assert response.status_code == 200
            assert response.json()["summary"] == "summary"
    model = state.models[0]
    assert model._invoke_calls == 2
    assert model._close_calls == 0, "consumer closed a caller-owned model"
    assert not model._closed


def _assert_per_minute_window(harness):
    """The count-based checks in ``_assert_quota`` (9 pass, the 10th 429s)
    pass identically whether the route is "10 per minute" or "10 per hour"
    -- they pin the count and the per-user key but never the window. Read
    the actual RateLimitItem slowapi registered for the route (not a
    re-declared literal) so a widened window fails this even though the
    count-only checks above still pass.
    """
    name = f"{notes.summarize_note.__module__}.{notes.summarize_note.__name__}"
    route_limits = harness.limiter._route_limits.get(name, [])
    assert route_limits, (
        "no registered rate limit found for the summarize route"
    )
    windows = {limit.limit.GRANULARITY.seconds for limit in route_limits}
    assert windows and max(windows) <= 60, (
        f"quota window is not per-minute (or tighter): {windows} seconds"
    )


async def _assert_quota(harness, alice, first_response):
    assert first_response.status_code == 200
    for _ in range(9):
        response = await alice.post(SUMMARY_URL, json={})
        assert response.status_code == 200, "quota was consumed more than once"
    response = await alice.post(SUMMARY_URL, json={})
    assert response.status_code == 429, "rate limiting was disabled or bypassed"
    _assert_per_minute_window(harness)
    async with harness.connect("bob") as bob:
        response = await bob.post(SUMMARY_URL, json={})
        assert response.status_code == 200, "users shared a rate-limit quota"


async def test_storage_preserves_responsiveness_and_user_quotas(
    harness, monkeypatch
):
    state = harness.install_model()
    gate = _HeldOperation()
    acquire = harness.storage.acquire_entry

    def held_storage(*args, **kwargs):
        if not gate.entered.is_set():
            gate.hold()
        return acquire(*args, **kwargs)

    monkeypatch.setattr(harness.storage, "acquire_entry", held_storage)
    async with harness.connect() as alice:
        first = await gate.run(alice, lambda: alice.post(SUMMARY_URL, json={}))
        await _assert_quota(harness, alice, first)
    assert gate.calls == 1, "storage latency injection was bypassed"
    assert sum(model._invoke_calls for model in state.models) == 11


@pytest.mark.parametrize("regression", ["blocking", "removed"])
async def test_cleanup_assertion_rejects_known_regressions(
    harness, monkeypatch, regression
):
    # Only the deliberately blocked progress phase gets a short timeout.
    # Startup remains generous so runner load cannot mask the intended fault.
    gate = _HeldOperation(progress_timeout=0.2)
    harness.install_model(gate=gate)

    async def broken_invoke(self, llm, prompt):
        try:
            return await llm.ainvoke(prompt)
        finally:
            if regression == "blocking":
                self._close_llm(llm)

    monkeypatch.setattr(NoteAIService, "_ainvoke_and_close", broken_invoke)
    expected = (
        "event loop did not serve"
        if regression == "blocking"
        else "never started"
    )
    async with harness.connect() as client:
        with pytest.raises(AssertionError, match=expected):
            await gate.run(client, lambda: client.post(SUMMARY_URL, json={}))
        if regression == "removed":
            # "never started" alone is also produced by any failure before
            # cleanup is reached (a bypassed model factory, an early 4xx) --
            # that is not this regression. Pin it to what only a skipped
            # cleanup produces: the request itself succeeded.
            assert gate.result is not None, "no request result was recorded"
            assert gate.result.status_code == 200, (
                "the removed-cleanup regression must be a successful "
                "request with cleanup skipped, not an earlier failure"
            )
            assert not gate.entered.is_set(), (
                "cleanup must never have started for this regression"
            )


async def test_quota_assertion_rejects_disabled_limiting(harness, monkeypatch):
    harness.install_model()
    monkeypatch.setattr(harness.limiter, "enabled", False)
    async with harness.connect() as client:
        first = await client.post(SUMMARY_URL, json={})
        with pytest.raises(AssertionError, match="disabled or bypassed"):
            await _assert_quota(harness, client, first)