test: add global contract update test (#12992)

This PR introduces test loop test for updating global contract deployed
by account id.

Part of #12718.

Author: pugachAG

test-loop-tests/Cargo.toml

@@ -42,3 +42,42 @@ near-test-contracts.workspace = true
 near-vm-runner.workspace = true
 nearcore.workspace = true
 testlib.workspace = true
+
+[features]
+nightly = [
+  "near-async/nightly",
+  "near-chain-configs/nightly",
+  "near-chain/nightly",
+  "near-chunks/nightly",
+  "near-client/nightly",
+  "near-epoch-manager/nightly",
+  "near-jsonrpc/nightly",
+  "near-network/nightly",
+  "near-o11y/nightly",
+  "near-parameters/nightly",
+  "near-primitives-core/nightly",
+  "near-primitives/nightly",
+  "near-store/nightly",
+  "near-vm-runner/nightly",
+  "nearcore/nightly",
+  "nightly_protocol",
+  "testlib/nightly",
+]
+nightly_protocol = [
+  "near-async/nightly_protocol",
+  "near-chain-configs/nightly_protocol",
+  "near-chain/nightly_protocol",
+  "near-chunks/nightly_protocol",
+  "near-client/nightly_protocol",
+  "near-epoch-manager/nightly_protocol",
+  "near-jsonrpc/nightly_protocol",
+  "near-network/nightly_protocol",
+  "near-o11y/nightly_protocol",
+  "near-parameters/nightly_protocol",
+  "near-primitives-core/nightly_protocol",
+  "near-primitives/nightly_protocol",
+  "near-store/nightly_protocol",
+  "near-vm-runner/nightly_protocol",
+  "nearcore/nightly_protocol",
+  "testlib/nightly_protocol",
+]

test-loop-tests/src/tests/global_contracts.rs

@@ -12,7 +12,9 @@ use near_o11y::testonly::init_test_logger;
 use near_parameters::{ActionCosts, RuntimeConfigStore, RuntimeFeesConfig};
 use near_primitives::action::{GlobalContractDeployMode, GlobalContractIdentifier};
 use near_primitives::epoch_manager::EpochConfigStore;
-use near_primitives::errors::{ActionError, ActionErrorKind, TxExecutionError};
+use near_primitives::errors::{
+    ActionError, ActionErrorKind, FunctionCallError, MethodResolveError, TxExecutionError,
+};
 use near_primitives::hash::CryptoHash;
 use near_primitives::shard_layout::ShardLayout;
 use near_primitives::test_utils::create_user_test_signer;
@@ -80,6 +82,46 @@ fn test_use_non_existent_global_contract() {
     env.shutdown();
 }
 
+#[cfg_attr(not(feature = "nightly_protocol"), ignore)]
+#[test]
+fn test_global_contract_update() {
+    let mut env = GlobalContractsTestEnv::setup(1000 * ONE_NEAR);
+    let use_accounts = [env.account_shard_0.clone(), env.account_shard_1.clone()];
+
+    env.deploy_trivial_global_contract(GlobalContractDeployMode::AccountId);
+
+    for account in &use_accounts {
+        env.use_global_contract(
+            account,
+            GlobalContractIdentifier::AccountId(env.deploy_account.clone()),
+        );
+
+        // Currently deployed trivial contract doesn't have any methods,
+        // so we expect any function call to fail with MethodNotFound error
+        let call_tx = env.call_global_contract_tx(account);
+        let call_outcome = env.execute_tx(call_tx);
+        assert_matches!(
+            call_outcome.status,
+            FinalExecutionStatus::Failure(TxExecutionError::ActionError(ActionError {
+                kind: ActionErrorKind::FunctionCallError(FunctionCallError::MethodResolveError(
+                    MethodResolveError::MethodNotFound
+                )),
+                index: _
+            }))
+        );
+    }
+
+    env.deploy_global_contract(GlobalContractDeployMode::AccountId);
+
+    for account in &use_accounts {
+        // Function call should be successful after deploying rs contract
+        // containing the function we call here
+        env.call_global_contract(account);
+    }
+
+    env.shutdown();
+}
+
 fn test_deploy_and_call_global_contract(deploy_mode: GlobalContractDeployMode) {
     const INITIAL_BALANCE: Balance = 1000 * ONE_NEAR;
     let mut env = GlobalContractsTestEnv::setup(INITIAL_BALANCE);
@@ -185,25 +227,41 @@ impl GlobalContractsTestEnv {
         }
     }
 
-    fn deploy_global_contract_tx(
+    fn deploy_global_contract_custom_tx(
         &mut self,
         deploy_mode: GlobalContractDeployMode,
+        contract_code: Vec<u8>,
     ) -> SignedTransaction {
         SignedTransaction::deploy_global_contract(
             self.next_nonce(),
             self.deploy_account.clone(),
-            self.contract.code().to_vec(),
+            contract_code,
             &create_user_test_signer(&self.deploy_account),
             self.get_tx_block_hash(),
             deploy_mode,
         )
     }
 
+    fn deploy_global_contract_tx(
+        &mut self,
+        deploy_mode: GlobalContractDeployMode,
+    ) -> SignedTransaction {
+        self.deploy_global_contract_custom_tx(deploy_mode, self.contract.code().to_vec())
+    }
+
     fn deploy_global_contract(&mut self, deploy_mode: GlobalContractDeployMode) {
         let tx = self.deploy_global_contract_tx(deploy_mode);
         self.run_tx(tx);
     }
 
+    fn deploy_trivial_global_contract(&mut self, deploy_mode: GlobalContractDeployMode) {
+        let tx = self.deploy_global_contract_custom_tx(
+            deploy_mode,
+            near_test_contracts::trivial_contract().to_vec(),
+        );
+        self.run_tx(tx);
+    }
+
     fn deploy_regular_contract(&mut self, account: &AccountId) {
         let tx = SignedTransaction::deploy_contract(
             self.next_nonce(),
@@ -234,8 +292,8 @@ impl GlobalContractsTestEnv {
         self.run_tx(tx);
     }
 
-    fn call_global_contract(&mut self, account: &AccountId) {
-        let tx = SignedTransaction::call(
+    fn call_global_contract_tx(&mut self, account: &AccountId) -> SignedTransaction {
+        SignedTransaction::call(
             self.next_nonce(),
             account.clone(),
             account.clone(),
@@ -245,7 +303,11 @@ impl GlobalContractsTestEnv {
             vec![],
             300 * TGAS,
             self.get_tx_block_hash(),
-        );
+        )
+    }
+
+    fn call_global_contract(&mut self, account: &AccountId) {
+        let tx = self.call_global_contract_tx(account);
         self.run_tx(tx);
     }