Skip to content
Python
13.3 KB
Raw Blame
# -*- coding: utf-8 -*-
"""
Neo4j 向量检索隔离性和多用户场景的测试

测试迭代式多轮获取策略确保:
1. 不同 isolation_key 的结果不会交叉泄露
2. 稀疏用户能获得期望的召回率
3. 迭代搜索开销 < 10%(正常情况下)

NOTE: 这些测试需要运行的 Neo4j 实例和已初始化的图模式。
标记为 @pytest.mark.integration 的测试在集成环境中运行。
"""

import asyncio
import pytest
from typing import List, Dict, Any
import time

# 假设已导入必要的类
# from hy_memory.data.graph_store_neo4j import Neo4jGraphStore
# from hy_memory.models.memory import MemoryNode, MemoryLayer, MemoryStatus


@pytest.mark.integration
class TestVectorSearchIsolation:
    """向量检索隔离性测试"""

    @pytest.mark.slow
    async def test_vector_search_no_cross_user_leakage(self, graph_store_neo4j_fixture):
        """
        测试:两个用户的向量搜索结果不会交叉泄露
        
        Setup:
        - User A: 创建 5 个关于"编程"的记忆节点
        - User B: 创建 10 个关于"美食"的记忆节点
        
        Query:
        - User A 搜索"编程"相关向量,isolation_key=user_a_ik
        
        Expected:
        - 返回结果仅包含 User A 的记忆(via isolation_key 检查)
        - 不包含 User B 的任何记忆
        """
        # 创建两个 isolation_key
        ik_a = "user_a::default"
        ik_b = "user_b::default"
        
        # 生成模拟向量(1536 维,符合 text-embedding-3-large)
        def make_embedding(seed: int) -> List[float]:
            import random
            random.seed(seed)
            return [random.gauss(0, 1) for _ in range(1536)]
        
        # User A: 编程相关记忆
        user_a_memories = [
            {
                "node_id": f"user_a_prog_{i}",
                "content": f"编程相关的记忆 {i}",
                "layer": "l6_schema",
                "status": "active",
                "isolation_key": ik_a,
                "embedding": make_embedding(100 + i),  # 一致的向量
                "confidence": 0.9,
                "custom_json": {"topic": "programming"}
            }
            for i in range(5)
        ]
        
        # User B: 美食相关记忆
        user_b_memories = [
            {
                "node_id": f"user_b_food_{i}",
                "content": f"美食相关的记忆 {i}",
                "layer": "l6_schema",
                "status": "active",
                "isolation_key": ik_b,
                "embedding": make_embedding(200 + i),  # 不同的向量
                "confidence": 0.9,
                "custom_json": {"topic": "food"}
            }
            for i in range(10)
        ]
        
        # 使用 graph_store_neo4j_fixture 的方法创建节点
        # (假设 graph_store 有某种批量创建方法)
        # 实际测试中这需要正确的实现
        
        # 用 User A 的向量进行搜索
        query_embedding = user_a_memories[0]["embedding"]
        results = await graph_store_neo4j_fixture.vector_search(
            query_embedding=query_embedding,
            isolation_key=ik_a,
            limit=10,
        )
        
        # 验证隔离性
        for result in results:
            assert result["node_id"].startswith("user_a_"), \
                f"Expected all results for user_a, but got {result['node_id']}"
        
        print(f"✓ Isolation test passed: got {len(results)} results for user_a only")

    @pytest.mark.slow
    async def test_vector_search_returns_results_for_sparse_user(self, graph_store_neo4j_fixture):
        """
        测试:稀疏用户(结果不在全局 top-K)仍能获得结果
        
        Setup:
        - User A (sparse): 5 个记忆
        - User B (dense): 100 个相似度更高的记忆
        
        Query:
        - User A 搜索,limit=10
        - 全局 top-30(迭代初值)可能被 User B 的记忆填满
        
        Expected:
        - 迭代搜索通过增加 K 倍数,最终返回 User A 的结果
        - 不会因为全局 top-K 被其他用户填满就放弃
        """
        ik_a = "sparse_user::default"
        ik_b = "dense_user::default"
        
        def make_embedding(seed: int) -> List[float]:
            import random
            random.seed(seed)
            return [random.gauss(0, 1) for _ in range(1536)]
        
        # Sparse user: 5 个记忆
        sparse_memories = [
            {
                "node_id": f"sparse_{i}",
                "content": f"稀疏用户记忆 {i}",
                "layer": "l6_schema",
                "status": "active",
                "isolation_key": ik_a,
                "embedding": make_embedding(300 + i),
                "confidence": 0.7,
            }
            for i in range(5)
        ]
        
        # Dense user: 100 个高相似度的记忆(可能填满全局 top-30)
        dense_memories = [
            {
                "node_id": f"dense_{i}",
                "content": f"密集用户记忆 {i}",
                "layer": "l6_schema",
                "status": "active",
                "isolation_key": ik_b,
                "embedding": make_embedding(400),  # 都使用相同的种子(高相似性)
                "confidence": 0.95,
            }
            for i in range(100)
        ]
        
        # 搜索 sparse user 的结果
        query_embedding = sparse_memories[0]["embedding"]
        results = await graph_store_neo4j_fixture.vector_search(
            query_embedding=query_embedding,
            isolation_key=ik_a,
            limit=5,
        )
        
        # 验证即使有 100 个密集用户的竞争,仍能获得稀疏用户的结果
        assert len(results) > 0, "Sparse user should get results despite dense competition"
        assert all(r["node_id"].startswith("sparse_") for r in results), \
            "All results should be from sparse user"
        
        print(f"✓ Sparse user test passed: got {len(results)} results despite 100 competing dense nodes")

    @pytest.mark.slow
    async def test_vector_search_multi_user_prefix(self, graph_store_neo4j_fixture):
        """
        测试:跨 user_id 搜索(指定 user_id 但不指定 agent_id)
        
        Setup:
        - User X::agent_1: 3 个记忆
        - User X::agent_2: 3 个记忆
        - User Y::agent_1: 3 个记忆
        
        Query:
        - 用 user_id="User X"(不指定 agent_id)搜索
        
        Expected:
        - 返回 User X::agent_1 和 User X::agent_2 的结果
        - 不包含 User Y 的结果
        """
        def make_embedding(seed: int) -> List[float]:
            import random
            random.seed(seed)
            return [random.gauss(0, 1) for _ in range(1536)]
        
        # 创建多个 agent 下的记忆
        memories_x_agent_1 = [
            {
                "node_id": f"x_a1_{i}",
                "content": f"User X Agent 1 记忆 {i}",
                "layer": "l6_schema",
                "status": "active",
                "isolation_key": "user_x::agent_1",
                "embedding": make_embedding(500 + i),
                "confidence": 0.8,
            }
            for i in range(3)
        ]
        
        memories_x_agent_2 = [
            {
                "node_id": f"x_a2_{i}",
                "content": f"User X Agent 2 记忆 {i}",
                "layer": "l6_schema",
                "status": "active",
                "isolation_key": "user_x::agent_2",
                "embedding": make_embedding(550 + i),
                "confidence": 0.8,
            }
            for i in range(3)
        ]
        
        memories_y_agent_1 = [
            {
                "node_id": f"y_a1_{i}",
                "content": f"User Y Agent 1 记忆 {i}",
                "layer": "l6_schema",
                "status": "active",
                "isolation_key": "user_y::agent_1",
                "embedding": make_embedding(600 + i),
                "confidence": 0.8,
            }
            for i in range(3)
        ]
        
        # 跨 agent 搜索
        query_embedding = memories_x_agent_1[0]["embedding"]
        results = await graph_store_neo4j_fixture.vector_search(
            query_embedding=query_embedding,
            isolation_key="",  # 空隔离键
            user_id="user_x",  # 指定 user_id(会转为 user_x::)
            limit=10,
        )
        
        # 验证
        result_ids = [r["node_id"] for r in results]
        # 应包含来自 user_x 的结果
        has_x_results = any(id.startswith("x_a1_") or id.startswith("x_a2_") for id in result_ids)
        # 不应包含来自 user_y 的结果
        has_y_results = any(id.startswith("y_a1_") for id in result_ids)
        
        assert has_x_results, "Should include results from user_x"
        assert not has_y_results, "Should not include results from user_y"
        
        print(f"✓ Multi-user prefix test passed: got {len(results)} results from user_x only")


@pytest.mark.integration
class TestVectorSearchPerformance:
    """向量检索性能测试"""

    @pytest.mark.slow
    async def test_vector_search_iteration_overhead(self, graph_store_neo4j_fixture):
        """
        测试:迭代搜索的性能开销 < 10%
        
        Measure:
        - 单轮查询耗时(limit*3 获取)
        - 多轮迭代查询耗时
        
        Expected:
        - 多轮迭代开销(相对于单轮)< 10%
        - 在正常情况下,90%+ 的结果在首轮获得(无需迭代)
        """
        ik = "test_perf::default"
        
        def make_embedding(seed: int) -> List[float]:
            import random
            random.seed(seed)
            return [random.gauss(0, 1) for _ in range(1536)]
        
        # 创建足够的节点以测试性能
        for i in range(100):
            # 模拟创建节点
            pass
        
        query_embedding = make_embedding(1000)
        
        # 测量搜索耗时
        start = time.time()
        results = await graph_store_neo4j_fixture.vector_search(
            query_embedding=query_embedding,
            isolation_key=ik,
            limit=10,
        )
        elapsed = time.time() - start
        
        # 日志中应该能看到迭代次数
        # 如果结果充足且在首轮获得,elapsed 应该接近单轮查询时间
        # 如果需要多轮,elapsed 会相应增加,但不应超过单轮的 1.1 倍
        
        print(f"✓ Performance test: vector_search took {elapsed:.3f}s for {len(results)} results")
        assert elapsed < 5.0, "Vector search should complete within 5 seconds"

    @pytest.mark.slow
    async def test_beh_vector_search_isolation(self, graph_store_neo4j_fixture):
        """
        测试:行为向量搜索(beh_vector_search)也遵守隔离策略
        
        验证 beh_vector_search 使用相同的迭代式多轮获取,确保隔离性
        """
        ik_a = "user_a_beh::default"
        ik_b = "user_b_beh::default"
        
        def make_embedding(seed: int) -> List[float]:
            import random
            random.seed(seed)
            return [random.gauss(0, 1) for _ in range(512)]
        
        # 创建 L6 schema 行为节点
        beh_nodes_a = [
            {
                "node_id": f"beh_a_{i}",
                "content": f"User A 行为 {i}",
                "layer": "l6_schema",
                "status": "active",
                "isolation_key": ik_a,
                "beh_embedding": make_embedding(700 + i),
            }
            for i in range(3)
        ]
        
        beh_nodes_b = [
            {
                "node_id": f"beh_b_{i}",
                "content": f"User B 行为 {i}",
                "layer": "l6_schema",
                "status": "active",
                "isolation_key": ik_b,
                "beh_embedding": make_embedding(800 + i),
            }
            for i in range(10)
        ]
        
        # 行为向量搜索
        query_beh_embedding = beh_nodes_a[0]["beh_embedding"]
        results = await graph_store_neo4j_fixture.beh_vector_search(
            query_beh_embedding=query_beh_embedding,
            isolation_key=ik_a,
            limit=5,
        )
        
        # 验证隔离性
        for result in results:
            assert result["node_id"].startswith("beh_a_"), \
                f"beh_vector_search should isolate by isolation_key, got {result['node_id']}"
        
        print(f"✓ Behavior vector search isolation test passed: got {len(results)} results for user_a only")


# ==================== Fixtures ====================

@pytest.fixture
async def graph_store_neo4j_fixture():
    """
    返回一个配置好的 Neo4j GraphStore 实例
    
    NOTE: 这是一个占位符,实际使用需要:
    1. 从配置文件读取 Neo4j 连接信息
    2. 初始化 GraphStore
    3. 在测试后清理
    """
    # 这里假设测试环境已配置 NEO4J_URI 等环境变量
    from hy_memory.config import MemoryConfig
    from hy_memory.data.graph_store_neo4j import Neo4jGraphStore
    
    config = MemoryConfig(
        # 从环境变量读取
        embedding_dims=1536,
        neo4j_uri="neo4j://localhost:7687",  # 需要从 .env 覆盖
        neo4j_user="neo4j",
        neo4j_password="password",
    )
    
    store = Neo4jGraphStore(config)
    await store.initialize()
    
    yield store
    
    # 清理
    await store.close()