Test Case: rust-instruct-1313

  1use serde::{Deserialize, Serialize};  2use std::error::Error;  3use std::fs;  4use std::net::IpAddr;  5use std::path::Path;  6​  7#[derive(Debug, Serialize, Deserialize, Clone)]  8pub struct NetworkConfig {  9    pub listen_address: IpAddr, 10    pub peer_discovery_enabled: bool, 11    pub max_peers: u32, 12    // Add other network configuration parameters here 13} 14​ 15impl NetworkConfig { 16    pub fn validate(&self) -> Result<(), Box<dyn Error>> { 17        if self.max_peers > 1000 { 18            return Err("Max peers cannot exceed 1000".into()); 19        } 20        // Add other validation rules here 21        Ok(()) 22    } 23} 24​ 25pub fn setup_network_from_config( 26    config_str: &str, 27    config_dir: &str, 28) -> Result<NetworkConfig, Box<dyn Error>> { 29    // 1. Deserialize the configuration 30    let config: NetworkConfig = serde_json::from_str(config_str)?; 31​ 32    // 2. Validate the configuration 33    config.validate()?; 34​ 35    // 3. Set up the network configuration 36    setup_network(&config, config_dir)?; 37​ 38    // 4. Return the validated configuration 39    Ok(config) 40} 41​ 42fn setup_network(config: &NetworkConfig, config_dir: &str) -> Result<(), Box<dyn Error>> { 43    // Create the config directory if it doesn't exist 44    let path = Path::new(config_dir); 45    fs::create_dir_all(path)?; 46​ 47    // Write the configuration to a file 48    let config_path = path.join("network_config.json"); 49    let config_str = serde_json::to_string_pretty(config)?; 50    fs::write(config_path, config_str)?; 51​ 52    // Implement the actual network setup logic here 53    println!("Setting up network with config: {:?}", config); 54    println!("Configuration saved to: {}", config_dir); 55​ 56    // Placeholder for actual network setup 57    // This would involve using network libraries to configure the node 58    // based on the parameters in the NetworkConfig struct. 59​ 60    Ok(()) 61} 62​ 63#[cfg(test)] 64mod tests { 65    use super::*; 66    use std::net::Ipv4Addr; 67    use tempfile::tempdir; 68​ 69    #[test] 70    fn test_setup_network_from_config_success() { 71        let config_str = r#" 72            { 73                "listen_address": "127.0.0.1", 74                "peer_discovery_enabled": true, 75                "max_peers": 100 76            } 77        "#; 78​ 79        let temp_dir = tempdir().unwrap(); 80        let config_dir = temp_dir.path().to_str().unwrap(); 81​ 82        let result = setup_network_from_config(config_str, config_dir); 83        assert!(result.is_ok()); 84​ 85        let config = result.unwrap(); 86        assert_eq!(config.listen_address, IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1))); 87        assert_eq!(config.peer_discovery_enabled, true); 88        assert_eq!(config.max_peers, 100); 89​ 90        // Check if the config file was created 91        let config_path = temp_dir.path().join("network_config.json"); 92        assert!(config_path.exists()); 93    } 94​ 95    #[test] 96    fn test_setup_network_from_config_validation_error() { 97        let config_str = r#" 98            { 99                "listen_address": "127.0.0.1",100                "peer_discovery_enabled": true,101                "max_peers": 1001102            }103        "#;104​105        let temp_dir = tempdir().unwrap();106        let config_dir = temp_dir.path().to_str().unwrap();107​108        let result = setup_network_from_config(config_str, config_dir);109        assert!(result.is_err());110        assert_eq!(result.unwrap_err().to_string(), "Max peers cannot exceed 1000");111    }112​113    #[test]114    fn test_setup_network_from_config_deserialization_error() {115        let config_str = r#"116            {117                "listen_address": 123,118                "peer_discovery_enabled": true,119                "max_peers": 100120            }121        "#;122​123        let temp_dir = tempdir().unwrap();124        let config_dir = temp_dir.path().to_str().unwrap();125​126        let result = setup_network_from_config(config_str, config_dir);127        assert!(result.is_err());128    }129}

None

  1use serde::{Deserialize, Serialize};  2use std::fs;  3use std::path::Path;  4use thiserror::Error;  5​  6#[derive(Debug, Serialize, Deserialize)]  7#[serde(deny_unknown_fields)]  8pub struct NetworkConfig {  9    pub listen_address: String, 10    pub peers: Vec<String>, 11    pub max_connections: u32, 12} 13​ 14#[derive(Debug, Error)] 15pub enum ConfigError { 16    #[error("Deserialization error: {0}")] 17    Deserialize(#[from] toml::de::Error), 18    #[error("Validation error: {0}")] 19    Validation(String), 20    #[error("IO error: {0}")] 21    Io(#[from] std::io::Error), 22} 23​ 24pub fn setup_network(config_str: &str, data_dir: &str) -> Result<NetworkConfig, ConfigError> { 25    // Deserialize the configuration 26    let mut config: NetworkConfig = toml::from_str(config_str)?; 27​ 28    // Validate the configuration 29    validate_config(&mut config)?; 30​ 31    // Set up the network configuration 32    setup_network_internal(&config, data_dir)?; 33​ 34    Ok(config) 35} 36​ 37fn validate_config(config: &mut NetworkConfig) -> Result<(), ConfigError> { 38    // Example validation: Check if listen address is a valid IP address 39    if !config.listen_address.contains(':') { 40        return Err(ConfigError::Validation( 41            "Invalid listen address format. Expected IP:Port".to_string(), 42        )); 43    } 44​ 45    // Example validation: Check if max_connections is within reasonable bounds 46    if config.max_connections > 1000 { 47        return Err(ConfigError::Validation( 48            "max_connections exceeds maximum allowed value".to_string(), 49        )); 50    } 51​ 52    // Example validation: Remove duplicate peers 53    config.peers.sort(); 54    config.peers.dedup(); 55​ 56    Ok(()) 57} 58​ 59fn setup_network_internal(config: &NetworkConfig, data_dir: &str) -> Result<(), ConfigError> { 60    // Create the data directory if it doesn't exist 61    let path = Path::new(data_dir); 62    fs::create_dir_all(path)?; 63​ 64    // Write the configuration to a file in the data directory 65    let config_path = path.join("network_config.toml"); 66    let config_str = toml::to_string_pretty(config).unwrap(); // Safe to unwrap after validation 67    fs::write(config_path, config_str)?; 68​ 69    // Placeholder for actual network setup logic 70    println!("Setting up network with config: {:?}", config); 71    println!("Data directory: {}", data_dir); 72​ 73    Ok(()) 74} 75​ 76#[cfg(test)] 77mod tests { 78    use super::*; 79​ 80    #[test] 81    fn test_setup_network_valid() { 82        let config_str = r#" 83            listen_address = "127.0.0.1:8000" 84            peers = ["192.168.1.1:8000", "192.168.1.2:8000"] 85            max_connections = 100 86        "#; 87        let data_dir = "test_data"; 88​ 89        let result = setup_network(config_str, data_dir); 90        assert!(result.is_ok()); 91​ 92        // Cleanup 93        fs::remove_dir_all(data_dir).unwrap(); 94    } 95​ 96    #[test] 97    fn test_setup_network_invalid_listen_address() { 98        let config_str = r#" 99            listen_address = "invalid_address"100            peers = ["192.168.1.1:8000", "192.168.1.2:8000"]101            max_connections = 100102        "#;103        let data_dir = "test_data";104​105        let result = setup_network(config_str, data_dir);106        assert!(result.is_err());107        match result {108            Err(ConfigError::Validation(_)) => {},109            _ => panic!("Expected validation error"),110        }111    }112​113    #[test]114    fn test_setup_network_unknown_field() {115        let config_str = r#"116            listen_address = "127.0.0.1:8000"117            peers = ["192.168.1.1:8000", "192.168.1.2:8000"]118            max_connections = 100119            extra_field = "something"120        "#;121        let data_dir = "test_data";122​123        let result = setup_network(config_str, data_dir);124        assert!(result.is_err());125        match result {126            Err(ConfigError::Deserialize(_)) => {},127            _ => panic!("Expected deserialization error"),128        }129    }130​131    #[test]132    fn test_setup_network_duplicate_peers() {133        let config_str = r#"134            listen_address = "127.0.0.1:8000"135            peers = ["192.168.1.1:8000", "192.168.1.2:8000", "192.168.1.1:8000"]136            max_connections = 100137        "#;138        let data_dir = "test_data";139​140        let result = setup_network(config_str, data_dir).unwrap();141        assert_eq!(result.peers.len(), 2);142​143        // Cleanup144        fs::remove_dir_all(data_dir).unwrap();145    }146}

None