Add script upgrade for multisig v2 integration test'

test/Cargo.toml

@@ -21,6 +21,7 @@ ckb-types = "1.0"
 ckb-jsonrpc-types = "1.0"
 ckb-app-config = "1.0"
 ckb-chain-spec = "1.0"
+ckb-system-scripts-v0_6_0 = { package = "ckb-system-scripts", version = "0.6.0" }
 regex = "1.1.6"
 faster-hex = "0.6"
 tokio = { version = "1", features = ["net", "io-util", "rt"] }

test/src/main.rs

@@ -8,11 +8,12 @@ use crate::app::App;
 use crate::setup::Setup;
 use crate::spec::{
     AccountKeystoreExportPerm, AccountKeystorePerm, AccountKeystoreUpdatePassword,
-    DaoPrepareMultiple, DaoPrepareOne, DaoWithdrawMultiple, DeployDepGroupEnableTypeIdLater,
+    DaoPrepareMultiple, DaoPrepareOne, DaoWithdrawMultiple, DeployMultisigV2Upgrade,
+    DeployMultisigV2UpgradeTestnet, DeployDepGroupEnableTypeIdLater,
     DeployDepGroupTypeIdTracking, DeployDepGroupWithTypeId, DeployDepGroupWithoutTypeId, Plugin,
-    RpcGetTipBlockNumber, Spec, SudtIssueToAcp, SudtIssueToCheque, SudtTransferToChequeForClaim,
-    SudtTransferToChequeForWithdraw, SudtTransferToMultiAcp, Util, WalletTimelockedAddress,
-    WalletTransfer,
+    RpcGetTipBlockNumber, Spec, SudtIssueToAcp,
+    SudtIssueToCheque, SudtTransferToChequeForClaim, SudtTransferToChequeForWithdraw,
+    SudtTransferToMultiAcp, Util, WalletTimelockedAddress, WalletTransfer,
 };
 use crate::util::{find_available_port, run_cmd, temp_dir};
 use std::env;
@@ -33,13 +34,28 @@ async fn main() {
         .map(|s| s.to_string())
         .or_else(|| env::var("SPEC_FILTER").ok());
 
-    let specs: Vec<_> = all_specs()
-        .into_iter()
-        .filter(|spec| match &spec_filter {
-            Some(filter) => spec.spec_name().contains(filter),
-            None => true,
-        })
-        .collect();
+    let available_specs = all_specs();
+    let specs: Vec<_> = match &spec_filter {
+        Some(filter) => {
+            let has_exact = available_specs
+                .iter()
+                .any(|spec| spec.spec_name() == filter.as_str());
+            available_specs
+                .into_iter()
+                .filter(|spec| {
+                    if has_exact {
+                        spec.spec_name() == filter
+                    } else {
+                        spec.spec_name().contains(filter)
+                    }
+                })
+                .collect()
+        }
+        None => available_specs
+            .into_iter()
+            .filter(|spec| !spec.spec_name().to_lowercase().contains("testnet"))
+            .collect(),
+    };
 
     if specs.is_empty() {
         if let Some(filter) = &spec_filter {
@@ -68,22 +84,31 @@ async fn main() {
 
 fn run_spec(spec: Box<dyn Spec>, app: &App) {
     let (tempdir, ckb_dir) = temp_dir();
-    let rpc_port = find_available_port(8000, 8099);
-    let p2p_port = find_available_port(8100, 8199);
-    let _stdout = run_cmd(
-        app.ckb_bin(),
-        vec![
-            "-C",
-            ckb_dir.as_str(),
-            "init",
-            "--chain",
-            "dev",
-            "--rpc-port",
-            &rpc_port.to_string(),
-            "--p2p-port",
-            &p2p_port.to_string(),
-        ],
-    );
+    let rpc_override = spec.rpc_override();
+    let (rpc_port, p2p_port) = if rpc_override.is_none() {
+        (
+            find_available_port(8000, 8099),
+            find_available_port(8100, 8199),
+        )
+    } else {
+        (0, 0)
+    };
+    if rpc_override.is_none() {
+        let _stdout = run_cmd(
+            app.ckb_bin(),
+            vec![
+                "-C",
+                ckb_dir.as_str(),
+                "init",
+                "--chain",
+                "dev",
+                "--rpc-port",
+                &rpc_port.to_string(),
+                "--p2p-port",
+                &p2p_port.to_string(),
+            ],
+        );
+    }
 
     let mut ckb_cli_dir = PathBuf::from(ckb_dir.as_str());
     ckb_cli_dir.push("ckb-cli");
@@ -95,6 +120,7 @@ fn run_spec(spec: Box<dyn Spec>, app: &App) {
         app.keystore_plugin_bin().to_string(),
         ckb_dir,
         rpc_port,
+        rpc_override,
         tempdir,
     );
     let _ckb_guard = setup.ready(&*spec);
@@ -125,5 +151,7 @@ fn all_specs() -> Vec<Box<dyn Spec>> {
         Box::new(DeployDepGroupWithTypeId),
         Box::new(DeployDepGroupTypeIdTracking),
         Box::new(DeployDepGroupEnableTypeIdLater),
+        Box::new(DeployMultisigV2Upgrade),
+        Box::new(DeployMultisigV2UpgradeTestnet),
     ]
 }

test/src/setup.rs

@@ -18,6 +18,7 @@ pub struct Setup {
     pub keystore_plugin_bin: String,
     ckb_dir: String,
     rpc_port: u16,
+    rpc_override: Option<String>,
     miner: Option<Miner>,
     success: bool,
     tempdir: PathBuf,
@@ -32,6 +33,7 @@ impl Setup {
         keystore_plugin_bin: String,
         ckb_dir: String,
         rpc_port: u16,
+        rpc_override: Option<String>,
         tempdir: tempfile::TempDir,
     ) -> Self {
         Self {
@@ -40,13 +42,18 @@ impl Setup {
             keystore_plugin_bin,
             ckb_dir,
             rpc_port,
+            rpc_override,
             miner: None,
             success: false,
             tempdir: tempdir.into_path(),
         }
     }
 
     pub fn ready(&mut self, spec: &dyn Spec) -> ProcessGuard {
+        if self.rpc_override.is_some() {
+            // External RPC: nothing to boot locally.
+            return ProcessGuard(None);
+        }
         self.modify_ckb_toml(spec);
         self.modify_spec_toml(spec);
 
@@ -64,10 +71,13 @@ impl Setup {
             .expect("Run `ckb run` failed");
 
         sleep(Duration::from_secs(3)); // Wait for ckb starting RPC thread
-        ProcessGuard(ckb_child_process)
+        ProcessGuard(Some(ckb_child_process))
     }
 
     pub fn miner(&mut self) -> &Miner {
+        if self.rpc_override.is_some() {
+            panic!("miner is unavailable when using an external rpc url");
+        }
         if self.miner.is_none() {
             self.miner = Some(Miner::init(self.rpc_url()));
         }
@@ -79,7 +89,10 @@ impl Setup {
     }
 
     pub fn rpc_url(&self) -> String {
-        format!("http://127.0.0.1:{}", self.rpc_port)
+        match &self.rpc_override {
+            Some(url) => url.clone(),
+            None => format!("http://127.0.0.1:{}", self.rpc_port),
+        }
     }
 
     pub fn consensus(&self) -> Consensus {