test: update deposit, refundableAmountOf and withdrawMax tests

test/integration/deposit/deposit.t.sol

@@ -23,16 +23,19 @@ contract Deposit_Integration_Test is Integration_Test {
         openEnded.deposit(nullStreamId, DEPOSIT_AMOUNT);
     }
 
-    function test_RevertGiven_Paused() external whenNotDelegateCalled givenNotNull {
-        expectRevertPaused();
-        openEnded.deposit(defaultStreamId, DEPOSIT_AMOUNT);
-    }
-
     function test_RevertWhen_DepositAmountZero() external whenNotDelegateCalled givenNotNull givenNotPaused {
         vm.expectRevert(Errors.SablierV2OpenEnded_DepositAmountZero.selector);
         openEnded.deposit(defaultStreamId, 0);
     }
 
+    function test_Deposit_Paused() external whenNotDelegateCalled givenNotNull {
+        openEnded.deposit(defaultStreamId, DEPOSIT_AMOUNT);
+
+        uint128 actualStreamBalance = openEnded.getBalance(defaultStreamId);
+        uint128 expectedStreamBalance = DEPOSIT_AMOUNT;
+        assertEq(actualStreamBalance, expectedStreamBalance, "stream balance");
+    }
+
     function test_Deposit_AssetMissingReturnValue_AssetNot18Decimals()
         external
         whenNotDelegateCalled

test/integration/deposit/deposit.tree

@@ -5,12 +5,12 @@ deposit.t.sol
    ├── given the id references a null stream
    │  └── it should revert
    └── given the id does not reference a null stream
-      ├── given the id references a paused stream
-      │  └── it should revert
-      └── given the id does not reference a paused stream
-         ├── when the deposit amount is zero
+      ├── when the deposit amount is zero
+      │  └── it should deposit on the stream
+      └── when the deposit amount is not zero
+         ├── given the id references a paused stream
          │  └── it should revert
-         └── when the deposit amount is not zero
+         └── given the id does not reference a paused stream
             ├── when the asset misses the ERC-20 return 
             │  └── it should make the deposit
             └── when the asset does not miss the ERC-20 return value

test/integration/refundable-amount-of/refundableAmountOf.t.sol

@@ -13,16 +13,22 @@ contract RefundableAmountOf_Integration_Test is Integration_Test {
         openEnded.refundableAmountOf(nullStreamId);
     }
 
-    function test_RevertGiven_Paused() external givenNotNull {
-        expectRevertPaused();
-        openEnded.refundableAmountOf(defaultStreamId);
-    }
-
     function test_RefundableAmountOf_BalanceZero() external view givenNotNull givenNotPaused {
         uint128 refundableAmount = openEnded.refundableAmountOf(defaultStreamId);
         assertEq(refundableAmount, 0, "refundable amount");
     }
 
+    function test_RefundableAmountOf_Paused() external givenNotNull {
+        defaultDeposit();
+        openEnded.refundableAmountOf(defaultStreamId);
+
+        vm.warp({ newTimestamp: WARP_ONE_MONTH });
+        openEnded.pause(defaultStreamId);
+
+        uint128 refundableAmount = openEnded.refundableAmountOf(defaultStreamId);
+        assertEq(refundableAmount, ONE_MONTH_REFUNDABLE_AMOUNT, "refundable amount");
+    }
+
     function test_RefundableAmountOf_BalanceLessThanOrEqualStreamedAmount() external givenNotNull givenNotPaused {
         uint128 depositAmount = 1e18;
         openEnded.deposit(defaultStreamId, depositAmount);

test/integration/refundable-amount-of/refundableAmountOf.tree

@@ -2,12 +2,12 @@ refundableAmountOf.t.sol
 ├── given the id references a null stream
 │  └── it should revert
 └── given the id does not reference a null stream
-   ├── given the id references a paused stream
-   │  └── it should revert
-   └── given the id does not reference a paused stream
-      ├── given the stream balance is zero
-      │  └── it should return zero
-      └── given the stream balance is not zero
+   ├── given the stream balance is zero
+   │  └── it should return zero
+   └── given the stream balance is not zero
+      ├── given the id references a paused stream
+      │  └── it should return the correct refundable amount
+      └── given the id does not reference a paused stream
          ├── given the stream balance is less than or equal to the streamed amount
          │  └── it should return zero
          └── given the stream balance is greater than the streamed amount

test/integration/withdraw-max/withdrawMax.t.sol

@@ -17,31 +17,25 @@ contract WithdrawMax_Integration_Concrete_Test is Integration_Test {
     function test_WithdrawMax_Paused() external {
         openEnded.pause(defaultStreamId);
 
-        uint128 beforeStreamBalance = openEnded.getBalance(defaultStreamId);
-        uint128 beforeRemainingAmount = openEnded.getRemainingAmount(defaultStreamId);
-
         vm.expectEmit({ emitter: address(dai) });
-        emit IERC20.Transfer({
-            from: address(openEnded),
-            to: users.recipient,
-            value: normalizeTransferAmount(defaultStreamId, beforeRemainingAmount)
-        });
+        emit IERC20.Transfer({ from: address(openEnded), to: users.recipient, value: ONE_MONTH_STREAMED_AMOUNT });
 
         vm.expectEmit({ emitter: address(openEnded) });
         emit WithdrawFromOpenEndedStream({
             streamId: defaultStreamId,
             to: users.recipient,
             asset: dai,
-            withdrawnAmount: beforeRemainingAmount
+            withdrawnAmount: ONE_MONTH_STREAMED_AMOUNT
         });
 
         openEnded.withdrawMax(defaultStreamId, users.recipient);
 
-        uint128 afterStreamBalance = openEnded.getBalance(defaultStreamId);
-        uint128 afterRemainingAmount = openEnded.getRemainingAmount(defaultStreamId);
+        uint128 actualStreamBalance = openEnded.getBalance(defaultStreamId);
+        uint128 expectedStreamBalance = DEPOSIT_AMOUNT - ONE_MONTH_STREAMED_AMOUNT;
+        assertEq(actualStreamBalance, expectedStreamBalance, "stream balance");
 
-        assertEq(beforeStreamBalance, afterStreamBalance, "stream balance should not change");
-        assertEq(afterRemainingAmount, 0, "remaining amount should be 0");
+        uint128 actualRemainingAmount = openEnded.getRemainingAmount(defaultStreamId);
+        assertEq(actualRemainingAmount, 0, "remaining amount");
         assertEq(openEnded.getLastTimeUpdate(defaultStreamId), WARP_ONE_MONTH, "last time update not updated");
     }
 

test/integration/withdraw-max/withdrawMax.tree

@@ -3,8 +3,9 @@ withdrawMax.t.sol
 │  └── it should withdraw the remaining amount
 └── given the end time is not paused
    ├── it should make the max withdrawal
+   ├── it should update the time
    ├── it should set the remaining amount to zero
    ├── it should update the stream balance
-   ├── it should update the time
    ├── it should perform the ERC-20 transfer
-   └── it should emit a {Transfer} and {WithdrawFromOpenEndedStream} event
+   ├── it should emit a {Transfer} and {WithdrawFromOpenEndedStream} event
+   └── it should emit a {MetadataUpdated} event