inital commit, which is clearly not initial

Signed-off-by: Uncle Stretch <uncle.stretch@ghostchain.io>

pallets/slow-clap/src/mock.rs

@@ -0,0 +1,253 @@
+#![cfg(test)]
+
+use frame_support::{
+    derive_impl, parameter_types,
+    traits::{ConstU32, ConstU64},
+    weights::Weight,
+    PalletId,
+};
+use frame_system::EnsureRoot;
+use pallet_session::historical as pallet_session_historical;
+use sp_runtime::{
+    testing::{TestXt, UintAuthorityId},
+    traits::ConvertInto,
+    BuildStorage, Permill,
+};
+use sp_staking::{
+    offence::{OffenceError, ReportOffence},
+    SessionIndex,
+};
+
+use crate as slow_clap;
+use crate::Config;
+
+type Block = frame_system::mocking::MockBlock<Runtime>;
+
+frame_support::construct_runtime!(
+    pub enum Runtime {
+        System: frame_system,
+        Session: pallet_session,
+        Historical: pallet_session_historical,
+        Balances: pallet_balances,
+        Networks: ghost_networks,
+        SlowClap: slow_clap,
+    }
+);
+
+parameter_types! {
+    pub static Validators: Option<Vec<u64>> = Some(vec![
+        1, 
+        2, 
+        3,
+    ]);
+}
+
+pub struct TestSessionManager;
+impl pallet_session::SessionManager<u64> for TestSessionManager {
+    fn new_session(_new_index: SessionIndex) -> Option<Vec<u64>> {
+        Validators::mutate(|l| l.take())
+    }
+    fn end_session(_: SessionIndex) {}
+    fn start_session(_: SessionIndex) {}
+}
+
+impl pallet_session::historical::SessionManager<u64, u64> for TestSessionManager {
+    fn new_session(_new_index: SessionIndex) -> Option<Vec<(u64, u64)>> {
+        Validators::mutate(|l| l
+            .take()
+            .map(|validators| validators
+                .iter()
+                .map(|v| (*v, *v))
+                .collect())
+        )
+    }
+    fn end_session(_: SessionIndex) {}
+    fn start_session(_: SessionIndex) {}
+}
+
+type IdentificationTuple = (u64, u64);
+type Offence = crate::ThrottlingOffence<IdentificationTuple>;
+
+parameter_types! {
+    pub static Offences: Vec<(Vec<u64>, Offence)> = vec![];
+}
+
+pub struct OffenceHandler;
+impl ReportOffence<u64, IdentificationTuple, Offence> for OffenceHandler {
+    fn report_offence(reporters: Vec<u64>, offence: Offence) -> Result<(), OffenceError> {
+        Offences::mutate(|l| l.push((reporters, offence)));
+        Ok(())
+    }
+
+    fn is_known_offence(_offenders: &[IdentificationTuple], _time_slot: &SessionIndex) -> bool {
+        false
+    }
+}
+
+pub fn alice_account_id() -> <Runtime as frame_system::Config>::AccountId { 69 }
+pub fn eve_account_id() -> <Runtime as frame_system::Config>::AccountId { 1337 }
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let mut t = frame_system::GenesisConfig::<Runtime>::default()
+        .build_storage()
+        .unwrap();
+
+    pallet_balances::GenesisConfig::<Runtime> {
+        balances: vec![ (alice_account_id(), 100) ],
+    }
+        .assimilate_storage(&mut t)
+        .unwrap();
+
+    let mut result = sp_io::TestExternalities::new(t);
+
+    result.execute_with(|| {
+        System::set_block_number(1);
+    });
+
+    result
+}
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Runtime {
+    type Block = Block;
+    type AccountData = pallet_balances::AccountData<u64>;
+}
+
+parameter_types! {
+    pub const Period: u64 = 1;
+    pub const Offset: u64 = 0;
+}
+
+impl pallet_session::Config for Runtime {
+    type ShouldEndSession = pallet_session::PeriodicSessions<Period, Offset>;
+    type SessionManager =
+        pallet_session::historical::NoteHistoricalRoot<Runtime, TestSessionManager>;
+    type SessionHandler = (SlowClap,);
+    type ValidatorId = u64;
+    type ValidatorIdOf = ConvertInto;
+    type Keys = UintAuthorityId;
+    type RuntimeEvent = RuntimeEvent;
+    type NextSessionRotation = pallet_session::PeriodicSessions<Period, Offset>;
+    type WeightInfo = ();
+}
+
+impl pallet_session::historical::Config for Runtime {
+    type FullIdentification = u64;
+    type FullIdentificationOf = ConvertInto;
+}
+
+parameter_types! {
+    pub static MockCurrentSessionProgress: Option<Option<Permill>> = None;
+}
+
+parameter_types! {
+    pub static MockAverageSessionLength: Option<u64> = None;
+}
+
+pub struct TestNextSessionRotation;
+impl frame_support::traits::EstimateNextSessionRotation<u64> for TestNextSessionRotation {
+    fn average_session_length() -> u64 {
+        let mock = MockAverageSessionLength::mutate(|p| p.take());
+        mock.unwrap_or(pallet_session::PeriodicSessions::<Period, Offset>::average_session_length())
+    }
+
+    fn estimate_current_session_progress(now: u64) -> (Option<Permill>, Weight) {
+        let (estimate, weight) = 
+            pallet_session::PeriodicSessions::<Period, Offset>::estimate_current_session_progress(
+                now,
+            );
+        let mock = MockCurrentSessionProgress::mutate(|p| p.take());
+        (mock.unwrap_or(estimate), weight)
+    }
+
+    fn estimate_next_session_rotation(now: u64) -> (Option<u64>, Weight) {
+        pallet_session::PeriodicSessions::<Period, Offset>::estimate_next_session_rotation(now)
+    }
+}
+
+impl ghost_networks::Config for Runtime {
+    type RuntimeEvent = RuntimeEvent;
+    type NetworkId = u32;
+    type RegisterOrigin = EnsureRoot<Self::AccountId>;
+    type UpdateOrigin = EnsureRoot<Self::AccountId>;
+    type RemoveOrigin = EnsureRoot<Self::AccountId>;
+    type WeightInfo = ();
+}
+
+parameter_types! {
+    pub static ExistentialDeposit: u64 = 2;
+    pub const TreasuryPalletId: PalletId = PalletId(*b"mck/test");
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Runtime {
+    type ExistentialDeposit = ExistentialDeposit;
+    type MaxReserves = ConstU32<2>;
+    type AccountStore = System;
+    type WeightInfo = ();
+}
+
+impl Config for Runtime {
+    type RuntimeEvent = RuntimeEvent;
+    type AuthorityId = UintAuthorityId;
+
+    type NextSessionRotation = TestNextSessionRotation;
+    type ValidatorSet = Historical;
+    type Currency = Balances;
+    type NetworkDataHandler = Networks;
+    type BlockNumberProvider = System;
+    type ReportUnresponsiveness = OffenceHandler;
+
+    type MaxAuthorities = ConstU32<5>;
+    type MaxNumberOfClaps = ConstU32<100>;
+    type ApplauseThreshold = ConstU32<0>;
+    type MaxAuthorityInfoInSession = ConstU32<5_000>;
+    type OffenceThreshold = ConstU32<40>;
+    type UnsignedPriority = ConstU64<{ 1 << 20 }>;
+    type TreasuryPalletId = TreasuryPalletId;
+
+    type WeightInfo = ();
+}
+
+pub type Extrinsic = TestXt<RuntimeCall, ()>;
+
+// impl frame_system::offchain::SigningTypes for Runtime {
+//     type Public = <Signature as Verify>::Signer;
+//     type Signature = Signature;
+// }
+
+impl<LocalCall> frame_system::offchain::SendTransactionTypes<LocalCall> for Runtime
+where
+    RuntimeCall: From<LocalCall>,
+{
+    type OverarchingCall = RuntimeCall;
+    type Extrinsic = Extrinsic;
+}
+
+// impl<LocalCall> frame_system::offchain::CreateSignedTransaction<LocalCall> for Runtime 
+// where
+//     RuntimeCall: From<LocalCall>,
+// {
+//     fn create_transaction<C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>>(
+//             call: Self::OverarchingCall,
+//             _public: Self::Public,
+//             _account: Self::AccountId,
+//             nonce: Self::Nonce,
+//         ) -> Option<(RuntimeCall, <Extrinsic as ExtrinsicT>::SignaturePayload)> {
+//         Some((call, (nonce.into(), ())))
+//     }
+// }
+
+// pub fn advance_session() {
+//     let now = System::block_number().max(1);
+//     System::set_block_number(now + 1);
+//     Session::rotate_session();
+//
+//     let authorities = Session::validators()
+//         .into_iter()
+//         .map(UintAuthorityId)
+//         .collect();
+//
+//     SlowClap::set_authorities(authorities);
+//     assert_eq!(Session::current_index(), (now / Period::get()) as u32);
+// }