Skip to content
Python
9.4 KB
Raw Blame
"""created_after 按**事件时间**过滤的回归测试。

修复的 bug:过滤字段原为 `gmt_created`(落库时间),批量灌入场景下所有记忆的
gmt_created 几乎同一时刻,导致时间过滤完全失效。改为按 `memory_at`(事件时间),
`memory_at` 为空才回退 `gmt_created`。

覆盖:
- payload 级 helper(Chroma / FAISS post-filter 用)
- hit 级 helper(reader 末端兜底用)
- 关键场景:批量灌入(gmt_created 全部=今天,memory_at 跨年)
"""

from datetime import datetime, timedelta

import pytest

from hy_memory.data.vector_store_base import (
    node_effective_time,
    passes_created_after,
)
from hy_memory.pipelines._retrieval.temporal import (
    filter_hits_by_created_after,
    hit_effective_ts,
)
from hy_memory.models.memory import MemoryNode, MemoryLayer


NOW = datetime(2026, 9, 12, 12, 0, 0)
LAST_YEAR = datetime(2025, 3, 1, 12, 0, 0)
CUTOFF = datetime(2026, 1, 1, 0, 0, 0).timestamp()


# ================================================================
# payload 级(Chroma / FAISS)
# ================================================================

class TestNodeEffectiveTime:
    def test_prefers_memory_at(self):
        payload = {"memory_at": 100.0, "gmt_created": 999.0}
        assert node_effective_time(payload) == 100.0

    def test_falls_back_to_gmt_created_when_none(self):
        assert node_effective_time({"memory_at": None, "gmt_created": 999.0}) == 999.0

    def test_falls_back_when_empty_string(self):
        # Chroma 不支持 None,_payload_to_chroma_metadata 把空值写成 ""
        assert node_effective_time({"memory_at": "", "gmt_created": 999.0}) == 999.0

    def test_none_when_both_missing(self):
        assert node_effective_time({}) is None
        assert node_effective_time({"memory_at": "", "gmt_created": ""}) is None

    def test_ignores_unparseable(self):
        assert node_effective_time({"memory_at": "not-a-number", "gmt_created": 7.0}) == 7.0


class TestPassesCreatedAfter:
    def test_no_filter_passes_everything(self):
        assert passes_created_after({"memory_at": 1.0}, None) is True
        assert passes_created_after({"memory_at": 1.0}, 0) is True

    def test_filters_on_event_time(self):
        old = {"memory_at": LAST_YEAR.timestamp(), "gmt_created": NOW.timestamp()}
        new = {"memory_at": NOW.timestamp(), "gmt_created": NOW.timestamp()}
        assert passes_created_after(old, CUTOFF) is False
        assert passes_created_after(new, CUTOFF) is True

    def test_bulk_ingest_scenario(self):
        """核心回归:批量灌入时 gmt_created 全部=今天,只有 memory_at 能区分。"""
        ingested_now = NOW.timestamp()
        payloads = [
            {"memory_at": (LAST_YEAR + timedelta(days=d)).timestamp(),
             "gmt_created": ingested_now}
            for d in range(0, 600, 60)
        ]
        kept = [p for p in payloads if passes_created_after(p, CUTOFF)]
        # 按 gmt_created 过滤会全部通过(旧 bug);按 memory_at 只留 cutoff 之后的
        assert 0 < len(kept) < len(payloads)
        assert all(p["memory_at"] >= CUTOFF for p in kept)

    def test_missing_time_is_kept(self):
        """两个时间字段都取不到时保留 —— 不因缺字段静默丢数据。"""
        assert passes_created_after({}, CUTOFF) is True

    def test_null_memory_at_uses_gmt_created(self):
        """L0_BASIC_INFO 这类旁路写入历史数据 memory_at 为空,行为与改动前一致。"""
        old_l0 = {"memory_at": None, "gmt_created": LAST_YEAR.timestamp()}
        new_l0 = {"memory_at": None, "gmt_created": NOW.timestamp()}
        assert passes_created_after(old_l0, CUTOFF) is False
        assert passes_created_after(new_l0, CUTOFF) is True


# ================================================================
# hit 级(reader 末端兜底)
# ================================================================

def _hit(memory_at=None, gmt_created=None, node=True, score=0.9):
    if not node:
        return {"node": None, "score": score,
                "memory_at": memory_at, "gmt_created": gmt_created}
    return {
        "node": MemoryNode(
            node_id="n1", content="c", layer=MemoryLayer.L2_FACT,
            memory_at=memory_at, gmt_created=gmt_created,
        ),
        "score": score,
    }


class TestHitEffectiveTs:
    def test_prefers_node_memory_at(self):
        h = _hit(memory_at=LAST_YEAR, gmt_created=NOW)
        assert hit_effective_ts(h) == LAST_YEAR.timestamp()

    def test_falls_back_to_node_gmt_created(self):
        h = _hit(memory_at=None, gmt_created=NOW)
        assert hit_effective_ts(h) == NOW.timestamp()

    def test_graph_hit_without_node(self):
        # graph 通道结果 node=None,字段挂在 hit dict 上(可能是 unix 秒)
        h = _hit(memory_at=LAST_YEAR.timestamp(), node=False)
        assert hit_effective_ts(h) == LAST_YEAR.timestamp()

    def test_none_when_nothing_available(self):
        assert hit_effective_ts({"node": None, "score": 0.5}) is None


class TestFilterHitsByCreatedAfter:
    def test_no_filter_returns_input(self):
        hits = [_hit(memory_at=LAST_YEAR)]
        assert filter_hits_by_created_after(hits, None) is hits

    def test_empty_input(self):
        assert filter_hits_by_created_after([], CUTOFF) == []

    def test_filters_by_event_time_not_write_time(self):
        hits = [
            _hit(memory_at=LAST_YEAR, gmt_created=NOW),  # 事件旧、写入新 → 应被过滤
            _hit(memory_at=NOW, gmt_created=NOW),
        ]
        out = filter_hits_by_created_after(hits, CUTOFF)
        assert len(out) == 1
        assert out[0]["node"].memory_at == NOW

    def test_keeps_hits_without_any_time(self):
        hits = [{"node": None, "score": 0.5}]
        assert filter_hits_by_created_after(hits, CUTOFF) == hits

    def test_boundary_is_inclusive(self):
        boundary = datetime.fromtimestamp(CUTOFF)
        out = filter_hits_by_created_after([_hit(memory_at=boundary)], CUTOFF)
        assert len(out) == 1


# ================================================================
# Qdrant 端到端:嵌套 should + IsNull 过滤器
# ================================================================

@pytest.mark.asyncio
async def test_qdrant_filters_on_event_time_end_to_end(tmp_path):
    """Qdrant 侧下推过滤的真实行为(嵌套 should + IsNullCondition)。

    过滤器写错会让主后端所有带 created_after 的查询直接崩,所以必须端到端验证。
    """
    from hy_memory.config import MemoryConfig, VectorStoreConfig
    from hy_memory.data.vector_store_qdrant import QdrantVectorStore

    cfg = MemoryConfig()
    cfg.vector_store = VectorStoreConfig(
        provider="qdrant",
        persist_directory=str(tmp_path),
        collection_name="test_created_after",
        embedding_dims=4,
    )
    vs = QdrantVectorStore(cfg)
    await vs.initialize()

    def _node(nid, memory_at, gmt_created):
        return MemoryNode(
            node_id=nid, user_id="u1", agent_id="a1", session_id="s1",
            layer=MemoryLayer.L2_FACT, content=f"fact {nid}",
            memory_at=memory_at, gmt_created=gmt_created,
            embedding=[1.0, 0.0, 0.0, 0.0],
        )

    try:
        # 批量灌入场景:gmt_created 全是"今天",只有 memory_at 能区分事件时间
        await vs.upsert(_node("old_event", LAST_YEAR, NOW))
        await vs.upsert(_node("new_event", NOW, NOW))
        # memory_at 为空的旁路节点 → 回退 gmt_created
        await vs.upsert(_node("nullma_old", None, LAST_YEAR))
        await vs.upsert(_node("nullma_new", None, NOW))

        async def _ids(created_after):
            res = await vs.search(
                query_embedding=[1.0, 0.0, 0.0, 0.0], user_id="u1",
                limit=10, score_threshold=0.0, created_after=created_after,
            )
            return sorted(r["node_id"] for r in res)

        assert await _ids(None) == [
            "new_event", "nullma_new", "nullma_old", "old_event",
        ]
        # old_event 的 gmt_created 是"今天" —— 旧实现按 gmt_created 过滤会漏放它
        assert await _ids(CUTOFF) == ["new_event", "nullma_new"]
    finally:
        await vs.close()


# ================================================================
# L0 旁路写入现在会带上 memory_at
# ================================================================

@pytest.mark.asyncio
async def test_basic_profile_node_carries_memory_at(monkeypatch):
    """upsert_basic_profile 建的 L0 节点必须带 memory_at(消除 null 源)。"""
    from hy_memory.agent.tools import basic_profile as bp

    captured = {}

    class _FakeVS:
        async def list_by_user(self, **kw):
            return []
        async def get_by_ids(self, ids):
            return []
        async def upsert(self, node):
            captured["node"] = node
            return node.node_id
        async def update_payload(self, nid, updates):
            return True

    class _FakeEmbed:
        async def embed_queued(self, text):
            return [0.1, 0.2, 0.3]

    res = await bp.upsert_basic_profile(
        user_id="u1",
        kv={"name": "Tim"},
        vector_store=_FakeVS(),
        embed_service=_FakeEmbed(),
        allowed_fields=["name"],
    )

    assert res.success, res.error
    node = captured.get("node")
    assert node is not None, "upsert 未被调用"
    assert node.layer == MemoryLayer.L0_BASIC_INFO
    assert node.memory_at is not None