clickatell_api/one_api/send_messages/
message_response.rs

1use crate::one_api::send_messages::GatewayError;
2use serde::Deserialize;
3
4/// Response for a message sent to the gateway
5#[derive(Deserialize, Clone, Debug, PartialEq)]
6pub struct MessageResponse {
7  /// Unique message identifier - `None` if an error occurs processing the message,
8  /// `Some` if successful
9  #[serde(rename = "apiMessageId")]
10  api_message_id: Option<String>,
11  /// Message accepted for processing
12  accepted: bool,
13  /// Message destination
14  pub to: String,
15  /// Error preventing message being processed, `None` if successfully processed
16  pub error: Option<GatewayError>,
17}
18
19impl MessageResponse {
20  /// Unique message identifier
21  ///
22  /// If there was an error processing the message, this will return an empty string.
23  pub fn message_id(&self) -> String {
24    match &self.api_message_id {
25      Some(message_id) => message_id.clone(),
26      None => String::from(""),
27    }
28  }
29
30  /// Convenience method to check if an error occured processing the message
31  pub fn is_error(&self) -> bool {
32    self.error.is_some()
33  }
34}
35
36#[test]
37fn test_deserialize() {
38  use crate::one_api::send_messages;
39
40  let succcess_202 = r#"{
41      "messages": [
42        {
43          "apiMessageId": "02ca87d5a95446e68b0ac36a0c2057f1",
44          "accepted": true,
45          "to": "2799900001"
46        },
47        {
48          "apiMessageId": "b71d513be46f4b29b16c2f354c7eef07",
49          "accepted": true,
50          "to": "2799900002"
51        }
52      ],
53      "error": null
54    }"#;
55
56  let send_messages_response: send_messages::Response = serde_json::from_str(succcess_202).unwrap();
57  assert_eq!(None, send_messages_response.error);
58
59  let messages = send_messages_response.messages();
60  assert_eq!(2, messages.len());
61
62  let success_207 = r#"{
63      "messages": [
64        {
65          "apiMessageId": "cd2d90701afe42cdb15e2670218d8567",
66          "accepted": true,
67          "to": "2799900001"
68        },
69        {
70          "error": {
71            "code": 23,
72            "description": "Invalid or missing parameter: to ."
73          },
74          "accepted": false,
75          "to": "27999abcde"
76        }
77      ],
78      "error": null
79    }"#;
80
81  let send_message_response: send_messages::Response = serde_json::from_str(success_207).unwrap();
82  assert_eq!(None, send_message_response.error);
83
84  let messages = send_message_response.messages();
85  assert_eq!(2, messages.len());
86
87  let error_message = messages[1].clone();
88  let error = error_message.error.unwrap();
89  assert_eq!(
90    send_messages::GatewayErrorCode::InvalidOrMissingParameter,
91    error.code
92  );
93
94  let error_400 = r#"{
95      "messages": [
96        {
97          "error": {
98            "code": 23,
99            "description": "Invalid or missing parameter: to ."
100          },
101          "accepted": false,
102          "to": "27999abcde"
103        }
104      ],
105      "error": null
106    }"#;
107
108  let send_message_response: send_messages::Response = serde_json::from_str(error_400).unwrap();
109  assert_eq!(None, send_message_response.error);
110
111  let messages = send_message_response.messages();
112  assert_eq!(1, messages.len());
113
114  let error_message = messages[0].clone();
115  let error = error_message.error.unwrap();
116  assert_eq!(
117    send_messages::GatewayErrorCode::InvalidOrMissingParameter,
118    error.code
119  );
120
121  let error_401 = r#"{
122      "error": {
123        "code": 1,
124        "description": "Invalid or missing integration API Key"
125      }
126    }"#;
127
128  let send_message_response: send_messages::Response = serde_json::from_str(error_401).unwrap();
129  assert!(send_message_response.messages().is_empty());
130
131  let error = send_message_response.error.unwrap();
132  assert_eq!(
133    send_messages::GatewayErrorCode::InvalidOrMissingIntegrationAPIKey,
134    error.code
135  )
136}