Add missing tests

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

@@ -14,10 +14,10 @@ use srml_support::dispatch::DispatchResult;
 pub use mock::*;
 
 pub(crate) fn increase_total_balance_issuance(balance: u64) {
-    increase_total_balance_issuance_using_account_id(balance, 999);
+    increase_total_balance_issuance_using_account_id(999, balance);
 }
 
-pub(crate) fn increase_total_balance_issuance_using_account_id(balance: u64, account_id: u64) {
+pub(crate) fn increase_total_balance_issuance_using_account_id(account_id: u64, balance: u64) {
     let initial_balance = Balances::total_issuance();
     {
         let _ = <Test as stake::Trait>::Currency::deposit_creating(&account_id, balance);
@@ -367,7 +367,7 @@ fn get_valid_election_parameters() -> ElectionParameters<u64, u64> {
 #[test]
 fn create_set_election_parameters_call_fails_with_incorrect_parameters() {
     initial_test_ext().execute_with(|| {
-        increase_total_balance_issuance_using_account_id(500000, 1);
+        increase_total_balance_issuance_using_account_id(1, 500000);
 
         let mut election_parameters = get_valid_election_parameters();
         election_parameters.council_size = 2;
@@ -687,7 +687,7 @@ fn create_spending_proposal_common_checks_succeed() {
 #[test]
 fn create_spending_proposal_call_fails_with_incorrect_balance() {
     initial_test_ext().execute_with(|| {
-        increase_total_balance_issuance_using_account_id(1, 500000);
+        increase_total_balance_issuance_using_account_id(500000, 1);
 
         assert_eq!(
             ProposalCodex::create_spending_proposal(
@@ -720,7 +720,7 @@ fn create_spending_proposal_call_fails_with_incorrect_balance() {
 #[test]
 fn create_set_lead_proposal_fails_with_proposed_councilor() {
     initial_test_ext().execute_with(|| {
-        increase_total_balance_issuance_using_account_id(500000, 1);
+        increase_total_balance_issuance_using_account_id(1, 500000);
 
         let lead_account_id = 20;
         <governance::council::Module<Test>>::set_council(

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

@@ -214,7 +214,7 @@ fn update_post_call_succeeds() {
 }
 
 #[test]
-fn update_post_call_failes_because_of_post_edition_limit() {
+fn update_post_call_fails_because_of_post_edition_limit() {
     initial_test_ext().execute_with(|| {
         let discussion_fixture = DiscussionFixture::default();
 
@@ -235,7 +235,7 @@ fn update_post_call_failes_because_of_post_edition_limit() {
 }
 
 #[test]
-fn update_post_call_failes_because_of_the_wrong_author() {
+fn update_post_call_fails_because_of_the_wrong_author() {
     initial_test_ext().execute_with(|| {
         let discussion_fixture = DiscussionFixture::default();
 
@@ -399,3 +399,19 @@ fn add_discussion_thread_fails_because_of_max_thread_by_same_author_in_a_row_lim
         discussion_fixture.create_discussion_and_assert(Err(Error::MaxThreadInARowLimitExceeded));
     });
 }
+
+#[test]
+fn discussion_thread_and_post_counters_are_valid() {
+    initial_test_ext().execute_with(|| {
+        let discussion_fixture = DiscussionFixture::default();
+        let thread_id = discussion_fixture
+            .create_discussion_and_assert(Ok(1))
+            .unwrap();
+
+        let mut post_fixture1 = PostFixture::default_for_thread(thread_id);
+        let _ = post_fixture1.add_post_and_assert(Ok(())).unwrap();
+
+        assert_eq!(Discussions::thread_count(), 1);
+        assert_eq!(Discussions::post_count(), 1);
+    });
+}

runtime-modules/proposals/discussion/src/types.rs

@@ -71,3 +71,32 @@ impl<ThreadAuthorId: Clone> ThreadCounter<ThreadAuthorId> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::types::ThreadCounter;
+
+    #[test]
+    fn thread_counter_increment_works() {
+        let test = ThreadCounter {
+            author_id: 56,
+            counter: 56,
+        };
+        let expected = ThreadCounter {
+            author_id: 56,
+            counter: 57,
+        };
+
+        assert_eq!(expected, test.increment());
+    }
+
+    #[test]
+    fn thread_counter_new_works() {
+        let expected = ThreadCounter {
+            author_id: 56,
+            counter: 1,
+        };
+
+        assert_eq!(expected, ThreadCounter::new(56));
+    }
+}

runtime-modules/proposals/engine/src/lib.rs

@@ -663,7 +663,9 @@ impl<T: Trait> Module<T> {
     // - update proposal status fields (status, finalized_at)
     // - add to pending execution proposal cache if approved
     // - slash and unstake proposal stake if stake exists
+    // - decrease active proposal counter
     // - fire an event
+    // It prints an error message in case of an attempt to finalize the non-active proposal.
     fn finalize_proposal(proposal_id: T::ProposalId, decision_status: ProposalDecisionStatus) {
         Self::decrease_active_proposal_counter();
         <ActiveProposalIds<T>>::remove(&proposal_id.clone());
@@ -719,7 +721,8 @@ impl<T: Trait> Module<T> {
     }
 
     // Calculates required slash based on finalization ProposalDecisionStatus and proposal parameters.
-    fn calculate_slash_balance(
+    // Method visibility allows testing.
+    pub(crate) fn calculate_slash_balance(
         decision_status: &ProposalDecisionStatus,
         proposal_parameters: &ProposalParameters<T::BlockNumber, types::BalanceOf<T>>,
     ) -> types::BalanceOf<T> {

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

@@ -12,6 +12,14 @@ use system::{EventRecord, Phase};
 
 use srml_support::traits::Currency;
 
+pub(crate) fn increase_total_balance_issuance_using_account_id(account_id: u64, balance: u64) {
+    let initial_balance = Balances::total_issuance();
+    {
+        let _ = <Test as stake::Trait>::Currency::deposit_creating(&account_id, balance);
+    }
+    assert_eq!(Balances::total_issuance(), initial_balance + balance);
+}
+
 struct ProposalParametersFixture {
     parameters: ProposalParameters<u64, u64>,
 }
@@ -437,6 +445,9 @@ fn voting_results_calculation_succeeds() {
 #[test]
 fn rejected_voting_results_and_remove_proposal_id_from_active_succeeds() {
     initial_test_ext().execute_with(|| {
+        // internal active proposal counter check
+        assert_eq!(<ActiveProposalCount>::get(), 0);
+
         let dummy_proposal = DummyProposalFixture::default();
         let proposal_id = dummy_proposal.create_proposal_and_assert(Ok(1)).unwrap();
 
@@ -448,6 +459,9 @@ fn rejected_voting_results_and_remove_proposal_id_from_active_succeeds() {
 
         assert!(<ActiveProposalIds<Test>>::exists(proposal_id));
 
+        // internal active proposal counter check
+        assert_eq!(<ActiveProposalCount>::get(), 1);
+
         run_to_block_and_finalize(2);
 
         let proposal = <Proposals<Test>>::get(proposal_id);
@@ -467,6 +481,9 @@ fn rejected_voting_results_and_remove_proposal_id_from_active_succeeds() {
             ProposalStatus::finalized_successfully(ProposalDecisionStatus::Rejected, 1),
         );
         assert!(!<ActiveProposalIds<Test>>::exists(proposal_id));
+
+        // internal active proposal counter check
+        assert_eq!(<ActiveProposalCount>::get(), 0);
     });
 }
 
@@ -555,9 +572,15 @@ fn cancel_proposal_succeeds() {
             DummyProposalFixture::default().with_parameters(parameters_fixture.params());
         let proposal_id = dummy_proposal.create_proposal_and_assert(Ok(1)).unwrap();
 
+        // internal active proposal counter check
+        assert_eq!(<ActiveProposalCount>::get(), 1);
+
         let cancel_proposal = CancelProposalFixture::new(proposal_id);
         cancel_proposal.cancel_and_assert(Ok(()));
 
+        // internal active proposal counter check
+        assert_eq!(<ActiveProposalCount>::get(), 0);
+
         let proposal = <crate::Proposals<Test>>::get(proposal_id);
 
         assert_eq!(
@@ -819,46 +842,6 @@ fn proposal_execution_postponed_because_of_grace_period() {
     });
 }
 
-/*
-
-#[test]
-fn veto_proposal_succeeds() {
-    initial_test_ext().execute_with(|| {
-        // internal active proposal counter check
-        assert_eq!(<ActiveProposalCount>::get(), 0);
-
-        let parameters_fixture = ProposalParametersFixture::default();
-        let dummy_proposal =
-            DummyProposalFixture::default().with_parameters(parameters_fixture.params());
-        let proposal_id = dummy_proposal.create_proposal_and_assert(Ok(1)).unwrap();
-
-        // internal active proposal counter check
-        assert_eq!(<ActiveProposalCount>::get(), 1);
-
-        let veto_proposal = VetoProposalFixture::new(proposal_id);
-        veto_proposal.veto_and_assert(Ok(()));
-
-        let proposal = <crate::Proposals<Test>>::get(proposal_id);
-
-        assert_eq!(
-            proposal,
-            Proposal {
-                parameters: parameters_fixture.params(),
-                proposer_id: 1,
-                created_at: 1,
-                status: ProposalStatus::finalized_successfully(ProposalDecisionStatus::Vetoed, 1),
-                title: b"title".to_vec(),
-                description: b"description".to_vec(),
-                voting_results: VotingResults::default(),
-            }
-        );
-
-        // internal active proposal counter check
-        assert_eq!(<ActiveProposalCount>::get(), 0);
-    });
-}
-*/
-
 #[test]
 fn proposal_execution_vetoed_successfully_during_the_grace_period() {
     initial_test_ext().execute_with(|| {
@@ -1492,3 +1475,107 @@ fn proposal_reset_succeeds() {
         );
     });
 }
+
+#[test]
+fn proposal_counters_are_valid() {
+    initial_test_ext().execute_with(|| {
+        let mut dummy_proposal = DummyProposalFixture::default();
+        let _ = dummy_proposal.create_proposal_and_assert(Ok(1)).unwrap();
+
+        dummy_proposal = DummyProposalFixture::default();
+        let _ = dummy_proposal.create_proposal_and_assert(Ok(2)).unwrap();
+
+        dummy_proposal = DummyProposalFixture::default();
+        let proposal_id = dummy_proposal.create_proposal_and_assert(Ok(3)).unwrap();
+
+        assert_eq!(ActiveProposalCount::get(), 3);
+        assert_eq!(ProposalCount::get(), 3);
+
+        let cancel_proposal_fixture = CancelProposalFixture::new(proposal_id);
+        cancel_proposal_fixture.cancel_and_assert(Ok(()));
+
+        assert_eq!(ActiveProposalCount::get(), 2);
+        assert_eq!(ProposalCount::get(), 3);
+    });
+}
+
+#[test]
+fn proposal_stake_cache_is_valid() {
+    initial_test_ext().execute_with(|| {
+        increase_total_balance_issuance_using_account_id(1, 50000);
+
+        let stake = 250u32;
+        let parameters = ProposalParametersFixture::default().with_required_stake(stake.into());
+        let dummy_proposal = DummyProposalFixture::default()
+            .with_parameters(parameters.params())
+            .with_stake(stake as u64);
+
+        let proposal_id = dummy_proposal.create_proposal_and_assert(Ok(1)).unwrap();
+        let expected_stake_id = 0;
+        assert_eq!(
+            <StakesProposals<Test>>::get(&expected_stake_id),
+            proposal_id
+        );
+    });
+}
+
+#[test]
+fn slash_balance_is_calculated_correctly() {
+    initial_test_ext().execute_with(|| {
+        let vetoed_slash_balance = ProposalsEngine::calculate_slash_balance(
+            &ProposalDecisionStatus::Vetoed,
+            &ProposalParametersFixture::default().params(),
+        );
+
+        assert_eq!(vetoed_slash_balance, 0);
+
+        let approved_slash_balance = ProposalsEngine::calculate_slash_balance(
+            &ProposalDecisionStatus::Approved(ApprovedProposalStatus::Executed),
+            &ProposalParametersFixture::default().params(),
+        );
+
+        assert_eq!(approved_slash_balance, 0);
+
+        let rejection_fee = <Test as crate::Trait>::RejectionFee::get();
+
+        let rejected_slash_balance = ProposalsEngine::calculate_slash_balance(
+            &ProposalDecisionStatus::Rejected,
+            &ProposalParametersFixture::default().params(),
+        );
+
+        assert_eq!(rejected_slash_balance, rejection_fee);
+
+        let expired_slash_balance = ProposalsEngine::calculate_slash_balance(
+            &ProposalDecisionStatus::Expired,
+            &ProposalParametersFixture::default().params(),
+        );
+
+        assert_eq!(expired_slash_balance, rejection_fee);
+
+        let cancellation_fee = <Test as crate::Trait>::CancellationFee::get();
+
+        let cancellation_slash_balance = ProposalsEngine::calculate_slash_balance(
+            &ProposalDecisionStatus::Canceled,
+            &ProposalParametersFixture::default().params(),
+        );
+
+        assert_eq!(cancellation_slash_balance, cancellation_fee);
+
+        let slash_balance_with_no_stake = ProposalsEngine::calculate_slash_balance(
+            &ProposalDecisionStatus::Slashed,
+            &ProposalParametersFixture::default().params(),
+        );
+
+        assert_eq!(slash_balance_with_no_stake, 0);
+
+        let stake = 256;
+        let slash_balance_with_stake = ProposalsEngine::calculate_slash_balance(
+            &ProposalDecisionStatus::Slashed,
+            &ProposalParametersFixture::default()
+                .with_required_stake(stake)
+                .params(),
+        );
+
+        assert_eq!(slash_balance_with_stake, stake);
+    });
+}

runtime-modules/proposals/engine/src/types/proposal_statuses.rs

@@ -148,3 +148,50 @@ pub enum ProposalDecisionStatus {
     /// must be no less than the quorum value for the given proposal type.
     Approved(ApprovedProposalStatus),
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        ActiveStake, ApprovedProposalStatus, FinalizationData, ProposalDecisionStatus,
+        ProposalStatus,
+    };
+
+    #[test]
+    fn approved_proposal_status_helper_succeeds() {
+        let msg = "error";
+
+        assert_eq!(
+            ApprovedProposalStatus::failed_execution(&msg),
+            ApprovedProposalStatus::ExecutionFailed {
+                error: msg.as_bytes().to_vec()
+            }
+        );
+    }
+
+    #[test]
+    fn finalized_proposal_status_helper_succeeds() {
+        let msg = "error";
+        let block_number = 20;
+        let stake = ActiveStake {
+            stake_id: 50,
+            source_account_id: 2,
+        };
+
+        let proposal_status = ProposalStatus::finalized(
+            ProposalDecisionStatus::Slashed,
+            Some(msg),
+            Some(stake),
+            block_number,
+        );
+
+        assert_eq!(
+            ProposalStatus::Finalized(FinalizationData {
+                proposal_status: ProposalDecisionStatus::Slashed,
+                finalized_at: block_number,
+                encoded_unstaking_error_due_to_broken_runtime: Some(msg.as_bytes().to_vec()),
+                stake_data_after_unstaking_error: Some(stake)
+            }),
+            proposal_status
+        );
+    }
+}