Skip to content
Snippets Groups Projects
Commit eec7100c authored by Éloïs's avatar Éloïs
Browse files

collect and print all errors

parent 9c0dce2e
No related branches found
No related tags found
1 merge request!76tests(live): add sanity tests against gdev live chain
Hide whitespace changes
Inline Side-by-side
live-tests/tests/sanity_gdev.rs
+ 124
− 70
View file @ eec7100c
......@@ -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(())
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment