add scheduling tests for v3 descriptor with v2 collators

.github/zombienet-tests/zombienet_polkadot_tests.yml

@@ -251,3 +251,36 @@
   test-filter: "functional::coretime_partitioning::coretime_assignment_boundary_test"
   runner-type: "default"
   use-zombienet-sdk: true
+
+- job-name: "zombienet-polkadot-scheduling-v3-dynamic-enablement"
+  test-filter: "scheduling::v3_dynamic_enablement::v3_dynamic_enablement_test"
+  runner-type: "default"
+  use-zombienet-sdk: true
+  cumulus-image: "test-parachain"
+
+- job-name: "zombienet-polkadot-scheduling-v3-rolling-upgrade"
+  test-filter: "scheduling::v3_rolling_upgrade::v3_rolling_upgrade"
+  runner-type: "default"
+  use-zombienet-sdk: true
+  cumulus-image: "test-parachain"
+  additional-setup: |
+    BIN_DIR="$(pwd)/bin_old"
+    mkdir -p $BIN_DIR
+    for bin in polkadot polkadot-parachain; do
+      OLD_NAME="$bin-old"
+      echo "downloading $bin as $OLD_NAME in $BIN_DIR";
+      curl -L -o $BIN_DIR/$OLD_NAME https://github.com/paritytech/polkadot-sdk/releases/download/polkadot-stable2506/$bin
+      chmod 755 $BIN_DIR/$OLD_NAME;
+    done
+    for bin in polkadot-execute-worker polkadot-prepare-worker; do
+      OLD_NAME="$bin"
+      echo "downloading $bin as $OLD_NAME in $BIN_DIR";
+      curl -L -o $BIN_DIR/$OLD_NAME https://github.com/paritytech/polkadot-sdk/releases/download/polkadot-stable2506/$bin
+      chmod 755 $BIN_DIR/$OLD_NAME;
+    done
+    ls -ltr $BIN_DIR
+    export PATH=$BIN_DIR:$PATH
+    echo "PATH=$PATH" >> $GITHUB_ENV
+  additional-env:
+    OLD_POLKADOT_IMAGE: "docker.io/paritypr/polkadot-debug:master-187cddde"
+    OLD_POLKADOT_COMMAND: "polkadot-old"

polkadot/node/network/collator-protocol/src/validator_side/tests/prospective_parachains.rs

@@ -1960,6 +1960,109 @@ fn v3_descriptor(#[case] v3_feature_enabled: bool, #[case] crafted_unknown: bool
 	});
 }
 
+/// Test that a V3-capable validator (V3 node feature enabled) correctly identifies a V1 descriptor
+#[test]
+fn v1_descriptor_version_detection_with_v3_enabled() {
+	let mut test_state = TestState::default();
+
+	// Enable both V2 and V3 features — this is a "V3-capable" validator.
+	test_state
+		.node_features
+		.resize(node_features::FeatureIndex::CandidateReceiptV3 as usize + 1, false);
+	test_state
+		.node_features
+		.set(node_features::FeatureIndex::CandidateReceiptV3 as u8 as usize, true);
+
+	test_harness(ReputationAggregator::new(|_| true), HashSet::new(), |test_harness| async move {
+		let TestHarness { mut virtual_overseer, keystore } = test_harness;
+
+		let pair_a = CollatorPair::generate().0;
+
+		let head_b = Hash::from_low_u64_be(128);
+		let head_b_num: u32 = 0;
+
+		update_view(&mut virtual_overseer, &mut test_state, vec![(head_b, head_b_num)]).await;
+
+		let peer_a = PeerId::random();
+
+		// Collator connects using the legacy V1 wire protocol.
+		connect_and_declare_collator(
+			&mut virtual_overseer,
+			peer_a,
+			pair_a.clone(),
+			test_state.chain_ids[0],
+			CollationVersion::V1,
+		)
+		.await;
+
+		advertise_collation(&mut virtual_overseer, peer_a, head_b, None).await;
+
+		let response_channel = assert_fetch_collation_request(
+			&mut virtual_overseer,
+			head_b,
+			test_state.chain_ids[0],
+			None,
+		)
+		.await;
+
+		// Build a V1 descriptor: `dummy_candidate_receipt_bad_sig` populates `collator` with
+		// `dummy_collator()` (non-zero) and `signature` with `dummy_collator_signature()`
+		// (non-zero). In the V2 layout these bytes occupy `reserved2`, triggering V1 detection.
+		let mut candidate = dummy_candidate_receipt_bad_sig(head_b, Some(Default::default()));
+		candidate.descriptor.para_id = test_state.chain_ids[0];
+		candidate.descriptor.persisted_validation_data_hash = dummy_pvd().hash();
+
+		let commitments = CandidateCommitments {
+			head_data: HeadData(vec![1u8]),
+			horizontal_messages: Default::default(),
+			upward_messages: Default::default(),
+			new_validation_code: None,
+			processed_downward_messages: 0,
+			hrmp_watermark: 0,
+		};
+		candidate.commitments_hash = commitments.hash();
+
+		// Convert to CandidateReceiptV2 and assert version detection.
+		let candidate: CandidateReceipt = candidate.into();
+		assert_eq!(
+			candidate.descriptor.version(true),
+			CandidateDescriptorVersion::V1,
+			"non-zero reserved2 bytes must be detected as V1 even when v3_enabled=true"
+		);
+
+		let pov = PoV { block_data: BlockData(vec![1]) };
+
+		response_channel
+			.send(Ok((
+				request_v2::CollationFetchingResponse::Collation(candidate.clone(), pov.clone())
+					.encode(),
+				ProtocolName::from(""),
+			)))
+			.expect("Sending response should succeed");
+
+		// The subsystem must take the legacy path: RuntimeApi::PersistedValidationData,
+		// NOT ProspectiveParachains::GetProspectiveValidationData.
+		// assert_candidate_backing_second with CollationVersion::V1 asserts exactly that.
+		assert_candidate_backing_second(
+			&mut virtual_overseer,
+			head_b,
+			test_state.chain_ids[0],
+			&pov,
+			CollationVersion::V1,
+		)
+		.await;
+
+		let committed =
+			CommittedCandidateReceipt { descriptor: candidate.descriptor, commitments };
+		send_seconded_statement(&mut virtual_overseer, keystore.clone(), &committed).await;
+
+		assert_collation_seconded(&mut virtual_overseer, head_b, peer_a, CollationVersion::V1)
+			.await;
+
+		virtual_overseer
+	});
+}
+
 #[test]
 fn invalid_v2_descriptor() {
 	let mut test_state = TestState::default();

polkadot/runtime/parachains/src/configuration/tests.rs

@@ -18,6 +18,7 @@ use super::*;
 use crate::{
 	configuration,
 	mock::{new_test_ext, Configuration, MockGenesisConfig, ParasShared, RuntimeOrigin, Test},
+	runtime_api_impl,
 };
 use bitvec::{bitvec, prelude::Lsb0};
 use frame_support::{assert_err, assert_ok};
@@ -587,3 +588,15 @@ fn active_config_hrmp_channel_size_and_capacity_ratio_works() {
 		);
 	})
 }
+
+#[test]
+fn max_relay_parent_session_age_runtime_api_returns_zero_post_migration() {
+	// Verify that the `max_relay_parent_session_age` runtime API also
+	// returns 0 when queried against the default / post-migration active config.
+	new_test_ext(Default::default()).execute_with(|| {
+		assert_eq!(
+			runtime_api_impl::vstaging::max_relay_parent_session_age::<Test>(),
+			0,
+		);
+	});
+}

polkadot/runtime/parachains/src/paras_inherent/tests.rs

@@ -2399,6 +2399,96 @@ mod enter {
 			);
 		});
 	}
+
+	/// Verifies that a V3-capable runtime (CandidateReceiptV3 enabled) correctly accepts V1
+	/// descriptors from non-upgraded collators: not filtered, backed, and placed in
+	/// `PendingAvailability`.
+	#[test]
+	fn v1_descriptor_accepted_by_v3_capable_runtime() {
+		let config = MockGenesisConfig::default();
+
+		new_test_ext(config).execute_with(|| {
+			configuration::Pallet::<Test>::set_node_feature(
+				RuntimeOrigin::root(),
+				FeatureIndex::CandidateReceiptV3 as u8,
+				true,
+			)
+			.unwrap();
+
+			let mut backed_and_concluding = BTreeMap::new();
+			backed_and_concluding.insert(0, 1);
+			backed_and_concluding.insert(1, 1);
+
+			// Set non-zero collator/signature bytes so the V3 detection algorithm
+			// (checks reserved1[0..16]) identifies these as V1. Clear UMP signals
+			// since V1 candidates must not carry them.
+			let candidate_modifier = |mut candidate: CommittedCandidateReceiptV2| {
+				candidate.commitments.upward_messages.clear();
+
+				let mut v1: CandidateDescriptor = candidate.descriptor.into();
+				v1.collator = junk_collator();
+				v1.signature = junk_collator_signature();
+				candidate.descriptor = v1.into();
+
+				candidate
+			};
+
+			let scenario = make_inherent_data(TestConfig {
+				dispute_statements: BTreeMap::new(),
+				dispute_sessions: vec![],
+				backed_and_concluding,
+				num_validators_per_core: 1,
+				code_upgrade: None,
+				elastic_paras: BTreeMap::new(),
+				unavailable_cores: vec![],
+				descriptor_version: CandidateDescriptorVersionConfig::V1,
+				approved_peer_signal: None,
+				candidate_modifier: Some(candidate_modifier),
+			});
+
+			let expected_para_inherent_data = scenario.data.clone();
+
+			assert_eq!(expected_para_inherent_data.bitfields.len(), 2);
+			assert_eq!(expected_para_inherent_data.backed_candidates.len(), 2);
+
+			for candidate in &expected_para_inherent_data.backed_candidates {
+				assert_eq!(candidate.descriptor().version(true), CandidateDescriptorVersion::V1);
+				assert!(candidate.descriptor().session_index(true).is_none());
+			}
+
+			let mut inherent_data = InherentData::new();
+			inherent_data
+				.put_data(PARACHAINS_INHERENT_IDENTIFIER, &expected_para_inherent_data)
+				.unwrap();
+
+			assert_eq!(
+				Pallet::<Test>::create_inherent_inner(&inherent_data).unwrap(),
+				expected_para_inherent_data
+			);
+
+			assert_eq!(
+				OnChainVotes::<Test>::get().unwrap().backing_validators_per_candidate.len(),
+				2
+			);
+
+			assert_eq!(
+				inclusion::PendingAvailability::<Test>::get(ParaId::from(0))
+					.unwrap()
+					.into_iter()
+					.map(|c| c.core_occupied())
+					.collect::<Vec<_>>(),
+				vec![CoreIndex(0)]
+			);
+			assert_eq!(
+				inclusion::PendingAvailability::<Test>::get(ParaId::from(1))
+					.unwrap()
+					.into_iter()
+					.map(|c| c.core_occupied())
+					.collect::<Vec<_>>(),
+				vec![CoreIndex(1)]
+			);
+		});
+	}
 }
 
 fn default_header() -> polkadot_primitives::Header {

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

@@ -7,7 +7,7 @@
 use anyhow::anyhow;
 
 use cumulus_zombienet_sdk_helpers::{assert_finality_lag, assert_para_throughput, assign_cores};
-use polkadot_primitives::Id as ParaId;
+use polkadot_primitives::{CandidateDescriptorVersion, Id as ParaId};
 use serde_json::json;
 use zombienet_sdk::{
 	subxt::{OnlineClient, PolkadotConfig},
@@ -98,6 +98,18 @@ async fn slot_based_3cores_test() -> Result<(), anyhow::Error> {
 	assign_cores(&relay_client, 2100, vec![0, 1]).await?;
 	assign_cores(&relay_client, 2200, vec![2, 3]).await?;
 
+	crate::utils::enable_v3_node_features(&relay_client).await?;
+
+	crate::scheduling::assert_candidates_version(
+		&relay_client,
+		ParaId::from(2200),
+		CandidateDescriptorVersion::V2,
+		true,
+		15,
+		20,
+	)
+	.await?;
+
 	// Expect a backed candidate count of at least 39 for each parachain in 15 relay chain blocks
 	// (2.6 candidates per para per relay chain block).
 	// Note that only blocks after the first session change and blocks that don't contain a session

polkadot/zombienet-sdk-tests/tests/lib.rs

@@ -9,6 +9,8 @@ mod functional;
 #[cfg(feature = "zombie-ci")]
 mod parachains;
 #[cfg(feature = "zombie-ci")]
+mod scheduling;
+#[cfg(feature = "zombie-ci")]
 mod smoke;
 #[cfg(feature = "zombie-ci")]
 mod utils;