cargo-steady-state 0.2.13

Code generator for steady_state projects based on a structured dot file.
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

use clap::*;

#[derive(Parser, Debug, PartialEq, Clone)]
pub struct Args {

    #[arg(short = 'l', long = "loglevel"
                , default_value = "Info")]
    pub(crate) loglevel: String,

    #[arg(short = 'd', long = "dotfile"
                             , default_value = "graph.dot")]
    pub(crate) dotfile: String,

    #[arg(short = 'n', long = "name"
                , default_value = "unnamed")]
    pub(crate) name: String,

    //other global  switches,  --disable-testing --import-actors ??

}


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



    fn log_variants() -> &'static [&'static str] {
        &["error", "warn", "info", "debug", "trace"]
    }

    fn validate_logging_level(level: String) -> Result<(), String> {
        let level_lower = level.to_lowercase();
        let valid_levels = log_variants();
        if valid_levels.contains(&level_lower.as_str()) {
            Ok(())
        } else {
            Err(String::from("Invalid logging level format."))
        }
    }
    
    #[test]
    fn test_default_values() {
        let args = Args::parse_from([""]);
        assert_eq!(args.loglevel, "Info");
        assert_eq!(args.dotfile, "graph.dot");
        assert_eq!(args.name, "unnamed");
    }

    #[test]
    fn test_custom_values() {
        let args = Args::parse_from([
            "",
            "-l", "debug",
            "-d", "custom.dot",
            "-n", "custom_name"
        ]);
        assert_eq!(args.loglevel, "debug");
        assert_eq!(args.dotfile, "custom.dot");
        assert_eq!(args.name, "custom_name");
    }

    #[test]
    fn test_logging_level_variants() {
        for &level in log_variants() {
            assert!(validate_logging_level(level.to_string()).is_ok());
        }
    }

    #[test]
    fn test_invalid_logging_level_validation() {
        let invalid_level = "invalid_level".to_string();
        let result = validate_logging_level(invalid_level);
        assert!(result.is_err());
        assert_eq!(result.unwrap_err(), "Invalid logging level format.");
    }
}