forked from Rockachopa/Timmy-time-dashboard
501 lines
18 KiB
Python
501 lines
18 KiB
Python
"""Tests for the Spark Intelligence integration.
|
|
|
|
Covers:
|
|
- spark.memory: event capture, memory consolidation, importance scoring
|
|
- spark.eidos: predictions, evaluations, accuracy stats
|
|
- spark.advisor: advisory generation from patterns
|
|
- spark.engine: top-level engine wiring all subsystems
|
|
- dashboard.routes.spark: HTTP endpoints
|
|
"""
|
|
|
|
import pytest
|
|
|
|
# ── Fixtures ────────────────────────────────────────────────────────────────
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def tmp_spark_db(tmp_path, monkeypatch):
|
|
"""Redirect all Spark SQLite writes to a temp directory."""
|
|
db_path = tmp_path / "spark.db"
|
|
monkeypatch.setattr("spark.memory.DB_PATH", db_path)
|
|
monkeypatch.setattr("spark.eidos.DB_PATH", db_path)
|
|
yield db_path
|
|
|
|
|
|
# ── spark.memory ────────────────────────────────────────────────────────────
|
|
|
|
|
|
class TestImportanceScoring:
|
|
def test_failure_scores_high(self):
|
|
from spark.memory import score_importance
|
|
|
|
score = score_importance("task_failed", {})
|
|
assert score >= 0.9
|
|
|
|
def test_bid_scores_low(self):
|
|
from spark.memory import score_importance
|
|
|
|
score = score_importance("bid_submitted", {})
|
|
assert score <= 0.3
|
|
|
|
def test_high_bid_boosts_score(self):
|
|
from spark.memory import score_importance
|
|
|
|
low = score_importance("bid_submitted", {"bid_sats": 10})
|
|
high = score_importance("bid_submitted", {"bid_sats": 100})
|
|
assert high > low
|
|
|
|
def test_unknown_event_default(self):
|
|
from spark.memory import score_importance
|
|
|
|
score = score_importance("unknown_type", {})
|
|
assert score == 0.5
|
|
|
|
|
|
class TestEventRecording:
|
|
def test_record_and_query(self):
|
|
from spark.memory import get_events, record_event
|
|
|
|
eid = record_event("task_posted", "Test task", task_id="t1")
|
|
assert eid
|
|
events = get_events(task_id="t1")
|
|
assert len(events) == 1
|
|
assert events[0].event_type == "task_posted"
|
|
assert events[0].description == "Test task"
|
|
|
|
def test_record_with_agent(self):
|
|
from spark.memory import get_events, record_event
|
|
|
|
record_event(
|
|
"bid_submitted", "Agent bid", agent_id="a1", task_id="t2", data='{"bid_sats": 50}'
|
|
)
|
|
events = get_events(agent_id="a1")
|
|
assert len(events) == 1
|
|
assert events[0].agent_id == "a1"
|
|
|
|
def test_filter_by_event_type(self):
|
|
from spark.memory import get_events, record_event
|
|
|
|
record_event("task_posted", "posted", task_id="t3")
|
|
record_event("task_completed", "completed", task_id="t3")
|
|
posted = get_events(event_type="task_posted")
|
|
assert len(posted) == 1
|
|
|
|
def test_filter_by_min_importance(self):
|
|
from spark.memory import get_events, record_event
|
|
|
|
record_event("bid_submitted", "low", importance=0.1)
|
|
record_event("task_failed", "high", importance=0.9)
|
|
high_events = get_events(min_importance=0.5)
|
|
assert len(high_events) == 1
|
|
assert high_events[0].event_type == "task_failed"
|
|
|
|
def test_count_events(self):
|
|
from spark.memory import count_events, record_event
|
|
|
|
record_event("task_posted", "a")
|
|
record_event("task_posted", "b")
|
|
record_event("task_completed", "c")
|
|
assert count_events() == 3
|
|
assert count_events("task_posted") == 2
|
|
|
|
def test_limit_results(self):
|
|
from spark.memory import get_events, record_event
|
|
|
|
for i in range(10):
|
|
record_event("bid_submitted", f"bid {i}")
|
|
events = get_events(limit=3)
|
|
assert len(events) == 3
|
|
|
|
|
|
class TestMemoryConsolidation:
|
|
def test_store_and_query_memory(self):
|
|
from spark.memory import get_memories, store_memory
|
|
|
|
mid = store_memory("pattern", "agent-x", "Strong performer", confidence=0.8)
|
|
assert mid
|
|
memories = get_memories(subject="agent-x")
|
|
assert len(memories) == 1
|
|
assert memories[0].content == "Strong performer"
|
|
|
|
def test_filter_by_type(self):
|
|
from spark.memory import get_memories, store_memory
|
|
|
|
store_memory("pattern", "system", "Good pattern")
|
|
store_memory("anomaly", "system", "Bad anomaly")
|
|
patterns = get_memories(memory_type="pattern")
|
|
assert len(patterns) == 1
|
|
assert patterns[0].memory_type == "pattern"
|
|
|
|
def test_filter_by_confidence(self):
|
|
from spark.memory import get_memories, store_memory
|
|
|
|
store_memory("pattern", "a", "Low conf", confidence=0.2)
|
|
store_memory("pattern", "b", "High conf", confidence=0.9)
|
|
high = get_memories(min_confidence=0.5)
|
|
assert len(high) == 1
|
|
assert high[0].content == "High conf"
|
|
|
|
def test_count_memories(self):
|
|
from spark.memory import count_memories, store_memory
|
|
|
|
store_memory("pattern", "a", "X")
|
|
store_memory("anomaly", "b", "Y")
|
|
assert count_memories() == 2
|
|
assert count_memories("pattern") == 1
|
|
|
|
|
|
# ── spark.eidos ─────────────────────────────────────────────────────────────
|
|
|
|
|
|
class TestPredictions:
|
|
def test_predict_stores_prediction(self):
|
|
from spark.eidos import get_predictions, predict_task_outcome
|
|
|
|
result = predict_task_outcome("t1", "Fix the bug", ["agent-a", "agent-b"])
|
|
assert "prediction_id" in result
|
|
assert result["likely_winner"] == "agent-a"
|
|
preds = get_predictions(task_id="t1")
|
|
assert len(preds) == 1
|
|
|
|
def test_predict_with_history(self):
|
|
from spark.eidos import predict_task_outcome
|
|
|
|
history = {
|
|
"agent-a": {"success_rate": 0.3, "avg_winning_bid": 40},
|
|
"agent-b": {"success_rate": 0.9, "avg_winning_bid": 30},
|
|
}
|
|
result = predict_task_outcome(
|
|
"t2",
|
|
"Research topic",
|
|
["agent-a", "agent-b"],
|
|
agent_history=history,
|
|
)
|
|
assert result["likely_winner"] == "agent-b"
|
|
assert result["success_probability"] > 0.5
|
|
|
|
def test_predict_empty_candidates(self):
|
|
from spark.eidos import predict_task_outcome
|
|
|
|
result = predict_task_outcome("t3", "No agents", [])
|
|
assert result["likely_winner"] is None
|
|
|
|
|
|
class TestEvaluation:
|
|
def test_evaluate_correct_prediction(self):
|
|
from spark.eidos import evaluate_prediction, predict_task_outcome
|
|
|
|
predict_task_outcome("t4", "Task", ["agent-a"])
|
|
result = evaluate_prediction("t4", "agent-a", task_succeeded=True, winning_bid=30)
|
|
assert result is not None
|
|
assert result["accuracy"] > 0.0
|
|
|
|
def test_evaluate_wrong_prediction(self):
|
|
from spark.eidos import evaluate_prediction, predict_task_outcome
|
|
|
|
predict_task_outcome("t5", "Task", ["agent-a"])
|
|
result = evaluate_prediction("t5", "agent-b", task_succeeded=False)
|
|
assert result is not None
|
|
# Wrong winner + failed = lower accuracy
|
|
assert result["accuracy"] < 1.0
|
|
|
|
def test_evaluate_no_prediction_returns_none(self):
|
|
from spark.eidos import evaluate_prediction
|
|
|
|
result = evaluate_prediction("no-task", "agent-a", task_succeeded=True)
|
|
assert result is None
|
|
|
|
def test_double_evaluation_returns_none(self):
|
|
from spark.eidos import evaluate_prediction, predict_task_outcome
|
|
|
|
predict_task_outcome("t6", "Task", ["agent-a"])
|
|
evaluate_prediction("t6", "agent-a", task_succeeded=True)
|
|
# Second evaluation should return None (already evaluated)
|
|
result = evaluate_prediction("t6", "agent-a", task_succeeded=True)
|
|
assert result is None
|
|
|
|
|
|
class TestAccuracyStats:
|
|
def test_empty_stats(self):
|
|
from spark.eidos import get_accuracy_stats
|
|
|
|
stats = get_accuracy_stats()
|
|
assert stats["total_predictions"] == 0
|
|
assert stats["evaluated"] == 0
|
|
assert stats["avg_accuracy"] == 0.0
|
|
|
|
def test_stats_after_evaluations(self):
|
|
from spark.eidos import evaluate_prediction, get_accuracy_stats, predict_task_outcome
|
|
|
|
for i in range(3):
|
|
predict_task_outcome(f"task-{i}", "Description", ["agent-a"])
|
|
evaluate_prediction(f"task-{i}", "agent-a", task_succeeded=True, winning_bid=30)
|
|
stats = get_accuracy_stats()
|
|
assert stats["total_predictions"] == 3
|
|
assert stats["evaluated"] == 3
|
|
assert stats["pending"] == 0
|
|
assert stats["avg_accuracy"] > 0.0
|
|
|
|
|
|
class TestComputeAccuracy:
|
|
def test_perfect_prediction(self):
|
|
from spark.eidos import _compute_accuracy
|
|
|
|
predicted = {
|
|
"likely_winner": "agent-a",
|
|
"success_probability": 1.0,
|
|
"estimated_bid_range": [20, 40],
|
|
}
|
|
actual = {"winner": "agent-a", "succeeded": True, "winning_bid": 30}
|
|
acc = _compute_accuracy(predicted, actual)
|
|
assert acc == pytest.approx(1.0, abs=0.01)
|
|
|
|
def test_all_wrong(self):
|
|
from spark.eidos import _compute_accuracy
|
|
|
|
predicted = {
|
|
"likely_winner": "agent-a",
|
|
"success_probability": 1.0,
|
|
"estimated_bid_range": [10, 20],
|
|
}
|
|
actual = {"winner": "agent-b", "succeeded": False, "winning_bid": 100}
|
|
acc = _compute_accuracy(predicted, actual)
|
|
assert acc < 0.5
|
|
|
|
def test_partial_credit(self):
|
|
from spark.eidos import _compute_accuracy
|
|
|
|
predicted = {
|
|
"likely_winner": "agent-a",
|
|
"success_probability": 0.5,
|
|
"estimated_bid_range": [20, 40],
|
|
}
|
|
actual = {"winner": "agent-b", "succeeded": True, "winning_bid": 30}
|
|
acc = _compute_accuracy(predicted, actual)
|
|
# Wrong winner but right success and in bid range → partial
|
|
assert 0.2 < acc < 0.8
|
|
|
|
|
|
# ── spark.advisor ───────────────────────────────────────────────────────────
|
|
|
|
|
|
class TestAdvisor:
|
|
def test_insufficient_data(self):
|
|
from spark.advisor import generate_advisories
|
|
|
|
advisories = generate_advisories()
|
|
assert len(advisories) >= 1
|
|
assert advisories[0].category == "system_health"
|
|
assert "Insufficient" in advisories[0].title
|
|
|
|
def test_failure_detection(self):
|
|
from spark.advisor import generate_advisories
|
|
from spark.memory import record_event
|
|
|
|
# Record enough events to pass the minimum threshold
|
|
for i in range(5):
|
|
record_event("task_failed", f"Failed task {i}", agent_id="agent-bad", task_id=f"t-{i}")
|
|
advisories = generate_advisories()
|
|
failure_advisories = [a for a in advisories if a.category == "failure_prevention"]
|
|
assert len(failure_advisories) >= 1
|
|
assert "agent-ba" in failure_advisories[0].title
|
|
|
|
def test_advisories_sorted_by_priority(self):
|
|
from spark.advisor import generate_advisories
|
|
from spark.memory import record_event
|
|
|
|
for i in range(4):
|
|
record_event("task_posted", f"posted {i}", task_id=f"p-{i}")
|
|
record_event("task_completed", f"done {i}", agent_id="agent-good", task_id=f"p-{i}")
|
|
advisories = generate_advisories()
|
|
if len(advisories) >= 2:
|
|
assert advisories[0].priority >= advisories[-1].priority
|
|
|
|
def test_no_activity_advisory(self):
|
|
from spark.advisor import _check_system_activity
|
|
|
|
advisories = _check_system_activity()
|
|
assert len(advisories) >= 1
|
|
assert "No swarm activity" in advisories[0].title
|
|
|
|
|
|
# ── spark.engine ────────────────────────────────────────────────────────────
|
|
|
|
|
|
class TestSparkEngine:
|
|
def test_engine_enabled(self):
|
|
from spark.engine import SparkEngine
|
|
|
|
engine = SparkEngine(enabled=True)
|
|
assert engine.enabled
|
|
|
|
def test_engine_disabled(self):
|
|
from spark.engine import SparkEngine
|
|
|
|
engine = SparkEngine(enabled=False)
|
|
result = engine.on_task_posted("t1", "Ignored task")
|
|
assert result is None
|
|
|
|
def test_on_task_posted(self):
|
|
from spark.engine import SparkEngine
|
|
from spark.memory import get_events
|
|
|
|
engine = SparkEngine(enabled=True)
|
|
eid = engine.on_task_posted("t1", "Test task", ["agent-a"])
|
|
assert eid is not None
|
|
events = get_events(task_id="t1")
|
|
assert len(events) == 1
|
|
|
|
def test_on_bid_submitted(self):
|
|
from spark.engine import SparkEngine
|
|
from spark.memory import get_events
|
|
|
|
engine = SparkEngine(enabled=True)
|
|
eid = engine.on_bid_submitted("t1", "agent-a", 50)
|
|
assert eid is not None
|
|
events = get_events(event_type="bid_submitted")
|
|
assert len(events) == 1
|
|
|
|
def test_on_task_assigned(self):
|
|
from spark.engine import SparkEngine
|
|
from spark.memory import get_events
|
|
|
|
engine = SparkEngine(enabled=True)
|
|
eid = engine.on_task_assigned("t1", "agent-a")
|
|
assert eid is not None
|
|
events = get_events(event_type="task_assigned")
|
|
assert len(events) == 1
|
|
|
|
def test_on_task_completed_evaluates_prediction(self):
|
|
from spark.eidos import get_predictions
|
|
from spark.engine import SparkEngine
|
|
|
|
engine = SparkEngine(enabled=True)
|
|
engine.on_task_posted("t1", "Fix bug", ["agent-a"])
|
|
eid = engine.on_task_completed("t1", "agent-a", "Fixed it")
|
|
assert eid is not None
|
|
preds = get_predictions(task_id="t1")
|
|
# Should have prediction(s) evaluated
|
|
assert len(preds) >= 1
|
|
|
|
def test_on_task_failed(self):
|
|
from spark.engine import SparkEngine
|
|
from spark.memory import get_events
|
|
|
|
engine = SparkEngine(enabled=True)
|
|
engine.on_task_posted("t1", "Deploy server", ["agent-a"])
|
|
eid = engine.on_task_failed("t1", "agent-a", "Connection timeout")
|
|
assert eid is not None
|
|
events = get_events(event_type="task_failed")
|
|
assert len(events) == 1
|
|
|
|
def test_on_agent_joined(self):
|
|
from spark.engine import SparkEngine
|
|
from spark.memory import get_events
|
|
|
|
engine = SparkEngine(enabled=True)
|
|
eid = engine.on_agent_joined("agent-a", "Echo")
|
|
assert eid is not None
|
|
events = get_events(event_type="agent_joined")
|
|
assert len(events) == 1
|
|
|
|
def test_status(self):
|
|
from spark.engine import SparkEngine
|
|
|
|
engine = SparkEngine(enabled=True)
|
|
engine.on_task_posted("t1", "Test", ["agent-a"])
|
|
engine.on_bid_submitted("t1", "agent-a", 30)
|
|
status = engine.status()
|
|
assert status["enabled"] is True
|
|
assert status["events_captured"] >= 2
|
|
assert "predictions" in status
|
|
assert "event_types" in status
|
|
|
|
def test_get_advisories(self):
|
|
from spark.engine import SparkEngine
|
|
|
|
engine = SparkEngine(enabled=True)
|
|
advisories = engine.get_advisories()
|
|
assert isinstance(advisories, list)
|
|
|
|
def test_get_advisories_disabled(self):
|
|
from spark.engine import SparkEngine
|
|
|
|
engine = SparkEngine(enabled=False)
|
|
advisories = engine.get_advisories()
|
|
assert advisories == []
|
|
|
|
def test_get_timeline(self):
|
|
from spark.engine import SparkEngine
|
|
|
|
engine = SparkEngine(enabled=True)
|
|
engine.on_task_posted("t1", "Task 1")
|
|
engine.on_task_posted("t2", "Task 2")
|
|
timeline = engine.get_timeline(limit=10)
|
|
assert len(timeline) == 2
|
|
|
|
def test_memory_consolidation(self):
|
|
from spark.engine import SparkEngine
|
|
from spark.memory import get_memories
|
|
|
|
engine = SparkEngine(enabled=True)
|
|
# Generate enough completions to trigger consolidation (>=5 events, >=3 outcomes)
|
|
for i in range(6):
|
|
engine.on_task_completed(f"t-{i}", "agent-star", f"Result {i}")
|
|
memories = get_memories(subject="agent-star")
|
|
# Should have at least one consolidated memory about strong performance
|
|
assert len(memories) >= 1
|
|
|
|
|
|
# ── Dashboard routes ────────────────────────────────────────────────────────
|
|
|
|
|
|
class TestSparkRoutes:
|
|
def test_spark_json(self, client):
|
|
resp = client.get("/spark")
|
|
assert resp.status_code == 200
|
|
data = resp.json()
|
|
assert "status" in data
|
|
assert "advisories" in data
|
|
|
|
def test_spark_ui(self, client):
|
|
resp = client.get("/spark/ui")
|
|
assert resp.status_code == 200
|
|
assert "SPARK INTELLIGENCE" in resp.text
|
|
|
|
def test_spark_timeline(self, client):
|
|
resp = client.get("/spark/timeline")
|
|
assert resp.status_code == 200
|
|
|
|
def test_spark_insights(self, client):
|
|
resp = client.get("/spark/insights")
|
|
assert resp.status_code == 200
|
|
|
|
|
|
# ── WAL Mode ──────────────────────────────────────────────────────────────
|
|
|
|
|
|
class TestWALMode:
|
|
"""Verify SQLite WAL mode is enabled for all Spark databases."""
|
|
|
|
def test_spark_memory_uses_wal(self):
|
|
from spark.memory import _get_conn
|
|
|
|
with _get_conn() as conn:
|
|
mode = conn.execute("PRAGMA journal_mode").fetchone()[0]
|
|
assert mode == "wal", f"Expected WAL mode, got {mode}"
|
|
|
|
def test_spark_eidos_uses_wal(self):
|
|
from spark.eidos import _get_conn
|
|
|
|
with _get_conn() as conn:
|
|
mode = conn.execute("PRAGMA journal_mode").fetchone()[0]
|
|
assert mode == "wal", f"Expected WAL mode, got {mode}"
|
|
|
|
def test_spark_memory_busy_timeout(self):
|
|
from spark.memory import _get_conn
|
|
|
|
with _get_conn() as conn:
|
|
timeout = conn.execute("PRAGMA busy_timeout").fetchone()[0]
|
|
assert timeout == 5000
|