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.

4.3 KB
Raw Blame
from __future__ import annotations

from pathlib import Path
from typing import Protocol

from sqlalchemy import select

from local_deep_research.database.encrypted_db import db_manager
from local_deep_research.database.models import UserSettings
from local_deep_research.database.session_passwords import (
    session_password_store,
)
from local_deep_research.web.auth.session_manager import session_manager

from tests.connected.conftest import csrf_headers, register_connected_user


class ConnectedUserFixture(Protocol):
    # Flask app/client type hints dropped: the branch's ``client`` fixture
    # is a Flask-compat-shimmed Starlette TestClient.
    app: object
    client: object
    username: str
    password: str
    data_root: Path


def test_connected_fixture_finalizer_clears_generated_user_state(
    connected_user: ConnectedUserFixture,
) -> None:
    case = connected_user

    register_connected_user(case)
    db_manager.close_user_database(case.username)
    assert (
        db_manager.open_user_database(case.username, case.password) is not None
    )
    assert db_manager.is_user_connected(case.username)
    assert session_manager.has_active_sessions_for(case.username)
    session_password_store.store_session_password(
        case.username,
        "fixture-cleanup-probe",
        case.password,
    )
    assert (
        session_password_store.get_session_password(
            case.username,
            "fixture-cleanup-probe",
        )
        == case.password
    )


def test_authentication_reopens_persisted_user_data_after_logout(
    connected_user: ConnectedUserFixture,
):
    case = connected_user

    register_connected_user(case)
    assert case.client.get("/auth/check").json() == {
        "authenticated": True,
        "username": case.username,
    }

    database_session = db_manager.get_session(case.username)
    assert database_session is not None
    with database_session:
        database_session.add(
            UserSettings(
                key="connected.lifecycle",
                value={"username": case.username},
                category="connected",
            )
        )
        database_session.commit()

    # Capture the exact server-side session id for this user so the
    # post-logout assertions can prove *this* session (not just any session
    # for the user) was invalidated.
    with session_manager._lock:
        pre_logout_session_ids = [
            sid
            for sid, data in session_manager.sessions.items()
            if data["username"] == case.username
        ]
    assert len(pre_logout_session_ids) == 1
    pre_logout_session_id = pre_logout_session_ids[0]
    assert isinstance(pre_logout_session_id, str)
    logout_response = case.client.post(
        "/auth/logout",
        headers=csrf_headers(case.client),
        follow_redirects=False,
    )

    assert logout_response.status_code == 302
    assert db_manager.is_user_connected(case.username) is False
    assert case.client.get("/auth/check").status_code == 401
    assert session_manager.validate_session(pre_logout_session_id) is None
    assert (
        session_password_store.get_session_password(
            case.username, pre_logout_session_id
        )
        is None
    )

    wrong_password_response = case.client.post(
        "/auth/login",
        data={"username": case.username, "password": "WrongConnectedPass123!"},
        headers=csrf_headers(case.client),
        follow_redirects=False,
    )

    assert wrong_password_response.status_code == 401
    assert case.client.get("/auth/check").status_code == 401

    correct_login_response = case.client.post(
        "/auth/login",
        data={"username": case.username, "password": case.password},
        headers=csrf_headers(case.client),
        follow_redirects=False,
    )

    assert correct_login_response.status_code == 302
    assert case.client.get("/auth/check").json() == {
        "authenticated": True,
        "username": case.username,
    }

    reopened_database_session = db_manager.get_session(case.username)
    assert reopened_database_session is not None
    with reopened_database_session:
        persisted_value = reopened_database_session.execute(
            select(UserSettings.value).where(
                UserSettings.key == "connected.lifecycle"
            )
        ).scalar_one_or_none()

        assert persisted_value == {"username": case.username}