1b4ad7f435
* feat: add update document tags endpoint with observation invalidation
Adds PATCH /v1/default/banks/{bank_id}/documents/{document_id} to change
tags on a document without re-processing content.
- Updates tags on the document and all associated memory units atomically
- Invalidates observations derived from the document's memory units
- Resets consolidated_at on the document's own units for re-consolidation
- Also resets consolidated_at on co-source memories from other documents
that shared those observations (matching delete_document behavior)
- Triggers async consolidation when observations are invalidated
- 9 new tests covering all invalidation scenarios
UI: adds inline tag editor to the document detail panel in the control plane
Docs: new "Update Document Tags" section in documents.mdx with Python/JS examples
* refactor: simplify UpdateDocumentTagsResponse to {success: true}
* refactor: make PATCH /documents generic update_document endpoint
Renames update_document_tags → update_document (engine + HTTP + clients + UI).
Currently only tags are supported; the structure is open for future fields.
Tags are the only field with side effects (observation invalidation + re-consolidation).
735 lines
32 KiB
Python
735 lines
32 KiB
Python
"""
|
|
Tests for observation invalidation when source memories are deleted.
|
|
|
|
These tests verify that:
|
|
1. Observations are deleted (not just updated) when their source memories are removed
|
|
2. Remaining source memories are reset for re-consolidation (consolidated_at=NULL)
|
|
3. The clear_observations_for_memory method correctly clears observations and
|
|
resets the target memory itself for re-consolidation
|
|
4. delete_bank(fact_type=...) also cleans up affected observations
|
|
"""
|
|
import uuid
|
|
from unittest.mock import AsyncMock, patch
|
|
|
|
import pytest
|
|
|
|
from hindsight_api import RequestContext
|
|
from hindsight_api.engine.memory_engine import MemoryEngine
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Helpers
|
|
# ---------------------------------------------------------------------------
|
|
|
|
async def _insert_memory(conn, bank_id: str, text: str, fact_type: str = "experience") -> uuid.UUID:
|
|
"""Insert a memory unit directly, bypassing LLM retain pipeline."""
|
|
mem_id = uuid.uuid4()
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO memory_units (id, bank_id, text, fact_type, event_date, created_at, updated_at, consolidated_at)
|
|
VALUES ($1, $2, $3, $4, NOW(), NOW(), NOW(), NOW())
|
|
""",
|
|
mem_id,
|
|
bank_id,
|
|
text,
|
|
fact_type,
|
|
)
|
|
return mem_id
|
|
|
|
|
|
async def _insert_observation(
|
|
conn, bank_id: str, text: str, source_memory_ids: list[uuid.UUID]
|
|
) -> uuid.UUID:
|
|
"""Insert an observation unit directly."""
|
|
obs_id = uuid.uuid4()
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO memory_units (
|
|
id, bank_id, text, fact_type, event_date, source_memory_ids, proof_count, created_at, updated_at
|
|
) VALUES ($1, $2, $3, 'observation', NOW(), $4, $5, NOW(), NOW())
|
|
""",
|
|
obs_id,
|
|
bank_id,
|
|
text,
|
|
source_memory_ids,
|
|
len(source_memory_ids),
|
|
)
|
|
return obs_id
|
|
|
|
|
|
async def _get_observation_ids(conn, bank_id: str) -> list[str]:
|
|
rows = await conn.fetch(
|
|
"SELECT id FROM memory_units WHERE bank_id = $1 AND fact_type = 'observation'",
|
|
bank_id,
|
|
)
|
|
return [str(r["id"]) for r in rows]
|
|
|
|
|
|
async def _get_consolidated_at(conn, memory_id: uuid.UUID):
|
|
return await conn.fetchval(
|
|
"SELECT consolidated_at FROM memory_units WHERE id = $1",
|
|
memory_id,
|
|
)
|
|
|
|
|
|
async def _ensure_bank(memory: MemoryEngine, bank_id: str, request_context: RequestContext):
|
|
await memory.get_bank_profile(bank_id=bank_id, request_context=request_context)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests: delete_memory_unit
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestDeleteMemoryUnitObservationCleanup:
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_deleting_source_memory_removes_observation(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Deleting a source memory removes observations derived from it."""
|
|
bank_id = f"test-invalidate-del-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
m1 = await _insert_memory(conn, bank_id, "Alice loves hiking.")
|
|
m2 = await _insert_memory(conn, bank_id, "Alice goes hiking every weekend.")
|
|
obs_id = await _insert_observation(conn, bank_id, "Alice enjoys hiking regularly.", [m1, m2])
|
|
|
|
await memory.delete_memory_unit(str(m1), request_context=request_context)
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs_id) not in obs_ids, "Observation should have been deleted"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_deleting_source_memory_resets_remaining_source_consolidated_at(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""After deleting a source memory, remaining source memories are reset for re-consolidation."""
|
|
bank_id = f"test-invalidate-reset-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
m1 = await _insert_memory(conn, bank_id, "Alice loves hiking.")
|
|
m2 = await _insert_memory(conn, bank_id, "Alice goes hiking every weekend.")
|
|
await _insert_observation(conn, bank_id, "Alice enjoys hiking regularly.", [m1, m2])
|
|
|
|
# Verify m2 starts with consolidated_at set
|
|
assert await _get_consolidated_at(conn, m2) is not None
|
|
|
|
# Patch out consolidation so it doesn't re-set consolidated_at before we can check it
|
|
with patch.object(memory, "submit_async_consolidation", new=AsyncMock()):
|
|
await memory.delete_memory_unit(str(m1), request_context=request_context)
|
|
|
|
async with pool.acquire() as conn:
|
|
# m2 should have consolidated_at reset to NULL
|
|
consolidated_at = await _get_consolidated_at(conn, m2)
|
|
assert consolidated_at is None, "Remaining source memory should be reset for re-consolidation"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_deleting_non_source_memory_leaves_observations_intact(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Deleting a memory that is not a source of any observation leaves observations unchanged."""
|
|
bank_id = f"test-invalidate-noop-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
m1 = await _insert_memory(conn, bank_id, "Alice loves hiking.")
|
|
m2 = await _insert_memory(conn, bank_id, "Alice goes hiking every weekend.")
|
|
unrelated = await _insert_memory(conn, bank_id, "Bob likes cycling.")
|
|
obs_id = await _insert_observation(conn, bank_id, "Alice enjoys hiking regularly.", [m1, m2])
|
|
|
|
await memory.delete_memory_unit(str(unrelated), request_context=request_context)
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs_id) in obs_ids, "Observation should remain untouched"
|
|
# m1 and m2 should still be consolidated
|
|
assert await _get_consolidated_at(conn, m1) is not None
|
|
assert await _get_consolidated_at(conn, m2) is not None
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_deleting_sole_source_memory_removes_observation_no_remaining_reset(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""When an observation has only one source and it's deleted, observation is removed with no remaining memories to reset."""
|
|
bank_id = f"test-invalidate-sole-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
m1 = await _insert_memory(conn, bank_id, "Alice loves hiking.")
|
|
obs_id = await _insert_observation(conn, bank_id, "Alice enjoys hiking.", [m1])
|
|
|
|
await memory.delete_memory_unit(str(m1), request_context=request_context)
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs_id) not in obs_ids, "Observation should have been deleted"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_deleting_observation_type_memory_does_not_trigger_invalidation(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Deleting a memory with fact_type='observation' directly does not trigger invalidation logic."""
|
|
bank_id = f"test-invalidate-obstype-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
m1 = await _insert_memory(conn, bank_id, "Alice loves hiking.")
|
|
obs_id = await _insert_observation(conn, bank_id, "Alice enjoys hiking.", [m1])
|
|
|
|
# Delete the observation directly (not the source memory)
|
|
await memory.delete_memory_unit(str(obs_id), request_context=request_context)
|
|
|
|
async with pool.acquire() as conn:
|
|
# Source memory should still be consolidated (not reset)
|
|
assert await _get_consolidated_at(conn, m1) is not None
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs_id) not in obs_ids
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests: delete_document
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestDeleteDocumentObservationCleanup:
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_deleting_document_removes_observations(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Deleting a document removes observations derived from its memory units."""
|
|
bank_id = f"test-invalidate-doc-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
|
|
# Create a document and attach memories to it
|
|
async with pool.acquire() as conn:
|
|
doc_id = str(uuid.uuid4()) # documents.id is TEXT
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO documents (id, bank_id, original_text, content_hash, created_at, updated_at)
|
|
VALUES ($1, $2, 'some doc', 'hash123', NOW(), NOW())
|
|
""",
|
|
doc_id,
|
|
bank_id,
|
|
)
|
|
m1 = uuid.uuid4()
|
|
m2 = uuid.uuid4()
|
|
for mem_id, text in [(m1, "Alice loves hiking."), (m2, "Alice goes hiking every weekend.")]:
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO memory_units (id, bank_id, text, fact_type, event_date, document_id, created_at, updated_at, consolidated_at)
|
|
VALUES ($1, $2, $3, 'experience', NOW(), $4, NOW(), NOW(), NOW())
|
|
""",
|
|
mem_id,
|
|
bank_id,
|
|
text,
|
|
doc_id,
|
|
)
|
|
|
|
# Standalone memory (not in document)
|
|
m3 = await _insert_memory(conn, bank_id, "Alice is an avid outdoor person.")
|
|
|
|
# Observation referencing both doc memories and the standalone memory
|
|
obs_id = await _insert_observation(
|
|
conn, bank_id, "Alice enjoys outdoor activities.", [m1, m2, m3]
|
|
)
|
|
|
|
# Patch out consolidation so it doesn't re-set consolidated_at before we can check it
|
|
with patch.object(memory, "submit_async_consolidation", new=AsyncMock()):
|
|
await memory.delete_document(str(doc_id), bank_id, request_context=request_context)
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs_id) not in obs_ids, "Observation should have been deleted"
|
|
|
|
# m3 (remaining source) should be reset for re-consolidation
|
|
consolidated_at = await _get_consolidated_at(conn, m3)
|
|
assert consolidated_at is None, "Remaining source memory should be reset"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests: delete_bank with fact_type filter
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestDeleteBankByTypeObservationCleanup:
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_clearing_experience_memories_removes_affected_observations(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Clearing all experience memories removes observations sourced from them."""
|
|
bank_id = f"test-invalidate-banktype-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
exp1 = await _insert_memory(conn, bank_id, "Alice went hiking last week.", "experience")
|
|
world1 = await _insert_memory(conn, bank_id, "Alice is a hiker.", "world")
|
|
obs_id = await _insert_observation(
|
|
conn, bank_id, "Alice is a regular hiker.", [exp1, world1]
|
|
)
|
|
|
|
# Patch out consolidation so it doesn't re-set consolidated_at before we can check it
|
|
with patch.object(memory, "submit_async_consolidation", new=AsyncMock()):
|
|
await memory.delete_bank(bank_id, fact_type="experience", request_context=request_context)
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs_id) not in obs_ids, "Observation should have been deleted"
|
|
|
|
# world1 (remaining source) should be reset for re-consolidation
|
|
consolidated_at = await _get_consolidated_at(conn, world1)
|
|
assert consolidated_at is None, "World memory should be reset for re-consolidation"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_clearing_unrelated_type_leaves_observations_intact(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Clearing memories of a type that is not a source of any observation leaves observations untouched."""
|
|
bank_id = f"test-invalidate-banktype-noop-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
world1 = await _insert_memory(conn, bank_id, "Alice is a hiker.", "world")
|
|
obs_id = await _insert_observation(conn, bank_id, "Alice is a regular hiker.", [world1])
|
|
|
|
# Deleting 'experience' type should not affect observations sourced only from 'world'
|
|
await memory.delete_bank(bank_id, fact_type="experience", request_context=request_context)
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs_id) in obs_ids, "Observation should remain untouched"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests: clear_observations_for_memory
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestClearObservationsForMemory:
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_clears_observations_and_resets_all_source_memories(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Clearing observations for a memory deletes them and resets all related source memories."""
|
|
bank_id = f"test-clear-obs-mem-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
m1 = await _insert_memory(conn, bank_id, "Alice loves hiking.")
|
|
m2 = await _insert_memory(conn, bank_id, "Alice hikes every weekend.")
|
|
obs_id = await _insert_observation(conn, bank_id, "Alice is an avid hiker.", [m1, m2])
|
|
|
|
# Patch out consolidation so it doesn't re-set consolidated_at before we can check it
|
|
with patch.object(memory, "submit_async_consolidation", new=AsyncMock()):
|
|
result = await memory.clear_observations_for_memory(
|
|
bank_id, str(m1), request_context=request_context
|
|
)
|
|
|
|
assert result["deleted_count"] == 1
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs_id) not in obs_ids, "Observation should be deleted"
|
|
|
|
# Both m1 (target) and m2 (remaining source) should be reset
|
|
assert await _get_consolidated_at(conn, m1) is None, "Target memory should be reset"
|
|
assert await _get_consolidated_at(conn, m2) is None, "Remaining source should be reset"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_no_observations_returns_zero(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Returns 0 when the memory has no associated observations."""
|
|
bank_id = f"test-clear-obs-noop-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
m1 = await _insert_memory(conn, bank_id, "Alice loves hiking.")
|
|
|
|
result = await memory.clear_observations_for_memory(
|
|
bank_id, str(m1), request_context=request_context
|
|
)
|
|
|
|
assert result["deleted_count"] == 0
|
|
|
|
async with pool.acquire() as conn:
|
|
# Memory should still be consolidated (no observations were cleared)
|
|
assert await _get_consolidated_at(conn, m1) is not None
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_only_clears_observations_referencing_target_memory(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Clearing observations for m1 does not affect observations that only reference m2."""
|
|
bank_id = f"test-clear-obs-selective-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
m1 = await _insert_memory(conn, bank_id, "Alice loves hiking.")
|
|
m2 = await _insert_memory(conn, bank_id, "Alice hikes every weekend.")
|
|
m3 = await _insert_memory(conn, bank_id, "Alice climbed a mountain.")
|
|
|
|
obs1_id = await _insert_observation(conn, bank_id, "Alice is an avid hiker.", [m1, m2])
|
|
obs2_id = await _insert_observation(conn, bank_id, "Alice is a mountaineer.", [m3])
|
|
|
|
result = await memory.clear_observations_for_memory(
|
|
bank_id, str(m1), request_context=request_context
|
|
)
|
|
|
|
assert result["deleted_count"] == 1
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs1_id) not in obs_ids, "obs1 (references m1) should be deleted"
|
|
assert str(obs2_id) in obs_ids, "obs2 (does not reference m1) should remain"
|
|
|
|
# m3 should still be consolidated
|
|
assert await _get_consolidated_at(conn, m3) is not None
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_multiple_observations_for_same_memory_all_cleared(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""All observations referencing the target memory are cleared in one call."""
|
|
bank_id = f"test-clear-obs-multi-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
m1 = await _insert_memory(conn, bank_id, "Alice loves hiking.")
|
|
m2 = await _insert_memory(conn, bank_id, "Alice hikes every weekend.")
|
|
|
|
obs1_id = await _insert_observation(conn, bank_id, "Alice hikes often.", [m1])
|
|
obs2_id = await _insert_observation(conn, bank_id, "Alice is outdoorsy.", [m1, m2])
|
|
|
|
# Patch out consolidation so it doesn't re-set consolidated_at before we can check it
|
|
with patch.object(memory, "submit_async_consolidation", new=AsyncMock()):
|
|
result = await memory.clear_observations_for_memory(
|
|
bank_id, str(m1), request_context=request_context
|
|
)
|
|
|
|
assert result["deleted_count"] == 2
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs1_id) not in obs_ids
|
|
assert str(obs2_id) not in obs_ids
|
|
|
|
# m1 and m2 should both be reset
|
|
assert await _get_consolidated_at(conn, m1) is None
|
|
assert await _get_consolidated_at(conn, m2) is None
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests: update_document
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
async def _insert_document_with_memories(
|
|
conn, bank_id: str, doc_id: str, memories: list[tuple[str, str]]
|
|
) -> list[uuid.UUID]:
|
|
"""Insert a document and attach memory units to it. Returns list of memory UUIDs."""
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO documents (id, bank_id, original_text, content_hash, created_at, updated_at)
|
|
VALUES ($1, $2, 'some doc', 'hash123', NOW(), NOW())
|
|
""",
|
|
doc_id,
|
|
bank_id,
|
|
)
|
|
mem_ids = []
|
|
for text, fact_type in memories:
|
|
mem_id = uuid.uuid4()
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO memory_units (id, bank_id, text, fact_type, event_date, document_id, created_at, updated_at, consolidated_at)
|
|
VALUES ($1, $2, $3, $4, NOW(), $5, NOW(), NOW(), NOW())
|
|
""",
|
|
mem_id,
|
|
bank_id,
|
|
text,
|
|
fact_type,
|
|
doc_id,
|
|
)
|
|
mem_ids.append(mem_id)
|
|
return mem_ids
|
|
|
|
|
|
class TestUpdateDocumentTagsObservationCleanup:
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_update_tags_returns_updated_document(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""update_document returns the updated document with new tags."""
|
|
bank_id = f"test-tag-update-basic-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
doc_id = f"doc-{uuid.uuid4().hex[:8]}"
|
|
await _insert_document_with_memories(conn, bank_id, doc_id, [("Alice loves hiking.", "experience")])
|
|
|
|
result = await memory.update_document(
|
|
doc_id, bank_id, tags=["new-tag"], request_context=request_context
|
|
)
|
|
|
|
assert result is True
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_update_tags_returns_none_for_missing_document(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""update_document returns False when document does not exist."""
|
|
bank_id = f"test-tag-update-missing-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
result = await memory.update_document(
|
|
"nonexistent-doc", bank_id, tags=["tag"], request_context=request_context
|
|
)
|
|
|
|
assert result is False
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_update_tags_propagates_to_memory_units(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Changing document tags also updates all associated memory unit tags."""
|
|
bank_id = f"test-tag-update-propagate-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
doc_id = f"doc-{uuid.uuid4().hex[:8]}"
|
|
mem_ids = await _insert_document_with_memories(
|
|
conn, bank_id, doc_id, [("Alice loves hiking.", "experience"), ("Alice hikes weekly.", "world")]
|
|
)
|
|
|
|
with patch.object(memory, "submit_async_consolidation", new=AsyncMock()):
|
|
await memory.update_document(
|
|
doc_id, bank_id, tags=["new-tag"], request_context=request_context
|
|
)
|
|
|
|
async with pool.acquire() as conn:
|
|
for mem_id in mem_ids:
|
|
tags = await conn.fetchval(
|
|
"SELECT tags FROM memory_units WHERE id = $1", mem_id
|
|
)
|
|
assert list(tags) == ["new-tag"], f"Memory unit {mem_id} should have updated tags"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_update_tags_invalidates_observations(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Observations referencing the document's memory units are deleted on tag change."""
|
|
bank_id = f"test-tag-update-obs-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
doc_id = f"doc-{uuid.uuid4().hex[:8]}"
|
|
mem_ids = await _insert_document_with_memories(
|
|
conn, bank_id, doc_id, [("Alice loves hiking.", "experience")]
|
|
)
|
|
obs_id = await _insert_observation(conn, bank_id, "Alice is a hiker.", mem_ids)
|
|
|
|
with patch.object(memory, "submit_async_consolidation", new=AsyncMock()):
|
|
await memory.update_document(
|
|
doc_id, bank_id, tags=["new-tag"], request_context=request_context
|
|
)
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs_id) not in obs_ids, "Observation should have been invalidated"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_update_tags_resets_consolidated_at_on_affected_units(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Affected memory units get consolidated_at reset for re-consolidation under new tags."""
|
|
bank_id = f"test-tag-update-reset-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
doc_id = f"doc-{uuid.uuid4().hex[:8]}"
|
|
mem_ids = await _insert_document_with_memories(
|
|
conn, bank_id, doc_id, [("Alice loves hiking.", "experience")]
|
|
)
|
|
obs_id = await _insert_observation(conn, bank_id, "Alice is a hiker.", mem_ids)
|
|
|
|
# Verify memory starts consolidated
|
|
assert await _get_consolidated_at(conn, mem_ids[0]) is not None
|
|
|
|
with patch.object(memory, "submit_async_consolidation", new=AsyncMock()):
|
|
await memory.update_document(
|
|
doc_id, bank_id, tags=["new-tag"], request_context=request_context
|
|
)
|
|
|
|
async with pool.acquire() as conn:
|
|
consolidated_at = await _get_consolidated_at(conn, mem_ids[0])
|
|
assert consolidated_at is None, "Memory unit should be reset for re-consolidation"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_update_tags_triggers_consolidation_when_observations_invalidated(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""submit_async_consolidation is called when observations are invalidated."""
|
|
bank_id = f"test-tag-update-cons-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
doc_id = f"doc-{uuid.uuid4().hex[:8]}"
|
|
mem_ids = await _insert_document_with_memories(
|
|
conn, bank_id, doc_id, [("Alice loves hiking.", "experience")]
|
|
)
|
|
await _insert_observation(conn, bank_id, "Alice is a hiker.", mem_ids)
|
|
|
|
with patch.object(memory, "submit_async_consolidation", new=AsyncMock()) as mock_consolidate:
|
|
await memory.update_document(
|
|
doc_id, bank_id, tags=["new-tag"], request_context=request_context
|
|
)
|
|
mock_consolidate.assert_awaited_once()
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_update_tags_no_consolidation_when_no_observations(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""submit_async_consolidation is NOT called when no observations are invalidated."""
|
|
bank_id = f"test-tag-update-nocons-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
doc_id = f"doc-{uuid.uuid4().hex[:8]}"
|
|
await _insert_document_with_memories(
|
|
conn, bank_id, doc_id, [("Alice loves hiking.", "experience")]
|
|
)
|
|
# No observations inserted
|
|
|
|
with patch.object(memory, "submit_async_consolidation", new=AsyncMock()) as mock_consolidate:
|
|
await memory.update_document(
|
|
doc_id, bank_id, tags=["new-tag"], request_context=request_context
|
|
)
|
|
mock_consolidate.assert_not_awaited()
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_update_tags_resets_co_source_memories_from_other_documents(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Co-source memories from other documents that shared an invalidated observation are also reset."""
|
|
bank_id = f"test-tag-update-cosource-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
doc_id = f"doc-{uuid.uuid4().hex[:8]}"
|
|
doc_mem_ids = await _insert_document_with_memories(
|
|
conn, bank_id, doc_id, [("Alice loves hiking.", "experience")]
|
|
)
|
|
# Unrelated memory from another document — co-sourced in the same observation
|
|
other_mem = await _insert_memory(conn, bank_id, "Alice also rock-climbs.")
|
|
obs_id = await _insert_observation(
|
|
conn, bank_id, "Alice loves outdoor activities.", doc_mem_ids + [other_mem]
|
|
)
|
|
|
|
# Verify other_mem starts consolidated
|
|
assert await _get_consolidated_at(conn, other_mem) is not None
|
|
|
|
with patch.object(memory, "submit_async_consolidation", new=AsyncMock()):
|
|
await memory.update_document(
|
|
doc_id, bank_id, tags=["new-tag"], request_context=request_context
|
|
)
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs_id) not in obs_ids, "Observation should have been invalidated"
|
|
|
|
# other_mem (co-source from another document) must also be reset
|
|
consolidated_at = await _get_consolidated_at(conn, other_mem)
|
|
assert consolidated_at is None, "Co-source memory from other document should be reset"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_update_tags_does_not_affect_unrelated_observations(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Observations referencing memories from a different document are not affected."""
|
|
bank_id = f"test-tag-update-unrelated-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
doc_id = f"doc-{uuid.uuid4().hex[:8]}"
|
|
mem_ids = await _insert_document_with_memories(
|
|
conn, bank_id, doc_id, [("Alice loves hiking.", "experience")]
|
|
)
|
|
# Unrelated memory not in the document
|
|
unrelated = await _insert_memory(conn, bank_id, "Bob likes cycling.")
|
|
unrelated_obs_id = await _insert_observation(
|
|
conn, bank_id, "Bob is a cyclist.", [unrelated]
|
|
)
|
|
|
|
with patch.object(memory, "submit_async_consolidation", new=AsyncMock()):
|
|
await memory.update_document(
|
|
doc_id, bank_id, tags=["new-tag"], request_context=request_context
|
|
)
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(unrelated_obs_id) in obs_ids, "Unrelated observation should remain untouched"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|