test(starknet_client): deprecated feeder gw get_latest_block_when_no_blocks_exists

crates/starknet_client/resources/reader/block_post_0_14_0.json

@@ -1,7 +1,7 @@
 {
     "block_hash": "0x1219b7fcf5b8872c5d16ecabe3120eb221bec7d99eb299fa2dd830100f70bfd",
     "parent_block_hash": "0x0",
-    "block_number": 0,
+    "block_number": 329526,
     "state_root": "0x502c54a3efd1d6e679675e3edc3d0b5a978e5de5118e439605985b5a3dc9816",
     "transaction_commitment": "0x3669da31ff0c48e7a14c7caf54480defcbfd3d6c506c38ce6a069acf64e8436",
     "event_commitment": "0x0",

crates/starknet_client/src/reader/starknet_feeder_gateway_client_test.rs

@@ -57,7 +57,7 @@ fn get_block_url(
 ) -> String {
     let mut url = match block_number_or_latest {
         Some(block_number) => format!("/feeder_gateway/get_block?blockNumber={}", block_number),
-        None => "/feeder_gateway/get_block?blockNumber=latest".to_string(),
+        _ => "/feeder_gateway/get_block?blockNumber=latest".to_string(),
     };
 
     if !use_deprecated_feeder_gateway {
@@ -72,6 +72,35 @@ fn starknet_client() -> StarknetFeederGatewayClient {
         .unwrap()
 }
 
+// TODO(Ayelet): Consider making this function generic for all successful mock responses in this
+// file.
+fn mock_successful_get_block_response(
+    response_file: &str,
+    request_param: Option<u64>,
+    use_deprecated_feeder_gateway: bool,
+) -> mockito::Mock {
+    mock("GET", get_block_url(request_param, use_deprecated_feeder_gateway).as_str())
+        .with_status(200)
+        .with_body(read_resource_file(response_file))
+        .create()
+}
+
+// TODO(Ayelet): Consider making this function generic for all error mock responses in this file.
+fn mock_error_get_block_response(
+    error_response_body: String,
+    request_param: Option<u64>,
+    use_deprecated_feeder_gateway: bool,
+) -> mockito::Mock {
+    mock("GET", get_block_url(request_param, use_deprecated_feeder_gateway).as_str())
+        .with_status(400)
+        .with_body(error_response_body)
+        .create()
+}
+
+fn mock_current_feeder_gateway_invalid_get_latest_block_response() -> mockito::Mock {
+    mock_error_get_block_response(malformed_error(), None, false)
+}
+
 fn block_not_found_error(block_number: i64) -> String {
     let error = StarknetError {
         code: StarknetErrorCode::KnownErrorCode(KnownStarknetErrorCode::BlockNotFound),
@@ -80,6 +109,14 @@ fn block_not_found_error(block_number: i64) -> String {
     serde_json::to_string(&error).unwrap()
 }
 
+fn malformed_error() -> String {
+    let error = StarknetError {
+        code: StarknetErrorCode::KnownErrorCode(KnownStarknetErrorCode::MalformedRequest),
+        message: "Malformed request.".to_string(),
+    };
+    serde_json::to_string(&error).unwrap()
+}
+
 #[test]
 fn new_urls() {
     let url_base_str = "https://url";
@@ -99,23 +136,41 @@ fn new_urls() {
 #[tokio::test]
 async fn get_latest_block_when_blocks_exists() {
     let starknet_client = starknet_client();
-    let mock_block = mock("GET", get_block_url(None, false).as_str())
-        .with_status(200)
-        .with_body(read_resource_file("reader/block_post_0_13_1.json"))
-        .create();
+    let mock_block =
+        mock_successful_get_block_response("reader/block_post_0_14_0.json", None, false);
     let latest_block = starknet_client.latest_block().await.unwrap();
     mock_block.assert();
+    assert_eq!(latest_block.unwrap().block_number(), BlockNumber(329526));
+}
+
+#[tokio::test]
+async fn fallback_get_latest_block_when_blocks_exists() {
+    let starknet_client = starknet_client();
+    let mock_fallback_error = mock_current_feeder_gateway_invalid_get_latest_block_response();
+    let mock_block =
+        mock_successful_get_block_response("reader/block_post_0_13_1.json", None, true);
+    let latest_block = starknet_client.latest_block().await.unwrap();
+    mock_fallback_error.assert();
+    mock_block.assert();
     assert_eq!(latest_block.unwrap().block_number(), BlockNumber(329525));
 }
 
 #[tokio::test]
 async fn get_latest_block_when_no_blocks_exist() {
     let starknet_client = starknet_client();
-    let mock_no_block = mock("GET", get_block_url(None, false).as_str())
-        .with_status(400)
-        .with_body(block_not_found_error(-1))
-        .create();
+    let mock_no_block = mock_error_get_block_response(block_not_found_error(-1), None, false);
+    let latest_block = starknet_client.latest_block().await.unwrap();
+    mock_no_block.assert();
+    assert!(latest_block.is_none());
+}
+
+#[tokio::test]
+async fn fallback_get_latest_block_when_no_blocks_exist() {
+    let starknet_client = starknet_client();
+    let mock_fallback_error = mock_current_feeder_gateway_invalid_get_latest_block_response();
+    let mock_no_block = mock_error_get_block_response(block_not_found_error(-1), None, true);
     let latest_block = starknet_client.latest_block().await.unwrap();
+    mock_fallback_error.assert();
     mock_no_block.assert();
     assert!(latest_block.is_none());
 }
@@ -365,10 +420,7 @@ async fn get_block() {
         let raw_block = read_resource_file(&json_filename);
         let expected_block: Block = serde_json::from_str(&raw_block).unwrap();
 
-        let mock_block = mock("GET", get_block_url(Some(20), false).as_str())
-            .with_status(200)
-            .with_body(&raw_block)
-            .create();
+        let mock_block = mock_successful_get_block_response(&json_filename, Some(20), false);
         let block = starknet_client.block(BlockNumber(20)).await.unwrap().unwrap();
         mock_block.assert();
 
@@ -380,10 +432,8 @@ async fn get_block() {
 #[tokio::test]
 async fn get_block_not_found() {
     let starknet_client = starknet_client();
-    let mock_no_block = mock("GET", get_block_url(Some(9999999999), false).as_str())
-        .with_status(400)
-        .with_body(block_not_found_error(9999999999))
-        .create();
+    let mock_no_block =
+        mock_error_get_block_response(block_not_found_error(9999999999), Some(9999999999), false);
     let block = starknet_client.block(BlockNumber(9999999999)).await.unwrap();
     mock_no_block.assert();
     assert!(block.is_none());