diff --git a/bridges/modules/grandpa/src/benchmarking.rs b/bridges/modules/grandpa/src/benchmarking.rs
index 78c7fc362a281ac98ef694f4ca0cbe62a316da4c..aa222d6e4de6f0ffa9eabe93436bb3726129bd31 100644
--- a/bridges/modules/grandpa/src/benchmarking.rs
+++ b/bridges/modules/grandpa/src/benchmarking.rs
@@ -136,4 +136,6 @@ benchmarks_instance_pallet! {
// check that the header#0 has been pruned
assert!(!<ImportedHeaders<T, I>>::contains_key(genesis_header.hash()));
}
+
+ impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::TestRuntime)
}
diff --git a/bridges/modules/grandpa/src/mock.rs b/bridges/modules/grandpa/src/mock.rs
index b10f5d86c3de2bcc49db3abb014db541800ae970..2220ba3f129f56e9bbe01607c2cac996e9772084 100644
--- a/bridges/modules/grandpa/src/mock.rs
+++ b/bridges/modules/grandpa/src/mock.rs
@@ -131,10 +131,17 @@ impl ChainWithGrandpa for TestBridgedChain {
const AVERAGE_HEADER_SIZE_IN_JUSTIFICATION: u32 = 64;
}
+/// Return test externalities to use in tests.
+pub fn new_test_ext() -> sp_io::TestExternalities {
+ sp_io::TestExternalities::new(Default::default())
+}
+
+/// Return test within default test externalities context.
pub fn run_test<T>(test: impl FnOnce() -> T) -> T {
- sp_io::TestExternalities::new(Default::default()).execute_with(test)
+ new_test_ext().execute_with(test)
}
+/// Return test header with given number.
pub fn test_header(num: TestNumber) -> TestHeader {
// We wrap the call to avoid explicit type annotations in our tests
bp_test_utils::test_header(num)
diff --git a/bridges/modules/messages/Cargo.toml b/bridges/modules/messages/Cargo.toml
index afa8b92b228275349f60d5bb5f955e9cf3e91173..4f1e04eecc278b88c4bf0c4a85dee8dd313ce722 100644
--- a/bridges/modules/messages/Cargo.toml
+++ b/bridges/modules/messages/Cargo.toml
@@ -27,9 +27,9 @@ sp-runtime = { git = "https://github.com/paritytech/substrate", branch = "master
sp-std = { git = "https://github.com/paritytech/substrate", branch = "master", default-features = false }
[dev-dependencies]
-sp-io = { git = "https://github.com/paritytech/substrate", branch = "master" }
-pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "master" }
bp-test-utils = { path = "../../primitives/test-utils" }
+pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "master" }
+sp-io = { git = "https://github.com/paritytech/substrate", branch = "master" }
[features]
default = ["std"]
diff --git a/bridges/modules/messages/src/benchmarking.rs b/bridges/modules/messages/src/benchmarking.rs
index bc9c1f752574b233fef4d9c21f8fa488be50db05..aab8855a729a8310dfa7f5a1b7d872e95cf1e2b3 100644
--- a/bridges/modules/messages/src/benchmarking.rs
+++ b/bridges/modules/messages/src/benchmarking.rs
@@ -37,7 +37,7 @@ use sp_std::{ops::RangeInclusive, prelude::*};
const SEED: u32 = 0;
/// Pallet we're benchmarking here.
-pub struct Pallet<T: Config<I>, I: 'static>(crate::Pallet<T, I>);
+pub struct Pallet<T: Config<I>, I: 'static = ()>(crate::Pallet<T, I>);
/// Benchmark-specific message proof parameters.
#[derive(Debug)]
@@ -437,6 +437,8 @@ benchmarks_instance_pallet! {
);
assert!(T::is_message_successfully_dispatched(21));
}
+
+ impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::TestRuntime)
}
fn send_regular_message<T: Config<I>, I: 'static>() {
diff --git a/bridges/modules/messages/src/mock.rs b/bridges/modules/messages/src/mock.rs
index 807721ba866746c53a32662ff127fdda39ac97d0..02940f369e25c2f3f882f89e7d995c665f9b3cee 100644
--- a/bridges/modules/messages/src/mock.rs
+++ b/bridges/modules/messages/src/mock.rs
@@ -170,6 +170,44 @@ impl Config for TestRuntime {
type BridgedChainId = TestBridgedChainId;
}
+#[cfg(feature = "runtime-benchmarks")]
+impl crate::benchmarking::Config<()> for TestRuntime {
+ fn bench_lane_id() -> LaneId {
+ TEST_LANE_ID
+ }
+
+ fn prepare_message_proof(
+ params: crate::benchmarking::MessageProofParams,
+ ) -> (TestMessagesProof, Weight) {
+ // in mock run we only care about benchmarks correctness, not the benchmark results
+ // => ignore size related arguments
+ let (messages, total_dispatch_weight) =
+ params.message_nonces.into_iter().map(|n| message(n, REGULAR_PAYLOAD)).fold(
+ (Vec::new(), Weight::zero()),
+ |(mut messages, total_dispatch_weight), message| {
+ let weight = REGULAR_PAYLOAD.declared_weight;
+ messages.push(message);
+ (messages, total_dispatch_weight.saturating_add(weight))
+ },
+ );
+ let mut proof: TestMessagesProof = Ok(messages).into();
+ proof.result.as_mut().unwrap().get_mut(0).unwrap().1.lane_state = params.outbound_lane_data;
+ (proof, total_dispatch_weight)
+ }
+
+ fn prepare_message_delivery_proof(
+ params: crate::benchmarking::MessageDeliveryProofParams<AccountId>,
+ ) -> TestMessagesDeliveryProof {
+ // in mock run we only care about benchmarks correctness, not the benchmark results
+ // => ignore size related arguments
+ TestMessagesDeliveryProof(Ok((params.lane, params.inbound_lane_data)))
+ }
+
+ fn is_relayer_rewarded(_relayer: &AccountId) -> bool {
+ true
+ }
+}
+
impl Size for TestPayload {
fn size(&self) -> u32 {
16 + self.extra.len() as u32
@@ -439,12 +477,16 @@ pub fn unrewarded_relayer(
UnrewardedRelayer { relayer, messages: DeliveredMessages { begin, end } }
}
-/// Run pallet test.
-pub fn run_test<T>(test: impl FnOnce() -> T) -> T {
+/// Return test externalities to use in tests.
+pub fn new_test_ext() -> sp_io::TestExternalities {
let mut t = frame_system::GenesisConfig::default().build_storage::<TestRuntime>().unwrap();
pallet_balances::GenesisConfig::<TestRuntime> { balances: vec![(ENDOWED_ACCOUNT, 1_000_000)] }
.assimilate_storage(&mut t)
.unwrap();
- let mut ext = sp_io::TestExternalities::new(t);
- ext.execute_with(test)
+ sp_io::TestExternalities::new(t)
+}
+
+/// Run pallet test.
+pub fn run_test<T>(test: impl FnOnce() -> T) -> T {
+ new_test_ext().execute_with(test)
}
diff --git a/bridges/modules/parachains/src/benchmarking.rs b/bridges/modules/parachains/src/benchmarking.rs
index 83cfba0b8c6b0329ee7ede57767672d770a2f53b..59c4642cde9997b5046afa491f59fc11b88ae17b 100644
--- a/bridges/modules/parachains/src/benchmarking.rs
+++ b/bridges/modules/parachains/src/benchmarking.rs
@@ -28,7 +28,7 @@ use frame_system::RawOrigin;
use sp_std::prelude::*;
/// Pallet we're benchmarking here.
-pub struct Pallet<T: Config<I>, I: 'static>(crate::Pallet<T, I>);
+pub struct Pallet<T: Config<I>, I: 'static = ()>(crate::Pallet<T, I>);
/// Trait that must be implemented by runtime to benchmark the parachains finality pallet.
pub trait Config<I: 'static>: crate::Config<I> {
@@ -111,4 +111,6 @@ benchmarks_instance_pallet! {
assert!(crate::Pallet::<T, I>::best_parachain_head(parachain).is_some());
}
}
+
+ impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::TestRuntime)
}
diff --git a/bridges/modules/parachains/src/lib.rs b/bridges/modules/parachains/src/lib.rs
index e72e2aec8c202bde6c2e237ef150e41c9507cb55..8fe6c4e938391f286e4cf694204cf78fba8f8551 100644
--- a/bridges/modules/parachains/src/lib.rs
+++ b/bridges/modules/parachains/src/lib.rs
@@ -689,7 +689,7 @@ pub fn initialize_for_benchmarks<T: Config<I>, I: 'static, PC: Parachain<Hash =
}
#[cfg(test)]
-mod tests {
+pub(crate) mod tests {
use super::*;
use crate::mock::{
run_test, test_relay_header, BigParachainHeader, RegularParachainHasher,
@@ -724,7 +724,7 @@ mod tests {
type WeightInfo = <TestRuntime as Config>::WeightInfo;
type DbWeight = <TestRuntime as frame_system::Config>::DbWeight;
- fn initialize(state_root: RelayBlockHash) {
+ pub(crate) fn initialize(state_root: RelayBlockHash) -> RelayBlockHash {
pallet_bridge_grandpa::Pallet::<TestRuntime, BridgesGrandpaPalletInstance>::initialize(
RuntimeOrigin::root(),
bp_header_chain::InitializationData {
@@ -738,6 +738,8 @@ mod tests {
System::<TestRuntime>::set_block_number(1);
System::<TestRuntime>::reset_events();
+
+ test_relay_header(0, state_root).hash()
}
fn proceed(num: RelayBlockNumber, state_root: RelayBlockHash) -> ParaHash {
@@ -759,7 +761,7 @@ mod tests {
hash
}
- fn prepare_parachain_heads_proof(
+ pub(crate) fn prepare_parachain_heads_proof(
heads: Vec<(u32, ParaHead)>,
) -> (RelayBlockHash, ParaHeadsProof, Vec<(ParaId, ParaHash)>) {
let mut parachains = Vec::with_capacity(heads.len());
@@ -795,7 +797,7 @@ mod tests {
}
}
- fn head_data(parachain: u32, head_number: u32) -> ParaHead {
+ pub(crate) fn head_data(parachain: u32, head_number: u32) -> ParaHead {
ParaHead(
RegularParachainHeader::new(
head_number as _,
diff --git a/bridges/modules/parachains/src/mock.rs b/bridges/modules/parachains/src/mock.rs
index c19ce98eba2fe2f8d2f0ed44d60edb5e1abceaa2..90e6d7c558e495148a8d0eb74d65742552c2fd80 100644
--- a/bridges/modules/parachains/src/mock.rs
+++ b/bridges/modules/parachains/src/mock.rs
@@ -228,6 +228,36 @@ impl pallet_bridge_parachains::Config for TestRuntime {
type MaxParaHeadDataSize = ConstU32<MAXIMAL_PARACHAIN_HEAD_DATA_SIZE>;
}
+#[cfg(feature = "runtime-benchmarks")]
+impl pallet_bridge_parachains::benchmarking::Config<()> for TestRuntime {
+ fn parachains() -> Vec<ParaId> {
+ vec![
+ ParaId(Parachain1::PARACHAIN_ID),
+ ParaId(Parachain2::PARACHAIN_ID),
+ ParaId(Parachain3::PARACHAIN_ID),
+ ]
+ }
+
+ fn prepare_parachain_heads_proof(
+ parachains: &[ParaId],
+ _parachain_head_size: u32,
+ _proof_size: bp_runtime::StorageProofSize,
+ ) -> (
+ crate::RelayBlockNumber,
+ crate::RelayBlockHash,
+ bp_polkadot_core::parachains::ParaHeadsProof,
+ Vec<(ParaId, bp_polkadot_core::parachains::ParaHash)>,
+ ) {
+ // in mock run we only care about benchmarks correctness, not the benchmark results
+ // => ignore size related arguments
+ let (state_root, proof, parachains) = crate::tests::prepare_parachain_heads_proof(
+ parachains.iter().map(|p| (p.0, crate::tests::head_data(p.0, 1))).collect(),
+ );
+ let relay_genesis_hash = crate::tests::initialize(state_root);
+ (0, relay_genesis_hash, proof, parachains)
+ }
+}
+
#[derive(Debug)]
pub struct TestBridgedChain;
@@ -290,14 +320,21 @@ impl ChainWithGrandpa for OtherBridgedChain {
const AVERAGE_HEADER_SIZE_IN_JUSTIFICATION: u32 = 64;
}
+/// Return test externalities to use in tests.
+pub fn new_test_ext() -> sp_io::TestExternalities {
+ sp_io::TestExternalities::new(Default::default())
+}
+
+/// Run pallet test.
pub fn run_test<T>(test: impl FnOnce() -> T) -> T {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
+ new_test_ext().execute_with(|| {
System::set_block_number(1);
System::reset_events();
test()
})
}
+/// Return test relay chain header with given number.
pub fn test_relay_header(
num: crate::RelayBlockNumber,
state_root: crate::RelayBlockHash,
diff --git a/bridges/modules/relayers/src/benchmarking.rs b/bridges/modules/relayers/src/benchmarking.rs
index 7dcf77eb958ea53ededc7440596bc7660681a201..a762a5693c26e24e7f868ac02e9c35d98e181738 100644
--- a/bridges/modules/relayers/src/benchmarking.rs
+++ b/bridges/modules/relayers/src/benchmarking.rs
@@ -54,4 +54,6 @@ benchmarks! {
// payment logic, so we assume that if call has succeeded, the procedure has
// also completed successfully
}
+
+ impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::TestRuntime)
}
diff --git a/bridges/modules/relayers/src/mock.rs b/bridges/modules/relayers/src/mock.rs
index 5e97e81ae3344c409cfd6b94c81f428726d4970b..fe8c586eecc590f9c5dc147663d8326dd2c61e75 100644
--- a/bridges/modules/relayers/src/mock.rs
+++ b/bridges/modules/relayers/src/mock.rs
@@ -99,6 +99,18 @@ impl pallet_bridge_relayers::Config for TestRuntime {
type WeightInfo = ();
}
+#[cfg(feature = "runtime-benchmarks")]
+impl pallet_bridge_relayers::benchmarking::Config for TestRuntime {
+ fn prepare_environment(account_params: RewardsAccountParams, reward: Balance) {
+ use frame_support::traits::fungible::Mutate;
+ let rewards_account =
+ bp_relayers::PayRewardFromAccount::<Balances, AccountId>::rewards_account(
+ account_params,
+ );
+ Balances::mint_into(&rewards_account, reward).unwrap();
+ }
+}
+
/// Message lane that we're using in tests.
pub const TEST_REWARDS_ACCOUNT_PARAMS: RewardsAccountParams =
RewardsAccountParams::new(LaneId([0, 0, 0, 0]), *b"test", RewardsAccountOwner::ThisChain);
@@ -127,9 +139,13 @@ impl PaymentProcedure<AccountId, Balance> for TestPaymentProcedure {
}
}
+/// Return test externalities to use in tests.
+pub fn new_test_ext() -> sp_io::TestExternalities {
+ let t = frame_system::GenesisConfig::default().build_storage::<TestRuntime>().unwrap();
+ sp_io::TestExternalities::new(t)
+}
+
/// Run pallet test.
pub fn run_test<T>(test: impl FnOnce() -> T) -> T {
- let t = frame_system::GenesisConfig::default().build_storage::<TestRuntime>().unwrap();
- let mut ext = sp_io::TestExternalities::new(t);
- ext.execute_with(test)
+ new_test_ext().execute_with(test)
}