Function test 

pub fn test<F>(name: &str, f: F)
where
    F: FnMut(&mut TestContext) -> TestResult + Send + 'static,

Examples found in repository

examples/user_specified_ports.rs (lines 118-130)

fn main() {
    println!("🔧 User-Specified Ports Example");
    println!("==============================");
    println!();
    
    // Example 1: PostgreSQL on standard port 5432
    let postgres_container = ContainerConfig::new("postgres:13-alpine")
        .port(5432, 5432)     // Map host port 5432 to container port 5432
        .env("POSTGRES_PASSWORD", "testpass")
        .env("POSTGRES_DB", "testdb")
        .name("postgres_test")
        .ready_timeout(Duration::from_secs(15));
    
    // Example 2: Web service on port 8080
    let web_container = ContainerConfig::new("nginx:alpine")
        .port(8080, 80)       // Map host port 8080 to container port 80
        .name("nginx_test")
        .ready_timeout(Duration::from_secs(10));
    
    // Example 3: Mixed configuration - some fixed, some auto
    let api_container = ContainerConfig::new("httpd:alpine")
        .port(3000, 80)       // Fixed port for main API
        .auto_port(443)       // Auto-assign for HTTPS
        .auto_port(9090)      // Auto-assign for metrics
        .name("api_test")
        .ready_timeout(Duration::from_secs(10));
    
    println!("📋 Container Configurations:");
    println!("1. PostgreSQL: Fixed on localhost:5432 (standard PostgreSQL port)");
    println!("2. Web Service: Fixed on localhost:8080");
    println!("3. API Service: Fixed localhost:3000, auto-assigned for 443 and 9090");
    println!();
    
    // Clone containers for hooks
    let postgres_before = postgres_container.clone();
    let web_before = web_container.clone();
    let api_before = api_container.clone();
    
    // Start containers in before_each
    before_each(move |ctx| {
        println!("🚀 before_each: Starting containers with specified ports...");
        
        // Start PostgreSQL container
        let postgres_info = postgres_before.start()
            .map_err(|e| format!("Failed to start PostgreSQL container: {}", e))?;
        ctx.set_data("postgres_container_info", postgres_info.clone());
        
        println!("✅ PostgreSQL started: {}", postgres_info.container_id);
        println!("   📍 Port mappings: {}", postgres_info.ports_summary());
        println!("   🗄️ Database URL: postgresql://postgres:testpass@localhost:5432/testdb");
        
        // Start web container
        let web_info = web_before.start()
            .map_err(|e| format!("Failed to start web container: {}", e))?;
        ctx.set_data("web_container_info", web_info.clone());
        
        println!("✅ Web service started: {}", web_info.container_id);
        println!("   📍 Port mappings: {}", web_info.ports_summary());
        println!("   🌐 Web accessible at: http://localhost:8080");
        
        // Start API container
        let api_info = api_before.start()
            .map_err(|e| format!("Failed to start API container: {}", e))?;
        ctx.set_data("api_container_info", api_info.clone());
        
        println!("✅ API service started: {}", api_info.container_id);
        println!("   📍 Port mappings: {}", api_info.ports_summary());
        println!("   🔗 API accessible at: http://localhost:3000");
        if let Some(https_port) = api_info.host_port_for(443) {
            println!("   🔒 HTTPS accessible at: https://localhost:{}", https_port);
        }
        if let Some(metrics_port) = api_info.host_port_for(9090) {
            println!("   📊 Metrics accessible at: http://localhost:{}/metrics", metrics_port);
        }
        
        Ok(())
    });
    
    // Cleanup containers in after_each
    let postgres_after = postgres_container.clone();
    let web_after = web_container.clone();
    let api_after = api_container.clone();
    
    after_each(move |ctx| {
        println!("🧹 after_each: Cleaning up containers...");
        
        if let Some(postgres_info) = ctx.get_data::<rust_test_harness::ContainerInfo>("postgres_container_info") {
            let _ = postgres_after.stop(&postgres_info.container_id);
            println!("🛑 Stopped PostgreSQL container");
        }
        
        if let Some(web_info) = ctx.get_data::<rust_test_harness::ContainerInfo>("web_container_info") {
            let _ = web_after.stop(&web_info.container_id);
            println!("🛑 Stopped web container");
        }
        
        if let Some(api_info) = ctx.get_data::<rust_test_harness::ContainerInfo>("api_container_info") {
            let _ = api_after.stop(&api_info.container_id);
            println!("🛑 Stopped API container");
        }
        
        println!("✅ All containers cleaned up!");
        Ok(())
    });
    
    // Test 1: Database connection test
    test("test_database_connection", |ctx| {
        println!("🧪 Testing database connection on fixed port 5432...");
        
        if let Some(postgres_info) = ctx.get_data::<rust_test_harness::ContainerInfo>("postgres_container_info") {
            assert_eq!(postgres_info.host_port_for(5432), Some(5432));
            assert_eq!(postgres_info.url_for_port(5432), Some("localhost:5432".to_string()));
            println!("✅ Database is accessible on the expected port 5432");
        } else {
            return Err("PostgreSQL container info not found".into());
        }
        
        Ok(())
    });
    
    // Test 2: Web service test
    test("test_web_service_fixed_port", |ctx| {
        println!("🧪 Testing web service on fixed port 8080...");
        
        if let Some(web_info) = ctx.get_data::<rust_test_harness::ContainerInfo>("web_container_info") {
            assert_eq!(web_info.host_port_for(80), Some(8080));
            assert_eq!(web_info.url_for_port(80), Some("localhost:8080".to_string()));
            println!("✅ Web service is accessible on the expected port 8080");
        } else {
            return Err("Web container info not found".into());
        }
        
        Ok(())
    });
    
    // Test 3: Mixed configuration test
    test("test_mixed_port_configuration", |ctx| {
        println!("🧪 Testing mixed port configuration (fixed + auto)...");
        
        if let Some(api_info) = ctx.get_data::<rust_test_harness::ContainerInfo>("api_container_info") {
            // Test fixed port
            assert_eq!(api_info.host_port_for(80), Some(3000));
            assert_eq!(api_info.url_for_port(80), Some("localhost:3000".to_string()));
            println!("✅ Fixed port 3000 -> 80 is working");
            
            // Test auto-assigned ports
            if let Some(https_port) = api_info.host_port_for(443) {
                assert!(https_port > 1024); // Should be a high port
                println!("✅ Auto-assigned HTTPS port: {}", https_port);
            }
            
            if let Some(metrics_port) = api_info.host_port_for(9090) {
                assert!(metrics_port > 1024); // Should be a high port
                println!("✅ Auto-assigned metrics port: {}", metrics_port);
            }
            
            println!("✅ Mixed configuration is working correctly");
        } else {
            return Err("API container info not found".into());
        }
        
        Ok(())
    });
    
    println!("🚀 Running user-specified ports tests...");
    
    let config = TestConfig {
        html_report: Some("user-specified-ports-report.html".to_string()),
        ..Default::default()
    };
    
    let exit_code = run_tests_with_config(config);
    
    println!();
    println!("🎉 Tests completed!");
    println!("📊 Check the HTML report for detailed results.");
    println!();
    println!("💡 Key Takeaways:");
    println!("   • Use .port(host_port, container_port) for fixed port mappings");
    println!("   • Use .auto_port(container_port) for automatic port assignment");
    println!("   • Mix both approaches for maximum flexibility");
    println!("   • Fixed ports are great for services with standard ports (5432, 3306, etc.)");
    println!("   • Auto-ports prevent conflicts in parallel test environments");
    
    std::process::exit(exit_code);
}

examples/mongodb_integration.rs (lines 132-169)

fn main() {
    println!("🐳 MongoDB Integration Example with Container Hooks");
    println!("==================================================");
    println!();
    
    // Define container configuration with auto-port for MongoDB
    let mongo_container = ContainerConfig::new("mongo:5.0")
        .auto_port(27017) // Automatically assign available host port for MongoDB
        .env("MONGO_INITDB_ROOT_USERNAME", "admin")
        .env("MONGO_INITDB_ROOT_PASSWORD", "password")
        .name("test_mongodb")
        .ready_timeout(Duration::from_secs(30));
    
    println!("📋 Container Configuration:");
    println!("  Image: {}", mongo_container.image);
    println!("  Auto-ports: {:?}", mongo_container.auto_ports);
    println!("  Environment: {:?}", mongo_container.env);
    println!("  Name: {:?}", mongo_container.name);
    println!("  Ready Timeout: {:?}", mongo_container.ready_timeout);
    println!("  Auto-cleanup: {}", mongo_container.auto_cleanup);
    println!();
    
    // Clone for before_each hook
    let mongo_container_before = mongo_container.clone();
    
    // Register before_each hook to start container
    before_each(move |ctx| {
        println!("🔄 before_each: Starting MongoDB container...");
        
        // Start the container and get ContainerInfo
        let container_info = mongo_container_before.start()
            .map_err(|e| format!("Failed to start container: {}", e))?;
        
        // Store container info in context for tests to access
        ctx.set_data("mongo_container_info", container_info.clone());
        
        // Log container details including auto-assigned ports
        println!("✅ before_each: MongoDB container {} started", container_info.container_id);
        println!("🌐 Container exposed on: {}", container_info.ports_summary());
        if let Some(primary_url) = container_info.primary_url() {
            println!("🔗 Primary URL: {}", primary_url);
        }
        
        Ok(())
    });
    
    // Register after_each hook to stop container
    let mongo_container_after = mongo_container.clone();
    rust_test_harness::after_each(move |ctx| {
        println!("🔄 after_each: Stopping MongoDB container...");
        
        // Get container info from context
        let container_info = ctx.get_data::<rust_test_harness::ContainerInfo>("mongo_container_info")
            .expect("Container info should be available");
        
        // Stop the container
        mongo_container_after.stop(&container_info.container_id)
            .map_err(|e| format!("Failed to stop container: {}", e))?;
        
        println!("✅ after_each: MongoDB container {} stopped", container_info.container_id);
        Ok(())
    });
    
    // Test 1: Basic MongoDB operations
    test("test_mongodb_basic_operations", |ctx| {
        println!("🧪 Running test: test_mongodb_basic_operations");
        
        // Get container info from context
        let container_info = ctx.get_data::<rust_test_harness::ContainerInfo>("mongo_container_info")
            .expect("Container info should be available");
        
        // Show how to access port information
        println!("🌐 Container {} is running on:", container_info.container_id);
        println!("   Ports: {}", container_info.ports_summary());
        if let Some(primary_url) = container_info.primary_url() {
            println!("   Primary URL: {}", primary_url);
        }
        
        // Get the MongoDB port (27017) and show the actual host port
        if let Some(host_port) = container_info.host_port_for(27017) {
            println!("   MongoDB accessible at: localhost:{}", host_port);
        }
        
        // Create MongoDB client
        let mut client = MongoClient::new(container_info.container_id.clone());
        
        // Connect to MongoDB
        client.connect()?;
        
        // Insert a document
        client.insert_document("users", r#"{"name": "John Doe", "email": "john@example.com"}"#)?;
        
        // Find documents
        let documents = client.find_documents("users", r#"{"name": "John Doe"}"#)?;
        assert_eq!(documents.len(), 2);
        
        // Disconnect
        client.disconnect()?;
        
        println!("✅ test_mongodb_basic_operations passed");
        Ok(())
    });
    
    // Test 2: Multiple operations
    test("test_mongodb_multiple_operations", |ctx| {
        println!("🧪 Running test: test_mongodb_multiple_operations");
        
        // Get container info from context
        let container_info = ctx.get_data::<rust_test_harness::ContainerInfo>("mongo_container_info")
            .expect("Container info should be available");
        
        // Show container status
        println!("🌐 Container {} status:", container_info.container_id);
        println!("   Active ports: {}", container_info.ports_summary());
        
        // Create MongoDB client
        let mut client = MongoClient::new(container_info.container_id.clone());
        
        // Connect to MongoDB
        client.connect()?;
        
        // Insert multiple documents
        client.insert_document("products", r#"{"name": "Laptop", "price": 999.99}"#)?;
        client.insert_document("products", r#"{"name": "Mouse", "price": 29.99}"#)?;
        client.insert_document("products", r#"{"name": "Keyboard", "price": 79.99}"#)?;
        
        // Find documents
        let documents = client.find_documents("products", r#"{"price": {"$gt": 50}}"#)?;
        assert_eq!(documents.len(), 2); // Laptop and Keyboard
        
        // Disconnect
        client.disconnect()?;
        
        println!("✅ test_mongodb_multiple_operations passed");
        Ok(())
    });
    
    // Test 3: Error handling
    test("test_mongodb_error_handling", |ctx| {
        println!("🧪 Running test: test_mongodb_error_handling");
        
        // Get container ID from context
        let container_id = ctx.get_data::<String>("mongo_container_id")
            .expect("Container ID should be available")
            .to_string();
        
        // Create MongoDB client
        let client = MongoClient::new(container_id);
        
        // Try to insert without connecting (should fail)
        let result = client.insert_document("users", r#"{"name": "Test"}"#);
        assert!(result.is_err());
        assert_eq!(result.unwrap_err(), "Not connected to MongoDB");
        
        println!("✅ test_mongodb_error_handling passed");
        Ok(())
    });
    
    // Test 4: Performance testing
    test("test_mongodb_performance", |ctx| {
        println!("🧪 Running test: test_mongodb_performance");
        
        // Get container ID from context
        let container_id = ctx.get_data::<String>("mongo_container_id")
            .expect("Container ID should be available")
            .to_string();
        
        // Create MongoDB client
        let mut client = MongoClient::new(container_id);
        
        // Connect to MongoDB
        client.connect()?;
        
        // Simulate bulk operations
        for i in 0..100 {
            client.insert_document("bulk_data", &format!(r#"{{"index": {}, "data": "bulk_item_{}"}}"#, i, i))?;
        }
        
        // Simulate bulk retrieval
        let documents = client.find_documents("bulk_data", r#"{"index": {"$lt": 50}}"#)?;
        assert_eq!(documents.len(), 2); // Mock always returns 2
        
        // Disconnect
        client.disconnect()?;
        
        println!("✅ test_mongodb_performance passed");
        Ok(())
    });
    
    println!("\n🚀 Running MongoDB integration tests...");
    println!("   Each test will get a fresh MongoDB container via before_each");
    println!("   Each test will clean up its container via after_each");
    println!();
    
    // Run tests with container hooks enabled
    let config = TestConfig {
        skip_hooks: Some(false),
        ..Default::default()
    };
    
    let result = run_tests_with_config(config);
    
    println!("\n📊 Test Results:");
    if result == 0 {
        println!("✅ All MongoDB integration tests passed!");
        println!("🎯 Container lifecycle management working correctly");
        println!("🐳 Each test got its own MongoDB container");
        println!("🧹 Each test cleaned up its container properly");
    } else {
        println!("❌ Some tests failed");
    }
    
    println!("\n💡 Key Benefits of this approach:");
    println!("   • Clean separation of concerns");
    println!("   • Each test gets a fresh container");
    println!("   • Automatic cleanup via after_each");
    println!("   • Easy to configure containers");
    println!("   • No complex global state management");
}

examples/html_reporting.rs (line 28)

fn main() {
    println!("🧪 HTML Reporting Example");
    println!("=========================");
    println!();
    
    // Example 1: Basic HTML Report Generation
    println!("📊 Example 1: Basic HTML Report");
    println!("Generating basic HTML report...");
    
    // Register some tests
    test("basic_passing_test", |_| Ok(()));
    test("another_passing_test", |_| Ok(()));
    
    let config = TestConfig {
        html_report: Some("basic_report.html".to_string()),
        skip_hooks: None,
        ..Default::default()
    };
    
    let result = run_tests_with_config(config);
    println!("✅ Basic report generated with exit code: {}", result);
    println!();
    
    // Example 2: HTML Report with Mixed Results
    println!("📊 Example 2: Mixed Results Report");
    println!("Generating report with pass/fail/skip results...");
    
    // Clear previous tests and register new ones
    test("successful_test", |_| Ok(()));
    test("failing_test", |_| Err("intentional failure".into()));
    test("skipped_test", |_| Ok(()));
    
    let config = TestConfig {
        html_report: Some("mixed_results_report.html".to_string()),
        skip_hooks: None,
        ..Default::default()
    };
    
    let result = run_tests_with_config(config);
    println!("✅ Mixed results report generated with exit code: {}", result);
    println!();
    
    // Example 3: HTML Report with Rich Metadata
    println!("📊 Example 3: Rich Metadata Report");
    println!("Generating report with tags, timeouts, and Docker...");
    
    // Clear previous tests and register new ones with realistic scenarios
    test("tagged_test", |_| Ok(()));
    test("timeout_test", |_| Ok(()));
    test("docker_integration_test", |_| Ok(()));
    test("database_connection_test", |_| Ok(()));
    test("api_endpoint_test", |_| Ok(()));
    
    // Note: In a real scenario, you'd use test_with_tags and test_with_docker
    // For this example, we'll simulate the metadata by showing different test types
    
    let config = TestConfig {
        html_report: Some("rich_metadata_report.html".to_string()),
        skip_hooks: None,
        ..Default::default()
    };
    
    let result = run_tests_with_config(config);
    println!("✅ Rich metadata report generated with exit code: {}", result);
    println!("   📊 5 tests with different types (tags, timeouts, Docker, DB, API)");
    println!();
    
    // Example 4: Large Test Suite Report
    println!("📊 Example 4: Large Test Suite Report");
    println!("Generating report for many tests with realistic mixed results...");
    
    // Clear previous tests and register many tests with realistic scenarios
    for i in 0..25 {
        match i {
            // Some tests pass normally
            0..=15 => {
                test(&format!("large_suite_test_{}", i), |_| Ok(()));
            },
            // Some tests fail with different error types
            16..=19 => {
                test(&format!("large_suite_test_{}", i), move |_| {
                    Err(format!("Test {} failed due to assertion error", i).into())
                });
            },
            // Some tests have timeouts
            20..=22 => {
                test(&format!("large_suite_test_{}", i), move |_| {
                    // Simulate a test that takes too long and fails due to timeout
                    std::thread::sleep(Duration::from_millis(50));
                    Err(format!("Test {} failed due to timeout (exceeded 30ms limit)", i).into())
                });
            },
            // Some tests panic
            23 => {
                test(&format!("large_suite_test_{}", i), move |_| {
                    panic!("Test {} panicked due to unexpected condition", i);
                });
            },
            // Some tests are skipped (simulated by returning error)
            24 => {
                test(&format!("large_suite_test_{}", i), |_| {
                    Err("Test skipped due to missing dependencies".into())
                });
            },
            _ => unreachable!(),
        }
    }
    
    let config = TestConfig {
        html_report: Some("large_suite_report.html".to_string()),
        skip_hooks: None,
        ..Default::default()
    };
    
    let result = run_tests_with_config(config);
    println!("✅ Large suite report generated with exit code: {}", result);
    println!("   📊 16 tests passed, 7 failed (4 errors + 3 timeouts), 1 panic, 1 skipped");
    println!();
    
    // Example 5: Environment Variable Configuration
    println!("📊 Example 5: Environment Variable Configuration");
    println!("Setting TEST_HTML_REPORT environment variable...");
    
    // Set environment variable
    std::env::set_var("TEST_HTML_REPORT", "env_var_report.html");
    
    // Clear previous tests and register new ones
    test("env_test", |_| Ok(()));
    
    let config = TestConfig::default();
    println!("📝 Config HTML report path: {:?}", config.html_report);
    
    let result = run_tests_with_config(config);
    println!("✅ Environment variable report generated with exit code: {}", result);
    println!();
    
    // Example 6: Performance Testing Report
    println!("📊 Example 6: Performance Testing Report");
    println!("Generating report for performance tests with realistic scenarios...");
    
    // Clear previous tests and register performance tests with mixed results
    for i in 0..15 {
        match i {
            // Fast tests that pass
            0..=8 => {
                test(&format!("perf_test_{}", i), |_| {
                    // Simulate some work
                    std::thread::sleep(Duration::from_millis(5));
                    Ok(())
                });
            },
            // Medium tests that pass
            9..=11 => {
                test(&format!("perf_test_{}", i), |_| {
                    // Simulate medium work
                    std::thread::sleep(Duration::from_millis(20));
                    Ok(())
                });
            },
            // Slow tests that pass
            12..=13 => {
                test(&format!("perf_test_{}", i), |_| {
                    // Simulate slow but successful tests
                    std::thread::sleep(Duration::from_millis(50));
                    Ok(())
                });
            },
            // One test that fails due to timeout
            14 => {
                test(&format!("perf_test_{}", i), |_| {
                    // Simulate a test that takes too long and fails due to timeout
                    std::thread::sleep(Duration::from_millis(100));
                    Err("Performance test exceeded expected time limit (50ms)".into())
                });
            },
            _ => unreachable!(),
        }
    }
    
    let config = TestConfig {
        html_report: Some("performance_report.html".to_string()),
        max_concurrency: Some(4),
        skip_hooks: None,
        ..Default::default()
    };
    
    let result = run_tests_with_config(config);
    println!("✅ Performance report generated with exit code: {}", result);
    println!("   📊 14 tests passed, 1 failed (timeout)");
    println!();
    
    // Summary
    println!("🎉 HTML Reporting Examples Complete!");
    println!("=====================================");
    println!();
    println!("Generated HTML reports (stored in target/test-reports/):");
    println!("  📄 basic_report.html - Basic functionality");
    println!("  📄 mixed_results_report.html - Pass/fail/skip results");
    println!("  📄 rich_metadata_report.html - Rich test metadata");
    println!("  📄 large_suite_report.html - Large test suite");
    println!("  📄 env_var_report.html - Environment variable config");
    println!("  📄 performance_report.html - Performance testing");
    println!();
    println!("📁 All reports are automatically organized in target/test-reports/");
    println!();
    println!("📖 HTML Report Features:");
    println!("  🔽 Expandable test details - Click any test to expand");
    println!("  🔍 Real-time search - Search by name, status, or tags");
    println!("  ⌨️  Keyboard shortcuts - Ctrl+F (search), Ctrl+A (expand all)");
    println!("  🚨 Auto-expand failed - Failed tests automatically expand");
    println!("  📱 Responsive design - Works on all devices");
    println!();
    println!("💡 Usage Tips:");
    println!("  • Open any .html file in your web browser");
    println!("  • Use Ctrl+F to search for specific tests");
    println!("  • Click test headers to expand/collapse details");
    println!("  • Failed tests are automatically expanded for visibility");
    println!("  • Reports work great in CI/CD pipelines and team sharing");
    println!("  • All reports are neatly organized in target/test-reports/");
    println!();
    println!("🔧 Configuration Options:");
    println!("  • Set TEST_HTML_REPORT environment variable");
    println!("  • Use TestConfig.html_report for programmatic control");
    println!("  • Combine with other config options (filtering, concurrency)");
    println!("  • Reports automatically go to target/test-reports/ for clean organization");
}

examples/auto_port_demo.rs (lines 158-174)

fn main() {
    println!("🚀 Auto-Port and Container Management Demo");
    println!("==========================================");
    println!();
    
    // Example 1: Web service with auto-port
    let web_container = ContainerConfig::new("nginx:alpine")
        .auto_port(80) // Automatically assign host port for container port 80
        .env("NGINX_HOST", "localhost")
        .name("web_service")
        .ready_timeout(Duration::from_secs(15));
    
    // Example 2: Database with auto-port
    let db_container = ContainerConfig::new("postgres:13-alpine")
        .auto_port(5432) // Automatically assign host port for container port 5432
        .env("POSTGRES_PASSWORD", "testpass")
        .env("POSTGRES_DB", "testdb")
        .name("test_database")
        .ready_timeout(Duration::from_secs(20));
    
    // Example 3: Redis with auto-port
    let redis_container = ContainerConfig::new("redis:6-alpine")
        .auto_port(6379) // Automatically assign host port for container port 6379
        .name("test_redis")
        .ready_timeout(Duration::from_secs(10));
    
    // Example 4: Mixed configuration (manual + auto ports)
    let mixed_container = ContainerConfig::new("httpd:alpine")
        .port(8080, 80) // Manual port mapping
        .auto_port(443) // Auto port for HTTPS
        .env("APACHE_DOCUMENT_ROOT", "/var/www/html")
        .name("mixed_ports")
        .ready_timeout(Duration::from_secs(15));
    
    println!("📋 Container Configurations:");
    println!("1. Web Service (nginx):");
    println!("   - Image: {}", web_container.image);
    println!("   - Auto-ports: {:?}", web_container.auto_ports);
    println!("   - Auto-cleanup: {}", web_container.auto_cleanup);
    
    println!("2. Database (postgres):");
    println!("   - Image: {}", db_container.image);
    println!("   - Auto-ports: {:?}", db_container.auto_ports);
    println!("   - Auto-cleanup: {}", db_container.auto_cleanup);
    
    println!("3. Cache (redis):");
    println!("   - Image: {}", redis_container.image);
    println!("   - Auto-ports: {:?}", redis_container.auto_ports);
    println!("   - Auto-cleanup: {}", redis_container.auto_cleanup);
    
    println!("4. Mixed (httpd):");
    println!("   - Image: {}", mixed_container.image);
    println!("   - Manual ports: {:?}", mixed_container.ports);
    println!("   - Auto-ports: {:?}", mixed_container.auto_ports);
    println!("   - Auto-cleanup: {}", mixed_container.auto_cleanup);
    println!();
    
    // Clone containers for hooks
    let web_before = web_container.clone();
    let db_before = db_container.clone();
    let redis_before = redis_container.clone();
    let mixed_before = mixed_container.clone();
    
    // Start all containers in before_each for each test
    before_each(move |ctx| {
        println!("🚀 before_each: Starting all containers...");
        
        // Start web container
        let web_info = web_before.start()
            .map_err(|e| format!("Failed to start web container: {}", e))?;
        ctx.set_data("web_container_info", web_info.clone());
        println!("✅ Web container started: {}", web_info.container_id);
        println!("   Ports: {}", web_info.ports_summary());
        if let Some(url) = web_info.primary_url() {
            println!("   URL: {}", url);
        }
        
        // Start database container
        let db_info = db_before.start()
            .map_err(|e| format!("Failed to start db container: {}", e))?;
        ctx.set_data("db_container_info", db_info.clone());
        println!("✅ Database container started: {}", db_info.container_id);
        println!("   Ports: {}", db_info.ports_summary());
        if let Some(host_port) = db_info.host_port_for(5432) {
            println!("   PostgreSQL accessible at: localhost:{}", host_port);
        }
        
        // Start redis container
        let redis_info = redis_before.start()
            .map_err(|e| format!("Failed to start redis container: {}", e))?;
        ctx.set_data("redis_container_info", redis_info.clone());
        println!("✅ Redis container started: {}", redis_info.container_id);
        println!("   Ports: {}", redis_info.ports_summary());
        if let Some(host_port) = redis_info.host_port_for(6379) {
            println!("   Redis accessible at: localhost:{}", host_port);
        }
        
        // Start mixed container
        let mixed_info = mixed_before.start()
            .map_err(|e| format!("Failed to start mixed container: {}", e))?;
        ctx.set_data("mixed_container_info", mixed_info.clone());
        println!("✅ Mixed container started: {}", mixed_info.container_id);
        println!("   Ports: {}", mixed_info.ports_summary());
        if let Some(host_port) = mixed_info.host_port_for(443) {
            println!("   HTTPS accessible at: localhost:{}", host_port);
        }
        
        println!("🎉 All containers started successfully!");
        Ok(())
    });
    
    // Cleanup all containers in after_each for each test
    let web_after = web_container.clone();
    let db_after = db_container.clone();
    let redis_after = redis_container.clone();
    let mixed_after = mixed_container.clone();
    
    after_each(move |ctx| {
        println!("🧹 after_each: Cleaning up all containers...");
        
        // Get all container info and stop them
        if let Some(web_info) = ctx.get_data::<rust_test_harness::ContainerInfo>("web_container_info") {
            let _ = web_after.stop(&web_info.container_id);
            println!("🛑 Stopped web container: {}", web_info.container_id);
        }
        
        if let Some(db_info) = ctx.get_data::<rust_test_harness::ContainerInfo>("db_container_info") {
            let _ = db_after.stop(&db_info.container_id);
            println!("🛑 Stopped database container: {}", db_info.container_id);
        }
        
        if let Some(redis_info) = ctx.get_data::<rust_test_harness::ContainerInfo>("redis_container_info") {
            let _ = redis_after.stop(&redis_info.container_id);
            println!("🛑 Stopped redis container: {}", redis_info.container_id);
        }
        
        if let Some(mixed_info) = ctx.get_data::<rust_test_harness::ContainerInfo>("mixed_container_info") {
            let _ = mixed_after.stop(&mixed_info.container_id);
            println!("🛑 Stopped mixed container: {}", mixed_info.container_id);
        }
        
        println!("✅ All containers cleaned up!");
        Ok(())
    });
    
    // Test 1: Access web service
    test("test_web_service_access", |ctx| {
        println!("🧪 Testing web service access...");
        
        let web_info = ctx.get_data::<rust_test_harness::ContainerInfo>("web_container_info")
            .expect("Web container info should be available");
        
        println!("🌐 Web service container: {}", web_info.container_id);
        println!("   Ports: {}", web_info.ports_summary());
        println!("   Primary URL: {}", web_info.primary_url().unwrap_or("None"));
        
        // In a real test, you would make HTTP requests to the container
        // For demo purposes, just verify the port information
        assert!(web_info.host_port_for(80).is_some(), "Web service should have port 80 exposed");
        
        println!("✅ Web service test passed");
        Ok(())
    });
    
    // Test 2: Access database
    test("test_database_access", |ctx| {
        println!("🧪 Testing database access...");
        
        let db_info = ctx.get_data::<rust_test_harness::ContainerInfo>("db_container_info")
            .expect("Database container info should be available");
        
        println!("🗄️ Database container: {}", db_info.container_id);
        println!("   Ports: {}", db_info.ports_summary());
        
        // Verify PostgreSQL port is exposed
        let postgres_port = db_info.host_port_for(5432)
            .expect("PostgreSQL port 5432 should be exposed");
        println!("   PostgreSQL accessible at: localhost:{}", postgres_port);
        
        // In a real test, you would connect to the database
        // For demo purposes, just verify the port information
        assert!(postgres_port > 0, "PostgreSQL port should be valid");
        
        println!("✅ Database test passed");
        Ok(())
    });
    
    // Test 3: Access redis
    test("test_redis_access", |ctx| {
        println!("🧪 Testing redis access...");
        
        let redis_info = ctx.get_data::<rust_test_harness::ContainerInfo>("redis_container_info")
            .expect("Redis container info should be available");
        
        println!("🔴 Redis container: {}", redis_info.container_id);
        println!("   Ports: {}", redis_info.ports_summary());
        
        // Verify Redis port is exposed
        let redis_port = redis_info.host_port_for(6379)
            .expect("Redis port 6379 should be exposed");
        println!("   Redis accessible at: localhost:{}", redis_port);
        
        // In a real test, you would connect to Redis
        // For demo purposes, just verify the port information
        assert!(redis_port > 0, "Redis port should be valid");
        
        println!("✅ Redis test passed");
        Ok(())
    });
    
    // Test 4: Mixed port configuration
    test("test_mixed_port_config", |ctx| {
        println!("🧪 Testing mixed port configuration...");
        
        let mixed_info = ctx.get_data::<rust_test_harness::ContainerInfo>("mixed_container_info")
            .expect("Mixed container info should be available");
        
        println!("🔀 Mixed container: {}", mixed_info.container_id);
        println!("   Ports: {}", mixed_info.ports_summary());
        
        // Verify both manual and auto ports
        let http_port = mixed_info.host_port_for(80)
            .expect("HTTP port 80 should be exposed");
        let https_port = mixed_info.host_port_for(443)
            .expect("HTTPS port 443 should be exposed");
        
        println!("   HTTP accessible at: localhost:{}", http_port);
        println!("   HTTPS accessible at: localhost:{}", https_port);
        
        // Verify the manual port mapping (8080 -> 80)
        assert_eq!(http_port, 8080, "Manual port mapping should work");
        
        // Verify auto port is different from manual port
        assert_ne!(https_port, 8080, "Auto port should be different from manual port");
        
        println!("✅ Mixed port configuration test passed");
        Ok(())
    });
    
    // Test 5: Container info methods
    test("test_container_info_methods", |ctx| {
        println!("🧪 Testing container info methods...");
        
        let web_info = ctx.get_data::<rust_test_harness::ContainerInfo>("web_container_info")
            .expect("Web container info should be available");
        
        // Test all the convenience methods
        println!("🔍 Testing container info methods for: {}", web_info.container_id);
        
        // Test primary_url
        if let Some(url) = web_info.primary_url() {
            println!("   Primary URL: {}", url);
            assert!(url.starts_with("http://localhost:"), "URL should start with http://localhost:");
        }
        
        // Test url_for_port
        if let Some(url) = web_info.url_for_port(80) {
            println!("   URL for port 80: {}", url);
            assert!(url.starts_with("http://localhost:"), "URL should start with http://localhost:");
        }
        
        // Test host_port_for
        if let Some(host_port) = web_info.host_port_for(80) {
            println!("   Host port for container port 80: {}", host_port);
            assert!(host_port > 0, "Host port should be valid");
        }
        
        // Test ports_summary
        let summary = web_info.ports_summary();
        println!("   Ports summary: {}", summary);
        assert!(!summary.is_empty(), "Ports summary should not be empty");
        
        println!("✅ Container info methods test passed");
        Ok(())
    });
    
    println!("🚀 Running tests with auto-port functionality...");
    println!();
    
    // Run the tests
    let config = TestConfig {
        html_report: Some("auto-port-demo-report.html".to_string()),
        ..Default::default()
    };
    
    let exit_code = run_tests_with_config(config);
    
    println!();
    if exit_code == 0 {
        println!("🎉 All tests passed! Auto-port functionality is working correctly.");
        println!("📊 Check the HTML report for detailed results.");
    } else {
        println!("❌ Some tests failed. Check the output above for details.");
    }
    
    std::process::exit(exit_code);
}

examples/container_port_access.rs (lines 149-197)

fn main() {
    println!("🌐 Container Port and URL Access Example");
    println!("========================================");
    println!();
    
    // Example 1: Web service with multiple auto-ports
    let web_container = ContainerConfig::new("nginx:alpine")
        .auto_port(80)      // Auto-assign port for HTTP
        .auto_port(443)     // Auto-assign port for HTTPS
        .env("NGINX_HOST", "localhost")
        .name("web_service")
        .ready_timeout(Duration::from_secs(15));
    
    // Example 2: Database with auto-port
    let db_container = ContainerConfig::new("postgres:13-alpine")
        .auto_port(5432)    // Auto-assign port for PostgreSQL
        .env("POSTGRES_PASSWORD", "testpass")
        .env("POSTGRES_DB", "testdb")
        .name("test_database")
        .ready_timeout(Duration::from_secs(20));
    
    // Example 3: Mixed configuration (manual + auto ports)
    let api_container = ContainerConfig::new("httpd:alpine")
        .port(8080, 80)     // Manual port mapping
        .auto_port(9090)    // Auto-assign port for API
        .auto_port(9091)    // Auto-assign port for metrics
        .env("API_VERSION", "v1")
        .name("api_service")
        .ready_timeout(Duration::from_secs(15));
    
    println!("📋 Container Configurations:");
    println!("1. Web Service:");
    println!("   - Image: {}", web_container.image);
    println!("   - Auto-ports: {:?}", web_container.auto_ports);
    println!("   - Will auto-assign host ports for container ports 80 and 443");
    
    println!("2. Database:");
    println!("   - Image: {}", db_container.image);
    println!("   - Auto-ports: {:?}", db_container.auto_ports);
    println!("   - Will auto-assign host port for container port 5432");
    
    println!("3. API Service:");
    println!("   - Image: {}", api_container.image);
    println!("   - Manual ports: {:?}", api_container.ports);
    println!("   - Auto-ports: {:?}", api_container.auto_ports);
    println!("   - Manual mapping: 8080 -> 80, Auto-assign: 9090, 9091");
    println!();
    
    // Clone containers for hooks
    let web_before = web_container.clone();
    let db_before = db_container.clone();
    let api_before = api_container.clone();
    
    // Start containers in before_each
    before_each(move |ctx| {
        println!("🚀 before_each: Starting containers and capturing port info...");
        
        // Start web container
        let web_info = web_before.start()
            .map_err(|e| format!("Failed to start web container: {}", e))?;
        ctx.set_data("web_container_info", web_info.clone());
        
        println!("✅ Web container started: {}", web_info.container_id);
        println!("   📍 Port mappings: {}", web_info.ports_summary());
        println!("   🔗 Primary URL: {}", web_info.primary_url().unwrap_or("None"));
        
        // Show specific port access
        if let Some(http_port) = web_info.host_port_for(80) {
            println!("   🌐 HTTP accessible at: http://localhost:{}", http_port);
        }
        if let Some(https_port) = web_info.host_port_for(443) {
            println!("   🔒 HTTPS accessible at: https://localhost:{}", https_port);
        }
        
        // Start database container
        let db_info = db_before.start()
            .map_err(|e| format!("Failed to start db container: {}", e))?;
        ctx.set_data("db_container_info", db_info.clone());
        
        println!("✅ Database container started: {}", db_info.container_id);
        println!("   📍 Port mappings: {}", db_info.ports_summary());
        if let Some(db_port) = db_info.host_port_for(5432) {
            println!("   🗄️ PostgreSQL accessible at: localhost:{}", db_port);
            println!("   📝 Connection string: postgresql://user:pass@localhost:{}/testdb", db_port);
        }
        
        // Start API container
        let api_info = api_before.start()
            .map_err(|e| format!("Failed to start api container: {}", e))?;
        ctx.set_data("api_container_info", api_info.clone());
        
        println!("✅ API container started: {}", api_info.container_id);
        println!("   📍 Port mappings: {}", api_info.ports_summary());
        
        // Show both manual and auto ports
        if let Some(http_port) = api_info.host_port_for(80) {
            println!("   🌐 HTTP API at: http://localhost:{} (manual mapping)", http_port);
        }
        if let Some(api_port) = api_info.host_port_for(9090) {
            println!("   🔧 API endpoint at: http://localhost:{} (auto-assigned)", api_port);
        }
        if let Some(metrics_port) = api_info.host_port_for(9091) {
            println!("   📊 Metrics at: http://localhost:{} (auto-assigned)", metrics_port);
        }
        
        println!("🎉 All containers started with auto-assigned ports!");
        Ok(())
    });
    
    // Cleanup containers in after_each
    let web_after = web_container.clone();
    let db_after = db_container.clone();
    let api_after = api_container.clone();
    
    after_each(move |ctx| {
        println!("🧹 after_each: Cleaning up containers...");
        
        if let Some(web_info) = ctx.get_data::<rust_test_harness::ContainerInfo>("web_container_info") {
            let _ = web_after.stop(&web_info.container_id);
            println!("🛑 Stopped web container: {}", web_info.container_id);
        }
        
        if let Some(db_info) = ctx.get_data::<rust_test_harness::ContainerInfo>("db_container_info") {
            let _ = db_after.stop(&db_info.container_id);
            println!("🛑 Stopped database container: {}", db_info.container_id);
        }
        
        if let Some(api_info) = ctx.get_data::<rust_test_harness::ContainerInfo>("api_container_info") {
            let _ = api_after.stop(&api_info.container_id);
            println!("🛑 Stopped API container: {}", api_info.container_id);
        }
        
        println!("✅ All containers cleaned up!");
        Ok(())
    });
    
    // Test 1: Web service port access
    test("test_web_service_port_access", |ctx| {
        println!("🧪 Testing web service port access...");
        
        let web_info = ctx.get_data::<rust_test_harness::ContainerInfo>("web_container_info")
            .expect("Web container info should be available");
        
        println!("🔍 Demonstrating port access methods:");
        
        // Method 1: Get specific host port for container port
        if let Some(http_port) = web_info.host_port_for(80) {
            println!("   ✅ HTTP port 80 is mapped to host port: {}", http_port);
            println!("      💡 Use this for HTTP client connections");
        }
        
        if let Some(https_port) = web_info.host_port_for(443) {
            println!("   ✅ HTTPS port 443 is mapped to host port: {}", https_port);
            println!("      💡 Use this for HTTPS client connections");
        }
        
        // Method 2: Get ready-to-use URLs
        if let Some(http_url) = web_info.url_for_port(80) {
            println!("   🔗 HTTP URL: {}", http_url);
            println!("      💡 Ready to use in HTTP requests");
        }
        
        if let Some(https_url) = web_info.url_for_port(443) {
            println!("   🔗 HTTPS URL: {}", https_url);
            println!("      💡 Ready to use in HTTPS requests (change http:// to https://)");
        }
        
        // Method 3: Get all URLs
        println!("   📋 All service URLs:");
        for (i, url) in web_info.urls.iter().enumerate() {
            println!("      {}. {}", i + 1, url);
        }
        
        // Method 4: Get all port mappings
        println!("   📊 All port mappings:");
        for (host_port, container_port) in &web_info.port_mappings {
            println!("      Host {} -> Container {}", host_port, container_port);
        }
        
        // Verify ports are different (auto-assigned)
        assert!(web_info.host_port_for(80).unwrap() != web_info.host_port_for(443).unwrap(), 
                "Auto-assigned ports should be different");
        
        println!("✅ Web service port access test passed");
        Ok(())
    });
    
    // Test 2: Database connection string generation
    test("test_database_connection_info", |ctx| {
        println!("🧪 Testing database connection info generation...");
        
        let db_info = ctx.get_data::<rust_test_harness::ContainerInfo>("db_container_info")
            .expect("Database container info should be available");
        
        println!("🗄️ Database connection information:");
        
        // Get the auto-assigned port for PostgreSQL
        let db_port = db_info.host_port_for(5432)
            .expect("PostgreSQL port should be exposed");
        
        println!("   📍 PostgreSQL running on: localhost:{}", db_port);
        
        // Generate connection strings using the auto-assigned port
        let connection_string = format!("postgresql://admin:testpass@localhost:{}/testdb", db_port);
        let jdbc_url = format!("jdbc:postgresql://localhost:{}/testdb", db_port);
        let docker_internal = format!("postgresql://admin:testpass@{}:5432/testdb", db_info.container_id);
        
        println!("   🔗 Connection strings:");
        println!("      Standard: {}", connection_string);
        println!("      JDBC: {}", jdbc_url);
        println!("      Docker internal: {}", docker_internal);
        
        // Show how to use this in real applications
        println!("   💡 Usage examples:");
        println!("      - Set DATABASE_URL={}", connection_string);
        println!("      - Use in tests: connect to localhost:{}", db_port);
        println!("      - Container-to-container: use port 5432");
        
        // Verify port is valid
        assert!(db_port > 0, "Database port should be valid");
        println!("✅ Database connection info test passed");
        
        Ok(())
    });
    
    // Test 3: Mixed port configuration
    test("test_mixed_port_configuration", |ctx| {
        println!("🧪 Testing mixed port configuration (manual + auto)...");
        
        let api_info = ctx.get_data::<rust_test_harness::ContainerInfo>("api_container_info")
            .expect("API container info should be available");
        
        println!("🔀 Mixed port configuration analysis:");
        
        // Manual port mapping
        let http_port = api_info.host_port_for(80)
            .expect("HTTP port should be mapped");
        println!("   📌 Manual mapping - HTTP port 80 -> host port: {}", http_port);
        assert_eq!(http_port, 8080, "Manual port should be exactly as specified");
        
        // Auto-assigned ports
        let api_port = api_info.host_port_for(9090)
            .expect("API port should be auto-assigned");
        let metrics_port = api_info.host_port_for(9091)
            .expect("Metrics port should be auto-assigned");
        
        println!("   🎲 Auto-assigned - API port 9090 -> host port: {}", api_port);
        println!("   🎲 Auto-assigned - Metrics port 9091 -> host port: {}", metrics_port);
        
        // Verify auto-assigned ports are different from manual port
        assert_ne!(api_port, 8080, "Auto-assigned port should be different from manual port");
        assert_ne!(metrics_port, 8080, "Auto-assigned port should be different from manual port");
        assert_ne!(api_port, metrics_port, "Auto-assigned ports should be different from each other");
        
        println!("   🌐 Service endpoints:");
        println!("      Main API: http://localhost:{}/", http_port);
        println!("      API v2: http://localhost:{}/", api_port);
        println!("      Metrics: http://localhost:{}/metrics", metrics_port);
        
        // Show complete port summary
        println!("   📋 Complete port summary: {}", api_info.ports_summary());
        
        println!("✅ Mixed port configuration test passed");
        Ok(())
    });
    
    // Test 4: Container info convenience methods
    test("test_container_info_convenience_methods", |ctx| {
        println!("🧪 Testing ContainerInfo convenience methods...");
        
        let web_info = ctx.get_data::<rust_test_harness::ContainerInfo>("web_container_info")
            .expect("Web container info should be available");
        
        println!("🔧 Testing all ContainerInfo methods:");
        
        // Test primary_url()
        if let Some(primary_url) = web_info.primary_url() {
            println!("   ✅ primary_url(): {}", primary_url);
            assert!(primary_url.starts_with("http://localhost:"), "Primary URL should be valid");
        }
        
        // Test url_for_port()
        if let Some(url_80) = web_info.url_for_port(80) {
            println!("   ✅ url_for_port(80): {}", url_80);
            assert!(url_80.contains("localhost:"), "URL should contain localhost");
        }
        
        // Test host_port_for()
        if let Some(port_80) = web_info.host_port_for(80) {
            println!("   ✅ host_port_for(80): {}", port_80);
            assert!(port_80 > 0, "Port should be positive");
        }
        
        // Test ports_summary()
        let summary = web_info.ports_summary();
        println!("   ✅ ports_summary(): {}", summary);
        assert!(summary.contains("->"), "Summary should contain port mappings");
        
        // Test direct field access
        println!("   ✅ container_id: {}", web_info.container_id);
        println!("   ✅ image: {}", web_info.image);
        println!("   ✅ auto_cleanup: {}", web_info.auto_cleanup);
        
        println!("   📊 All URLs:");
        for (i, url) in web_info.urls.iter().enumerate() {
            println!("      {}. {}", i + 1, url);
        }
        
        println!("   📊 All port mappings:");
        for (host_port, container_port) in &web_info.port_mappings {
            println!("      {} -> {}", host_port, container_port);
        }
        
        println!("✅ Container info convenience methods test passed");
        Ok(())
    });
    
    // Test 5: Real-world usage patterns
    test("test_real_world_usage_patterns", |ctx| {
        println!("🧪 Testing real-world usage patterns...");
        
        let web_info = ctx.get_data::<rust_test_harness::ContainerInfo>("web_container_info")
            .expect("Web container info should be available");
        let db_info = ctx.get_data::<rust_test_harness::ContainerInfo>("db_container_info")
            .expect("Database container info should be available");
        
        println!("🌍 Real-world usage examples:");
        
        // Pattern 1: HTTP client testing
        if let Some(web_url) = web_info.primary_url() {
            println!("   🌐 HTTP Client Testing:");
            println!("      Base URL: {}", web_url);
            println!("      GET {}/health", web_url);
            println!("      POST {}/api/users", web_url);
            println!("      Code: let response = reqwest::get(\"{}/health\").await?;", web_url);
        }
        
        // Pattern 2: Database testing
        if let Some(db_port) = db_info.host_port_for(5432) {
            println!("   🗄️ Database Testing:");
            println!("      Connection: localhost:{}", db_port);
            println!("      Code: let conn = PgConnection::establish(\"postgresql://user:pass@localhost:{}/db\")?;", db_port);
        }
        
        // Pattern 3: Environment variable setup
        println!("   🔧 Environment Variables:");
        if let Some(web_port) = web_info.host_port_for(80) {
            println!("      export WEB_SERVICE_URL=http://localhost:{}", web_port);
        }
        if let Some(db_port) = db_info.host_port_for(5432) {
            println!("      export DATABASE_URL=postgresql://localhost:{}/testdb", db_port);
        }
        
        // Pattern 4: Docker-compose style networking
        println!("   🐳 Container Networking:");
        println!("      External: Use auto-assigned host ports");
        println!("      Internal: Use original container ports");
        println!("      Web -> DB: {}:5432 (container-to-container)", db_info.container_id);
        
        // Pattern 5: Health checks
        println!("   ❤️ Health Checks:");
        if let Some(web_url) = web_info.primary_url() {
            println!("      Health endpoint: {}/health", web_url);
            println!("      Ready endpoint: {}/ready", web_url);
        }
        
        println!("✅ Real-world usage patterns test passed");
        Ok(())
    });
    
    println!("🚀 Running container port access tests...");
    println!();
    
    // Run the tests
    let config = TestConfig {
        html_report: Some("container-port-access-report.html".to_string()),
        ..Default::default()
    };
    
    let exit_code = run_tests_with_config(config);
    
    println!();
    if exit_code == 0 {
        println!("🎉 All tests passed! Port access functionality is working correctly.");
        println!("📊 Check the HTML report for detailed results.");
        println!();
        println!("💡 Key Takeaways:");
        println!("   • Use auto_port() to avoid port conflicts");
        println!("   • Access host ports with host_port_for(container_port)");
        println!("   • Get ready-to-use URLs with url_for_port(container_port)");
        println!("   • Use ports_summary() for human-readable port info");
        println!("   • ContainerInfo provides complete access to all port information");
    } else {
        println!("❌ Some tests failed. Check the output above for details.");
    }
    
    std::process::exit(exit_code);
}