test(refactor): use bulloak for concrete tests (#153)

* test(refactor): use bulloak for concrete tests

test(bulloak): deposit
test(refactor): use 'delegate call' instead of 'deletage called'
test(modifiers): rename to whenDepositAmountIsNotZero

test(bulloak): adjustRatePerSecond
test: use "when no delegate call", whenNoDelegateCall
test: rename whenCallerIsNotSender to whenCallerNotSender

test(bulloak): pause
test: use getBlockTimestamp()

test(bulloak): recent-amount-of

test(bulloak): refund

test(bulloak): refundableAmountOf

test(bulloak): restart

test(bulloak): restartAndDeposit

test(bulloak): streamDebtOf

test(bulloak): transferFrom

test(bulloak): withdrawableAmountOf
test(refactor): rename createDefaultStreamWithAsset to createStreamWithAsset
test(refactor): use "when" for last time update in branches

test(bulloak): withdrawMax

test(bulloak): create and withdrawAt

test(refactor): remove redundant modifiers

* fix: merge conflicts

* test(refactor): move Helper libraries to Integration

* test(fix): test_WhenAmountOwedExceedsBalance in WithdrawAt_Integration_Concrete_Test

* refactor: rename custom error

test: move functions in Utils
test: move function in Integration_Test
test: remove "Is" from tree branches
test: "It should revert" comments

* test: fix comments

* test: fix bulloak warnings

---------

Co-authored-by: andreivladbrg <andreivladbrg@gmail.com>

src/SablierFlow.sol

@@ -531,9 +531,9 @@ contract SablierFlow is
 
     /// @dev See the documentation for the user-facing functions that call this internal function.
     function _deposit(uint256 streamId, uint128 transferAmount) internal {
-        // Check: the deposit amount is not zero.
+        // Check: the transfer amount is not zero.
         if (transferAmount == 0) {
-            revert Errors.SablierFlow_DepositAmountZero();
+            revert Errors.SablierFlow_TransferAmountZero();
         }
 
         // Retrieve the ERC-20 asset from storage.

src/libraries/Errors.sol

@@ -33,8 +33,8 @@ library Errors {
     /// @notice Thrown when trying to create a stream with a broker recipient address as zero.
     error SablierFlow_BrokerAddressZero();
 
-    /// @notice Thrown when trying to create a stream with a zero deposit amount.
-    error SablierFlow_DepositAmountZero();
+    /// @notice Thrown when trying to create a stream with a zero transfer amount.
+    error SablierFlow_TransferAmountZero();
 
     /// @notice Thrown when trying to create a stream with an asset with no decimals.
     error SablierFlow_InvalidAssetDecimals(address asset);

test/integration/Integration.t.sol

@@ -31,10 +31,10 @@ abstract contract Integration_Test is Base_Test {
     }
 
     function createDefaultStream() internal returns (uint256) {
-        return createDefaultStreamWithAsset(dai);
+        return createStreamWithAsset(dai);
     }
 
-    function createDefaultStreamWithAsset(IERC20 asset_) internal returns (uint256) {
+    function createStreamWithAsset(IERC20 asset_) internal returns (uint256) {
         return flow.create({
             sender: users.sender,
             recipient: users.recipient,
@@ -48,6 +48,22 @@ abstract contract Integration_Test is Base_Test {
         flow.deposit(defaultStreamId, TRANSFER_AMOUNT);
     }
 
+    function depositToStreamId(uint256 streamId, uint128 amount) internal {
+        flow.deposit(streamId, amount);
+    }
+
+    /// @dev Update the `lastTimeUpdate` of a stream to the current block timestamp.
+    function updateLastTimeToBlockTimestamp(uint256 streamId) internal {
+        resetPrank(users.sender);
+        uint128 ratePerSecond = flow.getRatePerSecond(streamId);
+
+        // Updates the last time update via `adjustRatePerSecond`.
+        flow.adjustRatePerSecond(streamId, 1);
+
+        // Restores the rate per second.
+        flow.adjustRatePerSecond(streamId, ratePerSecond);
+    }
+
     /*//////////////////////////////////////////////////////////////////////////
                                 COMMON-REVERT-TESTS
     //////////////////////////////////////////////////////////////////////////*/

test/integration/concrete/adjust-rate-per-second/adjustRatePerSecond.t.sol

@@ -6,117 +6,74 @@ import { Errors } from "src/libraries/Errors.sol";
 import { Integration_Test } from "../../Integration.t.sol";
 
 contract AdjustRatePerSecond_Integration_Concrete_Test is Integration_Test {
-    function setUp() public override {
-        Integration_Test.setUp();
-    }
-
     function test_RevertWhen_DelegateCall() external {
         bytes memory callData = abi.encodeCall(flow.adjustRatePerSecond, (defaultStreamId, RATE_PER_SECOND));
         expectRevert_DelegateCall(callData);
     }
 
-    function test_RevertGiven_Null() external whenNotDelegateCalled {
+    function test_RevertGiven_Null() external whenNoDelegateCall {
         bytes memory callData = abi.encodeCall(flow.adjustRatePerSecond, (nullStreamId, RATE_PER_SECOND));
         expectRevert_Null(callData);
     }
 
-    function test_RevertGiven_Paused() external whenNotDelegateCalled givenNotNull {
+    function test_RevertGiven_Paused() external whenNoDelegateCall givenNotNull {
         bytes memory callData = abi.encodeCall(flow.adjustRatePerSecond, (defaultStreamId, RATE_PER_SECOND));
         expectRevert_Paused(callData);
     }
 
     function test_RevertWhen_CallerRecipient()
         external
-        whenNotDelegateCalled
+        whenNoDelegateCall
         givenNotNull
         givenNotPaused
-        whenCallerIsNotSender
+        whenCallerNotSender
     {
         bytes memory callData = abi.encodeCall(flow.adjustRatePerSecond, (defaultStreamId, RATE_PER_SECOND));
         expectRevert_CallerRecipient(callData);
     }
 
     function test_RevertWhen_CallerMaliciousThirdParty()
         external
-        whenNotDelegateCalled
+        whenNoDelegateCall
         givenNotNull
         givenNotPaused
-        whenCallerIsNotSender
+        whenCallerNotSender
     {
         bytes memory callData = abi.encodeCall(flow.adjustRatePerSecond, (defaultStreamId, RATE_PER_SECOND));
         expectRevert_CallerMaliciousThirdParty(callData);
     }
 
-    function test_RevertWhen_RatePerSecondZero()
+    function test_RevertWhen_NewRatePerSecondZero()
         external
-        whenNotDelegateCalled
+        whenNoDelegateCall
         givenNotNull
         givenNotPaused
-        whenCallerIsSender
+        whenCallerSender
     {
         vm.expectRevert(Errors.SablierFlow_RatePerSecondZero.selector);
         flow.adjustRatePerSecond({ streamId: defaultStreamId, newRatePerSecond: 0 });
     }
 
-    function test_RevertWhen_RatePerSecondNotDifferent()
+    function test_RevertWhen_NewRatePerSecondEqualsCurrentRatePerSecond()
         external
-        whenNotDelegateCalled
+        whenNoDelegateCall
         givenNotNull
         givenNotPaused
-        whenCallerIsSender
-        whenRatePerSecondIsNotZero
+        whenCallerSender
+        whenNewRatePerSecondNotZero
     {
         vm.expectRevert(abi.encodeWithSelector(Errors.SablierFlow_RatePerSecondNotDifferent.selector, RATE_PER_SECOND));
         flow.adjustRatePerSecond({ streamId: defaultStreamId, newRatePerSecond: RATE_PER_SECOND });
     }
 
-    function test_AdjustRatePerSecond_WithdrawableAmountZero()
+    function test_WhenNewRatePerSecondNotEqualsCurrentRatePerSecond()
         external
-        whenNotDelegateCalled
+        whenNoDelegateCall
         givenNotNull
         givenNotPaused
-        whenCallerIsSender
-        whenRatePerSecondIsNotZero
-        whenRatePerSecondNotDifferent
+        whenCallerSender
+        whenNewRatePerSecondNotZero
     {
-        vm.warp({ newTimestamp: WARP_ONE_MONTH });
-
-        uint40 actualLastTimeUpdate = flow.getLastTimeUpdate(defaultStreamId);
-        uint40 expectedLastTimeUpdate = uint40(block.timestamp - ONE_MONTH);
-        assertEq(actualLastTimeUpdate, expectedLastTimeUpdate, "last time updated");
-
-        uint128 newRatePerSecond = RATE_PER_SECOND / 2;
-
-        vm.expectEmit({ emitter: address(flow) });
-        emit AdjustFlowStream({
-            streamId: defaultStreamId,
-            oldRatePerSecond: RATE_PER_SECOND,
-            newRatePerSecond: newRatePerSecond,
-            amountOwed: ONE_MONTH_STREAMED_AMOUNT
-        });
-
-        vm.expectEmit({ emitter: address(flow) });
-        emit MetadataUpdate({ _tokenId: defaultStreamId });
-
-        uint128 actualRemainingAmount = flow.getRemainingAmount(defaultStreamId);
-        assertEq(actualRemainingAmount, 0, "remaining amount");
-
-        flow.adjustRatePerSecond({ streamId: defaultStreamId, newRatePerSecond: newRatePerSecond });
-
-        actualRemainingAmount = flow.getRemainingAmount(defaultStreamId);
-        uint128 expectedRemainingAmount = ONE_MONTH_STREAMED_AMOUNT;
-        assertEq(actualRemainingAmount, expectedRemainingAmount, "remaining amount");
-
-        uint128 actualRatePerSecond = flow.getRatePerSecond(defaultStreamId);
-        uint128 expectedRatePerSecond = newRatePerSecond;
-        assertEq(actualRatePerSecond, expectedRatePerSecond, "rate per second");
-
-        actualLastTimeUpdate = flow.getLastTimeUpdate(defaultStreamId);
-        expectedLastTimeUpdate = uint40(block.timestamp);
-        assertEq(actualLastTimeUpdate, expectedLastTimeUpdate, "last time updated");
-    }
-
-    function test_AdjustRatePerSecond() external whenNotDelegateCalled givenNotNull givenNotPaused whenCallerIsSender {
         flow.deposit(defaultStreamId, TRANSFER_AMOUNT);
         vm.warp({ newTimestamp: WARP_ONE_MONTH });
 
@@ -125,7 +82,7 @@ contract AdjustRatePerSecond_Integration_Concrete_Test is Integration_Test {
         assertEq(actualRatePerSecond, expectedRatePerSecond, "rate per second");
 
         uint40 actualLastTimeUpdate = flow.getLastTimeUpdate(defaultStreamId);
-        uint40 expectedLastTimeUpdate = uint40(block.timestamp - ONE_MONTH);
+        uint40 expectedLastTimeUpdate = getBlockTimestamp() - ONE_MONTH;
         assertEq(actualLastTimeUpdate, expectedLastTimeUpdate, "last time updated");
 
         uint128 actualRemainingAmount = flow.getRemainingAmount(defaultStreamId);
@@ -134,6 +91,7 @@ contract AdjustRatePerSecond_Integration_Concrete_Test is Integration_Test {
 
         uint128 newRatePerSecond = RATE_PER_SECOND / 2;
 
+        // It should emit 1 {AdjustFlowStream}, 1 {MetadataUpdate} events.
         vm.expectEmit({ emitter: address(flow) });
         emit AdjustFlowStream({
             streamId: defaultStreamId,
@@ -147,16 +105,19 @@ contract AdjustRatePerSecond_Integration_Concrete_Test is Integration_Test {
 
         flow.adjustRatePerSecond({ streamId: defaultStreamId, newRatePerSecond: newRatePerSecond });
 
+        // It should update remaining amount.
         actualRemainingAmount = flow.getRemainingAmount(defaultStreamId);
         expectedRemainingAmount = ONE_MONTH_STREAMED_AMOUNT;
         assertEq(actualRemainingAmount, expectedRemainingAmount, "remaining amount");
 
+        // It should set the new rate per second
         actualRatePerSecond = flow.getRatePerSecond(defaultStreamId);
         expectedRatePerSecond = newRatePerSecond;
         assertEq(actualRatePerSecond, expectedRatePerSecond, "rate per second");
 
+        // It should update lastTimeUpdate
         actualLastTimeUpdate = flow.getLastTimeUpdate(defaultStreamId);
-        expectedLastTimeUpdate = uint40(block.timestamp);
+        expectedLastTimeUpdate = getBlockTimestamp();
         assertEq(actualLastTimeUpdate, expectedLastTimeUpdate, "last time updated");
     }
 }

test/integration/concrete/adjust-rate-per-second/adjustRatePerSecond.tree

@@ -1,34 +1,26 @@
-adjustRatePerSecond.t.sol
-├── when delegate called
+AdjustRatePerSecond_Integration_Concrete_Test
+├── when delegate call
 │  └── it should revert
-└── when not delegate called
-   ├── given the id references a null stream
+└── when no delegate call
+   ├── given null
    │  └── it should revert
-   └── given the id does not reference a null stream
-      ├── given the id references a paused stream
+   └── given not null
+      ├── given paused
       │  └── it should revert
-      └── given the id does not reference a paused stream
-          ├── when the caller is not the sender
-          │  ├── when the caller is the recipient
+      └── given not paused
+          ├── when caller not sender
+          │  ├── when caller recipient
           │  │  └── it should revert
-          │  └── when the caller is a malicious third party
+          │  └── when caller malicious third party
           │     └── it should revert
-          └── when the caller is the sender
-              ├── when the provided rate per second is zero
+          └── when caller sender
+              ├── when new rate per second zero
               │  └── it should revert
-              └── when the provided rate per second is not zero
-                 ├── when the provided rate per second is equal to the actual rate per second
+              └── when new rate per second not zero
+                 ├── when new rate per second equals current rate per second
                  │  └── it should revert
-                 └── when the provided rate per second is not equal to the actual rate per second
-                    ├── given the withdrawable amount is zero
-                    │  ├── it should update the stream remaining amount
-                    │  ├── it should update the rate per second
-                    │  ├── it should update the stream time
-                    │  ├── it should emit a {AdjustFlowStream} event
-                    │  └── it should emit a {MetadataUpdate} event
-                    └── given the withdrawable amount is not zero
-                       ├── it should update the stream remaining amount
-                       ├── it should update the rate per second
-                       ├── it should update the stream time
-                       ├── it should emit a {AdjustFlowStream} event
-                       └── it should emit a {MetadataUpdate} event   
+                 └── when new rate per second not equals current rate per second
+                    ├── it should update remaining amount
+                    ├── it should update lastTimeUpdate
+                    ├── it should set the new rate per second
+                    └── it should emit 1 {AdjustFlowStream}, 1 {MetadataUpdate} events

test/integration/concrete/amount-owed-of/amountOwedOf.t.sol

@@ -7,6 +7,7 @@ contract AmountOwedOf_Integration_Concrete_Test is Integration_Test {
     function setUp() public virtual override {
         Integration_Test.setUp();
 
+        // Simulate one month of streaming.
         vm.warp({ newTimestamp: WARP_ONE_MONTH });
     }
 
@@ -37,7 +38,7 @@ contract AmountOwedOf_Integration_Concrete_Test is Integration_Test {
         assertEq(amountOwed, remainingAmount, "amount owed");
     }
 
-    function test_WhenCurrentTimeIsGreaterThanLastTimeUpdate() external view givenNotNull givenNotPaused {
+    function test_WhenCurrentTimeGreaterThanLastTimeUpdate() external view givenNotNull givenNotPaused {
         // Fetch updated remaining amount
         uint128 remainingAmount = flow.getRemainingAmount(defaultStreamId);
         uint128 recentAmount = flow.recentAmountOf(defaultStreamId);

test/integration/concrete/amount-owed-of/amountOwedOf.tree

@@ -7,5 +7,5 @@ AmountOwedOf_Integration_Concrete_Test
     └── given not paused
         ├── when current time equals last time update
         │   └── it should return remaining amount
-        └── when current time is greater than last time update
+        └── when current time greater than last time update
             └── it should return the sum of remaining amount and recent amount.

test/integration/concrete/create-and-deposit-via-broker/createAndDepositViaBroker.t.sol

@@ -24,7 +24,7 @@ contract CreateAndDepositViaBroker_Integration_Concrete_Test is Integration_Test
         expectRevert_DelegateCall(callData);
     }
 
-    function test_WhenNotDelegateCalled() external {
+    function test_WhenNoDelegateCall() external {
         uint256 expectedStreamId = flow.nextStreamId();
 
         // It should emit events: 1 {MetadataUpdate}, 1 {CreateFlowStream}, 2 {Transfer}, 1
@@ -39,7 +39,7 @@ contract CreateAndDepositViaBroker_Integration_Concrete_Test is Integration_Test
             recipient: users.recipient,
             ratePerSecond: RATE_PER_SECOND,
             asset: dai,
-            lastTimeUpdate: uint40(block.timestamp)
+            lastTimeUpdate: getBlockTimestamp()
         });
 
         vm.expectEmit({ emitter: address(dai) });
@@ -77,7 +77,7 @@ contract CreateAndDepositViaBroker_Integration_Concrete_Test is Integration_Test
             asset: dai,
             assetDecimals: 18,
             balance: DEPOSIT_AMOUNT,
-            lastTimeUpdate: uint40(block.timestamp),
+            lastTimeUpdate: getBlockTimestamp(),
             isPaused: false,
             isStream: true,
             isTransferable: IS_TRANFERABLE,

test/integration/concrete/create-and-deposit-via-broker/createAndDepositViaBroker.tree

@@ -1,7 +1,7 @@
 CreateAndDepositViaBroker_Integration_Concrete_Test
 ├── when delegate call
 │   └── it should revert
-└── when not delegate call
+└── when no delegate call
     ├── it should create the stream
     ├── it should bump the next stream id
     ├── it should mint the NFT