tests.rs

			assert_eq!(Staking::next_election_prediction(System::block_number()), 45 + 5);

			Staking::force_new_era(Origin::root()).unwrap();
			assert_eq!(Staking::next_election_prediction(System::block_number()), 45 + 5);

			// Do a fail election
			MinimumValidatorCount::<Test>::put(1000);
			run_to_block(50);
			// Election: failed, next session is a new election
			assert_eq!(Staking::next_election_prediction(System::block_number()), 50 + 5);
			// The new era is still forced until a new era is planned.
			assert_eq!(ForceEra::<Test>::get(), Forcing::ForceNew);

			MinimumValidatorCount::<Test>::put(2);
			run_to_block(55);
			assert_eq!(Staking::next_election_prediction(System::block_number()), 55 + 25);
			assert_eq!(staking_events().len(), 6);
			assert_eq!(
				*staking_events().last().unwrap(),
				Event::StakingElection
			);
			// The new era has been planned, forcing is changed from `ForceNew` to `NotForcing`.
			assert_eq!(ForceEra::<Test>::get(), Forcing::NotForcing);
		})
	}

	#[test]
	#[should_panic]
	fn count_check_works() {
		ExtBuilder::default().build_and_execute(|| {
			// We should never insert into the validators or nominators map directly as this will
			// not keep track of the count. This test should panic as we verify the count is accurate
			// after every test using the `post_checks` in `mock`.
			Validators::<Test>::insert(987654321, ValidatorPrefs::default());
			Nominators::<Test>::insert(987654321, Nominations {
				targets: vec![],
				submitted_in: Default::default(),
				suppressed: false,
			});
		})
	}

	#[test]
	fn min_bond_checks_work() {
		ExtBuilder::default()
			.existential_deposit(100)
			.min_nominator_bond(1_000)
			.min_validator_bond(1_500)
			.build_and_execute(|| {
				// 500 is not enough for any role
				assert_ok!(Staking::bond(Origin::signed(3), 4, 500, RewardDestination::Controller));
				assert_noop!(Staking::nominate(Origin::signed(4), vec![1]), Error::<Test>::InsufficientBond);
				assert_noop!(
					Staking::validate(Origin::signed(4), ValidatorPrefs::default()),
					Error::<Test>::InsufficientBond,
				);

				// 1000 is enough for nominator
				assert_ok!(Staking::bond_extra(Origin::signed(3), 500));
				assert_ok!(Staking::nominate(Origin::signed(4), vec![1]));
				assert_noop!(
					Staking::validate(Origin::signed(4), ValidatorPrefs::default()),
					Error::<Test>::InsufficientBond,
				);

				// 1500 is enough for validator
				assert_ok!(Staking::bond_extra(Origin::signed(3), 500));
				assert_ok!(Staking::nominate(Origin::signed(4), vec![1]));
				assert_ok!(Staking::validate(Origin::signed(4), ValidatorPrefs::default()));

				// Can't unbond anything as validator
				assert_noop!(Staking::unbond(Origin::signed(4), 500), Error::<Test>::InsufficientBond);

				// Once they are a nominator, they can unbond 500
				assert_ok!(Staking::nominate(Origin::signed(4), vec![1]));
				assert_ok!(Staking::unbond(Origin::signed(4), 500));
				assert_noop!(Staking::unbond(Origin::signed(4), 500), Error::<Test>::InsufficientBond);

				// Once they are chilled they can unbond everything
				assert_ok!(Staking::chill(Origin::signed(4)));
				assert_ok!(Staking::unbond(Origin::signed(4), 1000));
			})
	}

	#[test]
	fn chill_other_works() {
		ExtBuilder::default()
			.existential_deposit(100)
			.min_nominator_bond(1_000)
			.min_validator_bond(1_500)
			.build_and_execute(|| {
				for i in 0 .. 15 {
					let a = 4 * i;
					let b = 4 * i + 1;
					let c = 4 * i + 2;
					let d = 4 * i + 3;
					Balances::make_free_balance_be(&a, 100_000);
					Balances::make_free_balance_be(&b, 100_000);
					Balances::make_free_balance_be(&c, 100_000);
					Balances::make_free_balance_be(&d, 100_000);

					// Nominator
					assert_ok!(Staking::bond(Origin::signed(a), b, 1000, RewardDestination::Controller));
					assert_ok!(Staking::nominate(Origin::signed(b), vec![1]));

					// Validator
					assert_ok!(Staking::bond(Origin::signed(c), d, 1500, RewardDestination::Controller));
					assert_ok!(Staking::validate(Origin::signed(d), ValidatorPrefs::default()));
				}

				// To chill other users, we need to:
				// * Set a minimum bond amount
				// * Set a limit
				// * Set a threshold
				//
				// If any of these are missing, we do not have enough information to allow the
				// `chill_other` to succeed from one user to another.

				// Can't chill these users
				assert_noop!(Staking::chill_other(Origin::signed(1337), 1), Error::<Test>::CannotChillOther);
				assert_noop!(Staking::chill_other(Origin::signed(1337), 3), Error::<Test>::CannotChillOther);

				// Change the minimum bond... but no limits.
				assert_ok!(Staking::set_staking_limits(Origin::root(), 1_500, 2_000, None, None, None));

				// Still can't chill these users
				assert_noop!(Staking::chill_other(Origin::signed(1337), 1), Error::<Test>::CannotChillOther);
				assert_noop!(Staking::chill_other(Origin::signed(1337), 3), Error::<Test>::CannotChillOther);

				// Add limits, but no threshold
				assert_ok!(Staking::set_staking_limits(Origin::root(), 1_500, 2_000, Some(10), Some(10), None));

				// Still can't chill these users
				assert_noop!(Staking::chill_other(Origin::signed(1337), 1), Error::<Test>::CannotChillOther);
				assert_noop!(Staking::chill_other(Origin::signed(1337), 3), Error::<Test>::CannotChillOther);

				// Add threshold, but no limits
				assert_ok!(Staking::set_staking_limits(
					Origin::root(), 1_500, 2_000, None, None, Some(Percent::from_percent(0))
				));

				// Still can't chill these users
				assert_noop!(Staking::chill_other(Origin::signed(1337), 1), Error::<Test>::CannotChillOther);
				assert_noop!(Staking::chill_other(Origin::signed(1337), 3), Error::<Test>::CannotChillOther);

				// Add threshold and limits
				assert_ok!(Staking::set_staking_limits(
					Origin::root(), 1_500, 2_000, Some(10), Some(10), Some(Percent::from_percent(75))
				));

				// 16 people total because tests start with 1 active one
				assert_eq!(CounterForNominators::<Test>::get(), 16);
				assert_eq!(CounterForValidators::<Test>::get(), 16);

				// Users can now be chilled down to 7 people, so we try to remove 9 of them (starting with 16)
				for i in 6 .. 15 {
					let b = 4 * i + 1;
					let d = 4 * i + 3;
					assert_ok!(Staking::chill_other(Origin::signed(1337), b));
					assert_ok!(Staking::chill_other(Origin::signed(1337), d));
				}

				// Cant go lower.
				assert_noop!(Staking::chill_other(Origin::signed(1337), 1), Error::<Test>::CannotChillOther);
				assert_noop!(Staking::chill_other(Origin::signed(1337), 3), Error::<Test>::CannotChillOther);
			})
	}

	#[test]
	fn capped_stakers_works() {
		ExtBuilder::default().build_and_execute(|| {
			let validator_count = CounterForValidators::<Test>::get();
			assert_eq!(validator_count, 3);
			let nominator_count = CounterForNominators::<Test>::get();
			assert_eq!(nominator_count, 1);

			// Change the maximums
			let max = 10;
			assert_ok!(Staking::set_staking_limits(
				Origin::root(), 10, 10, Some(max), Some(max), Some(Percent::from_percent(0))
			));

			// can create `max - validator_count` validators
			let mut some_existing_validator = AccountId::default();
			for i in 0 .. max - validator_count {
				let (_, controller) = testing_utils::create_stash_controller::<Test>(
					i + 10_000_000, 100, RewardDestination::Controller,
				).unwrap();
				assert_ok!(Staking::validate(Origin::signed(controller), ValidatorPrefs::default()));
				some_existing_validator = controller;
			}

			// but no more
			let (_, last_validator) = testing_utils::create_stash_controller::<Test>(
				1337, 100, RewardDestination::Controller,
			).unwrap();

			assert_noop!(
				Staking::validate(Origin::signed(last_validator), ValidatorPrefs::default()),
				Error::<Test>::TooManyValidators,
			);

			// same with nominators
			let mut some_existing_nominator = AccountId::default();
			for i in 0 .. max - nominator_count {
				let (_, controller) = testing_utils::create_stash_controller::<Test>(
					i + 20_000_000, 100, RewardDestination::Controller,
				).unwrap();
				assert_ok!(Staking::nominate(Origin::signed(controller), vec![1]));
				some_existing_nominator = controller;
			}

			// one more is too many
			let (_, last_nominator) = testing_utils::create_stash_controller::<Test>(
				30_000_000, 100, RewardDestination::Controller,
			).unwrap();
			assert_noop!(Staking::nominate(Origin::signed(last_nominator), vec![1]), Error::<Test>::TooManyNominators);

			// Re-nominate works fine
			assert_ok!(Staking::nominate(Origin::signed(some_existing_nominator), vec![1]));
			// Re-validate works fine
			assert_ok!(Staking::validate(Origin::signed(some_existing_validator), ValidatorPrefs::default()));

			// No problem when we set to `None` again
			assert_ok!(Staking::set_staking_limits(Origin::root(), 10, 10, None, None, None));
			assert_ok!(Staking::nominate(Origin::signed(last_nominator), vec![1]));
			assert_ok!(Staking::validate(Origin::signed(last_validator), ValidatorPrefs::default()));
		})
	}
}