refactor: [#255] extract tracker config types into submodules

- Convert config.rs into folder module (config/)
- Extract TrackerCoreConfig → config/core.rs (2 tests)
- Extract UdpTrackerConfig → config/udp.rs (3 tests)
- Extract HttpTrackerConfig → config/http.rs (3 tests)
- Extract HttpApiConfig → config/http_api.rs (3 tests)
- Extract HealthCheckApiConfig → config/health_check_api.rs (3 tests)
- Keep TrackerConfig in config/mod.rs (3 integration tests)
- Improve code organization and maintainability
- All 1582 tests passing

Author: josecelano

src/domain/tracker/config/core.rs

@@ -0,0 +1,47 @@
+//! Core tracker configuration
+
+use serde::{Deserialize, Serialize};
+
+use crate::domain::tracker::DatabaseConfig;
+
+/// Core tracker configuration options
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct TrackerCoreConfig {
+    /// Database configuration (`SQLite`, `MySQL`, etc.)
+    pub database: DatabaseConfig,
+
+    /// Tracker mode: true for private tracker, false for public
+    pub private: bool,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::domain::tracker::{DatabaseConfig, SqliteConfig};
+
+    #[test]
+    fn it_should_create_core_config() {
+        let core = TrackerCoreConfig {
+            database: DatabaseConfig::Sqlite(SqliteConfig {
+                database_name: "tracker.db".to_string(),
+            }),
+            private: true,
+        };
+
+        assert_eq!(core.database.database_name(), "tracker.db");
+        assert!(core.private);
+    }
+
+    #[test]
+    fn it_should_serialize_core_config() {
+        let core = TrackerCoreConfig {
+            database: DatabaseConfig::Sqlite(SqliteConfig {
+                database_name: "test.db".to_string(),
+            }),
+            private: false,
+        };
+
+        let json = serde_json::to_value(&core).unwrap();
+        assert_eq!(json["private"], false);
+    }
+}

src/domain/tracker/config/health_check_api.rs

@@ -0,0 +1,59 @@
+//! Health Check API configuration
+
+use std::net::SocketAddr;
+
+use serde::{Deserialize, Serialize};
+
+/// Health Check API configuration
+///
+/// The Health Check API is a minimal HTTP endpoint used by Docker and container
+/// orchestration tools to verify service health. It's separate from the main HTTP API.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct HealthCheckApiConfig {
+    /// Bind address (e.g., "127.0.0.1:1313")
+    ///
+    /// Conventionally uses port 1313, though this is configurable
+    #[serde(
+        serialize_with = "crate::domain::tracker::config::serialize_socket_addr",
+        deserialize_with = "crate::domain::tracker::config::deserialize_socket_addr"
+    )]
+    pub bind_address: SocketAddr,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_should_create_health_check_api_config() {
+        let config = HealthCheckApiConfig {
+            bind_address: "127.0.0.1:1313".parse().unwrap(),
+        };
+
+        assert_eq!(
+            config.bind_address,
+            "127.0.0.1:1313".parse::<SocketAddr>().unwrap()
+        );
+    }
+
+    #[test]
+    fn it_should_serialize_health_check_api_config() {
+        let config = HealthCheckApiConfig {
+            bind_address: "127.0.0.1:1313".parse().unwrap(),
+        };
+
+        let json = serde_json::to_value(&config).unwrap();
+        assert_eq!(json["bind_address"], "127.0.0.1:1313");
+    }
+
+    #[test]
+    fn it_should_deserialize_health_check_api_config() {
+        let json = r#"{"bind_address": "127.0.0.1:1313"}"#;
+        let config: HealthCheckApiConfig = serde_json::from_str(json).unwrap();
+
+        assert_eq!(
+            config.bind_address,
+            "127.0.0.1:1313".parse::<SocketAddr>().unwrap()
+        );
+    }
+}

src/domain/tracker/config/http.rs

@@ -0,0 +1,54 @@
+//! HTTP tracker configuration
+
+use std::net::SocketAddr;
+
+use serde::{Deserialize, Serialize};
+
+/// HTTP tracker bind configuration
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct HttpTrackerConfig {
+    /// Bind address (e.g., "0.0.0.0:7070")
+    #[serde(
+        serialize_with = "crate::domain::tracker::config::serialize_socket_addr",
+        deserialize_with = "crate::domain::tracker::config::deserialize_socket_addr"
+    )]
+    pub bind_address: SocketAddr,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_should_create_http_tracker_config() {
+        let config = HttpTrackerConfig {
+            bind_address: "0.0.0.0:7070".parse().unwrap(),
+        };
+
+        assert_eq!(
+            config.bind_address,
+            "0.0.0.0:7070".parse::<SocketAddr>().unwrap()
+        );
+    }
+
+    #[test]
+    fn it_should_serialize_http_tracker_config() {
+        let json = serde_json::to_value(&HttpTrackerConfig {
+            bind_address: "0.0.0.0:7070".parse().unwrap(),
+        })
+        .unwrap();
+
+        assert_eq!(json["bind_address"], "0.0.0.0:7070");
+    }
+
+    #[test]
+    fn it_should_deserialize_http_tracker_config() {
+        let json = r#"{"bind_address": "0.0.0.0:7070"}"#;
+        let config: HttpTrackerConfig = serde_json::from_str(json).unwrap();
+
+        assert_eq!(
+            config.bind_address,
+            "0.0.0.0:7070".parse::<SocketAddr>().unwrap()
+        );
+    }
+}

src/domain/tracker/config/http_api.rs

@@ -0,0 +1,64 @@
+//! HTTP API configuration
+
+use std::net::SocketAddr;
+
+use serde::{Deserialize, Serialize};
+
+use crate::shared::ApiToken;
+
+/// HTTP API configuration
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct HttpApiConfig {
+    /// Bind address (e.g., "0.0.0.0:1212")
+    #[serde(
+        serialize_with = "crate::domain::tracker::config::serialize_socket_addr",
+        deserialize_with = "crate::domain::tracker::config::deserialize_socket_addr"
+    )]
+    pub bind_address: SocketAddr,
+
+    /// Admin access token for HTTP API authentication
+    pub admin_token: ApiToken,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_should_create_http_api_config() {
+        let config = HttpApiConfig {
+            bind_address: "0.0.0.0:1212".parse().unwrap(),
+            admin_token: "test_token".to_string().into(),
+        };
+
+        assert_eq!(
+            config.bind_address,
+            "0.0.0.0:1212".parse::<SocketAddr>().unwrap()
+        );
+        assert_eq!(config.admin_token.expose_secret(), "test_token");
+    }
+
+    #[test]
+    fn it_should_serialize_http_api_config() {
+        let config = HttpApiConfig {
+            bind_address: "0.0.0.0:1212".parse().unwrap(),
+            admin_token: "token123".to_string().into(),
+        };
+
+        let json = serde_json::to_value(&config).unwrap();
+        assert_eq!(json["bind_address"], "0.0.0.0:1212");
+        assert_eq!(json["admin_token"], "token123");
+    }
+
+    #[test]
+    fn it_should_deserialize_http_api_config() {
+        let json = r#"{"bind_address": "0.0.0.0:1212", "admin_token": "MyToken"}"#;
+        let config: HttpApiConfig = serde_json::from_str(json).unwrap();
+
+        assert_eq!(
+            config.bind_address,
+            "0.0.0.0:1212".parse::<SocketAddr>().unwrap()
+        );
+        assert_eq!(config.admin_token.expose_secret(), "MyToken");
+    }
+}

src/domain/tracker/config.rs src/domain/tracker/config/mod.rssrc/domain/tracker/config.rs renamed to src/domain/tracker/config/mod.rs

@@ -7,8 +7,19 @@ use std::net::SocketAddr;
 
 use serde::{Deserialize, Serialize};
 
+mod core;
+mod health_check_api;
+mod http;
+mod http_api;
+mod udp;
+
+pub use core::TrackerCoreConfig;
+pub use health_check_api::HealthCheckApiConfig;
+pub use http::HttpTrackerConfig;
+pub use http_api::HttpApiConfig;
+pub use udp::UdpTrackerConfig;
+
 use super::{DatabaseConfig, SqliteConfig};
-use crate::shared::ApiToken;
 
 /// Tracker deployment configuration
 ///
@@ -63,68 +74,6 @@ pub struct TrackerConfig {
     pub health_check_api: HealthCheckApiConfig,
 }
 
-/// Core tracker configuration options
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct TrackerCoreConfig {
-    /// Database configuration (`SQLite`, `MySQL`, etc.)
-    pub database: DatabaseConfig,
-
-    /// Tracker mode: true for private tracker, false for public
-    pub private: bool,
-}
-
-/// UDP tracker bind configuration
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct UdpTrackerConfig {
-    /// Bind address (e.g., "0.0.0.0:6868")
-    #[serde(
-        serialize_with = "serialize_socket_addr",
-        deserialize_with = "deserialize_socket_addr"
-    )]
-    pub bind_address: SocketAddr,
-}
-
-/// HTTP tracker bind configuration
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct HttpTrackerConfig {
-    /// Bind address (e.g., "0.0.0.0:7070")
-    #[serde(
-        serialize_with = "serialize_socket_addr",
-        deserialize_with = "deserialize_socket_addr"
-    )]
-    pub bind_address: SocketAddr,
-}
-
-/// HTTP API configuration
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct HttpApiConfig {
-    /// Bind address (e.g., "0.0.0.0:1212")
-    #[serde(
-        serialize_with = "serialize_socket_addr",
-        deserialize_with = "deserialize_socket_addr"
-    )]
-    pub bind_address: SocketAddr,
-
-    /// Admin access token for HTTP API authentication
-    pub admin_token: ApiToken,
-}
-
-/// Health Check API configuration
-///
-/// The Health Check API is a minimal HTTP endpoint used by Docker and container
-/// orchestration tools to verify service health. It's separate from the main HTTP API.
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct HealthCheckApiConfig {
-    /// Bind address (e.g., "127.0.0.1:1313")
-    ///
-    /// Conventionally uses port 1313, though this is configurable
-    #[serde(
-        serialize_with = "serialize_socket_addr",
-        deserialize_with = "deserialize_socket_addr"
-    )]
-    pub bind_address: SocketAddr,
-}
-
 impl Default for TrackerConfig {
     /// Returns a default tracker configuration suitable for development and testing
     ///
@@ -161,14 +110,14 @@ impl Default for TrackerConfig {
     }
 }
 
-fn serialize_socket_addr<S>(addr: &SocketAddr, serializer: S) -> Result<S::Ok, S::Error>
+pub(crate) fn serialize_socket_addr<S>(addr: &SocketAddr, serializer: S) -> Result<S::Ok, S::Error>
 where
     S: serde::Serializer,
 {
     serializer.serialize_str(&addr.to_string())
 }
 
-fn deserialize_socket_addr<'de, D>(deserializer: D) -> Result<SocketAddr, D::Error>
+pub(crate) fn deserialize_socket_addr<'de, D>(deserializer: D) -> Result<SocketAddr, D::Error>
 where
     D: serde::Deserializer<'de>,
 {

src/domain/tracker/config/udp.rs

@@ -0,0 +1,54 @@
+//! UDP tracker configuration
+
+use std::net::SocketAddr;
+
+use serde::{Deserialize, Serialize};
+
+/// UDP tracker bind configuration
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct UdpTrackerConfig {
+    /// Bind address (e.g., "0.0.0.0:6868")
+    #[serde(
+        serialize_with = "crate::domain::tracker::config::serialize_socket_addr",
+        deserialize_with = "crate::domain::tracker::config::deserialize_socket_addr"
+    )]
+    pub bind_address: SocketAddr,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_should_create_udp_tracker_config() {
+        let config = UdpTrackerConfig {
+            bind_address: "0.0.0.0:6868".parse().unwrap(),
+        };
+
+        assert_eq!(
+            config.bind_address,
+            "0.0.0.0:6868".parse::<SocketAddr>().unwrap()
+        );
+    }
+
+    #[test]
+    fn it_should_serialize_udp_tracker_config() {
+        let config = UdpTrackerConfig {
+            bind_address: "0.0.0.0:6969".parse().unwrap(),
+        };
+
+        let json = serde_json::to_value(&config).unwrap();
+        assert_eq!(json["bind_address"], "0.0.0.0:6969");
+    }
+
+    #[test]
+    fn it_should_deserialize_udp_tracker_config() {
+        let json = r#"{"bind_address": "0.0.0.0:6969"}"#;
+        let config: UdpTrackerConfig = serde_json::from_str(json).unwrap();
+
+        assert_eq!(
+            config.bind_address,
+            "0.0.0.0:6969".parse::<SocketAddr>().unwrap()
+        );
+    }
+}