wacore 0.6.0

Core WhatsApp protocol implementation without runtime dependencies
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

//! Passive mode IQ specification.
//!
//! Passive mode tells the server whether the client is actively receiving
//! notifications or is in a background/passive state.
//!
//! ## Wire Format
//! ```xml
//! <!-- Set Active (foreground) -->
//! <iq xmlns="passive" type="set" to="s.whatsapp.net" id="...">
//!   <active/>
//! </iq>
//!
//! <!-- Set Passive (background) -->
//! <iq xmlns="passive" type="set" to="s.whatsapp.net" id="...">
//!   <passive/>
//! </iq>
//!
//! <!-- Response -->
//! <iq from="s.whatsapp.net" id="..." type="result"/>
//! ```

use crate::iq::spec::IqSpec;
use crate::request::InfoQuery;
use wacore_binary::builder::NodeBuilder;
use wacore_binary::{Jid, Server};
use wacore_binary::{NodeContent, NodeRef};

/// IQ namespace for passive mode.
pub const PASSIVE_NAMESPACE: &str = "passive";

/// Sets the client's passive/active mode.
#[derive(Debug, Clone)]
pub struct PassiveModeSpec {
    /// Whether to set passive mode (true) or active mode (false).
    pub passive: bool,
}

impl PassiveModeSpec {
    /// Create a spec to set passive mode (background).
    pub fn passive() -> Self {
        Self { passive: true }
    }

    /// Create a spec to set active mode (foreground).
    pub fn active() -> Self {
        Self { passive: false }
    }

    /// Create a spec from a boolean (true = passive, false = active).
    pub fn new(passive: bool) -> Self {
        Self { passive }
    }
}

impl IqSpec for PassiveModeSpec {
    type Response = ();

    fn build_iq(&self) -> InfoQuery<'static> {
        let tag = if self.passive { "passive" } else { "active" };
        let child_node = NodeBuilder::new(tag).build();

        InfoQuery::set(
            PASSIVE_NAMESPACE,
            Jid::new("", Server::Pn),
            Some(NodeContent::Nodes(vec![child_node])),
        )
    }

    fn parse_response(&self, _response: &NodeRef<'_>) -> Result<Self::Response, anyhow::Error> {
        // Passive mode just needs a successful response
        Ok(())
    }
}

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

    #[test]
    fn test_passive_mode_spec_passive() {
        let spec = PassiveModeSpec::passive();
        let iq = spec.build_iq();

        assert_eq!(iq.namespace, PASSIVE_NAMESPACE);
        assert_eq!(iq.query_type, crate::request::InfoQueryType::Set);

        if let Some(NodeContent::Nodes(nodes)) = &iq.content {
            assert_eq!(nodes.len(), 1);
            assert_eq!(nodes[0].tag, "passive");
        } else {
            panic!("Expected NodeContent::Nodes");
        }
    }

    #[test]
    fn test_passive_mode_spec_active() {
        let spec = PassiveModeSpec::active();
        let iq = spec.build_iq();

        assert_eq!(iq.namespace, PASSIVE_NAMESPACE);
        assert_eq!(iq.query_type, crate::request::InfoQueryType::Set);

        if let Some(NodeContent::Nodes(nodes)) = &iq.content {
            assert_eq!(nodes.len(), 1);
            assert_eq!(nodes[0].tag, "active");
        } else {
            panic!("Expected NodeContent::Nodes");
        }
    }

    #[test]
    fn test_passive_mode_spec_parse_response() {
        let spec = PassiveModeSpec::passive();
        let response = NodeBuilder::new("iq").attr("type", "result").build();

        let result = spec.parse_response(&response.as_node_ref());
        assert!(result.is_ok());
    }
}