vpn-kill-switch 0.8.3

VPN kill switch for macOS
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

pub mod run;

use crate::cli::verbosity::Verbosity;
use anyhow::Result;

#[derive(Debug)]
pub enum Action {
    Enable {
        ipv4: Option<String>,
        leak: bool,
        local: bool,
        verbose: Verbosity,
    },
    Disable {
        verbose: Verbosity,
    },
    Status {
        verbose: Verbosity,
    },
    Print {
        ipv4: Option<String>,
        leak: bool,
        local: bool,
        verbose: Verbosity,
    },
    ShowInterfaces {
        verbose: Verbosity,
    },
}

impl Action {
    /// Execute this action
    ///
    /// # Errors
    /// Returns an error if the action execution fails
    pub fn execute(&self) -> Result<()> {
        run::execute(self)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::cli::verbosity::Verbosity;

    #[test]
    fn test_action_debug_format() {
        let action = Action::Enable {
            ipv4: Some("10.8.0.1".to_string()),
            leak: false,
            local: false,
            verbose: Verbosity::Normal,
        };
        let debug_str = format!("{action:?}");
        assert!(debug_str.contains("Enable"));
        assert!(debug_str.contains("10.8.0.1"));
    }

    #[test]
    fn test_action_variants() {
        let enable = Action::Enable {
            ipv4: None,
            leak: true,
            local: true,
            verbose: Verbosity::Verbose,
        };
        assert!(matches!(enable, Action::Enable { .. }));

        let disable = Action::Disable {
            verbose: Verbosity::Normal,
        };
        assert!(matches!(disable, Action::Disable { .. }));

        let status = Action::Status {
            verbose: Verbosity::Debug,
        };
        assert!(matches!(status, Action::Status { .. }));

        let print = Action::Print {
            ipv4: Some("192.168.1.1".to_string()),
            leak: false,
            local: false,
            verbose: Verbosity::Normal,
        };
        assert!(matches!(print, Action::Print { .. }));
    }
}