diff --git a/pallets/certification/src/tests.rs b/pallets/certification/src/tests.rs
index 2667ecce5b552287cb3898b6ed5d0c75d87def9f..cb483613788650e98d1a21695bfc5b1af2308f52 100644
--- a/pallets/certification/src/tests.rs
+++ b/pallets/certification/src/tests.rs
@@ -18,7 +18,6 @@ use crate::mock::Event as RuntimeEvent;
 use crate::mock::*;
 use crate::{Error, Event};
 use frame_support::assert_ok;
-//use frame_system::{EventRecord, Phase};
 use maplit::btreemap;
 use sp_std::collections::btree_map::BTreeMap;
 
diff --git a/pallets/duniter-wot/src/tests.rs b/pallets/duniter-wot/src/tests.rs
index 7e1e8e901c8b8ac93e598a618a634f226f1de6c3..ca703ff60f720e273a4b8299bd8f5cee91198d5a 100644
--- a/pallets/duniter-wot/src/tests.rs
+++ b/pallets/duniter-wot/src/tests.rs
@@ -19,7 +19,6 @@ use crate::mock::{Identity, System};
 use codec::Encode;
 use frame_support::instances::Instance1;
 use frame_support::{assert_noop, assert_ok};
-use frame_system::{EventRecord, Phase};
 use pallet_identity::{
     IdtyName, IdtyStatus, NewOwnerKeyPayload, RevocationPayload, NEW_OWNER_KEY_PAYLOAD_PREFIX,
     REVOCATION_PAYLOAD_PREFIX,
@@ -178,32 +177,17 @@ fn test_create_idty_ok() {
         // Alice should be able to create an identity at block #2
         assert_ok!(Identity::create_identity(Origin::signed(1), 6));
         // 2 events should have occurred: IdtyCreated and NewCert
-        let events = System::events();
-        assert_eq!(events.len(), 2);
-        assert_eq!(
-            events[0],
-            EventRecord {
-                phase: Phase::Initialization,
-                event: Event::Identity(pallet_identity::Event::IdtyCreated {
-                    idty_index: 6,
-                    owner_key: 6,
-                }),
-                topics: vec![],
-            }
-        );
-        assert_eq!(
-            events[1],
-            EventRecord {
-                phase: Phase::Initialization,
-                event: Event::Cert(pallet_certification::Event::NewCert {
-                    issuer: 1,
-                    issuer_issued_count: 5,
-                    receiver: 6,
-                    receiver_received_count: 1
-                }),
-                topics: vec![],
-            }
-        );
+        System::assert_has_event(Event::Identity(pallet_identity::Event::IdtyCreated {
+            idty_index: 6,
+            owner_key: 6,
+        }));
+        System::assert_has_event(Event::Cert(pallet_certification::Event::NewCert {
+            issuer: 1,
+            issuer_issued_count: 5,
+            receiver: 6,
+            receiver_received_count: 1,
+        }));
+
         assert_eq!(Identity::identity(6).unwrap().status, IdtyStatus::Created);
         assert_eq!(Identity::identity(6).unwrap().removable_on, 4);
     });
@@ -274,30 +258,14 @@ fn test_confirm_idty_ok() {
             Origin::signed(6),
             IdtyName::from("Ferdie"),
         ));
-        let events = System::events();
-        // 2 events should have occurred: MembershipRequested and IdtyConfirmed
-        assert_eq!(events.len(), 2);
-        //println!("{:?}", events[0]);
-        assert_eq!(
-            events[0],
-            EventRecord {
-                phase: Phase::Initialization,
-                event: Event::Membership(pallet_membership::Event::MembershipRequested(6)),
-                topics: vec![],
-            }
-        );
-        assert_eq!(
-            events[1],
-            EventRecord {
-                phase: Phase::Initialization,
-                event: Event::Identity(pallet_identity::Event::IdtyConfirmed {
-                    idty_index: 6,
-                    owner_key: 6,
-                    name: IdtyName::from("Ferdie"),
-                }),
-                topics: vec![],
-            }
-        );
+        System::assert_has_event(Event::Membership(
+            pallet_membership::Event::MembershipRequested(6),
+        ));
+        System::assert_has_event(Event::Identity(pallet_identity::Event::IdtyConfirmed {
+            idty_index: 6,
+            owner_key: 6,
+            name: IdtyName::from("Ferdie"),
+        }));
     });
 }
 
@@ -314,25 +282,13 @@ fn test_idty_membership_expire_them_requested() {
         // Charlie's membership should expire at block #8
         run_to_block(8);
         assert!(Membership::membership(3).is_none());
-        let events = System::events();
-        println!("{:?}", events);
-        assert_eq!(events.len(), 2);
-        assert_eq!(
-            events[0],
-            EventRecord {
-                phase: Phase::Initialization,
-                event: Event::Membership(pallet_membership::Event::MembershipExpired(3)),
-                topics: vec![],
-            }
-        );
-        assert_eq!(
-            events[1],
-            EventRecord {
-                phase: Phase::Initialization,
-                event: Event::Identity(pallet_identity::Event::IdtyRemoved { idty_index: 3 }),
-                topics: vec![],
-            }
-        );
+
+        System::assert_has_event(Event::Membership(
+            pallet_membership::Event::MembershipExpired(3),
+        ));
+        System::assert_has_event(Event::Identity(pallet_identity::Event::IdtyRemoved {
+            idty_index: 3,
+        }));
 
         // Charlie's identity should be removed at block #8
         assert!(Identity::identity(3).is_none());
diff --git a/pallets/identity/src/tests.rs b/pallets/identity/src/tests.rs
index 77624e10ca3618d7588bdd20fb5173aa1657ad9f..9ee69d28c973ed51b2a0ebb8221615dfe3992065 100644
--- a/pallets/identity/src/tests.rs
+++ b/pallets/identity/src/tests.rs
@@ -22,7 +22,6 @@ use crate::{
 use codec::Encode;
 //use frame_support::assert_noop;
 use frame_support::{assert_err, assert_ok};
-use frame_system::{EventRecord, Phase};
 use sp_runtime::testing::TestSignature;
 
 type IdtyVal = IdtyValue<u64, u64, ()>;
@@ -78,19 +77,11 @@ fn test_create_identity_ok() {
 
         // Alice should be able to create an identity
         assert_ok!(Identity::create_identity(Origin::signed(1), 2));
-        let events = System::events();
-        assert_eq!(events.len(), 1);
-        assert_eq!(
-            events[0],
-            EventRecord {
-                phase: Phase::Initialization,
-                event: Event::Identity(crate::Event::IdtyCreated {
-                    idty_index: 2,
-                    owner_key: 2,
-                }),
-                topics: vec![],
-            }
-        );
+
+        System::assert_has_event(Event::Identity(crate::Event::IdtyCreated {
+            idty_index: 2,
+            owner_key: 2,
+        }));
     });
 }
 
@@ -108,33 +99,17 @@ fn test_create_identity_but_not_confirm_it() {
 
         // The identity shoud expire in blocs #3
         run_to_block(3);
-        let events = System::events();
-        assert_eq!(events.len(), 1);
-        assert_eq!(
-            events[0],
-            EventRecord {
-                phase: Phase::Initialization,
-                event: Event::Identity(crate::Event::IdtyRemoved { idty_index: 2 }),
-                topics: vec![],
-            }
-        );
+
+        System::assert_has_event(Event::Identity(crate::Event::IdtyRemoved { idty_index: 2 }));
 
         // We shoud be able to recreate the identity
         run_to_block(4);
         assert_ok!(Identity::create_identity(Origin::signed(1), 2));
-        let events = System::events();
-        assert_eq!(events.len(), 1);
-        assert_eq!(
-            events[0],
-            EventRecord {
-                phase: Phase::Initialization,
-                event: Event::Identity(crate::Event::IdtyCreated {
-                    idty_index: 3,
-                    owner_key: 2,
-                }),
-                topics: vec![],
-            }
-        );
+
+        System::assert_has_event(Event::Identity(crate::Event::IdtyCreated {
+            idty_index: 3,
+            owner_key: 2,
+        }));
     });
 }
 
@@ -149,19 +124,12 @@ fn test_idty_creation_period() {
 
         // Alice should be able to create an identity
         assert_ok!(Identity::create_identity(Origin::signed(1), 2));
-        let events = System::events();
-        assert_eq!(events.len(), 1);
-        assert_eq!(
-            events[0],
-            EventRecord {
-                phase: Phase::Initialization,
-                event: Event::Identity(crate::Event::IdtyCreated {
-                    idty_index: 2,
-                    owner_key: 2,
-                }),
-                topics: vec![],
-            }
-        );
+
+        System::assert_has_event(Event::Identity(crate::Event::IdtyCreated {
+            idty_index: 2,
+            owner_key: 2,
+        }));
+
         assert_eq!(Identity::identity(1).unwrap().next_creatable_identity_on, 4);
 
         // Alice cannot create a new identity before block #4
@@ -174,19 +142,11 @@ fn test_idty_creation_period() {
         // Alice should be able to create a second identity after block #4
         run_to_block(4);
         assert_ok!(Identity::create_identity(Origin::signed(1), 3));
-        let events = System::events();
-        assert_eq!(events.len(), 1);
-        assert_eq!(
-            events[0],
-            EventRecord {
-                phase: Phase::Initialization,
-                event: Event::Identity(crate::Event::IdtyCreated {
-                    idty_index: 3,
-                    owner_key: 3,
-                }),
-                topics: vec![],
-            }
-        );
+
+        System::assert_has_event(Event::Identity(crate::Event::IdtyCreated {
+            idty_index: 3,
+            owner_key: 3,
+        }));
     });
 }
 
@@ -374,24 +334,10 @@ fn test_idty_revocation() {
             TestSignature(1, (REVOCATION_PAYLOAD_PREFIX, revocation_payload).encode())
         ));
 
-        let events = System::events();
-        assert_eq!(events.len(), 2);
-        assert_eq!(
-            events[0],
-            EventRecord {
-                phase: Phase::Initialization,
-                event: Event::System(frame_system::Event::KilledAccount { account: 1 }),
-                topics: vec![],
-            }
-        );
-        assert_eq!(
-            events[1],
-            EventRecord {
-                phase: Phase::Initialization,
-                event: Event::Identity(crate::Event::IdtyRemoved { idty_index: 1 }),
-                topics: vec![],
-            }
-        );
+        System::assert_has_event(Event::System(frame_system::Event::KilledAccount {
+            account: 1,
+        }));
+        System::assert_has_event(Event::Identity(crate::Event::IdtyRemoved { idty_index: 1 }));
 
         run_to_block(2);
 
diff --git a/runtime/gdev/tests/integration_tests.rs b/runtime/gdev/tests/integration_tests.rs
index 262f8977a809133c5e1b26caf0b1b9d2b0c5e782..1f933bb4307410b702bf524751ffa723fd33f836 100644
--- a/runtime/gdev/tests/integration_tests.rs
+++ b/runtime/gdev/tests/integration_tests.rs
@@ -91,22 +91,16 @@ fn test_remove_identity() {
             4,
             None
         ));
-        let events = System::events();
-        assert_eq!(events.len(), 3);
-        assert_eq!(
-            System::events()[0].event,
-            Event::Membership(pallet_membership::Event::MembershipRevoked(4))
-        );
-        assert_eq!(
-            System::events()[1].event,
-            Event::System(frame_system::Event::KilledAccount {
-                account: AccountKeyring::Dave.to_account_id()
-            })
-        );
-        assert_eq!(
-            System::events()[2].event,
-            Event::Identity(pallet_identity::Event::IdtyRemoved { idty_index: 4 })
-        );
+
+        System::assert_has_event(Event::Membership(
+            pallet_membership::Event::MembershipRevoked(4),
+        ));
+        System::assert_has_event(Event::System(frame_system::Event::KilledAccount {
+            account: AccountKeyring::Dave.to_account_id(),
+        }));
+        System::assert_has_event(Event::Identity(pallet_identity::Event::IdtyRemoved {
+            idty_index: 4,
+        }));
     });
 }
 #[test]
@@ -122,39 +116,27 @@ fn test_remove_identity_after_one_ud() {
         ));
 
         // Verify events
-        let events = System::events();
-        //println!("{:?}", events);
-        assert_eq!(events.len(), 5);
-        assert_eq!(
-            System::events()[0].event,
-            Event::Membership(pallet_membership::Event::MembershipRevoked(4))
-        );
-        assert_eq!(
-            System::events()[1].event,
-            Event::Balances(pallet_balances::Event::Deposit {
-                who: AccountKeyring::Dave.to_account_id(),
-                amount: 1_000
-            })
-        );
-        assert_eq!(
-            System::events()[2].event,
-            Event::Balances(pallet_balances::Event::Endowed {
-                account: AccountKeyring::Dave.to_account_id(),
-                free_balance: 1_000
-            })
-        );
-        assert_eq!(
-            System::events()[3].event,
-            Event::UniversalDividend(pallet_universal_dividend::Event::UdsAutoPaidAtRemoval {
+        System::assert_has_event(Event::Membership(
+            pallet_membership::Event::MembershipRevoked(4),
+        ));
+        System::assert_has_event(Event::Balances(pallet_balances::Event::Deposit {
+            who: AccountKeyring::Dave.to_account_id(),
+            amount: 1_000,
+        }));
+        System::assert_has_event(Event::Balances(pallet_balances::Event::Endowed {
+            account: AccountKeyring::Dave.to_account_id(),
+            free_balance: 1_000,
+        }));
+        System::assert_has_event(Event::UniversalDividend(
+            pallet_universal_dividend::Event::UdsAutoPaidAtRemoval {
                 count: 1,
                 total: 1_000,
                 who: AccountKeyring::Dave.to_account_id(),
-            })
-        );
-        assert_eq!(
-            System::events()[4].event,
-            Event::Identity(pallet_identity::Event::IdtyRemoved { idty_index: 4 })
-        );
+            },
+        ));
+        System::assert_has_event(Event::Identity(pallet_identity::Event::IdtyRemoved {
+            idty_index: 4,
+        }));
 
         // Verify state
         assert!(Identity::identity(4).is_none());
@@ -175,25 +157,19 @@ fn test_remove_smith_identity() {
             3,
             None
         ));
-        let events = System::events();
-        assert_eq!(events.len(), 4);
-        assert_eq!(
-            System::events()[0].event,
-            Event::SmithsMembership(pallet_membership::Event::MembershipRevoked(3))
-        );
-        assert_eq!(
-            System::events()[1].event,
-            Event::AuthorityMembers(pallet_authority_members::Event::MemberRemoved(3))
-        );
-        assert_eq!(
-            System::events()[2].event,
-            Event::Membership(pallet_membership::Event::MembershipRevoked(3))
-        );
-        assert_eq!(
-            System::events()[3].event,
-            Event::Identity(pallet_identity::Event::IdtyRemoved { idty_index: 3 })
-        );
-        //println!("{:#?}", events);
+        // Verify events
+        System::assert_has_event(Event::SmithsMembership(
+            pallet_membership::Event::MembershipRevoked(3),
+        ));
+        System::assert_has_event(Event::AuthorityMembers(
+            pallet_authority_members::Event::MemberRemoved(3),
+        ));
+        System::assert_has_event(Event::Membership(
+            pallet_membership::Event::MembershipRevoked(3),
+        ));
+        System::assert_has_event(Event::Identity(pallet_identity::Event::IdtyRemoved {
+            idty_index: 3,
+        }));
     });
 }
 
@@ -211,55 +187,38 @@ fn test_create_new_account_with_insufficient_balance() {
                 MultiAddress::Id(AccountKeyring::Eve.to_account_id()),
                 400
             ));
-            let events = System::events();
-            //println!("{:#?}", events);
-            assert_eq!(events.len(), 3);
-            assert_eq!(
-                System::events()[0].event,
-                Event::System(frame_system::Event::NewAccount {
-                    account: AccountKeyring::Eve.to_account_id(),
-                })
-            );
-            assert_eq!(
-                System::events()[1].event,
-                Event::Balances(pallet_balances::Event::Endowed {
-                    account: AccountKeyring::Eve.to_account_id(),
-                    free_balance: 400,
-                })
-            );
-            assert_eq!(
-                System::events()[2].event,
-                Event::Balances(pallet_balances::Event::Transfer {
-                    from: AccountKeyring::Alice.to_account_id(),
-                    to: AccountKeyring::Eve.to_account_id(),
-                    amount: 400,
-                })
-            );
+
+            System::assert_has_event(Event::System(frame_system::Event::NewAccount {
+                account: AccountKeyring::Eve.to_account_id(),
+            }));
+            System::assert_has_event(Event::Balances(pallet_balances::Event::Endowed {
+                account: AccountKeyring::Eve.to_account_id(),
+                free_balance: 400,
+            }));
+            System::assert_has_event(Event::Balances(pallet_balances::Event::Transfer {
+                from: AccountKeyring::Alice.to_account_id(),
+                to: AccountKeyring::Eve.to_account_id(),
+                amount: 400,
+            }));
 
             // At next block, the new account must be reaped because its balance is not sufficient
             // to pay the "new account tax"
             run_to_block(3);
-            let events = System::events();
-            //println!("{:#?}", events);
-            assert_eq!(events.len(), 3);
-            assert_eq!(
-                System::events()[0].event,
-                Event::Account(pallet_duniter_account::Event::ForceDestroy {
+
+            System::assert_has_event(Event::Account(
+                pallet_duniter_account::Event::ForceDestroy {
                     who: AccountKeyring::Eve.to_account_id(),
                     balance: 400,
-                })
-            );
-            assert_eq!(
-                System::events()[1].event,
-                Event::Balances(pallet_balances::Event::Deposit {
-                    who: Treasury::account_id(),
-                    amount: 400,
-                })
-            );
-            assert_eq!(
-                System::events()[2].event,
-                Event::Treasury(pallet_treasury::Event::Deposit { value: 400 })
-            );
+                },
+            ));
+            System::assert_has_event(Event::Balances(pallet_balances::Event::Deposit {
+                who: Treasury::account_id(),
+                amount: 400,
+            }));
+            System::assert_has_event(Event::Treasury(pallet_treasury::Event::Deposit {
+                value: 400,
+            }));
+
             assert_eq!(
                 Balances::free_balance(AccountKeyring::Eve.to_account_id()),
                 0
@@ -299,27 +258,19 @@ fn test_create_new_account() {
             // At next block, the new account must be created,
             // and new account tax should be collected and deposited in the treasury
             run_to_block(3);
-            let events = System::events();
-            println!("{:#?}", events);
-            assert_eq!(events.len(), 3);
-            assert_eq!(
-                System::events()[0].event,
-                Event::Balances(pallet_balances::Event::Withdraw {
-                    who: AccountKeyring::Eve.to_account_id(),
-                    amount: 300,
-                })
-            );
-            assert_eq!(
-                System::events()[1].event,
-                Event::Balances(pallet_balances::Event::Deposit {
-                    who: Treasury::account_id(),
-                    amount: 300,
-                })
-            );
-            assert_eq!(
-                System::events()[2].event,
-                Event::Treasury(pallet_treasury::Event::Deposit { value: 300 })
-            );
+
+            System::assert_has_event(Event::Balances(pallet_balances::Event::Withdraw {
+                who: AccountKeyring::Eve.to_account_id(),
+                amount: 300,
+            }));
+            System::assert_has_event(Event::Balances(pallet_balances::Event::Deposit {
+                who: Treasury::account_id(),
+                amount: 300,
+            }));
+            System::assert_has_event(Event::Treasury(pallet_treasury::Event::Deposit {
+                value: 300,
+            }));
+
             assert_eq!(
                 Balances::free_balance(AccountKeyring::Eve.to_account_id()),
                 200