test(vector_store): fix two pgvector tests the first live CI run exposed

.github/workflows/integration.yml

@@ -0,0 +1,99 @@
+name: Integration Tests
+
+# Separate from ci.yml, which is a required check: a slow image pull or a
+# container flake must not block unrelated merges.
+
+permissions:
+  contents: read
+
+on:
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - 'docs_check.py'
+      - '**/*.md'
+  schedule:
+    - cron: '0 5 * * 1'
+  workflow_dispatch:
+
+jobs:
+  pgvector:
+    name: pgvector (live PostgreSQL)
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+
+    services:
+      postgres:
+        # pgvector/pgvector:pg16 as published 2026-08-13. Pinned by digest like
+        # the action pins, though verify-action-pins.sh does not check images.
+        image: pgvector/pgvector@sha256:ccc6e83d6e35e931dc7c5def2022729d5a6c370318d099181995567ff1fb4d6b
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_DB: test
+          # Throwaway container reachable only from this job, so trust auth
+          # avoids putting a credential in the workflow at all.
+          POSTGRES_HOST_AUTH_METHOD: trust
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd "pg_isready -U postgres -d test"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 10
+
+    env:
+      TEST_PGVECTOR_URL: postgresql://postgres@localhost:5432/test
+
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+
+      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7
+        with:
+          python-version: '3.11'
+          cache: 'pip'
+
+      - name: Install semantica with the pgvector extra
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[vectorstore-pgvector]" pytest==9.1.1
+
+      - name: Create the vector extension
+        # PgVectorStore._verify_pgvector_extension() requires it and refuses to
+        # create it. Doubles as the connectivity gate.
+        run: |
+          python - <<'PY'
+          import os
+
+          import psycopg
+
+          with psycopg.connect(os.environ["TEST_PGVECTOR_URL"]) as conn:
+              conn.execute("CREATE EXTENSION IF NOT EXISTS vector")
+              conn.commit()
+          print("vector extension ready")
+          PY
+
+      - name: Run the live pgvector suite
+        run: |
+          pytest tests/vector_store/test_pgvector_store.py -v -rs \
+            --junit-xml=junit.xml
+
+      - name: Fail if the suite skipped instead of running
+        # The suite skips itself when it cannot reach Postgres, so pytest would
+        # exit 0 having run nothing. Without this the job is green either way.
+        if: always()
+        run: |
+          python - <<'PY'
+          import sys
+          import xml.etree.ElementTree as ET
+
+          root = ET.parse("junit.xml").getroot()
+          suites = root.findall("testsuite") or [root]
+          total = sum(int(s.get("tests", 0)) for s in suites)
+          skipped = sum(int(s.get("skipped", 0)) for s in suites)
+
+          if total == 0:
+              sys.exit("no tests were collected")
+          if skipped:
+              sys.exit(f"{skipped} of {total} tests skipped; the live suite did not run")
+          print(f"{total} tests ran, none skipped")
+          PY

tests/vector_store/test_backend_facade_contract.py

@@ -1,142 +0,0 @@
-"""Facade-level contract tests for the cloud vector store backends.
-
-Other tests here either mock a backend's internals or inject a fake into
-``VectorStore._backend_store``. Both skip ``_init_backend_store``, which is
-where the qdrant/pinecone/milvus/weaviate adapters are built, and that is how
-#1316 shipped green while a qdrant-backed store could neither read nor write.
-
-Gaps are recorded as strict xfail so they turn into XPASS once the wiring
-lands, failing the suite until the stale marker is removed.
-
-Related: #1265, #1019.
-"""
-
-from contextlib import ExitStack
-from unittest.mock import MagicMock, patch
-
-import numpy as np
-import pytest
-
-from semantica.vector_store import VectorStore
-
-# Availability flag per backend, plus every symbol its connect/select path
-# calls. The clients must be patched too: without the real SDK installed they
-# are None, so a fixed _init_backend_store would still fail and these could
-# never reach XPASS. Extend these if the wiring touches more symbols.
-_AVAILABILITY_FLAG = {
-    "qdrant": "semantica.vector_store.qdrant_store.QDRANT_AVAILABLE",
-    "pinecone": "semantica.vector_store.pinecone_store.PINECONE_AVAILABLE",
-    "milvus": "semantica.vector_store.milvus_store.MILVUS_AVAILABLE",
-    "weaviate": "semantica.vector_store.weaviate_store.WEAVIATE_AVAILABLE",
-}
-
-_CLIENT_SYMBOLS = {
-    "qdrant": ("semantica.vector_store.qdrant_store.QdrantClientLib",),
-    "pinecone": ("semantica.vector_store.pinecone_store.PineconeClientLib",),
-    "milvus": (
-        "semantica.vector_store.milvus_store.connections",
-        "semantica.vector_store.milvus_store.Collection",
-        "semantica.vector_store.milvus_store.utility",
-    ),
-    "weaviate": ("semantica.vector_store.weaviate_store.weaviate",),
-}
-
-# Pinecone refuses to connect without a key, so supply a dummy one rather than
-# letting a missing credential masquerade as the wiring gap.
-_EXTRA_CONFIG = {"pinecone": {"api_key": "test-key"}}
-
-CLOUD_BACKENDS = sorted(_AVAILABILITY_FLAG)
-
-# Backends that store locally and need no connection step.
-_LOCAL_BACKENDS = {"inmemory", "faiss", "sqlite", "pgvector"}
-
-# The facade dispatches store_vectors() to `add` or `add_vectors`. Milvus
-# exposes add_vectors so it already resolves; the other three name their write
-# method differently and fall through to NotImplementedError.
-_NO_WRITE_DISPATCH = {"qdrant", "pinecone", "weaviate"}
-
-
-def _construct(backend):
-    """Build a VectorStore through the real _init_backend_store path."""
-    config = {"dimension": 3, **_EXTRA_CONFIG.get(backend, {})}
-    with ExitStack() as stack:
-        stack.enter_context(patch(_AVAILABILITY_FLAG[backend], True))
-        for symbol in _CLIENT_SYMBOLS[backend]:
-            stack.enter_context(patch(symbol, MagicMock()))
-        return VectorStore(backend=backend, config=config)
-
-
-def _live_handle(backend_store):
-    """The attribute each adapter holds its connected resource in.
-
-    Reaching into the adapter rather than asserting through the facade is
-    deliberate: the facade's read methods are exactly what is broken, so there
-    is no public call that distinguishes "not connected" from the other gaps.
-    """
-    for name in ("collection", "index"):
-        if hasattr(backend_store, name):
-            return getattr(backend_store, name)
-    return None
-
-
-def _param(backend, broken_for, reason):
-    marks = [pytest.mark.xfail(strict=True, reason=reason)] if backend in broken_for else []
-    return pytest.param(backend, marks=marks)
-
-
-def test_roster_covers_every_supported_backend():
-    """A new backend must be classified here rather than silently uncovered."""
-    assert set(CLOUD_BACKENDS) | _LOCAL_BACKENDS == VectorStore.SUPPORTED_BACKENDS
-
-
-@pytest.mark.parametrize("backend", CLOUD_BACKENDS)
-def test_facade_constructs_an_adapter(backend):
-    store = _construct(backend)
-
-    assert store._backend_store is not None
-    assert store.backend == backend
-
-
-@pytest.mark.parametrize(
-    "backend",
-    [
-        _param(b, CLOUD_BACKENDS, "_init_backend_store never connects or selects a collection")
-        for b in CLOUD_BACKENDS
-    ],
-)
-def test_backend_is_connected_after_construction(backend):
-    """A constructed store should be usable without the caller reaching past
-    the facade to call connect() and get_collection() itself."""
-    store = _construct(backend)
-
-    assert _live_handle(store._backend_store) is not None
-
-
-@pytest.mark.parametrize(
-    "backend",
-    [
-        _param(b, _NO_WRITE_DISPATCH, "facade dispatches only to add/add_vectors")
-        for b in CLOUD_BACKENDS
-    ],
-)
-def test_store_vectors_dispatch_resolves(backend):
-    """store_vectors() should reach the backend's write method."""
-    store = _construct(backend)
-
-    try:
-        store.store_vectors([np.zeros(3)], [{}], ids=["a"])
-    except NotImplementedError as exc:
-        pytest.fail(f"no write dispatch for {backend}: {exc}")
-    except Exception:
-        # Any other error means the facade found a write method and the failure
-        # came from below it, which is the connection gap the test above pins.
-        # Whether the write succeeds needs a live server, not this test.
-        pass
-
-
-def test_milvus_write_dispatch_already_resolves():
-    """Control for _NO_WRITE_DISPATCH: if milvus changes, the xfail list is
-    wrong rather than the feature being broken."""
-    store = _construct("milvus")
-
-    assert hasattr(store._backend_store, "add_vectors")

tests/vector_store/test_pgvector_store.py

@@ -10,7 +10,7 @@ To run these tests locally with Docker:
         -e POSTGRES_PASSWORD=postgres \
         -e POSTGRES_DB=test \
         -p 5432:5432 \
-        ankane/pgvector:latest
+        pgvector/pgvector:pg16
 
     pytest tests/vector_store/test_pgvector_store.py -v
 
@@ -191,7 +191,9 @@ class TestPgVectorStoreAdd:
         ids = store.add(vectors, metadata)
 
         assert len(ids) == 5
-        assert all(id.startswith("vec_") for id in ids)
+        assert len(set(ids)) == 5
+        # add() assigns uuid4 identifiers, not a "vec_" prefix
+        assert all(uuid.UUID(vector_id) for vector_id in ids)
 
     def test_add_auto_generate_ids(self, store):
         """Test that IDs are auto-generated if not provided."""
@@ -290,19 +292,37 @@ class TestPgVectorStoreSearch:
         if not pg_available:
             pytest.skip("PostgreSQL not available")
 
-        from semantica.vector_store.pgvector_store import PgVectorStore
+        from semantica.vector_store.pgvector_store import PgVectorStore, psycopg_sql
 
+        # setup_vectors is autouse and seeds unique_table_name, and fixtures are
+        # cached per test, so this needs a table of its own to be empty at all.
+        empty_table = f"{unique_table_name}_empty"
         empty_store = PgVectorStore(
             connection_string=TEST_CONNECTION_STRING,
-            table_name=unique_table_name,
+            table_name=empty_table,
             dimension=128,
             distance_metric="cosine",
         )
 
-        query = np.random.rand(128).astype(np.float32)
-        results = empty_store.search(query, top_k=5)
+        try:
+            query = np.random.rand(128).astype(np.float32)
+            results = empty_store.search(query, top_k=5)
 
-        assert len(results) == 0
+            assert len(results) == 0
+        finally:
+            try:
+                with empty_store._get_connection() as conn:
+                    cur = conn.cursor()
+                    cur.execute(
+                        psycopg_sql.SQL("DROP TABLE IF EXISTS {}").format(
+                            psycopg_sql.Identifier(empty_table)
+                        )
+                    )
+                    conn.commit()
+                    cur.close()
+                empty_store.close()
+            except Exception:
+                pass
 
         # Cleanup: Drop test table after test completes
         # Uses best-effort cleanup - failures are silently ignored since