apollo_storage: create storage_reader_server_test_utils (#10835)

* apollo_batcher: add StateDiffByBlockNumber request to the batcher

* apollo_storage: create storage_reader_server_test_utils

Author: nadin-Starkware

crates/apollo_storage/Cargo.toml

@@ -7,7 +7,7 @@ license-file.workspace = true
 description = "A storage implementation for a Starknet node."
 
 [features]
-testing = ["starknet_api/testing", "tempfile"]
+testing = ["starknet_api/testing", "tempfile", "tower"]
 
 [dependencies]
 apollo_config.workspace = true
@@ -36,6 +36,7 @@ starknet-types-core = { workspace = true, features = ["papyrus-serialization"] }
 starknet_api.workspace = true
 tempfile = { workspace = true, optional = true }
 thiserror.workspace = true
+tower = { workspace = true, optional = true }
 tracing = { workspace = true, features = ["log"] }
 validator = { workspace = true, features = ["derive"] }
 zstd.workspace = true

crates/apollo_storage/src/lib.rs

@@ -109,6 +109,9 @@ mod open_storage_test;
 #[cfg(any(feature = "testing", test))]
 pub mod test_utils;
 
+#[cfg(any(feature = "testing", test))]
+pub mod storage_reader_server_test_utils;
+
 use std::collections::{BTreeMap, HashMap};
 use std::fmt::Debug;
 use std::fs;

crates/apollo_storage/src/storage_reader_server_test.rs

@@ -1,17 +1,16 @@
 use std::net::{IpAddr, Ipv4Addr};
 
 use async_trait::async_trait;
-use axum::body::{Body, Bytes, HttpBody};
+use axum::body::Body;
 use axum::http::{Request, StatusCode};
-use axum::response::Response;
-use axum::Router;
 use pretty_assertions::assert_eq;
 use serde::{Deserialize, Serialize};
 use starknet_api::block::{BlockHeader, BlockNumber};
 use tower::ServiceExt;
 
 use crate::header::{HeaderStorageReader, HeaderStorageWriter};
 use crate::storage_reader_server::{ServerConfig, StorageReaderServer, StorageReaderServerHandler};
+use crate::storage_reader_server_test_utils::{send_storage_query, to_bytes};
 use crate::test_utils::get_test_storage;
 use crate::{StorageError, StorageReader};
 
@@ -109,19 +108,6 @@ async fn test_endpoint_query_nonexistent_block() {
     assert!(!test_response.found);
 }
 
-async fn send_storage_query<T: Serialize>(app: Router, request: &T) -> Response {
-    app.oneshot(
-        Request::builder()
-            .method("POST")
-            .uri("/storage/query")
-            .header("content-type", "application/json")
-            .body(Body::from(serde_json::to_string(request).unwrap()))
-            .unwrap(),
-    )
-    .await
-    .unwrap()
-}
-
 #[tokio::test]
 async fn test_endpoint_handler_error() {
     let ((reader, _writer), _temp_dir) = get_test_storage();
@@ -169,8 +155,3 @@ async fn test_endpoint_invalid_json() {
     // Should return error status code
     assert!(!response.status().is_success());
 }
-
-// Helper function to convert response body to bytes
-async fn to_bytes(res: Response) -> Bytes {
-    res.into_body().collect().await.unwrap().to_bytes()
-}

crates/apollo_storage/src/storage_reader_server_test_utils.rs

@@ -0,0 +1,27 @@
+//! Test utilities for storage reader server testing.
+
+use axum::body::{Body, Bytes, HttpBody};
+use axum::http::Request;
+use axum::response::Response;
+use axum::Router;
+use serde::Serialize;
+use tower::ServiceExt;
+
+/// Helper function to send a storage query request.
+pub async fn send_storage_query<T: Serialize>(app: Router, request: &T) -> Response {
+    app.oneshot(
+        Request::builder()
+            .method("POST")
+            .uri("/storage/query")
+            .header("content-type", "application/json")
+            .body(Body::from(serde_json::to_string(request).unwrap()))
+            .unwrap(),
+    )
+    .await
+    .unwrap()
+}
+
+/// Helper function to convert response body to bytes.
+pub async fn to_bytes(res: Response) -> Bytes {
+    res.into_body().collect().await.unwrap().to_bytes()
+}