test(refactor): move all variables into Constants contract (#71)

* test(refactor): move all constants into CONSTANT contract test: remove redundant functions from Defaults test: remove Defaults contract fix bugs * test: move functions from Integration to Base test: rename function params with "_" * test: revert param names with underscore --------- Co-authored-by: andreivladbrg <[email protected]>
sablier-labs · Feb 20, 2025 · 958ce06 · 958ce06
1 parent f060524
commit 958ce06
Show file tree

Hide file tree

Showing 33 changed files with 695 additions and 972 deletions.
diff --git a/tests/Base.t.sol b/tests/Base.t.sol
diff --git a/tests/fork/Fork.t.sol b/tests/fork/Fork.t.sol
@@ -2,12 +2,11 @@
 pragma solidity >=0.8.22 <0.9.0;
 
 import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import { Merkle } from "murky/src/Merkle.sol";
 
 import { Base_Test } from "../Base.t.sol";
 
 /// @notice Common logic needed by all fork tests.
-abstract contract Fork_Test is Base_Test, Merkle {
+abstract contract Fork_Test is Base_Test {
     /*//////////////////////////////////////////////////////////////////////////
                                   STATE VARIABLES
     //////////////////////////////////////////////////////////////////////////*/

diff --git a/tests/fork/merkle-campaign/MerkleInstant.t.sol b/tests/fork/merkle-campaign/MerkleInstant.t.sol
@@ -16,7 +16,7 @@ import { Fork_Test } from "./../Fork.t.sol";
 abstract contract MerkleInstant_Fork_Test is Fork_Test {
     using MerkleBuilder for uint256[];
 
-    constructor(IERC20 token_) Fork_Test(token_) { }
+    constructor(IERC20 tokenAddress) Fork_Test(tokenAddress) { }
 
     /// @dev Encapsulates the data needed to compute a Merkle tree leaf.
     struct LeafData {
@@ -112,14 +112,14 @@ abstract contract MerkleInstant_Fork_Test is Fork_Test {
             campaignOwner: params.campaignOwner,
             expiration: params.expiration,
             merkleRoot: vars.merkleRoot,
-            token_: FORK_TOKEN
+            tokenAddress: FORK_TOKEN
         });
 
-        vars.params = defaults.merkleInstantConstructorParams({
+        vars.params = merkleInstantConstructorParams({
             campaignOwner: params.campaignOwner,
             expiration: params.expiration,
             merkleRoot: vars.merkleRoot,
-            token_: FORK_TOKEN
+            tokenAddress: FORK_TOKEN
         });
 
         vm.expectEmit({ emitter: address(merkleFactoryInstant) });
@@ -128,7 +128,7 @@ abstract contract MerkleInstant_Fork_Test is Fork_Test {
             params: vars.params,
             aggregateAmount: vars.aggregateAmount,
             recipientCount: vars.recipientCount,
-            fee: defaults.MINIMUM_FEE()
+            fee: MINIMUM_FEE
         });
 
         vars.merkleInstant =
@@ -180,7 +180,7 @@ abstract contract MerkleInstant_Fork_Test is Fork_Test {
 
         expectCallToClaimWithData({
             merkleLockup: address(vars.merkleInstant),
-            fee: defaults.MINIMUM_FEE(),
+            fee: MINIMUM_FEE,
             index: vars.indexes[params.posBeforeSort],
             recipient: vars.recipients[params.posBeforeSort],
             amount: vars.amounts[params.posBeforeSort],
@@ -193,7 +193,7 @@ abstract contract MerkleInstant_Fork_Test is Fork_Test {
             value: vars.amounts[params.posBeforeSort]
         });
 
-        vars.merkleInstant.claim{ value: defaults.MINIMUM_FEE() }({
+        vars.merkleInstant.claim{ value: MINIMUM_FEE }({
             index: vars.indexes[params.posBeforeSort],
             recipient: vars.recipients[params.posBeforeSort],
             amount: vars.amounts[params.posBeforeSort],
@@ -231,11 +231,11 @@ abstract contract MerkleInstant_Fork_Test is Fork_Test {
         emit ISablierMerkleFactoryBase.CollectFees({
             admin: factoryAdmin,
             merkleBase: vars.merkleInstant,
-            feeAmount: defaults.MINIMUM_FEE()
+            feeAmount: MINIMUM_FEE
         });
         merkleFactoryInstant.collectFees({ merkleBase: vars.merkleInstant });
 
         assertEq(address(vars.merkleInstant).balance, 0, "merkleInstant ETH balance");
-        assertEq(factoryAdmin.balance, initialAdminBalance + defaults.MINIMUM_FEE(), "admin ETH balance");
+        assertEq(factoryAdmin.balance, initialAdminBalance + MINIMUM_FEE, "admin ETH balance");
     }
 }
diff --git a/tests/fork/merkle-campaign/MerkleLL.t.sol b/tests/fork/merkle-campaign/MerkleLL.t.sol
@@ -19,7 +19,7 @@ import { Fork_Test } from "./../Fork.t.sol";
 abstract contract MerkleLL_Fork_Test is Fork_Test {
     using MerkleBuilder for uint256[];
 
-    constructor(IERC20 token_) Fork_Test(token_) { }
+    constructor(IERC20 tokenAddress) Fork_Test(tokenAddress) { }
 
     /// @dev Encapsulates the data needed to compute a Merkle tree leaf.
     struct LeafData {
@@ -117,15 +117,15 @@ abstract contract MerkleLL_Fork_Test is Fork_Test {
             campaignOwner: params.campaignOwner,
             expiration: params.expiration,
             merkleRoot: vars.merkleRoot,
-            token_: FORK_TOKEN
+            tokenAddress: FORK_TOKEN
         });
 
-        vars.params = defaults.merkleLLConstructorParams({
+        vars.params = merkleLLConstructorParams({
             campaignOwner: params.campaignOwner,
             expiration: params.expiration,
-            lockup: lockup,
+            lockupAddress: lockup,
             merkleRoot: vars.merkleRoot,
-            token_: FORK_TOKEN
+            tokenAddress: FORK_TOKEN
         });
 
         vm.expectEmit({ emitter: address(merkleFactoryLL) });
@@ -134,7 +134,7 @@ abstract contract MerkleLL_Fork_Test is Fork_Test {
             params: vars.params,
             aggregateAmount: vars.aggregateAmount,
             recipientCount: vars.recipientCount,
-            fee: defaults.MINIMUM_FEE()
+            fee: MINIMUM_FEE
         });
 
         vars.merkleLL = merkleFactoryLL.createMerkleLL(vars.params, vars.aggregateAmount, vars.recipientCount);
@@ -184,33 +184,31 @@ abstract contract MerkleLL_Fork_Test is Fork_Test {
 
         expectCallToClaimWithData({
             merkleLockup: address(vars.merkleLL),
-            fee: defaults.MINIMUM_FEE(),
+            fee: MINIMUM_FEE,
             index: vars.indexes[params.posBeforeSort],
             recipient: vars.recipients[params.posBeforeSort],
             amount: vars.amounts[params.posBeforeSort],
             merkleProof: vars.merkleProof
         });
 
-        vars.merkleLL.claim{ value: defaults.MINIMUM_FEE() }({
+        vars.merkleLL.claim{ value: MINIMUM_FEE }({
             index: vars.indexes[params.posBeforeSort],
             recipient: vars.recipients[params.posBeforeSort],
             amount: vars.amounts[params.posBeforeSort],
             merkleProof: vars.merkleProof
         });
 
         vars.expectedUnlockAmounts.start =
-            ud60x18(vars.amounts[params.posBeforeSort]).mul(defaults.START_PERCENTAGE().intoUD60x18()).intoUint128();
+            ud60x18(vars.amounts[params.posBeforeSort]).mul(START_PERCENTAGE.intoUD60x18()).intoUint128();
         vars.expectedUnlockAmounts.cliff =
-            ud60x18(vars.amounts[params.posBeforeSort]).mul(defaults.CLIFF_PERCENTAGE().intoUD60x18()).intoUint128();
+            ud60x18(vars.amounts[params.posBeforeSort]).mul(CLIFF_PERCENTAGE.intoUD60x18()).intoUint128();
 
         // Assert that the stream has been created successfully.
-        assertEq(
-            lockup.getCliffTime(vars.expectedStreamId), getBlockTimestamp() + defaults.CLIFF_DURATION(), "cliff time"
-        );
+        assertEq(lockup.getCliffTime(vars.expectedStreamId), getBlockTimestamp() + CLIFF_DURATION, "cliff time");
         assertEq(
             lockup.getDepositedAmount(vars.expectedStreamId), vars.amounts[params.posBeforeSort], "deposited amount"
         );
-        assertEq(lockup.getEndTime(vars.expectedStreamId), getBlockTimestamp() + defaults.TOTAL_DURATION(), "end time");
+        assertEq(lockup.getEndTime(vars.expectedStreamId), getBlockTimestamp() + TOTAL_DURATION, "end time");
         assertEq(lockup.getLockupModel(vars.expectedStreamId), Lockup.Model.LOCKUP_LINEAR);
         assertEq(lockup.getRecipient(vars.expectedStreamId), vars.recipients[params.posBeforeSort], "recipient");
         assertEq(lockup.getRefundedAmount(vars.expectedStreamId), 0, "refunded amount");
@@ -228,10 +226,10 @@ abstract contract MerkleLL_Fork_Test is Fork_Test {
             "unlock amounts start"
         );
         assertEq(lockup.getWithdrawnAmount(vars.expectedStreamId), 0, "withdrawn amount");
-        assertEq(lockup.isCancelable(vars.expectedStreamId), defaults.CANCELABLE(), "is cancelable");
+        assertEq(lockup.isCancelable(vars.expectedStreamId), CANCELABLE, "is cancelable");
         assertEq(lockup.isDepleted(vars.expectedStreamId), false, "is depleted");
         assertEq(lockup.isStream(vars.expectedStreamId), true, "is stream");
-        assertEq(lockup.isTransferable(vars.expectedStreamId), defaults.TRANSFERABLE(), "is transferable");
+        assertEq(lockup.isTransferable(vars.expectedStreamId), TRANSFERABLE, "is transferable");
         assertEq(lockup.wasCanceled(vars.expectedStreamId), false, "was canceled");
 
         assertTrue(vars.merkleLL.hasClaimed(vars.indexes[params.posBeforeSort]));
@@ -265,11 +263,11 @@ abstract contract MerkleLL_Fork_Test is Fork_Test {
         emit ISablierMerkleFactoryBase.CollectFees({
             admin: factoryAdmin,
             merkleBase: vars.merkleLL,
-            feeAmount: defaults.MINIMUM_FEE()
+            feeAmount: MINIMUM_FEE
         });
         merkleFactoryLL.collectFees({ merkleBase: vars.merkleLL });
 
         assertEq(address(vars.merkleLL).balance, 0, "merkleLL ETH balance");
-        assertEq(factoryAdmin.balance, initialAdminBalance + defaults.MINIMUM_FEE(), "admin ETH balance");
+        assertEq(factoryAdmin.balance, initialAdminBalance + MINIMUM_FEE, "admin ETH balance");
     }
 }
diff --git a/tests/fork/merkle-campaign/MerkleLT.t.sol b/tests/fork/merkle-campaign/MerkleLT.t.sol
@@ -17,7 +17,7 @@ import { Fork_Test } from "./../Fork.t.sol";
 abstract contract MerkleLT_Fork_Test is Fork_Test {
     using MerkleBuilder for uint256[];
 
-    constructor(IERC20 token_) Fork_Test(token_) { }
+    constructor(IERC20 tokenAddress) Fork_Test(tokenAddress) { }
 
     /// @dev Encapsulates the data needed to compute a Merkle tree leaf.
     struct LeafData {
@@ -115,15 +115,15 @@ abstract contract MerkleLT_Fork_Test is Fork_Test {
             campaignOwner: params.campaignOwner,
             expiration: params.expiration,
             merkleRoot: vars.merkleRoot,
-            token_: FORK_TOKEN
+            tokenAddress: FORK_TOKEN
         });
 
-        vars.params = defaults.merkleLTConstructorParams({
+        vars.params = merkleLTConstructorParams({
             campaignOwner: params.campaignOwner,
             expiration: params.expiration,
-            lockup: lockup,
+            lockupAddress: lockup,
             merkleRoot: vars.merkleRoot,
-            token_: FORK_TOKEN
+            tokenAddress: FORK_TOKEN
         });
 
         vm.expectEmit({ emitter: address(merkleFactoryLT) });
@@ -132,8 +132,8 @@ abstract contract MerkleLT_Fork_Test is Fork_Test {
             params: vars.params,
             aggregateAmount: vars.aggregateAmount,
             recipientCount: vars.recipientCount,
-            totalDuration: defaults.TOTAL_DURATION(),
-            fee: defaults.MINIMUM_FEE()
+            totalDuration: TOTAL_DURATION,
+            fee: MINIMUM_FEE
         });
 
         vars.merkleLT = merkleFactoryLT.createMerkleLT(vars.params, vars.aggregateAmount, vars.recipientCount);
@@ -182,14 +182,14 @@ abstract contract MerkleLT_Fork_Test is Fork_Test {
 
         expectCallToClaimWithData({
             merkleLockup: address(vars.merkleLT),
-            fee: defaults.MINIMUM_FEE(),
+            fee: MINIMUM_FEE,
             index: vars.indexes[params.posBeforeSort],
             recipient: vars.recipients[params.posBeforeSort],
             amount: vars.amounts[params.posBeforeSort],
             merkleProof: vars.merkleProof
         });
 
-        vars.merkleLT.claim{ value: defaults.MINIMUM_FEE() }({
+        vars.merkleLT.claim{ value: MINIMUM_FEE }({
             index: vars.indexes[params.posBeforeSort],
             recipient: vars.recipients[params.posBeforeSort],
             amount: vars.amounts[params.posBeforeSort],
@@ -200,22 +200,22 @@ abstract contract MerkleLT_Fork_Test is Fork_Test {
         assertEq(
             lockup.getDepositedAmount(vars.expectedStreamId), vars.amounts[params.posBeforeSort], "deposited amount"
         );
-        assertEq(lockup.getEndTime(vars.expectedStreamId), getBlockTimestamp() + defaults.TOTAL_DURATION(), "end time");
+        assertEq(lockup.getEndTime(vars.expectedStreamId), getBlockTimestamp() + TOTAL_DURATION, "end time");
         assertEq(lockup.getLockupModel(vars.expectedStreamId), Lockup.Model.LOCKUP_TRANCHED);
         assertEq(lockup.getRecipient(vars.expectedStreamId), vars.recipients[params.posBeforeSort], "recipient");
         assertEq(lockup.getRefundedAmount(vars.expectedStreamId), 0, "refunded amount");
         assertEq(lockup.getSender(vars.expectedStreamId), params.campaignOwner, "sender");
         assertEq(lockup.getStartTime(vars.expectedStreamId), getBlockTimestamp(), "start time");
         assertEq(
             lockup.getTranches(vars.expectedStreamId),
-            defaults.tranchesMerkleLT({ streamStartTime: ZERO, totalAmount: vars.amounts[params.posBeforeSort] })
+            tranchesMerkleLT({ streamStartTime: ZERO, totalAmount: vars.amounts[params.posBeforeSort] })
         );
         assertEq(lockup.getUnderlyingToken(vars.expectedStreamId), FORK_TOKEN, "token");
         assertEq(lockup.getWithdrawnAmount(vars.expectedStreamId), 0, "withdrawn amount");
-        assertEq(lockup.isCancelable(vars.expectedStreamId), defaults.CANCELABLE(), "is cancelable");
+        assertEq(lockup.isCancelable(vars.expectedStreamId), CANCELABLE, "is cancelable");
         assertEq(lockup.isDepleted(vars.expectedStreamId), false, "is depleted");
         assertEq(lockup.isStream(vars.expectedStreamId), true, "is stream");
-        assertEq(lockup.isTransferable(vars.expectedStreamId), defaults.TRANSFERABLE(), "is transferable");
+        assertEq(lockup.isTransferable(vars.expectedStreamId), TRANSFERABLE, "is transferable");
         assertEq(lockup.wasCanceled(vars.expectedStreamId), false, "was canceled");
 
         assertTrue(vars.merkleLT.hasClaimed(vars.indexes[params.posBeforeSort]));
@@ -250,11 +250,11 @@ abstract contract MerkleLT_Fork_Test is Fork_Test {
         emit ISablierMerkleFactoryBase.CollectFees({
             admin: factoryAdmin,
             merkleBase: vars.merkleLT,
-            feeAmount: defaults.MINIMUM_FEE()
+            feeAmount: MINIMUM_FEE
         });
         merkleFactoryLT.collectFees({ merkleBase: vars.merkleLT });
 
         assertEq(address(vars.merkleLT).balance, 0, "merkleLT ETH balance");
-        assertEq(factoryAdmin.balance, initialAdminBalance + defaults.MINIMUM_FEE(), "admin ETH balance");
+        assertEq(factoryAdmin.balance, initialAdminBalance + MINIMUM_FEE, "admin ETH balance");
     }
 }
diff --git a/tests/fork/merkle-campaign/MerkleVCA.t.sol b/tests/fork/merkle-campaign/MerkleVCA.t.sol
@@ -16,7 +16,7 @@ import { Fork_Test } from "./../Fork.t.sol";
 abstract contract MerkleVCA_Fork_Test is Fork_Test {
     using MerkleBuilder for uint256[];
 
-    constructor(IERC20 token_) Fork_Test(token_) { }
+    constructor(IERC20 tokenAddress) Fork_Test(tokenAddress) { }
 
     /// @dev Encapsulates the data needed to compute a Merkle tree leaf.
     struct LeafData {
@@ -124,15 +124,15 @@ abstract contract MerkleVCA_Fork_Test is Fork_Test {
             expiration: params.expiration,
             merkleRoot: vars.merkleRoot,
             timestamps: params.timestamps,
-            token_: FORK_TOKEN
+            tokenAddress: FORK_TOKEN
         });
 
-        vars.params = defaults.merkleVCAConstructorParams({
+        vars.params = merkleVCAConstructorParams({
             campaignOwner: params.campaignOwner,
             expiration: params.expiration,
             merkleRoot: vars.merkleRoot,
             timestamps: params.timestamps,
-            token_: FORK_TOKEN
+            tokenAddress: FORK_TOKEN
         });
 
         vm.expectEmit({ emitter: address(merkleFactoryVCA) });
@@ -141,7 +141,7 @@ abstract contract MerkleVCA_Fork_Test is Fork_Test {
             params: vars.params,
             aggregateAmount: vars.aggregateAmount,
             recipientCount: vars.recipientCount,
-            fee: defaults.MINIMUM_FEE()
+            fee: MINIMUM_FEE
         });
 
         vars.merkleVCA = merkleFactoryVCA.createMerkleVCA(vars.params, vars.aggregateAmount, vars.recipientCount);
@@ -198,7 +198,7 @@ abstract contract MerkleVCA_Fork_Test is Fork_Test {
 
         expectCallToClaimWithData({
             merkleLockup: address(vars.merkleVCA),
-            fee: defaults.MINIMUM_FEE(),
+            fee: MINIMUM_FEE,
             index: vars.indexes[params.posBeforeSort],
             recipient: vars.recipients[params.posBeforeSort],
             amount: vars.amounts[params.posBeforeSort],
@@ -211,7 +211,7 @@ abstract contract MerkleVCA_Fork_Test is Fork_Test {
             value: vars.claimableAmount
         });
 
-        vars.merkleVCA.claim{ value: defaults.MINIMUM_FEE() }({
+        vars.merkleVCA.claim{ value: MINIMUM_FEE }({
             index: vars.indexes[params.posBeforeSort],
             recipient: vars.recipients[params.posBeforeSort],
             amount: vars.amounts[params.posBeforeSort],
@@ -250,11 +250,11 @@ abstract contract MerkleVCA_Fork_Test is Fork_Test {
         emit ISablierMerkleFactoryBase.CollectFees({
             admin: factoryAdmin,
             merkleBase: vars.merkleVCA,
-            feeAmount: defaults.MINIMUM_FEE()
+            feeAmount: MINIMUM_FEE
         });
         merkleFactoryVCA.collectFees({ merkleBase: vars.merkleVCA });
 
         assertEq(address(vars.merkleVCA).balance, 0, "merkleVCA ETH balance");
-        assertEq(factoryAdmin.balance, initialAdminBalance + defaults.MINIMUM_FEE(), "admin ETH balance");
+        assertEq(factoryAdmin.balance, initialAdminBalance + MINIMUM_FEE, "admin ETH balance");
     }
 }