[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/salary/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.
+
+//! The crate's tests.
+
+use frame_support::{
+	assert_noop, assert_ok, derive_impl, hypothetically,
+	pallet_prelude::Weight,
+	parameter_types,
+	traits::{ConstU64, EitherOf, MapSuccess, PollStatus, Polling},
+};
+use pallet_ranked_collective::{EnsureRanked, Geometric, TallyOf, Votes};
+use sp_core::{ConstU16, Get};
+use sp_runtime::{
+	traits::{Convert, ReduceBy},
+	BuildStorage, DispatchError,
+};
+
+use crate as pallet_salary;
+use crate::*;
+
+type Rank = u16;
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Salary: pallet_salary,
+		Club: pallet_ranked_collective,
+	}
+);
+
+parameter_types! {
+	pub BlockWeights: frame_system::limits::BlockWeights =
+		frame_system::limits::BlockWeights::simple_max(Weight::from_parts(1_000_000, 0));
+}
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+impl frame_system::Config for Test {
+	type Block = Block;
+}
+
+pub struct TestPolls;
+impl Polling<TallyOf<Test>> for TestPolls {
+	type Index = u8;
+	type Votes = Votes;
+	type Moment = u64;
+	type Class = Rank;
+
+	fn classes() -> Vec<Self::Class> {
+		unimplemented!()
+	}
+	fn as_ongoing(_index: u8) -> Option<(TallyOf<Test>, Self::Class)> {
+		unimplemented!()
+	}
+	fn access_poll<R>(
+		_index: Self::Index,
+		_f: impl FnOnce(PollStatus<&mut TallyOf<Test>, Self::Moment, Self::Class>) -> R,
+	) -> R {
+		unimplemented!()
+	}
+	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> {
+		unimplemented!()
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn create_ongoing(_class: Self::Class) -> Result<Self::Index, ()> {
+		unimplemented!()
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn end_ongoing(_index: Self::Index, _approved: bool) -> Result<(), ()> {
+		unimplemented!()
+	}
+}
+
+pub struct MinRankOfClass<Delta>(PhantomData<Delta>);
+impl<Delta: Get<Rank>> Convert<u16, Rank> for MinRankOfClass<Delta> {
+	fn convert(a: u16) -> Rank {
+		a.saturating_sub(Delta::get())
+	}
+}
+
+pub struct TestPay;
+impl Pay for TestPay {
+	type Beneficiary = u64;
+	type Balance = u64;
+	type Id = u64;
+	type AssetKind = ();
+	type Error = ();
+
+	fn pay(
+		_: &Self::Beneficiary,
+		_: Self::AssetKind,
+		_: Self::Balance,
+	) -> Result<Self::Id, Self::Error> {
+		unreachable!()
+	}
+	fn check_payment(_: Self::Id) -> PaymentStatus {
+		unreachable!()
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_successful(_: &Self::Beneficiary, _: Self::AssetKind, _: Self::Balance) {}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_concluded(_: Self::Id) {
+		unreachable!()
+	}
+}
+
+parameter_types! {
+	pub static Budget: u64 = 10;
+}
+
+impl Config for Test {
+	type WeightInfo = ();
+	type RuntimeEvent = RuntimeEvent;
+	type Paymaster = TestPay;
+	type Members = Club;
+	type Salary = FixedSalary;
+	type RegistrationPeriod = ConstU64<2>;
+	type PayoutPeriod = ConstU64<2>;
+	type Budget = Budget;
+}
+
+pub struct FixedSalary;
+impl GetSalary<u16, u64, u64> for FixedSalary {
+	fn get_salary(_rank: u16, _who: &u64) -> u64 {
+		123
+	}
+}
+
+parameter_types! {
+	pub static MinRankOfClassDelta: Rank = 0;
+}
+
+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 = Salary;
+	type VoteWeight = Geometric;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkSetup = Salary;
+}
+
+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 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 promote_n_times(acc: u64, r: u16) {
+	for _ in 0..r {
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), acc));
+	}
+}
+
+#[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);
+			let _ = Salary::init(RuntimeOrigin::signed(acc));
+			assert_ok!(Salary::induct(RuntimeOrigin::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());
+		}
+	});
+}
+
+#[test]
+fn swap_exhaustive_works() {
+	new_test_ext().execute_with(|| {
+		let root_add = hypothetically!({
+			assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
+			assert_ok!(Club::promote_member(RuntimeOrigin::root(), 1));
+			assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+			assert_ok!(Salary::induct(RuntimeOrigin::signed(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));
+			assert_ok!(Club::promote_member(RuntimeOrigin::root(), 0));
+			assert_ok!(Salary::init(RuntimeOrigin::signed(0)));
+			assert_ok!(Salary::induct(RuntimeOrigin::signed(0)));
+
+			assert_ok!(Club::exchange_member(RuntimeOrigin::root(), 0, 1));
+
+			// The events mess up the storage root:
+			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!(Salary::init(RuntimeOrigin::signed(0)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(0)));
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
+		promote_n_times(1, 1);
+		assert_ok!(Salary::induct(RuntimeOrigin::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/salary/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)]
+
+//! Unit and integration tests for the salary pallet.
+
+pub(crate) mod integration;
+pub(crate) mod unit;

substrate/frame/salary/src/tests/unit.rs

@@ -0,0 +1,617 @@
+// 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,
+	pallet_prelude::Weight,
+	parameter_types,
+	traits::{tokens::ConvertRank, ConstU64},
+};
+use sp_runtime::{traits::Identity, BuildStorage, DispatchResult};
+use sp_std::cell::RefCell;
+
+use crate as pallet_salary;
+use crate::*;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Salary: pallet_salary,
+	}
+);
+
+parameter_types! {
+	pub BlockWeights: frame_system::limits::BlockWeights =
+		frame_system::limits::BlockWeights::simple_max(Weight::from_parts(1_000_000, 0));
+}
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+impl frame_system::Config for Test {
+	type Block = Block;
+}
+
+thread_local! {
+	pub static PAID: RefCell<BTreeMap<u64, u64>> = RefCell::new(BTreeMap::new());
+	pub static STATUS: RefCell<BTreeMap<u64, PaymentStatus>> = RefCell::new(BTreeMap::new());
+	pub static LAST_ID: RefCell<u64> = RefCell::new(0u64);
+}
+
+fn paid(who: u64) -> u64 {
+	PAID.with(|p| p.borrow().get(&who).cloned().unwrap_or(0))
+}
+fn unpay(who: u64, amount: u64) {
+	PAID.with(|p| p.borrow_mut().entry(who).or_default().saturating_reduce(amount))
+}
+fn set_status(id: u64, s: PaymentStatus) {
+	STATUS.with(|m| m.borrow_mut().insert(id, s));
+}
+
+pub struct TestPay;
+impl Pay for TestPay {
+	type Beneficiary = u64;
+	type Balance = u64;
+	type Id = u64;
+	type AssetKind = ();
+	type Error = ();
+
+	fn pay(
+		who: &Self::Beneficiary,
+		_: Self::AssetKind,
+		amount: Self::Balance,
+	) -> Result<Self::Id, Self::Error> {
+		PAID.with(|paid| *paid.borrow_mut().entry(*who).or_default() += amount);
+		Ok(LAST_ID.with(|lid| {
+			let x = *lid.borrow();
+			lid.replace(x + 1);
+			x
+		}))
+	}
+	fn check_payment(id: Self::Id) -> PaymentStatus {
+		STATUS.with(|s| s.borrow().get(&id).cloned().unwrap_or(PaymentStatus::Unknown))
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_successful(_: &Self::Beneficiary, _: Self::AssetKind, _: Self::Balance) {}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_concluded(id: Self::Id) {
+		set_status(id, PaymentStatus::Failure)
+	}
+}
+
+thread_local! {
+	pub static CLUB: RefCell<BTreeMap<u64, u64>> = RefCell::new(BTreeMap::new());
+}
+
+pub struct TestClub;
+impl RankedMembers for TestClub {
+	type AccountId = u64;
+	type Rank = u64;
+	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 club.borrow().get(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: u64) {
+	CLUB.with(|club| club.borrow_mut().insert(who, rank));
+}
+
+parameter_types! {
+	pub static Budget: u64 = 10;
+}
+
+impl Config for Test {
+	type WeightInfo = ();
+	type RuntimeEvent = RuntimeEvent;
+	type Paymaster = TestPay;
+	type Members = TestClub;
+	type Salary = ConvertRank<Identity>;
+	type RegistrationPeriod = ConstU64<2>;
+	type PayoutPeriod = ConstU64<2>;
+	type Budget = Budget;
+}
+
+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);
+}
+
+#[allow(dead_code)]
+fn run_to(n: u64) {
+	while System::block_number() < n {
+		next_block();
+	}
+}
+
+#[test]
+fn basic_stuff() {
+	new_test_ext().execute_with(|| {
+		assert!(Salary::last_active(&0).is_err());
+		assert_eq!(Salary::status(), None);
+	});
+}
+
+#[test]
+fn can_start() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		assert_eq!(
+			Salary::status(),
+			Some(StatusType {
+				cycle_index: 0,
+				cycle_start: 1,
+				budget: 10,
+				total_registrations: 0,
+				total_unregistered_paid: 0,
+			})
+		);
+	});
+}
+
+#[test]
+fn bump_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		run_to(4);
+		assert_noop!(Salary::bump(RuntimeOrigin::signed(1)), Error::<Test>::NotYet);
+
+		run_to(5);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_eq!(
+			Salary::status(),
+			Some(StatusType {
+				cycle_index: 1,
+				cycle_start: 5,
+				budget: 10,
+				total_registrations: 0,
+				total_unregistered_paid: 0
+			})
+		);
+
+		run_to(8);
+		assert_noop!(Salary::bump(RuntimeOrigin::signed(1)), Error::<Test>::NotYet);
+
+		BUDGET.with(|b| b.replace(5));
+		run_to(9);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_eq!(
+			Salary::status(),
+			Some(StatusType {
+				cycle_index: 2,
+				cycle_start: 9,
+				budget: 5,
+				total_registrations: 0,
+				total_unregistered_paid: 0
+			})
+		);
+	});
+}
+
+#[test]
+fn induct_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+
+		assert_noop!(Salary::induct(RuntimeOrigin::signed(1)), Error::<Test>::NotMember);
+		set_rank(1, 1);
+		assert!(Salary::last_active(&1).is_err());
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		assert_eq!(Salary::last_active(&1).unwrap(), 0);
+		assert_noop!(Salary::induct(RuntimeOrigin::signed(1)), Error::<Test>::AlreadyInducted);
+	});
+}
+
+#[test]
+fn unregistered_payment_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(1, 1);
+		assert_noop!(Salary::induct(RuntimeOrigin::signed(1)), Error::<Test>::NotStarted);
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NotInducted);
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		// No claim on the cycle active during induction.
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::TooEarly);
+		run_to(3);
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+
+		run_to(6);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::TooEarly);
+		run_to(7);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+		assert_eq!(paid(1), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+		run_to(8);
+		assert_noop!(Salary::bump(RuntimeOrigin::signed(1)), Error::<Test>::NotYet);
+		run_to(9);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		run_to(11);
+		assert_ok!(Salary::payout_other(RuntimeOrigin::signed(1), 10));
+		assert_eq!(paid(1), 1);
+		assert_eq!(paid(10), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+	});
+}
+
+#[test]
+fn retry_payment_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(1, 1);
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		run_to(6);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		run_to(7);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+
+		// Payment failed.
+		unpay(1, 1);
+		set_status(0, PaymentStatus::Failure);
+
+		assert_eq!(paid(1), 0);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+
+		// Can't just retry.
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+		// Check status.
+		assert_ok!(Salary::check_payment(RuntimeOrigin::signed(1)));
+		// Allowed to try again.
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+
+		assert_eq!(paid(1), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+		run_to(8);
+		assert_noop!(Salary::bump(RuntimeOrigin::signed(1)), Error::<Test>::NotYet);
+		run_to(9);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		run_to(11);
+		assert_ok!(Salary::payout_other(RuntimeOrigin::signed(1), 10));
+		assert_eq!(paid(1), 1);
+		assert_eq!(paid(10), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+	});
+}
+
+#[test]
+fn retry_registered_payment_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(1, 1);
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		run_to(6);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::register(RuntimeOrigin::signed(1)));
+		run_to(7);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+
+		// Payment failed.
+		unpay(1, 1);
+		set_status(0, PaymentStatus::Failure);
+
+		assert_eq!(paid(1), 0);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 0);
+
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+		// Check status.
+		assert_ok!(Salary::check_payment(RuntimeOrigin::signed(1)));
+		// Allowed to try again.
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+
+		assert_eq!(paid(1), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 0);
+	});
+}
+
+#[test]
+fn retry_payment_later_is_not_allowed() {
+	new_test_ext().execute_with(|| {
+		set_rank(1, 1);
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		run_to(6);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		run_to(7);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+
+		// Payment failed.
+		unpay(1, 1);
+		set_status(0, PaymentStatus::Failure);
+
+		assert_eq!(paid(1), 0);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+
+		// Can't just retry.
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+
+		// Next cycle.
+		run_to(9);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+
+		// Payment did fail but now too late to retry.
+		assert_noop!(Salary::check_payment(RuntimeOrigin::signed(1)), Error::<Test>::NotCurrent);
+
+		// We do get this cycle's payout, but we must wait for the payout period to start.
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::TooEarly);
+
+		run_to(11);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+		assert_eq!(paid(1), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+	});
+}
+
+#[test]
+fn retry_payment_later_without_bump_is_allowed() {
+	new_test_ext().execute_with(|| {
+		set_rank(1, 1);
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		run_to(6);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		run_to(7);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+
+		// Payment failed.
+		unpay(1, 1);
+		set_status(0, PaymentStatus::Failure);
+
+		// Next cycle.
+		run_to(9);
+
+		// Payment did fail but we can still retry as long as we don't `bump`.
+		assert_ok!(Salary::check_payment(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+
+		assert_eq!(paid(1), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+	});
+}
+
+#[test]
+fn retry_payment_to_other_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(1, 1);
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		run_to(6);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		run_to(7);
+		assert_ok!(Salary::payout_other(RuntimeOrigin::signed(1), 10));
+
+		// Payment failed.
+		unpay(10, 1);
+		set_status(0, PaymentStatus::Failure);
+
+		// Can't just retry.
+		assert_noop!(Salary::payout_other(RuntimeOrigin::signed(1), 10), Error::<Test>::NoClaim);
+		// Check status.
+		assert_ok!(Salary::check_payment(RuntimeOrigin::signed(1)));
+		// Allowed to try again.
+		assert_ok!(Salary::payout_other(RuntimeOrigin::signed(1), 10));
+
+		assert_eq!(paid(10), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+
+		assert_noop!(Salary::payout_other(RuntimeOrigin::signed(1), 10), Error::<Test>::NoClaim);
+		run_to(8);
+		assert_noop!(Salary::bump(RuntimeOrigin::signed(1)), Error::<Test>::NotYet);
+		run_to(9);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		run_to(11);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+		assert_eq!(paid(1), 1);
+		assert_eq!(paid(10), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+	});
+}
+
+#[test]
+fn registered_payment_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(1, 1);
+		assert_noop!(Salary::induct(RuntimeOrigin::signed(1)), Error::<Test>::NotStarted);
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NotInducted);
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		// No claim on the cycle active during induction.
+		assert_noop!(Salary::register(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+		run_to(3);
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+
+		run_to(5);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::register(RuntimeOrigin::signed(1)));
+		assert_eq!(Salary::status().unwrap().total_registrations, 1);
+		run_to(7);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+		assert_eq!(paid(1), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 0);
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+
+		run_to(9);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_eq!(Salary::status().unwrap().total_registrations, 0);
+		assert_ok!(Salary::register(RuntimeOrigin::signed(1)));
+		assert_eq!(Salary::status().unwrap().total_registrations, 1);
+		run_to(11);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+		assert_eq!(paid(1), 2);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 0);
+	});
+}
+
+#[test]
+fn zero_payment_fails() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		set_rank(1, 0);
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		run_to(7);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::ClaimZero);
+	});
+}
+
+#[test]
+fn unregistered_bankrupcy_fails_gracefully() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		set_rank(1, 2);
+		set_rank(2, 6);
+		set_rank(3, 12);
+
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(3)));
+
+		run_to(7);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(3)));
+
+		assert_eq!(paid(1), 2);
+		assert_eq!(paid(2), 6);
+		assert_eq!(paid(3), 2);
+	});
+}
+
+#[test]
+fn registered_bankrupcy_fails_gracefully() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		set_rank(1, 2);
+		set_rank(2, 6);
+		set_rank(3, 12);
+
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(3)));
+
+		run_to(5);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::register(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::register(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::register(RuntimeOrigin::signed(3)));
+
+		run_to(7);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(3)));
+
+		assert_eq!(paid(1), 1);
+		assert_eq!(paid(2), 3);
+		assert_eq!(paid(3), 6);
+	});
+}
+
+#[test]
+fn mixed_bankrupcy_fails_gracefully() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		set_rank(1, 2);
+		set_rank(2, 6);
+		set_rank(3, 12);
+
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(3)));
+
+		run_to(5);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::register(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::register(RuntimeOrigin::signed(2)));
+
+		run_to(7);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(3)));
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+
+		assert_eq!(paid(1), 2);
+		assert_eq!(paid(2), 6);
+		assert_eq!(paid(3), 2);
+	});
+}
+
+#[test]
+fn other_mixed_bankrupcy_fails_gracefully() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		set_rank(1, 2);
+		set_rank(2, 6);
+		set_rank(3, 12);
+
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(3)));
+
+		run_to(5);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::register(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::register(RuntimeOrigin::signed(3)));
+
+		run_to(7);
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::ClaimZero);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(3)));
+
+		assert_eq!(paid(1), 0);
+		assert_eq!(paid(2), 3);
+		assert_eq!(paid(3), 6);
+	});
+}