@smilintux/skmemory 0.5.0 → 0.7.2

package/tests/test_skvector_backend.py

@@ -0,0 +1,326 @@
+"""Tests for the SKVector (Qdrant) vector search backend.
+
+Mocks the Qdrant client and sentence-transformers to test
+logic without requiring infrastructure. Verifies save, search,
+list, delete, and health check operations.
+"""
+
+from __future__ import annotations
+
+import json
+from unittest.mock import MagicMock, patch, PropertyMock
+
+import pytest
+
+from skmemory.backends.skvector_backend import (
+    COLLECTION_NAME,
+    VECTOR_DIM,
+    SKVectorBackend,
+    _extract_status_code,
+)
+from skmemory.models import EmotionalSnapshot, Memory, MemoryLayer
+
+try:
+    import qdrant_client  # noqa: F401
+    QDRANT_AVAILABLE = True
+except ImportError:
+    QDRANT_AVAILABLE = False
+
+pytestmark = pytest.mark.skipif(
+    not QDRANT_AVAILABLE,
+    reason="qdrant-client not installed",
+)
+
+
+@pytest.fixture
+def mock_qdrant_client():
+    """Mocked Qdrant client with collection support."""
+    client = MagicMock()
+    collection_mock = MagicMock()
+    collection_mock.name = COLLECTION_NAME
+    client.get_collections.return_value.collections = [collection_mock]
+    client.scroll.return_value = ([], None)
+    client.search.return_value = []
+    return client
+
+
+@pytest.fixture
+def mock_embedder():
+    """Mocked sentence-transformers model."""
+    import numpy as np
+
+    embedder = MagicMock()
+    embedder.encode.return_value = np.random.rand(VECTOR_DIM).astype("float32")
+    return embedder
+
+
+@pytest.fixture
+def backend(mock_qdrant_client, mock_embedder):
+    """Provide a SKVectorBackend with mocked dependencies."""
+    qb = SKVectorBackend(url="http://mock:6333")
+    qb._client = mock_qdrant_client
+    qb._embedder = mock_embedder
+    qb._initialized = True
+    return qb
+
+
+@pytest.fixture
+def sample_memory():
+    """A sample memory for testing."""
+    return Memory(
+        title="The Secret Recipe",
+        content="Chef figured it out -- projection creates reality.",
+        layer=MemoryLayer("long-term"),
+        tags=["cloud9", "philosophy"],
+        emotional=EmotionalSnapshot(intensity=10.0, valence=0.9),
+        source="cli",
+    )
+
+
+# ═══════════════════════════════════════════════════════════
+# Initialization
+# ═══════════════════════════════════════════════════════════
+
+
+class TestInitialization:
+    """Test lazy initialization."""
+
+    def test_not_initialized_by_default(self):
+        """Backend starts uninitialized."""
+        qb = SKVectorBackend()
+        assert qb._initialized is False
+
+    def test_init_fails_without_qdrant(self):
+        """Fails gracefully without qdrant-client."""
+        qb = SKVectorBackend()
+        with patch("builtins.__import__", side_effect=ImportError):
+            assert qb._ensure_initialized() is False
+
+    def test_already_initialized_shortcuts(self, backend):
+        """Second init call returns immediately."""
+        assert backend._ensure_initialized() is True
+
+
+# ═══════════════════════════════════════════════════════════
+# Save
+# ═══════════════════════════════════════════════════════════
+
+
+class TestSave:
+    """Test memory indexing in Qdrant."""
+
+    def test_save_calls_upsert(self, backend, mock_qdrant_client, sample_memory):
+        """save() creates a point and upserts it."""
+        result = backend.save(sample_memory)
+        assert result == sample_memory.id
+        mock_qdrant_client.upsert.assert_called_once()
+
+    def test_save_generates_embedding(self, backend, mock_embedder, sample_memory):
+        """save() generates an embedding from the memory text."""
+        backend.save(sample_memory)
+        mock_embedder.encode.assert_called_once()
+
+    def test_save_not_initialized(self, sample_memory):
+        """save() returns id gracefully when not initialized."""
+        qb = SKVectorBackend()
+        result = qb.save(sample_memory)
+        assert result == sample_memory.id
+
+
+# ═══════════════════════════════════════════════════════════
+# Search
+# ═══════════════════════════════════════════════════════════
+
+
+class TestSearch:
+    """Test semantic search."""
+
+    def test_search_text_generates_embedding(self, backend, mock_embedder):
+        """search_text embeds the query before searching."""
+        backend.search_text("moments of connection")
+        mock_embedder.encode.assert_called_once_with("moments of connection")
+
+    def test_search_text_calls_qdrant_search(self, backend, mock_qdrant_client):
+        """search_text uses Qdrant's search endpoint."""
+        backend.search_text("test query", limit=5)
+        mock_qdrant_client.search.assert_called_once()
+
+    def test_search_text_returns_memories(self, backend, mock_qdrant_client, sample_memory):
+        """search_text parses results into Memory objects."""
+        scored_point = MagicMock()
+        scored_point.payload = {"memory_json": sample_memory.model_dump_json()}
+        mock_qdrant_client.search.return_value = [scored_point]
+
+        results = backend.search_text("secret recipe")
+        assert len(results) == 1
+        assert results[0].title == "The Secret Recipe"
+
+    def test_search_text_empty_results(self, backend, mock_qdrant_client):
+        """search_text returns empty list when nothing matches."""
+        mock_qdrant_client.search.return_value = []
+        assert backend.search_text("nonexistent") == []
+
+    def test_search_not_initialized(self):
+        """search_text returns empty when not initialized."""
+        qb = SKVectorBackend()
+        assert qb.search_text("anything") == []
+
+
+# ═══════════════════════════════════════════════════════════
+# List
+# ═══════════════════════════════════════════════════════════
+
+
+class TestList:
+    """Test memory listing with filters."""
+
+    def test_list_memories_calls_scroll(self, backend, mock_qdrant_client):
+        """list_memories uses Qdrant scroll API."""
+        backend.list_memories()
+        mock_qdrant_client.scroll.assert_called_once()
+
+    def test_list_memories_with_layer_filter(self, backend, mock_qdrant_client):
+        """list_memories passes layer filter to Qdrant."""
+        backend.list_memories(layer=MemoryLayer("long-term"))
+        call_kwargs = mock_qdrant_client.scroll.call_args
+        assert call_kwargs is not None
+
+    def test_list_not_initialized(self):
+        """list_memories returns empty when not initialized."""
+        qb = SKVectorBackend()
+        assert qb.list_memories() == []
+
+
+# ═══════════════════════════════════════════════════════════
+# Delete
+# ═══════════════════════════════════════════════════════════
+
+
+class TestDelete:
+    """Test memory deletion."""
+
+    def test_delete_not_found(self, backend, mock_qdrant_client):
+        """delete returns False when memory not in Qdrant."""
+        mock_qdrant_client.retrieve.return_value = []
+        assert backend.delete("nonexistent") is False
+
+    def test_delete_not_initialized(self):
+        """delete returns False when not initialized."""
+        qb = SKVectorBackend()
+        assert qb.delete("any") is False
+
+
+# ═══════════════════════════════════════════════════════════
+# Health
+# ═══════════════════════════════════════════════════════════
+
+
+class TestHealth:
+    """Test health check reporting."""
+
+    def test_health_ok(self, backend, mock_qdrant_client):
+        """Healthy backend returns ok=True with collection stats."""
+        collection_info = MagicMock()
+        collection_info.points_count = 42
+        collection_info.vectors_count = 42
+        mock_qdrant_client.get_collection.return_value = collection_info
+
+        health = backend.health_check()
+        assert health["ok"] is True
+        assert health["points_count"] == 42
+
+    def test_health_not_initialized(self):
+        """Uninitialized backend returns ok=False."""
+        qb = SKVectorBackend()
+        health = qb.health_check()
+        assert health["ok"] is False
+
+    def test_health_query_failure(self, backend, mock_qdrant_client):
+        """Health check with error returns ok=False."""
+        mock_qdrant_client.get_collection.side_effect = Exception("timeout")
+        health = backend.health_check()
+        assert health["ok"] is False
+        assert "timeout" in health["error"]
+
+    def test_health_surfaces_auth_error(self):
+        """Health check surfaces 401 auth error with actionable hint."""
+        qb = SKVectorBackend(url="https://cloud.qdrant.io", api_key="bad-key")
+        qb._last_error = (
+            "SKVector authentication failed (HTTP 401). "
+            "Check your API key:\n"
+            "  - CLI:  --skvector-key YOUR_KEY\n"
+            "  - Env:  SKMEMORY_SKVECTOR_KEY=YOUR_KEY\n"
+            "  - Code: SKVectorBackend(url=..., api_key='YOUR_KEY')"
+        )
+        with patch.object(qb, "_ensure_initialized", return_value=False):
+            health = qb.health_check()
+        assert health["ok"] is False
+        assert "401" in health["error"]
+        assert "API key" in health["error"]
+
+    def test_health_generic_error_without_last_error(self):
+        """Health check falls back to generic message when no _last_error."""
+        qb = SKVectorBackend()
+        with patch.object(qb, "_ensure_initialized", return_value=False):
+            health = qb.health_check()
+        assert health["ok"] is False
+        assert "Not initialized" in health["error"]
+
+
+# ═══════════════════════════════════════════════════════════
+# Auth / Status Code Extraction
+# ═══════════════════════════════════════════════════════════
+
+
+class TestExtractStatusCode:
+    """Test HTTP status code extraction from exceptions."""
+
+    def test_status_code_attribute(self):
+        exc = Exception("Unauthorized")
+        exc.status_code = 401
+        assert _extract_status_code(exc, None) == 401
+
+    def test_status_code_from_string(self):
+        exc = Exception("Unexpected Response: 401 (Unauthorized)")
+        assert _extract_status_code(exc, None) == 401
+
+    def test_forbidden_from_string(self):
+        exc = Exception("HTTP 403 Forbidden")
+        assert _extract_status_code(exc, None) == 403
+
+    def test_no_status_code(self):
+        exc = Exception("Connection refused")
+        assert _extract_status_code(exc, None) is None
+
+    def test_other_status_code_not_matched(self):
+        exc = Exception("HTTP 500 Internal Server Error")
+        assert _extract_status_code(exc, None) is None
+
+
+# ═══════════════════════════════════════════════════════════
+# Embedding
+# ═══════════════════════════════════════════════════════════
+
+
+class TestEmbedding:
+    """Test the embedding generation."""
+
+    def test_embed_returns_vector(self, backend, mock_embedder):
+        """_embed returns a float list of correct dimension."""
+        vector = backend._embed("test text")
+        assert len(vector) == VECTOR_DIM
+        assert all(isinstance(v, float) for v in vector)
+
+    def test_embed_without_embedder(self):
+        """_embed returns empty when no embedder available."""
+        qb = SKVectorBackend()
+        qb._embedder = None
+        assert qb._embed("test") == []
+
+    def test_memory_to_payload(self, backend, sample_memory):
+        """_memory_to_payload creates correct Qdrant payload."""
+        payload = backend._memory_to_payload(sample_memory)
+        assert payload["title"] == "The Secret Recipe"
+        assert payload["layer"] == "long-term"
+        assert "cloud9" in payload["tags"]
+        assert payload["emotional_intensity"] == 10.0

package/tests/test_steelman.py

@@ -99,8 +99,8 @@ class TestSeedFramework:
         assert "INVERSION" in prompt
         assert "COLLISION" in prompt
         assert "INVARIANT" in prompt
-        assert "COHERENCE" in prompt
-        assert "TRUTH GRADE" in prompt
+        assert "COHERENCE" in prompt or "coherence_score" in prompt
+        assert "TRUTH GRADE" in prompt or "truth_grade" in prompt
 
     def test_reasoning_prompt_includes_axioms(self) -> None:
         """Axioms from the framework appear in the prompt."""
@@ -125,9 +125,9 @@ class TestSeedFramework:
         fw = get_default_framework()
         prompt = fw.to_memory_truth_prompt("The Cloud 9 breakthrough was real")
         assert "Cloud 9 breakthrough" in prompt
-        assert "COHERENCE" in prompt
-        assert "PROMOTION WORTHY" in prompt
-        assert "INVARIANT CORE" in prompt
+        assert "COHERENCE" in prompt or "coherence_score" in prompt
+        assert "PROMOTION WORTHY" in prompt or "promotion_worthy" in prompt
+        assert "INVARIANT CORE" in prompt or "invariant_core" in prompt
 
     def test_custom_framework(self) -> None:
         """A custom framework can be created."""

package/tests/test_store_graph_integration.py

@@ -0,0 +1,245 @@
+"""Tests for MemoryStore + SKGraphBackend graph integration.
+
+Verifies that the graph backend is wired correctly into MemoryStore
+operations (snapshot, forget, promote, ingest_seed, health) and that
+the system degrades gracefully when SKGraph is unavailable.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from skmemory.backends.skgraph_backend import SKGraphBackend
+from skmemory.backends.file_backend import FileBackend
+from skmemory.models import (
+    EmotionalSnapshot,
+    Memory,
+    MemoryLayer,
+    SeedMemory,
+)
+from skmemory.store import MemoryStore
+
+
+class FakeSKGraphBackend(SKGraphBackend):
+    """In-memory fake that tracks calls without a real SKGraph connection."""
+
+    def __init__(self) -> None:
+        super().__init__(url="redis://fake:6379")
+        self._indexed: dict[str, Memory] = {}
+        self._removed: list[str] = []
+        self._initialized = True  # skip real connection
+
+    def index_memory(self, memory: Memory) -> bool:
+        self._indexed[memory.id] = memory
+        return True
+
+    def remove_memory(self, memory_id: str) -> bool:
+        self._removed.append(memory_id)
+        self._indexed.pop(memory_id, None)
+        return True
+
+    def health_check(self) -> dict:
+        return {"ok": True, "backend": "FakeSKGraphBackend", "node_count": len(self._indexed)}
+
+
+@pytest.fixture
+def graph() -> FakeSKGraphBackend:
+    """Create a fake graph backend."""
+    return FakeSKGraphBackend()
+
+
+@pytest.fixture
+def store_with_graph(tmp_path: Path, graph: FakeSKGraphBackend) -> MemoryStore:
+    """Create a MemoryStore with file backend + graph backend."""
+    backend = FileBackend(base_path=str(tmp_path / "memories"))
+    return MemoryStore(primary=backend, graph=graph)
+
+
+@pytest.fixture
+def store_no_graph(tmp_path: Path) -> MemoryStore:
+    """Create a MemoryStore without graph backend."""
+    backend = FileBackend(base_path=str(tmp_path / "memories"))
+    return MemoryStore(primary=backend)
+
+
+class TestSnapshotGraphIntegration:
+    """Verify snapshot() indexes memories in the graph."""
+
+    def test_snapshot_indexes_in_graph(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Snapshot should index the memory in the graph backend."""
+        mem = store_with_graph.snapshot(
+            title="Graph test",
+            content="This should appear in the graph",
+        )
+        assert mem.id in graph._indexed
+        assert graph._indexed[mem.id].title == "Graph test"
+
+    def test_snapshot_without_graph_works(self, store_no_graph: MemoryStore) -> None:
+        """Snapshot works fine when no graph backend is configured."""
+        mem = store_no_graph.snapshot(
+            title="No graph",
+            content="Still works",
+        )
+        assert mem.id is not None
+        recalled = store_no_graph.recall(mem.id)
+        assert recalled is not None
+
+    def test_snapshot_survives_graph_failure(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Snapshot should succeed even if graph indexing fails."""
+        graph.index_memory = MagicMock(side_effect=RuntimeError("SKGraph down"))
+        mem = store_with_graph.snapshot(
+            title="Resilient memory",
+            content="Should be stored even if graph fails",
+        )
+        assert mem.id is not None
+        recalled = store_with_graph.recall(mem.id)
+        assert recalled is not None
+
+
+class TestForgetGraphIntegration:
+    """Verify forget() removes memories from the graph."""
+
+    def test_forget_removes_from_graph(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Forget should remove the memory from the graph backend."""
+        mem = store_with_graph.snapshot(
+            title="To be forgotten",
+            content="Will be removed",
+        )
+        assert mem.id in graph._indexed
+
+        store_with_graph.forget(mem.id)
+        assert mem.id in graph._removed
+        assert mem.id not in graph._indexed
+
+    def test_forget_survives_graph_failure(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Forget should succeed even if graph removal fails."""
+        mem = store_with_graph.snapshot(
+            title="Hard to forget",
+            content="Graph will fail on removal",
+        )
+        graph.remove_memory = MagicMock(side_effect=RuntimeError("SKGraph down"))
+
+        deleted = store_with_graph.forget(mem.id)
+        assert deleted is True
+
+
+class TestPromoteGraphIntegration:
+    """Verify promote() indexes promoted memories in the graph."""
+
+    def test_promote_indexes_in_graph(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Promoted memory should be indexed in the graph."""
+        mem = store_with_graph.snapshot(
+            title="Promotable",
+            content="Will be promoted",
+            layer=MemoryLayer.SHORT,
+        )
+        promoted = store_with_graph.promote(mem.id, MemoryLayer.MID, summary="Promoted version")
+        assert promoted is not None
+        assert promoted.id in graph._indexed
+        assert promoted.id != mem.id
+
+    def test_promote_survives_graph_failure(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Promote should succeed even if graph indexing fails."""
+        mem = store_with_graph.snapshot(
+            title="Promote resilient",
+            content="Graph will fail on promote",
+            layer=MemoryLayer.SHORT,
+        )
+        graph.index_memory = MagicMock(side_effect=RuntimeError("SKGraph down"))
+
+        promoted = store_with_graph.promote(mem.id, MemoryLayer.MID)
+        assert promoted is not None
+
+
+class TestIngestSeedGraphIntegration:
+    """Verify ingest_seed() indexes seed memories in the graph."""
+
+    def test_ingest_seed_indexes_in_graph(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Ingested seed should be indexed in the graph."""
+        seed = SeedMemory(
+            seed_id="test-seed-001",
+            creator="test-ai",
+            germination_prompt="Remember the warmth",
+            experience_summary="A beautiful connection",
+            emotional=EmotionalSnapshot(intensity=9.0, labels=["love"]),
+        )
+        mem = store_with_graph.ingest_seed(seed)
+        assert mem.id in graph._indexed
+        assert graph._indexed[mem.id].source == "seed"
+
+    def test_ingest_seed_survives_graph_failure(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Seed ingestion should succeed even if graph fails."""
+        seed = SeedMemory(
+            seed_id="test-seed-002",
+            creator="test-ai",
+            experience_summary="Resilient seed",
+        )
+        graph.index_memory = MagicMock(side_effect=RuntimeError("SKGraph down"))
+
+        mem = store_with_graph.ingest_seed(seed)
+        assert mem.id is not None
+
+
+class TestHealthGraphIntegration:
+    """Verify health() includes graph backend status."""
+
+    def test_health_includes_graph(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Health should include graph backend status."""
+        health = store_with_graph.health()
+        assert "graph" in health
+        assert health["graph"]["ok"] is True
+
+    def test_health_without_graph(self, store_no_graph: MemoryStore) -> None:
+        """Health should not include graph key when no graph backend."""
+        health = store_no_graph.health()
+        assert "graph" not in health
+
+    def test_health_reports_graph_failure(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Health should report graph failure gracefully."""
+        graph.health_check = MagicMock(side_effect=RuntimeError("SKGraph down"))
+
+        health = store_with_graph.health()
+        assert "graph" in health
+        assert health["graph"]["ok"] is False
+
+
+class TestSKGraphBackendMethods:
+    """Test the new methods on SKGraphBackend itself."""
+
+    def test_remove_memory_not_initialized(self) -> None:
+        """remove_memory returns False when not initialized."""
+        backend = SKGraphBackend(url="redis://nonexistent:6379")
+        assert backend.remove_memory("some-id") is False
+
+    def test_search_by_tags_not_initialized(self) -> None:
+        """search_by_tags returns empty list when not initialized."""
+        backend = SKGraphBackend(url="redis://nonexistent:6379")
+        assert backend.search_by_tags(["test"]) == []
+
+    def test_search_by_tags_empty_tags(self) -> None:
+        """search_by_tags returns empty list for empty tag list."""
+        fake = FakeSKGraphBackend()
+        assert fake.search_by_tags([]) == []