Repository: paritytech/substrate
File: utils/frame/try-runtime/cli/tests/execute_block.rs (Rust)

Code before:
	#[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) -> 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()])
					.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;

			// Try to execute a block.
			let mut block_execution = execute_block(&ws_url);
			let re = Regex::new(r#".*executing block #(\d+)"#).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;
	}
}


Review comment (suggestion):
Matching this line will tell us the executing the block started, but not that it completed successfully. 

If there's no suitable log to match already, it's probably sensible to add a new one that fires at the end of `try_execute_block` if it executed without errors.

Code after:
	// 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;
}