~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
test(filters): cover journal reputation filter edge branches (#6125)
LearningCircuit20f285683ffe
diff --git a/tests/advanced_search_system/filters/test_journal_reputation_filter_edges.py b/tests/advanced_search_system/filters/test_journal_reputation_filter_edges.pynew file mode 100644index 0000000000..b55380782c--- /dev/null+++ b/tests/advanced_search_system/filters/test_journal_reputation_filter_edges.py@@ -0,0 +1,386 @@+"""Exercise journal-filter edge branches that broad happy-path tests miss.++These cases exist because malformed venue metadata, unavailable reference data,+and failed optional cache/LLM operations must not silently distort search+quality. Every external boundary is replaced in memory; no test uses network+or writes outside pytest's ``tmp_path``.+"""++import pathlib+import threading+from datetime import timedelta+from pathlib import Path+from typing import Final+from unittest.mock import MagicMock, patch++import pytest++from local_deep_research.advanced_search_system.filters import (+ journal_reputation_filter as journal_filter_module,+)+from local_deep_research.advanced_search_system.filters.journal_reputation_filter import (+ JournalReputationFilter,+ _format_affiliations,+ _sanitize_name,+)+++MODULE: Final = journal_filter_module.__name__+++def _hide_journal_quality_db(monkeypatch: pytest.MonkeyPatch) -> None:+ """Report ``journal_quality.db`` as absent so the pending branch runs.++ The autouse conftest fixture forces the db-ready probe to pass for+ every test in this directory; overriding it here — as that fixture's+ docstring prescribes — lets a test exercise the not-built path.+ """+ conftest_exists = pathlib.Path.exists++ def _exists_without_db(path: pathlib.Path) -> bool:+ if path.name == "journal_quality.db":+ return False+ return conftest_exists(path)++ monkeypatch.setattr(pathlib.Path, "exists", _exists_without_db)+++def _bare_filter(+ *, threshold: int = 4, exclude_non_published: bool = False+) -> JournalReputationFilter:+ filter_obj = JournalReputationFilter.__new__(JournalReputationFilter)+ filter_obj.model = MagicMock()+ filter_obj._owns_llm = False+ filter_obj._JournalReputationFilter__threshold = threshold+ filter_obj._JournalReputationFilter__max_context = 20+ filter_obj._JournalReputationFilter__exclude_non_published = (+ exclude_non_published+ )+ filter_obj._JournalReputationFilter__quality_reanalysis_period = timedelta(+ days=365+ )+ filter_obj._JournalReputationFilter__settings_snapshot = None+ filter_obj._JournalReputationFilter__searxng_available = False+ filter_obj._JournalReputationFilter__tls = threading.local()+ filter_obj._JournalReputationFilter__engine_lock = threading.Lock()+ filter_obj._JournalReputationFilter__engine = MagicMock()+ filter_obj._JournalReputationFilter__db_session = MagicMock(+ return_value=None+ )++ data_manager = MagicMock()+ data_manager.is_predatory.return_value = (False, None)+ data_manager.is_whitelisted.return_value = False+ data_manager.lookup_openalex.return_value = None+ data_manager.lookup_doaj.return_value = None+ data_manager.score_from_affiliations.return_value = None+ data_manager.expand_abbreviation.return_value = None+ data_manager._engine = MagicMock()+ filter_obj._JournalReputationFilter__data_manager = data_manager+ return filter_obj+++def test_sanitize_name_bounds_and_normalizes_untrusted_metadata() -> None:+ raw = '\u202e\uff2a\uff4f\uff55\uff52\uff4e\uff41\uff4c"' + ("x" * 600)++ sanitized = _sanitize_name(raw)++ assert len(sanitized) <= 503 # 500 + "..."+ assert sanitized.startswith("Journal'")+ assert sanitized.endswith("...")+++ ("affiliations", "expected"),+ [+ ([], "(none)"),+ ([{"unrelated": "value"}], "(unknown)"),+ (+ ["One", {"name": "Two"}, {"display_name": "Three"}, "Four"],+ "One, Two, Three (+1 more)",+ ),+ ],+)+def test_format_affiliations_handles_missing_and_mixed_metadata(+ affiliations: list, expected: str+) -> None:+ assert _format_affiliations(affiliations) == expected+++ "failure",+ [ConnectionError("down"), TimeoutError("late"), ValueError("bad")],+)+def test_llm_name_cleanup_returns_none_for_expected_failures(+ failure: Exception,+) -> None:+ filter_obj = _bare_filter()+ filter_obj.model.invoke.side_effect = failure++ cleaned = filter_obj._JournalReputationFilter__llm_clean_journal_name(+ "Unknown Venue"+ )++ assert cleaned is None+++def test_llm_name_cleanup_rejects_empty_response() -> None:+ filter_obj = _bare_filter()+ filter_obj.model.invoke.return_value = MagicMock(content=" '' ")++ cleaned = filter_obj._JournalReputationFilter__llm_clean_journal_name(+ "Venue"+ )++ assert cleaned is None+++def test_tier4_rejects_search_results_without_usable_text() -> None:+ filter_obj = _bare_filter()+ filter_obj._JournalReputationFilter__engine.run.return_value = [+ {"snippet": "", "content": ""},+ {},+ ]++ with pytest.raises(ValueError, match="No search results"):+ filter_obj._JournalReputationFilter__analyze_journal_reputation("Venue")++ filter_obj.model.invoke.assert_not_called()+++def test_repository_score_is_lifted_by_stronger_affiliation() -> None:+ filter_obj = _bare_filter()+ data_manager = filter_obj._JournalReputationFilter__data_manager+ data_manager.lookup_openalex.return_value = {+ "h_index": 2,+ "type": "repository",+ "quartile": None,+ }+ data_manager.derive_quality_score.return_value = 4+ data_manager.score_from_affiliations.return_value = 6++ score = filter_obj._JournalReputationFilter__score_journal(+ "Preprint Server", {"affiliations": [{"name": "Strong University"}]}+ )++ assert score == (6, "institution")+++def test_unmatched_venue_uses_affiliation_score() -> None:+ filter_obj = _bare_filter()+ data_manager = filter_obj._JournalReputationFilter__data_manager+ data_manager.score_from_affiliations.return_value = 5++ score = filter_obj._JournalReputationFilter__score_journal(+ "Unindexed Venue", {"affiliations": ["Known Institute"]}+ )++ assert score == (5, "institution")+++ ("name", "derived_score", "expected"),+ [+ ("Proceedings of the Royal Society", 6, (3, "low_confidence")),+ ("Workshop on Reliable Search", 6, (6, "conference")),+ ],+)+def test_conference_heuristic_tags_proceedings_journals_as_low_confidence(+ name: str, derived_score: int, expected: tuple[int, str]+) -> None:+ filter_obj = _bare_filter()+ data_manager = filter_obj._JournalReputationFilter__data_manager+ data_manager.derive_quality_score.return_value = derived_score++ score = filter_obj._JournalReputationFilter__score_journal(name, {})++ assert score == expected+++def test_cache_update_normalizes_name_and_rolls_back_failed_commit() -> None:+ filter_obj = _bare_filter()+ journal = MagicMock()+ db_session = MagicMock()+ db_session.query.return_value.filter_by.return_value.first.return_value = (+ journal+ )+ db_session.commit.side_effect = RuntimeError("locked")+ session_context = MagicMock()+ session_context.__enter__.return_value = db_session++ with patch(f"{MODULE}.get_model_identifier", return_value="model-v1"):+ filter_obj._save_journal_to_db_inner(+ session_context, name=" NATURE™ ", quality=8+ )++ assert journal.name_lower == "naturetm"+ assert journal.quality == 8+ db_session.rollback.assert_called_once_with()++[email protected]("scope_blocks_fetch", [False, True])+def test_missing_reference_db_maps_pending_results_without_network(+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch, scope_blocks_fetch: bool+) -> None:+ _hide_journal_quality_db(monkeypatch)+ filter_obj = _bare_filter(exclude_non_published=True)+ filter_obj._JournalReputationFilter__data_manager._engine = None+ results = [+ {"title": "Published", "journal_ref": "Venue"},+ {"title": "Missing venue"},+ # Pending path checks `journal_ref` raw (filter.py:1299); the+ # scoring path strips it first (filter.py:1373-1378). "" is+ # falsy under both, so this doesn't distinguish the two.+ {"title": "Empty venue", "journal_ref": ""},+ ]++ with (+ patch(+ "local_deep_research.config.paths.get_journal_data_directory",+ return_value=tmp_path,+ ),+ patch.object(+ filter_obj,+ "_should_skip_journal_fetch_for_scope",+ return_value=scope_blocks_fetch,+ ),+ patch(f"{MODULE}._start_background_journal_fetch") as start_fetch,+ ):+ filtered = filter_obj.filter_results(results, "query")++ assert [result["title"] for result in filtered] == ["Published"]+ assert filtered[0]["journal_quality"] == "pending"+ assert start_fetch.call_count == (0 if scope_blocks_fetch else 1)+++def test_pass_one_uses_richer_duplicate_metadata_and_caches_cleaning(+ tmp_path: Path,+) -> None:+ filter_obj = _bare_filter()+ results = [+ {"title": "Sparse", "journal_ref": "Nature raw"},+ {+ "title": "Rich",+ "journal_ref": "Nature raw",+ "issn": "0028-0836",+ },+ ]++ with (+ patch.object(+ filter_obj,+ "_JournalReputationFilter__clean_journal_name",+ return_value="Nature",+ ) as clean_name,+ patch.object(+ filter_obj,+ "_JournalReputationFilter__score_journal",+ return_value=(8, "openalex"),+ ) as score_journal,+ patch(+ "local_deep_research.config.paths.get_journal_data_directory",+ return_value=tmp_path,+ ),+ ):+ filtered = filter_obj.filter_results(results, "query")++ assert len(filtered) == 2+ clean_name.assert_called_once_with("Nature raw")+ assert score_journal.call_count == 1+ assert score_journal.call_args.args[1]["issn"] == "0028-0836"+++def test_cleaned_empty_name_falls_back_to_no_venue_institution(+ tmp_path: Path,+) -> None:+ filter_obj = _bare_filter(threshold=5)+ data_manager = filter_obj._JournalReputationFilter__data_manager+ data_manager.score_from_affiliations.return_value = 5+ result = {+ "title": "Volume-only metadata",+ "journal_ref": "Vol. 3",+ "affiliations": [{"display_name": "Institute"}],+ }++ with (+ patch(+ "local_deep_research.config.paths.get_journal_data_directory",+ return_value=tmp_path,+ ),+ patch.object(+ filter_obj,+ "_JournalReputationFilter__clean_journal_name",+ return_value="",+ ),+ ):+ filtered = filter_obj.filter_results([result], "query")++ assert filtered == [result]+ assert result["journal_quality"] == 5+++def test_llm_name_cleanup_returns_cleaned_name() -> None:+ filter_obj = _bare_filter()+ filter_obj.model.invoke.return_value = MagicMock(content='"Nature Journal"')++ cleaned = filter_obj._JournalReputationFilter__llm_clean_journal_name(+ "Nature raw"+ )++ assert cleaned == "Nature Journal"+++def test_pending_mode_keeps_venueless_results_when_not_excluding(+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch+) -> None:+ _hide_journal_quality_db(monkeypatch)+ filter_obj = _bare_filter(exclude_non_published=False)+ filter_obj._JournalReputationFilter__data_manager._engine = None+ results = [+ {"title": "Published", "journal_ref": "Venue"},+ {"title": "No venue"},+ ]++ with (+ patch(+ "local_deep_research.config.paths.get_journal_data_directory",+ return_value=tmp_path,+ ),+ patch.object(+ filter_obj,+ "_should_skip_journal_fetch_for_scope",+ return_value=True,+ ),+ patch(f"{MODULE}._start_background_journal_fetch") as start_fetch,+ ):+ filtered = filter_obj.filter_results(results, "query")++ assert [result["title"] for result in filtered] == [+ "Published",+ "No venue",+ ]+ assert filtered[0]["journal_quality"] == "pending"+ assert "journal_quality" not in filtered[1]+ start_fetch.assert_not_called()+++def test_invalid_db_ready_probe_fails_soft_to_pending(tmp_path: Path) -> None:+ filter_obj = _bare_filter()+ filter_obj._JournalReputationFilter__data_manager._engine = None++ with (+ patch(+ "local_deep_research.config.paths.get_journal_data_directory",+ side_effect=RuntimeError("bad path"),+ ),+ patch.object(+ filter_obj,+ "_should_skip_journal_fetch_for_scope",+ return_value=True,+ ),+ ):+ filtered = filter_obj.filter_results(+ [{"title": tmp_path.name, "journal_ref": "Venue"}], "query"+ )++ assert filtered[0]["journal_quality"] == "pending"