test(http): add tests to axum extractor for scrape request

Author: josecelano

src/http/axum_implementation/extractors/scrape_request.rs

@@ -19,27 +19,117 @@ where
     type Rejection = Response;
 
     async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
-        let raw_query = parts.uri.query();
-
-        if raw_query.is_none() {
-            return Err(responses::error::Error::from(ParseScrapeQueryError::MissingParams {
-                location: Location::caller(),
-            })
-            .into_response());
+        match extract_scrape_from(parts.uri.query()) {
+            Ok(scrape_request) => Ok(ExtractRequest(scrape_request)),
+            Err(error) => Err(error.into_response()),
         }
+    }
+}
 
-        let query = raw_query.unwrap().parse::<Query>();
+fn extract_scrape_from(maybe_raw_query: Option<&str>) -> Result<Scrape, responses::error::Error> {
+    if maybe_raw_query.is_none() {
+        return Err(responses::error::Error::from(ParseScrapeQueryError::MissingParams {
+            location: Location::caller(),
+        }));
+    }
 
-        if let Err(error) = query {
-            return Err(responses::error::Error::from(error).into_response());
-        }
+    let query = maybe_raw_query.unwrap().parse::<Query>();
+
+    if let Err(error) = query {
+        return Err(responses::error::Error::from(error));
+    }
+
+    let scrape_request = Scrape::try_from(query.unwrap());
+
+    if let Err(error) = scrape_request {
+        return Err(responses::error::Error::from(error));
+    }
+
+    Ok(scrape_request.unwrap())
+}
 
-        let scrape_request = Scrape::try_from(query.unwrap());
+#[cfg(test)]
+mod tests {
+    use std::str::FromStr;
 
-        if let Err(error) = scrape_request {
-            return Err(responses::error::Error::from(error).into_response());
+    use super::extract_scrape_from;
+    use crate::http::axum_implementation::requests::scrape::Scrape;
+    use crate::http::axum_implementation::responses::error::Error;
+    use crate::protocol::info_hash::InfoHash;
+
+    struct TestInfoHash {
+        pub bencoded: String,
+        pub value: InfoHash,
+    }
+
+    fn test_info_hash() -> TestInfoHash {
+        TestInfoHash {
+            bencoded: "%3B%24U%04%CF%5F%11%BB%DB%E1%20%1C%EAjk%F4Z%EE%1B%C0".to_owned(),
+            value: InfoHash::from_str("3b245504cf5f11bbdbe1201cea6a6bf45aee1bc0").unwrap(),
         }
+    }
+
+    fn assert_error_response(error: &Error, error_message: &str) {
+        assert!(
+            error.failure_reason.contains(error_message),
+            "Error response does not contain message: '{error_message}'. Error: {error:?}"
+        );
+    }
+
+    #[test]
+    fn it_should_extract_the_scrape_request_from_the_url_query_params() {
+        let info_hash = test_info_hash();
+
+        let raw_query = format!("info_hash={}", info_hash.bencoded);
+
+        let scrape = extract_scrape_from(Some(&raw_query)).unwrap();
+
+        assert_eq!(
+            scrape,
+            Scrape {
+                info_hashes: vec![info_hash.value],
+            }
+        );
+    }
+
+    #[test]
+    fn it_should_extract_the_scrape_request_from_the_url_query_params_with_more_than_one_info_hash() {
+        let info_hash = test_info_hash();
+
+        let raw_query = format!("info_hash={}&info_hash={}", info_hash.bencoded, info_hash.bencoded);
+
+        let scrape = extract_scrape_from(Some(&raw_query)).unwrap();
+
+        assert_eq!(
+            scrape,
+            Scrape {
+                info_hashes: vec![info_hash.value, info_hash.value],
+            }
+        );
+    }
+
+    #[test]
+    fn it_should_reject_a_request_without_query_params() {
+        let response = extract_scrape_from(None).unwrap_err();
+
+        assert_error_response(
+            &response,
+            "Cannot parse query params for scrape request: missing query params for scrape request",
+        );
+    }
+
+    #[test]
+    fn it_should_reject_a_request_with_a_query_that_cannot_be_parsed() {
+        let invalid_query = "param1=value1=value2";
+        let response = extract_scrape_from(Some(invalid_query)).unwrap_err();
+
+        assert_error_response(&response, "Cannot parse query params");
+    }
+
+    #[test]
+    fn it_should_reject_a_request_with_a_query_that_cannot_be_parsed_into_a_scrape_request() {
+        let response = extract_scrape_from(Some("param1=value1")).unwrap_err();
 
-        Ok(ExtractRequest(scrape_request.unwrap()))
+        assert_error_response(&response, "Cannot parse query params for scrape request");
     }
 }