Split a long test

Author: teor2345

domains/client/domain-operator/src/tests.rs

@@ -17,8 +17,11 @@ use domain_test_service::evm_domain_test_runtime::{
 };
 use domain_test_service::EcdsaKeyring::{Alice, Bob, Charlie, Dave, Eve};
 use domain_test_service::Sr25519Keyring::{self, Alice as Sr25519Alice, Ferdie};
-use domain_test_service::{construct_extrinsic_generic, AUTO_ID_DOMAIN_ID, EVM_DOMAIN_ID};
+use domain_test_service::{
+    construct_extrinsic_generic, DomainNode, AUTO_ID_DOMAIN_ID, EVM_DOMAIN_ID,
+};
 use ethereum::TransactionV2 as EthereumTransaction;
+use evm_domain_test_runtime::{Runtime as EvmRuntime, RuntimeApi as EvmRuntimeApi};
 use fp_rpc::EthereumRuntimeRPCApi;
 use futures::StreamExt;
 use hex_literal::hex;
@@ -207,8 +210,13 @@ pub fn generate_evm_account_list(
     }
 }
 
-#[tokio::test(flavor = "multi_thread")]
-async fn test_evm_domain_create_contracts_with_allow_list() {
+async fn setup_evm_test_nodes(
+    ferdie_key: Sr25519Keyring,
+) -> (
+    TempDir,
+    MockConsensusNode,
+    DomainNode<EvmRuntime, EvmRuntimeApi>,
+) {
     let directory = TempDir::new().expect("Must be able to create temporary directory");
 
     let mut builder = sc_cli::LoggerBuilder::new("");
@@ -220,18 +228,31 @@ async fn test_evm_domain_create_contracts_with_allow_list() {
     // Start Ferdie with Alice Key since that is the sudo key
     let mut ferdie = MockConsensusNode::run(
         tokio_handle.clone(),
-        Sr25519Alice,
+        ferdie_key,
         BasePath::new(directory.path().join("ferdie")),
     );
 
     // Run Alice (an evm domain)
-    let mut alice = domain_test_service::DomainNodeBuilder::new(
+    let alice = domain_test_service::DomainNodeBuilder::new(
         tokio_handle.clone(),
         BasePath::new(directory.path().join("alice")),
     )
     .build_evm_node(Role::Authority, Alice, &mut ferdie)
     .await;
 
+    (directory, ferdie, alice)
+}
+
+async fn setup_evm_test_accounts(
+    ferdie_key: Sr25519Keyring,
+) -> (
+    TempDir,
+    MockConsensusNode,
+    DomainNode<EvmRuntime, EvmRuntimeApi>,
+    Vec<AccountInfo>,
+) {
+    let (directory, mut ferdie, mut alice) = setup_evm_test_nodes(ferdie_key).await;
+
     produce_blocks!(ferdie, alice, 3).await.unwrap();
 
     // Create more accounts and fund those accounts
@@ -253,8 +274,17 @@ async fn test_evm_domain_create_contracts_with_allow_list() {
             .await
             .expect("Failed to send extrinsic");
     }
+
     produce_blocks!(ferdie, alice, 3).await.unwrap();
 
+    (directory, ferdie, alice, account_infos)
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_evm_domain_create_contracts_with_allow_list_default() {
+    let (_directory, mut ferdie, mut alice, account_infos) =
+        setup_evm_test_accounts(Sr25519Alice).await;
+
     let gas_price = alice
         .client
         .runtime_api()
@@ -263,13 +293,12 @@ async fn test_evm_domain_create_contracts_with_allow_list() {
 
     // Any account should be able to create contracts by default
     let mut eth_nonce = U256::zero();
-    let mut eth_tx = generate_eth_domain_extrinsic(
+    let eth_tx = generate_eth_domain_extrinsic(
         account_infos[0].clone(),
         ethereum::TransactionAction::Create,
         eth_nonce,
         gas_price,
     );
-    let eth_contract_address = contract_address(account_infos[0].address, eth_nonce.as_u64());
     eth_nonce += U256::one();
 
     let result = alice.send_extrinsic(eth_tx).await;
@@ -287,7 +316,6 @@ async fn test_evm_domain_create_contracts_with_allow_list() {
         evm_nonce,
         gas_price,
     );
-    let evm_contract_address = contract_address(account_infos[1].address, evm_nonce.as_u64());
     evm_nonce += U256::one();
 
     let result = alice.construct_and_send_extrinsic(evm_tx).await;
@@ -367,11 +395,55 @@ async fn test_evm_domain_create_contracts_with_allow_list() {
     assert_eq!(receipt.consensus_block_hash, consensus_block_hash);
 
     produce_blocks!(ferdie, alice, 3).await.unwrap();
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_evm_domain_create_contracts_with_allow_list_reject_all() {
+    let (_directory, mut ferdie, mut alice, account_infos) =
+        setup_evm_test_accounts(Sr25519Alice).await;
+
+    let gas_price = alice
+        .client
+        .runtime_api()
+        .gas_price(alice.client.info().best_hash)
+        .unwrap();
+
+    // Create contracts used for testing contract calls
+    let mut eth_nonce = U256::zero();
+    let mut eth_tx = generate_eth_domain_extrinsic(
+        account_infos[0].clone(),
+        ethereum::TransactionAction::Create,
+        eth_nonce,
+        gas_price,
+    );
+    let eth_contract_address = contract_address(account_infos[0].address, eth_nonce.as_u64());
+    eth_nonce += U256::one();
+
+    alice.send_extrinsic(eth_tx).await.unwrap();
+
+    let mut evm_nonce = U256::zero();
+    let mut evm_tx = generate_evm_domain_call(
+        account_infos[1].clone(),
+        ethereum::TransactionAction::Create,
+        0,
+        evm_nonce,
+        gas_price,
+    );
+    let evm_contract_address = contract_address(account_infos[1].address, evm_nonce.as_u64());
+    evm_nonce += U256::one();
+
+    alice.construct_and_send_extrinsic(evm_tx).await.unwrap();
+
+    // Produce a bundle that contains just the sent extrinsics
+    let (slot, _bundle) = ferdie.produce_slot_and_wait_for_bundle_submission().await;
+    produce_block_with!(ferdie.produce_block_with_slot(slot), alice)
+        .await
+        .unwrap();
 
     // set EVM contract allow list on Domain using domain sudo.
     // Sudo on consensus chain will send a sudo call to domain
     // once the call is executed in the domain, list will be updated.
-    let mut allow_list = generate_evm_account_list(&account_infos, EvmAccountList::NoOne);
+    let allow_list = generate_evm_account_list(&account_infos, EvmAccountList::NoOne);
     let sudo_unsigned_extrinsic = alice
         .construct_unsigned_extrinsic(evm_domain_test_runtime::RuntimeCall::EVMNoncetracker(
             pallet_evm_tracker::Call::set_contract_creation_allowed_by {
@@ -555,9 +627,51 @@ async fn test_evm_domain_create_contracts_with_allow_list() {
     assert_eq!(receipt.consensus_block_hash, consensus_block_hash);
 
     produce_blocks!(ferdie, alice, 3).await.unwrap();
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_evm_domain_create_contracts_with_allow_list_single() {
+    let (_directory, mut ferdie, mut alice, account_infos) =
+        setup_evm_test_accounts(Sr25519Alice).await;
+
+    let gas_price = alice
+        .client
+        .runtime_api()
+        .gas_price(alice.client.info().best_hash)
+        .unwrap();
+
+    // Create contracts used for testing contract calls
+    let mut eth_nonce = U256::zero();
+    let mut eth_tx = generate_eth_domain_extrinsic(
+        account_infos[0].clone(),
+        ethereum::TransactionAction::Create,
+        eth_nonce,
+        gas_price,
+    );
+    eth_nonce += U256::one();
+
+    alice.send_extrinsic(eth_tx).await.unwrap();
+
+    let mut evm_nonce = U256::zero();
+    let mut evm_tx = generate_evm_domain_call(
+        account_infos[1].clone(),
+        ethereum::TransactionAction::Create,
+        0,
+        evm_nonce,
+        gas_price,
+    );
+    evm_nonce += U256::one();
+
+    alice.construct_and_send_extrinsic(evm_tx).await.unwrap();
+
+    // Produce a bundle that contains just the sent extrinsics
+    let (slot, _bundle) = ferdie.produce_slot_and_wait_for_bundle_submission().await;
+    produce_block_with!(ferdie.produce_block_with_slot(slot), alice)
+        .await
+        .unwrap();
 
     // 1 account in the allow list
-    allow_list = generate_evm_account_list(&account_infos, EvmAccountList::One);
+    let allow_list = generate_evm_account_list(&account_infos, EvmAccountList::One);
     let sudo_unsigned_extrinsic = alice
         .construct_unsigned_extrinsic(evm_domain_test_runtime::RuntimeCall::EVMNoncetracker(
             pallet_evm_tracker::Call::set_contract_creation_allowed_by {
@@ -637,7 +751,7 @@ async fn test_evm_domain_create_contracts_with_allow_list() {
 
     // Produce a bundle that contains just the sent extrinsics
     let (slot, bundle) = ferdie.produce_slot_and_wait_for_bundle_submission().await;
-    assert_eq!(bundle.extrinsics.len(), 1);
+    assert_eq!(bundle.extrinsics.len(), 2);
     produce_block_with!(ferdie.produce_block_with_slot(slot), alice)
         .await
         .unwrap();
@@ -745,9 +859,15 @@ async fn test_evm_domain_create_contracts_with_allow_list() {
     assert_eq!(receipt.consensus_block_hash, consensus_block_hash);
 
     produce_blocks!(ferdie, alice, 3).await.unwrap();
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_evm_domain_create_contracts_with_allow_list_multiple() {
+    let (_directory, mut ferdie, mut alice, account_infos) =
+        setup_evm_test_accounts(Sr25519Alice).await;
 
     // Multiple accounts in the allow list
-    allow_list = generate_evm_account_list(&account_infos, EvmAccountList::Multiple);
+    let allow_list = generate_evm_account_list(&account_infos, EvmAccountList::Multiple);
     let sudo_unsigned_extrinsic = alice
         .construct_unsigned_extrinsic(evm_domain_test_runtime::RuntimeCall::EVMNoncetracker(
             pallet_evm_tracker::Call::set_contract_creation_allowed_by {
@@ -783,7 +903,8 @@ async fn test_evm_domain_create_contracts_with_allow_list() {
         .unwrap();
 
     // Accounts 0-2 should be able to create contracts
-    eth_tx = generate_eth_domain_extrinsic(
+    let mut eth_nonce = U256::zero();
+    let mut eth_tx = generate_eth_domain_extrinsic(
         account_infos[1].clone(),
         ethereum::TransactionAction::Create,
         eth_nonce,
@@ -798,7 +919,8 @@ async fn test_evm_domain_create_contracts_with_allow_list() {
         "Unexpectedly failed to send self-contained extrinsic"
     );
 
-    evm_tx = generate_evm_domain_call(
+    let mut evm_nonce = U256::zero();
+    let mut evm_tx = generate_evm_domain_call(
         account_infos[2].clone(),
         ethereum::TransactionAction::Create,
         0,
@@ -817,7 +939,7 @@ async fn test_evm_domain_create_contracts_with_allow_list() {
 
     // Produce a bundle that contains just the sent extrinsics
     let (slot, bundle) = ferdie.produce_slot_and_wait_for_bundle_submission().await;
-    assert_eq!(bundle.extrinsics.len(), 1);
+    assert_eq!(bundle.extrinsics.len(), 2);
     produce_block_with!(ferdie.produce_block_with_slot(slot), alice)
         .await
         .unwrap();