try-runtime-cli: execute-block & create-snapshot tests (#14343)

* execute-block test

* test create-snapshot

* oops

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

Co-authored-by: Liam Aharon <liam.aharon@hotmail.com>

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

Co-authored-by: Liam Aharon <liam.aharon@hotmail.com>

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

Co-authored-by: Liam Aharon <liam.aharon@hotmail.com>

* remove snapshot

* execute block: new log

* use prefix & make tempfile a dev dependencie

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

Co-authored-by: Liam Aharon <liam.aharon@hotmail.com>

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

Co-authored-by: Liam Aharon <liam.aharon@hotmail.com>

* ".git/.scripts/commands/fmt/fmt.sh"

* --at option in execute-block test

* fixes & use --at option in create-snapshot test

* hmm

* fmt

* remove nonsense

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

Co-authored-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

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

Co-authored-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

* remove unnecessary test modules

* try to load snapshot file

* fix

---------

Co-authored-by: Liam Aharon <liam.aharon@hotmail.com>
Co-authored-by: command-bot <>
Co-authored-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

substrate/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]

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

@@ -0,0 +1,95 @@
+// 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")]
+
+use assert_cmd::cargo::cargo_bin;
+use node_primitives::Hash;
+use regex::Regex;
+use remote_externalities::{Builder, Mode, OfflineConfig, SnapshotConfig};
+use sp_runtime::testing::{Block as RawBlock, ExtrinsicWrapper};
+use std::{
+	path::{Path, PathBuf},
+	process,
+	time::Duration,
+};
+use substrate_cli_test_utils as common;
+use tokio::process::{Child, Command};
+
+type Block = RawBlock<ExtrinsicWrapper<Hash>>;
+
+#[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");
+
+		// Try and load the snapshot we have created by running `create-snapshot`.
+		let snapshot_loading_result = Builder::<Block>::new()
+			.mode(Mode::Offline(OfflineConfig {
+				state_snapshot: SnapshotConfig { path: snap_file_path },
+			}))
+			.build()
+			.await;
+
+		assert!(snapshot_loading_result.is_ok(), "Snapshot couldn't be loaded");
+	})
+	.await;
+}

substrate/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")]
+
+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);
+
+		// The execute-block command is actually executing the next block.
+		let expected_output =
+			format!(r#".*Block #{} successfully executed"#, block_number.saturating_add(1));
+		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;
+}

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

@@ -17,49 +17,47 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 #![cfg(unix)]
+#![cfg(feature = "try-runtime")]
 
-#[cfg(feature = "try-runtime")]
-mod tests {
-	use assert_cmd::cargo::cargo_bin;
-	use regex::Regex;
-	use std::{
-		process::{self},
-		time::Duration,
-	};
-	use substrate_cli_test_utils as common;
-	use tokio::process::{Child, Command};
+use assert_cmd::cargo::cargo_bin;
+use regex::Regex;
+use std::{
+	process::{self},
+	time::Duration,
+};
+use substrate_cli_test_utils as common;
+use tokio::process::{Child, Command};
 
-	#[tokio::test]
-	async fn follow_chain_works() {
-		// Build substrate so binaries used in the test use the latest code.
-		common::build_substrate(&["--features=try-runtime"]);
+#[tokio::test]
+async fn follow_chain_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 start_follow(ws_url: &str) -> Child {
-				Command::new(cargo_bin("substrate"))
-					.stdout(process::Stdio::piped())
-					.stderr(process::Stdio::piped())
-					.args(&["try-runtime", "--runtime=existing"])
-					.args(&["follow-chain", format!("--uri={}", ws_url).as_str()])
-					.kill_on_drop(true)
-					.spawn()
-					.unwrap()
-			}
+	common::run_with_timeout(Duration::from_secs(60), async move {
+		fn start_follow(ws_url: &str) -> Child {
+			Command::new(cargo_bin("substrate"))
+				.stdout(process::Stdio::piped())
+				.stderr(process::Stdio::piped())
+				.args(&["try-runtime", "--runtime=existing"])
+				.args(&["follow-chain", format!("--uri={}", ws_url).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(1, &ws_url).await;
+		// 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(1, &ws_url).await;
 
-			// Kick off the follow-chain process and wait for it to process at least 3 blocks.
-			let mut follow = start_follow(&ws_url);
-			let re = Regex::new(r#".*executed block ([3-9]|[1-9]\d+).*"#).unwrap();
-			let matched =
-				common::wait_for_stream_pattern_match(follow.stderr.take().unwrap(), re).await;
+		// Kick off the follow-chain process and wait for it to process at least 3 blocks.
+		let mut follow = start_follow(&ws_url);
+		let re = Regex::new(r#".*executed block ([3-9]|[1-9]\d+).*"#).unwrap();
+		let matched =
+			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(_)));
-		})
-		.await;
-	}
+		// Assert that the follow-chain process has followed at least 3 blocks.
+		assert!(matched.is_ok());
+	})
+	.await;
 }