smirrors 0.1.0

Automatic mirror list updater for Linux distributions
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use anyhow::Result;
use crate::config::Config;
use crate::utils::SMirrorsError;

/// Validate that all required directories exist and are accessible
pub fn validate_directories(config: &Config) -> Result<()> {
    let data_dir = Config::data_dir()?;
    let cache_dir = Config::cache_dir()?;

    // Check if directories exist or can be created
    if !data_dir.exists() {
        std::fs::create_dir_all(&data_dir)
            .map_err(|e| SMirrorsError::ConfigError(
                format!("Cannot create data directory {:?}: {}", data_dir, e)
            ))?;
    }

    if !cache_dir.exists() {
        std::fs::create_dir_all(&cache_dir)
            .map_err(|e| SMirrorsError::ConfigError(
                format!("Cannot create cache directory {:?}: {}", cache_dir, e)
            ))?;
    }

    // Check write permissions
    let test_file = data_dir.join(".write_test");
    std::fs::write(&test_file, "test")
        .map_err(|e| SMirrorsError::ConfigError(
            format!("Data directory {:?} is not writable: {}", data_dir, e)
        ))?;
    std::fs::remove_file(&test_file).ok();

    Ok(())
}

/// Validate static mirror URLs
pub fn validate_static_mirrors(config: &Config) -> Result<()> {
    for (name, url) in &config.static_mirrors {
        url::Url::parse(url)
            .map_err(|e| SMirrorsError::ConfigError(
                format!("Invalid static mirror URL for '{}': {} - {}", name, url, e)
            ))?;
    }

    Ok(())
}

/// Validate logging configuration
pub fn validate_logging(config: &Config) -> Result<()> {
    // Check log level is valid
    let valid_levels = ["trace", "debug", "info", "warn", "error"];
    if !valid_levels.contains(&config.logging.level.to_lowercase().as_str()) {
        return Err(SMirrorsError::ConfigError(
            format!("Invalid log level '{}'. Must be one of: trace, debug, info, warn, error",
                   config.logging.level)
        ).into());
    }

    // Check log format is valid
    let valid_formats = ["json", "pretty", "compact"];
    if !valid_formats.contains(&config.logging.format.to_lowercase().as_str()) {
        return Err(SMirrorsError::ConfigError(
            format!("Invalid log format '{}'. Must be one of: json, pretty, compact",
                   config.logging.format)
        ).into());
    }

    // If log file is specified, check parent directory exists
    if let Some(log_file) = &config.logging.file {
        if let Some(parent) = log_file.parent() {
            if !parent.exists() {
                std::fs::create_dir_all(parent)
                    .map_err(|e| SMirrorsError::ConfigError(
                        format!("Cannot create log directory {:?}: {}", parent, e)
                    ))?;
            }
        }
    }

    Ok(())
}

/// Perform complete configuration validation
pub fn validate_complete(config: &Config) -> Result<()> {
    // Run built-in validation
    config.validate()?;

    // Validate directories
    validate_directories(config)?;

    // Validate static mirrors
    validate_static_mirrors(config)?;

    // Validate logging
    validate_logging(config)?;

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_validate_default_config() {
        let config = Config::default();
        assert!(config.validate().is_ok());
    }

    #[test]
    fn test_validate_invalid_weights() {
        let mut config = Config::default();
        config.testing.speed_weight = 0.5;
        config.testing.latency_weight = 0.3;
        assert!(config.validate().is_err());
    }

    #[test]
    fn test_validate_negative_weights() {
        let mut config = Config::default();
        config.testing.speed_weight = -0.1;
        assert!(config.validate().is_err());
    }

    #[test]
    fn test_validate_invalid_min_score() {
        let mut config = Config::default();
        config.testing.min_score = 1.5;
        assert!(config.validate().is_err());
    }

    #[test]
    fn test_validate_invalid_concurrent_tests() {
        let mut config = Config::default();
        config.general.concurrent_tests = 0;
        assert!(config.validate().is_err());

        config.general.concurrent_tests = 101;
        assert!(config.validate().is_err());
    }
}