refactor: add TestEnvironmentType enum and fix OpenTofu cleanup issue

- Add TestEnvironmentType enum with Container and VirtualMachine variants
- Fix Drop implementation to only cleanup OpenTofu for VirtualMachine environments
- Add warning when keep_env flag is used with Container environments
- Remove confusing --keep CLI flag from config tests since containers auto-cleanup
- Extract E2E tasks into modular functions for better code organization
- Add comprehensive task modules for container setup, SSH connectivity, and validation

This resolves the 'No such file or directory' OpenTofu warnings in Docker-based
config tests while maintaining full functionality for VM-based provision tests.

Author: josecelano

src/bin/e2e_config_tests.rs

@@ -16,9 +16,6 @@
 //! Run with custom options:
 //!
 //! ```bash
-//! # Keep test environment after completion
-//! cargo run --bin e2e-config-tests -- --keep
-//!
 //! # Use custom templates directory
 //! cargo run --bin e2e-config-tests -- --templates-dir ./custom/templates
 //!
@@ -49,32 +46,29 @@
 
 use anyhow::{Context, Result};
 use clap::Parser;
-use std::net::SocketAddr;
-use std::sync::Arc;
 use std::time::Instant;
 use tracing::{error, info};
 
-use torrust_tracker_deploy::application::commands::ConfigureCommand;
-use torrust_tracker_deploy::config::{InstanceName, SshCredentials};
-use torrust_tracker_deploy::container::Services;
-use torrust_tracker_deploy::e2e::containers::actions::{SshKeySetupAction, SshWaitAction};
-use torrust_tracker_deploy::e2e::containers::timeout::ContainerTimeouts;
-use torrust_tracker_deploy::e2e::containers::{
-    RunningProvisionedContainer, StoppedProvisionedContainer,
+use torrust_tracker_deploy::config::InstanceName;
+use torrust_tracker_deploy::e2e::environment::{TestEnvironment, TestEnvironmentType};
+use torrust_tracker_deploy::e2e::tasks::{
+    container::{
+        cleanup_docker_container::cleanup_docker_container,
+        configure_ssh_connectivity::configure_ssh_connectivity,
+        run_provision_simulation::run_provision_simulation,
+        setup_docker_container::setup_docker_container,
+    },
+    create_test_ssh_credentials::create_test_ssh_credentials,
+    preflight_cleanup,
+    run_ansible_configuration::run_ansible_configuration,
+    run_deployment_validation::run_deployment_validation,
 };
-use torrust_tracker_deploy::e2e::environment::TestEnvironment;
-use torrust_tracker_deploy::e2e::tasks::container::provision_docker_infrastructure::provision_docker_infrastructure;
-use torrust_tracker_deploy::e2e::tasks::preflight_cleanup;
 use torrust_tracker_deploy::logging::{self, LogFormat};
 
 #[derive(Parser)]
 #[command(name = "e2e-config-tests")]
 #[command(about = "E2E configuration tests for Torrust Tracker Deploy using Docker containers")]
 struct CliArgs {
-    /// Keep the test environment after completion
-    #[arg(long)]
-    keep: bool,
-
     /// Templates directory path (default: ./data/templates)
     #[arg(long, default_value = "./data/templates")]
     templates_dir: String,
@@ -126,7 +120,7 @@ pub async fn main() -> Result<()> {
         InstanceName::new("torrust-tracker-vm".to_string()).expect("Valid hardcoded instance name");
 
     // Setup test environment with preflight cleanup
-    let test_env = setup_test_environment(cli.templates_dir, instance_name)?;
+    let test_env = setup_test_environment(false, cli.templates_dir, instance_name)?;
 
     let test_result = run_configuration_tests(&test_env).await;
 
@@ -163,262 +157,51 @@ pub async fn main() -> Result<()> {
 
 /// Setup test environment with preflight cleanup
 fn setup_test_environment(
+    keep_env: bool,
     templates_dir: String,
     instance_name: InstanceName,
 ) -> Result<TestEnvironment> {
     info!("Running preflight cleanup for Docker-based E2E tests");
-    let test_env =
-        TestEnvironment::with_ssh_user_and_init(false, templates_dir, "torrust", instance_name)
-            .context("Failed to create test environment")?;
+    let test_env = TestEnvironment::with_ssh_user_and_init(
+        keep_env,
+        templates_dir,
+        "torrust",
+        instance_name,
+        TestEnvironmentType::Container,
+    )
+    .context("Failed to create test environment")?;
 
     preflight_cleanup::cleanup_lingering_resources_docker(&test_env)
         .context("Failed to complete preflight cleanup")?;
 
     Ok(test_env)
 }
 
-/// Setup Docker container and start it
-async fn setup_docker_container() -> Result<RunningProvisionedContainer> {
-    info!("Setting up Docker container");
-    let stopped_container = StoppedProvisionedContainer::default();
-    let running_container = stopped_container
-        .start()
-        .await
-        .context("Failed to start provisioned instance container")?;
-
-    Ok(running_container)
-}
-
-/// Configure SSH connectivity to the running container
-async fn configure_ssh_connectivity(
-    container: &RunningProvisionedContainer,
-    test_env: &TestEnvironment,
-) -> Result<()> {
-    let socket_addr = container.ssh_socket_addr();
-    let timeouts = ContainerTimeouts::default();
-    let ssh_wait_action = SshWaitAction::new(timeouts.ssh_ready, 10);
-    ssh_wait_action
-        .execute(socket_addr)
-        .context("SSH server failed to start")?;
-
-    // Get SSH credentials from test environment and setup keys
-    let ssh_credentials = &test_env.config.ssh_credentials;
-    let ssh_key_setup_action = SshKeySetupAction::new();
-    ssh_key_setup_action
-        .execute(container, ssh_credentials)
-        .await
-        .context("Failed to setup SSH authentication")?;
-
-    info!(
-        socket_addr = %socket_addr,
-        ssh_user = %ssh_credentials.ssh_username,
-        container_id = %container.container_id(),
-        "Container ready for Ansible configuration"
-    );
-
-    Ok(())
-}
-
-/// Run the complete configuration tests
+/// Run the complete configuration tests using extracted tasks
 async fn run_configuration_tests(test_env: &TestEnvironment) -> Result<()> {
     info!("Starting configuration tests with Docker container");
 
-    // Step 1: Setup Docker container - start with stopped state
+    // Step 1: Setup Docker container
     let running_container = setup_docker_container().await?;
+    let socket_addr = running_container.ssh_socket_addr();
 
-    // Step 2: Wait for SSH server and setup connectivity (only available when running)
-    configure_ssh_connectivity(&running_container, test_env).await?;
-
-    // Step 2.5: Run provision simulation to render Ansible templates
-    info!("Running provision simulation to prepare container configuration");
-    run_provision_simulation(running_container.ssh_socket_addr(), test_env).await?;
-
-    // Step 3: Run configuration tasks (Ansible playbooks)
-    info!("Running Ansible configuration tasks");
-    run_ansible_configuration(running_container.ssh_socket_addr(), test_env)?;
-
-    // Step 4: Validate deployment
-    info!("Validating service deployment");
-    run_deployment_validation(running_container.ssh_socket_addr(), test_env).await?;
-
-    // Step 5: Cleanup - transition back to stopped state
-    cleanup_container(running_container);
-
-    info!("Configuration tests completed successfully");
-
-    Ok(())
-}
-
-/// Cleanup container by stopping it
-fn cleanup_container(running_container: RunningProvisionedContainer) {
-    info!("Cleaning up container");
-    let _stopped_container = running_container.stop();
-    info!("Container stopped successfully");
-}
-
-/// Run provision simulation to prepare templates for container configuration
-async fn run_provision_simulation(
-    ssh_service_socket_addr: SocketAddr,
-    test_env: &TestEnvironment,
-) -> Result<()> {
-    info!(
-        socket_addr = %ssh_service_socket_addr,
-        "Running provision simulation for container"
-    );
-
-    // Create SSH credentials and use configuration from test environment
-    let ssh_credentials =
-        create_container_ssh_credentials(&test_env.config.ssh_credentials.ssh_username)?;
-    let services = Services::new(&test_env.config);
-
-    // Run the Docker infrastructure provision simulation
-    provision_docker_infrastructure(
-        Arc::clone(&services.ansible_template_renderer),
-        ssh_credentials,
-        ssh_service_socket_addr,
-    )
-    .await
-    .context("Failed to complete Docker infrastructure provision simulation")?;
-
-    info!(
-        status = "complete",
-        "Provision simulation completed - Ansible templates rendered with container details"
-    );
-
-    Ok(())
-}
-
-/// Run Ansible configuration tasks on the container
-fn run_ansible_configuration(
-    ssh_service_socket_addr: SocketAddr,
-    test_env: &TestEnvironment,
-) -> Result<()> {
-    info!(
-        socket_addr = %ssh_service_socket_addr,
-        "Running Ansible configuration on container"
-    );
-
-    // NOTE: This demonstrates the configuration workflow structure, but currently
-    // the ConfigureCommand uses LXD-based inventory that tries to connect to
-    // 10.140.190.171 instead of 127.0.0.1:mapped_port for containers.
-    //
-    // To fully implement container-based configuration, we need to:
-    // 1. Create container-specific Ansible inventory templates
-    // 2. Modify Config/Services to support container-specific templates
-    // 3. Update template rendering to use container host/port
-    //
-    // For now, we'll catch the expected connection error and log it:
-
-    let services = Services::new(&test_env.config);
-    let configure_command = ConfigureCommand::new(Arc::clone(&services.ansible_client));
-
-    match configure_command.execute().map_err(anyhow::Error::from) {
-        Ok(()) => {
-            info!(
-                status = "complete",
-                "Container configuration completed successfully"
-            );
-        }
-        Err(e) => {
-            // Expected failure due to inventory mismatch - log and return error
-            info!(
-                status = "expected_failure",
-                error = %e,
-                note = "ConfigureCommand failed as expected - needs container-specific inventory"
-            );
-            return Err(
-                e.context("Configuration failed (expected - needs container-specific inventory)")
-            );
-        }
-    }
-
-    info!(
-        status = "structural_complete",
-        "Configuration workflow structure implemented"
-    );
-
-    Ok(())
-}
-
-/// Run deployment validation tests on the container  
-async fn run_deployment_validation(
-    ssh_service_socket_addr: SocketAddr,
-    test_env: &TestEnvironment,
-) -> Result<()> {
-    info!(
-        socket_addr = %ssh_service_socket_addr,
-        "Running deployment validation on container"
-    );
-
-    // Now we can use the proper SSH infrastructure with custom port support
+    // Step 2: Configure SSH connectivity
     let ssh_credentials =
-        create_container_ssh_credentials(&test_env.config.ssh_credentials.ssh_username)
-            .context("Failed to create container SSH credentials")?;
+        create_test_ssh_credentials(&test_env.config.ssh_credentials.ssh_username)?;
+    configure_ssh_connectivity(socket_addr, &ssh_credentials, Some(&running_container)).await?;
 
-    // Create SSH connection with the container's dynamic port
-    validate_container_deployment_with_port(&ssh_credentials, ssh_service_socket_addr)
-        .await
-        .context("Container deployment validation failed")?;
+    // Step 3: Run provision simulation
+    run_provision_simulation(socket_addr, &ssh_credentials, test_env).await?;
 
-    info!(status = "success", "All deployment validations passed");
+    // Step 4: Run Ansible configuration (expect failure due to inventory mismatch)
+    run_ansible_configuration(socket_addr, test_env, false)?;
 
-    info!(
-        status = "success",
-        "Validation workflow completed successfully"
-    );
+    // Step 5: Run deployment validation
+    run_deployment_validation(socket_addr, &ssh_credentials).await?;
 
-    Ok(())
-}
-
-/// Create centralized SSH credentials for test purposes
-///
-/// Uses fixed test SSH keys from fixtures/ directory with provided username.
-/// This factory eliminates code duplication across multiple functions that need
-/// the same test SSH credentials.
-fn create_test_ssh_credentials(ssh_username: &str) -> Result<SshCredentials> {
-    let project_root = std::env::current_dir().context("Failed to get current directory")?;
-    Ok(SshCredentials::new(
-        project_root.join("fixtures/testing_rsa"),
-        project_root.join("fixtures/testing_rsa.pub"),
-        ssh_username.to_string(),
-    ))
-}
-
-/// Create SSH credentials for connecting to the container
-fn create_container_ssh_credentials(ssh_username: &str) -> Result<SshCredentials> {
-    // Use the centralized test SSH credentials factory
-    create_test_ssh_credentials(ssh_username)
-}
-
-/// Validate container deployment using SSH infrastructure with custom port
-async fn validate_container_deployment_with_port(
-    ssh_credentials: &SshCredentials,
-    socket_addr: SocketAddr,
-) -> Result<()> {
-    use torrust_tracker_deploy::infrastructure::remote_actions::{
-        DockerComposeValidator, DockerValidator, RemoteAction,
-    };
-
-    let ip_addr = socket_addr.ip();
-
-    // Create SSH connection with the container's dynamic port using the new port support
-    let ssh_connection = ssh_credentials
-        .clone()
-        .with_host_and_port(ip_addr, socket_addr.port());
-
-    // Validate Docker installation
-    let docker_validator = DockerValidator::new(ssh_connection.clone());
-    docker_validator
-        .execute(&ip_addr)
-        .await
-        .context("Docker validation failed")?;
-
-    // Validate Docker Compose installation
-    let compose_validator = DockerComposeValidator::new(ssh_connection);
-    compose_validator
-        .execute(&ip_addr)
-        .await
-        .context("Docker Compose validation failed")?;
+    // Step 6: Cleanup container
+    cleanup_docker_container(running_container);
 
+    info!("Configuration tests completed successfully");
     Ok(())
 }