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.

11.1 KB
Raw Blame
"""A legacy library path stays in use but cannot be redirected by its owner."""

from contextlib import nullcontext

import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

from local_deep_research.database.models import Base, Setting, SettingType
from local_deep_research.research_library.utils import (
    get_absolute_path_from_settings,
    get_library_storage_path,
)
from local_deep_research.settings.manager import (
    SettingsManager,
    is_operator_only_setting,
)
from local_deep_research.web.routers import settings as settings_routes


KEY = "research_library.storage_path"
# SQLite's LIKE ignores ASCII case, so get_setting(KEY) finds these child rows.
CASE_VARIANT_CHILDREN = (
    "Research_Library.storage_path.x",
    "RESEARCH_LIBRARY.STORAGE_PATH.x",
)
CASE_VARIANT_KEYS = (
    *CASE_VARIANT_CHILDREN,
    "Research_Library.Storage_Path",
    KEY.upper(),
)


def _add_raw_row(session, key, value):
    """Store a row directly, the way a database written before the policy has it."""
    session.add(
        Setting(
            key=key,
            value=value,
            type=SettingType.APP,
            name="Legacy row",
            ui_element="text",
        )
    )
    session.commit()


def _stored_path(session):
    """Read the stored path column fresh from the database."""
    return session.query(Setting.value).filter(Setting.key == KEY).scalar()


@pytest.fixture
def legacy_path_manager(tmp_path, monkeypatch):
    """Model a pre-upgrade account with a custom, still-editable path row."""
    monkeypatch.delenv("LDR_RESEARCH_LIBRARY_STORAGE_PATH", raising=False)
    monkeypatch.setenv("LDR_DATA_DIR", str(tmp_path / "data"))
    engine = create_engine("sqlite:///:memory:")
    Base.metadata.create_all(engine)
    session = sessionmaker(bind=engine)()
    manager = SettingsManager(session)
    custom_root = tmp_path / "existing-documents" / "Library"
    row = session.query(Setting).filter(Setting.key == KEY).one()
    row.value = str(custom_root)
    row.editable = True
    session.commit()
    try:
        yield manager, session, custom_root
    finally:
        session.close()
        engine.dispose()


def test_legacy_location_survives_upgrade_and_operator_override(
    legacy_path_manager, monkeypatch
):
    manager, session, custom_root = legacy_path_manager
    monkeypatch.setattr(
        "local_deep_research.utilities.db_utils.get_settings_manager",
        lambda: manager,
    )

    # The shipped default and old custom roots may be outside LDR_DATA_DIR.
    # Preserve their files in place while changing who can edit the setting.
    user_root = get_library_storage_path("alice")
    assert user_root == custom_root / "alice"
    stored_pdf = user_root / "pdfs" / "5.pdf"
    stored_pdf.parent.mkdir(parents=True)
    stored_pdf.write_bytes(b"existing pdf")
    assert (
        get_absolute_path_from_settings(
            "pdfs/5.pdf",
            "alice",
            settings_manager=manager,
        )
        == stored_pdf
    )

    manager.import_settings(
        manager.default_settings, overwrite=False, override_locked=True
    )
    row = session.query(Setting).filter(Setting.key == KEY).one()
    assert row.value == str(custom_root)
    assert row.editable is False
    assert stored_pdf.read_bytes() == b"existing pdf"

    operator_root = custom_root.parent / "operator-selected"
    monkeypatch.setenv("LDR_RESEARCH_LIBRARY_STORAGE_PATH", str(operator_root))
    assert manager.get_setting(KEY) == str(operator_root)
    assert manager.get_all_settings()[KEY]["editable"] is False
    assert _stored_path(session) == str(custom_root)


def test_legacy_editable_row_rejects_direct_and_imported_changes(
    legacy_path_manager, tmp_path
):
    manager, session, custom_root = legacy_path_manager
    redirected = str(tmp_path / "other-users-files")
    assert manager.get_all_settings()[KEY]["editable"] is False
    assert manager.set_setting(KEY, redirected) is False
    assert manager.set_setting(f"{KEY}.child", redirected) is False
    assert (
        manager.create_or_update_setting(
            {"key": KEY, "name": "Library Storage Path", "value": redirected}
        )
        is None
    )
    assert manager.delete_setting(KEY) is False

    supplied = dict(manager.default_settings[KEY])
    supplied.update(value=redirected, editable=True)
    manager.import_settings({KEY: supplied}, delete_extra=True)
    assert manager.get_setting(KEY) == str(custom_root)
    manager.import_settings({KEY: supplied}, override_locked=True)
    assert manager.get_setting(KEY) == str(custom_root)
    manager.import_settings({}, delete_extra=True)
    assert manager.get_setting(KEY) == str(custom_root)

    # The authenticated import/reset routes use this wrapper. It must not
    # reset a pre-existing library location to the bundled default.
    manager.load_from_defaults_file()
    row = session.query(Setting).filter(Setting.key == KEY).one()
    assert row.value == str(custom_root)


def test_http_write_helpers_reject_stale_editable_rows(
    legacy_path_manager, monkeypatch, tmp_path
):
    manager, session, custom_root = legacy_path_manager
    monkeypatch.setattr(
        settings_routes,
        "get_user_db_session",
        lambda _username: nullcontext(session),
    )
    monkeypatch.setattr(
        settings_routes,
        "get_settings_manager",
        lambda *_args, **_kwargs: manager,
    )

    response = settings_routes._api_update_setting_sync(
        {"value": str(tmp_path / "new-root")}, KEY, "alice"
    )
    assert response.status_code == 403
    assert manager.get_setting(KEY) == str(custom_root)

    form_data = {
        KEY: str(tmp_path / "new-root"),
        "research_library.confirm_deletions": False,
    }
    settings_routes._filter_editable_settings(form_data, session)
    assert KEY not in form_data
    assert form_data == {"research_library.confirm_deletions": False}


def test_bulk_save_echo_masks_legacy_editability(
    legacy_path_manager, monkeypatch
):
    manager, session, custom_root = legacy_path_manager
    monkeypatch.setattr(
        settings_routes,
        "get_user_db_session",
        lambda _username: nullcontext(session),
    )
    monkeypatch.setattr(
        settings_routes,
        "get_settings_manager",
        lambda *_args, **_kwargs: manager,
    )
    monkeypatch.setattr(
        settings_routes, "invalidate_settings_caches", lambda _: None
    )
    monkeypatch.setattr(
        settings_routes, "reschedule_document_jobs_if_needed", lambda *_: None
    )
    monkeypatch.setattr(
        settings_routes, "reschedule_zotero_jobs_if_needed", lambda *_: None
    )

    result = settings_routes._save_all_settings_sync(
        {"research_library.confirm_deletions": False}, "alice"
    )
    assert result["status"] == "success"
    assert result["settings"][KEY]["value"] == str(custom_root)
    assert result["settings"][KEY]["editable"] is False


def test_operator_only_match_covers_every_child_row_the_lookup_returns(
    legacy_path_manager,
):
    manager, session, _custom_root = legacy_path_manager
    candidates = {
        f"{KEY[:i]}{KEY[i].upper()}{KEY[i + 1 :]}.x"
        for i in range(len(KEY))
        if KEY[i].isalpha()
    }
    candidates |= {f"{KEY.upper()}.X", f"{KEY.title()}.x", f"{KEY}.x"}
    # SQLite does not fold these lookalikes, so the lookup must skip them.
    candidates |= {
        f"{KEY.replace('s', chr(0x017F), 1)}.x",
        f"{KEY.replace('i', chr(0x0131), 1)}.x",
        f"{KEY.replace('a', chr(0x0430), 1)}.x",
    }
    for key in sorted(candidates):
        _add_raw_row(session, key, "/redirected")

    # get_setting() finds child rows with this lookup, so every row it
    # returns for KEY must be refused as operator-only.
    returned = {
        str(row.key) for row in manager._SettingsManager__query_settings(KEY)
    }
    assert {key for key in candidates if key.isascii()} <= returned
    assert not {key for key in candidates if not key.isascii()} & returned
    assert all(is_operator_only_setting(key) for key in returned)


@pytest.mark.parametrize("variant", CASE_VARIANT_KEYS)
def test_case_variant_keys_are_refused_by_every_manager_write(
    legacy_path_manager, tmp_path, variant
):
    manager, session, custom_root = legacy_path_manager
    redirected = str(tmp_path / "other-users-files")

    assert manager.set_setting(variant, redirected) is False
    assert (
        manager.create_or_update_setting(
            {
                "key": variant,
                "name": "Library Storage Path",
                "value": redirected,
            }
        )
        is None
    )
    supplied = dict(manager.default_settings[KEY])
    supplied.update(value=redirected, editable=True)
    manager.import_settings({variant: supplied})

    assert session.query(Setting).filter(Setting.key == variant).count() == 0
    assert manager.get_setting(KEY) == str(custom_root)
    assert manager.get_all_settings()[KEY]["editable"] is False


def test_legacy_child_rows_never_replace_the_path_on_read(
    legacy_path_manager, monkeypatch, tmp_path
):
    manager, session, custom_root = legacy_path_manager
    for child in (f"{KEY}.x", *CASE_VARIANT_CHILDREN):
        _add_raw_row(session, child, str(tmp_path / "redirected"))

    assert manager.get_setting(KEY) == str(custom_root)
    assert manager.get_setting(KEY, check_env=False) == str(custom_root)
    for child in CASE_VARIANT_CHILDREN:
        assert manager.get_all_settings()[child]["editable"] is False

    operator_root = tmp_path / "operator-selected"
    monkeypatch.setenv("LDR_RESEARCH_LIBRARY_STORAGE_PATH", str(operator_root))
    assert manager.get_setting(KEY) == str(operator_root)


def test_version_bump_import_keeps_the_path_with_legacy_child_rows(
    legacy_path_manager, tmp_path
):
    manager, session, custom_root = legacy_path_manager
    for child in (f"{KEY}.x", *CASE_VARIANT_CHILDREN):
        _add_raw_row(session, child, str(tmp_path / "redirected"))

    manager.import_settings(
        manager.default_settings, overwrite=False, override_locked=True
    )

    assert _stored_path(session) == str(custom_root)
    assert manager.get_setting(KEY) == str(custom_root)


def test_http_write_helpers_reject_case_variant_keys(
    legacy_path_manager, monkeypatch, tmp_path
):
    manager, session, custom_root = legacy_path_manager
    monkeypatch.setattr(
        settings_routes,
        "get_user_db_session",
        lambda _username: nullcontext(session),
    )
    monkeypatch.setattr(
        settings_routes,
        "get_settings_manager",
        lambda *_args, **_kwargs: manager,
    )

    for variant in CASE_VARIANT_KEYS:
        response = settings_routes._api_update_setting_sync(
            {"value": str(tmp_path / "new-root")}, variant, "alice"
        )
        assert response.status_code == 403, variant
        assert (
            session.query(Setting).filter(Setting.key == variant).count() == 0
        )

    form_data = {
        variant: str(tmp_path / "new-root") for variant in CASE_VARIANT_KEYS
    }
    form_data["research_library.confirm_deletions"] = False
    settings_routes._filter_editable_settings(form_data, session)
    assert form_data == {"research_library.confirm_deletions": False}
    assert manager.get_setting(KEY) == str(custom_root)