canlink-cli 0.3.2

Command-line interface for CAN hardware abstraction layer
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

//! Validate command implementation.
//!
//! Validates a configuration file.

use crate::error::{CliError, CliResult};
use crate::output::OutputFormatter;
use canlink_hal::CanlinkConfig;
use std::path::Path;

/// Execute the validate command.
pub fn execute(config_path: &str, formatter: &OutputFormatter) -> CliResult<()> {
    let path = Path::new(config_path);

    // Check if file exists
    if !path.exists() {
        return Err(CliError::ConfigError(format!(
            "Configuration file not found: {}",
            config_path
        )));
    }

    // Try to load the configuration
    match CanlinkConfig::from_file(config_path) {
        Ok(config) => {
            // Validate backend name is not empty
            if config.backend.backend_name.is_empty() {
                return Err(CliError::ConfigError(
                    "Backend name cannot be empty".to_string(),
                ));
            }

            // Additional validation could be added here
            // For example: check if backend exists, validate channel numbers, etc.

            if formatter.is_json() {
                let result = serde_json::json!({
                    "valid": true,
                    "backend": config.backend.backend_name,
                    "file": config_path
                });
                formatter.print(&result)?;
            } else {
                formatter
                    .print_success(&format!("Configuration file is valid: {}", config_path))?;
                println!("  Backend: {}", config.backend.backend_name);
            }

            Ok(())
        }
        Err(e) => Err(CliError::ConfigError(format!(
            "Invalid configuration file: {}",
            e
        ))),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::io::Write;
    use tempfile::NamedTempFile;

    #[test]
    fn test_validate_nonexistent_file() {
        let formatter = OutputFormatter::new(false);
        let result = execute("/nonexistent/config.toml", &formatter);
        assert!(result.is_err());
        assert!(matches!(result.unwrap_err(), CliError::ConfigError(_)));
    }

    #[test]
    fn test_validate_valid_config() {
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(temp_file, "[backend]").unwrap();
        writeln!(temp_file, "backend_name = \"tscan\"").unwrap();
        temp_file.flush().unwrap();

        let formatter = OutputFormatter::new(false);
        let result = execute(temp_file.path().to_str().unwrap(), &formatter);
        assert!(result.is_ok());
    }

    #[test]
    fn test_validate_invalid_toml() {
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(temp_file, "invalid toml content [[[").unwrap();
        temp_file.flush().unwrap();

        let formatter = OutputFormatter::new(false);
        let result = execute(temp_file.path().to_str().unwrap(), &formatter);
        assert!(result.is_err());
        assert!(matches!(result.unwrap_err(), CliError::ConfigError(_)));
    }

    #[test]
    fn test_validate_empty_backend() {
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(temp_file, "[backend]").unwrap();
        writeln!(temp_file, "backend_name = \"\"").unwrap();
        temp_file.flush().unwrap();

        let formatter = OutputFormatter::new(false);
        let result = execute(temp_file.path().to_str().unwrap(), &formatter);
        assert!(result.is_err());
        assert!(matches!(result.unwrap_err(), CliError::ConfigError(_)));
    }
}