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.

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.py
new file mode 100644
index 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"