Personal AI, On Personal Devices
Python
"""Regression coverage for background connector writes during test teardown."""
from __future__ import annotations
import hashlib
import threading
from types import SimpleNamespace
import pytest
def test_delayed_sync_finishes_before_database_paths_are_restored(
tmp_path, monkeypatch
):
"""A worker delayed before opening its DB must never use restored defaults."""
pytest.importorskip("fastapi")
from fastapi import FastAPI
from fastapi.testclient import TestClient
from openjarvis.connectors import embeddings, sync_engine
from openjarvis.connectors.pipeline import IngestionPipeline
from openjarvis.connectors.store import KnowledgeStore
from openjarvis.core import config
from openjarvis.server import connectors_router
from tests.server.conftest import _finish_connector_syncs, _isolate_connector_dbs
baseline = tmp_path / "restored-home"
isolated = tmp_path / "isolated-home"
isolated.mkdir()
monkeypatch.setattr(config, "DEFAULT_CONFIG_DIR", baseline)
monkeypatch.setattr(sync_engine, "DEFAULT_CONFIG_DIR", baseline)
monkeypatch.setattr(embeddings, "default_embedder", lambda: None)
monkeypatch.setattr(connectors_router, "_instances", {})
with KnowledgeStore() as store:
store.store(content="Existing user note", source="obsidian")
with sync_engine.SyncEngine(IngestionPipeline(store=store)) as engine:
engine._save_checkpoint("obsidian", 7, cursor="original")
before = {
name: hashlib.sha256((baseline / name).read_bytes()).digest()
for name in ("knowledge.db", "sync_state.db")
}
started = threading.Event()
release = threading.Event()
joining = threading.Event()
finished = threading.Event()
errors = []
real_init = KnowledgeStore.__init__
real_join = threading.Thread.join
def delayed_init(self, *args, **kwargs):
if "_run_sync" in threading.current_thread().name:
started.set()
if not release.wait(10):
raise TimeoutError("test did not release its sync worker")
real_init(self, *args, **kwargs)
def observed_join(self, *args, **kwargs):
if "_run_sync" in self.name:
joining.set()
return real_join(self, *args, **kwargs)
monkeypatch.setattr(KnowledgeStore, "__init__", delayed_init)
monkeypatch.setattr(threading.Thread, "join", observed_join)
isolation = _isolate_connector_dbs.__wrapped__(
SimpleNamespace(mktemp=lambda _name: isolated)
)
next(isolation)
with pytest.MonkeyPatch.context() as worker_patch:
cleanup = _finish_connector_syncs.__wrapped__(worker_patch)
next(cleanup)
def teardown():
try:
cleanup.close()
isolation.close()
except BaseException as exc:
errors.append(exc)
finally:
finished.set()
teardown_thread = threading.Thread(target=teardown)
try:
vault = tmp_path / "vault"
vault.mkdir()
(vault / "fixture.md").write_text("Fixture content must stay isolated.")
app = FastAPI()
app.include_router(connectors_router.create_connectors_router())
client = TestClient(app)
response = client.post(
"/v1/connectors/obsidian/connect", json={"path": str(vault)}
)
assert response.status_code == 200
assert started.wait(5)
teardown_thread.start()
assert joining.wait(5)
assert not finished.is_set()
assert config.DEFAULT_CONFIG_DIR == isolated
assert sync_engine.DEFAULT_CONFIG_DIR == isolated
finally:
release.set()
if teardown_thread.ident is not None:
teardown_thread.join(timeout=10)
else:
cleanup.close()
isolation.close()
assert not teardown_thread.is_alive()
assert not errors
assert finished.is_set()
assert config.DEFAULT_CONFIG_DIR == baseline
assert sync_engine.DEFAULT_CONFIG_DIR == baseline
assert before == {
name: hashlib.sha256((baseline / name).read_bytes()).digest() for name in before
}
with KnowledgeStore(db_path=isolated / "knowledge.db") as store:
assert store.retrieve("Fixture content", top_k=10)
with KnowledgeStore(db_path=isolated / "knowledge.db") as store:
with sync_engine.SyncEngine(
IngestionPipeline(store=store), state_db=str(isolated / "sync_state.db")
) as engine:
assert engine.get_checkpoint("obsidian")["items_synced"] > 0