add pallet testing

Author: gabriele-0201

sugondat/chain/pallets/length-fee-adjustment/src/lib.rs

@@ -2,6 +2,11 @@
 
 pub use pallet::*;
 
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
 /// Currently, the `pallet_transaction_payment` uses the following formula:
 ///
 /// ```ignore

sugondat/chain/pallets/length-fee-adjustment/src/mock.rs

@@ -0,0 +1,117 @@
+use crate as pallet_sugondat_length_fee_adjustment;
+use frame_support::{
+    parameter_types,
+    traits::ConstU64,
+    weights::{Weight, WeightToFee as WeightToFeeT},
+};
+use pallet_transaction_payment::Multiplier;
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    FixedPointNumber, Perquintill, SaturatedConversion,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+type Balance = u64;
+
+frame_support::construct_runtime!(
+    pub enum Test {
+        System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+        Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+        TransactionPayment: pallet_transaction_payment::{Pallet, Storage, Event<T>},
+        LengthFeeAdjustment: pallet_sugondat_length_fee_adjustment::{Pallet, Storage},
+    }
+);
+
+parameter_types! {
+    pub const BlockHashCount: u64 = 250;
+    pub const SS58Prefix: u8 = 42;
+}
+
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type RuntimeCall = RuntimeCall;
+    type Nonce = u64;
+    type Hash = H256;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type BlockHashCount = BlockHashCount;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = SS58Prefix;
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+impl pallet_balances::Config for Test {
+    type Balance = u64;
+    type RuntimeEvent = RuntimeEvent;
+    type DustRemoval = ();
+    type ExistentialDeposit = ConstU64<1>;
+    type AccountStore = System;
+    type MaxLocks = ();
+    type MaxReserves = ();
+    type ReserveIdentifier = [u8; 8];
+    type WeightInfo = ();
+    type FreezeIdentifier = ();
+    type MaxFreezes = ();
+    type RuntimeHoldReason = ();
+    type RuntimeFreezeReason = ();
+    type MaxHolds = ();
+}
+
+parameter_types! {
+    pub TransactionByteFee: Balance = 333333u64;
+    pub TargetBlockFullness: Perquintill = Perquintill::from_percent(25);
+    pub AdjustmentVariableBlockFullness: Multiplier = Multiplier::saturating_from_rational(75, 1_000_000);
+    pub MinimumMultiplierBlockFullness: Multiplier = Multiplier::saturating_from_rational(1, 10u128);
+    pub MaximumMultiplierBlockFullness: Multiplier = Multiplier::saturating_from_integer(10);
+    pub MaximumBlockLength: u32 = 5 * 1024 * 1024;
+    pub AdjustmentVariableBlockSize: Multiplier = Multiplier::saturating_from_rational(1, 840);
+    pub MinimumMultiplierBlockSize: Multiplier = Multiplier::saturating_from_rational(1, 10u128);
+    pub MaximumMultiplierBlockSize: Multiplier = Multiplier::saturating_from_integer(10);
+
+    pub static WeightToFee: u64 = 1;
+    pub static OperationalFeeMultiplier: u8 = 5;
+}
+
+impl WeightToFeeT for WeightToFee {
+    type Balance = u64;
+
+    fn weight_to_fee(weight: &Weight) -> Self::Balance {
+        Self::Balance::saturated_from(weight.ref_time())
+            .saturating_mul(WEIGHT_TO_FEE.with(|v| *v.borrow()))
+    }
+}
+
+impl pallet_transaction_payment::Config for Test {
+    type RuntimeEvent = RuntimeEvent;
+    type OnChargeTransaction = pallet_transaction_payment::CurrencyAdapter<Balances, ()>;
+    type OperationalFeeMultiplier = OperationalFeeMultiplier;
+    type WeightToFee = WeightToFee;
+    type LengthToFee = LengthFeeAdjustment;
+    type FeeMultiplierUpdate = ();
+}
+
+impl pallet_sugondat_length_fee_adjustment::Config for Test {
+    type TransactionByteFee = TransactionByteFee;
+    type MaximumBlockLength = MaximumBlockLength;
+    type AdjustmentVariableBlockSize = AdjustmentVariableBlockSize;
+    type MinimumMultiplierBlockSize = MinimumMultiplierBlockSize;
+    type MaximumMultiplierBlockSize = MaximumMultiplierBlockSize;
+    type TargetBlockFullness = TargetBlockFullness;
+    type AdjustmentVariableBlockFullness = AdjustmentVariableBlockFullness;
+    type MaximumMultiplierBlockFullness = MaximumMultiplierBlockFullness;
+    type MinimumMultiplierBlockFullness = MinimumMultiplierBlockFullness;
+}

sugondat/chain/pallets/length-fee-adjustment/src/tests.rs

@@ -0,0 +1,62 @@
+use crate::{
+    mock::{LengthFeeAdjustment, Test},
+    *,
+};
+use pallet_transaction_payment::Multiplier;
+use sp_runtime::BuildStorage;
+use sp_runtime::{traits::Get, FixedPointNumber};
+use sp_weights::{Weight, WeightToFee};
+
+fn new_test_ext() -> sp_io::TestExternalities {
+    frame_system::GenesisConfig::<Test>::default()
+        .build_storage()
+        .unwrap()
+        .into()
+}
+
+#[test]
+fn test_weight_to_fee() {
+    new_test_ext().execute_with(|| {
+        // test with multipliers smaller, equal and bigger than 1
+        let multipliers = vec![
+            Multiplier::from_rational(12, 19),
+            Multiplier::saturating_from_integer(1),
+            Multiplier::from_rational(19, 12),
+        ];
+        let max_block_len = <Test as Config>::MaximumBlockLength::get() as u64;
+        // test 1000 step between 0 and the maximum size of a block
+        for len in (0..max_block_len).step_by(max_block_len as usize / 1000) {
+            for multiplier in multipliers.iter() {
+                NextLengthMultiplier::<Test>::put(multiplier);
+
+                let length_fee = len * <Test as Config>::TransactionByteFee::get();
+                let expected = multiplier.saturating_mul_int(length_fee);
+
+                assert_eq!(
+                    LengthFeeAdjustment::weight_to_fee(&Weight::from_parts(len, 0)),
+                    expected
+                );
+            }
+        }
+    });
+}
+
+#[test]
+fn test_default_next_length_multiplier() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(
+            NextLengthMultiplier::<Test>::get(),
+            NextLengthMultiplierDefualt::get()
+        )
+    });
+}
+
+#[test]
+fn test_default_target_block_size() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(
+            TargetBlockSize::<Test>::get(),
+            TargetBlockSizeDefualt::get()
+        )
+    });
+}