test(aggregator-client): add aggregatorClientError tests

imported from mithril-signer client

Author: Alenar

internal/mithril-aggregator-client/src/error.rs

@@ -10,12 +10,12 @@ use crate::JSON_CONTENT_TYPE;
 /// Error structure for the Aggregator Client.
 #[derive(Error, Debug)]
 pub enum AggregatorClientError {
-    /// The aggregator host has returned a technical error.
-    #[error("remote server technical error")]
+    /// Error raised when querying the aggregator returned a 5XX error.
+    #[error("Internal error of the Aggregator")]
     RemoteServerTechnical(#[source] StdError),
 
-    /// The aggregator host responded it cannot fulfill our request.
-    #[error("remote server logical error")]
+    /// Error raised when querying the aggregator returned a 4XX error.
+    #[error("Invalid request to the Aggregator")]
     RemoteServerLogical(#[source] StdError),
 
     /// Could not reach aggregator.
@@ -33,6 +33,10 @@ pub enum AggregatorClientError {
     /// Failed to join the query endpoint to the aggregator url
     #[error("Invalid endpoint")]
     InvalidEndpoint(#[source] StdError),
+
+    /// No signer registration round opened yet
+    #[error("A signer registration round is not opened yet, please try again later")]
+    RegistrationRoundNotYetOpened(#[source] StdError),
 }
 
 impl AggregatorClientError {
@@ -49,7 +53,10 @@ impl AggregatorClientError {
             Self::RemoteServerLogical(anyhow!(root_cause))
         } else if error_code.is_server_error() {
             let root_cause = Self::get_root_cause(response).await;
-            Self::RemoteServerTechnical(anyhow!(root_cause))
+            match error_code.as_u16() {
+                550 => Self::RegistrationRoundNotYetOpened(anyhow!(root_cause)),
+                _ => Self::RemoteServerTechnical(anyhow!(root_cause)),
+            }
         } else {
             let response_text = response.text().await.unwrap_or_default();
             Self::UnhandledStatusCode(error_code, response_text)
@@ -87,3 +94,162 @@ impl AggregatorClientError {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use http::response::Builder as HttpResponseBuilder;
+    use serde_json::json;
+
+    use super::*;
+
+    macro_rules! assert_error_text_contains {
+        ($error: expr, $expect_contains: expr) => {
+            let error = &$error;
+            assert!(
+                error.contains($expect_contains),
+                "Expected error message to contain '{}'\ngot '{error:?}'",
+                $expect_contains,
+            );
+        };
+    }
+
+    fn build_text_response<T: Into<String>>(status_code: StatusCode, body: T) -> Response {
+        HttpResponseBuilder::new()
+            .status(status_code)
+            .body(body.into())
+            .unwrap()
+            .into()
+    }
+
+    fn build_json_response<T: serde::Serialize>(status_code: StatusCode, body: &T) -> Response {
+        HttpResponseBuilder::new()
+            .status(status_code)
+            .header(header::CONTENT_TYPE, JSON_CONTENT_TYPE)
+            .body(serde_json::to_string(&body).unwrap())
+            .unwrap()
+            .into()
+    }
+
+    #[tokio::test]
+    async fn test_4xx_errors_are_handled_as_remote_server_logical() {
+        let response = build_text_response(StatusCode::BAD_REQUEST, "error text");
+        let handled_error = AggregatorClientError::from_response(response).await;
+
+        assert!(
+            matches!(
+                handled_error,
+                AggregatorClientError::RemoteServerLogical(..)
+            ),
+            "Expected error to be RemoteServerLogical\ngot '{handled_error:?}'",
+        );
+    }
+
+    #[tokio::test]
+    async fn test_5xx_errors_are_handled_as_remote_server_technical() {
+        let response = build_text_response(StatusCode::INTERNAL_SERVER_ERROR, "error text");
+        let handled_error = AggregatorClientError::from_response(response).await;
+
+        assert!(
+            matches!(
+                handled_error,
+                AggregatorClientError::RemoteServerTechnical(..)
+            ),
+            "Expected error to be RemoteServerLogical\ngot '{handled_error:?}'",
+        );
+    }
+
+    #[tokio::test]
+    async fn test_550_error_is_handled_as_registration_round_not_yet_opened() {
+        let response = build_text_response(StatusCode::from_u16(550).unwrap(), "Not yet available");
+        let handled_error = AggregatorClientError::from_response(response).await;
+
+        assert!(
+            matches!(
+                handled_error,
+                AggregatorClientError::RegistrationRoundNotYetOpened(..)
+            ),
+            "Expected error to be RegistrationRoundNotYetOpened\ngot '{handled_error:?}'",
+        );
+    }
+
+    #[tokio::test]
+    async fn test_non_4xx_or_5xx_errors_are_handled_as_unhandled_status_code_and_contains_response_text()
+     {
+        let response = build_text_response(StatusCode::OK, "ok text");
+        let handled_error = AggregatorClientError::from_response(response).await;
+
+        assert!(
+            matches!(
+                handled_error,
+                AggregatorClientError::UnhandledStatusCode(..) if format!("{handled_error:?}").contains("ok text")
+            ),
+            "Expected error to be UnhandledStatusCode with 'ok text' in error text\ngot '{handled_error:?}'",
+        );
+    }
+
+    #[tokio::test]
+    async fn test_root_cause_of_non_json_response_contains_response_plain_text() {
+        let error_text = "An error occurred; please try again later.";
+        let response = build_text_response(StatusCode::EXPECTATION_FAILED, error_text);
+
+        assert_error_text_contains!(
+            AggregatorClientError::get_root_cause(response).await,
+            "expectation failed: An error occurred; please try again later."
+        );
+    }
+
+    #[tokio::test]
+    async fn test_root_cause_of_json_formatted_client_error_response_contains_error_label_and_message()
+     {
+        let client_error = ClientError::new("label", "message");
+        let response = build_json_response(StatusCode::BAD_REQUEST, &client_error);
+
+        assert_error_text_contains!(
+            AggregatorClientError::get_root_cause(response).await,
+            "bad request: label: message"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_root_cause_of_json_formatted_server_error_response_contains_error_label_and_message()
+     {
+        let server_error = ServerError::new("message");
+        let response = build_json_response(StatusCode::BAD_REQUEST, &server_error);
+
+        assert_error_text_contains!(
+            AggregatorClientError::get_root_cause(response).await,
+            "bad request: message"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_root_cause_of_unknown_formatted_json_response_contains_json_key_value_pairs() {
+        let response = build_json_response(
+            StatusCode::INTERNAL_SERVER_ERROR,
+            &json!({ "second": "unknown", "first": "foreign" }),
+        );
+
+        assert_error_text_contains!(
+            AggregatorClientError::get_root_cause(response).await,
+            r#"internal server error: {"first":"foreign","second":"unknown"}"#
+        );
+    }
+
+    #[tokio::test]
+    async fn test_root_cause_with_invalid_json_response_still_contains_response_status_name() {
+        let response = HttpResponseBuilder::new()
+            .status(StatusCode::BAD_REQUEST)
+            .header(header::CONTENT_TYPE, JSON_CONTENT_TYPE)
+            .body(r#"{"invalid":"unexpected dot", "key": "value".}"#)
+            .unwrap()
+            .into();
+
+        let root_cause = AggregatorClientError::get_root_cause(response).await;
+
+        assert_error_text_contains!(root_cause, "bad request");
+        assert!(
+            !root_cause.contains("bad request: "),
+            "Expected error message should not contain additional information \ngot '{root_cause:?}'"
+        );
+    }
+}