@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/audit_orchestrator/tests/integration/test_hybrid_search.py

@@ -1,799 +0,0 @@
-"""Integration tests for Phase 47 hybrid search functionality.
-
-These tests verify the RRF (Reciprocal Rank Fusion) hybrid search implementation
-for the VDS Audit Orchestrator corpus retrieval.
-
-Test Categories:
-- Lexical search (PostgreSQL tsvector with 'simple' config)
-- Vector search (pgvector ANN/HNSW)
-- Hybrid search (RRF fusion of lexical + vector results)
-- Advisory locks for concurrent corpus updates
-
-References:
-- .kiro/specs/audit-orchestrator/design.md (RRF SQL functions)
-- FR-47.3.7 (Hybrid code retrieval with RRF fusion metadata)
-- FR-47.2.10 (Advisory lock contract)
-
-Prerequisites:
-- Docker compose with Postgres + pgvector running
-- audit_state schema initialized
-- corpus_documents and corpus_chunks tables populated
-"""
-
-from __future__ import annotations
-
-import os
-
-import pytest
-
-# Skip all tests in this module if no database is available
-# These tests require a live Postgres with pgvector extension
-pytestmark = [
-    pytest.mark.serial,
-    pytest.mark.integration,
-    pytest.mark.skipif(
-        os.environ.get("VDS_AUDIT_STATE_DSN") is None,
-        reason="VDS_AUDIT_STATE_DSN not set - hybrid search tests require database",
-    ),
-]
-
-
-# =============================================================================
-# Test Fixtures
-# =============================================================================
-
-
-@pytest.fixture
-def state_dsn() -> str:
-    """Get the state DSN from environment."""
-    dsn = os.environ.get("VDS_AUDIT_STATE_DSN")
-    if not dsn:
-        pytest.skip("VDS_AUDIT_STATE_DSN not set")
-    return dsn
-
-
-@pytest.fixture
-def db_connection(state_dsn: str):
-    """Create a database connection for testing."""
-    import psycopg
-
-    conn = psycopg.connect(state_dsn)
-    try:
-        yield conn
-    finally:
-        conn.close()
-
-
-@pytest.fixture
-def test_corpus_setup(db_connection):
-    """Set up test corpus data for search tests.
-
-    Creates a minimal test corpus with Vietnamese and English content
-    to validate lexical, vector, and hybrid search.
-    """
-    import hashlib
-    import json
-
-    cur = db_connection.cursor()
-
-    # Create test project if not exists
-    cur.execute(
-        """
-        INSERT INTO audit_state.projects (project_key, display_name, metadata)
-        VALUES ('test_hybrid_search', 'Test Hybrid Search', '{"test": true}')
-        ON CONFLICT (project_key) DO UPDATE SET display_name = EXCLUDED.display_name
-        RETURNING id
-        """
-    )
-    project_id = cur.fetchone()[0]
-
-    # Create test retrieval snapshot
-    cur.execute(
-        """
-        INSERT INTO audit_state.retrieval_snapshots
-            (snapshot_key, project_key, embedding_model_name, embedding_dimensions, lexical_only)
-        VALUES
-            ('test_snapshot_hybrid', 'test_hybrid_search', 'test-model', 384, false)
-        ON CONFLICT (snapshot_key) DO UPDATE SET embedding_model_name = EXCLUDED.embedding_model_name
-        RETURNING id
-        """
-    )
-    snapshot_id = cur.fetchone()[0]
-
-    # Create test documents with Vietnamese and English content
-    test_docs = [
-        {
-            "document_id": "doc_vn_001",
-            "content": """# Tai lieu yeu cau he thong
-
-## 1. Gioi thieu
-He thong bao hiem so la mot nen tang so hoa cho cac dich vu bao hiem.
-
-## 2. Yeu cau chuc nang
-- Dang ky nguoi dung
-- Xac thuc EKYC
-- Xu ly yeu cau bao hiem
-- Thanh toan truc tuyen
-""",
-            "metadata": json.dumps({"doc_type": "SRS", "language": "vi"}),
-        },
-        {
-            "document_id": "doc_en_001",
-            "content": """# System Requirements Specification
-
-## 1. Introduction
-The Insurance Digital Platform is a digitalization platform for insurance services.
-
-## 2. Functional Requirements
-- User registration
-- EKYC verification
-- Insurance claim processing
-- Online payment
-""",
-            "metadata": json.dumps({"doc_type": "SRS", "language": "en"}),
-        },
-        {
-            "document_id": "doc_code_001",
-            "content": """class InsuranceService:
-    def process_claim(self, claim_id: str) -> ClaimResult:
-        '''Process an insurance claim.
-
-        Args:
-            claim_id: The unique identifier for the claim
-
-        Returns:
-            ClaimResult with status and amount
-        '''
-        claim = self.claim_repository.get(claim_id)
-        return self.validator.validate(claim)
-""",
-            "metadata": json.dumps({"doc_type": "CODE", "language": "python"}),
-        },
-    ]
-
-    doc_pks = []
-    for doc in test_docs:
-        content_hash = hashlib.sha256(doc["content"].encode()).hexdigest()
-        cur.execute(
-            """
-            INSERT INTO audit_state.corpus_documents
-                (snapshot_id, project_id, document_id, content_hash, metadata)
-            VALUES (%s, %s, %s, %s, %s)
-            ON CONFLICT (snapshot_id, document_id) DO UPDATE SET content_hash = EXCLUDED.content_hash
-            RETURNING id
-            """,
-            (snapshot_id, project_id, doc["document_id"], content_hash, doc["metadata"]),
-        )
-        doc_pks.append(cur.fetchone()[0])
-
-    # Create chunks for each document
-    for doc_pk, doc in zip(doc_pks, test_docs, strict=True):
-        chunk_id = f"chunk_{doc['document_id']}_001"
-        content_hash = hashlib.sha256(doc["content"].encode()).hexdigest()
-        cur.execute(
-            """
-            INSERT INTO audit_state.corpus_chunks
-                (document_pk, chunk_id, content_hash, content_text, metadata)
-            VALUES (%s, %s, %s, %s, %s)
-            ON CONFLICT (document_pk, chunk_id) DO UPDATE SET content_text = EXCLUDED.content_text
-            RETURNING id
-            """,
-            (doc_pk, chunk_id, content_hash, doc["content"], doc["metadata"]),
-        )
-
-    db_connection.commit()
-
-    yield {
-        "project_id": project_id,
-        "snapshot_id": snapshot_id,
-        "doc_pks": doc_pks,
-        "docs": test_docs,
-    }
-
-    # Cleanup (optional - tests can leave data for inspection)
-    # cur.execute("DELETE FROM audit_state.corpus_chunks WHERE document_pk = ANY(%s)", (doc_pks,))
-    # cur.execute("DELETE FROM audit_state.corpus_documents WHERE id = ANY(%s)", (doc_pks,))
-    # db_connection.commit()
-
-
-# =============================================================================
-# Lexical Search Tests (tsvector with 'simple' config)
-# =============================================================================
-
-
-class TestLexicalSearch:
-    """Test lexical search using PostgreSQL tsvector with 'simple' config.
-
-    The 'simple' config is Vietnamese-safe (no stemming) as specified in FR-47.2.11.
-    """
-
-    def test_tsvector_uses_simple_config(self, db_connection, test_corpus_setup):
-        """Verify that corpus_chunks.search_vector uses 'simple' tsvector config.
-
-        The GIN index on search_vector should work with plainto_tsquery('simple', query).
-        """
-        cur = db_connection.cursor()
-
-        # Check that search_vector column exists and uses 'simple' config
-        cur.execute(
-            """
-            SELECT column_name, generation_expression
-            FROM information_schema.columns
-            WHERE table_schema = 'audit_state'
-            AND table_name = 'corpus_chunks'
-            AND column_name = 'search_vector'
-            """
-        )
-        row = cur.fetchone()
-        assert row is not None, "search_vector column should exist"
-        assert "simple" in row[1].lower(), f"search_vector should use 'simple' config, got: {row[1]}"
-
-    def test_lexical_search_returns_vietnamese_content(self, db_connection, test_corpus_setup):
-        """Test that lexical search returns Vietnamese content correctly.
-
-        Vietnamese text should be tokenized without stemming errors.
-        """
-        cur = db_connection.cursor()
-
-        # Search for Vietnamese terms
-        cur.execute(
-            """
-            SELECT cc.chunk_id, cc.content_text
-            FROM audit_state.corpus_chunks cc
-            WHERE cc.search_vector @@ plainto_tsquery('simple', 'bao hiem')
-            LIMIT 5
-            """
-        )
-        results = cur.fetchall()
-
-        # Should find the Vietnamese document containing "bao hiem"
-        assert len(results) > 0, "Should find Vietnamese content with 'bao hiem'"
-        assert any("bao hiem" in r[1].lower() for r in results), "Results should contain 'bao hiem'"
-
-    def test_lexical_search_returns_english_content(self, db_connection, test_corpus_setup):
-        """Test that lexical search returns English content correctly."""
-        cur = db_connection.cursor()
-
-        # Search for English terms
-        cur.execute(
-            """
-            SELECT cc.chunk_id, cc.content_text
-            FROM audit_state.corpus_chunks cc
-            WHERE cc.search_vector @@ plainto_tsquery('simple', 'insurance platform')
-            LIMIT 5
-            """
-        )
-        results = cur.fetchall()
-
-        # Should find the English document
-        assert len(results) > 0, "Should find English content with 'insurance platform'"
-
-    def test_lexical_search_code_content(self, db_connection, test_corpus_setup):
-        """Test that lexical search works for code content."""
-        cur = db_connection.cursor()
-
-        # Search for code terms
-        cur.execute(
-            """
-            SELECT cc.chunk_id, cc.content_text
-            FROM audit_state.corpus_chunks cc
-            WHERE cc.search_vector @@ plainto_tsquery('simple', 'process_claim')
-            LIMIT 5
-            """
-        )
-        results = cur.fetchall()
-
-        # Should find the code document
-        assert len(results) > 0, "Should find code content with 'process_claim'"
-        assert any("process_claim" in r[1] for r in results), "Results should contain 'process_claim'"
-
-    def test_lexical_ranking_by_ts_rank(self, db_connection, test_corpus_setup):
-        """Test that lexical results can be ranked by ts_rank_cd."""
-        cur = db_connection.cursor()
-
-        cur.execute(
-            """
-            SELECT
-                cc.chunk_id,
-                ts_rank_cd(cc.search_vector, plainto_tsquery('simple', 'insurance')) AS rank
-            FROM audit_state.corpus_chunks cc
-            WHERE cc.search_vector @@ plainto_tsquery('simple', 'insurance')
-            ORDER BY rank DESC
-            LIMIT 5
-            """
-        )
-        results = cur.fetchall()
-
-        assert len(results) > 0, "Should find results for 'insurance'"
-        # Verify results are ordered by rank descending
-        ranks = [r[1] for r in results]
-        assert ranks == sorted(ranks, reverse=True), "Results should be ranked by ts_rank_cd DESC"
-
-
-# =============================================================================
-# Vector Search Tests (pgvector)
-# =============================================================================
-
-
-@pytest.mark.skip(reason="Vector search requires embedding model and vector column - not yet implemented")
-class TestVectorSearch:
-    """Test vector search using pgvector.
-
-    These tests require:
-    - embedding_vector column with VECTOR(N) type
-    - HNSW index on embedding_vector
-    - Pre-computed embeddings for test chunks
-    """
-
-    def test_vector_column_exists(self, db_connection, test_corpus_setup):
-        """Verify that corpus_embeddings has embedding_vector column."""
-        cur = db_connection.cursor()
-
-        cur.execute(
-            """
-            SELECT column_name, data_type
-            FROM information_schema.columns
-            WHERE table_schema = 'audit_state'
-            AND table_name = 'corpus_embeddings'
-            AND column_name = 'embedding_vector'
-            """
-        )
-        row = cur.fetchone()
-        assert row is not None, "embedding_vector column should exist in corpus_embeddings"
-
-    def test_vector_search_returns_similar_chunks(self, db_connection, test_corpus_setup):
-        """Test that vector search returns semantically similar chunks."""
-        # Placeholder - requires embedding model
-        pytest.skip("Requires embedding model to generate query vector")
-
-    def test_hnsw_index_exists(self, db_connection, test_corpus_setup):
-        """Verify HNSW index exists on embedding_vector."""
-        cur = db_connection.cursor()
-
-        cur.execute(
-            """
-            SELECT indexname, indexdef
-            FROM pg_indexes
-            WHERE schemaname = 'audit_state'
-            AND tablename = 'corpus_embeddings'
-            AND indexdef LIKE '%embedding_vector%'
-            """
-        )
-        indexes = cur.fetchall()
-        assert any("hnsw" in idx[1].lower() for idx in indexes), "HNSW index should exist on embedding_vector"
-
-
-# =============================================================================
-# Hybrid Search Tests (RRF Fusion)
-# =============================================================================
-
-
-class TestHybridSearch:
-    """Test hybrid search using RRF (Reciprocal Rank Fusion).
-
-    These tests require the hybrid_search() SQL function from design.md.
-
-    RRF Formula: rrf_score = 1 / (k + rank), where k=60 (industry standard)
-    Final score = lexical_weight * rrf(lexical_rank) + vector_weight * rrf(vector_rank)
-    """
-
-    def test_rrf_score_function_exists(self, db_connection):
-        """Verify that audit_state.rrf_score function exists."""
-        cur = db_connection.cursor()
-
-        cur.execute(
-            """
-            SELECT proname, prosrc
-            FROM pg_proc p
-            JOIN pg_namespace n ON p.pronamespace = n.oid
-            WHERE n.nspname = 'audit_state'
-            AND p.proname = 'rrf_score'
-            """
-        )
-        row = cur.fetchone()
-        assert row is not None, "audit_state.rrf_score function should exist"
-        assert "rrf_k" in row[1] or "60" in row[1], "rrf_score should have k parameter (default 60)"
-
-    def test_hybrid_search_function_exists(self, db_connection):
-        """Verify that audit_state.hybrid_search function exists."""
-        cur = db_connection.cursor()
-
-        cur.execute(
-            """
-            SELECT proname
-            FROM pg_proc p
-            JOIN pg_namespace n ON p.pronamespace = n.oid
-            WHERE n.nspname = 'audit_state'
-            AND p.proname = 'hybrid_search'
-            """
-        )
-        row = cur.fetchone()
-        assert row is not None, "audit_state.hybrid_search function should exist"
-
-    def test_hybrid_search_returns_rank_components(self, db_connection, test_corpus_setup):
-        """Test that hybrid_search returns lexical_rank, vector_rank, and rrf_score."""
-        cur = db_connection.cursor()
-
-        cur.execute(
-            """
-            SELECT chunk_pk, document_id, chunk_id, content_text,
-                   lexical_rank, vector_rank, rrf_score
-            FROM audit_state.hybrid_search(
-                p_project_key := 'test_hybrid_search',
-                p_query_text := 'insurance claim',
-                p_top_k := 10,
-                p_lexical_weight := 0.4,
-                p_vector_weight := 0.6
-            )
-            """
-        )
-        results = cur.fetchall()
-        # Should return results with rank components (lexical-only since no embeddings)
-        for row in results:
-            chunk_pk, document_id, _chunk_id, _content_text, lex_rank, _vec_rank, rrf = row
-            assert chunk_pk is not None, "chunk_pk should be present"
-            assert document_id is not None, "document_id should be present"
-            assert rrf is not None, "rrf_score should be present"
-            # lexical_rank should be set, vector_rank may be NULL (no embeddings)
-            assert lex_rank is not None, "lexical_rank should be set for lexical matches"
-
-    def test_hybrid_search_scope_filtering(self, db_connection, test_corpus_setup):
-        """Test that hybrid_search enforces project/repo scope filtering."""
-        cur = db_connection.cursor()
-
-        # Query with a non-existent project should return no results
-        cur.execute(
-            """
-            SELECT COUNT(*)
-            FROM audit_state.hybrid_search(
-                p_project_key := 'non_existent_project',
-                p_query_text := 'insurance'
-            )
-            """
-        )
-        count = cur.fetchone()[0]
-        assert count == 0, "Non-existent project scope should return no results"
-
-    def test_hybrid_search_default_weights(self, db_connection, test_corpus_setup):
-        """Test that default weights are lexical=0.4, vector=0.6."""
-        cur = db_connection.cursor()
-
-        # Verify the function signature has the expected defaults
-        cur.execute(
-            """
-            SELECT proargnames, proargdefaults
-            FROM pg_proc p
-            JOIN pg_namespace n ON p.pronamespace = n.oid
-            WHERE n.nspname = 'audit_state'
-            AND p.proname = 'hybrid_search'
-            """
-        )
-        row = cur.fetchone()
-        assert row is not None, "hybrid_search function should exist"
-        arg_names = row[0]
-        assert "p_lexical_weight" in arg_names, "Should have p_lexical_weight parameter"
-        assert "p_vector_weight" in arg_names, "Should have p_vector_weight parameter"
-
-
-# =============================================================================
-# Advisory Lock Tests
-# =============================================================================
-
-
-class TestAdvisoryLocks:
-    """Test advisory locks for concurrent corpus updates.
-
-    Per FR-47.2.10, extract-docs should acquire pg_try_advisory_xact_lock()
-    per project to prevent concurrent corpus updates.
-    """
-
-    def test_advisory_lock_function_exists(self, db_connection):
-        """Verify that acquire_corpus_lock function exists or can be implemented."""
-        cur = db_connection.cursor()
-
-        # Check if the function exists (may be Python-side only)
-        cur.execute(
-            """
-            SELECT proname
-            FROM pg_proc p
-            JOIN pg_namespace n ON p.pronamespace = n.oid
-            WHERE n.nspname = 'audit_state'
-            AND p.proname = 'acquire_corpus_lock'
-            """
-        )
-        row = cur.fetchone()
-
-        # If function doesn't exist, Python code should use pg_try_advisory_xact_lock directly
-        # This test documents the expected behavior
-        if row is None:
-            # Verify pg_try_advisory_xact_lock is available (built-in PostgreSQL function)
-            cur.execute(
-                """
-                SELECT proname
-                FROM pg_proc p
-                JOIN pg_namespace n ON p.pronamespace = n.oid
-                WHERE n.nspname = 'pg_catalog'
-                AND p.proname = 'pg_try_advisory_xact_lock'
-                """
-            )
-            builtin = cur.fetchone()
-            assert builtin is not None, "pg_try_advisory_xact_lock should be available"
-
-    def test_advisory_lock_non_blocking(self, db_connection):
-        """Test that pg_try_advisory_xact_lock is non-blocking.
-
-        Unlike pg_advisory_xact_lock(), the _try variant returns FALSE immediately
-        if lock cannot be acquired, rather than blocking.
-        """
-        import hashlib
-
-        cur = db_connection.cursor()
-
-        # Generate lock key from project name
-        project_key = "test_lock_project"
-        lock_key = int(hashlib.sha256(f"corpus:{project_key}".encode()).hexdigest()[:8], 16)
-
-        # Try to acquire lock (should succeed)
-        cur.execute("SELECT pg_try_advisory_xact_lock(%s)", (lock_key,))
-        acquired = cur.fetchone()[0]
-        assert acquired is True, "First lock acquisition should succeed"
-
-        # In the same transaction, try again (should succeed - reentrant)
-        cur.execute("SELECT pg_try_advisory_xact_lock(%s)", (lock_key,))
-        acquired_again = cur.fetchone()[0]
-        assert acquired_again is True, "Same transaction should be able to re-acquire"
-
-        # Lock is released on transaction commit/rollback
-        db_connection.commit()
-
-    def test_advisory_lock_conflict_detection(self, db_connection, state_dsn):
-        """Test that concurrent lock attempts are detected.
-
-        Two connections should not both acquire the same lock.
-        """
-        import hashlib
-
-        import psycopg
-
-        project_key = "test_conflict_project"
-        lock_key = int(hashlib.sha256(f"corpus:{project_key}".encode()).hexdigest()[:8], 16)
-
-        # First connection acquires lock
-        cur1 = db_connection.cursor()
-        cur1.execute("SELECT pg_try_advisory_xact_lock(%s)", (lock_key,))
-        assert cur1.fetchone()[0] is True, "First connection should acquire lock"
-
-        # Second connection tries to acquire same lock
-        conn2 = psycopg.connect(state_dsn)
-        try:
-            cur2 = conn2.cursor()
-            cur2.execute("SELECT pg_try_advisory_xact_lock(%s)", (lock_key,))
-            acquired = cur2.fetchone()[0]
-            # Should fail because conn1 holds the lock
-            assert acquired is False, "Second connection should NOT acquire lock while first holds it"
-        finally:
-            conn2.close()
-
-        # Release lock by committing first transaction
-        db_connection.commit()
-
-        # Now second attempt should succeed
-        conn3 = psycopg.connect(state_dsn)
-        try:
-            cur3 = conn3.cursor()
-            cur3.execute("SELECT pg_try_advisory_xact_lock(%s)", (lock_key,))
-            assert cur3.fetchone()[0] is True, "Should acquire lock after first transaction commits"
-        finally:
-            conn3.commit()
-            conn3.close()
-
-
-# =============================================================================
-# Integration Tests (Full Workflow)
-# =============================================================================
-
-
-class TestHybridSearchIntegration:
-    """Integration tests for the complete hybrid search workflow."""
-
-    def test_corpus_documents_table_populated(self, db_connection, test_corpus_setup):
-        """Verify that corpus_documents table has test data."""
-        cur = db_connection.cursor()
-
-        cur.execute(
-            """
-            SELECT COUNT(*) FROM audit_state.corpus_documents cd
-            JOIN audit_state.projects p ON cd.project_id = p.id
-            WHERE p.project_key = 'test_hybrid_search'
-            """
-        )
-        count = cur.fetchone()[0]
-        assert count > 0, "corpus_documents should have test data"
-
-    def test_corpus_chunks_table_populated(self, db_connection, test_corpus_setup):
-        """Verify that corpus_chunks table has test data with search_vector."""
-        cur = db_connection.cursor()
-
-        cur.execute(
-            """
-            SELECT COUNT(*) FROM audit_state.corpus_chunks cc
-            JOIN audit_state.corpus_documents cd ON cc.document_pk = cd.id
-            JOIN audit_state.projects p ON cd.project_id = p.id
-            WHERE p.project_key = 'test_hybrid_search'
-            """
-        )
-        count = cur.fetchone()[0]
-        assert count > 0, "corpus_chunks should have test data"
-
-        # Verify search_vector is populated (GENERATED ALWAYS column)
-        cur.execute(
-            """
-            SELECT COUNT(*) FROM audit_state.corpus_chunks cc
-            JOIN audit_state.corpus_documents cd ON cc.document_pk = cd.id
-            JOIN audit_state.projects p ON cd.project_id = p.id
-            WHERE p.project_key = 'test_hybrid_search'
-            AND cc.search_vector IS NOT NULL
-            """
-        )
-        vector_count = cur.fetchone()[0]
-        assert vector_count == count, "All chunks should have search_vector populated"
-
-    def test_gin_index_on_search_vector(self, db_connection):
-        """Verify GIN index exists on corpus_chunks.search_vector."""
-        cur = db_connection.cursor()
-
-        cur.execute(
-            """
-            SELECT indexname
-            FROM pg_indexes
-            WHERE schemaname = 'audit_state'
-            AND tablename = 'corpus_chunks'
-            AND indexdef LIKE '%search_vector%'
-            """
-        )
-        indexes = cur.fetchall()
-        assert len(indexes) > 0, "GIN index should exist on search_vector"
-
-    def test_end_to_end_lexical_search(self, db_connection, test_corpus_setup):
-        """Test end-to-end lexical search workflow.
-
-        This simulates the EvidenceQueryService retrieval flow.
-        """
-        cur = db_connection.cursor()
-
-        # 1. Scoped chunk selection
-        cur.execute(
-            """
-            SELECT cc.id, cc.chunk_id, cc.content_text, cc.search_vector
-            FROM audit_state.corpus_chunks cc
-            JOIN audit_state.corpus_documents cd ON cc.document_pk = cd.id
-            JOIN audit_state.projects p ON cd.project_id = p.id
-            WHERE p.project_key = 'test_hybrid_search'
-            """
-        )
-        scoped_chunks = cur.fetchall()
-        assert len(scoped_chunks) > 0, "Should find scoped chunks"
-
-        # 2. Lexical ranking
-        query = "claim processing"
-        cur.execute(
-            """
-            SELECT
-                cc.chunk_id,
-                cc.content_text,
-                ts_rank_cd(cc.search_vector, plainto_tsquery('simple', %s)) AS lexical_rank
-            FROM audit_state.corpus_chunks cc
-            JOIN audit_state.corpus_documents cd ON cc.document_pk = cd.id
-            JOIN audit_state.projects p ON cd.project_id = p.id
-            WHERE p.project_key = 'test_hybrid_search'
-            AND cc.search_vector @@ plainto_tsquery('simple', %s)
-            ORDER BY lexical_rank DESC
-            LIMIT 10
-            """,
-            (query, query),
-        )
-        results = cur.fetchall()
-
-        # 3. Verify results have expected structure
-        assert len(results) > 0, f"Should find results for query: {query}"
-        for chunk_id, content_text, lexical_rank in results:
-            assert chunk_id is not None, "chunk_id should be present"
-            assert content_text is not None, "content_text should be present"
-            assert lexical_rank > 0, "lexical_rank should be positive"
-
-
-# =============================================================================
-# Schema Verification Tests
-# =============================================================================
-
-
-class TestSchemaCompliance:
-    """Verify Phase 47 schema compliance."""
-
-    def test_corpus_documents_has_project_id_fk(self, db_connection):
-        """Verify corpus_documents has project_id FK column (NOT project_key text)."""
-        cur = db_connection.cursor()
-
-        cur.execute(
-            """
-            SELECT column_name, data_type, is_nullable
-            FROM information_schema.columns
-            WHERE table_schema = 'audit_state'
-            AND table_name = 'corpus_documents'
-            AND column_name = 'project_id'
-            """
-        )
-        row = cur.fetchone()
-        assert row is not None, "corpus_documents should have project_id FK column"
-        assert row[1] == "bigint", "project_id should be BIGINT FK"
-        assert row[2] == "NO", "project_id should be NOT NULL"
-
-        # Verify project_key TEXT column does NOT exist (uses FK instead)
-        cur.execute(
-            """
-            SELECT column_name
-            FROM information_schema.columns
-            WHERE table_schema = 'audit_state'
-            AND table_name = 'corpus_documents'
-            AND column_name = 'project_key'
-            """
-        )
-        assert cur.fetchone() is None, "corpus_documents should NOT have project_key text column (uses project_id FK)"
-
-    def test_corpus_chunks_has_content_text(self, db_connection):
-        """Verify corpus_chunks has content_text column with NOT NULL constraint."""
-        cur = db_connection.cursor()
-
-        cur.execute(
-            """
-            SELECT column_name, is_nullable
-            FROM information_schema.columns
-            WHERE table_schema = 'audit_state'
-            AND table_name = 'corpus_chunks'
-            AND column_name = 'content_text'
-            """
-        )
-        row = cur.fetchone()
-        assert row is not None, "corpus_chunks should have content_text column"
-        assert row[1] == "NO", "content_text should be NOT NULL"
-
-    def test_corpus_chunks_search_vector_generated(self, db_connection):
-        """Verify corpus_chunks.search_vector is GENERATED ALWAYS."""
-        cur = db_connection.cursor()
-
-        cur.execute(
-            """
-            SELECT column_name, is_generated, generation_expression
-            FROM information_schema.columns
-            WHERE table_schema = 'audit_state'
-            AND table_name = 'corpus_chunks'
-            AND column_name = 'search_vector'
-            """
-        )
-        row = cur.fetchone()
-        assert row is not None, "search_vector column should exist"
-        assert row[1] == "ALWAYS", "search_vector should be GENERATED ALWAYS"
-        assert "simple" in row[2].lower(), "search_vector should use 'simple' config"
-
-    def test_unique_constraint_on_corpus_chunks(self, db_connection):
-        """Verify UNIQUE constraint on (document_pk, chunk_id)."""
-        cur = db_connection.cursor()
-
-        cur.execute(
-            """
-            SELECT conname, contype
-            FROM pg_constraint c
-            JOIN pg_namespace n ON c.connamespace = n.oid
-            WHERE n.nspname = 'audit_state'
-            AND conrelid = 'audit_state.corpus_chunks'::regclass
-            AND contype = 'u'
-            """
-        )
-        constraints = cur.fetchall()
-
-        # Should have UNIQUE constraint on (document_pk, chunk_id)
-        assert len(constraints) > 0, "corpus_chunks should have UNIQUE constraint"
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])