fix: await ensure_collection and survive partial embed failures in document sync

- ensure_collection was called without await, so the coroutine never ran
  and fresh tenants had no collection when the upsert hit Qdrant
- a single None entry from embed_batch poisoned the point batch and
  aborted the whole document upsert; failed chunks are now skipped with
  a warning (all-failed raises and the IndexResult reports failure)
- raw client.delete/client.upsert calls now go through the async wrapper
  (delete_by_filter and the new batch upsert_points method)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QbFZyDvYksazX6nYQYZ67L

tests/test_document_sync.py

@@ -0,0 +1,135 @@
+"""
+Offline unit tests for DocumentSyncService vector indexing fixes.
+
+Pins the Phase D fixes:
+- ensure_collection is actually awaited (it used to be a bare coroutine
+  that never ran, so fresh tenants had no collection at upsert time)
+- None entries from embed_batch are filtered out instead of poisoning
+  the whole batch upsert (one failed chunk aborted the document)
+- raw client.delete/client.upsert calls are routed through the async
+  wrapper methods (delete_by_filter / upsert_points)
+"""
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from src.services.document_sync_service import DocumentSyncService
+
+TENANT = "llm_tester"
+TENANT_COLLECTION = "library_desk_llm_tester"
+
+
+@pytest.fixture
+def mock_qdrant():
+    qdrant = MagicMock()
+    qdrant.ensure_collection = AsyncMock()
+    qdrant.delete_by_filter = AsyncMock(return_value=0)
+    qdrant.upsert_points = AsyncMock(side_effect=lambda collection_name, points: len(points))
+    return qdrant
+
+
+@pytest.fixture
+def mock_ollama():
+    ollama = MagicMock()
+    ollama.embed_batch = AsyncMock(
+        side_effect=lambda texts: [[0.1] * 768 for _ in texts]
+    )
+    return ollama
+
+
+@pytest.fixture
+def mock_neo4j():
+    neo4j = MagicMock()
+    neo4j.execute_query = AsyncMock(return_value=[])
+    return neo4j
+
+
+@pytest.fixture
+def mock_paperless():
+    paperless = MagicMock()
+    paperless.get_custom_field_by_name = AsyncMock(return_value=None)
+    return paperless
+
+
+@pytest.fixture
+def sync_service(mock_paperless, mock_qdrant, mock_ollama, mock_neo4j):
+    return DocumentSyncService(
+        paperless_client=mock_paperless,
+        qdrant_client=mock_qdrant,
+        ollama_client=mock_ollama,
+        neo4j_client=mock_neo4j,
+        wiki_client=MagicMock(),
+        settings=MagicMock(),
+    )
+
+
+@pytest.mark.unit
+class TestIndexVectors:
+    async def test_ensure_collection_is_awaited(self, sync_service, mock_qdrant):
+        result = await sync_service.index_document(
+            document_id=1, user=TENANT, content="hello world", title="Doc"
+        )
+
+        assert result.success is True
+        mock_qdrant.ensure_collection.assert_awaited_once_with(TENANT_COLLECTION)
+
+    async def test_delete_routed_through_wrapper(self, sync_service, mock_qdrant):
+        await sync_service.index_document(
+            document_id=7, user=TENANT, content="hello world", title="Doc"
+        )
+
+        mock_qdrant.delete_by_filter.assert_awaited_once_with(
+            collection_name=TENANT_COLLECTION,
+            filter_conditions={"doc_type": "document", "paperless_id": 7},
+        )
+
+    async def test_upsert_routed_through_wrapper(self, sync_service, mock_qdrant):
+        result = await sync_service.index_document(
+            document_id=1, user=TENANT, content="hello world", title="Doc"
+        )
+
+        assert result.chunks_created == 1
+        kwargs = mock_qdrant.upsert_points.await_args.kwargs
+        assert kwargs["collection_name"] == TENANT_COLLECTION
+        payload = kwargs["points"][0]["payload"]
+        assert payload["doc_type"] == "document"
+        assert payload["paperless_id"] == 1
+
+    async def test_failed_chunk_embedding_is_skipped_not_fatal(
+        self, sync_service, mock_qdrant, mock_ollama
+    ):
+        # Three chunks; the middle embedding fails
+        long_content = " ".join(f"word{i}" for i in range(1200))
+        mock_ollama.embed_batch = AsyncMock(
+            side_effect=lambda texts: [
+                [0.1] * 768 if i != 1 else None for i in range(len(texts))
+            ]
+        )
+
+        result = await sync_service.index_document(
+            document_id=2, user=TENANT, content=long_content, title="Doc"
+        )
+
+        assert result.success is True
+        points = mock_qdrant.upsert_points.await_args.kwargs["points"]
+        assert result.chunks_created == len(points)
+        # The failed chunk (index 1) is absent, the others kept their index
+        indices = [p["payload"]["chunk_index"] for p in points]
+        assert 1 not in indices
+        assert len(indices) >= 2
+
+    async def test_all_embeddings_failed_reports_failure(
+        self, sync_service, mock_qdrant, mock_ollama
+    ):
+        mock_ollama.embed_batch = AsyncMock(
+            side_effect=lambda texts: [None for _ in texts]
+        )
+
+        result = await sync_service.index_document(
+            document_id=3, user=TENANT, content="hello world", title="Doc"
+        )
+
+        assert result.success is False
+        assert "embed" in (result.error or "").lower()
+        mock_qdrant.upsert_points.assert_not_awaited()