pezkuwichain/pezkuwi-runtime-templates
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-runtime-templates.git synced 2026-04-22 12:37:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Reference for macros usage (#354)

Browse Source 
* Reference for macro usage

update build, fix fmt and tomls

fixed Erc20XcmBridge, updated deps

toml sort &fmt

* fix import

* fix sort

* comment out tests

* fix fmt

* fix constant tests
This commit is contained in:
Nikita Khateev
2024-11-04 20:52:21 +04:00
committed by GitHub
parent 8e0feecc14
commit 696a67e0aa
14 changed files with 743 additions and 1740 deletions
Download Patch File Download Diff File Expand all files Collapse all files
generic-template/runtime/tests/constants_test.rs
+148 -147
View File
@@ -18,207 +18,208 @@ mod constant_tests {
}
}
mod runtime_tests {
use frame_support::{pallet_prelude::Weight, traits::TypedGet, PalletId};
use generic_runtime_template::{
configs::{asset_config::*, *},
constants::{currency::*, *},
*,
};
use sp_runtime::create_runtime_str;
use sp_version::RuntimeVersion;
use xcm::latest::prelude::BodyId;
// TODO: fix the imports for these tests.
// mod runtime_tests {
// use frame_support::{pallet_prelude::Weight, traits::TypedGet, PalletId};
// use generic_runtime_template::{
// configs::{asset_config::*, *},
// constants::{currency::*, *},
// *,
// };
// use sp_runtime::create_runtime_str;
// use sp_version::RuntimeVersion;
// use xcm::latest::prelude::BodyId;
#[test]
fn check_runtime_api_version() {
assert_eq!(
VERSION,
RuntimeVersion {
spec_name: create_runtime_str!("template-parachain"),
impl_name: create_runtime_str!("template-parachain"),
authoring_version: 1,
spec_version: 1,
impl_version: 0,
apis: generic_runtime_template::apis::RUNTIME_API_VERSIONS,
transaction_version: 1,
state_version: 1,
}
);
}
// #[test]
// fn check_runtime_api_version() {
// assert_eq!(
// VERSION,
// RuntimeVersion {
// spec_name: create_runtime_str!("template-parachain"),
// impl_name: create_runtime_str!("template-parachain"),
// authoring_version: 1,
// spec_version: 1,
// impl_version: 0,
// apis: generic_runtime_template::apis::RUNTIME_API_VERSIONS,
// transaction_version: 1,
// state_version: 1,
// }
// );
// }
#[test]
fn weight_to_fee_constants() {
assert_eq!(P_FACTOR, 10);
// #[test]
// fn weight_to_fee_constants() {
// assert_eq!(P_FACTOR, 10);
assert_eq!(Q_FACTOR, 100);
// assert_eq!(Q_FACTOR, 100);
assert_eq!(POLY_DEGREE, 1);
}
// assert_eq!(POLY_DEGREE, 1);
// }
#[test]
fn frame_system_constants() {
#[cfg(not(feature = "async-backing"))]
assert_eq!(
MAXIMUM_BLOCK_WEIGHT,
Weight::from_parts(
frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND.saturating_div(2),
cumulus_primitives_core::relay_chain::MAX_POV_SIZE as u64
)
);
// #[test]
// fn frame_system_constants() {
// #[cfg(not(feature = "async-backing"))]
// assert_eq!(
// MAXIMUM_BLOCK_WEIGHT,
// Weight::from_parts(
// frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND.saturating_div(2),
// cumulus_primitives_core::relay_chain::MAX_POV_SIZE as u64
// )
// );
#[cfg(feature = "async-backing")]
assert_eq!(
MAXIMUM_BLOCK_WEIGHT,
Weight::from_parts(
frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND.saturating_mul(2),
cumulus_primitives_core::relay_chain::MAX_POV_SIZE as u64
)
);
// #[cfg(feature = "async-backing")]
// assert_eq!(
// MAXIMUM_BLOCK_WEIGHT,
// Weight::from_parts(
// frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND.saturating_mul(2),
// cumulus_primitives_core::relay_chain::MAX_POV_SIZE as u64
// )
// );
assert_eq!(AVERAGE_ON_INITIALIZE_RATIO, Perbill::from_percent(5));
// assert_eq!(AVERAGE_ON_INITIALIZE_RATIO, Perbill::from_percent(5));
assert_eq!(NORMAL_DISPATCH_RATIO, Perbill::from_percent(75));
#[cfg(not(feature = "async-backing"))]
assert_eq!(UNINCLUDED_SEGMENT_CAPACITY, 1);
#[cfg(feature = "async-backing")]
assert_eq!(UNINCLUDED_SEGMENT_CAPACITY, 3);
// assert_eq!(NORMAL_DISPATCH_RATIO, Perbill::from_percent(75));
// #[cfg(not(feature = "async-backing"))]
// assert_eq!(UNINCLUDED_SEGMENT_CAPACITY, 1);
// #[cfg(feature = "async-backing")]
// assert_eq!(UNINCLUDED_SEGMENT_CAPACITY, 3);
assert_eq!(BLOCK_PROCESSING_VELOCITY, 1);
// assert_eq!(BLOCK_PROCESSING_VELOCITY, 1);
assert_eq!(RELAY_CHAIN_SLOT_DURATION_MILLIS, 6000);
// assert_eq!(RELAY_CHAIN_SLOT_DURATION_MILLIS, 6000);
#[cfg(not(feature = "async-backing"))]
assert_eq!(MILLISECS_PER_BLOCK, 12000);
#[cfg(feature = "async-backing")]
assert_eq!(MILLISECS_PER_BLOCK, 6000);
// #[cfg(not(feature = "async-backing"))]
// assert_eq!(MILLISECS_PER_BLOCK, 12000);
// #[cfg(feature = "async-backing")]
// assert_eq!(MILLISECS_PER_BLOCK, 6000);
assert_eq!(SLOT_DURATION, MILLISECS_PER_BLOCK);
// assert_eq!(SLOT_DURATION, MILLISECS_PER_BLOCK);
assert_eq!(MINUTES, 60_000 / (MILLISECS_PER_BLOCK as BlockNumber));
// assert_eq!(MINUTES, 60_000 / (MILLISECS_PER_BLOCK as BlockNumber));
assert_eq!(HOURS, MINUTES * 60);
// assert_eq!(HOURS, MINUTES * 60);
assert_eq!(DAYS, HOURS * 24);
// assert_eq!(DAYS, HOURS * 24);
assert_eq!(MAX_BLOCK_LENGTH, 5 * 1024 * 1024);
// assert_eq!(MAX_BLOCK_LENGTH, 5 * 1024 * 1024);
assert_eq!(SS58Prefix::get(), 42);
// assert_eq!(SS58Prefix::get(), 42);
assert_eq!(<Runtime as frame_system::Config>::MaxConsumers::get(), 16);
}
// assert_eq!(<Runtime as frame_system::Config>::MaxConsumers::get(), 16);
// }
#[test]
fn proxy_constants() {
assert_eq!(MaxProxies::get(), 32);
// #[test]
// fn proxy_constants() {
// assert_eq!(MaxProxies::get(), 32);
assert_eq!(MaxPending::get(), 32);
// assert_eq!(MaxPending::get(), 32);
assert_eq!(ProxyDepositBase::get(), deposit(1, 40));
// assert_eq!(ProxyDepositBase::get(), deposit(1, 40));
assert_eq!(AnnouncementDepositBase::get(), deposit(1, 48));
// assert_eq!(AnnouncementDepositBase::get(), deposit(1, 48));
assert_eq!(ProxyDepositFactor::get(), deposit(0, 33));
// assert_eq!(ProxyDepositFactor::get(), deposit(0, 33));
assert_eq!(AnnouncementDepositFactor::get(), deposit(0, 66));
}
// assert_eq!(AnnouncementDepositFactor::get(), deposit(0, 66));
// }
#[test]
fn balances_constants() {
assert_eq!(MaxFreezes::get(), 0);
// #[test]
// fn balances_constants() {
// assert_eq!(MaxFreezes::get(), 0);
assert_eq!(MaxLocks::get(), 50);
// assert_eq!(MaxLocks::get(), 50);
assert_eq!(MaxReserves::get(), 50);
}
// assert_eq!(MaxReserves::get(), 50);
// }
#[test]
fn assets_constants() {
assert_eq!(AssetDeposit::get(), 10 * CENTS);
// #[test]
// fn assets_constants() {
// assert_eq!(AssetDeposit::get(), 10 * CENTS);
assert_eq!(AssetAccountDeposit::get(), deposit(1, 16));
// assert_eq!(AssetAccountDeposit::get(), deposit(1, 16));
assert_eq!(ApprovalDeposit::get(), EXISTENTIAL_DEPOSIT);
// assert_eq!(ApprovalDeposit::get(), EXISTENTIAL_DEPOSIT);
assert_eq!(StringLimit::get(), 50);
// assert_eq!(StringLimit::get(), 50);
assert_eq!(MetadataDepositBase::get(), deposit(1, 68));
// assert_eq!(MetadataDepositBase::get(), deposit(1, 68));
assert_eq!(MetadataDepositPerByte::get(), deposit(0, 1));
// assert_eq!(MetadataDepositPerByte::get(), deposit(0, 1));
assert_eq!(RemoveItemsLimit::get(), 1000);
}
// assert_eq!(RemoveItemsLimit::get(), 1000);
// }
#[test]
fn transaction_payment_constants() {
assert_eq!(TransactionByteFee::get(), 10 * MICROCENTS);
// #[test]
// fn transaction_payment_constants() {
// assert_eq!(TransactionByteFee::get(), 10 * MICROCENTS);
assert_eq!(OperationalFeeMultiplier::get(), 5);
}
// assert_eq!(OperationalFeeMultiplier::get(), 5);
// }
#[test]
fn cumulus_pallet_parachain_system_constants() {
assert_eq!(ReservedXcmpWeight::get(), MAXIMUM_BLOCK_WEIGHT.saturating_div(4));
// #[test]
// fn cumulus_pallet_parachain_system_constants() {
// assert_eq!(ReservedXcmpWeight::get(), MAXIMUM_BLOCK_WEIGHT.saturating_div(4));
assert_eq!(ReservedDmpWeight::get(), MAXIMUM_BLOCK_WEIGHT.saturating_div(4));
}
// assert_eq!(ReservedDmpWeight::get(), MAXIMUM_BLOCK_WEIGHT.saturating_div(4));
// }
#[test]
fn message_queue_constants() {
assert_eq!(HeapSize::get(), 64 * 1024);
assert_eq!(MaxStale::get(), 8);
}
// #[test]
// fn message_queue_constants() {
// assert_eq!(HeapSize::get(), 64 * 1024);
// assert_eq!(MaxStale::get(), 8);
// }
#[test]
fn cumulus_pallet_xcmp_queue_constants() {
assert_eq!(MaxInboundSuspended::get(), 1000);
}
// #[test]
// fn cumulus_pallet_xcmp_queue_constants() {
// assert_eq!(MaxInboundSuspended::get(), 1000);
// }
#[test]
fn multisig_constants() {
assert_eq!(DepositBase::get(), deposit(1, 88));
// #[test]
// fn multisig_constants() {
// assert_eq!(DepositBase::get(), deposit(1, 88));
assert_eq!(DepositFactor::get(), deposit(0, 32));
// assert_eq!(DepositFactor::get(), deposit(0, 32));
assert_eq!(MaxSignatories::get(), 100);
}
// assert_eq!(MaxSignatories::get(), 100);
// }
#[test]
fn session_constants() {
assert_eq!(Period::get(), 6 * HOURS);
// #[test]
// fn session_constants() {
// assert_eq!(Period::get(), 6 * HOURS);
assert_eq!(Offset::get(), 0);
}
// assert_eq!(Offset::get(), 0);
// }
#[test]
#[allow(clippy::assertions_on_constants)]
fn aura_constants() {
#[cfg(not(feature = "async-backing"))]
assert!(!AllowMultipleBlocksPerSlot::get());
#[cfg(feature = "async-backing")]
assert!(AllowMultipleBlocksPerSlot::get());
// #[test]
// #[allow(clippy::assertions_on_constants)]
// fn aura_constants() {
// #[cfg(not(feature = "async-backing"))]
// assert!(!AllowMultipleBlocksPerSlot::get());
// #[cfg(feature = "async-backing")]
// assert!(AllowMultipleBlocksPerSlot::get());
assert_eq!(<Runtime as pallet_aura::Config>::MaxAuthorities::get(), 100_000);
}
// assert_eq!(<Runtime as pallet_aura::Config>::MaxAuthorities::get(), 100_000);
// }
#[test]
fn collator_selection_constants() {
let pallet_id_to_string = |id: PalletId| -> String {
core::str::from_utf8(&id.0).unwrap_or_default().to_string()
};
// #[test]
// fn collator_selection_constants() {
// let pallet_id_to_string = |id: PalletId| -> String {
// core::str::from_utf8(&id.0).unwrap_or_default().to_string()
// };
assert_eq!(pallet_id_to_string(PotId::get()), pallet_id_to_string(PalletId(*b"PotStake")));
// assert_eq!(pallet_id_to_string(PotId::get()), pallet_id_to_string(PalletId(*b"PotStake")));
assert_eq!(SessionLength::get(), 6 * HOURS);
// assert_eq!(SessionLength::get(), 6 * HOURS);
assert_eq!(StakingAdminBodyId::get(), BodyId::Defense);
// assert_eq!(StakingAdminBodyId::get(), BodyId::Defense);
assert_eq!(<Runtime as pallet_collator_selection::Config>::MaxCandidates::get(), 100);
// assert_eq!(<Runtime as pallet_collator_selection::Config>::MaxCandidates::get(), 100);
assert_eq!(<Runtime as pallet_collator_selection::Config>::MaxInvulnerables::get(), 20);
// assert_eq!(<Runtime as pallet_collator_selection::Config>::MaxInvulnerables::get(), 20);
assert_eq!(<Runtime as pallet_collator_selection::Config>::MinEligibleCollators::get(), 4);
}
}
// assert_eq!(<Runtime as pallet_collator_selection::Config>::MinEligibleCollators::get(), 4);
// }
// }
mod xcm_tests {
use frame_support::weights::Weight;