refactor: [#220] make E2eConfigEnvironment single source of truth for E2E test configuration

- Add E2eConfigEnvironment::new() constructor for direct instantiation
- Add E2eConfigEnvironment::to_json_config() to generate JSON from struct values
- Implement Default trait for TrackerPorts (instead of custom method)
- Refactor build_e2e_test_config() to build struct in-memory without file I/O
- Add write_environment_config() helper to separate file writing from struct creation
- Move config file writing to run_deployer_workflow() where it's actually needed
- Rename generate_environment_config_with_port() to build_e2e_test_config() for clarity

Benefits:
- E2eConfigEnvironment is now the authoritative source, not the file
- Better testability: can work with config in-memory without file I/O
- Clearer data flow: build struct → use it → write file when needed
- Configuration values come from struct, not hardcoded defaults
- Function name clearly indicates E2E scope without misleading port parameter

Author: josecelano

src/bin/e2e_config_and_release_tests.rs

@@ -73,8 +73,8 @@ use torrust_tracker_deployer_lib::testing::e2e::containers::{
     RunningProvisionedContainer, StoppedProvisionedContainer,
 };
 use torrust_tracker_deployer_lib::testing::e2e::tasks::black_box::{
-    generate_environment_config_with_port, run_container_preflight_cleanup,
-    verify_required_dependencies, E2eTestRunner,
+    build_e2e_test_config, run_container_preflight_cleanup, verify_required_dependencies,
+    write_environment_config, E2eTestRunner,
 };
 use torrust_tracker_deployer_lib::testing::e2e::tasks::container::cleanup_infrastructure::stop_test_infrastructure;
 use torrust_tracker_deployer_lib::testing::e2e::tasks::run_configuration_validation::run_configuration_validation;
@@ -213,20 +213,25 @@ async fn run_configure_release_run_tests() -> Result<()> {
     // Build SSH credentials
     let ssh_credentials = build_test_ssh_credentials();
 
-    // Step 1: Generate environment configuration
-    // This returns configuration with desired ports from environment.json
-    let config_env = generate_environment_config_with_port(ENVIRONMENT_NAME)?;
+    // Step 1: Build E2E test configuration in-memory
+    // This creates the configuration structure without file I/O
+    let config_env = build_e2e_test_config(ENVIRONMENT_NAME);
 
     // Step 2: Create and start Docker container
     // With bridge networking, Docker assigns random mapped ports
     // Returns runtime environment with both config and actual mapped ports
     let (runtime_env, running_container) = create_and_start_container(&config_env).await?;
 
     // Get SSH socket address from runtime environment (using actual mapped port)
-    let socket_addr = runtime_env.ssh_socket_addr();
+    let ssh_socket_address = runtime_env.ssh_socket_addr();
 
     // Step 3: Establish SSH connectivity using the mapped SSH port
-    establish_ssh_connectivity(socket_addr, &ssh_credentials, Some(&running_container)).await?;
+    establish_ssh_connectivity(
+        ssh_socket_address,
+        &ssh_credentials,
+        Some(&running_container),
+    )
+    .await?;
 
     // Step 4: Run deployer commands (black-box via CLI)
     let test_result = run_deployer_workflow(&config_env, &runtime_env, &ssh_credentials).await;
@@ -253,6 +258,9 @@ async fn run_deployer_workflow(
 ) -> Result<()> {
     let test_runner = E2eTestRunner::new(ENVIRONMENT_NAME);
 
+    // Write environment configuration to disk (needed by create command)
+    write_environment_config(config_env)?;
+
     // Create environment (CLI: cargo run -- create environment --env-file <file>)
     test_runner.create_environment(&config_env.config_file_path)?;
 

src/testing/e2e/containers/tracker_ports.rs

@@ -26,6 +26,90 @@ pub struct E2eConfigEnvironment {
 }
 
 impl E2eConfigEnvironment {
+    /// Create E2E config environment directly from values
+    ///
+    /// This is the primary constructor that builds the configuration in-memory
+    /// without requiring file I/O. Use this when you want to work with the
+    /// configuration before writing it to disk.
+    ///
+    /// # Arguments
+    /// * `environment_name` - Name of the environment
+    /// * `config_file_path` - Path where config will be written (if needed)
+    /// * `ssh_port` - SSH port to use
+    /// * `tracker_ports` - Tracker port configuration
+    #[must_use]
+    pub fn new(
+        environment_name: String,
+        config_file_path: PathBuf,
+        ssh_port: u16,
+        tracker_ports: TrackerPorts,
+    ) -> Self {
+        Self {
+            environment_name,
+            config_file_path,
+            ssh_port,
+            tracker_ports,
+        }
+    }
+
+    /// Generate JSON configuration string from this E2E environment
+    ///
+    /// Creates a complete environment configuration JSON using the values
+    /// from this struct, with absolute paths to SSH keys.
+    ///
+    /// # Returns
+    ///
+    /// Returns a JSON string ready to be written to the environment config file.
+    ///
+    /// # Example
+    ///
+    /// ```rust,ignore
+    /// let env_info = E2eConfigEnvironment::new(...);
+    /// let json = env_info.to_json_config();
+    /// ```
+    #[must_use]
+    pub fn to_json_config(&self) -> String {
+        // Use compile-time constant to get project root - more reliable than current_dir()
+        let project_root = env!("CARGO_MANIFEST_DIR");
+        let private_key_path = format!("{project_root}/fixtures/testing_rsa");
+        let public_key_path = format!("{project_root}/fixtures/testing_rsa.pub");
+
+        // Create configuration JSON with absolute paths and tracker configuration
+        // This must match the format expected by EnvironmentCreationConfig
+        serde_json::json!({
+            "environment": {
+                "name": &self.environment_name
+            },
+            "ssh_credentials": {
+                "private_key_path": private_key_path,
+                "public_key_path": public_key_path
+            },
+            "provider": {
+                "provider": "lxd",
+                "profile_name": format!("torrust-profile-{}", &self.environment_name)
+            },
+            "tracker": {
+                "core": {
+                    "database": {
+                        "driver": "sqlite3",
+                        "database_name": "tracker.db"
+                    },
+                    "private": false
+                },
+                "udp_trackers": [
+                    {"bind_address": format!("0.0.0.0:{}", self.tracker_ports.udp_tracker_port)}
+                ],
+                "http_trackers": [
+                    {"bind_address": format!("0.0.0.0:{}", self.tracker_ports.http_tracker_port)}
+                ],
+                "http_api": {
+                    "admin_token": "MyAccessToken"
+                }
+            }
+        })
+        .to_string()
+    }
+
     /// Create E2E config environment from configuration file
     ///
     /// # Arguments
@@ -162,6 +246,22 @@ pub struct TrackerPorts {
     pub udp_tracker_port: u16,
 }
 
+impl Default for TrackerPorts {
+    /// Create tracker ports with default values
+    ///
+    /// Default ports match the standard test configuration:
+    /// - HTTP API: 1212
+    /// - HTTP tracker: 7070
+    /// - UDP tracker: 6969
+    fn default() -> Self {
+        Self {
+            http_api_port: 1212,
+            http_tracker_port: 7070,
+            udp_tracker_port: 6969,
+        }
+    }
+}
+
 impl TrackerPorts {
     /// Extract tracker ports from an environment configuration JSON file
     ///

src/testing/e2e/tasks/black_box/generate_config.rs

@@ -46,16 +46,20 @@ use crate::testing::e2e::containers::E2eEnvironmentInfo;
 /// let config_path = generate_environment_config("e2e-full")?;
 /// ```
 pub fn generate_environment_config(environment_name: &str) -> Result<PathBuf> {
-    let env_info = generate_environment_config_with_port(environment_name)?;
+    let env_info = build_e2e_test_config(environment_name);
+    write_environment_config(&env_info)?;
     Ok(env_info.config_file_path)
 }
 
-/// Generates the environment configuration file with absolute SSH key paths.
+/// Generates E2E environment configuration in-memory
 ///
 /// Creates a complete E2E environment configuration including tracker ports,
 /// SSH credentials, and provider settings. With host networking, the SSH port
 /// is defined in the configuration and remains the same inside and outside the container.
 ///
+/// This function builds the configuration structure directly without file I/O.
+/// Use `write_environment_config()` to persist the configuration to disk when needed.
+///
 /// # Arguments
 ///
 /// * `environment_name` - The name of the environment to create
@@ -64,49 +68,94 @@ pub fn generate_environment_config(environment_name: &str) -> Result<PathBuf> {
 ///
 /// Returns `E2eEnvironmentInfo` containing all necessary information for E2E testing:
 /// - Environment name
-/// - Path to the generated configuration file
-/// - SSH port (extracted from tracker configuration)
-/// - Tracker ports (extracted from tracker configuration)
+/// - Path where config should be written (if needed)
+/// - SSH port (22 - default for test containers)
+/// - Tracker ports (default test configuration)
 ///
-/// # Errors
+/// # Panics
 ///
-/// Returns an error if the configuration file cannot be created.
+/// Panics if the current working directory cannot be determined (should never happen in normal operation).
 ///
 /// # Example
 ///
 /// ```rust,ignore
-/// use torrust_tracker_deployer_lib::testing::e2e::tasks::black_box::generate_environment_config_with_port;
+/// use torrust_tracker_deployer_lib::testing::e2e::tasks::black_box::build_e2e_test_config;
 ///
-/// let env_info = generate_environment_config_with_port("e2e-config")?;
+/// let env_info = build_e2e_test_config("e2e-config");
 /// let socket_addr = env_info.ssh_socket_addr();
 /// ```
-pub fn generate_environment_config_with_port(environment_name: &str) -> Result<E2eEnvironmentInfo> {
-    use std::fs;
-
-    let project_root = std::env::current_dir()
-        .map_err(|e| anyhow::anyhow!("Failed to get current directory: {e}"))?;
+#[must_use]
+pub fn build_e2e_test_config(environment_name: &str) -> E2eEnvironmentInfo {
+    use crate::testing::e2e::containers::TrackerPorts;
 
-    let config_json = create_test_environment_config(environment_name);
+    let project_root = std::env::current_dir().expect("Failed to get current directory");
 
-    // Write to envs directory
     let config_path = project_root.join(format!("envs/{environment_name}.json"));
 
+    // Build E2eConfigEnvironment directly with default test values
+    let ssh_port = 22; // Default SSH port for test containers
+    let tracker_ports = TrackerPorts::default();
+
+    info!(
+        environment_name = %environment_name,
+        ssh_port = %ssh_port,
+        "Generated E2E environment configuration in-memory"
+    );
+
+    E2eEnvironmentInfo::new(
+        environment_name.to_string(),
+        config_path,
+        ssh_port,
+        tracker_ports,
+    )
+}
+
+/// Writes E2E environment configuration to disk
+///
+/// Creates the configuration JSON file with absolute SSH key paths,
+/// ensuring the environment can be used by CLI commands.
+///
+/// # Arguments
+///
+/// * `config_env` - The E2E configuration to write
+///
+/// # Errors
+///
+/// Returns an error if:
+/// - Configuration directory cannot be created
+/// - Configuration file cannot be written
+///
+/// # Example
+///
+/// ```rust,ignore
+/// use torrust_tracker_deployer_lib::testing::e2e::tasks::black_box::{
+///     build_e2e_test_config,
+///     write_environment_config,
+/// };
+///
+/// let env_info = build_e2e_test_config("e2e-config");
+/// write_environment_config(&env_info)?;
+/// ```
+pub fn write_environment_config(config_env: &E2eEnvironmentInfo) -> Result<()> {
+    use std::fs;
+
+    let config_json = config_env.to_json_config();
+
     // Ensure parent directory exists
-    if let Some(parent) = config_path.parent() {
+    if let Some(parent) = config_env.config_file_path.parent() {
         fs::create_dir_all(parent)
             .map_err(|e| anyhow::anyhow!("Failed to create config directory: {e}"))?;
     }
 
-    fs::write(&config_path, config_json)
+    fs::write(&config_env.config_file_path, config_json)
         .map_err(|e| anyhow::anyhow!("Failed to write config file: {e}"))?;
 
     info!(
-        config_path = %config_path.display(),
-        "Generated environment configuration"
+        config_path = %config_env.config_file_path.display(),
+        "Wrote environment configuration to disk"
     );
 
-    // Create E2eEnvironmentInfo from the generated config
-    E2eEnvironmentInfo::from_config_file(environment_name.to_string(), config_path, None)
+    Ok(())
 }
 
 /// Creates a test environment configuration with absolute SSH key paths

src/testing/e2e/tasks/black_box/mod.rs

@@ -51,8 +51,8 @@ pub use test_runner::E2eTestRunner;
 
 // Re-export standalone setup functions
 pub use generate_config::{
-    create_test_environment_config, generate_environment_config,
-    generate_environment_config_with_port,
+    build_e2e_test_config, create_test_environment_config, generate_environment_config,
+    write_environment_config,
 };
 pub use preflight_cleanup::run_container_preflight_cleanup;
 pub use preflight_cleanup::run_preflight_cleanup;