test: add additional tests

Author: glottologist

Cargo.lock

@@ -183,51 +183,6 @@ impl Display for BlockParam {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use proptest::prelude::*;
-    use rstest::rstest;
-
-    #[rstest]
-    #[case("latest", BlockParam::Latest)]
-    #[case("pending", BlockParam::Pending)]
-    #[case("finalized", BlockParam::Finalized)]
-    #[case("0", BlockParam::BlockHeight(0))]
-    #[case("42", BlockParam::BlockHeight(42))]
-    #[case("999999999", BlockParam::BlockHeight(999_999_999))]
-    fn from_str_valid(#[case] input: &str, #[case] expected: BlockParam) {
-        assert_eq!(BlockParam::from_str(input).unwrap(), expected);
-    }
-
-    #[rstest]
-    #[case("")]
-    #[case("nonsense!@#")]
-    #[case("LATEST")]
-    fn from_str_invalid(#[case] input: &str) {
-        assert!(BlockParam::from_str(input).is_err());
-    }
-
-    proptest! {
-        #[test]
-        fn block_height_display_fromstr_roundtrip(height: u64) {
-            let param = BlockParam::BlockHeight(height);
-            let s = param.to_string();
-            let parsed = BlockParam::from_str(&s).unwrap();
-            prop_assert_eq!(parsed, BlockParam::BlockHeight(height));
-        }
-
-        #[test]
-        fn hash_display_fromstr_roundtrip(bytes in proptest::collection::vec(any::<u8>(), 32)) {
-            let arr: [u8; 32] = bytes.try_into().unwrap();
-            let param = BlockParam::Hash(H256(arr));
-            let s = param.to_string();
-            let parsed = BlockParam::from_str(&s).unwrap();
-            prop_assert_eq!(parsed, param);
-        }
-    }
-}
-
 // #[cfg(test)]
 // mod tests {
 //     use crate::routes;
@@ -379,3 +334,53 @@ mod tests {
 //         Ok(())
 //     }
 // }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use proptest::prelude::*;
+
+    proptest! {
+        #[test]
+        fn block_param_roundtrip_keywords(variant in prop_oneof![
+            Just("latest"),
+            Just("pending"),
+            Just("finalized"),
+        ]) {
+            let parsed = BlockParam::from_str(variant).unwrap();
+            let displayed = parsed.to_string();
+            prop_assert_eq!(displayed.as_str(), variant);
+
+            let reparsed = BlockParam::from_str(&displayed).unwrap();
+            prop_assert_eq!(reparsed, parsed);
+        }
+
+        #[test]
+        fn block_param_roundtrip_height(height: u64) {
+            let param = BlockParam::BlockHeight(height);
+            let displayed = param.to_string();
+            let reparsed = BlockParam::from_str(&displayed).unwrap();
+            prop_assert_eq!(reparsed, param);
+        }
+
+        #[test]
+        fn block_param_roundtrip_hash(bytes in proptest::collection::vec(any::<u8>(), 32)) {
+            let mut arr = [0_u8; 32];
+            arr.copy_from_slice(&bytes);
+            let param = BlockParam::Hash(H256(arr));
+            let displayed = param.to_string();
+            let reparsed = BlockParam::from_str(&displayed).unwrap();
+            prop_assert_eq!(reparsed, param);
+        }
+
+        #[test]
+        fn block_param_rejects_invalid_base58(s in "[^0-9a-zA-Z]+") {
+            if s.parse::<u64>().is_err()
+                && !matches!(s.as_str(), "latest" | "pending" | "finalized")
+            {
+                let result = BlockParam::from_str(&s);
+                prop_assert!(result.is_err());
+            }
+        }
+    }
+}

crates/api-server/src/routes/block.rs

@@ -8,7 +8,7 @@ use awc::http::StatusCode;
 use irys_domain::get_node_info;
 
 pub async fn info_route(state: web::Data<ApiState>) -> HttpResponse {
-    let node_info = match get_node_info(
+    match get_node_info(
         &state.block_index,
         &state.block_tree,
         &state.peer_list,
@@ -19,18 +19,15 @@ pub async fn info_route(state: web::Data<ApiState>) -> HttpResponse {
     )
     .await
     {
-        Ok(info) => info,
-        Err(e) => {
-            return std::convert::Into::<ApiError>::into((
-                format!("Failed to get node info: {e}"),
-                StatusCode::INTERNAL_SERVER_ERROR,
-            ))
-            .error_response();
-        }
-    };
-    HttpResponse::Ok()
-        .content_type(ContentType::json())
-        .body(serde_json::to_string_pretty(&node_info).unwrap())
+        Ok(node_info) => HttpResponse::Ok()
+            .content_type(ContentType::json())
+            .body(serde_json::to_string_pretty(&node_info).unwrap()),
+        Err(_) => std::convert::Into::<ApiError>::into((
+            "Failed to retrieve node info".to_owned(),
+            StatusCode::INTERNAL_SERVER_ERROR,
+        ))
+        .error_response(),
+    }
 }
 
 pub async fn ready_route() -> HttpResponse {