mirror of
https://github.com/headroomlabs-ai/headroom.git
synced 2026-11-22 18:41:07 +08:00
## Description Saving an existing entity with the same owner in SQLiteGraphStore deletes all of its relationships, even when the entity is unchanged. `INSERT OR REPLACE` deletes the old row before inserting its replacement, triggering the relationship foreign-key cascades. Use a targeted ID-conflict update for same-owner saves. Owner reassignment still deletes the old entity and its edges, within the same transaction; a rejected insert rolls everything back. Explicit deletion still cascades. No schema migration or dependency change is needed. `INSERT OR REPLACE` is intentionally retained alongside `ON CONFLICT(id) DO UPDATE`: the targeted ID handler avoids the destructive replacement, while the existing NOT NULL/default behavior remains intact (including null `entity_type` becoming `unknown`). This does not change other adapters or ownership semantics. Source-audited bug; no matching issue or PR found. The original implementation in #24 promises a persistent drop-in replacement, not destructive entity updates. ## Type of Change - [x] Bug fix (non-breaking change that fixes an issue) ## Changes Made - Update every entity field on a same-owner ID conflict without deleting the row. - Cover identical saves and changed fields, incoming/outgoing/self-loop edges, name lookup, reopening, BFS, explicit deletion, owner reassignment, rollback, and null/default compatibility. ## Testing - [x] Three edge-preservation cases fail on unchanged source; two ownership/rollback controls already pass. All five pass after the fix. - [x] Relevant graph/model/connection/local-backend search tests pass. - [x] Full-repository Ruff lint/format and scoped adapter mypy pass. - [x] Standalone real database proof executed outside pytest. - [ ] Full repository and optional integration qualification completed. ### Test Output ```text python -m pytest tests/test_sqlite_graph_store.py -k "saving_entity_preserves_relationships or owner_reassignment or null_entity_type" -q -o addopts='' # Before: 3 failed, 2 passed, 39 deselected python -m pytest tests/test_sqlite_graph_store.py tests/test_memory_system.py::TestEntity tests/test_memory_system.py::TestRelationship tests/test_memory_system.py::TestSubgraph tests/test_memory_system.py::TestSubgraphToContext tests/test_memory_system.py::TestInMemoryGraphStore tests/test_memory/test_adapters_connection_leak.py tests/test_memory/test_local_backend_search.py -q -rs -o addopts='' 99 passed, 983 warnings in 0.77s ruff check . All checks passed! ruff format --check . 1812 files already formatted mypy --follow-imports=silent headroom/memory/adapters/sqlite_graph.py Success: no issues found in 1 source file ``` Warnings are existing `datetime.utcnow` deprecations. Scoped mypy also notes unused configuration sections. Full-project type qualification is not claimed. ## Real Behavior Proof - Environment: Linux, CPython 3.12.14, SQLite 3.53.1, real file-backed SQLiteGraphStore compared with InMemoryGraphStore. No mocks, model inference, provider calls, or network traffic. - Exact command / steps: Save this script outside the checkout and run `PYTHONPATH=. python /path/to/proof.py` from the original and patched checkouts: ```python import asyncio import json import tempfile from pathlib import Path from headroom.memory.adapters.graph import InMemoryGraphStore from headroom.memory.adapters.graph_models import Entity, Relationship from headroom.memory.adapters.sqlite_graph import SQLiteGraphStore async def run(store): first = Entity(id='alice', user_id='owner', name='Alice') second = Entity(id='bob', user_id='owner', name='Bob') await store.add_entity(first) await store.add_entity(second) await store.add_relationship(Relationship(id='knows', user_id='owner', source_id='alice', target_id='bob')) before = [r.id for r in await store.get_relationships('alice')] await store.add_entity(first) after = [r.id for r in await store.get_relationships('alice')] return {'before':before, 'after_identical_save':after} async def main(): with tempfile.TemporaryDirectory(prefix='headroom-graph-upsert-') as directory: results = {'in_memory': await run(InMemoryGraphStore()), 'sqlite': await run(SQLiteGraphStore(Path(directory)/'graph.db'))} print(json.dumps(results,indent=2)) assert results['sqlite'] == results['in_memory'], 'SQLite entity save deleted an existing relationship' asyncio.run(main()) ``` - Observed result: Before, the in-memory store retained `knows`, but SQLite changed from `["knows"]` to `[]` after the identical entity save, and the assertion failed. After, both retain `["knows"]`; the proof exits 0. The regression suite also reopens the database and verifies updated fields and retained edges, then confirms explicit deletion removes them. - Not tested: Full repository suites, live production databases, alternate SQL engines, or model/vector integrations. This prevents future edge loss; it cannot recover relationships already deleted by earlier saves. ## Runtime Rollout Safety - Rollout-managed feature(s): None; existing SQLite graph-store API. - Minimum rollout channel: Normal release after maintainer qualification. - Stable/default behavior changed: Same-owner saves preserve relationships, consistent with the in-memory implementation. Owner reassignment continues clearing incident edges; rejected writes roll back. Explicit delete and statement-level defaults are unchanged. - Kill switch / disable path: No new flag; revert the change if needed. - Unsafe override required: No. - Qualification impact: Real-store red/green proof and 99 relevant tests pass; full repository qualification remains outstanding. - Rollback path: Revert the commit. No schema, dependency, configuration, or data migration. ## Review Readiness - [x] I have performed a self-review - [x] This PR is ready for human review Ready for human review. The current PR delta was re-reviewed with AI assistance after upstream main was synchronized; the contributor patch is unchanged. Historical tests and reviewer-reported checks remain scoped as documented below; this is not a claim of full-suite/native/provider qualification or merge approval. ## Checklist - [x] Regression cases demonstrate the original data loss. - [x] Changed files pass lint and formatting. - [x] CHANGELOG.md was not edited. - [ ] Full repository qualification completed. ## Additional Notes Implementation and validation were AI-assisted. The publication account owner has not personally rerun these checks. --------- Co-authored-by: JerrettDavis <mxjerrett@gmail.com>
1092 lines
39 KiB
Python
1092 lines
39 KiB
Python
"""Comprehensive integration tests for SQLiteGraphStore.
|
|
|
|
Tests verify:
|
|
- Entity CRUD operations with persistence
|
|
- Relationship CRUD operations with CASCADE delete
|
|
- Case-insensitive name lookups
|
|
- BFS subgraph traversal
|
|
- Shortest path finding
|
|
- User data isolation
|
|
- Memory bounding via page cache
|
|
- Database file persistence across instances
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
import sqlite3
|
|
import tempfile
|
|
from dataclasses import replace
|
|
from datetime import datetime
|
|
|
|
import pytest
|
|
|
|
from headroom.memory.adapters.graph_models import (
|
|
Entity,
|
|
Relationship,
|
|
RelationshipDirection,
|
|
)
|
|
from headroom.memory.adapters.sqlite_graph import SQLiteGraphStore
|
|
|
|
|
|
class TestSQLiteGraphStoreEntityOperations:
|
|
"""Tests for entity CRUD operations."""
|
|
|
|
@pytest.fixture
|
|
def store(self):
|
|
"""Create a temporary SQLite graph store."""
|
|
with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
|
|
db_path = f.name
|
|
store = SQLiteGraphStore(db_path=db_path)
|
|
yield store
|
|
# Cleanup
|
|
if os.path.exists(db_path):
|
|
os.unlink(db_path)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_add_and_get_entity(self, store):
|
|
"""Test adding and retrieving an entity."""
|
|
entity = Entity(
|
|
user_id="user1",
|
|
name="Project Alpha",
|
|
entity_type="project",
|
|
description="A test project",
|
|
properties={"priority": "high"},
|
|
)
|
|
|
|
await store.add_entity(entity)
|
|
retrieved = await store.get_entity(entity.id)
|
|
|
|
assert retrieved is not None
|
|
assert retrieved.id == entity.id
|
|
assert retrieved.user_id == "user1"
|
|
assert retrieved.name == "Project Alpha"
|
|
assert retrieved.entity_type == "project"
|
|
assert retrieved.description == "A test project"
|
|
assert retrieved.properties == {"priority": "high"}
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_entity_not_found(self, store):
|
|
"""Test retrieving a non-existent entity."""
|
|
result = await store.get_entity("nonexistent-id")
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_entity_by_name_case_insensitive(self, store):
|
|
"""Test case-insensitive entity lookup by name."""
|
|
entity = Entity(
|
|
user_id="user1",
|
|
name="MyEntity",
|
|
entity_type="test",
|
|
)
|
|
|
|
await store.add_entity(entity)
|
|
|
|
# All these should find the same entity
|
|
assert (await store.get_entity_by_name("user1", "MyEntity")) is not None
|
|
assert (await store.get_entity_by_name("user1", "myentity")) is not None
|
|
assert (await store.get_entity_by_name("user1", "MYENTITY")) is not None
|
|
assert (await store.get_entity_by_name("user1", "mYeNtItY")) is not None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_entity_by_name_user_isolation(self, store):
|
|
"""Test that entity lookup is scoped to user."""
|
|
entity1 = Entity(user_id="user1", name="SharedName", entity_type="test")
|
|
entity2 = Entity(user_id="user2", name="SharedName", entity_type="test")
|
|
|
|
await store.add_entity(entity1)
|
|
await store.add_entity(entity2)
|
|
|
|
result1 = await store.get_entity_by_name("user1", "SharedName")
|
|
result2 = await store.get_entity_by_name("user2", "SharedName")
|
|
|
|
assert result1 is not None
|
|
assert result2 is not None
|
|
assert result1.id != result2.id
|
|
assert result1.user_id == "user1"
|
|
assert result2.user_id == "user2"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_update_entity(self, store):
|
|
"""Test updating an existing entity."""
|
|
entity = Entity(
|
|
user_id="user1",
|
|
name="Original Name",
|
|
entity_type="test",
|
|
)
|
|
|
|
await store.add_entity(entity)
|
|
|
|
# Update the entity
|
|
entity.name = "Updated Name"
|
|
entity.entity_type = "updated_type"
|
|
entity.properties = {"new_key": "new_value"}
|
|
await store.add_entity(entity)
|
|
|
|
retrieved = await store.get_entity(entity.id)
|
|
assert retrieved is not None
|
|
assert retrieved.name == "Updated Name"
|
|
assert retrieved.entity_type == "updated_type"
|
|
assert retrieved.properties == {"new_key": "new_value"}
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize("update", [False, True], ids=["identical-save", "updated-fields"])
|
|
async def test_saving_entity_preserves_relationships(self, store, update):
|
|
entity = Entity(user_id="user1", name="Original Name", entity_type="person")
|
|
neighbor = Entity(user_id="user1", name="Neighbor", entity_type="person")
|
|
await store.add_entity(entity)
|
|
await store.add_entity(neighbor)
|
|
relationships = [
|
|
Relationship(user_id="user1", source_id=entity.id, target_id=neighbor.id),
|
|
Relationship(user_id="user1", source_id=neighbor.id, target_id=entity.id),
|
|
Relationship(user_id="user1", source_id=entity.id, target_id=entity.id),
|
|
]
|
|
for relationship in relationships:
|
|
await store.add_relationship(relationship)
|
|
|
|
saved = (
|
|
replace(
|
|
entity,
|
|
name="Updated Name",
|
|
entity_type="updated_type",
|
|
description="Updated description",
|
|
properties={"priority": "high"},
|
|
created_at=datetime(2025, 1, 2),
|
|
updated_at=datetime(2026, 1, 2),
|
|
metadata={"source": "updated"},
|
|
)
|
|
if update
|
|
else entity
|
|
)
|
|
await store.add_entity(saved)
|
|
|
|
# Reopening also verifies that preserving edges is durable, not a cache effect.
|
|
reopened = SQLiteGraphStore(store.db_path)
|
|
assert await reopened.get_entity(entity.id) == saved
|
|
assert await reopened.get_entity_by_name("user1", saved.name.upper()) == saved
|
|
if update:
|
|
assert await reopened.get_entity_by_name("user1", entity.name) is None
|
|
actual = await reopened.get_relationships(entity.id)
|
|
assert {relationship.id: relationship for relationship in actual} == {
|
|
relationship.id: relationship for relationship in relationships
|
|
}
|
|
subgraph = await reopened.query_subgraph([entity.id], max_hops=1)
|
|
assert subgraph.entity_ids == {entity.id, neighbor.id}
|
|
assert subgraph.relationship_ids == {relationship.id for relationship in relationships}
|
|
|
|
# Explicit deletion must still cascade; only an upsert preserves relationships.
|
|
assert await reopened.delete_entity(entity.id)
|
|
assert reopened.relationship_count == 0
|
|
assert await reopened.get_entity(neighbor.id) == neighbor
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize("reject", [False, True], ids=["reassign-owner", "rollback-error"])
|
|
async def test_owner_reassignment_preserves_replacement_semantics(self, store, reject):
|
|
entity = Entity(user_id="old-owner", name="Entity", entity_type="person")
|
|
neighbor = Entity(user_id="old-owner", name="Neighbor", entity_type="person")
|
|
await store.add_entity(entity)
|
|
await store.add_entity(neighbor)
|
|
relationship = Relationship(user_id="old-owner", source_id=entity.id, target_id=neighbor.id)
|
|
await store.add_relationship(relationship)
|
|
reassigned = replace(entity, user_id="new-owner")
|
|
if reject:
|
|
# Reject the save after the conditional delete to verify transaction rollback.
|
|
with store._get_conn() as conn:
|
|
conn.execute(
|
|
"""
|
|
CREATE TRIGGER reject_entity_insert BEFORE INSERT ON entities
|
|
BEGIN SELECT RAISE(ABORT, 'synthetic insert failure'); END
|
|
"""
|
|
)
|
|
with pytest.raises(sqlite3.IntegrityError, match="synthetic insert failure"):
|
|
await store.add_entity(reassigned)
|
|
else:
|
|
await store.add_entity(reassigned)
|
|
|
|
reopened = SQLiteGraphStore(store.db_path)
|
|
assert await reopened.get_entity(entity.id) == (entity if reject else reassigned)
|
|
assert await reopened.get_relationships(entity.id) == ([relationship] if reject else [])
|
|
assert await reopened.get_entity(neighbor.id) == neighbor
|
|
assert reopened.entity_count == 2
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_null_entity_type_keeps_sqlite_replacement_default(self, store):
|
|
entity = replace(Entity(user_id="user1", name="Entity"), entity_type=None)
|
|
neighbor = Entity(user_id="user1", name="Neighbor")
|
|
await store.add_entity(entity)
|
|
await store.add_entity(neighbor)
|
|
assert (await store.get_entity(entity.id)).entity_type == "unknown"
|
|
relationship = Relationship(user_id="user1", source_id=entity.id, target_id=neighbor.id)
|
|
await store.add_relationship(relationship)
|
|
|
|
for user_id in ("user1", "user2"):
|
|
await store.add_entity(replace(entity, user_id=user_id, name="Updated"))
|
|
reopened = SQLiteGraphStore(store.db_path)
|
|
retrieved = await reopened.get_entity(entity.id)
|
|
assert retrieved is not None
|
|
assert retrieved.user_id == user_id
|
|
assert retrieved.name == "Updated"
|
|
assert retrieved.entity_type == "unknown"
|
|
assert await reopened.get_relationships(entity.id) == (
|
|
[relationship] if user_id == "user1" else []
|
|
)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_delete_entity(self, store):
|
|
"""Test deleting an entity."""
|
|
entity = Entity(user_id="user1", name="ToDelete", entity_type="test")
|
|
|
|
await store.add_entity(entity)
|
|
assert await store.get_entity(entity.id) is not None
|
|
|
|
result = await store.delete_entity(entity.id)
|
|
assert result is True
|
|
|
|
assert await store.get_entity(entity.id) is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_delete_entity_not_found(self, store):
|
|
"""Test deleting a non-existent entity."""
|
|
result = await store.delete_entity("nonexistent-id")
|
|
assert result is False
|
|
|
|
|
|
class TestSQLiteGraphStoreRelationshipOperations:
|
|
"""Tests for relationship CRUD operations."""
|
|
|
|
@pytest.fixture
|
|
async def store_with_entities(self):
|
|
"""Create a store with some entities."""
|
|
with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
|
|
db_path = f.name
|
|
|
|
store = SQLiteGraphStore(db_path=db_path)
|
|
|
|
# Create entities
|
|
alice = Entity(user_id="user1", name="Alice", entity_type="person")
|
|
bob = Entity(user_id="user1", name="Bob", entity_type="person")
|
|
charlie = Entity(user_id="user1", name="Charlie", entity_type="person")
|
|
|
|
await store.add_entity(alice)
|
|
await store.add_entity(bob)
|
|
await store.add_entity(charlie)
|
|
|
|
yield store, alice, bob, charlie
|
|
|
|
# Cleanup
|
|
if os.path.exists(db_path):
|
|
os.unlink(db_path)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_add_and_get_relationship(self, store_with_entities):
|
|
"""Test adding and retrieving a relationship."""
|
|
store, alice, bob, _ = store_with_entities
|
|
|
|
rel = Relationship(
|
|
user_id="user1",
|
|
source_id=alice.id,
|
|
target_id=bob.id,
|
|
relation_type="knows",
|
|
weight=0.9,
|
|
properties={"since": "2020"},
|
|
)
|
|
|
|
await store.add_relationship(rel)
|
|
|
|
# Get outgoing relationships from Alice
|
|
rels = await store.get_relationships(alice.id, RelationshipDirection.OUTGOING)
|
|
assert len(rels) == 1
|
|
assert rels[0].id == rel.id
|
|
assert rels[0].source_id == alice.id
|
|
assert rels[0].target_id == bob.id
|
|
assert rels[0].relation_type == "knows"
|
|
assert rels[0].weight == 0.9
|
|
assert rels[0].properties == {"since": "2020"}
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_relationships_by_direction(self, store_with_entities):
|
|
"""Test getting relationships by direction."""
|
|
store, alice, bob, charlie = store_with_entities
|
|
|
|
# Alice -> Bob
|
|
rel1 = Relationship(
|
|
user_id="user1",
|
|
source_id=alice.id,
|
|
target_id=bob.id,
|
|
relation_type="knows",
|
|
)
|
|
# Charlie -> Alice
|
|
rel2 = Relationship(
|
|
user_id="user1",
|
|
source_id=charlie.id,
|
|
target_id=alice.id,
|
|
relation_type="follows",
|
|
)
|
|
|
|
await store.add_relationship(rel1)
|
|
await store.add_relationship(rel2)
|
|
|
|
# Outgoing from Alice
|
|
outgoing = await store.get_relationships(alice.id, RelationshipDirection.OUTGOING)
|
|
assert len(outgoing) == 1
|
|
assert outgoing[0].target_id == bob.id
|
|
|
|
# Incoming to Alice
|
|
incoming = await store.get_relationships(alice.id, RelationshipDirection.INCOMING)
|
|
assert len(incoming) == 1
|
|
assert incoming[0].source_id == charlie.id
|
|
|
|
# Both directions
|
|
both = await store.get_relationships(alice.id, RelationshipDirection.BOTH)
|
|
assert len(both) == 2
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_relationships_filter_by_type(self, store_with_entities):
|
|
"""Test filtering relationships by type."""
|
|
store, alice, bob, charlie = store_with_entities
|
|
|
|
rel1 = Relationship(
|
|
user_id="user1",
|
|
source_id=alice.id,
|
|
target_id=bob.id,
|
|
relation_type="knows",
|
|
)
|
|
rel2 = Relationship(
|
|
user_id="user1",
|
|
source_id=alice.id,
|
|
target_id=charlie.id,
|
|
relation_type="manages",
|
|
)
|
|
|
|
await store.add_relationship(rel1)
|
|
await store.add_relationship(rel2)
|
|
|
|
# Filter by type
|
|
knows_rels = await store.get_relationships(
|
|
alice.id, RelationshipDirection.OUTGOING, relation_type="knows"
|
|
)
|
|
assert len(knows_rels) == 1
|
|
assert knows_rels[0].target_id == bob.id
|
|
|
|
manages_rels = await store.get_relationships(
|
|
alice.id, RelationshipDirection.OUTGOING, relation_type="manages"
|
|
)
|
|
assert len(manages_rels) == 1
|
|
assert manages_rels[0].target_id == charlie.id
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_delete_relationship(self, store_with_entities):
|
|
"""Test deleting a relationship."""
|
|
store, alice, bob, _ = store_with_entities
|
|
|
|
rel = Relationship(
|
|
user_id="user1",
|
|
source_id=alice.id,
|
|
target_id=bob.id,
|
|
relation_type="knows",
|
|
)
|
|
|
|
await store.add_relationship(rel)
|
|
rels = await store.get_relationships(alice.id, RelationshipDirection.OUTGOING)
|
|
assert len(rels) == 1
|
|
|
|
result = await store.delete_relationship(rel.id)
|
|
assert result is True
|
|
|
|
rels = await store.get_relationships(alice.id, RelationshipDirection.OUTGOING)
|
|
assert len(rels) == 0
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_cascade_delete_relationships(self, store_with_entities):
|
|
"""Test that deleting an entity cascades to its relationships."""
|
|
store, alice, bob, charlie = store_with_entities
|
|
|
|
# Create relationships
|
|
rel1 = Relationship(
|
|
user_id="user1",
|
|
source_id=alice.id,
|
|
target_id=bob.id,
|
|
relation_type="knows",
|
|
)
|
|
rel2 = Relationship(
|
|
user_id="user1",
|
|
source_id=charlie.id,
|
|
target_id=alice.id,
|
|
relation_type="follows",
|
|
)
|
|
|
|
await store.add_relationship(rel1)
|
|
await store.add_relationship(rel2)
|
|
|
|
# Delete Alice - should cascade delete both relationships
|
|
await store.delete_entity(alice.id)
|
|
|
|
# Both relationships should be gone
|
|
bob_rels = await store.get_relationships(bob.id, RelationshipDirection.BOTH)
|
|
assert len(bob_rels) == 0
|
|
|
|
charlie_rels = await store.get_relationships(charlie.id, RelationshipDirection.BOTH)
|
|
assert len(charlie_rels) == 0
|
|
|
|
|
|
class TestSQLiteGraphStoreTraversal:
|
|
"""Tests for graph traversal operations."""
|
|
|
|
@pytest.fixture
|
|
async def store_with_graph(self):
|
|
"""Create a store with a connected graph.
|
|
|
|
Graph structure:
|
|
A -> B -> D
|
|
| |
|
|
v v
|
|
C -> E
|
|
"""
|
|
with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
|
|
db_path = f.name
|
|
|
|
store = SQLiteGraphStore(db_path=db_path)
|
|
|
|
# Create entities
|
|
a = Entity(user_id="user1", name="A", entity_type="node")
|
|
b = Entity(user_id="user1", name="B", entity_type="node")
|
|
c = Entity(user_id="user1", name="C", entity_type="node")
|
|
d = Entity(user_id="user1", name="D", entity_type="node")
|
|
e = Entity(user_id="user1", name="E", entity_type="node")
|
|
|
|
for entity in [a, b, c, d, e]:
|
|
await store.add_entity(entity)
|
|
|
|
# Create relationships: A->B, A->C, B->D, B->E, C->E
|
|
rels = [
|
|
Relationship(user_id="user1", source_id=a.id, target_id=b.id, relation_type="edge"),
|
|
Relationship(user_id="user1", source_id=a.id, target_id=c.id, relation_type="edge"),
|
|
Relationship(user_id="user1", source_id=b.id, target_id=d.id, relation_type="edge"),
|
|
Relationship(user_id="user1", source_id=b.id, target_id=e.id, relation_type="edge"),
|
|
Relationship(user_id="user1", source_id=c.id, target_id=e.id, relation_type="edge"),
|
|
]
|
|
|
|
for rel in rels:
|
|
await store.add_relationship(rel)
|
|
|
|
yield store, {"A": a, "B": b, "C": c, "D": d, "E": e}
|
|
|
|
# Cleanup
|
|
if os.path.exists(db_path):
|
|
os.unlink(db_path)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_query_subgraph_single_hop(self, store_with_graph):
|
|
"""Test querying subgraph with single hop."""
|
|
store, nodes = store_with_graph
|
|
|
|
subgraph = await store.query_subgraph(
|
|
[nodes["A"].id], max_hops=1, direction=RelationshipDirection.OUTGOING
|
|
)
|
|
|
|
entity_names = {e.name for e in subgraph.entities}
|
|
assert entity_names == {"A", "B", "C"}
|
|
assert len(subgraph.relationships) == 2
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_query_subgraph_two_hops(self, store_with_graph):
|
|
"""Test querying subgraph with two hops."""
|
|
store, nodes = store_with_graph
|
|
|
|
subgraph = await store.query_subgraph(
|
|
[nodes["A"].id], max_hops=2, direction=RelationshipDirection.OUTGOING
|
|
)
|
|
|
|
entity_names = {e.name for e in subgraph.entities}
|
|
assert entity_names == {"A", "B", "C", "D", "E"}
|
|
assert len(subgraph.relationships) == 5
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_query_subgraph_incoming(self, store_with_graph):
|
|
"""Test querying subgraph with incoming direction."""
|
|
store, nodes = store_with_graph
|
|
|
|
subgraph = await store.query_subgraph(
|
|
[nodes["E"].id], max_hops=2, direction=RelationshipDirection.INCOMING
|
|
)
|
|
|
|
entity_names = {e.name for e in subgraph.entities}
|
|
# E <- B <- A, E <- C <- A
|
|
assert "E" in entity_names
|
|
assert "B" in entity_names
|
|
assert "C" in entity_names
|
|
assert "A" in entity_names
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_query_subgraph_both_direction_respects_relation_type_filter(self, tmp_path):
|
|
"""A relation_types filter must apply to BOTH the outgoing and incoming
|
|
sides of a ``direction=BOTH`` traversal.
|
|
|
|
Regression: the BOTH query was ``WHERE source_id = ? OR target_id = ?``
|
|
without parentheses, then ``AND relation_type IN (...)`` was appended.
|
|
SQL binds ``AND`` tighter than ``OR``, so the type filter applied only to
|
|
the incoming (target_id) side, letting outgoing edges of every type leak
|
|
into the subgraph.
|
|
"""
|
|
store = SQLiteGraphStore(db_path=str(tmp_path / "graph.db"))
|
|
x = Entity(user_id="u", name="X", entity_type="node")
|
|
liked = Entity(user_id="u", name="Liked", entity_type="node")
|
|
disliked = Entity(user_id="u", name="Disliked", entity_type="node")
|
|
for entity in (x, liked, disliked):
|
|
await store.add_entity(entity)
|
|
# Two OUTGOING edges from X of different types.
|
|
await store.add_relationship(
|
|
Relationship(user_id="u", source_id=x.id, target_id=liked.id, relation_type="likes")
|
|
)
|
|
await store.add_relationship(
|
|
Relationship(
|
|
user_id="u", source_id=x.id, target_id=disliked.id, relation_type="dislikes"
|
|
)
|
|
)
|
|
|
|
subgraph = await store.query_subgraph(
|
|
[x.id],
|
|
max_hops=1,
|
|
direction=RelationshipDirection.BOTH,
|
|
relation_types=["likes"],
|
|
)
|
|
|
|
types = {r.relation_type for r in subgraph.relationships}
|
|
assert types == {"likes"}, f"type filter leaked non-'likes' edges: {types}"
|
|
names = {e.name for e in subgraph.entities}
|
|
assert "Disliked" not in names
|
|
assert names == {"X", "Liked"}
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_find_path_direct(self, store_with_graph):
|
|
"""Test finding a direct path."""
|
|
store, nodes = store_with_graph
|
|
|
|
path = await store.find_path(nodes["A"].id, nodes["B"].id)
|
|
|
|
assert path is not None
|
|
assert len(path) == 2
|
|
assert path[0] == nodes["A"].id
|
|
assert path[1] == nodes["B"].id
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_find_path_multi_hop(self, store_with_graph):
|
|
"""Test finding a multi-hop path."""
|
|
store, nodes = store_with_graph
|
|
|
|
path = await store.find_path(nodes["A"].id, nodes["D"].id)
|
|
|
|
assert path is not None
|
|
assert len(path) == 3 # A -> B -> D
|
|
assert path[0] == nodes["A"].id
|
|
assert path[-1] == nodes["D"].id
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_find_path_not_found(self, store_with_graph):
|
|
"""Test that None is returned when no path exists."""
|
|
store, nodes = store_with_graph
|
|
|
|
# D has no outgoing edges, so no path from D to A
|
|
path = await store.find_path(
|
|
nodes["D"].id, nodes["A"].id, direction=RelationshipDirection.OUTGOING
|
|
)
|
|
|
|
assert path is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_find_path_self(self, store_with_graph):
|
|
"""Test finding a path to self."""
|
|
store, nodes = store_with_graph
|
|
|
|
path = await store.find_path(nodes["A"].id, nodes["A"].id)
|
|
|
|
assert path is not None
|
|
assert path == [nodes["A"].id]
|
|
|
|
|
|
class TestSQLiteGraphStoreUserManagement:
|
|
"""Tests for user data management."""
|
|
|
|
@pytest.fixture
|
|
def store(self):
|
|
"""Create a temporary SQLite graph store."""
|
|
with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
|
|
db_path = f.name
|
|
store = SQLiteGraphStore(db_path=db_path)
|
|
yield store
|
|
if os.path.exists(db_path):
|
|
os.unlink(db_path)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_entities_for_user(self, store):
|
|
"""Test getting all entities for a specific user."""
|
|
# Create entities for two users
|
|
for i in range(3):
|
|
await store.add_entity(
|
|
Entity(user_id="user1", name=f"User1Entity{i}", entity_type="test")
|
|
)
|
|
for i in range(2):
|
|
await store.add_entity(
|
|
Entity(user_id="user2", name=f"User2Entity{i}", entity_type="test")
|
|
)
|
|
|
|
user1_entities = await store.get_entities_for_user("user1")
|
|
user2_entities = await store.get_entities_for_user("user2")
|
|
|
|
assert len(user1_entities) == 3
|
|
assert len(user2_entities) == 2
|
|
assert all(e.user_id == "user1" for e in user1_entities)
|
|
assert all(e.user_id == "user2" for e in user2_entities)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_clear_user(self, store):
|
|
"""Test clearing all data for a user."""
|
|
# Create entities and relationships for two users
|
|
alice = Entity(user_id="user1", name="Alice", entity_type="person")
|
|
bob = Entity(user_id="user1", name="Bob", entity_type="person")
|
|
carol = Entity(user_id="user2", name="Carol", entity_type="person")
|
|
|
|
await store.add_entity(alice)
|
|
await store.add_entity(bob)
|
|
await store.add_entity(carol)
|
|
|
|
rel = Relationship(
|
|
user_id="user1",
|
|
source_id=alice.id,
|
|
target_id=bob.id,
|
|
relation_type="knows",
|
|
)
|
|
await store.add_relationship(rel)
|
|
|
|
# Clear user1
|
|
entities_deleted, rels_deleted = await store.clear_user("user1")
|
|
|
|
assert entities_deleted == 2
|
|
assert rels_deleted == 1
|
|
|
|
# User2 data should still exist
|
|
assert await store.get_entity(carol.id) is not None
|
|
assert store.entity_count == 1
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_clear_all(self, store):
|
|
"""Test clearing all data."""
|
|
# Add some data
|
|
for i in range(5):
|
|
await store.add_entity(
|
|
Entity(user_id=f"user{i}", name=f"Entity{i}", entity_type="test")
|
|
)
|
|
|
|
assert store.entity_count == 5
|
|
|
|
await store.clear()
|
|
|
|
assert store.entity_count == 0
|
|
assert store.relationship_count == 0
|
|
|
|
|
|
class TestSQLiteGraphStorePersistence:
|
|
"""Tests for data persistence across store instances."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_data_persists_across_instances(self):
|
|
"""Test that data survives store restart."""
|
|
with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
|
|
db_path = f.name
|
|
|
|
try:
|
|
# Create store and add data
|
|
store1 = SQLiteGraphStore(db_path=db_path)
|
|
entity = Entity(user_id="user1", name="Persistent", entity_type="test")
|
|
await store1.add_entity(entity)
|
|
entity_id = entity.id
|
|
|
|
# Create new store instance pointing to same database
|
|
store2 = SQLiteGraphStore(db_path=db_path)
|
|
|
|
# Data should be there
|
|
retrieved = await store2.get_entity(entity_id)
|
|
assert retrieved is not None
|
|
assert retrieved.name == "Persistent"
|
|
finally:
|
|
if os.path.exists(db_path):
|
|
os.unlink(db_path)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_relationships_persist(self):
|
|
"""Test that relationships persist across instances."""
|
|
with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
|
|
db_path = f.name
|
|
|
|
try:
|
|
store1 = SQLiteGraphStore(db_path=db_path)
|
|
|
|
alice = Entity(user_id="user1", name="Alice", entity_type="person")
|
|
bob = Entity(user_id="user1", name="Bob", entity_type="person")
|
|
await store1.add_entity(alice)
|
|
await store1.add_entity(bob)
|
|
|
|
rel = Relationship(
|
|
user_id="user1",
|
|
source_id=alice.id,
|
|
target_id=bob.id,
|
|
relation_type="knows",
|
|
)
|
|
await store1.add_relationship(rel)
|
|
|
|
# New instance
|
|
store2 = SQLiteGraphStore(db_path=db_path)
|
|
|
|
rels = await store2.get_relationships(alice.id, RelationshipDirection.OUTGOING)
|
|
assert len(rels) == 1
|
|
assert rels[0].target_id == bob.id
|
|
finally:
|
|
if os.path.exists(db_path):
|
|
os.unlink(db_path)
|
|
|
|
|
|
class TestSQLiteGraphStoreMemoryStats:
|
|
"""Tests for memory statistics and bounding."""
|
|
|
|
@pytest.fixture
|
|
def store(self):
|
|
"""Create a temporary SQLite graph store."""
|
|
with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
|
|
db_path = f.name
|
|
store = SQLiteGraphStore(db_path=db_path, page_cache_size_kb=4096)
|
|
yield store
|
|
if os.path.exists(db_path):
|
|
os.unlink(db_path)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_stats(self, store):
|
|
"""Test getting store statistics."""
|
|
# Add some data
|
|
for i in range(10):
|
|
await store.add_entity(Entity(user_id="user1", name=f"Entity{i}", entity_type="test"))
|
|
|
|
stats = store.stats()
|
|
|
|
assert stats["entity_count"] == 10
|
|
assert stats["relationship_count"] == 0
|
|
assert stats["users_count"] == 1
|
|
assert stats["page_cache_size_kb"] == 4096
|
|
assert "db_path" in stats
|
|
assert stats["db_size_bytes"] > 0
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_memory_stats(self, store):
|
|
"""Test memory statistics for MemoryTracker."""
|
|
# Add some data
|
|
for i in range(5):
|
|
await store.add_entity(Entity(user_id="user1", name=f"Entity{i}", entity_type="test"))
|
|
|
|
stats = store.get_memory_stats()
|
|
|
|
assert stats.name == "sqlite_graph_store"
|
|
assert stats.entry_count == 5
|
|
assert stats.size_bytes > 0
|
|
# Budget should be the page cache size
|
|
assert stats.budget_bytes == 4096 * 1024
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_vacuum(self, store):
|
|
"""Test vacuuming the database."""
|
|
# Add and delete data
|
|
entities = []
|
|
for i in range(100):
|
|
e = Entity(user_id="user1", name=f"Entity{i}", entity_type="test")
|
|
await store.add_entity(e)
|
|
entities.append(e)
|
|
|
|
# Delete all
|
|
for e in entities:
|
|
await store.delete_entity(e.id)
|
|
|
|
# Get size before vacuum
|
|
stats_before = store.stats()
|
|
|
|
# Vacuum
|
|
store.vacuum()
|
|
|
|
# Size should be smaller or same after vacuum
|
|
stats_after = store.stats()
|
|
assert stats_after["db_size_bytes"] <= stats_before["db_size_bytes"]
|
|
|
|
|
|
class TestSQLiteGraphStoreEdgeCases:
|
|
"""Tests for edge cases and error handling."""
|
|
|
|
@pytest.fixture
|
|
def store(self):
|
|
"""Create a temporary SQLite graph store."""
|
|
with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
|
|
db_path = f.name
|
|
store = SQLiteGraphStore(db_path=db_path)
|
|
yield store
|
|
if os.path.exists(db_path):
|
|
os.unlink(db_path)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_empty_subgraph_query(self, store):
|
|
"""Test querying subgraph with no entities."""
|
|
subgraph = await store.query_subgraph(["nonexistent-id"])
|
|
assert len(subgraph.entities) == 0
|
|
assert len(subgraph.relationships) == 0
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_one_corrupt_row_does_not_abort_a_multi_row_scan(self, tmp_path):
|
|
"""A single unparseable row must not take down an entire query.
|
|
|
|
Regression: ``_row_to_relationship`` / ``_row_to_entity`` parsed stored
|
|
JSON/timestamps with no guard, so one corrupt row (partial write, manual
|
|
edit, bad migration) raised inside the row loop and aborted the whole
|
|
``query_subgraph`` / ``get_relationships`` scan — taking unrelated,
|
|
perfectly good edges down with it. The corrupt row is now skipped.
|
|
"""
|
|
import sqlite3
|
|
|
|
store = SQLiteGraphStore(db_path=str(tmp_path / "graph.db"))
|
|
a = Entity(user_id="u", name="A", entity_type="n")
|
|
b = Entity(user_id="u", name="B", entity_type="n")
|
|
c = Entity(user_id="u", name="C", entity_type="n")
|
|
for entity in (a, b, c):
|
|
await store.add_entity(entity)
|
|
await store.add_relationship(
|
|
Relationship(user_id="u", source_id=a.id, target_id=b.id, relation_type="e")
|
|
)
|
|
await store.add_relationship(
|
|
Relationship(user_id="u", source_id=a.id, target_id=c.id, relation_type="e")
|
|
)
|
|
|
|
# Corrupt the A->B relationship row's properties JSON out-of-band.
|
|
con = sqlite3.connect(str(store.db_path))
|
|
con.execute("UPDATE relationships SET properties = '{oops' WHERE target_id = ?", (b.id,))
|
|
con.commit()
|
|
con.close()
|
|
|
|
# get_relationships returns the one good edge instead of raising.
|
|
rels = await store.get_relationships(a.id)
|
|
assert len(rels) == 1
|
|
assert rels[0].target_id == c.id
|
|
|
|
# query_subgraph completes, skipping the corrupt edge and its node.
|
|
subgraph = await store.query_subgraph(
|
|
[a.id], max_hops=1, direction=RelationshipDirection.OUTGOING
|
|
)
|
|
assert {e.name for e in subgraph.entities} == {"A", "C"}
|
|
assert len(subgraph.relationships) == 1
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_entity_with_special_characters(self, store):
|
|
"""Test entity names with special characters."""
|
|
entity = Entity(
|
|
user_id="user1",
|
|
name='Test\'s "Entity" (Special & <More>)',
|
|
entity_type="test",
|
|
description="Description with 'quotes' and \"more\"",
|
|
properties={"key": "value with 'quotes'"},
|
|
)
|
|
|
|
await store.add_entity(entity)
|
|
retrieved = await store.get_entity(entity.id)
|
|
|
|
assert retrieved is not None
|
|
assert retrieved.name == entity.name
|
|
assert retrieved.description == entity.description
|
|
assert retrieved.properties == entity.properties
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_entity_with_unicode(self, store):
|
|
"""Test entity names with unicode characters."""
|
|
entity = Entity(
|
|
user_id="user1",
|
|
name="Test 你好 🚀 Ñoño",
|
|
entity_type="test",
|
|
)
|
|
|
|
await store.add_entity(entity)
|
|
retrieved = await store.get_entity(entity.id)
|
|
|
|
assert retrieved is not None
|
|
assert retrieved.name == "Test 你好 🚀 Ñoño"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_large_properties(self, store):
|
|
"""Test entities with large properties."""
|
|
large_props = {f"key_{i}": f"value_{i}" * 100 for i in range(100)}
|
|
|
|
entity = Entity(
|
|
user_id="user1",
|
|
name="LargeEntity",
|
|
entity_type="test",
|
|
properties=large_props,
|
|
)
|
|
|
|
await store.add_entity(entity)
|
|
retrieved = await store.get_entity(entity.id)
|
|
|
|
assert retrieved is not None
|
|
assert retrieved.properties == large_props
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_concurrent_access(self, store):
|
|
"""Test basic concurrent access (thread-safe pattern)."""
|
|
import asyncio
|
|
|
|
async def add_entity(i: int):
|
|
e = Entity(user_id="user1", name=f"Concurrent{i}", entity_type="test")
|
|
await store.add_entity(e)
|
|
return e.id
|
|
|
|
# Add entities concurrently
|
|
ids = await asyncio.gather(*[add_entity(i) for i in range(20)])
|
|
|
|
# All should exist
|
|
assert len(ids) == 20
|
|
assert store.entity_count == 20
|
|
|
|
|
|
class TestSQLiteGraphStoreMemoryTrackerIntegration:
|
|
"""Tests for MemoryTracker integration."""
|
|
|
|
@pytest.fixture
|
|
def store(self):
|
|
"""Create a temporary SQLite graph store."""
|
|
with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
|
|
db_path = f.name
|
|
store = SQLiteGraphStore(db_path=db_path, page_cache_size_kb=4096)
|
|
yield store
|
|
if os.path.exists(db_path):
|
|
os.unlink(db_path)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_memory_tracker_registration(self, store):
|
|
"""Test registering SQLiteGraphStore with MemoryTracker."""
|
|
from headroom.memory.tracker import MemoryTracker
|
|
|
|
tracker = MemoryTracker.get()
|
|
|
|
# Unregister if already registered from previous test
|
|
tracker.unregister("sqlite_graph_test")
|
|
|
|
# Register the store
|
|
tracker.register("sqlite_graph_test", store.get_memory_stats)
|
|
|
|
try:
|
|
# Add some data
|
|
for i in range(10):
|
|
await store.add_entity(
|
|
Entity(user_id="user1", name=f"Entity{i}", entity_type="test")
|
|
)
|
|
|
|
# Get report
|
|
report = tracker.get_report()
|
|
|
|
# Find our component in the report's components dict
|
|
assert "sqlite_graph_test" in report.components
|
|
graph_stats = report.components["sqlite_graph_test"]
|
|
|
|
assert graph_stats is not None
|
|
assert graph_stats.entry_count == 10
|
|
assert graph_stats.budget_bytes == 4096 * 1024 # 4MB cache
|
|
finally:
|
|
tracker.unregister("sqlite_graph_test")
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_memory_stats_tracks_growth(self, store):
|
|
"""Test that memory stats track entity/relationship growth."""
|
|
stats_before = store.get_memory_stats()
|
|
assert stats_before.entry_count == 0
|
|
|
|
# Add entities
|
|
entities = []
|
|
for i in range(5):
|
|
e = Entity(user_id="user1", name=f"Entity{i}", entity_type="test")
|
|
await store.add_entity(e)
|
|
entities.append(e)
|
|
|
|
stats_after_entities = store.get_memory_stats()
|
|
assert stats_after_entities.entry_count == 5
|
|
|
|
# Add relationships
|
|
for i in range(4):
|
|
rel = Relationship(
|
|
user_id="user1",
|
|
source_id=entities[i].id,
|
|
target_id=entities[i + 1].id,
|
|
relation_type="connected",
|
|
)
|
|
await store.add_relationship(rel)
|
|
|
|
stats_after_rels = store.get_memory_stats()
|
|
assert stats_after_rels.entry_count == 9 # 5 entities + 4 relationships
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_memory_stats_bounded_by_cache(self, store):
|
|
"""Test that reported size is bounded by cache size."""
|
|
# Add many entities
|
|
for i in range(100):
|
|
await store.add_entity(Entity(user_id="user1", name=f"Entity{i}", entity_type="test"))
|
|
|
|
stats = store.get_memory_stats()
|
|
|
|
# Size should be bounded by cache + overhead
|
|
# Cache is 4MB, overhead should be small
|
|
assert stats.size_bytes < 5 * 1024 * 1024 # Less than 5MB
|
|
assert stats.budget_bytes == 4096 * 1024 # Exactly 4MB
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_memory_report_includes_sqlite_graph(self, store):
|
|
"""Test that MemoryTracker report includes SQLiteGraphStore stats."""
|
|
from headroom.memory.tracker import MemoryTracker
|
|
|
|
tracker = MemoryTracker.get()
|
|
|
|
# Unregister if already registered from previous test
|
|
tracker.unregister("graph_report_test")
|
|
tracker.register("graph_report_test", store.get_memory_stats)
|
|
|
|
try:
|
|
# Add data
|
|
await store.add_entity(Entity(user_id="user1", name="Test", entity_type="test"))
|
|
|
|
# Get full report dict
|
|
report = tracker.get_report()
|
|
report_dict = report.to_dict()
|
|
|
|
# Verify structure
|
|
assert "components" in report_dict
|
|
assert len(report_dict["components"]) > 0
|
|
|
|
# Find our component (components is a dict in to_dict output)
|
|
assert "graph_report_test" in report_dict["components"]
|
|
comp = report_dict["components"]["graph_report_test"]
|
|
|
|
assert comp["name"] == "sqlite_graph_store"
|
|
assert comp["entry_count"] == 1
|
|
assert "size_bytes" in comp
|
|
assert "budget_bytes" in comp
|
|
finally:
|
|
tracker.unregister("graph_report_test")
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_memory_stats_after_delete(self, store):
|
|
"""Test that memory stats decrease after deletion."""
|
|
# Add entities
|
|
entities = []
|
|
for i in range(10):
|
|
e = Entity(user_id="user1", name=f"Entity{i}", entity_type="test")
|
|
await store.add_entity(e)
|
|
entities.append(e)
|
|
|
|
stats_before_delete = store.get_memory_stats()
|
|
assert stats_before_delete.entry_count == 10
|
|
|
|
# Delete half
|
|
for e in entities[:5]:
|
|
await store.delete_entity(e.id)
|
|
|
|
stats_after_delete = store.get_memory_stats()
|
|
assert stats_after_delete.entry_count == 5
|