cargo-steady-state 0.0.26

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
81
82
83
84
85
86
87

use structopt_derive::StructOpt;

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

    #[structopt(short = "l", long = "loglevel"
                , default_value = "info"
                , possible_values = log_variants()
                , validator = validate_logging_level
                , case_insensitive = true)]
    pub(crate) loglevel: String,

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

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

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

}

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."))
    }
}

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

    #[test]
    fn test_default_values() {
        let args = Args::from_iter_safe(&[""]).unwrap();
        assert_eq!(args.loglevel, "info");
        assert_eq!(args.dotfile, "graph.dot");
        assert_eq!(args.name, "unnamed");
    }

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

    #[test]
    fn test_invalid_logging_level() {
        let result = Args::from_iter_safe(&["", "-l", "invalid_level"]);
        assert!(result.is_err());
    }

    #[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.");
    }
}