Revert "provide more detailed error info and align messages stylistically (#63)"

This reverts commit 3f55333.

Undo the semver break for a final 0.10.x release (#71).

Author: niklasf

src/clients/hyper_client.rs

@@ -71,7 +71,7 @@ impl WebPushClient for HyperWebPushClient {
         while let Some(chunk) = chunks.data().await {
             body.extend(&chunk?);
             if body.len() > MAX_RESPONSE_SIZE {
-                return Err(WebPushError::ResponseTooLarge);
+                return Err(WebPushError::InvalidResponse);
             }
         }
         trace!("Body: {:?}", body);
@@ -82,12 +82,8 @@ impl WebPushClient for HyperWebPushClient {
 
         debug!("Response: {:?}", response);
 
-        if let Err(WebPushError::ServerError {
-            retry_after: None,
-            info,
-        }) = response
-        {
-            Err(WebPushError::ServerError { retry_after, info })
+        if let Err(WebPushError::ServerError(None)) = response {
+            Err(WebPushError::ServerError(retry_after))
         } else {
             Ok(response?)
         }

src/clients/isahc_client.rs

@@ -75,7 +75,7 @@ impl WebPushClient for IsahcWebPushClient {
             .await?
             > MAX_RESPONSE_SIZE
         {
-            return Err(WebPushError::ResponseTooLarge);
+            return Err(WebPushError::InvalidResponse); // TODO: Use new error code
         }
         trace!("Body: {:?}", body);
 
@@ -85,12 +85,8 @@ impl WebPushClient for IsahcWebPushClient {
 
         trace!("Response: {:?}", response);
 
-        if let Err(WebPushError::ServerError {
-            retry_after: None,
-            info,
-        }) = response
-        {
-            Err(WebPushError::ServerError { retry_after, info })
+        if let Err(WebPushError::ServerError(None)) = response {
+            Err(WebPushError::ServerError(retry_after))
         } else {
             Ok(response?)
         }

src/clients/request_builder.rs

@@ -4,7 +4,15 @@
 use http::header::{CONTENT_ENCODING, CONTENT_LENGTH, CONTENT_TYPE};
 use http::{Request, StatusCode};
 
-use crate::{error::ErrorInfo, error::WebPushError, message::WebPushMessage};
+use crate::{error::WebPushError, message::WebPushMessage};
+
+#[derive(Deserialize, Serialize, Debug, PartialEq)]
+struct ErrorInfo {
+    code: u16,
+    errno: u16,
+    error: String,
+    message: String,
+}
 
 /// Builds the request to send to the push service.
 ///
@@ -64,28 +72,25 @@ where
 
 /// Parses the response from the push service, and will return `Err` if the request was bad.
 pub fn parse_response(response_status: StatusCode, body: Vec<u8>) -> Result<(), WebPushError> {
-    if response_status.is_success() {
-        return Ok(());
-    }
-
-    let info: ErrorInfo = serde_json::from_slice(&body).unwrap_or_else(|_| ErrorInfo {
-        code: response_status.as_u16(),
-        errno: 999,
-        error: "unknown error".into(),
-        message: String::from_utf8(body).unwrap_or_else(|_| "-".into()),
-    });
-
     match response_status {
-        StatusCode::UNAUTHORIZED => Err(WebPushError::Unauthorized(info)),
-        StatusCode::GONE => Err(WebPushError::EndpointNotValid(info)),
-        StatusCode::NOT_FOUND => Err(WebPushError::EndpointNotFound(info)),
+        status if status.is_success() => Ok(()),
+        status if status.is_server_error() => Err(WebPushError::ServerError(None)),
+
+        StatusCode::UNAUTHORIZED => Err(WebPushError::Unauthorized),
+        StatusCode::GONE => Err(WebPushError::EndpointNotValid),
+        StatusCode::NOT_FOUND => Err(WebPushError::EndpointNotFound),
         StatusCode::PAYLOAD_TOO_LARGE => Err(WebPushError::PayloadTooLarge),
-        StatusCode::BAD_REQUEST => Err(WebPushError::BadRequest(info)),
-        status if status.is_server_error() => Err(WebPushError::ServerError {
-            retry_after: None,
-            info,
-        }),
-        _ => Err(WebPushError::Other(info)),
+
+        StatusCode::BAD_REQUEST => match String::from_utf8(body) {
+            Err(_) => Err(WebPushError::BadRequest(None)),
+            Ok(body_str) => match serde_json::from_str::<ErrorInfo>(&body_str) {
+                Ok(error_info) => Err(WebPushError::BadRequest(Some(error_info.error))),
+                Err(_) if body_str.is_empty() => Err(WebPushError::BadRequest(None)),
+                Err(_) => Err(WebPushError::BadRequest(Some(body_str))),
+            },
+        },
+
+        e => Err(WebPushError::Other(format!("{:?}", e))),
     }
 }
 
@@ -159,76 +164,71 @@ mod tests {
 
     #[test]
     fn parses_a_successful_response_correctly() {
-        assert!(matches!(parse_response(StatusCode::OK, vec![]), Ok(())));
+        assert_eq!(Ok(()), parse_response(StatusCode::OK, vec![]))
     }
 
     #[test]
     fn parses_an_unauthorized_response_correctly() {
-        assert!(matches!(
-            parse_response(StatusCode::UNAUTHORIZED, vec![]),
-            Err(WebPushError::Unauthorized(_))
-        ));
+        assert_eq!(
+            Err(WebPushError::Unauthorized),
+            parse_response(StatusCode::UNAUTHORIZED, vec![])
+        )
     }
 
     #[test]
     fn parses_a_gone_response_correctly() {
-        assert!(matches!(
-            parse_response(StatusCode::GONE, vec![]),
-            Err(WebPushError::EndpointNotValid(_))
-        ));
+        assert_eq!(
+            Err(WebPushError::EndpointNotValid),
+            parse_response(StatusCode::GONE, vec![])
+        )
     }
 
     #[test]
     fn parses_a_not_found_response_correctly() {
-        assert!(matches!(
-            parse_response(StatusCode::NOT_FOUND, vec![]),
-            Err(WebPushError::EndpointNotFound(_))
-        ));
+        assert_eq!(
+            Err(WebPushError::EndpointNotFound),
+            parse_response(StatusCode::NOT_FOUND, vec![])
+        )
     }
 
     #[test]
     fn parses_a_payload_too_large_response_correctly() {
-        assert!(matches!(
-            parse_response(StatusCode::PAYLOAD_TOO_LARGE, vec![]),
-            Err(WebPushError::PayloadTooLarge)
-        ));
+        assert_eq!(
+            Err(WebPushError::PayloadTooLarge),
+            parse_response(StatusCode::PAYLOAD_TOO_LARGE, vec![])
+        )
     }
 
     #[test]
     fn parses_a_server_error_response_correctly() {
-        assert!(matches!(
-            parse_response(StatusCode::INTERNAL_SERVER_ERROR, vec![]),
-            Err(WebPushError::ServerError { .. })
-        ));
+        assert_eq!(
+            Err(WebPushError::ServerError(None)),
+            parse_response(StatusCode::INTERNAL_SERVER_ERROR, vec![])
+        )
     }
 
     #[test]
     fn parses_a_bad_request_response_with_no_body_correctly() {
-        assert!(matches!(
-            parse_response(StatusCode::BAD_REQUEST, vec![]),
-            Err(WebPushError::BadRequest(_))
-        ));
+        assert_eq!(
+            Err(WebPushError::BadRequest(None)),
+            parse_response(StatusCode::BAD_REQUEST, vec![])
+        )
     }
 
     #[test]
     fn parses_a_bad_request_response_with_body_correctly() {
         let json = r#"
             {
-                "code": 400,
+                "code": 404,
                 "errno": 103,
                 "error": "FooBar",
                 "message": "No message found"
             }
         "#;
 
-        assert!(matches!(
-            parse_response(StatusCode::BAD_REQUEST, json.as_bytes().to_vec()),
-            Err(WebPushError::BadRequest(ErrorInfo {
-                code: 400,
-                errno: 103,
-                error: _,
-                message: _,
-            })),
-        ));
+        assert_eq!(
+            Err(WebPushError::BadRequest(Some(String::from("FooBar")))),
+            parse_response(StatusCode::BAD_REQUEST, json.as_bytes().to_vec())
+        )
     }
 }

src/error.rs

@@ -6,49 +6,32 @@ use base64::DecodeError;
 use http::uri::InvalidUri;
 use serde_json::error::Error as JsonError;
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ErrorInfo {
-    pub code: u16,
-    pub errno: u16,
-    pub error: String,
-    pub message: String,
-}
-
-impl fmt::Display for ErrorInfo {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "code {}, errno {}: {} ({})",
-            self.code, self.errno, self.error, self.message
-        )
-    }
-}
-
-#[derive(Debug)]
+#[derive(PartialEq, Debug, Clone, Ord, PartialOrd, Eq, Deserialize, Serialize, Hash)]
 pub enum WebPushError {
-    /// An unknown error happened while encrypting or sending the message
+    /// An unknown error happened encrypting the message,
     Unspecified,
     /// Please provide valid credentials to send the notification
-    Unauthorized(ErrorInfo),
+    Unauthorized,
     /// Request was badly formed
-    BadRequest(ErrorInfo),
+    BadRequest(Option<String>),
     /// Contains an optional `Duration`, until the user can retry the request
-    ServerError {
-        retry_after: Option<Duration>,
-        info: ErrorInfo,
-    },
+    ServerError(Option<Duration>),
     /// The feature is not implemented yet
-    NotImplemented(ErrorInfo),
+    NotImplemented,
     /// The provided URI is invalid
     InvalidUri,
     /// The URL specified is no longer valid and should no longer be used
-    EndpointNotValid(ErrorInfo),
+    EndpointNotValid,
     /// The URL specified is invalid and should not be used again
-    EndpointNotFound(ErrorInfo),
+    EndpointNotFound,
     /// Maximum allowed payload size is 3800 characters
     PayloadTooLarge,
+    /// Could not initialize a TLS connection
+    TlsError,
+    /// Error in SSL signing
+    SslError,
     /// Error in reading a file
-    Io(IoError),
+    IoError,
     /// Make sure the message was addressed to a registration token whose
     /// package name matches the value passed in the request (Google).
     InvalidPackageName,
@@ -64,9 +47,7 @@ pub enum WebPushError {
     InvalidResponse,
     /// A claim had invalid data
     InvalidClaims,
-    /// Response from push endpoint was too large
-    ResponseTooLarge,
-    Other(ErrorInfo),
+    Other(String),
 }
 
 impl Error for WebPushError {}
@@ -104,8 +85,8 @@ impl From<isahc::Error> for WebPushError {
 }
 
 impl From<IoError> for WebPushError {
-    fn from(err: IoError) -> WebPushError {
-        WebPushError::Io(err)
+    fn from(_: IoError) -> WebPushError {
+        WebPushError::IoError
     }
 }
 
@@ -119,53 +100,65 @@ impl WebPushError {
     pub fn short_description(&self) -> &'static str {
         match *self {
             WebPushError::Unspecified => "unspecified",
-            WebPushError::Unauthorized(_) => "unauthorized",
+            WebPushError::Unauthorized => "unauthorized",
             WebPushError::BadRequest(_) => "bad_request",
-            WebPushError::ServerError { .. } => "server_error",
-            WebPushError::NotImplemented(_) => "not_implemented",
+            WebPushError::ServerError(_) => "server_error",
+            WebPushError::NotImplemented => "not_implemented",
             WebPushError::InvalidUri => "invalid_uri",
-            WebPushError::EndpointNotValid(_) => "endpoint_not_valid",
-            WebPushError::EndpointNotFound(_) => "endpoint_not_found",
+            WebPushError::EndpointNotValid => "endpoint_not_valid",
+            WebPushError::EndpointNotFound => "endpoint_not_found",
             WebPushError::PayloadTooLarge => "payload_too_large",
+            WebPushError::TlsError => "tls_error",
             WebPushError::InvalidPackageName => "invalid_package_name",
             WebPushError::InvalidTtl => "invalid_ttl",
             WebPushError::InvalidTopic => "invalid_topic",
             WebPushError::InvalidResponse => "invalid_response",
             WebPushError::MissingCryptoKeys => "missing_crypto_keys",
             WebPushError::InvalidCryptoKeys => "invalid_crypto_keys",
-            WebPushError::Io(_) => "io_error",
+            WebPushError::SslError => "ssl_error",
+            WebPushError::IoError => "io_error",
             WebPushError::Other(_) => "other",
             WebPushError::InvalidClaims => "invalidClaims",
-            WebPushError::ResponseTooLarge => "response_too_large",
         }
     }
 }
 
 impl fmt::Display for WebPushError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            WebPushError::Unspecified => write!(f, "unspecified error"),
-            WebPushError::Unauthorized(info) => write!(f, "unauthorized: {}", info),
-            WebPushError::BadRequest(info) => write!(f, "bad request: {}", info),
-            WebPushError::ServerError { info, .. } => write!(f, "server error: {}", info),
-            WebPushError::PayloadTooLarge => write!(f, "maximum payload size of 3070 characters exceeded"),
-            WebPushError::InvalidUri => write!(f, "invalid uri provided"),
-            WebPushError::NotImplemented(info) => write!(f, "not implemented: {}", info),
-            WebPushError::EndpointNotValid(info) => write!(f, "endpoint not valid: {}", info),
-            WebPushError::EndpointNotFound(info) => write!(f, "endpoint not found: {}", info),
-            WebPushError::Io(err) => write!(f, "i/o error: {}", err),
-            WebPushError::InvalidPackageName => write!(
-                f,
-                "package name of registration token does not match package name provided in the request"
-            ),
-            WebPushError::InvalidTtl => write!(f, "invalid or missing ttl value"),
-            WebPushError::InvalidTopic => write!(f, "invalid topic value"),
-            WebPushError::InvalidResponse => write!(f, "could not parse response data"),
-            WebPushError::MissingCryptoKeys => write!(f, "request is missing cryptographic keys"),
-            WebPushError::InvalidCryptoKeys => write!(f, "request has invalid cryptographic keys"),
-            WebPushError::Other(info) => write!(f, "other: {}", info),
-            WebPushError::InvalidClaims => write!(f, "at least one jwt claim was invalid"),
-            WebPushError::ResponseTooLarge => write!(f, "response from push endpoint was too large"),
+        match *self {
+            WebPushError::Unspecified =>
+                write!(f, "An unknown error happened encrypting the message"),
+            WebPushError::Unauthorized =>
+                write!(f, "Please provide valid credentials to send the notification"),
+            WebPushError::BadRequest(_) =>
+                write!(f, "Request was badly formed"),
+            WebPushError::ServerError(_) =>
+                write!(f, "Server was unable to process the request, please try again later"),
+            WebPushError::PayloadTooLarge =>
+                write!(f, "Maximum allowed payload size is 3070 characters"),
+            WebPushError::InvalidUri =>
+                write!(f, "The provided URI is invalid"),
+            WebPushError::NotImplemented =>
+                write!(f, "The feature is not implemented yet"),
+            WebPushError::EndpointNotValid =>
+                write!(f, "The URL specified is no longer valid and should no longer be used"),
+            WebPushError::EndpointNotFound =>
+                write!(f, "The URL specified is invalid and should not be used again"),
+            WebPushError::TlsError =>
+                write!(f, "Could not initialize a TLS connection"),
+            WebPushError::SslError =>
+                write!(f, "Error signing with SSL"),
+            WebPushError::IoError =>
+                write!(f, "Error opening a file"),
+            WebPushError::InvalidPackageName =>
+                write!(f, "Make sure the message was addressed to a registration token whose package name matches the value passed in the request."),
+            WebPushError::InvalidTtl => write!(f, "The TTL value provided was not valid or was not provided"),
+            WebPushError::InvalidTopic => write!(f, "The Topic value provided was invalid"),
+            WebPushError::InvalidResponse => write!(f, "The response data couldn't be parses"),
+            WebPushError::MissingCryptoKeys  => write!(f, "The request is missing cryptographic keys"),
+            WebPushError::InvalidCryptoKeys  => write!(f, "The request is having invalid cryptographic keys"),
+            WebPushError::Other(_) => write!(f, "An unknown error when connecting the notification service"),
+            WebPushError::InvalidClaims => write!(f, "At least one JWT claim was invalid.")
         }
     }
 }