Episodic Memory Testing

Episodic Memory Testing Patterns

Specialized testing patterns for the episodic memory system.

Episode Lifecycle Testing

Complete Flow

#[tokio::test]
async fn test_complete_episode_lifecycle() {
    let memory = setup_memory().await;

    // 1. Start episode
    let id = memory.start_episode("Test task", ctx, TaskType::CodeGen).await;
    assert!(!id.is_empty());

    // 2. Log steps
    memory.log_execution_step(id.clone(), step1).await;
    memory.log_execution_step(id.clone(), step2).await;

    // 3. Complete episode
    memory.complete_episode(id.clone(), TaskOutcome::Success, None).await?;

    // 4. Verify
    let episode = memory.get_episode(&id).await?;
    assert_eq!(episode.outcome, TaskOutcome::Success);
    assert_eq!(episode.steps.len(), 2);
}

ID Uniqueness

#[tokio::test]
async fn test_episode_ids_unique() {
    let ids: HashSet<String> = (0..100)
        .map(|i| memory.start_episode(format!("Task {}", i), ctx, type_).await)
        .collect();
    assert_eq!(ids.len(), 100);
}

Pattern Extraction Testing

#[tokio::test]
async fn test_pattern_extraction() {
    let patterns = memory.extract_patterns(episode_id).await?;
    assert!(!patterns.is_empty());
    for pattern in &patterns {
        assert!(!pattern.name.is_empty());
        assert!(pattern.frequency > 0.0);
    }
}

Reward Scoring Testing

#[tokio::test]
async fn test_reward_score_bounds() {
    let perfect = calculate_reward_score(1.0, 1.0);
    assert!(perfect >= 0.9);

    let zero_efficiency = calculate_reward_score(0.0, 1.0);
    assert!(zero_efficiency < perfect);
}

Memory Retrieval Testing

#[tokio::test]
async fn test_retrieval_by_context() {
    let rust_memories = memory.retrieve_context("rust", Some(10)).await?;
    assert!(rust_memories.len() >= 1);
    assert!(rust_memories.iter().all(|m| m.context.language == "rust"));
}

Best Practices

• Use setup functions for memory initialization
• Clean up after tests
• Test edge cases (empty episodes, failed operations)
• Verify state transitions
• Mock embedding providers for speed