blockifier: share the test utl assert_eq_test_result

Author: ArniStarkware

crates/apollo_gateway/src/state_reader_test.rs

@@ -18,6 +18,7 @@ use blockifier::execution::contract_class::RunnableCompiledClass;
 use blockifier::state::contract_class_manager::ContractClassManager;
 use blockifier::state::errors::StateError;
 use blockifier::state::state_api::{StateReader, StateResult};
+use blockifier::state::state_api_test_utils::assert_eq_state_result;
 use blockifier::state::state_reader_and_contract_manager::StateReaderAndContractManager;
 use blockifier::test_utils::initial_test_state::state_reader_and_contract_manager_for_testing;
 use lazy_static::lazy_static;
@@ -42,7 +43,7 @@ use starknet_api::{class_hash, contract_address, felt, nonce, storage_key};
 use crate::state_reader::{GatewayStateReaderWithCompiledClasses, MempoolStateReader};
 use crate::sync_state_reader::SyncStateReader;
 
-fn state_reader_and_contract_manager(
+fn sync_state_reader_and_contract_manager(
     state_sync_client: SharedStateSyncClient,
     class_manager_client: SharedClassManagerClient,
     contract_class_manager: ContractClassManager,
@@ -281,7 +282,7 @@ async fn test_get_block_info() {
         },
     );
 
-    let state_reader_and_contract_manager = state_reader_and_contract_manager(
+    let state_reader_and_contract_manager = sync_state_reader_and_contract_manager(
         Arc::new(mock_state_sync_client),
         Arc::new(mock_class_manager_client),
         contract_class_manager.clone(),
@@ -339,7 +340,7 @@ async fn test_get_storage_at() {
         )
         .returning(move |_, _, _| Ok(value));
 
-    let state_reader_and_contract_manager = state_reader_and_contract_manager(
+    let state_reader_and_contract_manager = sync_state_reader_and_contract_manager(
         Arc::new(mock_state_sync_client),
         Arc::new(mock_class_manager_client),
         contract_class_manager.clone(),
@@ -370,7 +371,7 @@ async fn test_get_nonce_at() {
         .with(predicate::eq(block_number), predicate::eq(contract_address))
         .returning(move |_, _| Ok(expected_result));
 
-    let state_reader_and_contract_manager = state_reader_and_contract_manager(
+    let state_reader_and_contract_manager = sync_state_reader_and_contract_manager(
         Arc::new(mock_state_sync_client),
         Arc::new(mock_class_manager_client),
         contract_class_manager.clone(),
@@ -402,7 +403,7 @@ async fn test_get_class_hash_at() {
         .with(predicate::eq(block_number), predicate::eq(contract_address))
         .returning(move |_, _| Ok(expected_result));
 
-    let state_reader_and_contract_manager = state_reader_and_contract_manager(
+    let state_reader_and_contract_manager = sync_state_reader_and_contract_manager(
         Arc::new(mock_state_sync_client),
         Arc::new(mock_class_manager_client),
         contract_class_manager.clone(),
@@ -430,21 +431,6 @@ lazy_static! {
         DUMMY_CONTRACT_CLASS_V0.clone().try_into().unwrap();
 }
 
-fn assert_eq_state_result(
-    a: &StateResult<RunnableCompiledClass>,
-    b: &StateResult<RunnableCompiledClass>,
-) {
-    match (a, b) {
-        (Ok(a), Ok(b)) => assert_eq!(a, b),
-        (Err(StateError::UndeclaredClassHash(a)), Err(StateError::UndeclaredClassHash(b))) => {
-            assert_eq!(a, b)
-        }
-        _ => panic!("StateResult mismatch (or unsupported comparison): {a:?} vs {b:?}"),
-    }
-}
-
-// TODO(Arni): Check if any test cases here should move to the tests of
-// `StateReaderAndContractManager`.
 #[rstest]
 #[case::cairo_0_declared_and_cached(
     cairo_0_declared_scenario(),
@@ -483,7 +469,7 @@ async fn test_get_compiled_class(
         first_scenario.expectations,
     );
 
-    let first_state_reader_and_class_manager = state_reader_and_contract_manager(
+    let first_state_reader_and_class_manager = sync_state_reader_and_contract_manager(
         Arc::new(mock_state_sync_client),
         Arc::new(mock_class_manager_client),
         contract_class_manager.clone(),
@@ -506,7 +492,7 @@ async fn test_get_compiled_class(
         second_scenario.expectations,
     );
 
-    let second_state_reader_and_class_manager = state_reader_and_contract_manager(
+    let second_state_reader_and_class_manager = sync_state_reader_and_contract_manager(
         Arc::new(mock_state_sync_client),
         Arc::new(mock_class_manager_client),
         contract_class_manager,

crates/apollo_gateway/src/sync_state_reader_test.rs

@@ -11,6 +11,7 @@ use apollo_test_utils::{get_rng, GetTestInstance};
 use blockifier::execution::contract_class::RunnableCompiledClass;
 use blockifier::state::errors::StateError;
 use blockifier::state::state_api::{StateReader, StateResult};
+use blockifier::state::state_api_test_utils::assert_eq_state_result;
 use lazy_static::lazy_static;
 use mockall::predicate;
 use rstest::rstest;
@@ -200,19 +201,6 @@ lazy_static! {
     static ref DUMMY_CONTRACT_CLASS: ContractClass = ContractClass::test_casm_contract_class();
 }
 
-fn assert_eq_state_result(
-    a: &StateResult<RunnableCompiledClass>,
-    b: &StateResult<RunnableCompiledClass>,
-) {
-    match (a, b) {
-        (Ok(a), Ok(b)) => assert_eq!(a, b),
-        (Err(StateError::UndeclaredClassHash(a)), Err(StateError::UndeclaredClassHash(b))) => {
-            assert_eq!(a, b)
-        }
-        _ => panic!("StateResult mismatch (or unsupported comparison): {a:?} vs {b:?}"),
-    }
-}
-
 #[rstest]
 #[case::class_declared(
     Ok(Some(DUMMY_CONTRACT_CLASS.clone())),

crates/blockifier/src/state.rs

@@ -8,6 +8,8 @@ pub mod global_cache;
 #[cfg(feature = "cairo_native")]
 pub mod native_class_manager;
 pub mod state_api;
+#[cfg(any(feature = "testing", test))]
+pub mod state_api_test_utils;
 pub mod state_reader_and_contract_manager;
 pub mod stateful_compression;
 #[cfg(any(feature = "testing", test))]

crates/blockifier/src/state/state_api_test_utils.rs

@@ -0,0 +1,16 @@
+use crate::execution::contract_class::RunnableCompiledClass;
+use crate::state::errors::StateError;
+use crate::state::state_api::StateResult;
+
+pub fn assert_eq_state_result(
+    a: &StateResult<RunnableCompiledClass>,
+    b: &StateResult<RunnableCompiledClass>,
+) {
+    match (a, b) {
+        (Ok(a), Ok(b)) => assert_eq!(a, b),
+        (Err(StateError::UndeclaredClassHash(a)), Err(StateError::UndeclaredClassHash(b))) => {
+            assert_eq!(a, b)
+        }
+        _ => panic!("StateResult mismatch (or unsupported comparison): {a:?} vs {b:?}"),
+    }
+}