Migrate security tests

src/tests.cairo

@@ -9,8 +9,8 @@
 mod mocks;
 // #[cfg(test)]
 // mod presets;
-// #[cfg(test)]
-// mod security;
+#[cfg(test)]
+mod security;
 #[cfg(test)]
 mod token;
 // #[cfg(test)]

src/tests/security/test_pausable.cairo

@@ -2,11 +2,11 @@ use openzeppelin::security::PausableComponent::{InternalImpl, PausableImpl};
 use openzeppelin::security::PausableComponent::{Paused, Unpaused};
 use openzeppelin::security::PausableComponent;
 use openzeppelin::tests::mocks::pausable_mocks::PausableMock;
-use openzeppelin::tests::utils::constants::{CALLER, ZERO};
-use openzeppelin::tests::utils;
+use openzeppelin::tests::utils::constants::CALLER;
+use openzeppelin::tests::utils::events::EventSpyExt;
+use snforge_std::EventSpy;
+use snforge_std::{spy_events, test_address, start_cheat_caller_address};
 use starknet::ContractAddress;
-use starknet::contract_address_const;
-use starknet::testing;
 
 type ComponentState = PausableComponent::ComponentState<PausableMock::ContractState>;
 
@@ -73,11 +73,13 @@ fn test_assert_not_paused_when_not_paused() {
 #[test]
 fn test_pause_when_unpaused() {
     let mut state = COMPONENT_STATE();
-    testing::set_caller_address(CALLER());
+    let contract_address = test_address();
 
+    let mut spy = spy_events();
+    start_cheat_caller_address(contract_address, CALLER());
     state.pause();
 
-    assert_event_paused(CALLER());
+    spy.assert_only_event_paused(contract_address, CALLER());
     assert!(state.is_paused());
 }
 
@@ -96,14 +98,15 @@ fn test_pause_when_paused() {
 #[test]
 fn test_unpause_when_paused() {
     let mut state = COMPONENT_STATE();
-    testing::set_caller_address(CALLER());
+    let contract_address = test_address();
 
+    let mut spy = spy_events();
+    start_cheat_caller_address(test_address(), CALLER());
     state.pause();
-    utils::drop_event(ZERO());
-
     state.unpause();
 
-    assert_event_unpaused(CALLER());
+    spy.assert_event_paused(contract_address, CALLER());
+    spy.assert_only_event_unpaused(contract_address, CALLER());
     assert!(!state.is_paused());
 }
 
@@ -119,16 +122,33 @@ fn test_unpause_when_unpaused() {
 // Helpers
 //
 
-fn assert_event_paused(account: ContractAddress) {
-    let event = utils::pop_log::<PausableComponent::Event>(ZERO()).unwrap();
-    let expected = PausableComponent::Event::Paused(Paused { account });
-    assert!(event == expected);
-    utils::assert_no_events_left(ZERO());
-}
-
-fn assert_event_unpaused(account: ContractAddress) {
-    let event = utils::pop_log::<PausableComponent::Event>(ZERO()).unwrap();
-    let expected = PausableComponent::Event::Unpaused(Unpaused { account });
-    assert!(event == expected);
-    utils::assert_no_events_left(ZERO());
+#[generate_trait]
+impl PausableSpyHelpersImpl of PausableSpyHelpers {
+    fn assert_event_paused(
+        ref self: EventSpy, contract: ContractAddress, account: ContractAddress
+    ) {
+        let expected = PausableComponent::Event::Paused(Paused { account });
+        self.assert_emitted_single(contract, expected);
+    }
+
+    fn assert_only_event_paused(
+        ref self: EventSpy, contract: ContractAddress, account: ContractAddress,
+    ) {
+        self.assert_event_paused(contract, account);
+        self.assert_no_events_left_from(contract);
+    }
+
+    fn assert_event_unpaused(
+        ref self: EventSpy, contract: ContractAddress, account: ContractAddress
+    ) {
+        let expected = PausableComponent::Event::Unpaused(Unpaused { account });
+        self.assert_emitted_single(contract, expected);
+    }
+
+    fn assert_only_event_unpaused(
+        ref self: EventSpy, contract: ContractAddress, account: ContractAddress,
+    ) {
+        self.assert_event_unpaused(contract, account);
+        self.assert_no_events_left_from(contract);
+    }
 }

src/tests/security/test_reentrancyguard.cairo

@@ -1,7 +1,7 @@
 use openzeppelin::security::ReentrancyGuardComponent::InternalImpl;
 use openzeppelin::security::ReentrancyGuardComponent;
 use openzeppelin::tests::mocks::reentrancy_mocks::{
-    Attacker, ReentrancyMock, IReentrancyMockDispatcher, IReentrancyMockDispatcherTrait
+    ReentrancyMock, IReentrancyMockDispatcher, IReentrancyMockDispatcherTrait
 };
 use openzeppelin::tests::utils;
 use starknet::storage::StorageMemberAccessTrait;
@@ -14,7 +14,7 @@ fn COMPONENT_STATE() -> ComponentState {
 
 fn deploy_mock() -> IReentrancyMockDispatcher {
     let calldata = array![];
-    let address = utils::deploy(ReentrancyMock::TEST_CLASS_HASH, calldata);
+    let address = utils::declare_and_deploy("ReentrancyMock", calldata);
     IReentrancyMockDispatcher { contract_address: address }
 }
 
@@ -64,35 +64,26 @@ fn test_reentrancy_guard_end() {
 //
 
 #[test]
-#[should_panic(
-    expected: (
-        'ReentrancyGuard: reentrant call',
-        'ENTRYPOINT_FAILED',
-        'ENTRYPOINT_FAILED',
-        'ENTRYPOINT_FAILED'
-    ),
-)]
+#[should_panic(expected: ('ReentrancyGuard: reentrant call',))]
 fn test_remote_callback() {
     let contract = deploy_mock();
 
     // Deploy attacker
-    let calldata = ArrayTrait::new();
-    let attacker_addr = utils::deploy(Attacker::TEST_CLASS_HASH, calldata);
+    let calldata = array![];
+    let attacker_addr = utils::declare_and_deploy("Attacker", calldata);
 
     contract.count_and_call(attacker_addr);
 }
 
 #[test]
-#[should_panic(expected: ('ReentrancyGuard: reentrant call', 'ENTRYPOINT_FAILED'))]
+#[should_panic(expected: ('ReentrancyGuard: reentrant call',))]
 fn test_local_recursion() {
     let contract = deploy_mock();
     contract.count_local_recursive(10);
 }
 
 #[test]
-#[should_panic(
-    expected: ('ReentrancyGuard: reentrant call', 'ENTRYPOINT_FAILED', 'ENTRYPOINT_FAILED')
-)]
+#[should_panic(expected: ('ReentrancyGuard: reentrant call',))]
 fn test_external_recursion() {
     let contract = deploy_mock();
     contract.count_external_recursive(10);