switch polkadot zombienet-sdk tests to use cumulus test helpers (paritytech#7993)

paritytech#7988.

The coretime-revenue test is the one remaining which uses static data
types from the metadata for rococo and coretime-rococo. That test does
some quite intricate event decoding which actually benefits from having
static data types. Rewriting it using only dynamic types would actually
be counterproductive and would complicate it

Author: alindima

.github/workflows/build-publish-images.yml

@@ -313,7 +313,7 @@ jobs:
         uses: actions/checkout@v4
       - name: build
         run: |
-          forklift cargo nextest --manifest-path polkadot/zombienet-sdk-tests/Cargo.toml archive --locked --features zombie-metadata --archive-file polkadot-zombienet-tests.tar.zst
+          forklift cargo nextest --manifest-path polkadot/zombienet-sdk-tests/Cargo.toml archive --locked --features zombie-metadata,zombie-ci --archive-file polkadot-zombienet-tests.tar.zst
       - name: pack artifacts
         run: |
           mkdir -p artifacts

.gitlab/pipeline/build.yml

@@ -131,7 +131,7 @@ build-polkadot-zombienet-tests:
       artifacts: true
 
   script:
-    - cargo nextest --manifest-path polkadot/zombienet-sdk-tests/Cargo.toml archive --features zombie-metadata --archive-file polkadot-zombienet-tests.tar.zst
+    - cargo nextest --manifest-path polkadot/zombienet-sdk-tests/Cargo.toml archive --features zombie-metadata,zombie-ci --archive-file polkadot-zombienet-tests.tar.zst
     - mkdir -p artifacts
     - cp polkadot-zombienet-tests.tar.zst ./artifacts
 

cumulus/zombienet/zombienet-sdk-helpers/Cargo.toml

@@ -16,5 +16,5 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 subxt = { workspace = true, features = ["native"] }
 subxt-signer = { workspace = true }
-tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
+tokio = { workspace = true, features = ["rt-multi-thread", "macros", "time"] }
 

cumulus/zombienet/zombienet-sdk-helpers/src/lib.rs

@@ -12,7 +12,10 @@ use subxt::{
 	blocks::Block, events::Events, ext::scale_value::value, tx::DynamicPayload, utils::H256,
 	OnlineClient, PolkadotConfig,
 };
-use tokio::join;
+use tokio::{
+	join,
+	time::{sleep, Duration},
+};
 
 // Maximum number of blocks to wait for a session change.
 // If it does not arrive for whatever reason, we should not wait forever.
@@ -234,7 +237,7 @@ pub async fn assert_para_throughput(
 /// Wait for the first block with a session change.
 ///
 /// The session change is detected by inspecting the events in the block.
-async fn wait_for_first_session_change(
+pub async fn wait_for_first_session_change(
 	blocks_sub: &mut subxt::backend::StreamOfResults<
 		Block<PolkadotConfig, OnlineClient<PolkadotConfig>>,
 	>,
@@ -277,3 +280,25 @@ pub async fn assert_finality_lag(
 	assert!(finality_lag <= maximum_lag, "Expected finality to lag by a maximum of {maximum_lag} blocks, but was lagging by {finality_lag} blocks.");
 	Ok(())
 }
+
+/// Assert that finality has not stalled.
+pub async fn assert_blocks_are_being_finalized(
+	client: &OnlineClient<PolkadotConfig>,
+) -> Result<(), anyhow::Error> {
+	let mut finalized_blocks = client.blocks().subscribe_finalized().await?;
+	let first_measurement = finalized_blocks
+		.next()
+		.await
+		.ok_or(anyhow::anyhow!("Can't get finalized block from stream"))??
+		.number();
+	sleep(Duration::from_secs(12)).await;
+	let second_measurement = finalized_blocks
+		.next()
+		.await
+		.ok_or(anyhow::anyhow!("Can't get finalized block from stream"))??
+		.number();
+
+	assert!(second_measurement > first_measurement);
+
+	Ok(())
+}

polkadot/zombienet-sdk-tests/Cargo.toml

@@ -24,6 +24,7 @@ zombienet-sdk = { workspace = true }
 
 [features]
 zombie-metadata = []
+zombie-ci = []
 
 [build-dependencies]
 substrate-build-script-utils = { workspace = true, default-features = true }

polkadot/zombienet-sdk-tests/build.rs

@@ -27,14 +27,7 @@ fn make_env_key(k: &str) -> String {
 
 fn wasm_sub_path(chain: &str) -> String {
 	let (package, runtime_name) =
-		if let Some(cumulus_test_runtime) = chain.strip_prefix("cumulus-test-runtime-") {
-			(
-				"cumulus-test-runtime".to_string(),
-				format!("wasm_binary_{}.rs", replace_dashes(cumulus_test_runtime)),
-			)
-		} else {
-			(format!("{chain}-runtime"), replace_dashes(&format!("{chain}-runtime")))
-		};
+		(format!("{chain}-runtime"), replace_dashes(&format!("{chain}-runtime")));
 
 	format!("{}/{}.wasm", package, runtime_name)
 }
@@ -61,11 +54,7 @@ fn find_wasm(chain: &str) -> Option<PathBuf> {
 
 // based on https://gist.github.com/s0me0ne-unkn0wn/bbd83fe32ce10327086adbf13e750eec
 fn build_wasm(chain: &str) -> PathBuf {
-	let package = if chain.starts_with("cumulus-test-runtime-") {
-		String::from("cumulus-test-runtime")
-	} else {
-		format!("{chain}-runtime")
-	};
+	let package = format!("{chain}-runtime");
 
 	let cargo = env::var("CARGO").unwrap();
 	let target = env::var("TARGET").unwrap();
@@ -132,10 +121,6 @@ fn main() {
 	const METADATA_DIR: &str = "metadata-files";
 	const CHAINS: [&str; 2] = ["rococo", "coretime-rococo"];
 
-	// Add some cumulus test runtimes if needed. Formatted like
-	// "cumulus-test-runtime-elastic-scaling".
-	const CUMULUS_TEST_RUNTIMES: [&str; 0] = [];
-
 	let metadata_path = format!("{manifest_path}/{METADATA_DIR}");
 
 	for chain in CHAINS {
@@ -153,21 +138,6 @@ fn main() {
 		};
 	}
 
-	for chain in CUMULUS_TEST_RUNTIMES {
-		let full_path = format!("{metadata_path}/{chain}-local.scale");
-		let output_path = path::PathBuf::from(&full_path);
-
-		match output_path.try_exists() {
-			Ok(true) => {
-				debug_output!("got: {}", full_path);
-			},
-			_ => {
-				debug_output!("needs: {}", full_path);
-				fetch_metadata_file(chain, &output_path);
-			},
-		};
-	}
-
 	substrate_build_script_utils::generate_cargo_keys();
 	substrate_build_script_utils::rerun_if_git_head_changed();
 	println!("cargo:rerun-if-changed={}", metadata_path);

polkadot/zombienet-sdk-tests/tests/disabling/slashing.rs

@@ -6,8 +6,10 @@
 //! making some of the honest nodes go offline.
 
 use anyhow::anyhow;
-
-use crate::helpers::{assert_blocks_are_being_finalized, assert_para_throughput};
+use cumulus_zombienet_sdk_helpers::{
+	assert_blocks_are_being_finalized, assert_finalized_para_throughput,
+	wait_for_first_session_change,
+};
 use polkadot_primitives::{BlockNumber, CandidateHash, DisputeState, Id as ParaId, SessionIndex};
 use serde_json::json;
 use subxt::{OnlineClient, PolkadotConfig};
@@ -87,8 +89,12 @@ async fn dispute_past_session_slashing() -> Result<(), anyhow::Error> {
 	let relay_client: OnlineClient<PolkadotConfig> = honest.wait_client().await?;
 
 	// Wait for some para blocks being produced
-	assert_para_throughput(&relay_client, 20, [(ParaId::from(1337), 10..20)].into_iter().collect())
-		.await?;
+	assert_finalized_para_throughput(
+		&relay_client,
+		20,
+		[(ParaId::from(1337), 10..20)].into_iter().collect(),
+	)
+	.await?;
 
 	// Let's initiate a dispute
 	malus.resume().await?;
@@ -119,16 +125,7 @@ async fn dispute_past_session_slashing() -> Result<(), anyhow::Error> {
 	assert_ne!(dispute_session, u32::MAX, "dispute should be initiated");
 	log::info!("Dispute initiated, now waiting for a new session");
 
-	while let Some(block) = best_blocks.next().await {
-		let current_session = relay_client
-			.runtime_api()
-			.at(block?.hash())
-			.call_raw::<SessionIndex>("ParachainHost_session_index_for_child", None)
-			.await?;
-		if current_session > dispute_session {
-			break
-		}
-	}
+	wait_for_first_session_change(&mut best_blocks).await?;
 
 	// We don't need malus anymore
 	malus.pause().await?;

polkadot/zombienet-sdk-tests/tests/elastic_scaling/basic_3cores.rs

@@ -5,14 +5,7 @@
 // can achieve full throughput of 3 candidates per block.
 
 use anyhow::anyhow;
-
-use crate::helpers::{
-	assert_para_throughput, rococo,
-	rococo::runtime_types::{
-		pallet_broker::coretime_interface::CoreAssignment,
-		polkadot_runtime_parachains::assigner_coretime::PartsOf57600,
-	},
-};
+use cumulus_zombienet_sdk_helpers::{assert_finalized_para_throughput, create_assign_core_call};
 use polkadot_primitives::Id as ParaId;
 use serde_json::json;
 use subxt::{OnlineClient, PolkadotConfig};
@@ -84,30 +77,7 @@ async fn basic_3cores_test() -> Result<(), anyhow::Error> {
 	relay_client
 		.tx()
 		.sign_and_submit_then_watch_default(
-			&rococo::tx()
-				.sudo()
-				.sudo(rococo::runtime_types::rococo_runtime::RuntimeCall::Utility(
-					rococo::runtime_types::pallet_utility::pallet::Call::batch {
-						calls: vec![
-							rococo::runtime_types::rococo_runtime::RuntimeCall::Coretime(
-								rococo::runtime_types::polkadot_runtime_parachains::coretime::pallet::Call::assign_core {
-									core: 0,
-									begin: 0,
-									assignment: vec![(CoreAssignment::Task(2000), PartsOf57600(57600))],
-									end_hint: None
-								}
-							),
-							rococo::runtime_types::rococo_runtime::RuntimeCall::Coretime(
-								rococo::runtime_types::polkadot_runtime_parachains::coretime::pallet::Call::assign_core {
-									core: 1,
-									begin: 0,
-									assignment: vec![(CoreAssignment::Task(2000), PartsOf57600(57600))],
-									end_hint: None
-								}
-							),
-						],
-					},
-				)),
+			&create_assign_core_call(&[(0, 2000), (1, 2000)]),
 			&alice,
 		)
 		.await?
@@ -116,7 +86,7 @@ async fn basic_3cores_test() -> Result<(), anyhow::Error> {
 
 	log::info!("2 more cores assigned to adder-2000");
 
-	assert_para_throughput(
+	assert_finalized_para_throughput(
 		&relay_client,
 		15,
 		[(ParaId::from(2000), 40..46), (ParaId::from(2001), 12..16)]

polkadot/zombienet-sdk-tests/tests/elastic_scaling/doesnt_break_parachains.rs

@@ -5,13 +5,8 @@
 // itself if ElasticScalingMVP feature is enabled in genesis.
 
 use anyhow::anyhow;
-
-use crate::helpers::{
-	assert_finalized_block_height, assert_para_throughput, rococo,
-	rococo::runtime_types::{
-		pallet_broker::coretime_interface::CoreAssignment,
-		polkadot_runtime_parachains::assigner_coretime::PartsOf57600,
-	},
+use cumulus_zombienet_sdk_helpers::{
+	assert_finality_lag, assert_finalized_para_throughput, create_assign_core_call,
 };
 use polkadot_primitives::{CoreIndex, Id as ParaId};
 use serde_json::json;
@@ -77,19 +72,7 @@ async fn doesnt_break_parachains_test() -> Result<(), anyhow::Error> {
 
 	relay_client
 		.tx()
-		.sign_and_submit_then_watch_default(
-			&rococo::tx()
-				.sudo()
-				.sudo(rococo::runtime_types::rococo_runtime::RuntimeCall::Coretime(
-                    rococo::runtime_types::polkadot_runtime_parachains::coretime::pallet::Call::assign_core {
-                        core: 0,
-                        begin: 0,
-                        assignment: vec![(CoreAssignment::Task(2000), PartsOf57600(57600))],
-                        end_hint: None
-                    }
-                )),
-			&alice,
-		)
+		.sign_and_submit_then_watch_default(&create_assign_core_call(&[(0, 2000)]), &alice)
 		.await?
 		.wait_for_finalized_success()
 		.await?;
@@ -98,12 +81,13 @@ async fn doesnt_break_parachains_test() -> Result<(), anyhow::Error> {
 
 	let para_id = ParaId::from(2000);
 	// Expect the parachain to be making normal progress, 1 candidate backed per relay chain block.
-	assert_para_throughput(&relay_client, 15, [(para_id, 13..16)].into_iter().collect()).await?;
+	assert_finalized_para_throughput(&relay_client, 15, [(para_id, 13..16)].into_iter().collect())
+		.await?;
 
 	let para_client = para_node.wait_client().await?;
 	// Assert the parachain finalized block height is also on par with the number of backed
 	// candidates.
-	assert_finalized_block_height(&para_client, 12..16).await?;
+	assert_finality_lag(&para_client, 5).await?;
 
 	// Sanity check that indeed the parachain has two assigned cores.
 	let cq = relay_client

polkadot/zombienet-sdk-tests/tests/functional/async_backing_6_seconds_rate.rs

@@ -5,7 +5,7 @@
 
 use anyhow::anyhow;
 
-use crate::helpers::{assert_finalized_block_height, assert_para_throughput};
+use cumulus_zombienet_sdk_helpers::{assert_finality_lag, assert_finalized_para_throughput};
 use polkadot_primitives::Id as ParaId;
 use serde_json::json;
 use subxt::{OnlineClient, PolkadotConfig};
@@ -73,7 +73,7 @@ async fn async_backing_6_seconds_rate_test() -> Result<(), anyhow::Error> {
 
 	let relay_client: OnlineClient<PolkadotConfig> = relay_node.wait_client().await?;
 
-	assert_para_throughput(
+	assert_finalized_para_throughput(
 		&relay_client,
 		15,
 		[(ParaId::from(2000), 11..16), (ParaId::from(2001), 11..16)]
@@ -84,7 +84,7 @@ async fn async_backing_6_seconds_rate_test() -> Result<(), anyhow::Error> {
 
 	// Assert the parachain finalized block height is also on par with the number of backed
 	// candidates. We can only do this for the collator based on cumulus.
-	assert_finalized_block_height(&para_node_2001.wait_client().await?, 10..16).await?;
+	assert_finality_lag(&para_node_2001.wait_client().await?, 5).await?;
 
 	log::info!("Test finished successfully");