mmrs 0.1.4

Small library to send POST requests to MatterMost Server
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use std::error::Error;
use std::fmt;

use serde::{Deserialize, Serialize};
use serde_json as json;

/// Creating a custom error for mapping Errors to return result from the library handles
/// The possible errors so far are BadJSONData and HTTPRequestError
/// BadJSONData maps to a serde_json::error::Error
/// HTTPRequestError maps to a reqwest::Error
#[derive(Debug)]
pub enum MMRSError {
    BadJSONData(serde_json::error::Error),
    HTTPRequestError(reqwest::Error),
}

impl fmt::Display for MMRSError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            MMRSError::BadJSONData(e) => write!(f, "Error writing to JSON string: {}", e),
            MMRSError::HTTPRequestError(e) => write!(f, "Error while sending HTTP POST: {}", e),
        }
    }
}

impl Error for MMRSError {}

/// Custom struct to serialize the HTTP POST data into a json objecting using serde_json
/// For a description of these fields see the [Official MatterMost Developer Documentation](https://developers.mattermost.com/integrate/incoming-webhooks/#parameters)
#[derive(Serialize, Deserialize, Default)]
pub struct MMBody {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub text: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub channel: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub username: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub icon_url: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub icon_emoji: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub attachments: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub props: Option<String>,
}

impl MMBody {
    pub fn new() -> MMBody {
        MMBody::default()
    }

    /// This function allows us to convert from the struct to a string of JSON which a web server
    /// will accept
    pub fn to_json(self) -> Result<String, MMRSError> {
        json::to_string(&self).map_err(MMRSError::BadJSONData)
    }
}

/// Main function of the library which asynchronously sends the request and returns the status code
/// response. Will error out on a reqwest::Error if the send results in a failure
#[tokio::main]
pub async fn send_message(uri: &str, body: String) -> Result<reqwest::StatusCode, MMRSError> {
    let status_code: reqwest::StatusCode = reqwest::Client::new()
        .post(uri)
        .body(body)
        .send()
        .await
        .map_err(MMRSError::HTTPRequestError)?
        .status();

    Ok(status_code)
}

#[cfg(test)]
mod tests {
    #[test]
    fn create_body() {
        use crate as mmrs;

        let x: mmrs::MMBody = mmrs::MMBody::new();
        assert_eq!(x.text, None);
    }

    #[test]
    fn modify_body() {
        use crate as mmrs;

        let mut x: mmrs::MMBody = mmrs::MMBody::new();

        x.text = Some("Hello world!".to_string());
        assert_eq!(x.text, Some("Hello world!".to_string()));
    }

    #[test]
    fn json_check() {
        use crate as mmrs;

        let x: mmrs::MMBody = mmrs::MMBody {
            text: Some("Hello, world!".to_string()),
            channel: None,
            username: None,
            icon_url: None,
            icon_emoji: None,
            attachments: None,
            r#type: None,
            props: None,
        };

        let body = x.to_json().unwrap();

        assert_eq!(body, "{\"text\":\"Hello, world!\"}");
    }

    #[test]
    fn send_test() {
        use crate as mmrs;
        use mockito::{Matcher, Server};
        let mut s = Server::new();

        let _m = s
            .mock("POST", "/")
            .match_body(Matcher::JsonString(
                "{\"text\":\"Hello, world!\"}".to_string(),
            ))
            .create();

        let x: mmrs::MMBody = mmrs::MMBody {
            text: Some("Hello, world!".to_string()),
            channel: None,
            username: None,
            icon_url: None,
            icon_emoji: None,
            attachments: None,
            r#type: None,
            props: None,
        };

        let body = x.to_json().unwrap();

        assert_eq!(
            mmrs::send_message(&s.url(), body.to_string()).unwrap(),
            reqwest::StatusCode::OK
        );
    }
}