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(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.py
index 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.py
index 4fcdd83e1a..98d71384af 100644
--- a/tests/embeddings/test_model_cache_serial.py
+++ b/tests/embeddings/test_model_cache_serial.py
@@ -4,6 +4,7 @@ import asyncio
from concurrent.futures import ThreadPoolExecutor
import gc
from threading import Event, Lock
+import time
import weakref
import pytest
@@ -11,6 +12,7 @@ import pytest
from local_deep_research.embeddings import model_cache
from 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():
pass
assert 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"]