pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-27 05:47:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use construct_runtime in tests (#8059)

Browse Source 
* impl some more

* add serde

* remove unused

* fix staking fuzz

* fix system bench

Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com>
This commit is contained in:
Guillaume Thiolliere
2021-02-06 21:12:46 +01:00
committed by GitHub
parent 4b1460f61f
commit 0ed683ca13
18 changed files with 446 additions and 445 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/frame/benchmarking/src/tests.rs
+206 -186
View File
@@ -21,59 +21,65 @@
use super::*;
use sp_std::prelude::*;
use sp_runtime::{traits::{BlakeTwo256, IdentityLookup}, testing::{H256, Header}};
use frame_support::{
dispatch::DispatchResult,
decl_module, decl_storage, impl_outer_origin, assert_ok, assert_err, ensure,
parameter_types, pallet_prelude::Get,
};
use frame_system::{RawOrigin, ensure_signed, ensure_none};
use sp_runtime::{traits::{BlakeTwo256, IdentityLookup}, testing::{H256, Header}, BuildStorage};
use frame_support::parameter_types;
decl_storage! {
trait Store for Module<T: Config> as Test where
<T as OtherConfig>::OtherEvent: Into<<T as Config>::Event>
mod pallet_test {
use frame_support::pallet_prelude::Get;
frame_support::decl_storage! {
trait Store for Module<T: Config> as Test where
<T as OtherConfig>::OtherEvent: Into<<T as Config>::Event>
{
pub Value get(fn value): Option<u32>;
}
}
frame_support::decl_module! {
pub struct Module<T: Config> for enum Call where
origin: T::Origin, <T as OtherConfig>::OtherEvent: Into<<T as Config>::Event>
{
#[weight = 0]
fn set_value(origin, n: u32) -> frame_support::dispatch::DispatchResult {
let _sender = frame_system::ensure_signed(origin)?;
Value::put(n);
Ok(())
}
#[weight = 0]
fn dummy(origin, _n: u32) -> frame_support::dispatch::DispatchResult {
let _sender = frame_system::ensure_none(origin)?;
Ok(())
}
}
}
pub trait OtherConfig {
type OtherEvent;
}
pub trait Config: frame_system::Config + OtherConfig
where Self::OtherEvent: Into<<Self as Config>::Event>
{
Value get(fn value): Option<u32>;
type Event;
type LowerBound: Get<u32>;
type UpperBound: Get<u32>;
}
}
decl_module! {
pub struct Module<T: Config> for enum Call where
origin: T::Origin, <T as OtherConfig>::OtherEvent: Into<<T as Config>::Event>
type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
type Block = frame_system::mocking::MockBlock<Test>;
frame_support::construct_runtime!(
pub enum Test where
Block = Block,
NodeBlock = Block,
UncheckedExtrinsic = UncheckedExtrinsic,
{
#[weight = 0]
fn set_value(origin, n: u32) -> DispatchResult {
let _sender = ensure_signed(origin)?;
Value::put(n);
Ok(())
}
#[weight = 0]
fn dummy(origin, _n: u32) -> DispatchResult {
let _sender = ensure_none(origin)?;
Ok(())
}
System: frame_system::{Module, Call, Config, Storage, Event<T>},
TestPallet: pallet_test::{Module, Call, Storage},
}
}
impl_outer_origin! {
pub enum Origin for Test where system = frame_system {}
}
pub trait OtherConfig {
type OtherEvent;
}
pub trait Config: frame_system::Config + OtherConfig
where Self::OtherEvent: Into<<Self as Config>::Event>
{
type Event;
type LowerBound: Get<u32>;
type UpperBound: Get<u32>;
}
#[derive(Clone, Eq, PartialEq)]
pub struct Test;
);
impl frame_system::Config for Test {
type BaseCallFilter = ();
@@ -84,15 +90,15 @@ impl frame_system::Config for Test {
type Index = u64;
type BlockNumber = u64;
type Hash = H256;
type Call = ();
type Call = Call;
type Hashing = BlakeTwo256;
type AccountId = u64;
type Lookup = IdentityLookup<Self::AccountId>;
type Header = Header;
type Event = ();
type Event = Event;
type BlockHashCount = ();
type Version = ();
type PalletInfo = ();
type PalletInfo = PalletInfo;
type AccountData = ();
type OnNewAccount = ();
type OnKilledAccount = ();
@@ -105,163 +111,177 @@ parameter_types!{
pub const UpperBound: u32 = 100;
}
impl Config for Test {
type Event = ();
impl pallet_test::Config for Test {
type Event = Event;
type LowerBound = LowerBound;
type UpperBound = UpperBound;
}
impl OtherConfig for Test {
type OtherEvent = ();
impl pallet_test::OtherConfig for Test {
type OtherEvent = Event;
}
fn new_test_ext() -> sp_io::TestExternalities {
frame_system::GenesisConfig::default().build_storage::<Test>().unwrap().into()
GenesisConfig::default().build_storage().unwrap().into()
}
benchmarks!{
where_clause { where <T as OtherConfig>::OtherEvent: Into<<T as Config>::Event> }
mod benchmarks {
use sp_std::prelude::*;
use frame_system::RawOrigin;
use super::{Test, pallet_test::{self, Value}, new_test_ext};
use frame_support::{assert_ok, assert_err, ensure, traits::Get, StorageValue};
use crate::{BenchmarkingSetup, BenchmarkParameter, account};
set_value {
let b in 1 .. 1000;
let caller = account::<T::AccountId>("caller", 0, 0);
}: _ (RawOrigin::Signed(caller), b.into())
verify {
assert_eq!(Value::get(), Some(b));
}
// Additional used internally by the benchmark macro.
use super::pallet_test::{Call, Config, Module};
other_name {
let b in 1 .. 1000;
}: dummy (RawOrigin::None, b.into())
sort_vector {
let x in 1 .. 10000;
let mut m = Vec::<u32>::new();
for i in (0..x).rev() {
m.push(i);
crate::benchmarks!{
where_clause {
where
<T as pallet_test::OtherConfig>::OtherEvent: Into<<T as pallet_test::Config>::Event>
}
}: {
m.sort();
} verify {
ensure!(m[0] == 0, "You forgot to sort!")
}
bad_origin {
let b in 1 .. 1000;
let caller = account::<T::AccountId>("caller", 0, 0);
}: dummy (RawOrigin::Signed(caller), b.into())
bad_verify {
let x in 1 .. 10000;
let mut m = Vec::<u32>::new();
for i in (0..x).rev() {
m.push(i);
set_value {
let b in 1 .. 1000;
let caller = account::<T::AccountId>("caller", 0, 0);
}: _ (RawOrigin::Signed(caller), b.into())
verify {
assert_eq!(Value::get(), Some(b));
}
}: { }
verify {
ensure!(m[0] == 0, "You forgot to sort!")
other_name {
let b in 1 .. 1000;
}: dummy (RawOrigin::None, b.into())
sort_vector {
let x in 1 .. 10000;
let mut m = Vec::<u32>::new();
for i in (0..x).rev() {
m.push(i);
}
}: {
m.sort();
} verify {
ensure!(m[0] == 0, "You forgot to sort!")
}
bad_origin {
let b in 1 .. 1000;
let caller = account::<T::AccountId>("caller", 0, 0);
}: dummy (RawOrigin::Signed(caller), b.into())
bad_verify {
let x in 1 .. 10000;
let mut m = Vec::<u32>::new();
for i in (0..x).rev() {
m.push(i);
}
}: { }
verify {
ensure!(m[0] == 0, "You forgot to sort!")
}
no_components {
let caller = account::<T::AccountId>("caller", 0, 0);
}: set_value(RawOrigin::Signed(caller), 0)
variable_components {
let b in ( T::LowerBound::get() ) .. T::UpperBound::get();
}: dummy (RawOrigin::None, b.into())
}
no_components {
let caller = account::<T::AccountId>("caller", 0, 0);
}: set_value(RawOrigin::Signed(caller), 0)
#[test]
fn benchmarks_macro_works() {
// Check benchmark creation for `set_value`.
let selected = SelectedBenchmark::set_value;
variable_components {
let b in ( T::LowerBound::get() ) .. T::UpperBound::get();
}: dummy (RawOrigin::None, b.into())
}
let components = <SelectedBenchmark as BenchmarkingSetup<Test>>::components(&selected);
assert_eq!(components, vec![(BenchmarkParameter::b, 1, 1000)]);
#[test]
fn benchmarks_macro_works() {
// Check benchmark creation for `set_value`.
let selected = SelectedBenchmark::set_value;
let closure = <SelectedBenchmark as BenchmarkingSetup<Test>>::instance(
&selected,
&[(BenchmarkParameter::b, 1)],
true,
).expect("failed to create closure");
let components = <SelectedBenchmark as BenchmarkingSetup<Test>>::components(&selected);
assert_eq!(components, vec![(BenchmarkParameter::b, 1, 1000)]);
new_test_ext().execute_with(|| {
assert_ok!(closure());
});
}
let closure = <SelectedBenchmark as BenchmarkingSetup<Test>>::instance(
&selected,
&[(BenchmarkParameter::b, 1)],
true,
).expect("failed to create closure");
#[test]
fn benchmarks_macro_rename_works() {
// Check benchmark creation for `other_dummy`.
let selected = SelectedBenchmark::other_name;
let components = <SelectedBenchmark as BenchmarkingSetup<Test>>::components(&selected);
assert_eq!(components, vec![(BenchmarkParameter::b, 1, 1000)]);
let closure = <SelectedBenchmark as BenchmarkingSetup<Test>>::instance(
&selected,
&[(BenchmarkParameter::b, 1)],
true,
).expect("failed to create closure");
new_test_ext().execute_with(|| {
assert_ok!(closure());
});
}
#[test]
fn benchmarks_macro_works_for_non_dispatchable() {
let selected = SelectedBenchmark::sort_vector;
let components = <SelectedBenchmark as BenchmarkingSetup<Test>>::components(&selected);
assert_eq!(components, vec![(BenchmarkParameter::x, 1, 10000)]);
let closure = <SelectedBenchmark as BenchmarkingSetup<Test>>::instance(
&selected,
&[(BenchmarkParameter::x, 1)],
true,
).expect("failed to create closure");
new_test_ext().execute_with(|| {
assert_ok!(closure());
});
}
#[test]
fn benchmarks_macro_rename_works() {
// Check benchmark creation for `other_dummy`.
let selected = SelectedBenchmark::other_name;
let components = <SelectedBenchmark as BenchmarkingSetup<Test>>::components(&selected);
assert_eq!(components, vec![(BenchmarkParameter::b, 1, 1000)]);
let closure = <SelectedBenchmark as BenchmarkingSetup<Test>>::instance(
&selected,
&[(BenchmarkParameter::b, 1)],
true,
).expect("failed to create closure");
new_test_ext().execute_with(|| {
assert_ok!(closure());
});
}
#[test]
fn benchmarks_macro_works_for_non_dispatchable() {
let selected = SelectedBenchmark::sort_vector;
let components = <SelectedBenchmark as BenchmarkingSetup<Test>>::components(&selected);
assert_eq!(components, vec![(BenchmarkParameter::x, 1, 10000)]);
let closure = <SelectedBenchmark as BenchmarkingSetup<Test>>::instance(
&selected,
&[(BenchmarkParameter::x, 1)],
true,
).expect("failed to create closure");
assert_ok!(closure());
}
#[test]
fn benchmarks_macro_verify_works() {
// Check postcondition for benchmark `set_value` is valid.
let selected = SelectedBenchmark::set_value;
let closure = <SelectedBenchmark as BenchmarkingSetup<Test>>::instance(
&selected,
&[(BenchmarkParameter::b, 1)],
true,
).expect("failed to create closure");
new_test_ext().execute_with(|| {
assert_ok!(closure());
});
// Check postcondition for benchmark `bad_verify` is invalid.
let selected = SelectedBenchmark::bad_verify;
let closure = <SelectedBenchmark as BenchmarkingSetup<Test>>::instance(
&selected,
&[(BenchmarkParameter::x, 10000)],
true,
).expect("failed to create closure");
new_test_ext().execute_with(|| {
assert_err!(closure(), "You forgot to sort!");
});
}
#[test]
fn benchmarks_generate_unit_tests() {
new_test_ext().execute_with(|| {
assert_ok!(test_benchmark_set_value::<Test>());
assert_ok!(test_benchmark_other_name::<Test>());
assert_ok!(test_benchmark_sort_vector::<Test>());
assert_err!(test_benchmark_bad_origin::<Test>(), "Bad origin");
assert_err!(test_benchmark_bad_verify::<Test>(), "You forgot to sort!");
assert_ok!(test_benchmark_no_components::<Test>());
assert_ok!(test_benchmark_variable_components::<Test>());
});
}
#[test]
fn benchmarks_macro_verify_works() {
// Check postcondition for benchmark `set_value` is valid.
let selected = SelectedBenchmark::set_value;
let closure = <SelectedBenchmark as BenchmarkingSetup<Test>>::instance(
&selected,
&[(BenchmarkParameter::b, 1)],
true,
).expect("failed to create closure");
new_test_ext().execute_with(|| {
assert_ok!(closure());
});
// Check postcondition for benchmark `bad_verify` is invalid.
let selected = SelectedBenchmark::bad_verify;
let closure = <SelectedBenchmark as BenchmarkingSetup<Test>>::instance(
&selected,
&[(BenchmarkParameter::x, 10000)],
true,
).expect("failed to create closure");
new_test_ext().execute_with(|| {
assert_err!(closure(), "You forgot to sort!");
});
}
#[test]
fn benchmarks_generate_unit_tests() {
new_test_ext().execute_with(|| {
assert_ok!(test_benchmark_set_value::<Test>());
assert_ok!(test_benchmark_other_name::<Test>());
assert_ok!(test_benchmark_sort_vector::<Test>());
assert_err!(test_benchmark_bad_origin::<Test>(), "Bad origin");
assert_err!(test_benchmark_bad_verify::<Test>(), "You forgot to sort!");
assert_ok!(test_benchmark_no_components::<Test>());
assert_ok!(test_benchmark_variable_components::<Test>());
});
}
}