Quota pallet benchmark

pallets/quota/src/benchmarking.rs

@@ -18,47 +18,138 @@
 
 use super::*;
 use frame_benchmarking::{account, benchmarks};
+use sp_runtime::traits::One;
 
-// FIXME this is a naïve implementation of benchmarks:
-// - without properly prepare data
-// - without "verify" blocks
-// - without thinking about worst case scenario
-// - without writing complexity in the term of refund queue length
-// It's there as a seed for benchmark implementation and to use WeightInfo where needed.
+fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+    frame_system::Pallet::<T>::assert_has_event(generic_event.into());
+}
 
 benchmarks! {
     where_clause {
         where
             IdtyId<T>: From<u32>,
             BalanceOf<T>: From<u64>,
+            T::AccountId: From<[u8; 32]>,
     }
     queue_refund {
         let account: T::AccountId = account("Alice", 1, 1);
+        let dummy_refund = Refund {
+            account: account.clone(),
+            identity: 0u32.into(),
+            amount: 20u64.into(),
+        };
         let refund = Refund {
             account,
             identity: 1u32.into(),
             amount: 10u64.into(),
         };
-    }: { Pallet::<T>::queue_refund(refund) }
+        // Complexity is bound to MAX_QUEUD_REFUNDS where an insertion is O(n-1)
+        for i in 0..MAX_QUEUED_REFUNDS-1 {
+            Pallet::<T>::queue_refund(dummy_refund.clone())
+        }
+    }: { Pallet::<T>::queue_refund(refund.clone()) }
+    verify {
+        assert_eq!(RefundQueue::<T>::get().last(), Some(refund).as_ref());
+        assert_eq!(RefundQueue::<T>::get().len() as u32, MAX_QUEUED_REFUNDS);
+    }
     spend_quota {
-        let idty_id = 1u32;
-        let amount = 1u64;
+        let idty_id: IdtyId<T> = 1u32.into();
+        let amount = 2u64;
+        let quota_amount = 10u64;
+        IdtyQuota::<T>::insert(
+            idty_id,
+            Quota {
+                last_use: T::BlockNumber::zero(),
+                amount: quota_amount.into(),
+            },
+        );
     }: { Pallet::<T>::spend_quota(idty_id.into(), amount.into()) }
+    verify {
+        let quota_growth = sp_runtime::Perbill::from_rational(
+            T::BlockNumber::one(),
+            T::ReloadRate::get(),
+        ).mul_floor(T::MaxQuota::get());
+        assert_eq!(IdtyQuota::<T>::get(idty_id).unwrap().amount,  quota_growth +quota_amount.into() - amount.into());
+    }
     try_refund {
         let account: T::AccountId = account("Alice", 1, 1);
+        let idty_id: IdtyId<T> = 1u32.into();
+        IdtyQuota::<T>::insert(
+            idty_id,
+            Quota {
+                last_use: T::BlockNumber::zero(),
+                amount: 10u64.into(),
+            },
+        );
+        let _ = CurrencyOf::<T>:: make_free_balance_be(
+                &T::RefundAccount::get(),u32::MAX.into(),
+            );
+        // The worst-case scenario is when the refund fails
+        // and can only be triggered if the account is dead,
+        // in this case by having no balance in the account.
         let refund = Refund {
-            account,
+            account: account.clone(),
             identity: 1u32.into(),
             amount: 10u64.into(),
         };
     }: { Pallet::<T>::try_refund(refund) }
+    verify {
+        assert_has_event::<T>(Event::<T>::RefundFailed ( account ).into());
+    }
     do_refund {
         let account: T::AccountId = account("Alice", 1, 1);
+        let _ = CurrencyOf::<T>:: make_free_balance_be(
+                &T::RefundAccount::get(),u32::MAX.into(),
+            );
+        // The worst-case scenario is when the refund fails
+        // and can only be triggered if the account is dead,
+        // in this case by having no balance in the account.
         let refund = Refund {
-            account,
+            account: account.clone(),
             identity: 1u32.into(),
             amount: 10u64.into(),
         };
-        let amount = 5u64.into();
-    }: { Pallet::<T>::do_refund(refund, amount) }
+    }: { Pallet::<T>::try_refund(refund) }
+    verify {
+        assert_has_event::<T>(Event::<T>::RefundFailed ( account ).into());
+    }
+    // The base weight consumed on processing refund queue when empty.
+    on_process_refund_queue {
+        assert_eq!(RefundQueue::<T>::get().len() as u32, 0);
+    }: { Pallet::<T>::process_refund_queue(Weight::MAX) }
+    // The weight consumed on processing refund queue with one element.
+    // Can deduce the process_refund_queue overhead by subtracting try_refund weight.
+    #[pov_mode = Measured]
+    on_process_refund_queue_elements {
+        let i in 1..MAX_QUEUED_REFUNDS;
+        let account: T::AccountId = account("Alice", 1, 1);
+        let idty_id: IdtyId<T> = 1u32.into();
+        IdtyQuota::<T>::insert(
+            idty_id,
+            Quota {
+                last_use: T::BlockNumber::zero(),
+                amount: 10u64.into(),
+            },
+        );
+        let _ = CurrencyOf::<T>:: make_free_balance_be(
+                &T::RefundAccount::get(),u32::MAX.into(),
+            );
+        // The worst-case scenario is when the refund fails
+        // and can only be triggered if the account is dead,
+        // in this case by having no balance in the account.
+        let refund = Refund {
+            account: account.clone(),
+            identity: 1u32.into(),
+            amount: 10u64.into(),
+        };
+        for _ in 0..i {
+            Pallet::<T>::queue_refund(refund.clone());
+        }
+        assert_eq!(RefundQueue::<T>::get().len() as u32, i);
+    }: { Pallet::<T>::process_refund_queue(Weight::MAX) }
+    verify {
+        assert_eq!(RefundQueue::<T>::get().len() as u32, 0);
+        assert_has_event::<T>(Event::<T>::RefundFailed ( account ).into());
+    }
+    impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(crate::mock::QuotaConfig{identities: vec![1, 2]}), crate::mock::Test);
 }