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.

5.8 KB
Raw Blame
"""Keep the data-free diagnostics behind scoped scanner annotations private."""

import json
import threading
import traceback

import pytest
from sqlalchemy.orm import Session

from local_deep_research.settings import manager as settings
from local_deep_research.settings.exceptions import SettingsValueError


_PRIVATE_VALUE = "synthetic-private-settings-value-1761"
_KEY = "llm.diagnostic_privacy_probe"
_ENV = "LDR_LLM_DIAGNOSTIC_PRIVACY_PROBE"


def _private_error(call, error_type=ValueError):
    with pytest.raises(error_type) as raised:
        call()
    error = raised.value
    rendered = "\n".join(
        [str(error), repr(error), repr(error.args), repr(vars(error))]
    ) + "".join(traceback.format_exception(error))
    assert _PRIVATE_VALUE not in rendered
    # Suppressing display with ``from None`` still retains a sensitive parser
    # exception in __context__. The typed boundary must discard it entirely.
    assert error.__cause__ is None
    assert error.__context__ is None
    return error


@pytest.mark.parametrize(
    "parse, raw",
    [
        (settings._parse_multiselect, {"value": _PRIVATE_VALUE}),
        (settings._parse_multiselect, json.dumps({"value": _PRIVATE_VALUE})),
        (settings._parse_environment_boolean, _PRIVATE_VALUE),
        (settings._reject_json_constant, _PRIVATE_VALUE),
    ],
    ids=[
        "multiselect-carrier",
        "multiselect-object",
        "boolean",
        "json-constant",
    ],
)
def test_parser_diagnostics_do_not_echo_rejected_values(parse, raw):
    _private_error(lambda: parse(raw))


@pytest.mark.parametrize(
    "source, ui_element, raw",
    [
        ("value", "number", _PRIVATE_VALUE),
        ("value", "range", _PRIVATE_VALUE),
        ("value", "multiselect", '["' + _PRIVATE_VALUE + '",broken'),
        ("environment", "number", _PRIVATE_VALUE),
        ("environment", "range", _PRIVATE_VALUE),
        ("environment", "checkbox", _PRIVATE_VALUE),
        ("environment", "json", '{"value":"' + _PRIVATE_VALUE + '",broken'),
        ("environment", "multiselect", '["' + _PRIVATE_VALUE + '",broken'),
    ],
)
def test_typed_errors_discard_sensitive_parser_state(
    monkeypatch, source, ui_element, raw
):
    monkeypatch.delenv(_ENV, raising=False)
    if source == "environment":
        monkeypatch.setenv(_ENV, raw)
    error = _private_error(
        lambda: settings.get_typed_setting_value(
            _KEY, raw, ui_element, default=5
        ),
        SettingsValueError,
    )
    assert error.key == _KEY
    assert error.source == source
    assert _KEY in error.diagnostic
    assert source in error.diagnostic


@pytest.mark.parametrize("source", ["value", "environment"])
def test_unsupported_control_metadata_does_not_enter_the_diagnostic(
    monkeypatch, source
):
    monkeypatch.delenv(_ENV, raising=False)
    if source == "environment":
        monkeypatch.setenv(_ENV, _PRIVATE_VALUE)
    error = _private_error(
        lambda: settings.get_typed_setting_value(
            _KEY, {"value": _PRIVATE_VALUE}, _PRIVATE_VALUE
        ),
        SettingsValueError,
    )
    assert error.key == _KEY
    assert error.source == source


@pytest.mark.parametrize(
    "method, args",
    [
        ("get_setting", (_KEY, {"value": _PRIVATE_VALUE})),
        ("set_setting", (_KEY, {"value": _PRIVATE_VALUE})),
        ("get_all_settings", ()),
        ("get_settings_snapshot", ()),
    ],
)
def test_closed_manager_does_not_echo_setting_data(method, args):
    manager = settings.SettingsManager(seed_defaults=False)
    manager.default_settings = {_KEY: {"value": _PRIVATE_VALUE}}
    manager.close()
    _private_error(
        lambda: getattr(manager, method)(*args),
        RuntimeError,
    )


@pytest.mark.parametrize(
    "method, args, kwargs",
    [
        ("_ensure_settings_initialized", (), {}),
        ("update_db_version", (), {}),
        (
            "import_settings",
            ({_KEY: {"value": _PRIVATE_VALUE}},),
            {"override_locked": True},
        ),
    ],
)
def test_missing_session_does_not_echo_setting_data(method, args, kwargs):
    manager = settings.SettingsManager(seed_defaults=False)
    manager.default_settings = {_KEY: {"value": _PRIVATE_VALUE}}
    try:
        _private_error(
            lambda: getattr(manager, method)(*args, **kwargs), RuntimeError
        )
    finally:
        manager.close()


def test_wrong_thread_diagnostic_does_not_render_session_state():
    with Session(info={"value": _PRIVATE_VALUE}) as session:
        manager = settings.SettingsManager(
            db_session=session, seed_defaults=False
        )
        outcomes = []
        failures = []

        def check():
            try:
                error = _private_error(
                    manager._check_thread_safety, RuntimeError
                )
                outcomes.append((threading.get_ident(), str(error)))
            except BaseException as error:
                failures.append(error)

        worker = threading.Thread(target=check)
        worker.start()
        worker.join(timeout=5)
        assert not worker.is_alive()
        assert not failures
        assert len(outcomes) == 1
        worker_id, message = outcomes[0]
        assert worker_id != manager._creation_thread_id
        assert str(worker_id) in message
        assert str(manager._creation_thread_id) in message
        manager.close()


@pytest.mark.parametrize(
    "ui_element, raw, expected",
    [
        ("number", "3.5", 3.5),
        ("range", "7", 7),
        ("multiselect", '["first","second"]', ["first", "second"]),
        ("checkbox", "false", False),
        ("json", '{"selected":true}', {"selected": True}),
    ],
)
def test_valid_environment_values_remain_usable(
    monkeypatch, ui_element, raw, expected
):
    monkeypatch.setenv(_ENV, raw)
    assert settings.get_typed_setting_value(_KEY, None, ui_element) == expected