~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(embeddings): cover writer priority, failed reload recovery, and shutdown cache clear (#7472)
Masyarakat AI Indonesia - FMDa71ce0ae731f
diff --git a/tests/embeddings/test_model_cache.py b/tests/embeddings/test_model_cache.pyindex 7ec961dcb3..7e5dfbc8d5 100644--- a/tests/embeddings/test_model_cache.py+++ b/tests/embeddings/test_model_cache.py@@ -200,6 +200,58 @@ def test_failed_load_is_retryable_and_never_poisoned(tmp_path):assert len(attempts) == 2+def test_failed_reload_is_retryable_and_never_poisoned(tmp_path):+ attempts = []+ failing = False++ def factory(**kwargs):+ attempts.append(kwargs)+ if failing:+ raise OSError("synthetic reload failure")+ return CyclicBackend(**kwargs)++ def create(name="synthetic/model"):+ return shared_sentence_transformer_embeddings(+ factory, model_name=name, cache_folder=str(tmp_path)+ )++ client = create()+ assert client.embed_query("resident") == [8.0]+ create("synthetic/other") # Evict without closing the first handle.+ failing = True+ with pytest.raises(OSError, match="synthetic reload failure"):+ client.embed_query("must fail")+ # A failed reload must leave nothing behind that an old handle could+ # mistake for its own weights.+ assert model_cache._MODEL_CACHE.key is None+ assert model_cache._MODEL_CACHE.backend is None+ failing = False+ assert client.embed_query("retry") == [5.0]+ assert model_cache._MODEL_CACHE.key == client._key+ assert len(attempts) == 4+++def test_shutdown_cache_clear_is_registered_without_waiting(monkeypatch):+ import atexit+ import importlib++ registrations = []+ monkeypatch.setattr(+ atexit,+ "register",+ lambda func, **kwargs: registrations.append((func, kwargs)),+ )+ try:+ importlib.reload(model_cache)+ assert registrations == [+ (model_cache.clear_sentence_transformer_cache, {"wait": False})+ ]+ finally:+ # undo() puts atexit.register back; reloading again here would only add a+ # duplicate handler for the real one.+ monkeypatch.undo()++def test_encoding_options_are_part_of_the_configuration(tmp_path):calls = []diff --git a/tests/embeddings/test_model_cache_serial.py b/tests/embeddings/test_model_cache_serial.pyindex 4fcdd83e1a..98d71384af 100644--- a/tests/embeddings/test_model_cache_serial.py+++ b/tests/embeddings/test_model_cache_serial.py@@ -4,6 +4,7 @@ import asynciofrom concurrent.futures import ThreadPoolExecutorimport gcfrom threading import Event, Lock+import timeimport weakrefimport pytest@@ -11,6 +12,7 @@ import pytestfrom local_deep_research.embeddings import model_cachefrom local_deep_research.embeddings.model_loading import (MODEL_LOAD_LOCK,+ ModelAccessLock,load_sentence_transformer,)@@ -405,3 +407,67 @@ def test_reader_gate_rejects_unsafe_upgrade_and_remains_usable():with MODEL_LOAD_LOCK.inference():passassert model_cache.clear_sentence_transformer_cache(wait=False)+++def test_blocked_writer_is_served_before_new_readers():+ lock = ModelAccessLock()+ reader_holding, release_reader = Event(), Event()+ writer_requested, writer_holding, release_writer = (+ Event(),+ Event(),+ Event(),+ )+ late_reader_holding = Event()+ order = []+ order_lock = Lock()++ def record(step):+ with order_lock:+ order.append(step)++ def hold_shared():+ with lock.inference():+ record("reader")+ reader_holding.set()+ assert release_reader.wait(timeout=10)++ def write_exclusively():+ assert reader_holding.wait(timeout=10)+ writer_requested.set()+ with lock:+ record("writer")+ writer_holding.set()+ assert release_writer.wait(timeout=10)++ def read_late():+ with lock.inference():+ record("late-reader")+ late_reader_holding.set()++ with ThreadPoolExecutor(max_workers=3) as executor:+ reader = executor.submit(hold_shared)+ assert reader_holding.wait(timeout=10)+ writer = executor.submit(write_exclusively)+ assert writer_requested.wait(timeout=10)+ # Wait until the writer is blocked behind the shared holder so the+ # late reader arrives while a writer is already waiting. The lock+ # exposes no public "a writer is waiting" probe, so poll the waiter+ # count its writer priority is built on.+ deadline = time.monotonic() + 10+ while lock._waiting_writers == 0 and time.monotonic() < deadline:+ time.sleep(0.01)+ assert lock._waiting_writers == 1+ late = executor.submit(read_late)+ try:+ # New readers must not be admitted ahead of the waiting writer.+ assert not late_reader_holding.wait(timeout=0.2)+ release_reader.set()+ assert writer_holding.wait(timeout=10)+ assert not late_reader_holding.wait(timeout=0.2)+ finally:+ release_reader.set()+ release_writer.set()+ reader.result(timeout=10)+ writer.result(timeout=10)+ late.result(timeout=10)+ assert order == ["reader", "writer", "late-reader"]