138 lines
4.6 KiB
Rust
138 lines
4.6 KiB
Rust
//! Integration Tests: Complete Substrate Workflow
|
|
//!
|
|
//! These tests verify the end-to-end functionality of the cognitive substrate,
|
|
//! from pattern storage through querying and retrieval.
|
|
|
|
#[cfg(test)]
|
|
mod substrate_tests {
|
|
// Note: These imports will be available once crates are implemented
|
|
// use exo_core::{Pattern, Query, SubstrateConfig};
|
|
// use exo_backend_classical::ClassicalBackend;
|
|
// use exo_manifold::ManifoldEngine;
|
|
|
|
/// Test: Complete substrate workflow
|
|
///
|
|
/// Steps:
|
|
/// 1. Initialize substrate with classical backend
|
|
/// 2. Store multiple patterns with embeddings
|
|
/// 3. Query with similarity search
|
|
/// 4. Verify results match expected patterns
|
|
#[tokio::test]
|
|
#[ignore] // Remove this when crates are implemented
|
|
async fn test_substrate_store_and_retrieve() {
|
|
// TODO: Implement once exo-core and exo-backend-classical exist
|
|
|
|
// Expected API usage:
|
|
// let config = SubstrateConfig::default();
|
|
// let backend = ClassicalBackend::new(config).unwrap();
|
|
// let substrate = SubstrateInstance::new(backend);
|
|
|
|
// // Store patterns
|
|
// let pattern1 = Pattern {
|
|
// embedding: vec![1.0, 0.0, 0.0, 0.0],
|
|
// metadata: Metadata::new(),
|
|
// timestamp: SubstrateTime::now(),
|
|
// antecedents: vec![],
|
|
// };
|
|
//
|
|
// let id1 = substrate.store(pattern1.clone()).await.unwrap();
|
|
//
|
|
// let pattern2 = Pattern {
|
|
// embedding: vec![0.9, 0.1, 0.0, 0.0],
|
|
// metadata: Metadata::new(),
|
|
// timestamp: SubstrateTime::now(),
|
|
// antecedents: vec![],
|
|
// };
|
|
//
|
|
// let id2 = substrate.store(pattern2.clone()).await.unwrap();
|
|
//
|
|
// // Query
|
|
// let query = Query::from_embedding(vec![1.0, 0.0, 0.0, 0.0]);
|
|
// let results = substrate.search(query, 2).await.unwrap();
|
|
//
|
|
// // Verify
|
|
// assert_eq!(results.len(), 2);
|
|
// assert_eq!(results[0].id, id1); // Closest match
|
|
// assert!(results[0].score > results[1].score);
|
|
|
|
panic!("Implement this test once exo-core crate exists");
|
|
}
|
|
|
|
/// Test: Manifold deformation (continuous learning)
|
|
///
|
|
/// Verifies that the learned manifold can be deformed to incorporate
|
|
/// new patterns without explicit insert operations.
|
|
#[tokio::test]
|
|
#[ignore]
|
|
async fn test_manifold_deformation() {
|
|
// TODO: Implement once exo-manifold exists
|
|
|
|
// Expected API:
|
|
// let manifold = ManifoldEngine::new(config);
|
|
//
|
|
// // Initial query should find nothing
|
|
// let query = Tensor::from_floats(&[0.5, 0.5, 0.0, 0.0]);
|
|
// let before = manifold.retrieve(query.clone(), 1);
|
|
// assert!(before.is_empty());
|
|
//
|
|
// // Deform manifold with new pattern
|
|
// let pattern = Pattern { embedding: vec![0.5, 0.5, 0.0, 0.0], ... };
|
|
// manifold.deform(pattern, salience=1.0);
|
|
//
|
|
// // Now query should find the pattern
|
|
// let after = manifold.retrieve(query, 1);
|
|
// assert_eq!(after.len(), 1);
|
|
|
|
panic!("Implement this test once exo-manifold crate exists");
|
|
}
|
|
|
|
/// Test: Strategic forgetting
|
|
///
|
|
/// Verifies that low-salience patterns decay over time.
|
|
#[tokio::test]
|
|
#[ignore]
|
|
async fn test_strategic_forgetting() {
|
|
// TODO: Implement once exo-manifold exists
|
|
|
|
// Expected behavior:
|
|
// 1. Store high-salience and low-salience patterns
|
|
// 2. Trigger forgetting
|
|
// 3. Verify low-salience patterns are forgotten
|
|
// 4. Verify high-salience patterns remain
|
|
|
|
panic!("Implement this test once exo-manifold crate exists");
|
|
}
|
|
|
|
/// Test: Batch operations and performance
|
|
///
|
|
/// Verifies substrate can handle bulk operations efficiently.
|
|
#[tokio::test]
|
|
#[ignore]
|
|
async fn test_bulk_operations() {
|
|
// TODO: Implement performance test
|
|
|
|
// Expected:
|
|
// - Store 10,000 patterns
|
|
// - Batch query 1,000 times
|
|
// - Verify latency < 10ms per query (classical backend)
|
|
|
|
panic!("Implement this test once exo-core crate exists");
|
|
}
|
|
|
|
/// Test: Filter-based queries
|
|
///
|
|
/// Verifies metadata filtering during similarity search.
|
|
#[tokio::test]
|
|
#[ignore]
|
|
async fn test_filtered_search() {
|
|
// TODO: Implement once exo-core exists
|
|
|
|
// Expected:
|
|
// - Store patterns with different metadata tags
|
|
// - Query with metadata filter
|
|
// - Verify only matching patterns returned
|
|
|
|
panic!("Implement this test once exo-core crate exists");
|
|
}
|
|
}
|