slack_rust/usergroups/users/
update.rs

1use crate::error::Error;
2use crate::http_client::{get_slack_url, ResponseMetadata, SlackWebAPIClient};
3use crate::usergroups::usergroup::Usergroup;
4use serde::{Deserialize, Serialize};
5use serde_with::skip_serializing_none;
6
7#[skip_serializing_none]
8#[derive(Deserialize, Serialize, Debug, Default, PartialEq)]
9pub struct UpdateRequest {
10    pub usergroup: String,
11    pub users: String,
12    pub include_count: Option<bool>,
13    pub team_id: Option<String>,
14}
15
16#[skip_serializing_none]
17#[derive(Deserialize, Serialize, Debug, Default, PartialEq)]
18pub struct UpdateResponse {
19    pub ok: bool,
20    pub error: Option<String>,
21    pub response_metadata: Option<ResponseMetadata>,
22    pub usergroup: Option<Usergroup>,
23}
24
25pub async fn update<T>(
26    client: &T,
27    param: &UpdateRequest,
28    bot_token: &str,
29) -> Result<UpdateResponse, Error>
30where
31    T: SlackWebAPIClient,
32{
33    let url = get_slack_url("usergroups.users.update");
34    let json = serde_json::to_string(&param)?;
35
36    client
37        .post_json(&url, &json, bot_token)
38        .await
39        .and_then(|result| {
40            serde_json::from_str::<UpdateResponse>(&result).map_err(Error::SerdeJsonError)
41        })
42}
43
44#[cfg(test)]
45mod test {
46    use super::*;
47    use crate::http_client::MockSlackWebAPIClient;
48    use crate::usergroups::usergroup::Pref;
49
50    #[test]
51    fn convert_request() {
52        let request = UpdateRequest {
53            usergroup: "S0604QSJC".to_string(),
54            users: "U060R4BJ4,U060RNRCZ".to_string(),
55            team_id: Some("T1234567890".to_string()),
56            include_count: Some(true),
57        };
58        let json = r##"{
59  "usergroup": "S0604QSJC",
60  "users": "U060R4BJ4,U060RNRCZ",
61  "include_count": true,
62  "team_id": "T1234567890"
63}"##;
64
65        let j = serde_json::to_string_pretty(&request).unwrap();
66        assert_eq!(json, j);
67
68        let s = serde_json::from_str::<UpdateRequest>(json).unwrap();
69        assert_eq!(request, s);
70    }
71
72    #[test]
73    fn convert_response() {
74        let response = UpdateResponse {
75            ok: true,
76            usergroup: Some(Usergroup {
77                id: Some("S0615G0KT".to_string()),
78                team_id: Some("T060RNRCH".to_string()),
79                is_usergroup: Some(true),
80                name: Some("Marketing Team".to_string()),
81                description: Some("Marketing gurus, PR experts and product advocates.".to_string()),
82                handle: Some("marketing-team".to_string()),
83                is_external: Some(false),
84                date_create: Some(1446746793),
85                date_update: Some(1446746793),
86                date_delete: Some(0),
87                auto_type: Some("".to_string()),
88                created_by: Some("U060RNRCZ".to_string()),
89                updated_by: Some("U060RNRCZ".to_string()),
90                deleted_by: Some("".to_string()),
91                prefs: Some(Pref {
92                    channels: Some(vec![]),
93                    groups: Some(vec![]),
94                }),
95                user_count: Some("0".to_string()),
96            }),
97            ..Default::default()
98        };
99        let json = r##"{
100  "ok": true,
101  "usergroup": {
102    "id": "S0615G0KT",
103    "team_id": "T060RNRCH",
104    "is_usergroup": true,
105    "name": "Marketing Team",
106    "description": "Marketing gurus, PR experts and product advocates.",
107    "handle": "marketing-team",
108    "is_external": false,
109    "date_create": 1446746793,
110    "date_update": 1446746793,
111    "date_delete": 0,
112    "auto_type": "",
113    "created_by": "U060RNRCZ",
114    "updated_by": "U060RNRCZ",
115    "deleted_by": "",
116    "prefs": {
117      "channels": [],
118      "groups": []
119    },
120    "user_count": "0"
121  }
122}"##;
123
124        let j = serde_json::to_string_pretty(&response).unwrap();
125        assert_eq!(json, j);
126
127        let s = serde_json::from_str::<UpdateResponse>(json).unwrap();
128        assert_eq!(response, s);
129    }
130
131    #[async_std::test]
132    async fn test_update() {
133        let param = UpdateRequest {
134            usergroup: "S0604QSJC".to_string(),
135            users: "U060R4BJ4,U060RNRCZ".to_string(),
136            team_id: Some("T1234567890".to_string()),
137            include_count: Some(true),
138        };
139        let mut mock = MockSlackWebAPIClient::new();
140        mock.expect_post_json().returning(|_, _, _| {
141            Ok(r##"{
142  "ok": true,
143  "usergroup": {
144    "id": "S0615G0KT",
145    "team_id": "T1234567890",
146    "is_usergroup": true,
147    "name": "My Test Team",
148    "description": "Marketing gurus, PR experts and product advocates.",
149    "handle": "marketing-team",
150    "is_external": false,
151    "date_create": 1446746793,
152    "date_update": 1446746793,
153    "date_delete": 0,
154    "auto_type": "",
155    "created_by": "U060RNRCZ",
156    "updated_by": "U060RNRCZ",
157    "deleted_by": "",
158    "prefs": {
159      "channels": [],
160      "groups": []
161    },
162    "user_count": "0"
163  }
164}"##
165            .to_string())
166        });
167
168        let response = update(&mock, &param, &"test_token".to_string())
169            .await
170            .unwrap();
171        let expect = UpdateResponse {
172            ok: true,
173            usergroup: Some(Usergroup {
174                id: Some("S0615G0KT".to_string()),
175                team_id: Some("T1234567890".to_string()),
176                is_usergroup: Some(true),
177                name: Some("My Test Team".to_string()),
178                description: Some("Marketing gurus, PR experts and product advocates.".to_string()),
179                handle: Some("marketing-team".to_string()),
180                is_external: Some(false),
181                date_create: Some(1446746793),
182                date_update: Some(1446746793),
183                date_delete: Some(0),
184                auto_type: Some("".to_string()),
185                created_by: Some("U060RNRCZ".to_string()),
186                updated_by: Some("U060RNRCZ".to_string()),
187                deleted_by: Some("".to_string()),
188                prefs: Some(Pref {
189                    channels: Some(vec![]),
190                    groups: Some(vec![]),
191                }),
192                user_count: Some("0".to_string()),
193            }),
194            ..Default::default()
195        };
196
197        assert_eq!(expect, response);
198    }
199}