mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-04-26 14:37:57 +00:00
Improve storage_alias and make UnlockAndUnreserveAllFunds independent of the pallet (#14773)
* Make `storage_alias` more generic over the `prefix` * Make `UnlockAndUnreserveAllFunds` indepenend from the pallet * FMT * Fix error reporting * Rename prefix type * Add test * Apply suggestions from code review Co-authored-by: Sam Johnson <sam@durosoft.com> * ".git/.scripts/commands/fmt/fmt.sh" --------- Co-authored-by: Sam Johnson <sam@durosoft.com> Co-authored-by: command-bot <>
This commit is contained in:
Bastian Köcher
@@ -74,6 +74,8 @@ pub mod inherent;
|
||||
pub mod instances;
|
||||
pub mod migrations;
|
||||
pub mod storage;
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
pub mod traits;
|
||||
pub mod weights;
|
||||
#[doc(hidden)]
|
||||
@@ -127,80 +129,50 @@ impl TypeId for PalletId {
|
||||
const TYPE_ID: [u8; 4] = *b"modl";
|
||||
}
|
||||
|
||||
/// Generate a new type alias for [`storage::types::StorageValue`],
|
||||
/// [`storage::types::StorageMap`], [`storage::types::StorageDoubleMap`]
|
||||
/// and [`storage::types::StorageNMap`].
|
||||
/// Generate a [`#[pallet::storage]`](pallet_macros::storage) alias outside of a pallet.
|
||||
///
|
||||
/// Useful for creating a *storage-like* struct for test and migrations.
|
||||
/// This storage alias works similarly to the [`#[pallet::storage]`](pallet_macros::storage)
|
||||
/// attribute macro. It supports [`StorageValue`](storage::types::StorageValue),
|
||||
/// [`StorageMap`](storage::types::StorageMap),
|
||||
/// [`StorageDoubleMap`](storage::types::StorageDoubleMap) and
|
||||
/// [`StorageNMap`](storage::types::StorageNMap). The main difference to the normal
|
||||
/// [`#[pallet::storage]`](pallet_macros::storage) is the flexibility around declaring the
|
||||
/// storage prefix to use. The storage prefix determines where to find the value in the
|
||||
/// storage. [`#[pallet::storage]`](pallet_macros::storage) uses the name of the pallet as
|
||||
/// declared in [`construct_runtime!`].
|
||||
///
|
||||
/// ```
|
||||
/// # use frame_support::storage_alias;
|
||||
/// use frame_support::codec;
|
||||
/// use frame_support::Twox64Concat;
|
||||
/// // generate a storage value with type u32.
|
||||
/// #[storage_alias]
|
||||
/// type StorageName = StorageValue<Prefix, u32>;
|
||||
/// The flexibility around declaring the storage prefix makes this macro very useful for
|
||||
/// writing migrations etc.
|
||||
///
|
||||
/// // generate a double map from `(u32, u32)` (with hashers `Twox64Concat` for each key)
|
||||
/// // to `Vec<u8>`
|
||||
/// #[storage_alias]
|
||||
/// type OtherStorageName = StorageDoubleMap<
|
||||
/// OtherPrefix,
|
||||
/// Twox64Concat,
|
||||
/// u32,
|
||||
/// Twox64Concat,
|
||||
/// u32,
|
||||
/// Vec<u8>,
|
||||
/// >;
|
||||
/// # Examples
|
||||
///
|
||||
/// // optionally specify the query type
|
||||
/// use frame_support::pallet_prelude::{ValueQuery, OptionQuery};
|
||||
/// #[storage_alias]
|
||||
/// type ValueName = StorageValue<Prefix, u32, OptionQuery>;
|
||||
/// #[storage_alias]
|
||||
/// type SomeStorageName = StorageMap<
|
||||
/// Prefix,
|
||||
/// Twox64Concat,
|
||||
/// u32,
|
||||
/// Vec<u8>,
|
||||
/// ValueQuery,
|
||||
/// >;
|
||||
/// There are different ways to declare the `prefix` to use. The `prefix` type can either be
|
||||
/// declared explicetly by passing it to the macro as an attribute or by letting the macro
|
||||
/// guess on what the `prefix` type is. The `prefix` is always passed as the first generic
|
||||
/// argument to the type declaration. When using [`#[pallet::storage]`](pallet_macros::storage)
|
||||
/// this first generic argument is always `_`. Besides declaring the `prefix`, the rest of the
|
||||
/// type declaration works as with [`#[pallet::storage]`](pallet_macros::storage).
|
||||
///
|
||||
/// // generate a map from `Config::AccountId` (with hasher `Twox64Concat`) to `Vec<u8>`
|
||||
/// trait Config { type AccountId: codec::FullCodec; }
|
||||
/// #[storage_alias]
|
||||
/// type GenericStorage<T> = StorageMap<Prefix, Twox64Concat, <T as Config>::AccountId, Vec<u8>>;
|
||||
/// 1. Use the `verbatim` prefix type. This prefix type uses the given identifier as the
|
||||
/// `prefix`:
|
||||
#[doc = docify::embed!("src/tests/storage_alias.rs", verbatim_attribute)]
|
||||
///
|
||||
/// // It also supports NMap
|
||||
/// use frame_support::storage::types::Key as NMapKey;
|
||||
/// 2. Use the `pallet_name` prefix type. This prefix type uses the name of the pallet as
|
||||
/// configured in [`construct_runtime!`] as the `prefix`:
|
||||
#[doc = docify::embed!("src/tests/storage_alias.rs", pallet_name_attribute)]
|
||||
/// It requires that the given prefix type implements
|
||||
/// [`PalletInfoAccess`](traits::PalletInfoAccess) (which is always the case for FRAME pallet
|
||||
/// structs). In the example above, `Pallet<T>` is the prefix type.
|
||||
///
|
||||
/// #[storage_alias]
|
||||
/// type SomeNMap = StorageNMap<Prefix, (NMapKey<Twox64Concat, u32>, NMapKey<Twox64Concat, u64>), Vec<u8>>;
|
||||
/// 3. Use the `dynamic` prefix type. This prefix type calls [`Get::get()`](traits::Get::get)
|
||||
/// to get the `prefix`:
|
||||
#[doc = docify::embed!("src/tests/storage_alias.rs", dynamic_attribute)]
|
||||
/// It requires that the given prefix type implements [`Get<'static str>`](traits::Get).
|
||||
///
|
||||
/// // Using pallet name as prefix.
|
||||
/// //
|
||||
/// // When the first generic argument is taking generic arguments it is expected to be a pallet.
|
||||
/// // The prefix will then be the pallet name as configured in the runtime through
|
||||
/// // `construct_runtime!`.
|
||||
///
|
||||
/// # struct Pallet<T: Config, I = ()>(std::marker::PhantomData<(T, I)>);
|
||||
/// # impl<T: Config, I: 'static> frame_support::traits::PalletInfoAccess for Pallet<T, I> {
|
||||
/// # fn index() -> usize { 0 }
|
||||
/// # fn name() -> &'static str { "pallet" }
|
||||
/// # fn module_name() -> &'static str { "module" }
|
||||
/// # fn crate_version() -> frame_support::traits::CrateVersion { unimplemented!() }
|
||||
/// # }
|
||||
///
|
||||
/// #[storage_alias]
|
||||
/// type SomeValue<T: Config> = StorageValue<Pallet<T>, u64>;
|
||||
///
|
||||
/// // Pallet with instance
|
||||
///
|
||||
/// #[storage_alias]
|
||||
/// type SomeValue2<T: Config, I: 'static> = StorageValue<Pallet<T, I>, u64>;
|
||||
///
|
||||
/// # fn main() {}
|
||||
/// ```
|
||||
/// 4. Let the macro "guess" what kind of prefix type to use. This only supports verbatim or
|
||||
/// pallet name. The macro uses the presence of generic arguments to the prefix type as
|
||||
/// an indication that it should use the pallet name as the `prefix`:
|
||||
#[doc = docify::embed!("src/tests/storage_alias.rs", storage_alias_guess)]
|
||||
pub use frame_support_procedural::storage_alias;
|
||||
|
||||
pub use frame_support_procedural::derive_impl;
|
||||
@@ -818,703 +790,6 @@ pub use serde::{Deserialize, Serialize};
|
||||
#[cfg(not(no_std))]
|
||||
pub use macro_magic;
|
||||
|
||||
#[cfg(test)]
|
||||
pub mod tests {
|
||||
use super::*;
|
||||
use crate::metadata_ir::{
|
||||
PalletStorageMetadataIR, StorageEntryMetadataIR, StorageEntryModifierIR,
|
||||
StorageEntryTypeIR, StorageHasherIR,
|
||||
};
|
||||
use sp_io::{MultiRemovalResults, TestExternalities};
|
||||
use sp_runtime::{generic, traits::BlakeTwo256, BuildStorage};
|
||||
use sp_std::result;
|
||||
|
||||
pub use self::frame_system::{pallet_prelude::*, Config, Pallet};
|
||||
|
||||
#[pallet]
|
||||
pub mod frame_system {
|
||||
#[allow(unused)]
|
||||
use super::{frame_system, frame_system::pallet_prelude::*};
|
||||
pub use crate::dispatch::RawOrigin;
|
||||
use crate::pallet_prelude::*;
|
||||
|
||||
#[pallet::pallet]
|
||||
pub struct Pallet<T>(_);
|
||||
|
||||
#[pallet::config]
|
||||
#[pallet::disable_frame_system_supertrait_check]
|
||||
pub trait Config: 'static {
|
||||
type Block: Parameter + sp_runtime::traits::Block;
|
||||
type AccountId;
|
||||
type BaseCallFilter: crate::traits::Contains<Self::RuntimeCall>;
|
||||
type RuntimeOrigin;
|
||||
type RuntimeCall;
|
||||
type PalletInfo: crate::traits::PalletInfo;
|
||||
type DbWeight: Get<crate::weights::RuntimeDbWeight>;
|
||||
}
|
||||
|
||||
#[pallet::error]
|
||||
pub enum Error<T> {
|
||||
/// Required by construct_runtime
|
||||
CallFiltered,
|
||||
}
|
||||
|
||||
#[pallet::origin]
|
||||
pub type Origin<T> = RawOrigin<<T as Config>::AccountId>;
|
||||
|
||||
#[pallet::call]
|
||||
impl<T: Config> Pallet<T> {}
|
||||
|
||||
#[pallet::storage]
|
||||
pub type Data<T> = StorageMap<_, Twox64Concat, u32, u64, ValueQuery>;
|
||||
|
||||
#[pallet::storage]
|
||||
pub type OptionLinkedMap<T> = StorageMap<_, Blake2_128Concat, u32, u32, OptionQuery>;
|
||||
|
||||
#[pallet::storage]
|
||||
#[pallet::getter(fn generic_data)]
|
||||
pub type GenericData<T: Config> =
|
||||
StorageMap<_, Identity, BlockNumberFor<T>, BlockNumberFor<T>, ValueQuery>;
|
||||
|
||||
#[pallet::storage]
|
||||
#[pallet::getter(fn generic_data2)]
|
||||
pub type GenericData2<T: Config> =
|
||||
StorageMap<_, Blake2_128Concat, BlockNumberFor<T>, BlockNumberFor<T>, OptionQuery>;
|
||||
|
||||
#[pallet::storage]
|
||||
pub type DataDM<T> =
|
||||
StorageDoubleMap<_, Twox64Concat, u32, Blake2_128Concat, u32, u64, ValueQuery>;
|
||||
|
||||
#[pallet::storage]
|
||||
pub type GenericDataDM<T: Config> = StorageDoubleMap<
|
||||
_,
|
||||
Blake2_128Concat,
|
||||
BlockNumberFor<T>,
|
||||
Identity,
|
||||
BlockNumberFor<T>,
|
||||
BlockNumberFor<T>,
|
||||
ValueQuery,
|
||||
>;
|
||||
|
||||
#[pallet::storage]
|
||||
pub type GenericData2DM<T: Config> = StorageDoubleMap<
|
||||
_,
|
||||
Blake2_128Concat,
|
||||
BlockNumberFor<T>,
|
||||
Twox64Concat,
|
||||
BlockNumberFor<T>,
|
||||
BlockNumberFor<T>,
|
||||
OptionQuery,
|
||||
>;
|
||||
|
||||
#[pallet::storage]
|
||||
#[pallet::unbounded]
|
||||
pub type AppendableDM<T: Config> = StorageDoubleMap<
|
||||
_,
|
||||
Blake2_128Concat,
|
||||
u32,
|
||||
Blake2_128Concat,
|
||||
BlockNumberFor<T>,
|
||||
Vec<u32>,
|
||||
ValueQuery,
|
||||
>;
|
||||
|
||||
#[pallet::genesis_config]
|
||||
pub struct GenesisConfig<T: Config> {
|
||||
pub data: Vec<(u32, u64)>,
|
||||
pub test_config: Vec<(u32, u32, u64)>,
|
||||
#[serde(skip)]
|
||||
pub _config: sp_std::marker::PhantomData<T>,
|
||||
}
|
||||
|
||||
impl<T: Config> Default for GenesisConfig<T> {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
_config: Default::default(),
|
||||
data: vec![(15u32, 42u64)],
|
||||
test_config: vec![(15u32, 16u32, 42u64)],
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[pallet::genesis_build]
|
||||
impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
|
||||
fn build(&self) {
|
||||
for (k, v) in &self.data {
|
||||
<Data<T>>::insert(k, v);
|
||||
}
|
||||
for (k1, k2, v) in &self.test_config {
|
||||
<DataDM<T>>::insert(k1, k2, v);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub mod pallet_prelude {
|
||||
pub type OriginFor<T> = <T as super::Config>::RuntimeOrigin;
|
||||
|
||||
pub type HeaderFor<T> =
|
||||
<<T as super::Config>::Block as sp_runtime::traits::HeaderProvider>::HeaderT;
|
||||
|
||||
pub type BlockNumberFor<T> = <HeaderFor<T> as sp_runtime::traits::Header>::Number;
|
||||
}
|
||||
}
|
||||
|
||||
type BlockNumber = u32;
|
||||
type AccountId = u32;
|
||||
type Header = generic::Header<BlockNumber, BlakeTwo256>;
|
||||
type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, (), ()>;
|
||||
type Block = generic::Block<Header, UncheckedExtrinsic>;
|
||||
|
||||
crate::construct_runtime!(
|
||||
pub enum Runtime
|
||||
{
|
||||
System: self::frame_system,
|
||||
}
|
||||
);
|
||||
|
||||
impl Config for Runtime {
|
||||
type Block = Block;
|
||||
type AccountId = AccountId;
|
||||
type BaseCallFilter = crate::traits::Everything;
|
||||
type RuntimeOrigin = RuntimeOrigin;
|
||||
type RuntimeCall = RuntimeCall;
|
||||
type PalletInfo = PalletInfo;
|
||||
type DbWeight = ();
|
||||
}
|
||||
|
||||
fn new_test_ext() -> TestExternalities {
|
||||
RuntimeGenesisConfig::default().build_storage().unwrap().into()
|
||||
}
|
||||
|
||||
trait Sorted {
|
||||
fn sorted(self) -> Self;
|
||||
}
|
||||
|
||||
impl<T: Ord> Sorted for Vec<T> {
|
||||
fn sorted(mut self) -> Self {
|
||||
self.sort();
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn storage_alias_works() {
|
||||
new_test_ext().execute_with(|| {
|
||||
#[crate::storage_alias]
|
||||
type GenericData2<T> =
|
||||
StorageMap<System, Blake2_128Concat, BlockNumberFor<T>, BlockNumberFor<T>>;
|
||||
|
||||
assert_eq!(Pallet::<Runtime>::generic_data2(5), None);
|
||||
GenericData2::<Runtime>::insert(5, 5);
|
||||
assert_eq!(Pallet::<Runtime>::generic_data2(5), Some(5));
|
||||
|
||||
/// Some random docs that ensure that docs are accepted
|
||||
#[crate::storage_alias]
|
||||
pub type GenericData<T> =
|
||||
StorageMap<Test2, Blake2_128Concat, BlockNumberFor<T>, BlockNumberFor<T>>;
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn storage_value_mutate_exists_should_work() {
|
||||
new_test_ext().execute_with(|| {
|
||||
#[crate::storage_alias]
|
||||
pub type Value = StorageValue<Test, u32>;
|
||||
|
||||
assert!(!Value::exists());
|
||||
|
||||
Value::mutate_exists(|v| *v = Some(1));
|
||||
assert!(Value::exists());
|
||||
assert_eq!(Value::get(), Some(1));
|
||||
|
||||
// removed if mutated to `None`
|
||||
Value::mutate_exists(|v| *v = None);
|
||||
assert!(!Value::exists());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn storage_value_try_mutate_exists_should_work() {
|
||||
new_test_ext().execute_with(|| {
|
||||
#[crate::storage_alias]
|
||||
pub type Value = StorageValue<Test, u32>;
|
||||
|
||||
type TestResult = result::Result<(), &'static str>;
|
||||
|
||||
assert!(!Value::exists());
|
||||
|
||||
// mutated if `Ok`
|
||||
assert_ok!(Value::try_mutate_exists(|v| -> TestResult {
|
||||
*v = Some(1);
|
||||
Ok(())
|
||||
}));
|
||||
assert!(Value::exists());
|
||||
assert_eq!(Value::get(), Some(1));
|
||||
|
||||
// no-op if `Err`
|
||||
assert_noop!(
|
||||
Value::try_mutate_exists(|v| -> TestResult {
|
||||
*v = Some(2);
|
||||
Err("nah")
|
||||
}),
|
||||
"nah"
|
||||
);
|
||||
assert_eq!(Value::get(), Some(1));
|
||||
|
||||
// removed if mutated to`None`
|
||||
assert_ok!(Value::try_mutate_exists(|v| -> TestResult {
|
||||
*v = None;
|
||||
Ok(())
|
||||
}));
|
||||
assert!(!Value::exists());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn map_issue_3318() {
|
||||
new_test_ext().execute_with(|| {
|
||||
type OptionLinkedMap = self::frame_system::OptionLinkedMap<Runtime>;
|
||||
|
||||
OptionLinkedMap::insert(1, 1);
|
||||
assert_eq!(OptionLinkedMap::get(1), Some(1));
|
||||
OptionLinkedMap::insert(1, 2);
|
||||
assert_eq!(OptionLinkedMap::get(1), Some(2));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn map_swap_works() {
|
||||
new_test_ext().execute_with(|| {
|
||||
type OptionLinkedMap = self::frame_system::OptionLinkedMap<Runtime>;
|
||||
|
||||
OptionLinkedMap::insert(0, 0);
|
||||
OptionLinkedMap::insert(1, 1);
|
||||
OptionLinkedMap::insert(2, 2);
|
||||
OptionLinkedMap::insert(3, 3);
|
||||
|
||||
let collect = || OptionLinkedMap::iter().collect::<Vec<_>>().sorted();
|
||||
assert_eq!(collect(), vec![(0, 0), (1, 1), (2, 2), (3, 3)]);
|
||||
|
||||
// Two existing
|
||||
OptionLinkedMap::swap(1, 2);
|
||||
assert_eq!(collect(), vec![(0, 0), (1, 2), (2, 1), (3, 3)]);
|
||||
|
||||
// Back to normal
|
||||
OptionLinkedMap::swap(2, 1);
|
||||
assert_eq!(collect(), vec![(0, 0), (1, 1), (2, 2), (3, 3)]);
|
||||
|
||||
// Left existing
|
||||
OptionLinkedMap::swap(2, 5);
|
||||
assert_eq!(collect(), vec![(0, 0), (1, 1), (3, 3), (5, 2)]);
|
||||
|
||||
// Right existing
|
||||
OptionLinkedMap::swap(5, 2);
|
||||
assert_eq!(collect(), vec![(0, 0), (1, 1), (2, 2), (3, 3)]);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn double_map_swap_works() {
|
||||
new_test_ext().execute_with(|| {
|
||||
type DataDM = self::frame_system::DataDM<Runtime>;
|
||||
|
||||
DataDM::insert(0, 1, 1);
|
||||
DataDM::insert(1, 0, 2);
|
||||
DataDM::insert(1, 1, 3);
|
||||
|
||||
let get_all = || {
|
||||
vec![
|
||||
DataDM::get(0, 1),
|
||||
DataDM::get(1, 0),
|
||||
DataDM::get(1, 1),
|
||||
DataDM::get(2, 0),
|
||||
DataDM::get(2, 1),
|
||||
]
|
||||
};
|
||||
assert_eq!(get_all(), vec![1, 2, 3, 0, 0]);
|
||||
|
||||
// Two existing
|
||||
DataDM::swap(0, 1, 1, 0);
|
||||
assert_eq!(get_all(), vec![2, 1, 3, 0, 0]);
|
||||
|
||||
// Left existing
|
||||
DataDM::swap(1, 0, 2, 0);
|
||||
assert_eq!(get_all(), vec![2, 0, 3, 1, 0]);
|
||||
|
||||
// Right existing
|
||||
DataDM::swap(2, 1, 1, 1);
|
||||
assert_eq!(get_all(), vec![2, 0, 0, 1, 3]);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn map_basic_insert_remove_should_work() {
|
||||
new_test_ext().execute_with(|| {
|
||||
type Map = self::frame_system::Data<Runtime>;
|
||||
|
||||
// initialized during genesis
|
||||
assert_eq!(Map::get(&15u32), 42u64);
|
||||
|
||||
// get / insert / take
|
||||
let key = 17u32;
|
||||
assert_eq!(Map::get(&key), 0u64);
|
||||
Map::insert(key, 4u64);
|
||||
assert_eq!(Map::get(&key), 4u64);
|
||||
assert_eq!(Map::take(&key), 4u64);
|
||||
assert_eq!(Map::get(&key), 0u64);
|
||||
|
||||
// mutate
|
||||
Map::mutate(&key, |val| {
|
||||
*val = 15;
|
||||
});
|
||||
assert_eq!(Map::get(&key), 15u64);
|
||||
|
||||
// remove
|
||||
Map::remove(&key);
|
||||
assert_eq!(Map::get(&key), 0u64);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn map_iteration_should_work() {
|
||||
new_test_ext().execute_with(|| {
|
||||
type Map = self::frame_system::Data<Runtime>;
|
||||
|
||||
assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(15, 42)]);
|
||||
// insert / remove
|
||||
let key = 17u32;
|
||||
Map::insert(key, 4u64);
|
||||
assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(15, 42), (key, 4)]);
|
||||
assert_eq!(Map::take(&15), 42u64);
|
||||
assert_eq!(Map::take(&key), 4u64);
|
||||
assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![]);
|
||||
|
||||
// Add couple of more elements
|
||||
Map::insert(key, 42u64);
|
||||
assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(key, 42)]);
|
||||
Map::insert(key + 1, 43u64);
|
||||
assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(key, 42), (key + 1, 43)]);
|
||||
|
||||
// mutate
|
||||
let key = key + 2;
|
||||
Map::mutate(&key, |val| {
|
||||
*val = 15;
|
||||
});
|
||||
assert_eq!(
|
||||
Map::iter().collect::<Vec<_>>().sorted(),
|
||||
vec![(key - 2, 42), (key - 1, 43), (key, 15)]
|
||||
);
|
||||
Map::mutate(&key, |val| {
|
||||
*val = 17;
|
||||
});
|
||||
assert_eq!(
|
||||
Map::iter().collect::<Vec<_>>().sorted(),
|
||||
vec![(key - 2, 42), (key - 1, 43), (key, 17)]
|
||||
);
|
||||
|
||||
// remove first
|
||||
Map::remove(&key);
|
||||
assert_eq!(
|
||||
Map::iter().collect::<Vec<_>>().sorted(),
|
||||
vec![(key - 2, 42), (key - 1, 43)]
|
||||
);
|
||||
|
||||
// remove last from the list
|
||||
Map::remove(&(key - 2));
|
||||
assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(key - 1, 43)]);
|
||||
|
||||
// remove the last element
|
||||
Map::remove(&(key - 1));
|
||||
assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![]);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn double_map_basic_insert_remove_remove_prefix_with_commit_should_work() {
|
||||
let key1 = 17u32;
|
||||
let key2 = 18u32;
|
||||
type DoubleMap = self::frame_system::DataDM<Runtime>;
|
||||
let mut e = new_test_ext();
|
||||
e.execute_with(|| {
|
||||
// initialized during genesis
|
||||
assert_eq!(DoubleMap::get(&15u32, &16u32), 42u64);
|
||||
|
||||
// get / insert / take
|
||||
assert_eq!(DoubleMap::get(&key1, &key2), 0u64);
|
||||
DoubleMap::insert(&key1, &key2, &4u64);
|
||||
assert_eq!(DoubleMap::get(&key1, &key2), 4u64);
|
||||
assert_eq!(DoubleMap::take(&key1, &key2), 4u64);
|
||||
assert_eq!(DoubleMap::get(&key1, &key2), 0u64);
|
||||
|
||||
// mutate
|
||||
DoubleMap::mutate(&key1, &key2, |val| *val = 15);
|
||||
assert_eq!(DoubleMap::get(&key1, &key2), 15u64);
|
||||
|
||||
// remove
|
||||
DoubleMap::remove(&key1, &key2);
|
||||
assert_eq!(DoubleMap::get(&key1, &key2), 0u64);
|
||||
|
||||
// remove prefix
|
||||
DoubleMap::insert(&key1, &key2, &4u64);
|
||||
DoubleMap::insert(&key1, &(key2 + 1), &4u64);
|
||||
DoubleMap::insert(&(key1 + 1), &key2, &4u64);
|
||||
DoubleMap::insert(&(key1 + 1), &(key2 + 1), &4u64);
|
||||
});
|
||||
e.commit_all().unwrap();
|
||||
e.execute_with(|| {
|
||||
assert!(matches!(
|
||||
DoubleMap::clear_prefix(&key1, u32::max_value(), None),
|
||||
MultiRemovalResults { maybe_cursor: None, backend: 2, unique: 2, loops: 2 }
|
||||
));
|
||||
assert_eq!(DoubleMap::get(&key1, &key2), 0u64);
|
||||
assert_eq!(DoubleMap::get(&key1, &(key2 + 1)), 0u64);
|
||||
assert_eq!(DoubleMap::get(&(key1 + 1), &key2), 4u64);
|
||||
assert_eq!(DoubleMap::get(&(key1 + 1), &(key2 + 1)), 4u64);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn double_map_basic_insert_remove_remove_prefix_should_work() {
|
||||
new_test_ext().execute_with(|| {
|
||||
let key1 = 17u32;
|
||||
let key2 = 18u32;
|
||||
type DoubleMap = self::frame_system::DataDM<Runtime>;
|
||||
|
||||
// initialized during genesis
|
||||
assert_eq!(DoubleMap::get(&15u32, &16u32), 42u64);
|
||||
|
||||
// get / insert / take
|
||||
assert_eq!(DoubleMap::get(&key1, &key2), 0u64);
|
||||
DoubleMap::insert(&key1, &key2, &4u64);
|
||||
assert_eq!(DoubleMap::get(&key1, &key2), 4u64);
|
||||
assert_eq!(DoubleMap::take(&key1, &key2), 4u64);
|
||||
assert_eq!(DoubleMap::get(&key1, &key2), 0u64);
|
||||
|
||||
// mutate
|
||||
DoubleMap::mutate(&key1, &key2, |val| *val = 15);
|
||||
assert_eq!(DoubleMap::get(&key1, &key2), 15u64);
|
||||
|
||||
// remove
|
||||
DoubleMap::remove(&key1, &key2);
|
||||
assert_eq!(DoubleMap::get(&key1, &key2), 0u64);
|
||||
|
||||
// remove prefix
|
||||
DoubleMap::insert(&key1, &key2, &4u64);
|
||||
DoubleMap::insert(&key1, &(key2 + 1), &4u64);
|
||||
DoubleMap::insert(&(key1 + 1), &key2, &4u64);
|
||||
DoubleMap::insert(&(key1 + 1), &(key2 + 1), &4u64);
|
||||
// all in overlay
|
||||
assert!(matches!(
|
||||
DoubleMap::clear_prefix(&key1, u32::max_value(), None),
|
||||
MultiRemovalResults { maybe_cursor: None, backend: 0, unique: 0, loops: 0 }
|
||||
));
|
||||
// Note this is the incorrect answer (for now), since we are using v2 of
|
||||
// `clear_prefix`.
|
||||
// When we switch to v3, then this will become:
|
||||
// MultiRemovalResults:: { maybe_cursor: None, backend: 0, unique: 2, loops: 2 },
|
||||
assert!(matches!(
|
||||
DoubleMap::clear_prefix(&key1, u32::max_value(), None),
|
||||
MultiRemovalResults { maybe_cursor: None, backend: 0, unique: 0, loops: 0 }
|
||||
));
|
||||
assert_eq!(DoubleMap::get(&key1, &key2), 0u64);
|
||||
assert_eq!(DoubleMap::get(&key1, &(key2 + 1)), 0u64);
|
||||
assert_eq!(DoubleMap::get(&(key1 + 1), &key2), 4u64);
|
||||
assert_eq!(DoubleMap::get(&(key1 + 1), &(key2 + 1)), 4u64);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn double_map_append_should_work() {
|
||||
new_test_ext().execute_with(|| {
|
||||
type DoubleMap = self::frame_system::AppendableDM<Runtime>;
|
||||
|
||||
let key1 = 17u32;
|
||||
let key2 = 18u32;
|
||||
|
||||
DoubleMap::insert(&key1, &key2, &vec![1]);
|
||||
DoubleMap::append(&key1, &key2, 2);
|
||||
assert_eq!(DoubleMap::get(&key1, &key2), &[1, 2]);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn double_map_mutate_exists_should_work() {
|
||||
new_test_ext().execute_with(|| {
|
||||
type DoubleMap = self::frame_system::DataDM<Runtime>;
|
||||
|
||||
let (key1, key2) = (11, 13);
|
||||
|
||||
// mutated
|
||||
DoubleMap::mutate_exists(key1, key2, |v| *v = Some(1));
|
||||
assert_eq!(DoubleMap::get(&key1, key2), 1);
|
||||
|
||||
// removed if mutated to `None`
|
||||
DoubleMap::mutate_exists(key1, key2, |v| *v = None);
|
||||
assert!(!DoubleMap::contains_key(&key1, key2));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn double_map_try_mutate_exists_should_work() {
|
||||
new_test_ext().execute_with(|| {
|
||||
type DoubleMap = self::frame_system::DataDM<Runtime>;
|
||||
type TestResult = Result<(), &'static str>;
|
||||
|
||||
let (key1, key2) = (11, 13);
|
||||
|
||||
// mutated if `Ok`
|
||||
assert_ok!(DoubleMap::try_mutate_exists(key1, key2, |v| -> TestResult {
|
||||
*v = Some(1);
|
||||
Ok(())
|
||||
}));
|
||||
assert_eq!(DoubleMap::get(&key1, key2), 1);
|
||||
|
||||
// no-op if `Err`
|
||||
assert_noop!(
|
||||
DoubleMap::try_mutate_exists(key1, key2, |v| -> TestResult {
|
||||
*v = Some(2);
|
||||
Err("nah")
|
||||
}),
|
||||
"nah"
|
||||
);
|
||||
|
||||
// removed if mutated to`None`
|
||||
assert_ok!(DoubleMap::try_mutate_exists(key1, key2, |v| -> TestResult {
|
||||
*v = None;
|
||||
Ok(())
|
||||
}));
|
||||
assert!(!DoubleMap::contains_key(&key1, key2));
|
||||
});
|
||||
}
|
||||
|
||||
fn expected_metadata() -> PalletStorageMetadataIR {
|
||||
PalletStorageMetadataIR {
|
||||
prefix: "System",
|
||||
entries: vec![
|
||||
StorageEntryMetadataIR {
|
||||
name: "Data",
|
||||
modifier: StorageEntryModifierIR::Default,
|
||||
ty: StorageEntryTypeIR::Map {
|
||||
hashers: vec![StorageHasherIR::Twox64Concat],
|
||||
key: scale_info::meta_type::<u32>(),
|
||||
value: scale_info::meta_type::<u64>(),
|
||||
},
|
||||
default: vec![0, 0, 0, 0, 0, 0, 0, 0],
|
||||
docs: vec![],
|
||||
},
|
||||
StorageEntryMetadataIR {
|
||||
name: "OptionLinkedMap",
|
||||
modifier: StorageEntryModifierIR::Optional,
|
||||
ty: StorageEntryTypeIR::Map {
|
||||
hashers: vec![StorageHasherIR::Blake2_128Concat],
|
||||
key: scale_info::meta_type::<u32>(),
|
||||
value: scale_info::meta_type::<u32>(),
|
||||
},
|
||||
default: vec![0],
|
||||
docs: vec![],
|
||||
},
|
||||
StorageEntryMetadataIR {
|
||||
name: "GenericData",
|
||||
modifier: StorageEntryModifierIR::Default,
|
||||
ty: StorageEntryTypeIR::Map {
|
||||
hashers: vec![StorageHasherIR::Identity],
|
||||
key: scale_info::meta_type::<u32>(),
|
||||
value: scale_info::meta_type::<u32>(),
|
||||
},
|
||||
default: vec![0, 0, 0, 0],
|
||||
docs: vec![],
|
||||
},
|
||||
StorageEntryMetadataIR {
|
||||
name: "GenericData2",
|
||||
modifier: StorageEntryModifierIR::Optional,
|
||||
ty: StorageEntryTypeIR::Map {
|
||||
hashers: vec![StorageHasherIR::Blake2_128Concat],
|
||||
key: scale_info::meta_type::<u32>(),
|
||||
value: scale_info::meta_type::<u32>(),
|
||||
},
|
||||
default: vec![0],
|
||||
docs: vec![],
|
||||
},
|
||||
StorageEntryMetadataIR {
|
||||
name: "DataDM",
|
||||
modifier: StorageEntryModifierIR::Default,
|
||||
ty: StorageEntryTypeIR::Map {
|
||||
hashers: vec![
|
||||
StorageHasherIR::Twox64Concat,
|
||||
StorageHasherIR::Blake2_128Concat,
|
||||
],
|
||||
key: scale_info::meta_type::<(u32, u32)>(),
|
||||
value: scale_info::meta_type::<u64>(),
|
||||
},
|
||||
default: vec![0, 0, 0, 0, 0, 0, 0, 0],
|
||||
docs: vec![],
|
||||
},
|
||||
StorageEntryMetadataIR {
|
||||
name: "GenericDataDM",
|
||||
modifier: StorageEntryModifierIR::Default,
|
||||
ty: StorageEntryTypeIR::Map {
|
||||
hashers: vec![StorageHasherIR::Blake2_128Concat, StorageHasherIR::Identity],
|
||||
key: scale_info::meta_type::<(u32, u32)>(),
|
||||
value: scale_info::meta_type::<u32>(),
|
||||
},
|
||||
default: vec![0, 0, 0, 0],
|
||||
docs: vec![],
|
||||
},
|
||||
StorageEntryMetadataIR {
|
||||
name: "GenericData2DM",
|
||||
modifier: StorageEntryModifierIR::Optional,
|
||||
ty: StorageEntryTypeIR::Map {
|
||||
hashers: vec![
|
||||
StorageHasherIR::Blake2_128Concat,
|
||||
StorageHasherIR::Twox64Concat,
|
||||
],
|
||||
key: scale_info::meta_type::<(u32, u32)>(),
|
||||
value: scale_info::meta_type::<u32>(),
|
||||
},
|
||||
default: vec![0],
|
||||
docs: vec![],
|
||||
},
|
||||
StorageEntryMetadataIR {
|
||||
name: "AppendableDM",
|
||||
modifier: StorageEntryModifierIR::Default,
|
||||
ty: StorageEntryTypeIR::Map {
|
||||
hashers: vec![
|
||||
StorageHasherIR::Blake2_128Concat,
|
||||
StorageHasherIR::Blake2_128Concat,
|
||||
],
|
||||
key: scale_info::meta_type::<(u32, u32)>(),
|
||||
value: scale_info::meta_type::<Vec<u32>>(),
|
||||
},
|
||||
default: vec![0],
|
||||
docs: vec![],
|
||||
},
|
||||
],
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn store_metadata() {
|
||||
let metadata = Pallet::<Runtime>::storage_metadata();
|
||||
pretty_assertions::assert_eq!(expected_metadata(), metadata);
|
||||
}
|
||||
|
||||
parameter_types! {
|
||||
storage StorageParameter: u64 = 10;
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn check_storage_parameter_type_works() {
|
||||
TestExternalities::default().execute_with(|| {
|
||||
assert_eq!(sp_io::hashing::twox_128(b":StorageParameter:"), StorageParameter::key());
|
||||
|
||||
assert_eq!(10, StorageParameter::get());
|
||||
|
||||
StorageParameter::set(&300);
|
||||
assert_eq!(300, StorageParameter::get());
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Private module re-exporting items used by frame support macros.
|
||||
#[doc(hidden)]
|
||||
pub mod _private {
|
||||
|
||||
Reference in New Issue
Block a user