apollo_integration_tests: split end to end flow test into 5 scenarios

Author: ArniStarkware

crates/apollo_infra_utils/src/test_utils.rs

@@ -39,7 +39,6 @@ pub enum TestIdentifier {
     RestartServiceMultipleNodesFlowIntegrationTest,
     RestartServiceSingleNodeFlowIntegrationTest,
     RevertFlowIntegrationTest,
-    SystemTestDumpSingleNodeConfig,
     HttpServerUnitTests,
     SyncFlowIntegrationTest,
     StorageReaderServerUnitTests,

crates/apollo_integration_tests/tests/declare_tx_flow_test.rs

@@ -0,0 +1,35 @@
+use apollo_infra_utils::test_utils::TestIdentifier;
+use apollo_integration_tests::utils::ACCOUNT_ID_0;
+use blockifier::bouncer::BouncerWeights;
+use mempool_test_utils::starknet_api_test_utils::MultiAccountTransactionGenerator;
+use starknet_api::rpc_transaction::RpcTransaction;
+
+use crate::common::{end_to_end_flow, test_single_tx, EndToEndFlowArgs, TestScenario};
+
+mod common;
+
+/// Number of threads is 3 = Num of sequencer + 1 for the test thread.
+#[tokio::test(flavor = "multi_thread", worker_threads = 3)]
+async fn declare_tx_flow() {
+    end_to_end_flow(EndToEndFlowArgs::new(
+        // TODO(Arni): Change the TestIdentifier to DeclareTxFlow.
+        TestIdentifier::EndToEndFlowTest,
+        create_test_scenarios(),
+        BouncerWeights::default().proving_gas,
+    ))
+    .await
+}
+
+fn create_test_scenarios() -> Vec<TestScenario> {
+    vec![TestScenario {
+        create_rpc_txs_fn: create_declare_tx,
+        create_l1_to_l2_messages_args_fn: |_| vec![],
+        test_tx_hashes_fn: test_single_tx,
+    }]
+}
+
+fn create_declare_tx(tx_generator: &mut MultiAccountTransactionGenerator) -> Vec<RpcTransaction> {
+    let account_tx_generator = tx_generator.account_with_id_mut(ACCOUNT_ID_0);
+    let declare_tx = account_tx_generator.generate_declare_of_contract_class();
+    vec![declare_tx]
+}

crates/apollo_integration_tests/tests/deploy_account_and_invoke_flow_test.rs

@@ -0,0 +1,40 @@
+use apollo_infra_utils::test_utils::TestIdentifier;
+use apollo_integration_tests::utils::{
+    create_deploy_account_tx_and_invoke_tx,
+    UNDEPLOYED_ACCOUNT_ID,
+};
+use blockifier::bouncer::BouncerWeights;
+use mempool_test_utils::starknet_api_test_utils::MultiAccountTransactionGenerator;
+use starknet_api::rpc_transaction::RpcTransaction;
+
+use crate::common::{end_to_end_flow, validate_tx_count, EndToEndFlowArgs, TestScenario};
+
+mod common;
+
+/// Number of threads is 3 = Num of sequencer + 1 for the test thread.
+#[tokio::test(flavor = "multi_thread", worker_threads = 3)]
+async fn deploy_account_and_invoke_flow() {
+    end_to_end_flow(EndToEndFlowArgs::new(
+        // TODO(Arni): Change the TestIdentifier to DeployAccountAndInvokeFlow.
+        TestIdentifier::EndToEndFlowTest,
+        create_test_scenarios(),
+        BouncerWeights::default().proving_gas,
+    ))
+    .await
+}
+
+fn create_test_scenarios() -> Vec<TestScenario> {
+    vec![TestScenario {
+        create_rpc_txs_fn: deploy_account_and_invoke,
+        create_l1_to_l2_messages_args_fn: |_| vec![],
+        test_tx_hashes_fn: |tx_hashes| validate_tx_count(tx_hashes, 2),
+    }]
+}
+
+/// Generates a deploy account transaction followed by an invoke transaction from the same deployed
+/// account.
+fn deploy_account_and_invoke(
+    tx_generator: &mut MultiAccountTransactionGenerator,
+) -> Vec<RpcTransaction> {
+    create_deploy_account_tx_and_invoke_tx(tx_generator, UNDEPLOYED_ACCOUNT_ID)
+}

crates/apollo_integration_tests/tests/end_to_end_flow_test.rs

@@ -0,0 +1,40 @@
+use apollo_infra_utils::test_utils::TestIdentifier;
+use apollo_integration_tests::utils::{ACCOUNT_ID_0, UNDEPLOYED_ACCOUNT_ID};
+use blockifier::bouncer::BouncerWeights;
+use mempool_test_utils::starknet_api_test_utils::MultiAccountTransactionGenerator;
+use starknet_api::rpc_transaction::RpcTransaction;
+
+use crate::common::{end_to_end_flow, test_single_tx, EndToEndFlowArgs, TestScenario};
+
+mod common;
+
+/// Number of threads is 3 = Num of sequencer + 1 for the test thread.
+#[tokio::test(flavor = "multi_thread", worker_threads = 3)]
+async fn funding_txs_flow() {
+    end_to_end_flow(EndToEndFlowArgs::new(
+        // TODO(Arni): Change the TestIdentifier to FundingTxsFlow.
+        TestIdentifier::EndToEndFlowTest,
+        create_test_scenarios(),
+        BouncerWeights::default().proving_gas,
+    ))
+    .await
+}
+
+fn create_test_scenarios() -> Vec<TestScenario> {
+    vec![TestScenario {
+        create_rpc_txs_fn: create_funding_txs,
+        create_l1_to_l2_messages_args_fn: |_| vec![],
+        test_tx_hashes_fn: test_single_tx,
+    }]
+}
+
+fn create_funding_txs(tx_generator: &mut MultiAccountTransactionGenerator) -> Vec<RpcTransaction> {
+    // TODO(yair): Register the undeployed account here instead of in the test setup
+    // once funding is implemented.
+    let undeployed_account = tx_generator.account_with_id(UNDEPLOYED_ACCOUNT_ID).account;
+    assert!(tx_generator.undeployed_accounts().contains(&undeployed_account));
+
+    let funding_tx =
+        tx_generator.account_with_id_mut(ACCOUNT_ID_0).generate_transfer(&undeployed_account);
+    vec![funding_tx]
+}

crates/apollo_integration_tests/tests/funding_txs_flow_test.rs

@@ -0,0 +1,31 @@
+use apollo_infra_utils::test_utils::TestIdentifier;
+use apollo_integration_tests::utils::create_l1_to_l2_messages_args;
+use blockifier::bouncer::BouncerWeights;
+use mempool_test_utils::starknet_api_test_utils::MultiAccountTransactionGenerator;
+use starknet_api::transaction::L1HandlerTransaction;
+
+use crate::common::{end_to_end_flow, test_single_tx, EndToEndFlowArgs, TestScenario};
+
+mod common;
+
+/// Number of threads is 3 = Num of sequencer + 1 for the test thread.
+#[tokio::test(flavor = "multi_thread", worker_threads = 3)]
+async fn l1_to_l2_message_flow() {
+    end_to_end_flow(EndToEndFlowArgs::new(
+        // TODO(Arni): Change the TestIdentifier to L1ToL2MessageFlow.
+        TestIdentifier::EndToEndFlowTest,
+        create_test_scenarios(),
+        BouncerWeights::default().proving_gas,
+    ))
+    .await
+}
+
+fn create_test_scenarios() -> Vec<TestScenario> {
+    vec![TestScenario {
+        create_rpc_txs_fn: |_| vec![],
+        create_l1_to_l2_messages_args_fn: |tx_generator| {
+            create_l1_to_l2_messages_args(tx_generator, 1, false)
+        },
+        test_tx_hashes_fn: test_single_tx,
+    }]
+}

crates/apollo_integration_tests/tests/l1_to_l2_message_flow_test.rs

@@ -0,0 +1,56 @@
+use apollo_infra_utils::test_utils::TestIdentifier;
+use apollo_integration_tests::utils::{ACCOUNT_ID_0, ACCOUNT_ID_1};
+use blockifier::bouncer::BouncerWeights;
+use mempool_test_utils::starknet_api_test_utils::MultiAccountTransactionGenerator;
+use starknet_api::rpc_transaction::RpcTransaction;
+use starknet_api::transaction::TransactionHash;
+
+use crate::common::{end_to_end_flow, EndToEndFlowArgs, TestScenario};
+
+mod common;
+
+/// Number of threads is 3 = Num of sequencer + 1 for the test thread.
+#[tokio::test(flavor = "multi_thread", worker_threads = 3)]
+async fn multiple_account_txs_flow() {
+    end_to_end_flow(EndToEndFlowArgs::new(
+        // TODO(Arni): Change the TestIdentifier to MultipleAccountTxsFlow.
+        TestIdentifier::EndToEndFlowTest,
+        create_test_scenarios(),
+        BouncerWeights::default().proving_gas,
+    ))
+    .await
+}
+
+fn create_test_scenarios() -> Vec<TestScenario> {
+    vec![TestScenario {
+        create_rpc_txs_fn: create_multiple_account_txs,
+        create_l1_to_l2_messages_args_fn: |_| vec![],
+        test_tx_hashes_fn: test_multiple_account_txs,
+    }]
+}
+
+fn create_multiple_account_txs(
+    tx_generator: &mut MultiAccountTransactionGenerator,
+) -> Vec<RpcTransaction> {
+    // Create RPC transactions.
+    let account0_invoke_nonce1 =
+        tx_generator.account_with_id_mut(ACCOUNT_ID_0).generate_trivial_rpc_invoke_tx(2);
+    let account0_invoke_nonce2 =
+        tx_generator.account_with_id_mut(ACCOUNT_ID_0).generate_trivial_rpc_invoke_tx(3);
+    let account1_invoke_nonce1 =
+        tx_generator.account_with_id_mut(ACCOUNT_ID_1).generate_trivial_rpc_invoke_tx(4);
+
+    vec![account0_invoke_nonce1, account0_invoke_nonce2, account1_invoke_nonce1]
+}
+
+fn test_multiple_account_txs(tx_hashes: &[TransactionHash]) -> Vec<TransactionHash> {
+    // Return the transaction hashes in the order they should be given by the mempool:
+    // Transactions from the same account are ordered by nonce; otherwise, higher tips are given
+    // priority.
+    assert!(
+        tx_hashes.len() == 3,
+        "Unexpected number of transactions sent in the test scenario. Found {} transactions",
+        tx_hashes.len()
+    );
+    vec![tx_hashes[2], tx_hashes[0], tx_hashes[1]]
+}