try-runtime-cli: execute-block & create-snapshot tests

frame/executive/src/lib.rs

@@ -332,6 +332,12 @@ where
 			);
 		}
 
+		frame_support::log::info!(
+			target: LOG_TARGET,
+			"try-runtime: Block #{:?} successfully executed",
+			header.number(),
+		);
+
 		Ok(frame_system::Pallet::<System>::block_weight().total())
 	}
 

test-utils/cli/Cargo.toml

@@ -14,6 +14,7 @@ targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
 substrate-rpc-client = { path = "../../utils/frame/rpc/client" }
+sp-rpc = { version = "6.0.0", path = "../../primitives/rpc" }
 assert_cmd = "2.0.10"
 nix = "0.26.2"
 regex = "1.7.3"

test-utils/cli/src/lib.rs

@@ -25,6 +25,7 @@ use nix::{
 };
 use node_primitives::{Hash, Header};
 use regex::Regex;
+use sp_rpc::{list::ListOrValue, number::NumberOrHex};
 use std::{
 	env,
 	io::{BufRead, BufReader, Read},
@@ -177,7 +178,8 @@ pub async fn wait_n_finalized_blocks(n: usize, url: &str) {
 	use substrate_rpc_client::{ws_client, ChainApi};
 
 	let mut built_blocks = std::collections::HashSet::new();
-	let mut interval = tokio::time::interval(Duration::from_secs(2));
+	let block_duration = Duration::from_secs(2);
+	let mut interval = tokio::time::interval(block_duration);
 	let rpc = ws_client(url).await.unwrap();
 
 	loop {
@@ -220,6 +222,25 @@ pub async fn run_node_for_a_while(base_path: &Path, args: &[&str]) {
 	.await
 }
 
+pub async fn block_hash(block_number: u64, url: &str) -> Result<Hash, String> {
+	use substrate_rpc_client::{ws_client, ChainApi};
+
+	let rpc = ws_client(url).await.unwrap();
+
+	let result = ChainApi::<(), Hash, Header, ()>::block_hash(
+		&rpc,
+		Some(ListOrValue::Value(NumberOrHex::Number(block_number.saturating_sub(1)))),
+	)
+	.await
+	.map_err(|_| "Couldn't get block hash".to_string())?;
+
+	match result {
+		ListOrValue::Value(maybe_block_hash) if maybe_block_hash.is_some() =>
+			Ok(maybe_block_hash.unwrap()),
+		_ => Err("Couldn't get block hash".to_string()),
+	}
+}
+
 pub struct KillChildOnDrop(pub Child);
 
 impl KillChildOnDrop {

utils/frame/try-runtime/cli/Cargo.toml

@@ -46,8 +46,10 @@ zstd = { version = "0.12.3", default-features = false }
 
 [dev-dependencies]
 assert_cmd = "2.0.10"
+node-primitives = { path = "../../../../bin/node/primitives" }
 regex = "1.7.3"
 substrate-cli-test-utils = { path = "../../../../test-utils/cli" }
+tempfile = "3.1.0"
 tokio = "1.27.0"
 
 [features]

utils/frame/try-runtime/cli/tests/create_snapshot.rs

@@ -0,0 +1,82 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+#![cfg(unix)]
+#[cfg(feature = "try-runtime")]
+mod tests {
+	use assert_cmd::cargo::cargo_bin;
+	use node_primitives::Hash;
+	use regex::Regex;
+	use std::{
+		path::{Path, PathBuf},
+		process,
+		time::Duration,
+	};
+	use substrate_cli_test_utils as common;
+	use tokio::process::{Child, Command};
+
+	#[tokio::test]
+	async fn create_snapshot_works() {
+		// Build substrate so binaries used in the test use the latest code.
+		common::build_substrate(&["--features=try-runtime"]);
+
+		let temp_dir = tempfile::Builder::new()
+			.prefix("try-runtime-cli-test-dir")
+			.tempdir()
+			.expect("Failed to create a tempdir");
+		let snap_file_path = temp_dir.path().join("snapshot.snap");
+
+		common::run_with_timeout(Duration::from_secs(60), async move {
+			fn create_snapshot(ws_url: &str, snap_file: &PathBuf, at: Hash) -> Child {
+				Command::new(cargo_bin("substrate"))
+					.stdout(process::Stdio::piped())
+					.stderr(process::Stdio::piped())
+					.args(&["try-runtime", "--runtime=existing"])
+					.args(&["create-snapshot", format!("--uri={}", ws_url).as_str()])
+					.arg(snap_file)
+					.args(&["--at", format!("{:?}", at).as_str()])
+					.kill_on_drop(true)
+					.spawn()
+					.unwrap()
+			}
+
+			// Start a node and wait for it to begin finalizing blocks
+			let mut node = common::KillChildOnDrop(common::start_node());
+			let ws_url = common::extract_info_from_output(node.stderr.take().unwrap()).0.ws_url;
+			common::wait_n_finalized_blocks(3, &ws_url).await;
+
+			let block_number = 2;
+			let block_hash = common::block_hash(block_number, &ws_url).await.unwrap();
+
+			// Try to create a snapshot.
+			let mut snapshot_creation = create_snapshot(&ws_url, &snap_file_path, block_hash);
+
+			let re = Regex::new(r#".*writing snapshot of (\d+) bytes to .*"#).unwrap();
+			let matched =
+				common::wait_for_stream_pattern_match(snapshot_creation.stderr.take().unwrap(), re)
+					.await;
+
+			// Assert that the snapshot creation succeded.
+			assert!(matched.is_ok(), "Failed to create snapshot");
+
+			let snapshot_is_on_disk = Path::new(&snap_file_path).exists();
+			assert!(snapshot_is_on_disk, "Snapshot was not written to disk");
+		})
+		.await;
+	}
+}

utils/frame/try-runtime/cli/tests/execute_block.rs

@@ -0,0 +1,70 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+#![cfg(unix)]
+#[cfg(feature = "try-runtime")]
+mod tests {
+	use assert_cmd::cargo::cargo_bin;
+	use node_primitives::Hash;
+	use regex::Regex;
+	use std::{process, time::Duration};
+	use substrate_cli_test_utils as common;
+	use tokio::process::{Child, Command};
+
+	#[tokio::test]
+	async fn block_execution_works() {
+		// Build substrate so binaries used in the test use the latest code.
+		common::build_substrate(&["--features=try-runtime"]);
+
+		common::run_with_timeout(Duration::from_secs(60), async move {
+			fn execute_block(ws_url: &str, at: Hash) -> Child {
+				Command::new(cargo_bin("substrate"))
+					.stdout(process::Stdio::piped())
+					.stderr(process::Stdio::piped())
+					.args(&["try-runtime", "--runtime=existing"])
+					.args(&["execute-block"])
+					.args(&["live", format!("--uri={}", ws_url).as_str()])
+					.args(&["--at", format!("{:?}", at).as_str()])
+					.kill_on_drop(true)
+					.spawn()
+					.unwrap()
+			}
+
+			// Start a node and wait for it to begin finalizing blocks
+			let mut node = common::KillChildOnDrop(common::start_node());
+			let ws_url = common::extract_info_from_output(node.stderr.take().unwrap()).0.ws_url;
+			common::wait_n_finalized_blocks(3, &ws_url).await;
+
+			let block_number = 1;
+			let block_hash = common::block_hash(block_number, &ws_url).await.unwrap();
+
+			// Try to execute the block.
+			let mut block_execution = execute_block(&ws_url, block_hash);
+
+			let expected_output = format!(r#".*Block #{} successfully executed"#, block_number);
+			let re = Regex::new(expected_output.as_str()).unwrap();
+			let matched =
+				common::wait_for_stream_pattern_match(block_execution.stderr.take().unwrap(), re)
+					.await;
+
+			// Assert that the block-execution process has executed a block.
+			assert!(matched.is_ok());
+		})
+		.await;
+	}
+}

utils/frame/try-runtime/cli/tests/follow_chain.rs

@@ -58,7 +58,7 @@ mod tests {
 				common::wait_for_stream_pattern_match(follow.stderr.take().unwrap(), re).await;
 
 			// Assert that the follow-chain process has followed at least 3 blocks.
-			assert!(matches!(matched, Ok(_)));
+			assert!(matched.is_ok());
 		})
 		.await;
 	}