tests.rs

// Copyright 2021 Axiom-Team
//
// This file is part of Duniter-v2S.
//
// Duniter-v2S is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, version 3 of the License.
//
// Duniter-v2S is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with Duniter-v2S. If not, see <https://www.gnu.org/licenses/>.

use crate::mock::*;
use crate::Weight;
use frame_support::traits::Currency;
use sp_core::Get;

// Note: values for reload rate and max quota defined in mock file
// parameter_types! {
//     pub const ReloadRate: u64 = 10;
//     pub const MaxQuota: u64 = 1000;
// }
// pub const ExistentialDeposit: Balance = 1000;

/// test that quota are well initialized for genesis identities
#[test]
fn test_initial_quota() {
    new_test_ext(QuotaConfig {
        identities: vec![1, 2, 3],
    })
    .execute_with(|| {
        run_to_block(1);

        // quota initialized to 0,0 for a given identity
        assert_eq!(
            Quota::quota(1),
            Some(pallet_quota::Quota {
                last_use: 0,
                amount: 0
            })
        );
        // no initialized quota for standard account
        assert_eq!(Quota::quota(4), None);
    })
}

/// test that quota are updated according to the reload rate and max quota values
#[test]
fn test_update_quota() {
    new_test_ext(QuotaConfig {
        identities: vec![1, 2, 3],
    })
    .execute_with(|| {
        // Block 1
        run_to_block(1);
        assert_eq!(
            Quota::quota(1),
            Some(pallet_quota::Quota {
                last_use: 0,
                amount: 0
            })
        );
        // (spending 0 quota will lead to only update)
        // assert zero quota spent
        assert_eq!(Quota::spend_quota(1, 0), 0);
        assert_eq!(
            Quota::quota(1),
            Some(pallet_quota::Quota {
                last_use: 1, // used at block 1
                // max quota × (current block - last use) / reload rate
                amount: 100 // 1000 × 1 / 10 = 100
            })
        );

        // Block 2
        run_to_block(2);
        assert_eq!(Quota::spend_quota(2, 0), 0);
        assert_eq!(
            Quota::quota(2),
            Some(pallet_quota::Quota {
                last_use: 2, // used at block 2
                // max quota × (current block - last use) / reload rate
                amount: 200 // 1000 × 2 / 10 = 200
            })
        );

        // Block 20
        run_to_block(20);
        assert_eq!(Quota::spend_quota(2, 0), 0);
        assert_eq!(
            Quota::quota(2),
            Some(pallet_quota::Quota {
                last_use: 20, // used at block 20
                // maximum quota is reached
                // 1000 × (20 - 2) / 10 = 1800
                amount: 1000 // min(1000, 1800)
            })
        );
    })
}

/// test that right amount of quota is spent
#[test]
fn test_spend_quota() {
    new_test_ext(QuotaConfig {
        identities: vec![1, 2, 3],
    })
    .execute_with(|| {
        // at block 5, quota are half loaded (500)
        run_to_block(5);
        // spending less than available
        assert_eq!(Quota::spend_quota(1, 200), 200);
        assert_eq!(
            Quota::quota(1),
            Some(pallet_quota::Quota {
                last_use: 5,
                amount: 300 // 500 - 200
            })
        );
        // spending all available
        assert_eq!(Quota::spend_quota(2, 500), 500);
        assert_eq!(
            Quota::quota(2),
            Some(pallet_quota::Quota {
                last_use: 5,
                amount: 0 // 500 - 500
            })
        );
        // spending more than available
        assert_eq!(Quota::spend_quota(3, 1000), 500);
        assert_eq!(
            Quota::quota(3),
            Some(pallet_quota::Quota {
                last_use: 5,
                amount: 0 // 500 - 500
            })
        );
    })
}

/// test complete scenario with queue and process refund queue
#[test]
fn test_process_refund_queue() {
    new_test_ext(QuotaConfig {
        identities: vec![1, 2],
    })
    .execute_with(|| {
        run_to_block(5);
        // give enough currency to accounts and treasury and double check
        Balances::make_free_balance_be(&account(1), 1000);
        Balances::make_free_balance_be(&account(2), 1000);
        Balances::make_free_balance_be(&account(3), 1000);
        Balances::make_free_balance_be(
            &<Test as pallet_quota::Config>::RefundAccount::get(),
            10_000,
        );
        assert_eq!(
            Balances::free_balance(<Test as pallet_quota::Config>::RefundAccount::get()),
            10_000
        );
        // fill in the refund queue
        Quota::queue_refund(pallet_quota::Refund {
            account: account(1),
            identity: 1,
            amount: 10,
        });
        Quota::queue_refund(pallet_quota::Refund {
            account: account(2),
            identity: 2,
            amount: 1000,
        });
        Quota::queue_refund(pallet_quota::Refund {
            account: account(3),
            identity: 3,
            amount: 666,
        });
        // process it
        Quota::process_refund_queue(Weight::from(10));
        // after processing, it should be empty
        assert!(pallet_quota::RefundQueue::<Test>::get().is_empty());
        // and we should observe the effects of refund
        assert_eq!(Balances::free_balance(account(1)), 1010); // 1000 initial + 10 refunded
        assert_eq!(Balances::free_balance(account(2)), 1500); // 1000 initial + 500 refunded
        assert_eq!(Balances::free_balance(account(3)), 1000); // only initial because no available quota
        assert_eq!(
            Balances::free_balance(<Test as pallet_quota::Config>::RefundAccount::get()),
            // initial minus refunds
            10_000 - 500 - 10
        );
        // events
        System::assert_has_event(RuntimeEvent::Quota(pallet_quota::Event::Refunded {
            who: account(1),
            identity: 1,
            amount: 10,
        }));
        System::assert_has_event(RuntimeEvent::Quota(pallet_quota::Event::NoQuotaForIdty(3)));
    })
}

/// test not enough currency in treasury
#[test]
fn test_not_enough_treasury() {
    new_test_ext(QuotaConfig {
        identities: vec![1],
    })
    .execute_with(|| {
        run_to_block(5);
        Balances::make_free_balance_be(&account(1), 1000);
        Balances::make_free_balance_be(&<Test as pallet_quota::Config>::RefundAccount::get(), 1200);
        Quota::queue_refund(pallet_quota::Refund {
            account: account(1),
            identity: 1,
            amount: 500,
        });
        Quota::process_refund_queue(Weight::from(10));
        // refund was not possible, would kill treasury
        assert_eq!(Balances::free_balance(account(1)), 1000);
        assert_eq!(
            Balances::free_balance(<Test as pallet_quota::Config>::RefundAccount::get()),
            1200
        );
        // event
        System::assert_has_event(RuntimeEvent::Quota(
            pallet_quota::Event::NoMoreCurrencyForRefund,
        ));
        // quotas were spent anyway, there is no refund for quotas when refund account is empty
        assert_eq!(
            Quota::quota(1),
            Some(pallet_quota::Quota {
                last_use: 5,
                amount: 0
            })
        );
    })
}

/// test complete scenario with queue and process refund queue weight with available quotas
#[test]
fn test_process_refund_queue_weight_with_quotas() {
    new_test_ext(QuotaConfig {
        identities: vec![1, 2, 3],
    })
    .execute_with(|| {
        run_to_block(15);
        // give enough currency to accounts and treasury and double check
        Balances::make_free_balance_be(&account(1), 1000);
        Balances::make_free_balance_be(&account(2), 1000);
        Balances::make_free_balance_be(&account(3), 1000);
        Balances::make_free_balance_be(
            &<Test as pallet_quota::Config>::RefundAccount::get(),
            10_000,
        );
        assert_eq!(
            Balances::free_balance(<Test as pallet_quota::Config>::RefundAccount::get()),
            10_000
        );
        // fill in the refund queue
        Quota::queue_refund(pallet_quota::Refund {
            account: account(1),
            identity: 10,
            amount: 10,
        });
        Quota::queue_refund(pallet_quota::Refund {
            account: account(2),
            identity: 2,
            amount: 500,
        });
        Quota::queue_refund(pallet_quota::Refund {
            account: account(3),
            identity: 3,
            amount: 666,
        });
        // process it with only no weight
        Quota::process_refund_queue(Weight::from(0));
        // after processing, it should be of the same size
        assert_eq!(pallet_quota::RefundQueue::<Test>::get().len(), 3);
        // process it with only 200 allowed weight
        Quota::process_refund_queue(Weight::from_parts(200u64, 0));
        // after processing, it should be of size 1 because total_weight += 25*2 by iteration and
        // limit is total_weight < 200-100 so 2 elements can be processed
        assert_eq!(pallet_quota::RefundQueue::<Test>::get().len(), 1);
        // and we should observe the effects of refund
        assert_eq!(Balances::free_balance(account(3)), 1666); // 1000 initial + 666 refunded
        assert_eq!(Balances::free_balance(account(2)), 1500); // 1000 initial + 1500 refunded
        assert_eq!(Balances::free_balance(account(1)), 1000); // only initial because no available weight to process
        assert_eq!(
            Balances::free_balance(<Test as pallet_quota::Config>::RefundAccount::get()),
            // initial minus refunds
            10_000 - 666 - 500
        );
        // events
        System::assert_has_event(RuntimeEvent::Quota(pallet_quota::Event::Refunded {
            who: account(3),
            identity: 3,
            amount: 666,
        }));
        System::assert_has_event(RuntimeEvent::Quota(pallet_quota::Event::Refunded {
            who: account(2),
            identity: 2,
            amount: 500,
        }));
    })
}

/// test complete scenario with queue and process refund queue weight with limited quotas
#[test]
fn test_process_refund_queue_weight_no_quotas() {
    new_test_ext(QuotaConfig {
        identities: vec![1, 2],
    })
    .execute_with(|| {
        run_to_block(15);
        // give enough currency to accounts and treasury and double check
        Balances::make_free_balance_be(&account(1), 1000);
        Balances::make_free_balance_be(&account(2), 1000);
        Balances::make_free_balance_be(&account(3), 1000);
        Balances::make_free_balance_be(
            &<Test as pallet_quota::Config>::RefundAccount::get(),
            10_000,
        );
        assert_eq!(
            Balances::free_balance(<Test as pallet_quota::Config>::RefundAccount::get()),
            10_000
        );
        // fill in the refund queue
        Quota::queue_refund(pallet_quota::Refund {
            account: account(1),
            identity: 10,
            amount: 10,
        });
        Quota::queue_refund(pallet_quota::Refund {
            account: account(2),
            identity: 2,
            amount: 500,
        });
        Quota::queue_refund(pallet_quota::Refund {
            account: account(3),
            identity: 3,
            amount: 666,
        });
        // process it with only no weight
        Quota::process_refund_queue(Weight::from(0));
        // after processing, it should be of the same size
        assert_eq!(pallet_quota::RefundQueue::<Test>::get().len(), 3);
        // process it with only 150 allowed weight
        Quota::process_refund_queue(Weight::from_parts(150u64, 0));
        // after processing, it should be of size 2 because try_refund weight is 25 (first in the queue with no quota) then 25*2 for the 2 other elements
        // limit is total_weight < 150-100 so 2 elements can be processed
        assert_eq!(pallet_quota::RefundQueue::<Test>::get().len(), 1);
        // and we should observe the effects of refund
        assert_eq!(Balances::free_balance(account(3)), 1000); // 1000 initial only because no quota available
        assert_eq!(Balances::free_balance(account(2)), 1500); // 1000 initial + 500 refunded
        assert_eq!(Balances::free_balance(account(1)), 1000); // only initial because no available weight to process
        assert_eq!(
            Balances::free_balance(<Test as pallet_quota::Config>::RefundAccount::get()),
            // initial minus refunds
            10_000 - 500
        );
        // events
        System::assert_has_event(RuntimeEvent::Quota(pallet_quota::Event::Refunded {
            who: account(2),
            identity: 2,
            amount: 500,
        }));
    })
}