Add tests for membership module (MembershipOriginValidator)

runtime-modules/membership/src/lib.rs

@@ -6,5 +6,5 @@ pub mod members;
 pub mod origin_validator;
 pub mod role_types;
 
-mod mock;
+pub(crate) mod mock;
 mod tests;

runtime-modules/membership/src/origin_validator.rs

@@ -1,5 +1,6 @@
 use rstd::marker::PhantomData;
 
+use srml_support::print;
 use system::ensure_signed;
 
 /// Abstract validator for the origin(account_id) and actor_id (eg.: thread author id).
@@ -47,6 +48,7 @@ impl<T: crate::members::Trait>
         let profile_result = <crate::members::Module<T>>::ensure_profile(actor_id);
 
         if let Ok(profile) = profile_result {
+            print("profile");
             // whether the account_id belongs to the actor
             if profile.root_account == account_id || profile.controller_account == account_id {
                 return Ok(account_id);
@@ -56,3 +58,109 @@ impl<T: crate::members::Trait>
         Err(error)
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+    use crate::members::UserInfo;
+    use crate::mock::{Test, TestExternalitiesBuilder};
+    use crate::origin_validator::{ActorOriginValidator, MembershipOriginValidator};
+    use system::RawOrigin;
+
+    type Membership = crate::members::Module<Test>;
+
+    pub fn initial_test_ext() -> runtime_io::TestExternalities {
+        const DEFAULT_FEE: u64 = 500;
+        let initial_members = [1, 2, 3];
+
+        TestExternalitiesBuilder::<Test>::default()
+            .set_membership_config(
+                crate::genesis::GenesisConfigBuilder::default()
+                    .default_paid_membership_fee(DEFAULT_FEE)
+                    .members(initial_members.to_vec())
+                    .build(),
+            )
+            .build()
+    }
+
+    #[test]
+    fn membership_origin_validator_fails_with_unregistered_member() {
+        initial_test_ext().execute_with(|| {
+            let origin = RawOrigin::Signed(1);
+            let member_id = 1;
+            let error = "Error";
+
+            let validation_result = MembershipOriginValidator::<Test>::ensure_actor_origin(
+                origin.into(),
+                member_id,
+                error,
+            );
+
+            assert_eq!(validation_result, Err(error));
+        });
+    }
+
+    #[test]
+    fn membership_origin_validator_succeeds() {
+        initial_test_ext().execute_with(|| {
+            let account_id = 1;
+            let origin = RawOrigin::Signed(account_id);
+            let member_id = 0;
+            let error = "Error";
+            let authority_account_id = 10;
+            Membership::set_screening_authority(RawOrigin::Root.into(), authority_account_id)
+                .unwrap();
+
+            Membership::add_screened_member(
+                RawOrigin::Signed(authority_account_id).into(),
+                account_id,
+                UserInfo {
+                    handle: Some(b"handle".to_vec()),
+                    avatar_uri: None,
+                    about: None,
+                },
+            )
+            .unwrap();
+
+            let validation_result = MembershipOriginValidator::<Test>::ensure_actor_origin(
+                origin.into(),
+                member_id,
+                error,
+            );
+
+            assert_eq!(validation_result, Ok(account_id));
+        });
+    }
+
+    #[test]
+    fn membership_origin_validator_fails_with_incompatible_account_id_and_member_id() {
+        initial_test_ext().execute_with(|| {
+            let account_id = 1;
+            let member_id = 0;
+            let error = "Error";
+            let authority_account_id = 10;
+            Membership::set_screening_authority(RawOrigin::Root.into(), authority_account_id)
+                .unwrap();
+
+            Membership::add_screened_member(
+                RawOrigin::Signed(authority_account_id).into(),
+                account_id,
+                UserInfo {
+                    handle: Some(b"handle".to_vec()),
+                    avatar_uri: None,
+                    about: None,
+                },
+            )
+            .unwrap();
+
+            let invalid_account_id = 2;
+            let validation_result = MembershipOriginValidator::<Test>::ensure_actor_origin(
+                RawOrigin::Signed(invalid_account_id).into(),
+                member_id,
+                error,
+            );
+
+            assert_eq!(validation_result, Err(error));
+        });
+    }
+}

runtime-modules/proposals/discussion/src/tests/mock.rs

@@ -59,17 +59,13 @@ parameter_types! {
 }
 
 impl balances::Trait for Test {
-    /// The type for recording an account's balance.
     type Balance = u64;
     /// What to do if an account's free balance gets zeroed.
     type OnFreeBalanceZero = ();
-    /// What to do if a new account is created.
     type OnNewAccount = ();
-
-    type Event = TestEvent;
-
-    type DustRemoval = ();
     type TransferPayment = ();
+    type DustRemoval = ();
+    type Event = TestEvent;
     type ExistentialDeposit = ExistentialDeposit;
     type TransferFee = TransferFee;
     type CreationFee = CreationFee;
@@ -120,9 +116,9 @@ impl ActorOriginValidator<Origin, u64, u64> for () {
 
 impl system::Trait for Test {
     type Origin = Origin;
+    type Call = ();
     type Index = u64;
     type BlockNumber = u64;
-    type Call = ();
     type Hash = H256;
     type Hashing = BlakeTwo256;
     type AccountId = u64;

runtime-modules/proposals/discussion/src/tests/mod.rs

@@ -86,6 +86,13 @@ impl DiscussionFixture {
         DiscussionFixture { author_id, ..self }
     }
 
+    fn with_origin(self, origin: RawOrigin<u64>) -> Self {
+        DiscussionFixture {
+            origin: origin.into(),
+            ..self
+        }
+    }
+
     fn create_discussion_and_assert(&self, result: Result<u32, &'static str>) -> Option<u32> {
         let create_discussion_result = Discussions::create_thread(
             self.origin.clone().into(),
@@ -417,7 +424,11 @@ fn add_discussion_thread_fails_because_of_max_thread_by_same_author_in_a_row_lim
 fn add_discussion_thread_fails_because_of_invalid_author_origin() {
     initial_test_ext().execute_with(|| {
         let discussion_fixture = DiscussionFixture::default().with_author(2);
+        discussion_fixture.create_discussion_and_assert(Err(MSG_INVALID_THREAD_AUTHOR_ORIGIN));
 
+        let discussion_fixture = DiscussionFixture::default()
+            .with_origin(RawOrigin::Signed(3))
+            .with_author(2);
         discussion_fixture.create_discussion_and_assert(Err(MSG_INVALID_THREAD_AUTHOR_ORIGIN));
     });
 }

runtime-modules/proposals/engine/src/tests/mock/mod.rs

@@ -123,7 +123,11 @@ impl crate::Trait for Test {
 }
 
 impl membership::origin_validator::ActorOriginValidator<Origin, u64, u64> for () {
-    fn ensure_actor_origin(origin: Origin, _account_id: u64, _: &'static str) -> Result<u64, &'static str> {
+    fn ensure_actor_origin(
+        origin: Origin,
+        _account_id: u64,
+        _: &'static str,
+    ) -> Result<u64, &'static str> {
         let signed_account_id = system::ensure_signed(origin)?;
 
         Ok(signed_account_id)

runtime-modules/proposals/engine/src/tests/mod.rs

@@ -291,7 +291,6 @@ fn create_dummy_proposal_succeeds() {
 fn create_dummy_proposal_fails_with_insufficient_rights() {
     initial_test_ext().execute_with(|| {
         let dummy_proposal = DummyProposalFixture::default().with_origin(RawOrigin::None);
-
         dummy_proposal.create_proposal_and_assert(Err("RequireSignedOrigin"));
     });
 }