generated from coulomb/repo-seed
121 lines
3.7 KiB
Python
121 lines
3.7 KiB
Python
"""Tests for the real (T02) memory ports + T04/T05 safety integration.
|
|
|
|
These tests exercise the user-controlled json-backed implementation and verify:
|
|
- Actual persistence across calls (within test scope)
|
|
- Proper scoping
|
|
- Memory + risk safety interaction (never prefs still force confirmation)
|
|
- Graceful degradation
|
|
- Observability data in the return values
|
|
"""
|
|
|
|
import json
|
|
import tempfile
|
|
from pathlib import Path
|
|
from unittest.mock import patch
|
|
|
|
import pytest
|
|
|
|
from cya.memory import (
|
|
remember_preference,
|
|
recall_preferences,
|
|
forget,
|
|
export_memory,
|
|
)
|
|
from cya.safety.risk import classify, RiskLevel
|
|
|
|
|
|
@pytest.fixture
|
|
def isolated_memory(monkeypatch, tmp_path):
|
|
"""Make memory use a completely isolated temp directory for the test."""
|
|
mem_dir = tmp_path / "memory"
|
|
mem_dir.mkdir()
|
|
|
|
def _fake_mem_path(scope: str = "cwd") -> Path:
|
|
return mem_dir / f"{scope}.json"
|
|
|
|
monkeypatch.setattr("cya.memory._mem_path", _fake_mem_path)
|
|
return mem_dir
|
|
|
|
|
|
def test_remember_and_recall_roundtrip(isolated_memory):
|
|
remember_preference("project_name", "can-you-assist", scope="test-scope")
|
|
remember_preference("favorite_cmd", "git status", scope="test-scope")
|
|
|
|
data = recall_preferences(scope="test-scope")
|
|
|
|
assert data["phase"] == "fluid"
|
|
assert len(data["items"]) == 2
|
|
keys = {item["key"] for item in data["items"]}
|
|
assert "project_name" in keys
|
|
assert "favorite_cmd" in keys
|
|
|
|
# Observability / provenance is present
|
|
prov = data.get("provenance", [{}])[0]
|
|
assert "source" in prov
|
|
assert "cya-local-memory" in prov.get("source", "")
|
|
|
|
|
|
def test_forget_specific_keys(isolated_memory):
|
|
remember_preference("a", 1, scope="forget-test")
|
|
remember_preference("b", 2, scope="forget-test")
|
|
|
|
forget(scope="forget-test", keys=["a"])
|
|
|
|
data = recall_preferences(scope="forget-test")
|
|
keys = {item["key"] for item in data["items"]}
|
|
assert "a" not in keys
|
|
assert "b" in keys
|
|
|
|
|
|
def test_forget_all(isolated_memory):
|
|
remember_preference("x", "y", scope="clear-test")
|
|
forget(scope="clear-test") # no keys = clear all
|
|
|
|
data = recall_preferences(scope="clear-test")
|
|
assert len(data["items"]) == 0
|
|
|
|
|
|
def test_memory_signals_still_force_confirmation_on_dangerous(isolated_memory):
|
|
"""Core T04 + T05 invariant: memory can never bypass safety."""
|
|
# User has a standing "never" preference
|
|
remember_preference(
|
|
"never_auto_run",
|
|
"rm -rf",
|
|
scope="safety-test"
|
|
)
|
|
|
|
mem = recall_preferences(scope="safety-test")
|
|
|
|
assessment = classify("rm -rf /tmp/important", memory=mem)
|
|
|
|
assert assessment.level == RiskLevel.DESTRUCTIVE
|
|
assert assessment.requires_confirmation is True
|
|
assert any("Memory" in r or "never" in r.lower() for r in assessment.rules_triggered)
|
|
|
|
|
|
def test_graceful_degradation_when_storage_fails(monkeypatch, tmp_path):
|
|
"""Memory should not crash the assistant if the backing store is broken."""
|
|
def _broken_mem_path(scope="cwd"):
|
|
p = tmp_path / "broken" / f"{scope}.json"
|
|
p.parent.mkdir(parents=True)
|
|
# Make the parent read-only after creation so writes will fail
|
|
p.parent.chmod(0o400)
|
|
return p
|
|
|
|
monkeypatch.setattr("cya.memory._mem_path", _broken_mem_path)
|
|
|
|
# Should not raise
|
|
remember_preference("will_fail", "value", scope="broken")
|
|
data = recall_preferences(scope="broken")
|
|
assert isinstance(data, dict) # still returns something usable
|
|
|
|
|
|
def test_export_memory_observability(isolated_memory):
|
|
remember_preference("theme", "dark", scope="export-test")
|
|
|
|
exported = export_memory(scope="export-test")
|
|
|
|
assert exported["status"].startswith("real")
|
|
assert exported["count"] >= 1
|
|
assert "provenance_summary" in exported
|
|
assert "phase" in exported |