fix(errors): convert ses invalid domain error into a 400

Author: philbooth

Cargo.lock

@@ -39,6 +39,7 @@ reqwest = ">=0.8.5"
 rocket = ">=0.3.17"
 rocket_codegen = ">=0.3.17"
 rocket_contrib = ">=0.3.17"
+roxmltree = ">=0.3.0"
 rusoto_core = ">=0.34.0"
 rusoto_credential = ">=0.13.0"
 rusoto_mock = ">=0.28.0"

Cargo.toml

@@ -54,6 +54,7 @@ extern crate reqwest;
 extern crate rocket;
 #[macro_use]
 extern crate rocket_contrib;
+extern crate roxmltree;
 extern crate rusoto_core;
 extern crate rusoto_credential;
 extern crate rusoto_ses;

src/lib.rs

@@ -5,12 +5,16 @@
 use std::boxed::Box;
 
 use base64;
+use roxmltree::Document as XmlDocument;
 use rusoto_core::{request::HttpClient, Region};
 use rusoto_credential::StaticProvider;
-use rusoto_ses::{RawMessage, SendRawEmailRequest, Ses, SesClient};
+use rusoto_ses::{RawMessage, SendRawEmailError, SendRawEmailRequest, Ses, SesClient};
 
 use super::{build_multipart_mime, Headers, Provider};
-use crate::{settings::Settings, types::error::AppResult};
+use crate::{
+    settings::Settings,
+    types::error::{AppError, AppErrorKind, AppResult},
+};
 
 #[cfg(test)]
 mod test;
@@ -77,3 +81,53 @@ impl Provider for SesProvider {
             .map_err(From::from)
     }
 }
+
+impl From<SendRawEmailError> for AppError {
+    fn from(error: SendRawEmailError) -> Self {
+        if let SendRawEmailError::Unknown(ref body) = error {
+            if let Ok(xml) = XmlDocument::parse(body) {
+                for child in xml.root_element().children() {
+                    if child.is_element() && child.tag_name().name() == "Error" {
+                        let mut is_invalid_payload = false;
+                        let mut error_message = None;
+                        let mut error_property = None;
+
+                        for grandchild in child.children() {
+                            if grandchild.is_element() {
+                                match grandchild.tag_name().name() {
+                                    "Code" => {
+                                        is_invalid_payload =
+                                            grandchild.text() == Some("InvalidParameterValue")
+                                    }
+                                    "Message" => {
+                                        error_message =
+                                            grandchild.text().map(|message| message.to_owned())
+                                    }
+                                    "Type" => {
+                                        error_property =
+                                            grandchild.text().map(|property| property.to_owned())
+                                    }
+                                    _ => {}
+                                }
+                            }
+                        }
+
+                        if is_invalid_payload {
+                            return AppErrorKind::InvalidPayload(error_message.unwrap_or_else(
+                                || {
+                                    format!(
+                                        "Invalid {}",
+                                        error_property.unwrap_or_else(|| "parameter".to_owned())
+                                    )
+                                },
+                            ))
+                            .into();
+                        }
+                    }
+                }
+            }
+        }
+
+        AppErrorKind::Internal(format!("{:?}", error)).into()
+    }
+}

src/providers/ses/mod.rs

@@ -91,3 +91,36 @@ fn ses_send_handles_error_response() {
     assert_eq!(error.error(), "Internal Server Error");
     assert_eq!(error.to_string(), "Unknown(\"FREAKOUT\")");
 }
+
+#[test]
+fn ses_send_handles_invalid_domain_response() {
+    let body = r#"
+        <ErrorResponse xmlns="http://ses.amazonaws.com/doc/2010-12-01/">
+          <Error>
+            <Type>Sender</Type>
+            <Code>InvalidParameterValue</Code>
+            <Message>Invalid domain name: gmail.com.com</Message>
+          </Error>
+          <RequestId>f972bc68-f90c-11e8-90d8-9f9fb80f3486</RequestId>
+        </ErrorResponse>
+    "#;
+    let mock_dispatcher = MockRequestDispatcher::with_status(500).with_body(&body);
+    let mock_ses = SesProvider {
+        client: Box::new(SesClient::new_with(
+            mock_dispatcher,
+            MockCredentialsProvider,
+            Region::SaEast1,
+        )),
+        sender: "Wibble <blee@example.com>".to_string(),
+    };
+    let result = mock_ses.send("blee@gmail.com.com", &[], None, "subject", "body", None);
+    assert!(result.is_err());
+    let error = result.unwrap_err();
+    assert_eq!(error.code(), 400);
+    assert_eq!(error.errno().unwrap(), 102);
+    assert_eq!(error.error(), "Bad Request");
+    assert_eq!(
+        error.to_string(),
+        "Invalid payload: Invalid domain name: gmail.com.com"
+    );
+}

src/providers/ses/test.rs

@@ -24,7 +24,6 @@ use rocket::{
     Outcome, Request, State,
 };
 use rocket_contrib::Json;
-use rusoto_ses::SendRawEmailError;
 use sendgrid::errors::SendgridError;
 use serde::ser::{Serialize, SerializeMap, Serializer};
 use serde_json::{map::Map, ser::to_string, Error as JsonError, Value};
@@ -277,7 +276,6 @@ to_internal_error!(JsonError);
 to_internal_error!(RedisError);
 to_internal_error!(RequestError);
 to_internal_error!(SendgridError);
-to_internal_error!(SendRawEmailError);
 to_internal_error!(SmtpError);
 to_internal_error!(SocketLabsError);
 to_internal_error!(ToStrError);