~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
"""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)