slack_rust/chat/
delete.rs

1//! Deletes a message.  
2//! See: <https://api.slack.com/methods/chat.delete>
3
4use crate::error::Error;
5use crate::http_client::{get_slack_url, ResponseMetadata, SlackWebAPIClient};
6use serde::{Deserialize, Serialize};
7use serde_with::skip_serializing_none;
8
9#[skip_serializing_none]
10#[derive(Deserialize, Serialize, Debug, Default, PartialEq)]
11pub struct DeleteRequest {
12    pub channel: String,
13    pub ts: String,
14    pub as_user: Option<bool>,
15}
16
17#[skip_serializing_none]
18#[derive(Deserialize, Serialize, Debug, Default, PartialEq)]
19pub struct DeleteResponse {
20    pub ok: bool,
21    pub error: Option<String>,
22    pub response_metadata: Option<ResponseMetadata>,
23    pub channel: Option<String>,
24    pub ts: Option<String>,
25}
26
27/// Deletes a message.
28/// See: <https://api.slack.com/methods/chat.delete>
29pub async fn delete<T>(
30    client: &T,
31    param: &DeleteRequest,
32    bot_token: &str,
33) -> Result<DeleteResponse, Error>
34where
35    T: SlackWebAPIClient,
36{
37    let url = get_slack_url("chat.delete");
38    let json = serde_json::to_string(&param)?;
39
40    client
41        .post_json(&url, &json, bot_token)
42        .await
43        .and_then(|result| {
44            serde_json::from_str::<DeleteResponse>(&result).map_err(Error::SerdeJsonError)
45        })
46}
47
48#[cfg(test)]
49mod test {
50    use super::*;
51    use crate::http_client::MockSlackWebAPIClient;
52
53    #[test]
54    fn convert_request() {
55        let request = DeleteRequest {
56            channel: "C1234567890".to_string(),
57            ts: "1405894322.002768".to_string(),
58            as_user: Some(true),
59        };
60        let json = r##"{
61  "channel": "C1234567890",
62  "ts": "1405894322.002768",
63  "as_user": true
64}"##;
65
66        let j = serde_json::to_string_pretty(&request).unwrap();
67        assert_eq!(json, j);
68
69        let s = serde_json::from_str::<DeleteRequest>(json).unwrap();
70        assert_eq!(request, s);
71    }
72
73    #[test]
74    fn convert_response() {
75        let response = DeleteResponse {
76            ok: true,
77            channel: Some("C1234567890".to_string()),
78            ts: Some("1405894322.002768".to_string()),
79            ..Default::default()
80        };
81        let json = r##"{
82  "ok": true,
83  "channel": "C1234567890",
84  "ts": "1405894322.002768"
85}"##;
86
87        let j = serde_json::to_string_pretty(&response).unwrap();
88        assert_eq!(json, j);
89
90        let s = serde_json::from_str::<DeleteResponse>(json).unwrap();
91        assert_eq!(response, s);
92    }
93
94    #[async_std::test]
95    async fn test_delete() {
96        let param = DeleteRequest {
97            channel: "C1234567890".to_string(),
98            ts: "1405894322.002768".to_string(),
99            as_user: Some(true),
100        };
101
102        let mut mock = MockSlackWebAPIClient::new();
103        mock.expect_post_json().returning(|_, _, _| {
104            Ok(r##"{
105  "ok": true,
106  "channel": "C1234567890",
107  "ts": "1405894322.002768"
108}"##
109            .to_string())
110        });
111
112        let response = delete(&mock, &param, &"test_token".to_string())
113            .await
114            .unwrap();
115        let expect = DeleteResponse {
116            ok: true,
117            channel: Some("C1234567890".to_string()),
118            ts: Some("1405894322.002768".to_string()),
119            ..Default::default()
120        };
121
122        assert_eq!(expect, response);
123    }
124}