fixed incentivized tests

testFoundry/PushCore/unit_tests/IncentivizedChatRequest/1_createIncentivizedChatRequest/createIncentivizedChatRequest.t.sol

@@ -0,0 +1,143 @@
+pragma solidity ^0.8.20;
+
+import {BaseIncentivizedChatRequest} from "../BaseIncentivizedChatRequest.t.sol";
+import {Errors} from "contracts/libraries/Errors.sol";
+
+contract CreateIncentivizeChatRequest_Test is BaseIncentivizedChatRequest {
+    function setUp() public virtual override {
+        BaseIncentivizedChatRequest.setUp();
+    }
+
+    modifier whenNotPaused() {
+        _;
+    }
+
+    function test_Revertwhen_AmountIsZero() public whenNotPaused {
+        address requestSender = actor.bob_channel_owner;
+        address requestReceiver = actor.charlie_channel_owner;
+        uint256 amount = 0;
+
+        vm.prank(requestSender);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                Errors.InvalidArg_LessThanExpected.selector,
+                0,
+                amount
+            )
+        );
+
+        commProxy.createIncentivizeChatRequest(requestReceiver, 0);
+    }
+
+    function test_Revertwhen_NotEnoughAllowance() public whenNotPaused {
+        address requestSender = actor.bob_channel_owner;
+        address requestReceiver = actor.charlie_channel_owner;
+        uint256 amount = 1e8;
+
+        vm.prank(requestSender);
+
+        vm.expectRevert(
+            bytes(
+                "Push::transferFrom: transfer amount exceeds spender allowance"
+            )
+        );
+
+        commProxy.createIncentivizeChatRequest(requestReceiver, amount);
+    }
+
+    function test_CoreShouldReceiveTokens() public whenNotPaused {
+        address requestSender = actor.bob_channel_owner;
+        address requestReceiver = actor.charlie_channel_owner;
+        uint256 amount = 1e20;
+
+        uint256 actualPushTokenbalanceBeforeCall = pushToken.balanceOf(
+            address(coreProxy)
+        );
+
+        approveTokens(requestSender, address(commProxy), amount);
+        vm.prank(requestSender);
+        commProxy.createIncentivizeChatRequest(requestReceiver, amount);
+
+        uint256 actualPushTokenbalanceAfterCall = pushToken.balanceOf(
+            address(coreProxy)
+        );
+        uint256 expectedPushTokenbalanceAfterCall = actualPushTokenbalanceBeforeCall +
+                amount;
+        assertEq(
+            expectedPushTokenbalanceAfterCall,
+            actualPushTokenbalanceAfterCall
+        );
+    }
+
+    function test_ShouldUpdateVariables() public whenNotPaused {
+        address requestSender = actor.bob_channel_owner;
+        address requestReceiver = actor.charlie_channel_owner;
+        uint256 amount = 1e20;
+
+        (
+            address requestSenderBeforeFirstRequest,
+            uint256 timestampBeforeFirstRequest,
+            uint256 amountDepositedBeforeFirstRequest
+        ) = commProxy.userChatData(requestSender);
+
+        assertEq(requestSenderBeforeFirstRequest, address(0));
+        assertEq(timestampBeforeFirstRequest, 0);
+        assertEq(amountDepositedBeforeFirstRequest, 0);
+
+        approveTokens(requestSender, address(commProxy), amount);
+        vm.prank(requestSender);
+        commProxy.createIncentivizeChatRequest(requestReceiver, amount);
+
+        (
+            address requestSenderAfterFirstRequest,
+            uint256 timestampAfterFirstRequest,
+            uint256 amountDepositedAfterFirstRequest
+        ) = commProxy.userChatData(requestSender);
+
+        uint256 blockTimestampInFirstRequest = block.timestamp;
+
+        assertEq(requestSenderAfterFirstRequest, requestSender);
+        assertEq(timestampAfterFirstRequest, blockTimestampInFirstRequest);
+        assertEq(amountDepositedAfterFirstRequest, amount);
+
+        uint256 forwardedTimestamp = 3000;
+        skip(forwardedTimestamp);
+
+        approveTokens(requestSender, address(commProxy), amount);
+        vm.prank(requestSender);
+        commProxy.createIncentivizeChatRequest(requestReceiver, amount);
+
+        (
+            address requestSenderAfterSecondRequest,
+            uint256 timestampAfterSecondRequest,
+            uint256 amountDepositedAfterSecondRequest
+        ) = commProxy.userChatData(requestSender);
+
+        assertEq(requestSenderAfterSecondRequest, requestSender);
+        assertEq(
+            timestampAfterSecondRequest,
+            blockTimestampInFirstRequest + forwardedTimestamp
+        );
+        assertEq(amountDepositedAfterSecondRequest, amount * 2);
+    }
+
+    function test_ShouldEmitRelevantEvent() public whenNotPaused {
+        address requestSender = actor.bob_channel_owner;
+        address requestReceiver = actor.charlie_channel_owner;
+        uint256 amount = 1e20;
+
+        approveTokens(requestSender, address(commProxy), amount);
+
+        vm.expectEmit(false, false, false, true, address(commProxy));
+        emit IncentivizeChatReqInitiated(
+            requestSender,
+            requestReceiver,
+            amount,
+            block.timestamp
+        );
+
+        vm.prank(requestSender);
+        commProxy.createIncentivizeChatRequest(requestReceiver, amount);
+    }
+}

testFoundry/PushCore/unit_tests/IncentivizedChatRequest/1_createIncentivizedChatRequest/createIncentivizedChatRequest.tree

@@ -0,0 +1,13 @@
+createIncentivizeChatRequest.t.sol
+    ├── when contract is Paused
+    │   └── it REVERT - EnforcedPause()
+    └── when contract is not Paused
+        ├── when amount is not more than 0
+        │   └── it REVERT - InvalidArg_LessThanExpected(0, 0)
+        └── when amount is sufficient (more than 0)
+            ├── when push token allowance is less than amount
+            │   └── it REVERT - Push::transferFrom: transfer amount exceeds spender allowance
+            └── when push token allowance is enough
+                ├── should send PUSH tokens to Core
+                ├── should update chatData variables
+                └── should emit event IncentivizeChatReqInitiated(requestSender, requestReceiver, amount, block.timestamp)

testFoundry/PushCore/unit_tests/IncentivizedChatRequest/2_handleChatRequestData/handleChatRequestData.t.sol

@@ -0,0 +1,71 @@
+pragma solidity ^0.8.20;
+
+import {BaseIncentivizedChatRequest} from "../BaseIncentivizedChatRequest.t.sol";
+import {Errors} from "contracts/libraries/Errors.sol";
+
+contract HandleChatRequestData_Test is BaseIncentivizedChatRequest {
+    function setUp() public virtual override {
+        BaseIncentivizedChatRequest.setUp();
+    }
+
+    modifier whenNotPaused() {
+        _;
+    }
+
+    function test_Revertwhen_CallerNotComm() public whenNotPaused {
+        address requestSender = actor.bob_channel_owner;
+        address requestReceiver = actor.charlie_channel_owner;
+        uint256 amount = 1e6;
+
+        vm.expectRevert(
+            abi.encodeWithSelector(Errors.UnauthorizedCaller.selector, requestSender)
+        );
+
+        vm.prank(requestSender);
+        coreProxy.handleChatRequestData(requestSender, requestReceiver, amount);
+    }
+
+    function test_ShouldUpdateRelevantVariables() public whenNotPaused {
+        address requestSender = actor.bob_channel_owner;
+        address requestReceiver = actor.charlie_channel_owner;
+        uint256 amount = 1e20;
+
+        uint256 actualCelebUserFundsBeforeRequest = coreProxy.celebUserFunds(requestReceiver);
+        uint256 actualProtocolFeeBeforeRequest = coreProxy.PROTOCOL_POOL_FEES();
+
+        approveTokens(requestSender, address(commProxy), amount);
+        vm.prank(requestSender);
+        commProxy.createIncentivizeChatRequest(requestReceiver, amount);
+
+        uint256 actualCelebUserFundsAfterRequest = coreProxy.celebUserFunds(requestReceiver);
+        uint256 actualProtocolFeeAfterRequest = coreProxy.PROTOCOL_POOL_FEES();
+
+        uint256 corePoolFeeAmount = coreProxy.FEE_AMOUNT();
+        uint256 expectedCelebUserFundsAfterRequest = actualCelebUserFundsBeforeRequest + amount - corePoolFeeAmount;
+        uint256 expectedProtocolFeeAfterRequest = actualProtocolFeeBeforeRequest + corePoolFeeAmount;
+
+        assertEq(expectedCelebUserFundsAfterRequest, actualCelebUserFundsAfterRequest);
+        assertEq(expectedProtocolFeeAfterRequest, actualProtocolFeeAfterRequest);
+    }
+
+    function test_ShouldEmitRelevantEvent() public whenNotPaused {
+        address requestSender = actor.bob_channel_owner;
+        address requestReceiver = actor.charlie_channel_owner;
+        uint256 amount = 1e20;
+
+        approveTokens(requestSender, address(commProxy), amount);
+        uint256 corePoolFeeAmount = coreProxy.FEE_AMOUNT();
+
+        vm.expectEmit(false, false, false, true, address(coreProxy));
+        emit IncentivizeChatReqReceived(
+            requestSender,
+            requestReceiver,
+            amount - corePoolFeeAmount,
+            corePoolFeeAmount,
+            block.timestamp
+        );
+
+        vm.prank(requestSender);
+        commProxy.createIncentivizeChatRequest(requestReceiver, amount);
+    }
+}

testFoundry/PushCore/unit_tests/IncentivizedChatRequest/2_handleChatRequestData/handleChatRequestData.tree

@@ -0,0 +1,9 @@
+handleChatRequestData.t.sol
+    ├── when contract is Paused
+    │   └── it REVERT - EnforcedPause()
+    └── when contract is not Paused
+        ├── when function caller is not Comm contract
+        │   └── it REVERT - UnauthorizedCaller(caller)
+        └── when function caller is Comm contract
+            ├── should update relevant variables
+            └── should emit IncentivizeChatReqReceived(requestSender, requestReceiver, requestReceiverAmount, poolFeeAmount, block.timestamp)

testFoundry/PushCore/unit_tests/IncentivizedChatRequest/3_claimChatIncentives/claimChatIncentives.t.sol

@@ -0,0 +1,143 @@
+pragma solidity ^0.8.20;
+
+import {BaseIncentivizedChatRequest} from "../BaseIncentivizedChatRequest.t.sol";
+import {Errors} from "contracts/libraries/Errors.sol";
+
+contract CreateIncentivizeChatRequest_Test is BaseIncentivizedChatRequest {
+    function setUp() public virtual override {
+        BaseIncentivizedChatRequest.setUp();
+    }
+
+    modifier whenNotPaused() {
+        _;
+    }
+
+    function test_Revertwhen_AmountIsZero() public whenNotPaused {
+        address requestSender = actor.bob_channel_owner;
+        address requestReceiver = actor.charlie_channel_owner;
+        uint256 amount = 0;
+
+        vm.prank(requestSender);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                Errors.InvalidArg_LessThanExpected.selector,
+                0,
+                amount
+            )
+        );
+
+        commProxy.createIncentivizeChatRequest(requestReceiver, 0);
+    }
+
+    function test_Revertwhen_NotEnoughAllowance() public whenNotPaused {
+        address requestSender = actor.bob_channel_owner;
+        address requestReceiver = actor.charlie_channel_owner;
+        uint256 amount = 1e8;
+
+        vm.prank(requestSender);
+
+        vm.expectRevert(
+            bytes(
+                "Push::transferFrom: transfer amount exceeds spender allowance"
+            )
+        );
+
+        commProxy.createIncentivizeChatRequest(requestReceiver, amount);
+    }
+
+    function test_CoreShouldReceiveTokens() public whenNotPaused {
+        address requestSender = actor.bob_channel_owner;
+        address requestReceiver = actor.charlie_channel_owner;
+        uint256 amount = 1e20;
+
+        uint256 actualPushTokenbalanceBeforeCall = pushToken.balanceOf(
+            address(coreProxy)
+        );
+
+        approveTokens(requestSender, address(commProxy), amount);
+        vm.prank(requestSender);
+        commProxy.createIncentivizeChatRequest(requestReceiver, amount);
+
+        uint256 actualPushTokenbalanceAfterCall = pushToken.balanceOf(
+            address(coreProxy)
+        );
+        uint256 expectedPushTokenbalanceAfterCall = actualPushTokenbalanceBeforeCall +
+                amount;
+        assertEq(
+            expectedPushTokenbalanceAfterCall,
+            actualPushTokenbalanceAfterCall
+        );
+    }
+
+    function test_ShouldUpdateVariables() public whenNotPaused {
+        address requestSender = actor.bob_channel_owner;
+        address requestReceiver = actor.charlie_channel_owner;
+        uint256 amount = 1e20;
+
+        (
+            address requestSenderBeforeFirstRequest,
+            uint256 timestampBeforeFirstRequest,
+            uint256 amountDepositedBeforeFirstRequest
+        ) = commProxy.userChatData(requestSender);
+
+        assertEq(requestSenderBeforeFirstRequest, address(0));
+        assertEq(timestampBeforeFirstRequest, 0);
+        assertEq(amountDepositedBeforeFirstRequest, 0);
+
+        approveTokens(requestSender, address(commProxy), amount);
+        vm.prank(requestSender);
+        commProxy.createIncentivizeChatRequest(requestReceiver, amount);
+
+        (
+            address requestSenderAfterFirstRequest,
+            uint256 timestampAfterFirstRequest,
+            uint256 amountDepositedAfterFirstRequest
+        ) = commProxy.userChatData(requestSender);
+
+        uint256 blockTimestampInFirstRequest = block.timestamp;
+
+        assertEq(requestSenderAfterFirstRequest, requestSender);
+        assertEq(timestampAfterFirstRequest, blockTimestampInFirstRequest);
+        assertEq(amountDepositedAfterFirstRequest, amount);
+
+        uint256 forwardedTimestamp = 3000;
+        skip(forwardedTimestamp);
+
+        approveTokens(requestSender, address(commProxy), amount);
+        vm.prank(requestSender);
+        commProxy.createIncentivizeChatRequest(requestReceiver, amount);
+
+        (
+            address requestSenderAfterSecondRequest,
+            uint256 timestampAfterSecondRequest,
+            uint256 amountDepositedAfterSecondRequest
+        ) = commProxy.userChatData(requestSender);
+
+        assertEq(requestSenderAfterSecondRequest, requestSender);
+        assertEq(
+            timestampAfterSecondRequest,
+            blockTimestampInFirstRequest + forwardedTimestamp
+        );
+        assertEq(amountDepositedAfterSecondRequest, amount * 2);
+    }
+
+    function test_ShouldEmitRelevantEvent() public whenNotPaused {
+        address requestSender = actor.bob_channel_owner;
+        address requestReceiver = actor.charlie_channel_owner;
+        uint256 amount = 1e20;
+
+        approveTokens(requestSender, address(commProxy), amount);
+
+        vm.expectEmit(false, false, false, true, address(commProxy));
+        emit IncentivizeChatReqInitiated(
+            requestSender,
+            requestReceiver,
+            amount,
+            block.timestamp
+        );
+
+        vm.prank(requestSender);
+        commProxy.createIncentivizeChatRequest(requestReceiver, amount);
+    }
+}

testFoundry/PushCore/unit_tests/IncentivizedChatRequest/3_claimChatIncentives/claimChatIncentives.tree

@@ -0,0 +1,9 @@
+claimChatIncentives.t.sol
+    ├── when contract is Paused
+    │   └── it REVERT - EnforcedPause()
+    └── when contract is not Paused
+        ├── when claimable funds of caller is less than amount asked
+        │   └── it REVERT - InvalidArg_MoreThanExpected(claimable funds, _amount)
+        └── when claimable funds of caller is more than equal to amount asked
+            ├── should update claimable funds of caller and emit ChatIncentiveClaimed(msg.sender, _amount)
+            └── should transfer PUSH token equal to _amount passed