docs: integrate Infrastructure Testing Strategies across redesign documentation

- Enhanced phase2-analysis/04-testing-strategy.md with infrastructure testing approaches
  * Infrastructure Testing-Driven Development (TDD) methodology
  * testcontainers-rs architecture for container-based testing
  * Multi-stage testing pipeline with performance targets
  * Rust async testing integration with tokio and comprehensive examples

- Enhanced phase2-analysis/02-automation-and-tooling.md with Rust testing framework
  * Comprehensive async testing with tokio (parallel execution, timeouts, resource management)
  * CLI testing integration patterns with clap and comprehensive test examples
  * Error handling strategies with anyhow/thiserror for robust testing
  * testcontainers-rs integration examples for infrastructure deployment testing

- Added container-based-testing-architecture-adr.md as architectural decision record
  * Container-based testing architecture using testcontainers-rs
  * Multi-stage testing pipeline: static validation (<30s), unit tests (<1min), container integration (1-3min), E2E (5-10min)
  * Parallel test execution strategies with tokio async capabilities
  * Comprehensive error handling patterns and 4-phase implementation strategy
  * Detailed rationale for hybrid VM+container testing approach

This integration establishes a comprehensive testing architecture foundation
combining fast container-based feedback with thorough VM-based validation,
leveraging Rust's async capabilities for optimal performance and reliability.

Author: josecelano

docs/redesign/phase2-analysis/02-automation-and-tooling.md

@@ -199,4 +199,128 @@ approach for the redesign is:
 - **Infrastructure**: OpenTofu/Terraform
 - **Configuration Management**: Ansible
 - **Services**: Docker Compose
-- **Automation**: Simplified orchestration with proper error handling
+- **Automation**: Rust-based CLI with proper error handling
+
+### Rust Testing Framework Integration
+
+For comprehensive infrastructure testing, the redesign should leverage Rust's robust
+testing ecosystem:
+
+**Async Testing with tokio**:
+
+- **Parallel Execution**: Multiple test suites run concurrently using async/await
+- **Timeout Management**: Built-in timeout handling for network operations
+- **Resource Management**: Automatic cleanup with async Drop implementations
+- **Performance**: Efficient handling of I/O-bound infrastructure operations
+
+**CLI Testing Integration**:
+
+```rust
+#[cfg(test)]
+mod cli_tests {
+    use std::process::Command;
+    use tempfile::TempDir;
+
+    #[tokio::test]
+    async fn test_deploy_command_dry_run() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+
+        // Create test configuration
+        let config = DeployConfig::test_default();
+        config.write_to_file(&config_path).await.unwrap();
+
+        // Test CLI command
+        let output = Command::new("torrust-installer")
+            .args(&["deploy", "--config", config_path.to_str().unwrap(), "--dry-run"])
+            .output()
+            .expect("Failed to execute command");
+
+        assert!(output.status.success());
+        assert!(String::from_utf8_lossy(&output.stdout).contains("Deployment plan validated"));
+    }
+
+    #[tokio::test]
+    async fn test_config_validation() {
+        let invalid_config = DeployConfig::builder()
+            .provider("invalid_provider")
+            .build();
+
+        let result = validate_config(&invalid_config).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().to_string().contains("unsupported provider"));
+    }
+}
+```
+
+**Error Handling with anyhow and thiserror**:
+
+```rust
+use anyhow::{Context, Result};
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum InfrastructureError {
+    #[error("Configuration validation failed: {message}")]
+    ConfigValidation { message: String },
+
+    #[error("Deployment failed for provider {provider}: {source}")]
+    DeploymentFailed {
+        provider: String,
+        #[source]
+        source: Box<dyn std::error::Error + Send + Sync>,
+    },
+
+    #[error("Service health check failed after {timeout_seconds}s")]
+    HealthCheckTimeout { timeout_seconds: u64 },
+}
+
+async fn deploy_infrastructure(config: &DeployConfig) -> Result<DeploymentResult> {
+    validate_prerequisites()
+        .await
+        .context("Prerequisites validation failed")?;
+
+    let provider = create_provider(&config.provider)
+        .await
+        .context("Failed to initialize cloud provider")?;
+
+    provider.deploy(config)
+        .await
+        .context("Infrastructure deployment failed")?;
+
+    wait_for_services(&config.services)
+        .await
+        .context("Service startup validation failed")?;
+
+    Ok(DeploymentResult::Success)
+}
+```
+
+**Integration with testcontainers-rs**:
+
+The Rust CLI can integrate seamlessly with container-based testing:
+
+```rust
+#[tokio::test]
+async fn test_infrastructure_deployment_integration() {
+    let docker = testcontainers::clients::Cli::default();
+
+    // Start test infrastructure
+    let mysql = docker.run(testcontainers_modules::mysql::Mysql::default());
+    let nginx = docker.run(testcontainers_modules::nginx::Nginx::default());
+
+    // Create test configuration pointing to containers
+    let config = DeployConfig::builder()
+        .database_url(format!("mysql://root@localhost:{}/test", mysql.get_host_port_ipv4(3306)))
+        .proxy_host(format!("localhost:{}", nginx.get_host_port_ipv4(80)))
+        .build();
+
+    // Test deployment against containerized services
+    let result = deploy_services(&config).await;
+    assert!(result.is_ok());
+
+    // Validate service integration
+    let health_result = check_service_health(&config).await;
+    assert!(health_result.is_ok());
+}
+```

docs/redesign/phase2-analysis/04-testing-strategy.md

@@ -110,7 +110,7 @@ CI/CD friction:
 ### Recommended: Container-First Testing Approach
 
 The redesign should prioritize Docker-based testing strategies that eliminate VM dependencies
-for most test scenarios:
+for most test scenarios, implementing comprehensive infrastructure testing with modern approaches:
 
 **Container Testing Benefits**:
 
@@ -120,28 +120,151 @@ for most test scenarios:
 4. **Reproducibility**: Consistent environment across local and CI systems
 5. **Debugging**: Direct access to application logs and state
 
+### Infrastructure Testing-Driven Development (TDD)
+
+Following Test-Driven Development principles for infrastructure provides:
+
+**TDD Infrastructure Benefits**:
+
+- **Early Error Detection**: Catch configuration issues before deployment
+- **Regression Prevention**: Automated tests prevent breaking changes
+- **Documentation**: Tests serve as living documentation of expected behavior
+- **Confidence**: Reliable automated validation enables fearless refactoring
+
+**TDD Implementation Strategy**:
+
+1. **Write Test First**: Define expected infrastructure behavior before implementation
+2. **Implement Minimal Code**: Create infrastructure code that makes the test pass
+3. **Refactor with Confidence**: Improve code while maintaining test coverage
+4. **Continuous Validation**: Run tests on every change to prevent regressions
+
+### Container-Based Testing with testcontainers-rs
+
+The Rust ecosystem provides `testcontainers-rs` for sophisticated container-based testing:
+
+**testcontainers-rs Capabilities**:
+
+- **Multi-Service Orchestration**: Start complex service dependencies in containers
+- **Network Isolation**: Each test gets isolated network environments
+- **Lifecycle Management**: Automatic container cleanup after test completion
+- **Real Service Testing**: Use actual database engines, message queues, web servers
+- **Parallel Execution**: Multiple test suites run simultaneously without conflicts
+
+**Infrastructure Testing Architecture**:
+
+```rust
+#[cfg(test)]
+mod infrastructure_tests {
+    use testcontainers::*;
+    use testcontainers_modules::{mysql::Mysql, nginx::Nginx};
+
+    #[tokio::test]
+    async fn test_mysql_tracker_integration() {
+        let docker = clients::Cli::default();
+        let mysql_container = docker.run(Mysql::default());
+
+        // Test database schema creation
+        let db_config = create_test_database_config(&mysql_container);
+        let schema_result = apply_tracker_schema(&db_config).await;
+        assert!(schema_result.is_ok());
+
+        // Test tracker database operations
+        let tracker = TrackerInstance::new(db_config);
+        let announce_result = tracker.handle_announce(test_announce()).await;
+        assert!(announce_result.is_ok());
+    }
+}
+```
+
 ### Three-Layer Testing Architecture (Enhanced)
 
 #### Layer 1: Unit Tests (Container-Based)
 
 - **Scope**: Individual component testing in isolated containers
-- **Tools**: pytest, jest, cargo test, etc.
+- **Tools**: pytest, jest, cargo test, testcontainers-rs
 - **Execution**: Seconds, runs on every commit
 - **Environment**: Docker containers with minimal dependencies
+- **TDD Integration**: Write failing tests before implementing features
 
 #### Layer 2: Integration Tests (Container-Based)
 
-- **Scope**: Multi-service testing with Docker Compose
-- **Tools**: Docker Compose, Testcontainers, pytest-docker
+- **Scope**: Multi-service testing with Docker Compose and testcontainers
+- **Tools**: Docker Compose, testcontainers-rs, Rust async testing framework
 - **Execution**: 1-3 minutes, runs on every commit
-- **Environment**: Full application stack in containers
+- **Environment**: Full application stack in containers with realistic data
+- **Service Dependencies**: Real MySQL, Redis, Nginx instances in containers
 
 #### Layer 3: E2E Tests (Minimal VM Usage)
 
 - **Scope**: Full deployment validation (reserved for critical scenarios)
 - **Tools**: Terraform + cloud providers for real infrastructure testing
 - **Execution**: 5-10 minutes, runs on PR merge or nightly
 - **Environment**: Actual cloud infrastructure (staging environments)
+- **Production Parity**: Test actual deployment procedures and networking
+
+### Multi-Stage Testing Pipeline
+
+**Static Validation (< 1 minute)**:
+
+```bash
+# Syntax validation
+cargo check --all
+terraform validate
+yamllint **/*.yml
+
+# Security scanning
+cargo audit
+terraform plan -detailed-exitcode
+```
+
+**Unit Testing (< 2 minutes)**:
+
+```rust
+// Infrastructure unit tests
+#[tokio::test]
+async fn test_tracker_config_generation() {
+    let config = TrackerConfig::builder()
+        .database_url("mysql://test:test@localhost/tracker")
+        .build()
+        .expect("Valid configuration");
+
+    let rendered = config.render_template().await?;
+    assert!(rendered.contains("mysql://test:test@localhost/tracker"));
+}
+```
+
+**Container Integration Testing (2-5 minutes)**:
+
+```rust
+#[tokio::test]
+async fn test_full_tracker_stack() {
+    let docker = clients::Cli::default();
+
+    // Start dependencies
+    let mysql = docker.run(Mysql::default());
+    let nginx = docker.run(Nginx::default());
+
+    // Test complete tracker deployment
+    let stack = TrackerStack::new()
+        .with_database(&mysql)
+        .with_proxy(&nginx)
+        .deploy().await?;
+
+    // Verify service health
+    assert!(stack.health_check().await.is_ok());
+
+    // Test tracker protocol
+    let announce = stack.udp_announce(test_torrent_hash()).await?;
+    assert_eq!(announce.peers.len(), 0); // Empty tracker
+}
+```
+
+**E2E Testing (5-10 minutes)**:
+
+- Cloud provider integration tests
+- Network security validation
+- Performance benchmarking
+- Multi-region deployment testing
 
 ### Implementation Strategy