test(ckerc20): stop ckETH minter before upgrading it in state machine tests

Author: gregorydemay

Cargo.lock

@@ -3,6 +3,7 @@ use candid::{Nat, Principal};
 use ic_cketh_minter::endpoints::events::EventPayload;
 use ic_cketh_minter::endpoints::AddCkErc20Token;
 use ic_cketh_test_utils::ckerc20::CkErc20Setup;
+use ic_cketh_test_utils::flow::DepositParams;
 use ic_cketh_test_utils::CkEthSetup;
 use ic_ethereum_types::Address;
 use ic_ledger_suite_orchestrator_test_utils::supported_erc20_tokens;
@@ -60,6 +61,14 @@ fn should_add_ckusdc_and_ckusdt_to_minter_via_orchestrator() {
     }
 }
 
+#[test]
+fn should_mint_with_ckerc20_setup() {
+    CkErc20Setup::default()
+        .cketh
+        .deposit(DepositParams::default())
+        .expect_mint();
+}
+
 fn format_ethereum_address_to_eip_55(address: &str) -> String {
     use std::str::FromStr;
     Address::from_str(address).unwrap().to_string()

rs/ethereum/cketh/minter/tests/ckerc20.rs

@@ -23,6 +23,7 @@ rust_library(
         "//rs/state_machine_tests",
         "//rs/test_utilities/load_wasm",
         "//rs/types/base_types",
+        "@crate_index//:assert_matches",
         "@crate_index//:candid",
         "@crate_index//:ethers-core",
         "@crate_index//:hex",

rs/ethereum/cketh/test_utils/BUILD.bazel

@@ -7,6 +7,7 @@ edition.workspace = true
 documentation.workspace = true
 
 [dependencies]
+assert_matches = "1.5.0"
 candid = { workspace = true }
 ethers-core = "2.0.8"
 hex = "0.4"

rs/ethereum/cketh/test_utils/Cargo.toml

@@ -2,6 +2,7 @@ use crate::flow::{
     ApprovalFlow, DepositFlow, DepositParams, LedgerTransactionAssert, WithdrawalFlow,
 };
 use crate::mock::JsonRpcMethod;
+use assert_matches::assert_matches;
 use candid::{Decode, Encode, Nat, Principal};
 use ic_canisters_http_types::{HttpRequest, HttpResponse};
 use ic_cketh_minter::endpoints::events::{Event, EventPayload, GetEventsResult};
@@ -15,7 +16,8 @@ use ic_cketh_minter::{
 use ic_ethereum_types::Address;
 use ic_icrc1_ledger::{InitArgsBuilder as LedgerInitArgsBuilder, LedgerArgument};
 use ic_state_machine_tests::{
-    CanisterId, Cycles, PrincipalId, StateMachine, StateMachineBuilder, UserError, WasmResult,
+    CanisterHttpResponsePayload, CanisterId, Cycles, PayloadBuilder, PrincipalId, StateMachine,
+    StateMachineBuilder, UserError, WasmResult,
 };
 use ic_test_utilities_load_wasm::load_wasm;
 use icrc_ledger_types::icrc1::account::Account;
@@ -425,13 +427,45 @@ impl CkEthSetup {
     }
 
     fn upgrade_minter(&self, upgrade_arg: UpgradeArg) {
+        self.stop_minter();
         self.env
             .upgrade_canister(
                 self.minter_id,
                 minter_wasm(),
                 Encode!(&MinterArg::UpgradeArg(upgrade_arg)).unwrap(),
             )
             .unwrap();
+        self.start_minter();
+    }
+
+    fn stop_minter(&self) {
+        let stop_msg_id = self.env.stop_canister_non_blocking(self.minter_id);
+        self.stop_ongoing_https_outcalls();
+        let stop_res = self.env.await_ingress(stop_msg_id, 100);
+        assert_matches!(stop_res, Ok(WasmResult::Reply(_)));
+    }
+
+    fn stop_ongoing_https_outcalls(&self) {
+        let server_error_response = CanisterHttpResponsePayload {
+            status: 500_u128,
+            headers: vec![],
+            body: vec![],
+        };
+        let ongoing_https_outcalls: Vec<_> = self
+            .env
+            .canister_http_request_contexts()
+            .into_keys()
+            .collect();
+        let mut payload = PayloadBuilder::new();
+        for callback_id in ongoing_https_outcalls {
+            payload = payload.http_response(callback_id, &server_error_response);
+        }
+        self.env.execute_payload(payload);
+    }
+
+    fn start_minter(&self) {
+        let start_res = self.env.start_canister(self.minter_id);
+        assert_matches!(start_res, Ok(WasmResult::Reply(_)));
     }
 
     pub fn upgrade_minter_to_add_orchestrator_id(self, orchestrator_id: Principal) -> Self {

rs/ethereum/cketh/test_utils/src/lib.rs

@@ -2259,6 +2259,21 @@ impl StateMachine {
         )
     }
 
+    /// Stops the canister with the specified ID in a non-blocking way.
+    ///
+    /// This function is asynchronous. It returns the ID of the ingress message
+    /// that can be awaited later with [await_ingress].
+    /// This allows to do some clean-up between the time the canister is in the stopping state
+    /// and the time it is actually stopped.
+    pub fn stop_canister_non_blocking(&self, canister_id: CanisterId) -> MessageId {
+        self.send_ingress(
+            PrincipalId::new_anonymous(),
+            CanisterId::ic_00(),
+            "stop_canister",
+            (CanisterIdRecord::from(canister_id)).encode(),
+        )
+    }
+
     /// Calls the `canister_status` endpoint on the management canister.
     pub fn canister_status(
         &self,