wacore 0.7.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

//! Keepalive IQ specification.
//!
//! Wire format:
//! ```xml
//! <!-- Request -->
//! <iq xmlns="w:p" type="get" to="s.whatsapp.net" id="..."/>
//!
//! <!-- Response -->
//! <iq from="s.whatsapp.net" id="..." type="result"/>
//! ```

use crate::iq::spec::IqSpec;
use crate::request::InfoQuery;
use std::time::Duration;
use wacore_binary::NodeRef;
use wacore_binary::{Jid, Server};

/// Keepalive ping to keep the connection alive.
#[derive(Debug, Clone, Default)]
pub struct KeepaliveSpec {
    /// Optional timeout for the keepalive response.
    pub timeout: Option<Duration>,
}

impl KeepaliveSpec {
    pub fn new() -> Self {
        Self { timeout: None }
    }

    /// Create a keepalive spec with a custom timeout.
    pub fn with_timeout(timeout: Duration) -> Self {
        Self {
            timeout: Some(timeout),
        }
    }
}

impl IqSpec for KeepaliveSpec {
    type Response = ();

    fn build_iq(&self) -> InfoQuery<'static> {
        let mut iq = InfoQuery::get("w:p", Jid::new("", Server::Pn), None);
        if let Some(timeout) = self.timeout {
            iq = iq.with_timeout(timeout);
        }
        iq
    }

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

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

    #[test]
    fn test_keepalive_spec_build_iq() {
        let spec = KeepaliveSpec::new();
        let iq = spec.build_iq();

        assert_eq!(iq.namespace, "w:p");
        assert_eq!(iq.query_type, crate::request::InfoQueryType::Get);
        assert!(iq.content.is_none());
        assert!(iq.timeout.is_none());
    }

    #[test]
    fn test_keepalive_spec_with_timeout() {
        let spec = KeepaliveSpec::with_timeout(Duration::from_secs(20));
        let iq = spec.build_iq();

        assert_eq!(iq.namespace, "w:p");
        assert_eq!(iq.timeout, Some(Duration::from_secs(20)));
    }

    #[test]
    fn test_keepalive_spec_parse_response() {
        let spec = KeepaliveSpec::new();
        let response = NodeBuilder::new("iq").build();

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