ifstat-rs 3.0.0

A tool to report network interface statistics.
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

#[cfg(test)]
mod command_line_options_tests {
    use clap::Parser;
    use ifstat_rs::opts::Opts;

    #[test]
    fn test_valid_command_line_options() {
        let opts = Opts::parse_from(&[
            "ifstat-rs",
            "-i",
            "eth0,lo",
            "-a",
            "-l",
            "-z",
            "--first-measurement",
            "3", // First measurement
            "2", // Delay
            "5", // Count
        ]);
        assert_eq!(opts.interfaces, Some("eth0,lo".to_string()));
        assert!(opts.monitor_all);
        assert!(opts.monitor_loopback);
        assert!(opts.hide_zero_counters);
        assert_eq!(opts.first_measurement, Some(3.0));
        assert_eq!(opts.delay, 2.0);
        assert_eq!(opts.count, Some(5));
    }

    #[test]
    fn test_delay_greater_than_zero() {
        let opts = Opts::parse_from(&[
            "ifstat-rs",
            "--first-measurement",
            "0",
            "0.1", // Delay
            "1",   // Count
        ]);
        assert_eq!(opts.first_measurement, Some(0.0));
        assert_eq!(opts.delay, 0.1);
        assert_eq!(opts.count, Some(1));
    }

    #[test]
    fn test_delay_zero_should_fail() {
        let result = Opts::try_parse_from(&["ifstat-rs", "0"]);
        assert!(result.is_err());
        let error_message = format!("{}", result.err().unwrap());
        assert!(error_message.contains("`0` must be greater than 0"));
    }

    #[test]
    fn test_delay_negative_should_fail() {
        let result = Opts::try_parse_from(&["ifstat-rs", "--", "-1"]);
        assert!(result.is_err());
        let error_message = format!("{}", result.err().unwrap());
        assert!(error_message.contains("`-1` must be greater than 0"));
    }

    #[test]
    fn test_first_measurement_zero() {
        let opts = Opts::parse_from(&[
            "ifstat-rs",
            "--first-measurement=0",
            "1", // Delay
        ]);
        assert_eq!(opts.first_measurement, Some(0.0));
        assert_eq!(opts.delay, 1.0);
    }

    #[test]
    fn test_first_measurement_negative_should_fail() {
        let result = Opts::try_parse_from(&[
            "ifstat-rs",
            "1", // Delay
            "--first-measurement=-1",
        ]);
        assert!(result.is_err());
        let error_message = format!("{}", result.err().unwrap());
        assert!(
            error_message.contains("must be greater than or equal to 0"),
            "errmsg={}",
            error_message
        );
    }

    #[test]
    fn test_count_zero_should_fail() {
        let result = Opts::try_parse_from(&[
            "ifstat-rs",
            "1", // Delay
            "0", // Count
        ]);
        assert!(result.is_err());
        let error_message = format!("{}", result.err().unwrap());
        assert!(error_message.contains("must be greater than 0"));
    }

    #[test]
    fn test_count_negative_unescaped_should_fail() {
        let result = Opts::try_parse_from(&[
            "ifstat-rs",
            "1",  // Delay
            "-1", // Count
        ]);
        assert!(result.is_err());
        let error_message = format!("{}", result.err().unwrap());
        assert!(error_message.contains("unexpected argument '-1'"));
    }

    #[test]
    fn test_count_negative_should_fail() {
        let result = Opts::try_parse_from(&[
            "ifstat-rs",
            "1", // Delay
            "--",
            "-1", // Count
        ]);
        assert!(result.is_err());
        let error_message = format!("{}", result.err().unwrap());
        assert!(error_message.contains("not a valid number > 0"));
    }
}