freeswitch-types 1.7.0-beta5

FreeSWITCH ESL protocol types: channel state, events, headers, commands, and variables
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
123
124
125
126

//! Gateway registration state and ping status enums.

wire_enum! {
    /// Gateway registration state from `sofia::gateway_state` events.
    ///
    /// The `State` header value, mapping to `reg_state_t` / `sofia_state_names[]`
    /// in mod_sofia.
    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
    #[cfg_attr(feature = "serde", serde(rename_all = "SCREAMING_SNAKE_CASE"))]
    pub enum GatewayRegState {
        #[cfg_attr(feature = "serde", serde(alias = "Unreged"))]
        Unreged => "UNREGED",
        #[cfg_attr(feature = "serde", serde(alias = "Trying"))]
        Trying => "TRYING",
        #[cfg_attr(feature = "serde", serde(alias = "Register"))]
        Register => "REGISTER",
        #[cfg_attr(feature = "serde", serde(alias = "Reged"))]
        Reged => "REGED",
        #[cfg_attr(feature = "serde", serde(alias = "Unregister"))]
        Unregister => "UNREGISTER",
        #[cfg_attr(feature = "serde", serde(alias = "Failed"))]
        Failed => "FAILED",
        #[cfg_attr(feature = "serde", serde(alias = "FailWait"))]
        FailWait => "FAIL_WAIT",
        #[cfg_attr(feature = "serde", serde(alias = "Expired"))]
        Expired => "EXPIRED",
        #[cfg_attr(feature = "serde", serde(alias = "Noreg"))]
        Noreg => "NOREG",
        #[cfg_attr(feature = "serde", serde(alias = "Down"))]
        Down => "DOWN",
        #[cfg_attr(feature = "serde", serde(alias = "Timeout"))]
        Timeout => "TIMEOUT",
    }
    error ParseGatewayRegStateError("gateway reg state");
    tests: gateway_reg_state_wire_tests;
}

wire_enum! {
    /// Gateway ping status from `sofia::gateway_state` events.
    ///
    /// The `Ping-Status` header value, mapping to `sofia_gateway_status_name()`.
    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
    #[cfg_attr(feature = "serde", serde(rename_all = "SCREAMING_SNAKE_CASE"))]
    pub enum GatewayPingStatus {
        #[cfg_attr(feature = "serde", serde(alias = "Down"))]
        Down => "DOWN",
        #[cfg_attr(feature = "serde", serde(alias = "Up"))]
        Up => "UP",
        #[cfg_attr(feature = "serde", serde(alias = "Invalid"))]
        Invalid => "INVALID",
    }
    error ParseGatewayPingStatusError("gateway ping status");
    tests: gateway_ping_status_wire_tests;
}

#[cfg(all(test, feature = "serde"))]
mod tests {
    use super::*;

    mod serde_tests {
        use super::*;

        #[test]
        fn reg_state_serde_uses_wire_format() {
            for &state in GatewayRegState::ALL {
                let json = serde_json::to_string(&state).unwrap();
                let expected = format!("\"{}\"", state.as_str());
                assert_eq!(json, expected, "serde must serialize as wire format");
            }
        }

        #[test]
        fn reg_state_serde_round_trip() {
            for &state in GatewayRegState::ALL {
                let json = serde_json::to_string(&state).unwrap();
                let parsed: GatewayRegState = serde_json::from_str(&json).unwrap();
                assert_eq!(parsed, state);
            }
        }

        #[test]
        fn reg_state_serde_accepts_pascal_case_alias() {
            let cases = [
                ("\"Noreg\"", GatewayRegState::Noreg),
                ("\"Reged\"", GatewayRegState::Reged),
                ("\"FailWait\"", GatewayRegState::FailWait),
                ("\"Unreged\"", GatewayRegState::Unreged),
            ];
            for (json, expected) in cases {
                let parsed: GatewayRegState = serde_json::from_str(json).unwrap();
                assert_eq!(parsed, expected, "PascalCase alias failed for {json}");
            }
        }

        #[test]
        fn ping_status_serde_uses_wire_format() {
            for &status in GatewayPingStatus::ALL {
                let json = serde_json::to_string(&status).unwrap();
                let expected = format!("\"{}\"", status.as_str());
                assert_eq!(json, expected, "serde must serialize as wire format");
            }
        }

        #[test]
        fn ping_status_serde_round_trip() {
            for &status in GatewayPingStatus::ALL {
                let json = serde_json::to_string(&status).unwrap();
                let parsed: GatewayPingStatus = serde_json::from_str(&json).unwrap();
                assert_eq!(parsed, status);
            }
        }

        #[test]
        fn ping_status_serde_accepts_pascal_case_alias() {
            let cases = [
                ("\"Down\"", GatewayPingStatus::Down),
                ("\"Up\"", GatewayPingStatus::Up),
                ("\"Invalid\"", GatewayPingStatus::Invalid),
            ];
            for (json, expected) in cases {
                let parsed: GatewayPingStatus = serde_json::from_str(json).unwrap();
                assert_eq!(parsed, expected, "PascalCase alias failed for {json}");
            }
        }
    }
}