[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>

substrate/frame/core-fellowship/src/tests/integration.rs

@@ -0,0 +1,278 @@
+// 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.
+
+//! Integration test together with the ranked-collective pallet.
+
+use frame_support::{
+	assert_noop, assert_ok, derive_impl, hypothetically, ord_parameter_types,
+	pallet_prelude::Weight,
+	parameter_types,
+	traits::{ConstU16, EitherOf, IsInVec, MapSuccess, PollStatus, Polling, TryMapSuccess},
+};
+use frame_system::EnsureSignedBy;
+use pallet_ranked_collective::{EnsureRanked, Geometric, Rank, TallyOf, Votes};
+use sp_core::Get;
+use sp_runtime::{
+	traits::{Convert, ReduceBy, TryMorphInto},
+	BuildStorage, DispatchError,
+};
+type Class = Rank;
+
+use crate as pallet_core_fellowship;
+use crate::*;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		CoreFellowship: pallet_core_fellowship,
+		Club: pallet_ranked_collective,
+	}
+);
+
+parameter_types! {
+	pub BlockWeights: frame_system::limits::BlockWeights =
+		frame_system::limits::BlockWeights::simple_max(Weight::from_parts(1_000_000, u64::max_value()));
+}
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+impl frame_system::Config for Test {
+	type Block = Block;
+}
+
+parameter_types! {
+	pub static MinRankOfClassDelta: Rank = 0;
+}
+
+parameter_types! {
+	pub ZeroToNine: Vec<u64> = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+	pub EvidenceSize: u32 = 1024;
+}
+ord_parameter_types! {
+	pub const One: u64 = 1;
+}
+
+impl Config for Test {
+	type WeightInfo = ();
+	type RuntimeEvent = RuntimeEvent;
+	type Members = Club;
+	type Balance = u64;
+	type ParamsOrigin = EnsureSignedBy<One, u64>;
+	type InductOrigin = EnsureInducted<Test, (), 1>;
+	type ApproveOrigin = TryMapSuccess<EnsureSignedBy<IsInVec<ZeroToNine>, u64>, TryMorphInto<u16>>;
+	type PromoteOrigin = TryMapSuccess<EnsureSignedBy<IsInVec<ZeroToNine>, u64>, TryMorphInto<u16>>;
+	type EvidenceSize = EvidenceSize;
+}
+
+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> {
+		unimplemented!()
+	}
+	fn as_ongoing(_: u8) -> Option<(TallyOf<Test>, Self::Class)> {
+		unimplemented!()
+	}
+	fn access_poll<R>(
+		_: Self::Index,
+		_: impl FnOnce(PollStatus<&mut TallyOf<Test>, Self::Moment, Self::Class>) -> R,
+	) -> R {
+		unimplemented!()
+	}
+	fn try_access_poll<R>(
+		_: Self::Index,
+		_: impl FnOnce(
+			PollStatus<&mut TallyOf<Test>, Self::Moment, Self::Class>,
+		) -> Result<R, DispatchError>,
+	) -> Result<R, DispatchError> {
+		unimplemented!()
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn create_ongoing(_: Self::Class) -> Result<Self::Index, ()> {
+		unimplemented!()
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn end_ongoing(_: Self::Index, _: bool) -> Result<(), ()> {
+		unimplemented!()
+	}
+}
+
+/// 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())
+	}
+}
+
+impl pallet_ranked_collective::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 = CoreFellowship;
+	type VoteWeight = Geometric;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkSetup = CoreFellowship;
+}
+
+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(|| {
+		let params = ParamsType {
+			active_salary: [10, 20, 30, 40, 50, 60, 70, 80, 90],
+			passive_salary: [1, 2, 3, 4, 5, 6, 7, 8, 9],
+			demotion_period: [2, 4, 6, 8, 10, 12, 14, 16, 18],
+			min_promotion_period: [3, 6, 9, 12, 15, 18, 21, 24, 27],
+			offboard_timeout: 1,
+		};
+		assert_ok!(CoreFellowship::set_params(signed(1), Box::new(params)));
+		System::set_block_number(1);
+	});
+	ext
+}
+
+fn promote_n_times(acc: u64, r: u16) {
+	for _ in 0..r {
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), acc));
+	}
+}
+
+fn signed(who: u64) -> RuntimeOrigin {
+	RuntimeOrigin::signed(who)
+}
+
+fn assert_last_event(generic_event: <Test as Config>::RuntimeEvent) {
+	let events = frame_system::Pallet::<Test>::events();
+	let system_event: <Test as frame_system::Config>::RuntimeEvent = generic_event.into();
+	let frame_system::EventRecord { event, .. } = events.last().expect("Event expected");
+	assert_eq!(event, &system_event.into());
+}
+
+fn evidence(e: u32) -> Evidence<Test, ()> {
+	e.encode()
+		.into_iter()
+		.cycle()
+		.take(1024)
+		.collect::<Vec<_>>()
+		.try_into()
+		.expect("Static length matches")
+}
+
+#[test]
+fn swap_simple_works() {
+	new_test_ext().execute_with(|| {
+		for i in 0u16..9 {
+			let acc = i as u64;
+
+			assert_ok!(Club::add_member(RuntimeOrigin::root(), acc));
+			promote_n_times(acc, i);
+			assert_ok!(CoreFellowship::import(signed(acc)));
+
+			// Swapping normally works:
+			assert_ok!(Club::exchange_member(RuntimeOrigin::root(), acc, acc + 10));
+			assert_last_event(Event::Swapped { who: acc, new_who: acc + 10 }.into());
+		}
+	});
+}
+
+/// Exhaustively test that adding member `1` is equivalent to adding member `0` and then swapping.
+///
+/// The member also submits evidence before the swap.
+#[test]
+fn swap_exhaustive_works() {
+	new_test_ext().execute_with(|| {
+		let root_add = hypothetically!({
+			assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
+			promote_n_times(1, 4);
+			assert_ok!(CoreFellowship::import(signed(1)));
+			assert_ok!(CoreFellowship::submit_evidence(signed(1), Wish::Retention, evidence(1)));
+
+			// The events mess up the storage root:
+			System::reset_events();
+			sp_io::storage::root(sp_runtime::StateVersion::V1)
+		});
+
+		let root_swap = hypothetically!({
+			assert_ok!(Club::add_member(RuntimeOrigin::root(), 0));
+			promote_n_times(0, 4);
+			assert_ok!(CoreFellowship::import(signed(0)));
+			assert_ok!(CoreFellowship::submit_evidence(signed(0), Wish::Retention, evidence(1)));
+
+			// Now we swap:
+			assert_ok!(Club::exchange_member(RuntimeOrigin::root(), 0, 1));
+
+			System::reset_events();
+			sp_io::storage::root(sp_runtime::StateVersion::V1)
+		});
+
+		assert_eq!(root_add, root_swap);
+		// Ensure that we dont compare trivial stuff like `()` from a type error above.
+		assert_eq!(root_add.len(), 32);
+	});
+}
+
+#[test]
+fn swap_bad_noops() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 0));
+		promote_n_times(0, 0);
+		assert_ok!(CoreFellowship::import(signed(0)));
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
+		promote_n_times(1, 1);
+		assert_ok!(CoreFellowship::import(signed(1)));
+
+		// Swapping for another member is a noop:
+		assert_noop!(
+			Club::exchange_member(RuntimeOrigin::root(), 0, 1),
+			pallet_ranked_collective::Error::<Test>::AlreadyMember
+		);
+		// Swapping for the same member is a noop:
+		assert_noop!(
+			Club::exchange_member(RuntimeOrigin::root(), 0, 0),
+			pallet_ranked_collective::Error::<Test>::SameMember
+		);
+	});
+}

substrate/frame/core-fellowship/src/tests/mod.rs

@@ -0,0 +1,23 @@
+// 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.
+
+#![cfg(test)]
+
+//! Tests for this crate.
+
+pub(crate) mod integration;
+pub(crate) mod unit;

substrate/frame/core-fellowship/src/tests/unit.rs

@@ -0,0 +1,354 @@
+// 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, ord_parameter_types,
+	pallet_prelude::Weight,
+	parameter_types,
+	traits::{tokens::GetSalary, ConstU32, IsInVec, TryMapSuccess},
+};
+use frame_system::EnsureSignedBy;
+use sp_runtime::{traits::TryMorphInto, BuildStorage, DispatchError, DispatchResult};
+use sp_std::cell::RefCell;
+
+use crate as pallet_core_fellowship;
+use crate::*;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		CoreFellowship: pallet_core_fellowship,
+	}
+);
+
+parameter_types! {
+	pub BlockWeights: frame_system::limits::BlockWeights =
+		frame_system::limits::BlockWeights::simple_max(Weight::from_parts(1_000_000, u64::max_value()));
+}
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+impl frame_system::Config for Test {
+	type Block = Block;
+}
+
+thread_local! {
+	pub static CLUB: RefCell<BTreeMap<u64, u16>> = RefCell::new(BTreeMap::new());
+}
+
+pub struct TestClub;
+impl RankedMembers for TestClub {
+	type AccountId = u64;
+	type Rank = u16;
+	fn min_rank() -> Self::Rank {
+		0
+	}
+	fn rank_of(who: &Self::AccountId) -> Option<Self::Rank> {
+		CLUB.with(|club| club.borrow().get(who).cloned())
+	}
+	fn induct(who: &Self::AccountId) -> DispatchResult {
+		CLUB.with(|club| club.borrow_mut().insert(*who, 0));
+		Ok(())
+	}
+	fn promote(who: &Self::AccountId) -> DispatchResult {
+		CLUB.with(|club| {
+			club.borrow_mut().entry(*who).and_modify(|r| *r += 1);
+		});
+		Ok(())
+	}
+	fn demote(who: &Self::AccountId) -> DispatchResult {
+		CLUB.with(|club| match Self::rank_of(who) {
+			None => Err(sp_runtime::DispatchError::Unavailable),
+			Some(0) => {
+				club.borrow_mut().remove(&who);
+				Ok(())
+			},
+			Some(_) => {
+				club.borrow_mut().entry(*who).and_modify(|x| *x -= 1);
+				Ok(())
+			},
+		})
+	}
+}
+
+fn set_rank(who: u64, rank: u16) {
+	CLUB.with(|club| club.borrow_mut().insert(who, rank));
+}
+
+fn unrank(who: u64) {
+	CLUB.with(|club| club.borrow_mut().remove(&who));
+}
+
+parameter_types! {
+	pub ZeroToNine: Vec<u64> = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+}
+ord_parameter_types! {
+	pub const One: u64 = 1;
+}
+
+impl Config for Test {
+	type WeightInfo = ();
+	type RuntimeEvent = RuntimeEvent;
+	type Members = TestClub;
+	type Balance = u64;
+	type ParamsOrigin = EnsureSignedBy<One, u64>;
+	type InductOrigin = EnsureInducted<Test, (), 1>;
+	type ApproveOrigin = TryMapSuccess<EnsureSignedBy<IsInVec<ZeroToNine>, u64>, TryMorphInto<u16>>;
+	type PromoteOrigin = TryMapSuccess<EnsureSignedBy<IsInVec<ZeroToNine>, u64>, TryMorphInto<u16>>;
+	type EvidenceSize = ConstU32<1024>;
+}
+
+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(|| {
+		let params = ParamsType {
+			active_salary: [10, 20, 30, 40, 50, 60, 70, 80, 90],
+			passive_salary: [1, 2, 3, 4, 5, 6, 7, 8, 9],
+			demotion_period: [2, 4, 6, 8, 10, 12, 14, 16, 18],
+			min_promotion_period: [3, 6, 9, 12, 15, 18, 21, 24, 27],
+			offboard_timeout: 1,
+		};
+		assert_ok!(CoreFellowship::set_params(signed(1), Box::new(params)));
+		System::set_block_number(1);
+	});
+	ext
+}
+
+fn next_block() {
+	System::set_block_number(System::block_number() + 1);
+}
+
+fn run_to(n: u64) {
+	while System::block_number() < n {
+		next_block();
+	}
+}
+
+fn signed(who: u64) -> RuntimeOrigin {
+	RuntimeOrigin::signed(who)
+}
+
+fn next_demotion(who: u64) -> u64 {
+	let member = Member::<Test>::get(who).unwrap();
+	let demotion_period = Params::<Test>::get().demotion_period;
+	member.last_proof + demotion_period[TestClub::rank_of(&who).unwrap() as usize - 1]
+}
+
+#[test]
+fn basic_stuff() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(CoreFellowship::rank_to_index(0), None);
+		assert_eq!(CoreFellowship::rank_to_index(1), Some(0));
+		assert_eq!(CoreFellowship::rank_to_index(9), Some(8));
+		assert_eq!(CoreFellowship::rank_to_index(10), None);
+		assert_eq!(CoreFellowship::get_salary(0, &1), 0);
+	});
+}
+
+#[test]
+fn set_params_works() {
+	new_test_ext().execute_with(|| {
+		let params = ParamsType {
+			active_salary: [10, 20, 30, 40, 50, 60, 70, 80, 90],
+			passive_salary: [1, 2, 3, 4, 5, 6, 7, 8, 9],
+			demotion_period: [1, 2, 3, 4, 5, 6, 7, 8, 9],
+			min_promotion_period: [1, 2, 3, 4, 5, 10, 15, 20, 30],
+			offboard_timeout: 1,
+		};
+		assert_noop!(
+			CoreFellowship::set_params(signed(2), Box::new(params.clone())),
+			DispatchError::BadOrigin
+		);
+		assert_ok!(CoreFellowship::set_params(signed(1), Box::new(params)));
+	});
+}
+
+#[test]
+fn induct_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(0, 0);
+		assert_ok!(CoreFellowship::import(signed(0)));
+		set_rank(1, 1);
+		assert_ok!(CoreFellowship::import(signed(1)));
+
+		assert_noop!(CoreFellowship::induct(signed(10), 10), DispatchError::BadOrigin);
+		assert_noop!(CoreFellowship::induct(signed(0), 10), DispatchError::BadOrigin);
+		assert_ok!(CoreFellowship::induct(signed(1), 10));
+		assert_noop!(CoreFellowship::induct(signed(1), 10), Error::<Test>::AlreadyInducted);
+	});
+}
+
+#[test]
+fn promote_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(1, 1);
+		assert_ok!(CoreFellowship::import(signed(1)));
+		assert_noop!(CoreFellowship::promote(signed(1), 10, 1), Error::<Test>::Unranked);
+
+		assert_ok!(CoreFellowship::induct(signed(1), 10));
+		assert_noop!(CoreFellowship::promote(signed(10), 10, 1), DispatchError::BadOrigin);
+		assert_noop!(CoreFellowship::promote(signed(0), 10, 1), Error::<Test>::NoPermission);
+		assert_noop!(CoreFellowship::promote(signed(3), 10, 2), Error::<Test>::UnexpectedRank);
+		run_to(3);
+		assert_noop!(CoreFellowship::promote(signed(1), 10, 1), Error::<Test>::TooSoon);
+		run_to(4);
+		assert_ok!(CoreFellowship::promote(signed(1), 10, 1));
+		set_rank(11, 0);
+		assert_noop!(CoreFellowship::promote(signed(1), 11, 1), Error::<Test>::NotTracked);
+	});
+}
+
+#[test]
+fn sync_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(10, 5);
+		assert_noop!(CoreFellowship::approve(signed(4), 10, 5), Error::<Test>::NoPermission);
+		assert_noop!(CoreFellowship::approve(signed(6), 10, 6), Error::<Test>::UnexpectedRank);
+		assert_ok!(CoreFellowship::import(signed(10)));
+		assert!(Member::<Test>::contains_key(10));
+		assert_eq!(next_demotion(10), 11);
+	});
+}
+
+#[test]
+fn auto_demote_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(10, 5);
+		assert_ok!(CoreFellowship::import(signed(10)));
+
+		run_to(10);
+		assert_noop!(CoreFellowship::bump(signed(0), 10), Error::<Test>::NothingDoing);
+		run_to(11);
+		assert_ok!(CoreFellowship::bump(signed(0), 10));
+		assert_eq!(TestClub::rank_of(&10), Some(4));
+		assert_noop!(CoreFellowship::bump(signed(0), 10), Error::<Test>::NothingDoing);
+		assert_eq!(next_demotion(10), 19);
+	});
+}
+
+#[test]
+fn auto_demote_offboard_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(10, 1);
+		assert_ok!(CoreFellowship::import(signed(10)));
+
+		run_to(3);
+		assert_ok!(CoreFellowship::bump(signed(0), 10));
+		assert_eq!(TestClub::rank_of(&10), Some(0));
+		assert_noop!(CoreFellowship::bump(signed(0), 10), Error::<Test>::NothingDoing);
+		run_to(4);
+		assert_ok!(CoreFellowship::bump(signed(0), 10));
+		assert_noop!(CoreFellowship::bump(signed(0), 10), Error::<Test>::NotTracked);
+	});
+}
+
+#[test]
+fn offboard_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(CoreFellowship::offboard(signed(0), 10), Error::<Test>::NotTracked);
+		set_rank(10, 0);
+		assert_noop!(CoreFellowship::offboard(signed(0), 10), Error::<Test>::Ranked);
+
+		assert_ok!(CoreFellowship::import(signed(10)));
+		assert_noop!(CoreFellowship::offboard(signed(0), 10), Error::<Test>::Ranked);
+
+		unrank(10);
+		assert_ok!(CoreFellowship::offboard(signed(0), 10));
+		assert_noop!(CoreFellowship::offboard(signed(0), 10), Error::<Test>::NotTracked);
+		assert_noop!(CoreFellowship::bump(signed(0), 10), Error::<Test>::NotTracked);
+	});
+}
+
+#[test]
+fn infinite_demotion_period_works() {
+	new_test_ext().execute_with(|| {
+		let params = ParamsType {
+			active_salary: [10; 9],
+			passive_salary: [10; 9],
+			min_promotion_period: [10; 9],
+			demotion_period: [0; 9],
+			offboard_timeout: 0,
+		};
+		assert_ok!(CoreFellowship::set_params(signed(1), Box::new(params)));
+
+		set_rank(0, 0);
+		assert_ok!(CoreFellowship::import(signed(0)));
+		set_rank(1, 1);
+		assert_ok!(CoreFellowship::import(signed(1)));
+
+		assert_noop!(CoreFellowship::bump(signed(0), 0), Error::<Test>::NothingDoing);
+		assert_noop!(CoreFellowship::bump(signed(0), 1), Error::<Test>::NothingDoing);
+	});
+}
+
+#[test]
+fn proof_postpones_auto_demote() {
+	new_test_ext().execute_with(|| {
+		set_rank(10, 5);
+		assert_ok!(CoreFellowship::import(signed(10)));
+
+		run_to(11);
+		assert_ok!(CoreFellowship::approve(signed(5), 10, 5));
+		assert_eq!(next_demotion(10), 21);
+		assert_noop!(CoreFellowship::bump(signed(0), 10), Error::<Test>::NothingDoing);
+	});
+}
+
+#[test]
+fn promote_postpones_auto_demote() {
+	new_test_ext().execute_with(|| {
+		set_rank(10, 5);
+		assert_ok!(CoreFellowship::import(signed(10)));
+
+		run_to(19);
+		assert_ok!(CoreFellowship::promote(signed(6), 10, 6));
+		assert_eq!(next_demotion(10), 31);
+		assert_noop!(CoreFellowship::bump(signed(0), 10), Error::<Test>::NothingDoing);
+	});
+}
+
+#[test]
+fn get_salary_works() {
+	new_test_ext().execute_with(|| {
+		for i in 1..=9u64 {
+			set_rank(10 + i, i as u16);
+			assert_ok!(CoreFellowship::import(signed(10 + i)));
+			assert_eq!(CoreFellowship::get_salary(i as u16, &(10 + i)), i * 10);
+		}
+	});
+}
+
+#[test]
+fn active_changing_get_salary_works() {
+	new_test_ext().execute_with(|| {
+		for i in 1..=9u64 {
+			set_rank(10 + i, i as u16);
+			assert_ok!(CoreFellowship::import(signed(10 + i)));
+			assert_ok!(CoreFellowship::set_active(signed(10 + i), false));
+			assert_eq!(CoreFellowship::get_salary(i as u16, &(10 + i)), i);
+			assert_ok!(CoreFellowship::set_active(signed(10 + i), true));
+			assert_eq!(CoreFellowship::get_salary(i as u16, &(10 + i)), i * 10);
+		}
+	});
+}