pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-05-30 17:31:03 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
07e55006ad05d0346142d5bf4cacf649b16836f6
pezkuwi-subxt/substrate/frame/ranked-collective/src/tests.rs
T
Oliver Tale-Yazdi 07e55006ad [FRAME] Make core-fellowship ans salary work for swapped members (#3156) 
Fixup for https://github.com/paritytech/polkadot-sdk/pull/2587 to make
the `core-fellowship` crate work with swapped members.

Adds a `MemberSwappedHandler` to the `ranked-collective` pallet that are
implemented by `core-fellowship+salary`.
There is are exhaustive tests
[here](https://github.com/paritytech/polkadot-sdk/blob/72aa7ac17a0e5b16faab5d2992aa2db2e01b05d0/substrate/frame/core-fellowship/src/tests/integration.rs#L338)
and
[here](https://github.com/paritytech/polkadot-sdk/blob/ab3cdb05a5ebc1ff841f8dda67edef0ea40bbba5/substrate/frame/salary/src/tests/integration.rs#L224)
to check that adding member `1` is equivalent to adding member `0` and
then swapping.

---------

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>
2024-01-31 16:29:48 +00:00

626 lines
20 KiB
Rust
Raw Blame History

// This file is part of Substrate.
// Copyright (C) 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.
//! The crate's tests.
use std::collections::BTreeMap;
use frame_support::{
assert_noop, assert_ok, derive_impl,
error::BadOrigin,
parameter_types,
traits::{ConstU16, EitherOf, MapSuccess, Polling},
};
use sp_core::Get;
use sp_runtime::{traits::ReduceBy, BuildStorage};
use super::*;
use crate as pallet_ranked_collective;
type Block = frame_system::mocking::MockBlock<Test>;
type Class = Rank;
frame_support::construct_runtime!(
pub enum Test
{
System: frame_system,
Club: pallet_ranked_collective,
}
);
#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
impl frame_system::Config for Test {
type Block = Block;
}
#[derive(Clone, PartialEq, Eq, Debug)]
pub enum TestPollState {
Ongoing(TallyOf<Test>, Rank),
Completed(u64, bool),
}
use TestPollState::*;
parameter_types! {
pub static Polls: BTreeMap<u8, TestPollState> = vec![
(1, Completed(1, true)),
(2, Completed(2, false)),
(3, Ongoing(Tally::from_parts(0, 0, 0), 1)),
].into_iter().collect();
}
pub struct TestPolls;
impl Polling<TallyOf<Test>> for TestPolls {
type Index = u8;
type Votes = Votes;
type Moment = u64;
type Class = Class;
fn classes() -> Vec<Self::Class> {
vec![0, 1, 2]
}
fn as_ongoing(index: u8) -> Option<(TallyOf<Test>, Self::Class)> {
Polls::get().remove(&index).and_then(|x| {
if let TestPollState::Ongoing(t, c) = x {
Some((t, c))
} else {
None
}
})
}
fn access_poll<R>(
index: Self::Index,
f: impl FnOnce(PollStatus<&mut TallyOf<Test>, Self::Moment, Self::Class>) -> R,
) -> R {
let mut polls = Polls::get();
let entry = polls.get_mut(&index);
let r = match entry {
Some(Ongoing(ref mut tally_mut_ref, class)) =>
f(PollStatus::Ongoing(tally_mut_ref, *class)),
Some(Completed(when, succeeded)) => f(PollStatus::Completed(*when, *succeeded)),
None => f(PollStatus::None),
};
Polls::set(polls);
r
}
fn try_access_poll<R>(
index: Self::Index,
f: impl FnOnce(
PollStatus<&mut TallyOf<Test>, Self::Moment, Self::Class>,
) -> Result<R, DispatchError>,
) -> Result<R, DispatchError> {
let mut polls = Polls::get();
let entry = polls.get_mut(&index);
let r = match entry {
Some(Ongoing(ref mut tally_mut_ref, class)) =>
f(PollStatus::Ongoing(tally_mut_ref, *class)),
Some(Completed(when, succeeded)) => f(PollStatus::Completed(*when, *succeeded)),
None => f(PollStatus::None),
}?;
Polls::set(polls);
Ok(r)
}
#[cfg(feature = "runtime-benchmarks")]
fn create_ongoing(class: Self::Class) -> Result<Self::Index, ()> {
let mut polls = Polls::get();
let i = polls.keys().rev().next().map_or(0, |x| x + 1);
polls.insert(i, Ongoing(Tally::new(class), class));
Polls::set(polls);
Ok(i)
}
#[cfg(feature = "runtime-benchmarks")]
fn end_ongoing(index: Self::Index, approved: bool) -> Result<(), ()> {
let mut polls = Polls::get();
match polls.get(&index) {
Some(Ongoing(..)) => {},
_ => return Err(()),
}
let now = frame_system::Pallet::<Test>::block_number();
polls.insert(index, Completed(now, approved));
Polls::set(polls);
Ok(())
}
}
/// Convert the tally class into the minimum rank required to vote on the poll.
/// MinRank(Class) = Class - Delta
pub struct MinRankOfClass<Delta>(PhantomData<Delta>);
impl<Delta: Get<Rank>> Convert<Class, Rank> for MinRankOfClass<Delta> {
fn convert(a: Class) -> Rank {
a.saturating_sub(Delta::get())
}
}
parameter_types! {
pub static MinRankOfClassDelta: Rank = 0;
}
impl Config for Test {
type WeightInfo = ();
type RuntimeEvent = RuntimeEvent;
type PromoteOrigin = EitherOf<
// Root can promote arbitrarily.
frame_system::EnsureRootWithSuccess<Self::AccountId, ConstU16<65535>>,
// Members can promote up to the rank of 2 below them.
MapSuccess<EnsureRanked<Test, (), 2>, ReduceBy<ConstU16<2>>>,
>;
type DemoteOrigin = EitherOf<
// Root can demote arbitrarily.
frame_system::EnsureRootWithSuccess<Self::AccountId, ConstU16<65535>>,
// Members can demote up to the rank of 3 below them.
MapSuccess<EnsureRanked<Test, (), 3>, ReduceBy<ConstU16<3>>>,
>;
type ExchangeOrigin = EitherOf<
// Root can exchange arbitrarily.
frame_system::EnsureRootWithSuccess<Self::AccountId, ConstU16<65535>>,
// Members can exchange up to the rank of 2 below them.
MapSuccess<EnsureRanked<Test, (), 2>, ReduceBy<ConstU16<2>>>,
>;
type Polls = TestPolls;
type MinRankOfClass = MinRankOfClass<MinRankOfClassDelta>;
type MemberSwappedHandler = ();
type VoteWeight = Geometric;
#[cfg(feature = "runtime-benchmarks")]
type BenchmarkSetup = ();
}
pub fn new_test_ext() -> sp_io::TestExternalities {
let t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
let mut ext = sp_io::TestExternalities::new(t);
ext.execute_with(|| System::set_block_number(1));
ext
}
fn next_block() {
System::set_block_number(System::block_number() + 1);
}
fn member_count(r: Rank) -> MemberIndex {
MemberCount::<Test>::get(r)
}
#[allow(dead_code)]
fn run_to(n: u64) {
while System::block_number() < n {
next_block();
}
}
fn tally(index: u8) -> TallyOf<Test> {
<TestPolls as Polling<TallyOf<Test>>>::as_ongoing(index).expect("No poll").0
}
#[test]
#[ignore]
#[should_panic(expected = "No poll")]
fn unknown_poll_should_panic() {
let _ = tally(0);
}
#[test]
#[ignore]
#[should_panic(expected = "No poll")]
fn completed_poll_should_panic() {
let _ = tally(1);
}
#[test]
fn basic_stuff() {
new_test_ext().execute_with(|| {
assert_eq!(tally(3), Tally::from_parts(0, 0, 0));
});
}
#[test]
fn member_lifecycle_works() {
new_test_ext().execute_with(|| {
assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 1));
assert_ok!(Club::demote_member(RuntimeOrigin::root(), 1));
assert_ok!(Club::demote_member(RuntimeOrigin::root(), 1));
assert_eq!(member_count(0), 0);
assert_eq!(member_count(1), 0);
});
}
#[test]
fn add_remove_works() {
new_test_ext().execute_with(|| {
assert_noop!(Club::add_member(RuntimeOrigin::signed(1), 1), DispatchError::BadOrigin);
assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
assert_eq!(member_count(0), 1);
assert_ok!(Club::demote_member(RuntimeOrigin::root(), 1));
assert_eq!(member_count(0), 0);
assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
assert_eq!(member_count(0), 1);
assert_ok!(Club::add_member(RuntimeOrigin::root(), 2));
assert_eq!(member_count(0), 2);
assert_ok!(Club::add_member(RuntimeOrigin::root(), 3));
assert_eq!(member_count(0), 3);
assert_ok!(Club::demote_member(RuntimeOrigin::root(), 3));
assert_eq!(member_count(0), 2);
assert_ok!(Club::demote_member(RuntimeOrigin::root(), 1));
assert_eq!(member_count(0), 1);
assert_ok!(Club::demote_member(RuntimeOrigin::root(), 2));
assert_eq!(member_count(0), 0);
});
}
#[test]
fn promote_demote_works() {
new_test_ext().execute_with(|| {
assert_noop!(Club::add_member(RuntimeOrigin::signed(1), 1), DispatchError::BadOrigin);
assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
assert_eq!(member_count(0), 1);
assert_eq!(member_count(1), 0);
assert_ok!(Club::add_member(RuntimeOrigin::root(), 2));
assert_eq!(member_count(0), 2);
assert_eq!(member_count(1), 0);
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 1));
assert_eq!(member_count(0), 2);
assert_eq!(member_count(1), 1);
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 2));
assert_eq!(member_count(0), 2);
assert_eq!(member_count(1), 2);
assert_ok!(Club::demote_member(RuntimeOrigin::root(), 1));
assert_eq!(member_count(0), 2);
assert_eq!(member_count(1), 1);
assert_noop!(Club::demote_member(RuntimeOrigin::signed(1), 1), DispatchError::BadOrigin);
assert_ok!(Club::demote_member(RuntimeOrigin::root(), 1));
assert_eq!(member_count(0), 1);
assert_eq!(member_count(1), 1);
});
}
#[test]
fn promote_demote_by_rank_works() {
new_test_ext().execute_with(|| {
assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
for _ in 0..7 {
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 1));
}
// #1 can add #2 and promote to rank 1
assert_ok!(Club::add_member(RuntimeOrigin::signed(1), 2));
assert_ok!(Club::promote_member(RuntimeOrigin::signed(1), 2));
// #2 as rank 1 cannot do anything privileged
assert_noop!(Club::add_member(RuntimeOrigin::signed(2), 3), BadOrigin);
assert_ok!(Club::promote_member(RuntimeOrigin::signed(1), 2));
// #2 as rank 2 can add #3.
assert_ok!(Club::add_member(RuntimeOrigin::signed(2), 3));
// #2 as rank 2 cannot promote #3 to rank 1
assert_noop!(
Club::promote_member(RuntimeOrigin::signed(2), 3),
Error::<Test>::NoPermission
);
// #1 as rank 7 can promote #2 only up to rank 5 and once there cannot demote them.
assert_ok!(Club::promote_member(RuntimeOrigin::signed(1), 2));
assert_ok!(Club::promote_member(RuntimeOrigin::signed(1), 2));
assert_ok!(Club::promote_member(RuntimeOrigin::signed(1), 2));
assert_noop!(
Club::promote_member(RuntimeOrigin::signed(1), 2),
Error::<Test>::NoPermission
);
assert_noop!(Club::demote_member(RuntimeOrigin::signed(1), 2), Error::<Test>::NoPermission);
// #2 as rank 5 can promote #3 only up to rank 3 and once there cannot demote them.
assert_ok!(Club::promote_member(RuntimeOrigin::signed(2), 3));
assert_ok!(Club::promote_member(RuntimeOrigin::signed(2), 3));
assert_ok!(Club::promote_member(RuntimeOrigin::signed(2), 3));
assert_noop!(
Club::promote_member(RuntimeOrigin::signed(2), 3),
Error::<Test>::NoPermission
);
assert_noop!(Club::demote_member(RuntimeOrigin::signed(2), 3), Error::<Test>::NoPermission);
// #2 can add #4 & #5 as rank 0 and #6 & #7 as rank 1.
assert_ok!(Club::add_member(RuntimeOrigin::signed(2), 4));
assert_ok!(Club::add_member(RuntimeOrigin::signed(2), 5));
assert_ok!(Club::add_member(RuntimeOrigin::signed(2), 6));
assert_ok!(Club::promote_member(RuntimeOrigin::signed(2), 6));
assert_ok!(Club::add_member(RuntimeOrigin::signed(2), 7));
assert_ok!(Club::promote_member(RuntimeOrigin::signed(2), 7));
// #3 as rank 3 can demote/remove #4 & #5 but not #6 & #7
assert_ok!(Club::demote_member(RuntimeOrigin::signed(3), 4));
assert_ok!(Club::remove_member(RuntimeOrigin::signed(3), 5, 0));
assert_noop!(Club::demote_member(RuntimeOrigin::signed(3), 6), Error::<Test>::NoPermission);
assert_noop!(
Club::remove_member(RuntimeOrigin::signed(3), 7, 1),
Error::<Test>::NoPermission
);
// #2 as rank 5 can demote/remove #6 & #7
assert_ok!(Club::demote_member(RuntimeOrigin::signed(2), 6));
assert_ok!(Club::remove_member(RuntimeOrigin::signed(2), 7, 1));
});
}
#[test]
fn voting_works() {
new_test_ext().execute_with(|| {
assert_ok!(Club::add_member(RuntimeOrigin::root(), 0));
assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 1));
assert_ok!(Club::add_member(RuntimeOrigin::root(), 2));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 2));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 2));
assert_ok!(Club::add_member(RuntimeOrigin::root(), 3));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
assert_noop!(Club::vote(RuntimeOrigin::signed(0), 3, true), Error::<Test>::RankTooLow);
assert_eq!(tally(3), Tally::from_parts(0, 0, 0));
assert_ok!(Club::vote(RuntimeOrigin::signed(1), 3, true));
assert_eq!(tally(3), Tally::from_parts(1, 1, 0));
assert_ok!(Club::vote(RuntimeOrigin::signed(1), 3, false));
assert_eq!(tally(3), Tally::from_parts(0, 0, 1));
assert_ok!(Club::vote(RuntimeOrigin::signed(2), 3, true));
assert_eq!(tally(3), Tally::from_parts(1, 3, 1));
assert_ok!(Club::vote(RuntimeOrigin::signed(2), 3, false));
assert_eq!(tally(3), Tally::from_parts(0, 0, 4));
assert_ok!(Club::vote(RuntimeOrigin::signed(3), 3, true));
assert_eq!(tally(3), Tally::from_parts(1, 6, 4));
assert_ok!(Club::vote(RuntimeOrigin::signed(3), 3, false));
assert_eq!(tally(3), Tally::from_parts(0, 0, 10));
});
}
#[test]
fn cleanup_works() {
new_test_ext().execute_with(|| {
assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 1));
assert_ok!(Club::add_member(RuntimeOrigin::root(), 2));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 2));
assert_ok!(Club::add_member(RuntimeOrigin::root(), 3));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
assert_ok!(Club::vote(RuntimeOrigin::signed(1), 3, true));
assert_ok!(Club::vote(RuntimeOrigin::signed(2), 3, false));
assert_ok!(Club::vote(RuntimeOrigin::signed(3), 3, true));
assert_noop!(Club::cleanup_poll(RuntimeOrigin::signed(4), 3, 10), Error::<Test>::Ongoing);
Polls::set(
vec![(1, Completed(1, true)), (2, Completed(2, false)), (3, Completed(3, true))]
.into_iter()
.collect(),
);
assert_ok!(Club::cleanup_poll(RuntimeOrigin::signed(4), 3, 10));
// NOTE: This will fail until #10016 is merged.
// assert_noop!(Club::cleanup_poll(RuntimeOrigin::signed(4), 3, 10),
// Error::<Test>::NoneRemaining);
});
}
#[test]
fn remove_member_cleanup_works() {
new_test_ext().execute_with(|| {
assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 1));
assert_ok!(Club::add_member(RuntimeOrigin::root(), 2));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 2));
assert_ok!(Club::add_member(RuntimeOrigin::root(), 3));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
assert_eq!(IdToIndex::<Test>::get(1, 2), Some(1));
assert_eq!(IndexToId::<Test>::get(1, 1), Some(2));
assert_eq!(IdToIndex::<Test>::get(1, 3), Some(2));
assert_eq!(IndexToId::<Test>::get(1, 2), Some(3));
assert_ok!(Club::remove_member(RuntimeOrigin::root(), 2, 1));
assert_eq!(IdToIndex::<Test>::get(1, 2), None);
assert_eq!(IndexToId::<Test>::get(1, 1), Some(3));
assert_eq!(IdToIndex::<Test>::get(1, 3), Some(1));
assert_eq!(IndexToId::<Test>::get(1, 2), None);
});
}
#[test]
fn ensure_ranked_works() {
new_test_ext().execute_with(|| {
assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 1));
assert_ok!(Club::add_member(RuntimeOrigin::root(), 2));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 2));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 2));
assert_ok!(Club::add_member(RuntimeOrigin::root(), 3));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
use frame_support::traits::OriginTrait;
type Rank1 = EnsureRanked<Test, (), 1>;
type Rank2 = EnsureRanked<Test, (), 2>;
type Rank3 = EnsureRanked<Test, (), 3>;
type Rank4 = EnsureRanked<Test, (), 4>;
assert_eq!(<Rank1 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(1)).unwrap(), 1);
assert_eq!(<Rank1 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(2)).unwrap(), 2);
assert_eq!(<Rank1 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(3)).unwrap(), 3);
assert_eq!(
<Rank2 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(1))
.unwrap_err()
.into_signer()
.unwrap(),
1
);
assert_eq!(<Rank2 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(2)).unwrap(), 2);
assert_eq!(<Rank2 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(3)).unwrap(), 3);
assert_eq!(
<Rank3 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(1))
.unwrap_err()
.into_signer()
.unwrap(),
1
);
assert_eq!(
<Rank3 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(2))
.unwrap_err()
.into_signer()
.unwrap(),
2
);
assert_eq!(<Rank3 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(3)).unwrap(), 3);
assert_eq!(
<Rank4 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(1))
.unwrap_err()
.into_signer()
.unwrap(),
1
);
assert_eq!(
<Rank4 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(2))
.unwrap_err()
.into_signer()
.unwrap(),
2
);
assert_eq!(
<Rank4 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(3))
.unwrap_err()
.into_signer()
.unwrap(),
3
);
});
}
#[test]
fn do_add_member_to_rank_works() {
new_test_ext().execute_with(|| {
let max_rank = 9u16;
assert_ok!(Club::do_add_member_to_rank(69, max_rank / 2, true));
assert_ok!(Club::do_add_member_to_rank(1337, max_rank, true));
for i in 0..=max_rank {
if i <= max_rank / 2 {
assert_eq!(member_count(i), 2);
} else {
assert_eq!(member_count(i), 1);
}
}
assert_eq!(member_count(max_rank + 1), 0);
})
}
#[test]
fn tally_support_correct() {
new_test_ext().execute_with(|| {
// add members,
// rank 1: accounts 1, 2, 3
// rank 2: accounts 2, 3
// rank 3: accounts 3.
assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 1));
assert_ok!(Club::add_member(RuntimeOrigin::root(), 2));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 2));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 2));
assert_ok!(Club::add_member(RuntimeOrigin::root(), 3));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
// init tally with 1 aye vote.
let tally: TallyOf<Test> = Tally::from_parts(1, 1, 0);
// with minRank(Class) = Class
// for class 3, 100% support.
MinRankOfClassDelta::set(0);
assert_eq!(tally.support(3), Perbill::from_rational(1u32, 1));
// with minRank(Class) = (Class - 1)
// for class 3, ~50% support.
MinRankOfClassDelta::set(1);
assert_eq!(tally.support(3), Perbill::from_rational(1u32, 2));
// with minRank(Class) = (Class - 2)
// for class 3, ~33% support.
MinRankOfClassDelta::set(2);
assert_eq!(tally.support(3), Perbill::from_rational(1u32, 3));
// reset back.
MinRankOfClassDelta::set(0);
});
}
#[test]
fn exchange_member_works() {
new_test_ext().execute_with(|| {
assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
assert_eq!(member_count(0), 1);
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 1));
let member_record = MemberRecord { rank: 1 };
assert_eq!(Members::<Test>::get(1), Some(member_record.clone()));
assert_eq!(Members::<Test>::get(2), None);
assert_ok!(Club::exchange_member(RuntimeOrigin::root(), 1, 2));
assert_eq!(member_count(0), 1);
assert_eq!(Members::<Test>::get(1), None);
assert_eq!(Members::<Test>::get(2), Some(member_record));
assert_ok!(Club::add_member(RuntimeOrigin::root(), 3));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
assert_noop!(
Club::exchange_member(RuntimeOrigin::signed(3), 2, 1),
DispatchError::BadOrigin
);
});
}
#[test]
fn exchange_member_same_noops() {
new_test_ext().execute_with(|| {
assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 1));
assert_ok!(Club::add_member(RuntimeOrigin::root(), 2));
assert_ok!(Club::promote_member(RuntimeOrigin::root(), 2));
// Swapping the same accounts is a noop:
assert_noop!(Club::exchange_member(RuntimeOrigin::root(), 1, 1), Error::<Test>::SameMember);
// Swapping with a different member is a noop:
assert_noop!(
Club::exchange_member(RuntimeOrigin::root(), 1, 2),
Error::<Test>::AlreadyMember
);
});
}
Reference in New Issue View Git Blame Copy Permalink