refactor: [#232] Split EnvContext into service-specific types

- Create TrackerServiceConfig and MySqlServiceConfig types to mirror .env template structure
- Update .env.tera template to use nested variable syntax (e.g., {{ tracker.api_admin_token }}, {{ mysql.root_password }})
- Add backward-compatible getter methods on EnvContext for existing code
- Update all template tests to use new nested variable syntax
- Add comprehensive tests for context serialization and MySQL configuration
- Benefits: Better separation of concerns, more maintainable code, clearer template variable organization

Author: josecelano

src/infrastructure/templating/docker_compose/template/renderer/env.rs

@@ -218,7 +218,7 @@ mod tests {
 TORRUST_TRACKER_CONFIG_TOML_PATH=/etc/torrust/tracker/tracker.toml
 
 # Override the admin token for the tracker HTTP API
-TORRUST_TRACKER_CONFIG_OVERRIDE_HTTP_API__ACCESS_TOKENS__ADMIN={{ tracker_api_admin_token }}
+TORRUST_TRACKER_CONFIG_OVERRIDE_HTTP_API__ACCESS_TOKENS__ADMIN={{ tracker.api_admin_token }}
 ";
 
         fs::write(docker_compose_dir.join(".env.tera"), template_content)?;

src/infrastructure/templating/docker_compose/template/wrappers/env/context.rs

@@ -2,31 +2,52 @@
 //!
 //! This module defines the structure and validation for environment variables
 //! that will be rendered into the .env file for Docker Compose.
+//!
+//! The context is organized by service to mirror the structure of the .env template:
+//! - Tracker service configuration
+//! - `MySQL` service configuration (optional)
 
 use serde::Serialize;
 
-/// Context for rendering the .env template
+/// Configuration for the Tracker service
 ///
-/// Contains all variables needed for the Docker Compose environment configuration.
+/// Contains environment variables for the Torrust Tracker container.
 #[derive(Serialize, Debug, Clone)]
-pub struct EnvContext {
+pub struct TrackerServiceConfig {
     /// The admin token for the Torrust Tracker HTTP API
-    tracker_api_admin_token: String,
+    pub api_admin_token: String,
     /// Database driver type ("sqlite3" or "mysql")
     /// Controls which config template the container entrypoint uses
-    database_driver: String,
-    /// `MySQL` root password (only used when `MySQL` driver is configured)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    mysql_root_password: Option<String>,
-    /// `MySQL` database name (only used when `MySQL` driver is configured)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    mysql_database: Option<String>,
-    /// `MySQL` user (only used when `MySQL` driver is configured)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    mysql_user: Option<String>,
-    /// `MySQL` password (only used when `MySQL` driver is configured)
+    pub database_driver: String,
+}
+
+/// Configuration for the `MySQL` service
+///
+/// Contains environment variables for the `MySQL` container.
+/// Only included when `MySQL` driver is configured.
+#[derive(Serialize, Debug, Clone)]
+pub struct MySqlServiceConfig {
+    /// `MySQL` root password
+    pub root_password: String,
+    /// `MySQL` database name
+    pub database: String,
+    /// `MySQL` user
+    pub user: String,
+    /// `MySQL` password
+    pub password: String,
+}
+
+/// Context for rendering the .env template
+///
+/// Contains all variables needed for the Docker Compose environment configuration,
+/// organized by service to mirror the template structure.
+#[derive(Serialize, Debug, Clone)]
+pub struct EnvContext {
+    /// Tracker service configuration
+    pub tracker: TrackerServiceConfig,
+    /// `MySQL` service configuration (only present when `MySQL` driver is configured)
     #[serde(skip_serializing_if = "Option::is_none")]
-    mysql_password: Option<String>,
+    pub mysql: Option<MySqlServiceConfig>,
 }
 
 impl EnvContext {
@@ -42,19 +63,21 @@ impl EnvContext {
     /// use torrust_tracker_deployer_lib::infrastructure::templating::docker_compose::template::wrappers::env::EnvContext;
     ///
     /// let context = EnvContext::new("MySecretToken123".to_string());
-    /// assert_eq!(context.tracker_api_admin_token(), "MySecretToken123");
+    /// assert_eq!(context.tracker.api_admin_token, "MySecretToken123");
+    /// assert_eq!(context.tracker.database_driver, "sqlite3");
+    /// assert!(context.mysql.is_none());
     /// ```
     #[must_use]
     pub fn new(tracker_api_admin_token: String) -> Self {
         Self {
-            tracker_api_admin_token,
-            database_driver: "sqlite3".to_string(),
-            mysql_root_password: None,
-            mysql_database: None,
-            mysql_user: None,
-            mysql_password: None,
+            tracker: TrackerServiceConfig {
+                api_admin_token: tracker_api_admin_token,
+                database_driver: "sqlite3".to_string(),
+            },
+            mysql: None,
         }
     }
+
     /// Creates a new `EnvContext` with `MySQL` credentials
     ///
     /// # Arguments
@@ -64,6 +87,22 @@ impl EnvContext {
     /// * `mysql_database` - `MySQL` database name
     /// * `mysql_user` - `MySQL` user
     /// * `mysql_password` - `MySQL` password
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use torrust_tracker_deployer_lib::infrastructure::templating::docker_compose::template::wrappers::env::EnvContext;
+    ///
+    /// let context = EnvContext::new_with_mysql(
+    ///     "MySecretToken123".to_string(),
+    ///     "root_pass".to_string(),
+    ///     "tracker_db".to_string(),
+    ///     "tracker_user".to_string(),
+    ///     "user_pass".to_string(),
+    /// );
+    /// assert_eq!(context.tracker.database_driver, "mysql");
+    /// assert!(context.mysql.is_some());
+    /// ```
     #[must_use]
     pub fn new_with_mysql(
         tracker_api_admin_token: String,
@@ -73,43 +112,53 @@ impl EnvContext {
         mysql_password: String,
     ) -> Self {
         Self {
-            tracker_api_admin_token,
-            database_driver: "mysql".to_string(),
-            mysql_root_password: Some(mysql_root_password),
-            mysql_database: Some(mysql_database),
-            mysql_user: Some(mysql_user),
-            mysql_password: Some(mysql_password),
+            tracker: TrackerServiceConfig {
+                api_admin_token: tracker_api_admin_token,
+                database_driver: "mysql".to_string(),
+            },
+            mysql: Some(MySqlServiceConfig {
+                root_password: mysql_root_password,
+                database: mysql_database,
+                user: mysql_user,
+                password: mysql_password,
+            }),
         }
     }
 
     /// Get the tracker API admin token
     #[must_use]
     pub fn tracker_api_admin_token(&self) -> &str {
-        &self.tracker_api_admin_token
+        &self.tracker.api_admin_token
+    }
+
+    /// Get the database driver type
+    #[must_use]
+    pub fn database_driver(&self) -> &str {
+        &self.tracker.database_driver
     }
 
     /// Get the `MySQL` root password (if configured)
     #[must_use]
     pub fn mysql_root_password(&self) -> Option<&str> {
-        self.mysql_root_password.as_deref()
+        self.mysql.as_ref().map(|m| m.root_password.as_str())
     }
 
     /// Get the `MySQL` database name (if configured)
     #[must_use]
     pub fn mysql_database(&self) -> Option<&str> {
-        self.mysql_database.as_deref()
+        self.mysql.as_ref().map(|m| m.database.as_str())
     }
 
     /// Get the `MySQL` user (if configured)
     #[must_use]
     pub fn mysql_user(&self) -> Option<&str> {
-        self.mysql_user.as_deref()
+        self.mysql.as_ref().map(|m| m.user.as_str())
     }
 
     /// Get the `MySQL` password (if configured)
     #[must_use]
     pub fn mysql_password(&self) -> Option<&str> {
-        self.mysql_password.as_deref()
+        self.mysql.as_ref().map(|m| m.password.as_str())
     }
 }
 
@@ -122,7 +171,30 @@ mod tests {
         let token = "TestToken123".to_string();
         let context = EnvContext::new(token.clone());
 
-        assert_eq!(context.tracker_api_admin_token(), "TestToken123");
+        assert_eq!(context.tracker.api_admin_token, "TestToken123");
+        assert_eq!(context.tracker.database_driver, "sqlite3");
+        assert!(context.mysql.is_none());
+    }
+
+    #[test]
+    fn it_should_create_context_with_mysql_configuration() {
+        let context = EnvContext::new_with_mysql(
+            "AdminToken456".to_string(),
+            "root_pass".to_string(),
+            "tracker_db".to_string(),
+            "tracker_user".to_string(),
+            "user_pass".to_string(),
+        );
+
+        assert_eq!(context.tracker.api_admin_token, "AdminToken456");
+        assert_eq!(context.tracker.database_driver, "mysql");
+        assert!(context.mysql.is_some());
+
+        let mysql_config = context.mysql.as_ref().unwrap();
+        assert_eq!(mysql_config.root_password, "root_pass");
+        assert_eq!(mysql_config.database, "tracker_db");
+        assert_eq!(mysql_config.user, "tracker_user");
+        assert_eq!(mysql_config.password, "user_pass");
     }
 
     #[test]
@@ -131,7 +203,51 @@ mod tests {
 
         // Verify it can be serialized (needed for Tera template rendering)
         let serialized = serde_json::to_string(&context).unwrap();
-        assert!(serialized.contains("tracker_api_admin_token"));
+        assert!(serialized.contains("tracker"));
+        assert!(serialized.contains("api_admin_token"));
         assert!(serialized.contains("AdminToken456"));
     }
+
+    #[test]
+    fn it_should_serialize_mysql_config_when_present() {
+        let context = EnvContext::new_with_mysql(
+            "Token123".to_string(),
+            "root".to_string(),
+            "db".to_string(),
+            "user".to_string(),
+            "pass".to_string(),
+        );
+
+        let serialized = serde_json::to_string(&context).unwrap();
+        assert!(serialized.contains("mysql"));
+        assert!(serialized.contains("root_password"));
+    }
+
+    #[test]
+    fn it_should_not_serialize_mysql_config_when_absent() {
+        let context = EnvContext::new("Token123".to_string());
+
+        let serialized = serde_json::to_string(&context).unwrap();
+        // MySQL section should not be present when None
+        assert!(!serialized.contains("mysql"));
+    }
+
+    #[test]
+    fn it_should_provide_backward_compatible_getters() {
+        let context = EnvContext::new_with_mysql(
+            "Token123".to_string(),
+            "root_pass".to_string(),
+            "tracker_db".to_string(),
+            "tracker_user".to_string(),
+            "user_pass".to_string(),
+        );
+
+        // Backward compatible getter methods
+        assert_eq!(context.tracker_api_admin_token(), "Token123");
+        assert_eq!(context.database_driver(), "mysql");
+        assert_eq!(context.mysql_root_password(), Some("root_pass"));
+        assert_eq!(context.mysql_database(), Some("tracker_db"));
+        assert_eq!(context.mysql_user(), Some("tracker_user"));
+        assert_eq!(context.mysql_password(), Some("user_pass"));
+    }
 }

src/infrastructure/templating/docker_compose/template/wrappers/env/template.rs

@@ -85,7 +85,7 @@ mod tests {
 
     #[test]
     fn it_should_create_env_template_successfully() {
-        let template_content = "TORRUST_TRACKER_CONFIG_OVERRIDE_HTTP_API__ACCESS_TOKENS__ADMIN={{ tracker_api_admin_token }}\n";
+        let template_content = "TORRUST_TRACKER_CONFIG_OVERRIDE_HTTP_API__ACCESS_TOKENS__ADMIN={{ tracker.api_admin_token }}\n";
 
         let template_file = File::new(".env.tera", template_content.to_string()).unwrap();
 
@@ -97,7 +97,7 @@ mod tests {
 
     #[test]
     fn it_should_render_template_with_substituted_variables() {
-        let template_content = "TOKEN={{ tracker_api_admin_token }}\n";
+        let template_content = "TOKEN={{ tracker.api_admin_token }}\n";
 
         let template_file = File::new(".env.tera", template_content.to_string()).unwrap();
 
@@ -141,7 +141,7 @@ mod tests {
     fn it_should_render_to_file() {
         use tempfile::TempDir;
 
-        let template_content = "ADMIN_TOKEN={{ tracker_api_admin_token }}\n";
+        let template_content = "ADMIN_TOKEN={{ tracker.api_admin_token }}\n";
         let template_file = File::new(".env.tera", template_content.to_string()).unwrap();
 
         let env_context = EnvContext::new("FileTestToken".to_string());

templates/docker-compose/.env.tera

@@ -11,20 +11,20 @@ TORRUST_TRACKER_CONFIG_TOML_PATH='/etc/torrust/tracker/tracker.toml'
 # Database driver type - tells the container entrypoint which config template to use
 # Must match the driver specified in tracker.toml
 # Uses standardized TORRUST_TRACKER_CONFIG_OVERRIDE_* naming convention
-TORRUST_TRACKER_CONFIG_OVERRIDE_CORE__DATABASE__DRIVER='{{ database_driver }}'
+TORRUST_TRACKER_CONFIG_OVERRIDE_CORE__DATABASE__DRIVER='{{ tracker.database_driver }}'
 
 # Admin API token for tracker HTTP API access
 # This overrides the admin token in the tracker configuration file
-TORRUST_TRACKER_CONFIG_OVERRIDE_HTTP_API__ACCESS_TOKENS__ADMIN='{{ tracker_api_admin_token }}'
+TORRUST_TRACKER_CONFIG_OVERRIDE_HTTP_API__ACCESS_TOKENS__ADMIN='{{ tracker.api_admin_token }}'
 
-{% if database_driver == "mysql" %}
+{% if mysql %}
 # =============================================================================
 # MySQL Service Configuration
 # =============================================================================
 
 # These variables are only needed when MySQL driver is configured
-MYSQL_ROOT_PASSWORD='{{ mysql_root_password }}'
-MYSQL_DATABASE='{{ mysql_database }}'
-MYSQL_USER='{{ mysql_user }}'
-MYSQL_PASSWORD='{{ mysql_password }}'
+MYSQL_ROOT_PASSWORD='{{ mysql.root_password }}'
+MYSQL_DATABASE='{{ mysql.database }}'
+MYSQL_USER='{{ mysql.user }}'
+MYSQL_PASSWORD='{{ mysql.password }}'
 {% endif %}