step: [#220] implement UdpTrackerSection DTO

Author: josecelano

src/application/command_handlers/create/config/errors.rs

@@ -50,6 +50,16 @@ pub enum CreateConfigError {
     #[error("Invalid SSH port: {port} (must be between 1 and 65535)")]
     InvalidPort { port: u16 },
 
+    /// Invalid bind address format
+    #[error("Invalid bind address '{address}': failed to parse as IP:PORT")]
+    InvalidBindAddress {
+        /// The invalid bind address that was provided
+        address: String,
+        /// The underlying parse error
+        #[source]
+        source: std::net::AddrParseError,
+    },
+
     /// Failed to serialize configuration template to JSON
     #[error("Failed to serialize configuration template to JSON")]
     TemplateSerializationFailed {
@@ -195,6 +205,23 @@ impl CreateConfigError {
                  \n\
                  Fix: Update the SSH port in your configuration to a valid port number (1-65535)."
             }
+            Self::InvalidBindAddress { .. } => {
+                "Invalid bind address format.\n\
+                 \n\
+                 Bind addresses must be in the format IP:PORT (e.g., '0.0.0.0:8080').\n\
+                 \n\
+                 Valid examples:\n\
+                 - '0.0.0.0:6969' (bind to all interfaces on port 6969)\n\
+                 - '127.0.0.1:7070' (bind to localhost on port 7070)\n\
+                 - '[::]:1212' (bind to all IPv6 interfaces on port 1212)\n\
+                 \n\
+                 Common mistakes:\n\
+                 - Missing port number (e.g., '0.0.0.0')\n\
+                 - Invalid IP address format\n\
+                 - Port number out of range (must be 1-65535)\n\
+                 \n\
+                 Fix: Update the bind_address in your configuration to use valid IP:PORT format."
+            }
             Self::TemplateSerializationFailed { .. } => {
                 "Template serialization failed.\n\
                  \n\

src/application/command_handlers/create/config/tracker/mod.rs

@@ -3,3 +3,7 @@
 //! This module contains DTO types for tracker configuration used in
 //! environment creation. These types use raw primitives (String) for
 //! JSON deserialization and convert to rich domain types (`SocketAddr`).
+
+mod udp_tracker_section;
+
+pub use udp_tracker_section::UdpTrackerSection;

src/application/command_handlers/create/config/tracker/udp_tracker_section.rs

@@ -0,0 +1,86 @@
+use std::net::SocketAddr;
+
+use serde::{Deserialize, Serialize};
+
+use crate::application::command_handlers::create::config::errors::CreateConfigError;
+use crate::domain::tracker::UdpTrackerConfig;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct UdpTrackerSection {
+    pub bind_address: String,
+}
+
+impl UdpTrackerSection {
+    /// Converts this DTO to a domain `UdpTrackerConfig`
+    ///
+    /// # Errors
+    ///
+    /// Returns `CreateConfigError::InvalidBindAddress` if the bind address cannot be parsed as a valid IP:PORT combination.
+    pub fn to_udp_tracker_config(&self) -> Result<UdpTrackerConfig, CreateConfigError> {
+        // Validate that the bind address can be parsed as SocketAddr
+        let _bind_address = self.bind_address.parse::<SocketAddr>().map_err(|e| {
+            CreateConfigError::InvalidBindAddress {
+                address: self.bind_address.clone(),
+                source: e,
+            }
+        })?;
+
+        // For now, keep as String since domain type still uses String
+        // This will be updated in Step 0.7 when we enhance domain types
+        Ok(UdpTrackerConfig {
+            bind_address: self.bind_address.clone(),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_should_convert_valid_bind_address_to_udp_tracker_config() {
+        let section = UdpTrackerSection {
+            bind_address: "0.0.0.0:6969".to_string(),
+        };
+
+        let result = section.to_udp_tracker_config();
+        assert!(result.is_ok());
+
+        let config = result.unwrap();
+        assert_eq!(config.bind_address, "0.0.0.0:6969");
+    }
+
+    #[test]
+    fn it_should_fail_for_invalid_bind_address() {
+        let section = UdpTrackerSection {
+            bind_address: "invalid".to_string(),
+        };
+
+        let result = section.to_udp_tracker_config();
+        assert!(result.is_err());
+
+        if let Err(CreateConfigError::InvalidBindAddress { address, .. }) = result {
+            assert_eq!(address, "invalid");
+        } else {
+            panic!("Expected InvalidBindAddress error");
+        }
+    }
+
+    #[test]
+    fn it_should_be_serializable() {
+        let section = UdpTrackerSection {
+            bind_address: "0.0.0.0:6969".to_string(),
+        };
+
+        let json = serde_json::to_string(&section).unwrap();
+        assert!(json.contains("bind_address"));
+        assert!(json.contains("0.0.0.0:6969"));
+    }
+
+    #[test]
+    fn it_should_be_deserializable() {
+        let json = r#"{"bind_address":"0.0.0.0:6969"}"#;
+        let section: UdpTrackerSection = serde_json::from_str(json).unwrap();
+        assert_eq!(section.bind_address, "0.0.0.0:6969");
+    }
+}