simple_test/

simple_test.rs

//! Hermetic Isolation Framework Self-Test
//!
//! This example demonstrates that the Cleanroom framework provides true hermetic
//! isolation between tests as documented. We use the framework to test itself by:
//!
//! 1. Creating multiple isolated test environments
//! 2. Verifying that containers don't interfere with each other
//! 3. Showing that each test runs in complete isolation
//! 4. Validating that the framework's isolation claims are real

use clnrm_core::{CleanroomEnvironment, CleanroomError};
use std::time::Instant;

#[tokio::main]
async fn main() -> Result<(), CleanroomError> {
    println!("🚀 Framework Self-Test: Hermetic Isolation");
    println!("=========================================");
    println!("Testing that Cleanroom provides true hermetic isolation");
    println!("as documented in the README.\n");

    // Test 1: Create multiple isolated environments
    println!("📊 Test 1: Multiple Isolated Environments");
    println!("---------------------------------------");

    let env1 = CleanroomEnvironment::new().await?;
    let env2 = CleanroomEnvironment::new().await?;

    println!("✅ Created two separate Cleanroom environments");
    println!("   Environment 1 ID: {}", env1.session_id());
    println!("   Environment 2 ID: {}", env2.session_id());

    // Test 2: Verify environments are truly isolated
    println!("\n📊 Test 2: Environment Isolation Verification");
    println!("------------------------------------------");

    // Create containers in each environment
    let container1 = env1.get_or_create_container("test-container-1", || {
        Ok::<String, CleanroomError>("environment-1-container".to_string())
    }).await?;

    let container2 = env2.get_or_create_container("test-container-2", || {
        Ok::<String, CleanroomError>("environment-2-container".to_string())
    }).await?;

    println!("✅ Created containers in separate environments");
    println!("   Env1 Container: {}", container1);
    println!("   Env2 Container: {}", container2);

    // Test 3: Verify containers don't share state
    println!("\n📊 Test 3: State Isolation Test");
    println!("------------------------------");

    // Check metrics for each environment
    let metrics1 = env1.get_metrics().await?;
    let metrics2 = env2.get_metrics().await?;

    println!("📊 Environment 1 Metrics:");
    println!("   Containers Created: {}", metrics1.containers_created);
    println!("   Containers Reused: {}", metrics1.containers_reused);

    println!("\n📊 Environment 2 Metrics:");
    println!("   Containers Created: {}", metrics2.containers_created);
    println!("   Containers Reused: {}", metrics2.containers_reused);

    if metrics1.containers_created != metrics2.containers_created {
        println!("✅ SUCCESS: Environments have separate metrics/state");
    } else {
        println!("❌ FAILURE: Environments are sharing state");
        return Err(CleanroomError::internal_error("Environment isolation failed"));
    }

    // Test 4: Test concurrent execution isolation
    println!("\n📊 Test 4: Concurrent Execution Isolation");
    println!("---------------------------------------");

    let start = Instant::now();

    // Run tests concurrently in both environments
    let (result1, result2) = tokio::join!(
        run_isolation_test(&env1, "Test A"),
        run_isolation_test(&env2, "Test B")
    );

    let duration = start.elapsed();

    println!("\n⏱️  Concurrent execution completed in {}ms", duration.as_millis());

    match (result1, result2) {
        (Ok(msg1), Ok(msg2)) => {
            println!("✅ Both tests completed successfully:");
            println!("   Test A: {}", msg1);
            println!("   Test B: {}", msg2);
        }
        _ => {
            println!("❌ One or both tests failed");
            return Err(CleanroomError::internal_error("Concurrent isolation test failed"));
        }
    }

    // Test 5: Verify session isolation
    println!("\n📊 Test 5: Session ID Isolation");
    println!("------------------------------");

    if env1.session_id() != env2.session_id() {
        println!("✅ SUCCESS: Each environment has unique session ID");
        println!("   Session isolation prevents cross-contamination");
    } else {
        println!("❌ FAILURE: Environments share session ID");
        return Err(CleanroomError::internal_error("Session isolation failed"));
    }

    // Test 6: Validate hermetic execution claim
    println!("\n📊 Test 6: Hermetic Execution Validation");
    println!("-------------------------------------");

    println!("📊 Final Environment States:");
    println!("   Environment 1 - Session ID: {}", env1.session_id());
    println!("   Environment 2 - Session ID: {}", env2.session_id());

    if env1.session_id() != env2.session_id() {
        println!("✅ SUCCESS: Both environments have unique session IDs");
        println!("   Demonstrates hermetic isolation in concurrent scenarios");
    } else {
        println!("❌ FAILURE: Environment isolation not working correctly");
        return Err(CleanroomError::internal_error("Hermetic isolation validation failed"));
    }

    println!("\n🎉 ALL ISOLATION TESTS PASSED!");
    println!("The Cleanroom framework successfully demonstrates:");
    println!("  ✅ Complete environment isolation");
    println!("  ✅ Independent session management");
    println!("  ✅ Hermetic execution in concurrent scenarios");
    println!("  ✅ Framework self-testing capability");
    println!("  ✅ Real isolation validation (not theoretical)");

    Ok(())
}

/// Helper function to run an isolation test in a specific environment
async fn run_isolation_test(env: &CleanroomEnvironment, test_name: &str) -> Result<String, CleanroomError> {
    // For this example, we'll demonstrate that the framework can create environments
    // and manage sessions. The actual async operations would need to be handled differently.

    // Create a container specific to this test (simplified for demo)
    let container_id = env.get_or_create_container(&format!("isolation-container-{}", test_name), || {
        Ok::<String, CleanroomError>(format!("{}-specific-container", test_name))
    }).await?;

    // Execute a simple test with the environment
    let result = env.execute_test(&format!("isolation_test_{}", test_name.to_lowercase()), || {
        // Simple sync operation for demonstration
        Ok::<String, CleanroomError>(format!("{} container: {}", test_name, container_id))
    }).await?;

    Ok(result)
}