vkteams_bot/api/chats/
resolve_pendings.rs

1//! Resolve pendings in chat method `chats/resolvePending`
2//! [More info](https://teams.vk.com/botapi/#/chats/get_chats_resolvePending)
3use crate::api::types::*;
4bot_api_method! {
5    method   = "chats/resolvePending",
6    request  = RequestChatsResolvePending {
7        required {
8            chat_id: ChatId,
9            approve: bool,
10        },
11        optional {
12            user_id: UserId,
13            everyone: bool,
14        }
15    },
16    response = ResponseChatsResolvePending {},
17}
18
19#[cfg(test)]
20mod tests {
21    use super::*;
22    use crate::api::types::{ChatId, UserId};
23    use serde_json::json;
24
25    #[test]
26    fn test_request_chats_resolve_pending_serialize() {
27        let req = RequestChatsResolvePending {
28            chat_id: ChatId::from("c1"),
29            approve: true,
30            user_id: Some(UserId("u1".to_string())),
31            everyone: Some(false),
32        };
33        let val = serde_json::to_value(&req).unwrap();
34        assert_eq!(val["chatId"], "c1");
35        assert_eq!(val["approve"], true);
36        assert_eq!(val["userId"], "u1");
37        assert_eq!(val["everyone"], false);
38    }
39
40    #[test]
41    fn test_request_chats_resolve_pending_deserialize() {
42        let val = json!({"chatId": "c2", "approve": false, "userId": "u2", "everyone": true});
43        let req: RequestChatsResolvePending = serde_json::from_value(val).unwrap();
44        assert_eq!(req.chat_id.0, "c2");
45        assert!(!req.approve);
46        assert_eq!(req.user_id.as_ref().unwrap().0, "u2");
47        assert_eq!(req.everyone, Some(true));
48    }
49
50    #[test]
51    fn test_request_chats_resolve_pending_missing_optional() {
52        let val = json!({"chatId": "c3", "approve": true});
53        let req: RequestChatsResolvePending = serde_json::from_value(val).unwrap();
54        assert_eq!(req.chat_id.0, "c3");
55        assert!(req.approve);
56        assert!(req.user_id.is_none());
57        assert!(req.everyone.is_none());
58    }
59
60    #[test]
61    fn test_request_chats_resolve_pending_missing_required() {
62        let val = json!({"chatId": "c4"});
63        let req = serde_json::from_value::<RequestChatsResolvePending>(val);
64        assert!(req.is_err());
65    }
66
67    #[test]
68    fn test_request_chats_resolve_pending_invalid_types() {
69        let val = json!({"chatId": 123, "approve": "yes"});
70        let req = serde_json::from_value::<RequestChatsResolvePending>(val);
71        assert!(req.is_err());
72    }
73
74    #[test]
75    fn test_response_chats_resolve_pending_serialize() {
76        let resp = ResponseChatsResolvePending {};
77        let val = serde_json::to_value(&resp).unwrap();
78        assert_eq!(val.as_object().unwrap().len(), 0);
79    }
80
81    #[test]
82    fn test_response_chats_resolve_pending_deserialize() {
83        let val = json!({});
84        let resp: ResponseChatsResolvePending = serde_json::from_value(val).unwrap();
85        let _ = resp;
86    }
87}