Breakout mock runtimes to separate files (#13150)

* break out moch runtimes to separate files

* tranaction-payment: break out tests & mock runtime to separate files

frame/transaction-payment/asset-tx-payment/src/lib.rs

@@ -59,6 +59,8 @@ use sp_runtime::{
  FixedPointOperand,
 };
 
+#[cfg(test)]
+mod mock;
 #[cfg(test)]
 mod tests;
 

frame/transaction-payment/asset-tx-payment/src/mock.rs

@@ -0,0 +1,213 @@
+// Copyright (C) 2021-2022 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use super::*;
+use crate as pallet_asset_tx_payment;
+
+use codec;
+use frame_support::{
+ dispatch::DispatchClass,
+ pallet_prelude::*,
+ parameter_types,
+ traits::{AsEnsureOriginWithArg, ConstU32, ConstU64, ConstU8, FindAuthor},
+ weights::{Weight, WeightToFee as WeightToFeeT},
+ ConsensusEngineId,
+};
+use frame_system as system;
+use frame_system::EnsureRoot;
+use pallet_transaction_payment::CurrencyAdapter;
+use sp_core::H256;
+use sp_runtime::{
+ testing::Header,
+ traits::{BlakeTwo256, ConvertInto, IdentityLookup, SaturatedConversion},
+};
+
+type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Runtime>;
+type Block = frame_system::mocking::MockBlock<Runtime>;
+type Balance = u64;
+type AccountId = u64;
+
+frame_support::construct_runtime!(
+ pub enum Runtime where
+ Block = Block,
+ NodeBlock = Block,
+ UncheckedExtrinsic = UncheckedExtrinsic,
+ {
+ System: system::{Pallet, Call, Config, Storage, Event<T>},
+ Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+ TransactionPayment: pallet_transaction_payment::{Pallet, Storage, Event<T>},
+ Assets: pallet_assets::{Pallet, Call, Storage, Event<T>},
+ Authorship: pallet_authorship::{Pallet, Call, Storage},
+ AssetTxPayment: pallet_asset_tx_payment::{Pallet, Event<T>},
+ }
+);
+
+parameter_types! {
+ pub(crate) static ExtrinsicBaseWeight: Weight = Weight::zero();
+}
+
+pub struct BlockWeights;
+impl Get<frame_system::limits::BlockWeights> for BlockWeights {
+ fn get() -> frame_system::limits::BlockWeights {
+ frame_system::limits::BlockWeights::builder()
+ .base_block(Weight::zero())
+ .for_class(DispatchClass::all(), |weights| {
+ weights.base_extrinsic = ExtrinsicBaseWeight::get().into();
+ })
+ .for_class(DispatchClass::non_mandatory(), |weights| {
+ weights.max_total = Weight::from_ref_time(1024).set_proof_size(u64::MAX).into();
+ })
+ .build_or_panic()
+ }
+}
+
+parameter_types! {
+ pub static WeightToFee: u64 = 1;
+ pub static TransactionByteFee: u64 = 1;
+}
+
+impl frame_system::Config for Runtime {
+ type BaseCallFilter = frame_support::traits::Everything;
+ type BlockWeights = BlockWeights;
+ type BlockLength = ();
+ type DbWeight = ();
+ type RuntimeOrigin = RuntimeOrigin;
+ type Index = u64;
+ type BlockNumber = u64;
+ type RuntimeCall = RuntimeCall;
+ type Hash = H256;
+ type Hashing = BlakeTwo256;
+ type AccountId = AccountId;
+ type Lookup = IdentityLookup<Self::AccountId>;
+ type Header = Header;
+ type RuntimeEvent = RuntimeEvent;
+ type BlockHashCount = ConstU64<250>;
+ type Version = ();
+ type PalletInfo = PalletInfo;
+ type AccountData = pallet_balances::AccountData<u64>;
+ type OnNewAccount = ();
+ type OnKilledAccount = ();
+ type SystemWeightInfo = ();
+ type SS58Prefix = ();
+ type OnSetCode = ();
+ type MaxConsumers = ConstU32<16>;
+}
+
+parameter_types! {
+ pub const ExistentialDeposit: u64 = 10;
+}
+
+impl pallet_balances::Config for Runtime {
+ type Balance = Balance;
+ type RuntimeEvent = RuntimeEvent;
+ type DustRemoval = ();
+ type ExistentialDeposit = ConstU64<10>;
+ type AccountStore = System;
+ type MaxLocks = ();
+ type WeightInfo = ();
+ type MaxReserves = ConstU32<50>;
+ type ReserveIdentifier = [u8; 8];
+}
+
+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 WeightToFeeT for TransactionByteFee {
+ type Balance = u64;
+
+ fn weight_to_fee(weight: &Weight) -> Self::Balance {
+ Self::Balance::saturated_from(weight.ref_time())
+ .saturating_mul(TRANSACTION_BYTE_FEE.with(|v| *v.borrow()))
+ }
+}
+
+impl pallet_transaction_payment::Config for Runtime {
+ type RuntimeEvent = RuntimeEvent;
+ type OnChargeTransaction = CurrencyAdapter<Balances, ()>;
+ type WeightToFee = WeightToFee;
+ type LengthToFee = TransactionByteFee;
+ type FeeMultiplierUpdate = ();
+ type OperationalFeeMultiplier = ConstU8<5>;
+}
+
+type AssetId = u32;
+
+impl pallet_assets::Config for Runtime {
+ type RuntimeEvent = RuntimeEvent;
+ type Balance = Balance;
+ type AssetId = AssetId;
+ type AssetIdParameter = codec::Compact<AssetId>;
+ type Currency = Balances;
+ type CreateOrigin = AsEnsureOriginWithArg<frame_system::EnsureSigned<AccountId>>;
+ type ForceOrigin = EnsureRoot<AccountId>;
+ type AssetDeposit = ConstU64<2>;
+ type AssetAccountDeposit = ConstU64<2>;
+ type MetadataDepositBase = ConstU64<0>;
+ type MetadataDepositPerByte = ConstU64<0>;
+ type ApprovalDeposit = ConstU64<0>;
+ type StringLimit = ConstU32<20>;
+ type Freezer = ();
+ type Extra = ();
+ type CallbackHandle = ();
+ type WeightInfo = ();
+ type RemoveItemsLimit = ConstU32<1000>;
+ pallet_assets::runtime_benchmarks_enabled! {
+ type BenchmarkHelper = ();
+ }
+}
+
+pub struct HardcodedAuthor;
+pub(crate) const BLOCK_AUTHOR: AccountId = 1234;
+impl FindAuthor<AccountId> for HardcodedAuthor {
+ fn find_author<'a, I>(_: I) -> Option<AccountId>
+ where
+ I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,
+ {
+ Some(BLOCK_AUTHOR)
+ }
+}
+
+impl pallet_authorship::Config for Runtime {
+ type FindAuthor = HardcodedAuthor;
+ type UncleGenerations = ();
+ type FilterUncle = ();
+ type EventHandler = ();
+}
+
+pub struct CreditToBlockAuthor;
+impl HandleCredit<AccountId, Assets> for CreditToBlockAuthor {
+ fn handle_credit(credit: CreditOf<AccountId, Assets>) {
+ if let Some(author) = pallet_authorship::Pallet::<Runtime>::author() {
+ // What to do in case paying the author fails (e.g. because `fee < min_balance`)
+ // default: drop the result which will trigger the `OnDrop` of the imbalance.
+ let _ = <Assets as Balanced<AccountId>>::resolve(&author, credit);
+ }
+ }
+}
+
+impl Config for Runtime {
+ type RuntimeEvent = RuntimeEvent;
+ type Fungibles = Assets;
+ type OnChargeAssetTransaction = FungiblesAdapter<
+ pallet_assets::BalanceToAssetBalance<Balances, Runtime, ConvertInto>,
+ CreditToBlockAuthor,
+ >;
+}