vkteams_bot/api/messages/
send_text.rs

1#![allow(unused_parens)]
2//! Send text messages to the chat method `messages/sendText`
3//! [More info](https://teams.vk.com/botapi/#/messages/get_messages_sendText)
4use crate::prelude::*;
5bot_api_method! {
6    method = "messages/sendText",
7    request = RequestMessagesSendText {
8        required {
9            chat_id: ChatId,
10        },
11        optional {
12            text: String,
13            reply_msg_id: MsgId,
14            forward_chat_id: ChatId,
15            forward_msg_id: MsgId,
16            inline_keyboard_markup: String,
17            format: MessageFormat,
18            parse_mode: ParseMode,
19        }
20    },
21    response = ResponseMessagesSendText {
22        msg_id: MsgId,
23    },
24}
25
26impl MessageTextSetters for RequestMessagesSendText {
27    /// Set text and parse_mode
28    /// ## Parameters
29    /// - `parser`: [`MessageTextParser`]
30    fn set_text(self, parser: MessageTextParser) -> Result<Self> {
31        let (text, parse_mode) = parser.parse()?;
32        Ok(self.with_text(text).with_parse_mode(parse_mode))
33    }
34    /// Set keyboard
35    /// ## Parameters
36    /// - `keyboard`: [`Keyboard`]
37    fn set_keyboard(self, keyboard: Keyboard) -> Result<Self> {
38        Ok(self.with_inline_keyboard_markup(keyboard.into()))
39    }
40}
41
42#[cfg(test)]
43mod tests {
44    use super::*;
45
46    #[test]
47    fn test_set_text_valid() {
48        let req = RequestMessagesSendText::new(ChatId::from("c1"));
49        let mut parser = MessageTextParser::default();
50        parser
51            .text
52            .push(MessageTextFormat::Plain("hello".to_string()));
53        let res = req.set_text(parser);
54        assert!(res.is_ok());
55        let req2 = res.unwrap();
56        assert_eq!(req2.text.unwrap(), "hello");
57    }
58
59    #[test]
60    fn test_set_text_parser_error() {
61        let req = RequestMessagesSendText::new(ChatId::from("c1"));
62        // Парсер с невалидным URL (ошибка парсинга)
63        let mut parser = MessageTextParser::default();
64        parser.text.push(MessageTextFormat::Link(
65            "not a url".to_string(),
66            "text".to_string(),
67        ));
68        let res = req.set_text(parser);
69        assert!(res.is_err());
70    }
71
72    #[test]
73    fn test_set_keyboard_valid() {
74        let req = RequestMessagesSendText::new(ChatId::from("c1"));
75        let keyboard = Keyboard {
76            buttons: vec![vec![ButtonKeyboard {
77                text: "ok".to_string(),
78                url: None,
79                callback_data: None,
80                style: None,
81            }]],
82        };
83        let res = req.set_keyboard(keyboard);
84        assert!(res.is_ok());
85        let req2 = res.unwrap();
86        assert!(req2.inline_keyboard_markup.is_some());
87    }
88
89    #[test]
90    fn test_serialize_deserialize_request_minimal() {
91        let req = RequestMessagesSendText::new(ChatId::from("c1"));
92        let val = serde_json::to_value(&req).unwrap();
93        assert_eq!(val["chatId"], "c1");
94        let req2: RequestMessagesSendText = serde_json::from_value(val).unwrap();
95        assert_eq!(req2.chat_id.0, "c1");
96        assert!(req2.text.is_none());
97    }
98
99    #[test]
100    fn test_serialize_deserialize_request_full() {
101        let mut req = RequestMessagesSendText::new(ChatId::from("c1"));
102        req.text = Some("hello".to_string());
103        req.reply_msg_id = Some(MsgId("m1".to_string()));
104        req.forward_chat_id = Some(ChatId::from("c2"));
105        req.forward_msg_id = Some(MsgId("m2".to_string()));
106        let val = serde_json::to_value(&req).unwrap();
107        let req2: RequestMessagesSendText = serde_json::from_value(val).unwrap();
108        assert_eq!(req2.text.as_deref(), Some("hello"));
109        assert_eq!(req2.reply_msg_id.as_ref().unwrap().0, "m1");
110        assert_eq!(req2.forward_chat_id.as_ref().unwrap().0, "c2");
111        assert_eq!(req2.forward_msg_id.as_ref().unwrap().0, "m2");
112    }
113
114    #[test]
115    fn test_serialize_deserialize_response() {
116        let resp = ResponseMessagesSendText {
117            msg_id: MsgId("m1".to_string()),
118        };
119        let val = serde_json::to_value(&resp).unwrap();
120        assert_eq!(val["msgId"], "m1");
121        let resp2: ResponseMessagesSendText = serde_json::from_value(val).unwrap();
122        assert_eq!(resp2.msg_id.0, "m1");
123    }
124
125    #[test]
126    fn test_request_missing_required_field() {
127        let val = serde_json::json!({"text": "hello"});
128        let req = serde_json::from_value::<RequestMessagesSendText>(val);
129        assert!(req.is_err());
130    }
131}