Fix testing to have all hook lifecycle methods

Author: corydickson

src/AgoraGovernor.sol

@@ -148,7 +148,6 @@ contract AgoraGovernor is
         uint256 beforeProposalId = hooks.beforeExecute(targets, values, calldatas, descriptionHash);
 
         uint256 proposalId = super.execute(targets, values, calldatas, descriptionHash);
-
         uint256 afterProposalId = hooks.afterExecute(proposalId, targets, values, calldatas, descriptionHash);
 
         // TODO: check that before and after proposal IDs are the same

src/libraries/Hooks.sol

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import "forge-std/console2.sol";
 import {IHooks} from "src/interfaces/IHooks.sol";
 
 /// Inspired in the https://github.com/Uniswap/v4-core/blob/main/src/libraries/Hooks.sol[Uniswap v4 implementation of hooks].

test/BaseHook.t.sol

@@ -87,7 +87,7 @@ contract BaseHookTest is Test, Deployers {
     function test_vote_succeeds(address _actor) public {
         deployGovernor(address(hook));
 
-        vm.assume(_actor != proxyAdmin && _actor != address(hook));
+        _actor = makeAddr("actor");
 
         vm.prank(minter);
         token.mint(_actor, 100);
@@ -115,4 +115,103 @@ contract BaseHookTest is Test, Deployers {
         vm.roll(block.number + 14);
         vm.stopPrank();
     }
+
+    function test_cancel_succeeds() public {
+        deployGovernor(address(hook));
+
+        address[] memory targets = new address[](1);
+        targets[0] = address(this);
+        uint256[] memory values = new uint256[](1);
+        bytes[] memory calldatas = new bytes[](1);
+        calldatas[0] = abi.encodeWithSelector(this.test_initialize_succeeds.selector);
+
+        vm.startPrank(manager);
+        uint256 proposalId = governor.propose(targets, values, calldatas, "Test");
+
+        vm.roll(block.number + 2);
+
+        vm.expectEmit(address(hook));
+        emit BaseHookMock.BeforeCancel();
+        vm.expectEmit(address(hook));
+        emit BaseHookMock.AfterCancel();
+        governor.cancel(targets, values, calldatas, keccak256("Test"));
+
+        vm.stopPrank();
+    }
+
+    function test_queue_succeeds(address _actor) public {
+        deployGovernor(address(hook));
+
+        _actor = makeAddr("actor");
+
+        vm.prank(minter);
+        token.mint(_actor, 100);
+        vm.startPrank(_actor);
+        token.delegate(_actor);
+        vm.roll(block.number + 1);
+
+        address[] memory targets = new address[](1);
+        targets[0] = address(this);
+        uint256[] memory values = new uint256[](1);
+        bytes[] memory calldatas = new bytes[](1);
+        calldatas[0] = abi.encodeWithSelector(this.test_initialize_succeeds.selector);
+
+        vm.startPrank(_actor);
+        uint256 proposalId = governor.propose(targets, values, calldatas, "Test");
+
+        vm.roll(block.number + 2);
+
+        governor.castVote(proposalId, uint8(GovernorCountingSimple.VoteType.For));
+
+        vm.roll(block.number + 14);
+
+        vm.expectEmit(address(hook));
+        emit BaseHookMock.BeforeQueue();
+        vm.expectEmit(address(hook));
+        emit BaseHookMock.AfterQueue();
+        governor.queue(targets, values, calldatas, keccak256("Test"));
+    }
+
+    function test_execute_succeeds(
+        address _actor,
+        uint256 _proposalTargetCalldata,
+        uint256 _elapsedAfterQueuing
+    ) public {
+        deployGovernor(address(hook));
+
+        _actor = makeAddr("actor");
+
+        _elapsedAfterQueuing = bound(_elapsedAfterQueuing, timelockDelay, type(uint208).max);
+
+        vm.prank(minter);
+        token.mint(_actor, 100);
+        vm.startPrank(_actor);
+        token.delegate(_actor);
+        vm.roll(block.number + 1);
+
+        address[] memory targets = new address[](1);
+        targets[0] = address(this);
+        uint256[] memory values = new uint256[](1);
+        bytes[] memory calldatas = new bytes[](1);
+        calldatas[0] = abi.encodeWithSelector(this.test_initialize_succeeds.selector);
+
+        vm.startPrank(_actor);
+        uint256 proposalId = governor.propose(targets, values, calldatas, "Test");
+
+        vm.roll(block.number + 2);
+
+        governor.castVote(proposalId, uint8(GovernorCountingSimple.VoteType.For));
+
+        vm.roll(block.number + 14);
+
+        governor.queue(targets, values, calldatas, keccak256("Test"));
+        vm.warp(block.timestamp + _elapsedAfterQueuing);
+
+        vm.expectEmit(address(hook));
+        emit BaseHookMock.BeforeExecute();
+        vm.expectCall(
+            address(hook), abi.encodeCall(hook.afterExecute, (_actor, proposalId, targets, values, calldatas, keccak256("Test")))
+        );
+        governor.execute(targets, values, calldatas, keccak256("Test"));
+    }
 }

test/mocks/BaseHookMock.sol

@@ -144,14 +144,14 @@ contract BaseHookMock is BaseHook {
         return (this.beforeExecute.selector, 0);
     }
 
-    function afterExecute(address, uint256, address[] memory, uint256[] memory, bytes[] memory, bytes32)
+    function afterExecute(address, uint256 proposalId, address[] memory, uint256[] memory, bytes[] memory, bytes32)
         external
         virtual
         override
         returns (bytes4, uint256)
     {
         emit AfterExecute();
-        return (this.afterExecute.selector, 0);
+        return (this.afterExecute.selector, proposalId);
     }
 
     /**