clickatell-api 0.3.0

Send messages to mobile phones via Clickatell messaging gateways
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

use crate::one_api::send_messages::GatewayError;
use serde::Deserialize;

/// Response for a message sent to the gateway
#[derive(Deserialize, Clone, Debug, PartialEq)]
pub struct MessageResponse {
  /// Unique message identifier - `None` if an error occurs processing the message,
  /// `Some` if successful
  #[serde(rename = "apiMessageId")]
  api_message_id: Option<String>,
  /// Message accepted for processing
  accepted: bool,
  /// Message destination
  pub to: String,
  /// Error preventing message being processed, `None` if successfully processed
  pub error: Option<GatewayError>,
}

impl MessageResponse {
  /// Unique message identifier
  ///
  /// If there was an error processing the message, this will return an empty string.
  pub fn message_id(&self) -> String {
    match &self.api_message_id {
      Some(message_id) => message_id.clone(),
      None => String::from(""),
    }
  }

  /// Convenience method to check if an error occured processing the message
  pub fn is_error(&self) -> bool {
    self.error.is_some()
  }
}

#[test]
fn test_deserialize() {
  use crate::one_api::send_messages;

  let succcess_202 = r#"{
      "messages": [
        {
          "apiMessageId": "02ca87d5a95446e68b0ac36a0c2057f1",
          "accepted": true,
          "to": "2799900001"
        },
        {
          "apiMessageId": "b71d513be46f4b29b16c2f354c7eef07",
          "accepted": true,
          "to": "2799900002"
        }
      ],
      "error": null
    }"#;

  let send_messages_response: send_messages::Response = serde_json::from_str(succcess_202).unwrap();
  assert_eq!(None, send_messages_response.error);

  let messages = send_messages_response.messages();
  assert_eq!(2, messages.len());

  let success_207 = r#"{
      "messages": [
        {
          "apiMessageId": "cd2d90701afe42cdb15e2670218d8567",
          "accepted": true,
          "to": "2799900001"
        },
        {
          "error": {
            "code": 23,
            "description": "Invalid or missing parameter: to ."
          },
          "accepted": false,
          "to": "27999abcde"
        }
      ],
      "error": null
    }"#;

  let send_message_response: send_messages::Response = serde_json::from_str(success_207).unwrap();
  assert_eq!(None, send_message_response.error);

  let messages = send_message_response.messages();
  assert_eq!(2, messages.len());

  let error_message = messages[1].clone();
  let error = error_message.error.unwrap();
  assert_eq!(
    send_messages::GatewayErrorCode::InvalidOrMissingParameter,
    error.code
  );

  let error_400 = r#"{
      "messages": [
        {
          "error": {
            "code": 23,
            "description": "Invalid or missing parameter: to ."
          },
          "accepted": false,
          "to": "27999abcde"
        }
      ],
      "error": null
    }"#;

  let send_message_response: send_messages::Response = serde_json::from_str(error_400).unwrap();
  assert_eq!(None, send_message_response.error);

  let messages = send_message_response.messages();
  assert_eq!(1, messages.len());

  let error_message = messages[0].clone();
  let error = error_message.error.unwrap();
  assert_eq!(
    send_messages::GatewayErrorCode::InvalidOrMissingParameter,
    error.code
  );

  let error_401 = r#"{
      "error": {
        "code": 1,
        "description": "Invalid or missing integration API Key"
      }
    }"#;

  let send_message_response: send_messages::Response = serde_json::from_str(error_401).unwrap();
  assert!(send_message_response.messages().is_empty());

  let error = send_message_response.error.unwrap();
  assert_eq!(
    send_messages::GatewayErrorCode::InvalidOrMissingIntegrationAPIKey,
    error.code
  )
}