EXO-AI 2025 Test Templates

Purpose

This directory contains comprehensive test templates for all EXO-AI 2025 crates. These templates are ready to be copied into the actual crate directories once the implementation code is written.

Directory Structure

test-templates/
├── exo-core/
│   └── tests/
│       └── core_traits_test.rs        # Core trait and type tests
├── exo-manifold/
│   └── tests/
│       └── manifold_engine_test.rs    # Manifold engine tests
├── exo-hypergraph/
│   └── tests/
│       └── hypergraph_test.rs         # Hypergraph substrate tests
├── exo-temporal/
│   └── tests/
│       └── temporal_memory_test.rs    # Temporal memory tests
├── exo-federation/
│   └── tests/
│       └── federation_test.rs         # Federation and consensus tests
├── exo-backend-classical/
│   └── tests/
│       └── classical_backend_test.rs  # ruvector integration tests
├── integration/
│   ├── manifold_hypergraph_test.rs    # Cross-crate integration
│   ├── temporal_federation_test.rs    # Distributed memory
│   └── full_stack_test.rs             # Complete system tests
└── README.md                           # This file

How to Use

1. When Crates Are Created

Once a coder agent creates a crate (e.g., crates/exo-core/), copy the corresponding test template:

# Example for exo-core
cp test-templates/exo-core/tests/core_traits_test.rs \
   crates/exo-core/tests/

# Uncomment the use statements and imports
# Remove placeholder comments
# Run tests
cd crates/exo-core
cargo test

2. Activation Checklist

For each test file:

• Copy to actual crate directory
• Uncomment use statements
• Remove placeholder comments
• Add #[cfg(test)] if not present
• Run cargo test to verify
• Fix any compilation errors
• Ensure tests pass or fail appropriately (TDD)

3. Test Categories Covered

Each crate has tests for:

exo-core

• ✅ Pattern construction and validation
• ✅ TopologicalQuery variants
• ✅ SubstrateTime operations
• ✅ Error handling
• ✅ Filter types

exo-manifold

• ✅ Gradient descent retrieval
• ✅ Manifold deformation
• ✅ Strategic forgetting
• ✅ SIREN network operations
• ✅ Fourier features
• ✅ Tensor Train compression (feature-gated)
• ✅ Edge cases (NaN, infinity, etc.)

exo-hypergraph

• ✅ Hyperedge creation and query
• ✅ Persistent homology (0D, 1D, 2D)
• ✅ Betti numbers
• ✅ Sheaf consistency (feature-gated)
• ✅ Simplicial complex operations
• ✅ Entity and relation indexing

exo-temporal

• ✅ Causal cone queries (past, future, light-cone)
• ✅ Memory consolidation
• ✅ Salience computation
• ✅ Anticipatory pre-fetch
• ✅ Causal graph operations
• ✅ Temporal knowledge graph
• ✅ Short-term buffer management

exo-federation

• ✅ Post-quantum key exchange (Kyber)
• ✅ Byzantine fault tolerance
• ✅ CRDT reconciliation
• ✅ Onion routing
• ✅ Federation handshake
• ✅ Raft consensus
• ✅ Encrypted channels

exo-backend-classical

• ✅ ruvector-core integration
• ✅ ruvector-graph integration
• ✅ ruvector-gnn integration
• ✅ SubstrateBackend implementation
• ✅ Performance tests
• ✅ Concurrency tests

4. Integration Tests

Integration tests in integration/ should be placed in crates/tests/ at the workspace root:

# Create workspace integration test directory
mkdir -p crates/tests

# Copy integration tests
cp test-templates/integration/*.rs crates/tests/

5. Running Tests

# Run all tests in workspace
cargo test --all-features

# Run tests for specific crate
cargo test -p exo-manifold

# Run specific test file
cargo test -p exo-manifold --test manifold_engine_test

# Run with coverage
cargo tarpaulin --all-features

# Run integration tests only
cargo test --test '*'

# Run benchmarks
cargo bench

6. Test-Driven Development Workflow

1. Copy template to crate directory
2. Uncomment imports and test code
3. Run tests - they will fail (RED)
4. Implement code to make tests pass
5. Run tests again - they should pass (GREEN)
6. Refactor code while keeping tests green
7. Repeat for next test

7. Feature Gates

Some tests are feature-gated:

#[test]
#[cfg(feature = "tensor-train")]
fn test_tensor_train_compression() {
    // Only runs with --features tensor-train
}

#[test]
#[cfg(feature = "sheaf-consistency")]
fn test_sheaf_consistency() {
    // Only runs with --features sheaf-consistency
}

#[test]
#[cfg(feature = "post-quantum")]
fn test_kyber_key_exchange() {
    // Only runs with --features post-quantum
}

Run with features:

cargo test --features tensor-train
cargo test --all-features

8. Async Tests

Federation and temporal tests use tokio::test:

#[tokio::test]
async fn test_async_operation() {
    // Async test code
}

Ensure tokio is in dev-dependencies:

[dev-dependencies]
tokio = { version = "1.0", features = ["full", "test-util"] }

9. Test Data and Fixtures

Common test utilities should be placed in:

crates/test-utils/
├── src/
│   ├── fixtures.rs    # Test data generators
│   ├── mocks.rs       # Mock implementations
│   └── helpers.rs     # Test helper functions

10. Coverage Reports

Generate coverage reports:

# Install tarpaulin
cargo install cargo-tarpaulin

# Generate coverage
cargo tarpaulin --all-features --out Html --output-dir coverage/

# View report
open coverage/index.html

11. Continuous Integration

Tests should be run in CI:

# .github/workflows/test.yml
name: Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@stable
      - run: cargo test --all-features
      - run: cargo test --test '*'  # Integration tests

Test Metrics

Coverage Targets

• Unit Tests: 85%+ statement coverage
• Integration Tests: 70%+ coverage
• E2E Tests: Key user scenarios

Performance Targets

Operation	Target Latency	Target Throughput
Manifold Retrieve (k=10)	<10ms	>1000 qps
Hyperedge Creation	<1ms	>10000 ops/s
Causal Query	<20ms	>500 qps
Byzantine Commit	<100ms	>100 commits/s

Next Steps

1. ✅ Test strategy created (docs/TEST_STRATEGY.md)
2. ✅ Test templates created (this directory)
3. ⏳ Wait for coder to create crates
4. ⏳ Copy templates to crates
5. ⏳ Uncomment and activate tests
6. ⏳ Run tests (TDD: RED phase)
7. ⏳ Implement code to pass tests
8. ⏳ Achieve GREEN phase
9. ⏳ Refactor and optimize

References

• Test Strategy: ../docs/TEST_STRATEGY.md
• Architecture: ../architecture/ARCHITECTURE.md
• Specification: ../specs/SPECIFICATION.md
• Pseudocode: ../architecture/PSEUDOCODE.md

Contact

For questions about test implementation:

• Check docs/TEST_STRATEGY.md for comprehensive guidance
• Review template files for examples
• Ensure TDD workflow is followed