botrs 0.13.0

A Rust QQ Bot framework based on QQ Guild Bot API
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

//! HTTP webhook session models.

use serde::{Deserialize, Serialize};

/// Identity payload for creating an HTTP webhook session.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct HttpIdentity {
    /// Gateway intents bitmask
    pub intents: u32,
    /// Shard tuple: `[shard_id, num_shards]`
    pub shards: [u32; 2],
    /// Callback URL
    pub callback_url: String,
}

/// Bot information embedded in an HTTP webhook ready response.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct HttpBot {
    /// Bot ID
    pub id: String,
    /// Bot username
    pub username: String,
}

/// Ready response returned after creating an HTTP webhook session.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct HttpReady {
    /// Gateway version
    pub version: i32,
    /// Session ID
    pub session_id: String,
    /// Bot information
    pub bot: HttpBot,
    /// Shard tuple
    pub shard: [u32; 2],
}

/// HTTP webhook session object.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct HttpSession {
    /// App ID
    pub app_id: i64,
    /// Session ID
    pub session_id: String,
    /// Callback URL
    pub callback_url: String,
    /// Environment
    pub env: String,
    /// Gateway intents bitmask
    pub intents: i64,
    /// Last heartbeat time
    pub last_heartbeat_time: String,
    /// Session state
    pub state: String,
    /// Shard tuple
    pub shards: [i64; 2],
}

/// Webhook callback validation request data.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
pub struct WebhookValidationRequest {
    /// Plain token from the validation request
    pub plain_token: String,
    /// Event timestamp
    pub event_ts: String,
}

/// Webhook callback validation response data.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
pub struct WebhookValidationResponse {
    /// Plain token from the validation request
    pub plain_token: String,
    /// Signature generated with the app secret
    pub signature: String,
    /// Data format version
    pub data_version: String,
}

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

    #[test]
    fn http_identity_keeps_official_json_shape() {
        let identity = HttpIdentity {
            intents: 1 << 25,
            shards: [0, 2],
            callback_url: "https://example.com/callback".to_string(),
        };
        let value = serde_json::to_value(&identity).unwrap();

        assert_eq!(value["intents"], 1 << 25);
        assert_eq!(value["shards"], serde_json::json!([0, 2]));
        assert_eq!(value["callback_url"], "https://example.com/callback");
    }

    #[test]
    fn http_ready_bot_uses_embedded_shape() {
        let ready: HttpReady = serde_json::from_value(serde_json::json!({
            "version": 1,
            "session_id": "session-1",
            "bot": {
                "id": "bot-1",
                "username": "bot"
            },
            "shard": [0, 1]
        }))
        .unwrap();

        assert_eq!(ready.version, 1);
        assert_eq!(ready.session_id, "session-1");
        assert_eq!(ready.bot.id, "bot-1");
        assert_eq!(ready.bot.username, "bot");
        assert_eq!(ready.shard, [0, 1]);

        let value = serde_json::to_value(&ready).unwrap();
        assert_eq!(value["bot"]["id"], "bot-1");
        assert_eq!(value["bot"]["username"], "bot");
        assert!(value["bot"].get("avatar").is_none());
        assert!(value["bot"].get("bot").is_none());
    }
}