tests(live): add sanity tests against gdev live chain

The goal is to execute theses tests on a regular basis against the real gdev storage with a scheduled pipeline.

live-tests/tests/sanity_gdev.rs

@@ -46,6 +46,11 @@ type IdtyValue =
     gdev_runtime::runtime_types::pallet_identity::types::IdtyValue<BlockNumber, AccountId32>;
 use gdev_runtime::runtime_types::pallet_identity::types::IdtyStatus;
 
+struct Storage {
+    accounts: HashMap<AccountId32, AccountInfo>,
+    identities: HashMap<IdtyIndex, IdtyValue>,
+}
+
 #[tokio::test(flavor = "current_thread")]
 async fn main() -> anyhow::Result<()> {
     let ws_rpc_endpoint =
@@ -87,6 +92,7 @@ async fn sanity_tests_at(client: Client, maybe_block_hash: Option<H256>) -> anyh
         account_id_bytes.copy_from_slice(&key.0[48..]);
         accounts.insert(AccountId32::new(account_id_bytes), account_info);
     }
+    println!("{} accounts.", accounts.len());
 
     // Collect identities
     let mut identities = HashMap::new();
@@ -100,90 +106,138 @@ async fn sanity_tests_at(client: Client, maybe_block_hash: Option<H256>) -> anyh
         idty_index_bytes.copy_from_slice(&key.0[40..]);
         identities.insert(IdtyIndex::from_le_bytes(idty_index_bytes), idty_value);
     }
+    println!("{} identities.", identities.len());
 
-    // ===== Verify storage ===== //
+    let storage = Storage {
+        accounts,
+        identities,
+    };
 
-    verify_accounts(&accounts).await?;
-    verify_identities(&accounts, &identities).await?;
+    // ===== Verify storage ===== //
 
-    Ok(())
+    verifier::Verifier::new().verify_storage(&storage).await
 }
 
-async fn verify_accounts(accounts: &HashMap<AccountId32, AccountInfo>) -> anyhow::Result<()> {
-    for (account_id, account_info) in accounts {
-        if account_info.sufficients == 0 {
-            // Rule 1: If the account is not sufficient, it should have at least one provider
-            assert!(
-                account_info.providers > 0,
-                "Account {} has no providers nor sufficients",
-                account_id
-            );
-            // Rule 2: If the account is not sufficient, it should comply to the existential deposit
-            assert!(
-                (account_info.data.free + account_info.data.reserved) >= 200,
-                "Account {} not respect existential deposit rule",
-                account_id
-            );
+mod verifier {
+    use super::*;
+
+    pub(super) struct Verifier {
+        errors: Vec<String>,
+    }
+
+    impl Verifier {
+        pub(super) fn new() -> Self {
+            Self { errors: Vec::new() }
         }
 
-        // Rule 3: If the account have consumers, it shoul have at least one provider
-        if account_info.consumers > 0 {
-            // Rule 1: If the account is not s
-            assert!(
-                account_info.providers > 0,
-                "Account {} has no providers nor sufficients",
-                account_id
-            );
+        pub(super) async fn verify_storage(&mut self, storage: &Storage) -> anyhow::Result<()> {
+            self.verify_accounts(&storage.accounts).await?;
+            self.verify_identities(&storage.accounts, &storage.identities)
+                .await?;
+
+            if self.errors.is_empty() {
+                Ok(())
+            } else {
+                for error in &self.errors {
+                    println!("{}", error);
+                }
+                Err(anyhow::anyhow!(
+                    "Storage corrupted: {} errors.",
+                    self.errors.len()
+                ))
+            }
         }
 
-        if account_id.as_slice() != TREASURY_ACCOUNT_ID {
-            // Rule 4: If the account is not a "special account",
-            // it should have a random id or a consumer
-            assert!(
-                account_info.data.random_id.is_some() || account_info.consumers > 0,
-                "Account {} has no random_id nor consumer",
-                account_id
-            );
+        fn assert(&mut self, assertion: bool, error: String) {
+            if !assertion {
+                self.errors.push(error);
+            }
         }
-    }
-    Ok(())
-}
 
-async fn verify_identities(
-    accounts: &HashMap<AccountId32, AccountInfo>,
-    identities: &HashMap<IdtyIndex, IdtyValue>,
-) -> anyhow::Result<()> {
-    for (idty_index, idty_value) in identities {
-        // Rule 1: each identity should have an account
-        let idty_account = accounts
-            .get(&idty_value.owner_key)
-            .unwrap_or_else(|| panic!("Identity {} has no account", idty_index));
-
-        // Rule 2: each identity account should be sufficient
-        assert!(
-            idty_account.sufficients > 0,
-            "Identity {} is corrupted: idty_account.sufficients == 0",
-            idty_index
-        );
-
-        match idty_value.status {
-            IdtyStatus::Validated => {
-                // Rule 3: If the identity is validated, removable_on shoud be zero
-                assert!(
-                    idty_value.removable_on == 0,
-                    "Identity {} is corrupted: removable_on > 0 on validated idty",
-                    idty_index
-                );
+        async fn verify_accounts(
+            &mut self,
+            accounts: &HashMap<AccountId32, AccountInfo>,
+        ) -> anyhow::Result<()> {
+            for (account_id, account_info) in accounts {
+                if account_info.sufficients == 0 {
+                    // Rule 1: If the account is not sufficient, it should have at least one provider
+                    self.assert(
+                        account_info.providers > 0,
+                        format!("Account {} has no providers nor sufficients", account_id),
+                    );
+                    // Rule 2: If the account is not sufficient, it should comply to the existential deposit
+                    self.assert(
+                        (account_info.data.free + account_info.data.reserved) >= 200,
+                        format!(
+                            "Account {} not respect existential deposit rule",
+                            account_id
+                        ),
+                    );
+                }
+
+                // Rule 3: If the account have consumers, it shoul have at least one provider
+                if account_info.consumers > 0 {
+                    // Rule 1: If the account is not s
+                    self.assert(
+                        account_info.providers > 0,
+                        format!("Account {} has no providers nor sufficients", account_id),
+                    );
+                }
+
+                if account_id.as_slice() != TREASURY_ACCOUNT_ID {
+                    // Rule 4: If the account is not a "special account",
+                    // it should have a random id or a consumer
+                    self.assert(
+                        account_info.data.random_id.is_some() || account_info.consumers > 0,
+                        format!("Account {} has no random_id nor consumer", account_id),
+                    );
+                }
             }
-            _ => {
-                // Rule 4: If the identity is not validated, next_creatable_identity_on shoud be zero
-                assert!(
-                    idty_value.next_creatable_identity_on == 0,
-                    "Identity {} is corrupted: next_creatable_identity_on > 0 on non-validated idty",
-                    idty_index
+            Ok(())
+        }
+
+        async fn verify_identities(
+            &mut self,
+            accounts: &HashMap<AccountId32, AccountInfo>,
+            identities: &HashMap<IdtyIndex, IdtyValue>,
+        ) -> anyhow::Result<()> {
+            for (idty_index, idty_value) in identities {
+                // Rule 1: each identity should have an account
+                let idty_account = accounts
+                    .get(&idty_value.owner_key)
+                    .unwrap_or_else(|| panic!("Identity {} has no account", idty_index));
+
+                // Rule 2: each identity account should be sufficient
+                self.assert(
+                    idty_account.sufficients > 0,
+                    format!(
+                        "Identity {} is corrupted: idty_account.sufficients == 0",
+                        idty_index
+                    ),
                 );
+
+                match idty_value.status {
+                    IdtyStatus::Validated => {
+                        // Rule 3: If the identity is validated, removable_on shoud be zero
+                        self.assert(
+                            idty_value.removable_on == 0,
+                            format!(
+                                "Identity {} is corrupted: removable_on > 0 on validated idty",
+                                idty_index
+                            ),
+                        );
+                    }
+                    _ => {
+                        // Rule 4: If the identity is not validated, next_creatable_identity_on shoud be zero
+                        self.assert(
+							idty_value.next_creatable_identity_on == 0,
+							format!("Identity {} is corrupted: next_creatable_identity_on > 0 on non-validated idty",
+							idty_index)
+						);
+                    }
+                }
             }
+            Ok(())
         }
     }
-    Ok(())
 }