added *-remark tests

runtime-modules/council/src/mock.rs

@@ -684,6 +684,23 @@ pub fn default_genesis_config() -> GenesisConfig<Runtime> {
     }
 }
 
+pub fn augmented_genesis_config() -> GenesisConfig<Runtime> {
+    GenesisConfig::<Runtime> {
+        stage: CouncilStageUpdate::default(),
+        council_members: vec![CouncilMemberOf::<Runtime> {
+            membership_id: 1,
+            ..Default::default()
+        }],
+        candidates: vec![(2, Default::default())],
+        announcement_period_nr: 0,
+        budget: 0,
+        next_reward_payments: 0,
+        next_budget_refill: <Runtime as Trait>::BudgetRefillPeriod::get(),
+        budget_increment: 1,
+        councilor_reward: 100,
+    }
+}
+
 pub fn build_test_externalities(config: GenesisConfig<Runtime>) -> sp_io::TestExternalities {
     let mut t = frame_system::GenesisConfig::default()
         .build_storage::<Runtime>()

runtime-modules/council/src/tests.rs

@@ -8,7 +8,7 @@ use crate::mock::*;
 use common::council::CouncilBudgetManager;
 use common::council::CouncilOriginValidator;
 use frame_support::traits::Currency;
-use frame_support::StorageValue;
+use frame_support::{assert_err, assert_ok, StorageValue};
 use frame_system::RawOrigin;
 use staking_handler::StakingHandler;
 
@@ -1805,3 +1805,85 @@ fn test_council_budget_manager_works_correctlyl() {
         );
     });
 }
+
+#[test]
+fn councilor_remark_successful() {
+    let config = augmented_genesis_config();
+
+    build_test_externalities(config).execute_with(|| {
+        let account_id = 1;
+        let member_id = 1;
+        let msg = b"test".to_vec();
+        let origin = RawOrigin::Signed(account_id.clone());
+
+        assert_ok!(Council::councilor_remark(origin.into(), member_id, msg));
+    });
+}
+
+#[test]
+fn councilor_remark_unsuccessful_with_invalid_origin() {
+    let config = augmented_genesis_config();
+
+    build_test_externalities(config).execute_with(|| {
+        let account_id = 21;
+        let member_id = 1;
+        let msg = b"test".to_vec();
+        let origin = RawOrigin::Signed(account_id.clone());
+
+        assert_err!(
+            Council::councilor_remark(origin.into(), member_id, msg),
+            Error::<Runtime>::MemberIdNotMatchAccount,
+        );
+    });
+}
+
+#[test]
+fn councilor_remark_unsuccessful_with_invalid_councilor() {
+    let config = default_genesis_config();
+
+    build_test_externalities(config).execute_with(|| {
+        let account_id = 2;
+        let member_id = 2;
+        let msg = b"test".to_vec();
+        let origin = RawOrigin::Signed(account_id.clone());
+
+        assert_err!(
+            Council::councilor_remark(origin.into(), member_id, msg),
+            Error::<Runtime>::NotCouncilor,
+        );
+    });
+}
+
+#[test]
+fn candidate_remark_unsuccessful_with_invalid_candidate() {
+    let config = default_genesis_config();
+
+    build_test_externalities(config).execute_with(|| {
+        let account_id = 2;
+        let member_id = 2;
+        let msg = b"test".to_vec();
+        let origin = RawOrigin::Signed(account_id.clone());
+
+        assert_err!(
+            Council::candidate_remark(origin.into(), member_id, msg),
+            Error::<Runtime>::CandidateDoesNotExist,
+        );
+    });
+}
+
+#[test]
+fn candidate_remark_unsuccessful_with_invalid_origin() {
+    let config = default_genesis_config();
+
+    build_test_externalities(config).execute_with(|| {
+        let account_id = 21;
+        let member_id = 2;
+        let msg = b"test".to_vec();
+        let origin = RawOrigin::Signed(account_id.clone());
+
+        assert_err!(
+            Council::candidate_remark(origin.into(), member_id, msg),
+            Error::<Runtime>::MemberIdNotMatchAccount,
+        );
+    });
+}

runtime-modules/storage/src/tests/mod.rs

@@ -5710,6 +5710,42 @@ fn storage_operator_remark_unsuccessful_with_invalid_bucket_id() {
     })
 }
 
+#[test]
+fn storage_operator_remark_unsuccessful_with_invalid_origin() {
+    build_test_externalities().execute_with(|| {
+        run_to_block(1);
+
+        let msg = b"test".to_vec();
+        let storage_provider_id = DEFAULT_STORAGE_PROVIDER_ID;
+        let invite_worker = Some(storage_provider_id);
+        let transactor_id = DEFAULT_STORAGE_PROVIDER_ACCOUNT_ID;
+
+        let bucket_id = CreateStorageBucketFixture::default()
+            .with_origin(RawOrigin::Signed(STORAGE_WG_LEADER_ACCOUNT_ID))
+            .with_invite_worker(invite_worker)
+            .call_and_assert(Ok(()))
+            .unwrap();
+
+        AcceptStorageBucketInvitationFixture::default()
+            .with_origin(RawOrigin::Signed(DEFAULT_STORAGE_PROVIDER_ACCOUNT_ID))
+            .with_storage_bucket_id(bucket_id)
+            .with_worker_id(storage_provider_id)
+            .with_transactor_account_id(transactor_id)
+            .call_and_assert(Ok(()));
+
+        let invalid_origin = RawOrigin::Signed(DEFAULT_STORAGE_PROVIDER_ACCOUNT_ID + 100).into();
+        assert_err!(
+            Storage::storage_operator_remark(
+                invalid_origin,
+                DEFAULT_STORAGE_PROVIDER_ID,
+                bucket_id,
+                msg
+            ),
+            DispatchError::BadOrigin,
+        );
+    })
+}
+
 #[test]
 fn storage_operator_remark_unsuccessful_with_invalid_worker_id() {
     build_test_externalities().execute_with(|| {
@@ -5886,3 +5922,54 @@ fn distribution_operator_remark_unsuccessful_with_invalid_worker_id() {
         );
     })
 }
+
+#[test]
+fn distribution_operator_remark_unsuccessful_with_invalid_origin() {
+    build_test_externalities().execute_with(|| {
+        run_to_block(1);
+
+        let invalid_distribution_worker_id = DEFAULT_DISTRIBUTION_PROVIDER_ID.saturating_add(1);
+        let msg = b"test".to_vec();
+
+        let distribution_bucket_family_id = CreateDistributionBucketFamilyFixture::default()
+            .with_origin(RawOrigin::Signed(DISTRIBUTION_WG_LEADER_ACCOUNT_ID))
+            .call_and_assert(Ok(()))
+            .unwrap();
+
+        let distribution_bucket_index = CreateDistributionBucketFixture::default()
+            .with_family_id(distribution_bucket_family_id)
+            .with_origin(RawOrigin::Signed(DISTRIBUTION_WG_LEADER_ACCOUNT_ID))
+            .call_and_assert(Ok(()))
+            .unwrap();
+
+        InviteDistributionBucketOperatorFixture::default()
+            .with_origin(RawOrigin::Signed(DISTRIBUTION_WG_LEADER_ACCOUNT_ID))
+            .with_bucket_index(distribution_bucket_index)
+            .with_family_id(distribution_bucket_family_id)
+            .with_operator_worker_id(DEFAULT_DISTRIBUTION_PROVIDER_ID)
+            .call_and_assert(Ok(()));
+
+        AcceptDistributionBucketInvitationFixture::default()
+            .with_origin(RawOrigin::Signed(DEFAULT_DISTRIBUTION_PROVIDER_ACCOUNT_ID))
+            .with_family_id(distribution_bucket_family_id)
+            .with_bucket_index(distribution_bucket_index)
+            .with_worker_id(DEFAULT_DISTRIBUTION_PROVIDER_ID)
+            .call_and_assert(Ok(()));
+
+        let invalid_origin =
+            RawOrigin::Signed(DEFAULT_DISTRIBUTION_PROVIDER_ACCOUNT_ID + 100).into();
+
+        assert_err!(
+            Storage::distribution_operator_remark(
+                invalid_origin,
+                invalid_distribution_worker_id,
+                DistributionBucketId::<Test> {
+                    distribution_bucket_family_id,
+                    distribution_bucket_index,
+                },
+                msg
+            ),
+            DispatchError::BadOrigin,
+        );
+    })
+}