@bananapus/core-v6 0.0.1

package/test/units/static/JBController/TestSetTokenFor.sol

@@ -0,0 +1,227 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBControllerSetup} from "./JBControllerSetup.sol";
+
+contract TestSetTokenFor_Local is JBControllerSetup {
+    IJBToken _token = IJBToken(makeAddr("token"));
+    uint256 _projectId = 1;
+
+    function setUp() public {
+        super.controllerSetup();
+    }
+
+    function test_WhenCallerIsPermissionedAndCurrentRuleset() external {
+        // it will set token
+
+        // mock ownerOf call to auth this contract (caller)
+        bytes memory _ownerOfCall = abi.encodeCall(IERC721.ownerOf, (_projectId));
+        bytes memory _ownerOfReturn = abi.encode(address(this));
+        mockExpect(address(projects), _ownerOfCall, _ownerOfReturn);
+
+        // mock call to JBTokens
+        bytes memory _tokensCall = abi.encodeCall(IJBTokens.setTokenFor, (_projectId, _token));
+        mockExpect(address(tokens), _tokensCall, "");
+
+        // mock call to JBRulesets
+
+        // setup: return data
+        JBRulesetMetadata memory _metadata = JBRulesetMetadata({
+            reservedPercent: JBConstants.MAX_RESERVED_PERCENT / 2, //50%
+            cashOutTaxRate: JBConstants.MAX_CASH_OUT_TAX_RATE / 2, //50%
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: true,
+            allowSetCustomToken: true, // Allows authorized to set a token or mint tokens
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: false,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: false,
+            useTotalSurplusForCashOuts: true,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+
+        uint256 _packedMetadata = JBRulesetMetadataResolver.packRulesetMetadata(_metadata);
+
+        JBRuleset memory ruleset = JBRuleset({
+            cycleNumber: 1,
+            id: uint48(block.timestamp),
+            basedOnId: 0,
+            start: uint48(block.timestamp),
+            duration: 8000,
+            weight: 5000,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: _packedMetadata
+        });
+
+        bytes memory _currentRulesetCall = abi.encodeCall(IJBRulesets.currentOf, (1));
+        mockExpect(address(rulesets), _currentRulesetCall, abi.encode(ruleset));
+
+        _controller.setTokenFor(_projectId, _token);
+    }
+
+    function test_WhenCallerIsPermissionedAndNoCurrentRulesetButUpcomingCompatible() external {
+        // it will set token
+
+        // mock ownerOf call to auth this contract (caller)
+        bytes memory _ownerOfCall = abi.encodeCall(IERC721.ownerOf, (_projectId));
+        bytes memory _ownerOfReturn = abi.encode(address(this));
+        mockExpect(address(projects), _ownerOfCall, _ownerOfReturn);
+
+        // mock call to JBTokens
+        bytes memory _tokensCall = abi.encodeCall(IJBTokens.setTokenFor, (_projectId, _token));
+        mockExpect(address(tokens), _tokensCall, "");
+
+        // mock call to JBRulesets
+
+        // setup: return data
+        JBRulesetMetadata memory _metadata = JBRulesetMetadata({
+            reservedPercent: JBConstants.MAX_RESERVED_PERCENT / 2, //50%
+            cashOutTaxRate: JBConstants.MAX_CASH_OUT_TAX_RATE / 2, //50%
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: true,
+            allowSetCustomToken: true, // Allows authorized to set a token or mint tokens
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: false,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: false,
+            useTotalSurplusForCashOuts: true,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+
+        uint256 _packedMetadata = JBRulesetMetadataResolver.packRulesetMetadata(_metadata);
+
+        JBRuleset memory ruleset = JBRuleset({
+            cycleNumber: 0,
+            id: 0,
+            basedOnId: 0,
+            start: 0,
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: 0
+        });
+
+        JBRuleset memory upcoming = JBRuleset({
+            cycleNumber: 1,
+            id: uint48(block.timestamp),
+            basedOnId: 0,
+            start: uint48(block.timestamp),
+            duration: 8000,
+            weight: 5000,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: _packedMetadata
+        });
+
+        // Will check the current ruleset
+        bytes memory _currentRulesetCall = abi.encodeCall(IJBRulesets.currentOf, (1));
+        mockExpect(address(rulesets), _currentRulesetCall, abi.encode(ruleset));
+
+        // Will check the upcoming ruleset
+        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.upcomingOf, (1)), abi.encode(upcoming));
+
+        _controller.setTokenFor(_projectId, _token);
+    }
+
+    function test_WhenCallerIsPermissionedAndAllowSetTokensEQFalse() external {
+        // it will set token
+
+        // mock ownerOf call to auth this contract (caller)
+        bytes memory _ownerOfCall = abi.encodeCall(IERC721.ownerOf, (_projectId));
+        bytes memory _ownerOfReturn = abi.encode(address(this));
+        mockExpect(address(projects), _ownerOfCall, _ownerOfReturn);
+
+        // mock call to JBRulesets
+
+        // setup: return data
+        JBRulesetMetadata memory _metadata = JBRulesetMetadata({
+            reservedPercent: JBConstants.MAX_RESERVED_PERCENT / 2, //50%
+            cashOutTaxRate: JBConstants.MAX_CASH_OUT_TAX_RATE / 2, //50%
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: true,
+            allowSetCustomToken: false, // Allows authorized to set a token or mint tokens
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: false,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: false,
+            useTotalSurplusForCashOuts: true,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+
+        uint256 _packedMetadata = JBRulesetMetadataResolver.packRulesetMetadata(_metadata);
+
+        JBRuleset memory ruleset = JBRuleset({
+            cycleNumber: 1,
+            id: uint48(block.timestamp),
+            basedOnId: 0,
+            start: uint48(block.timestamp),
+            duration: 8000,
+            weight: 5000,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: _packedMetadata
+        });
+
+        bytes memory _currentRulesetCall = abi.encodeCall(IJBRulesets.currentOf, (1));
+        mockExpect(address(rulesets), _currentRulesetCall, abi.encode(ruleset));
+
+        vm.expectRevert(
+            abi.encodeWithSelector(JBController.JBController_RulesetSetTokenNotAllowed.selector, _projectId)
+        );
+        _controller.setTokenFor(_projectId, _token);
+    }
+
+    function test_WhenCallerIsNotPermissioned() external {
+        // it will revert UNAUTHORIZED
+
+        // mock ownerOf call as not this address (unauth)
+        bytes memory _ownerOfCall = abi.encodeCall(IERC721.ownerOf, (_projectId));
+        address _ownerOfReturn = address(0);
+        mockExpect(address(projects), _ownerOfCall, abi.encode(_ownerOfReturn));
+
+        // mock permissions call as unauth
+        bytes memory _permsCall1 = abi.encodeCall(
+            IJBPermissions.hasPermission, (address(this), address(0), 1, JBPermissionIds.SET_TOKEN, true, true)
+        );
+        bytes memory _permsCallReturn1 = abi.encode(false);
+        mockExpect(address(permissions), _permsCall1, _permsCallReturn1);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBPermissioned.JBPermissioned_Unauthorized.selector,
+                _ownerOfReturn,
+                address(this),
+                _projectId,
+                JBPermissionIds.SET_TOKEN
+            )
+        );
+        _controller.setTokenFor(_projectId, _token);
+    }
+}

package/test/units/static/JBController/TestSetUriOf.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBControllerSetup} from "./JBControllerSetup.sol";
+
+contract TestSetUriOf_Local is JBControllerSetup {
+    function setUp() public {
+        super.controllerSetup();
+    }
+
+    function test_WhenCallerIsOwnerOrHasPermission() external {
+        // it should set metadata and emit SetMetadata
+        // mock ownerOf call
+        bytes memory _ownerOfCall = abi.encodeCall(IERC721.ownerOf, (1));
+        bytes memory _ownerData = abi.encode(address(this));
+
+        mockExpect(address(projects), _ownerOfCall, _ownerData);
+
+        vm.expectEmit();
+        emit IJBController.SetUri(1, "Juicay", address(this));
+
+        _controller.setUriOf(1, "Juicay");
+    }
+
+    function test_RevertWhenCallerIsNotOwnerOrHasPermission() external {
+        // it should revert
+        // mock ownerOf call
+        bytes memory _ownerOfCall = abi.encodeCall(IERC721.ownerOf, (1));
+        address _ownerData = address(1);
+
+        mockExpect(address(projects), _ownerOfCall, abi.encode(_ownerData));
+
+        // mock first permissions call
+        bytes memory _permissionsCall = abi.encodeCall(
+            IJBPermissions.hasPermission, (address(this), address(1), 1, JBPermissionIds.SET_PROJECT_URI, true, true)
+        );
+        bytes memory _permissionsReturned = abi.encode(false);
+
+        mockExpect(address(permissions), _permissionsCall, _permissionsReturned);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBPermissioned.JBPermissioned_Unauthorized.selector,
+                _ownerData,
+                address(this),
+                1,
+                JBPermissionIds.SET_PROJECT_URI
+            )
+        );
+        _controller.setUriOf(1, "Not Juicay");
+    }
+}

package/test/units/static/JBController/TestTransferCreditsFrom.sol

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBControllerSetup} from "./JBControllerSetup.sol";
+
+contract TestTransferCreditsFrom_Local is JBControllerSetup {
+    using JBRulesetMetadataResolver for JBRulesetMetadata;
+
+    address _holder = makeAddr("hodler");
+    uint256 _projectId = 1;
+    uint256 _rootId = 0;
+    uint256 _amount = 1e18;
+    address _beneficiary = makeAddr("bene");
+
+    function setUp() public {
+        super.controllerSetup();
+    }
+
+    modifier whenCallerIsPermissioned() {
+        // it will call permissions
+        bytes memory _permCall = abi.encodeCall(
+            IJBPermissions.hasPermission,
+            (address(this), _holder, _projectId, JBPermissionIds.TRANSFER_CREDITS, true, true)
+        );
+        bytes memory _permReturn = abi.encode(true);
+        mockExpect(address(permissions), _permCall, _permReturn);
+        _;
+    }
+
+    function test_GivenRulesetAllowsCreditTransfers() external whenCallerIsPermissioned {
+        // it will call JBTokens to transfer the credits
+
+        // data for JBRulesets currentOf call
+        JBRulesetMetadata memory _rulesMetadata = JBRulesetMetadata({
+            reservedPercent: JBConstants.MAX_RESERVED_PERCENT / 2,
+            cashOutTaxRate: JBConstants.MAX_CASH_OUT_TAX_RATE / 2,
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: false,
+            allowSetCustomToken: false,
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: false,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: false,
+            useTotalSurplusForCashOuts: true,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+
+        uint256 _packed = _rulesMetadata.packRulesetMetadata();
+
+        // mocked ruleset that allows credit transfer
+        JBRuleset memory _returnedRuleset = JBRuleset({
+            cycleNumber: 1,
+            id: uint48(block.timestamp),
+            basedOnId: 0,
+            start: uint48(block.timestamp),
+            duration: 100,
+            weight: 1e18,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: _packed
+        });
+
+        // mock the call to JBRulesets currentOf
+        bytes memory _rulesetCall = abi.encodeCall(IJBRulesets.currentOf, (_projectId));
+        bytes memory _rulesetCallReturn = abi.encode(_returnedRuleset);
+        mockExpect(address(rulesets), _rulesetCall, _rulesetCallReturn);
+
+        // mock the subsequent call to JBTokens transferCreditsFrom
+        bytes memory _transferCall =
+            abi.encodeCall(IJBTokens.transferCreditsFrom, (_holder, _projectId, _beneficiary, _amount));
+        bytes memory _transferCallReturn = "";
+        mockExpect(address(tokens), _transferCall, _transferCallReturn);
+
+        _controller.transferCreditsFrom(_holder, _projectId, _beneficiary, _amount);
+    }
+
+    function test_GivenRulesetDoesNotAllowCreditTransfers() external whenCallerIsPermissioned {
+        // it will revert CREDIT_TRANSFERS_PAUSED
+
+        // data for JBRulesets currentOf call
+        JBRulesetMetadata memory _rulesMetadata = JBRulesetMetadata({
+            reservedPercent: JBConstants.MAX_RESERVED_PERCENT / 2,
+            cashOutTaxRate: JBConstants.MAX_CASH_OUT_TAX_RATE / 2,
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            // will revert in this case
+            pauseCreditTransfers: true,
+            allowOwnerMinting: false,
+            allowSetCustomToken: false,
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: false,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: false,
+            useTotalSurplusForCashOuts: true,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+
+        uint256 _packed = _rulesMetadata.packRulesetMetadata();
+
+        // mocked ruleset that allows credit transfer
+        JBRuleset memory _returnedRuleset = JBRuleset({
+            cycleNumber: 1,
+            id: uint48(block.timestamp),
+            basedOnId: 0,
+            start: uint48(block.timestamp),
+            duration: 100,
+            weight: 1e18,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: _packed
+        });
+
+        // mock the call to JBRulesets currentOf
+        bytes memory _rulesetCall = abi.encodeCall(IJBRulesets.currentOf, (_projectId));
+        bytes memory _rulesetCallReturn = abi.encode(_returnedRuleset);
+        mockExpect(address(rulesets), _rulesetCall, _rulesetCallReturn);
+
+        vm.expectRevert(JBController.JBController_CreditTransfersPaused.selector);
+        _controller.transferCreditsFrom(_holder, _projectId, _beneficiary, _amount);
+    }
+
+    function test_WhenCallerIsNotPermissioned() external {
+        // it will revert UNAUTHORIZED
+        // it will call permissions
+        bytes memory _permCall = abi.encodeCall(
+            IJBPermissions.hasPermission,
+            (address(this), _holder, _projectId, JBPermissionIds.TRANSFER_CREDITS, true, true)
+        );
+        bytes memory _permReturn = abi.encode(false);
+        mockExpect(address(permissions), _permCall, _permReturn);
+
+        // will revert
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBPermissioned.JBPermissioned_Unauthorized.selector,
+                _holder,
+                address(this),
+                _projectId,
+                JBPermissionIds.TRANSFER_CREDITS
+            )
+        );
+        _controller.transferCreditsFrom(_holder, _projectId, _beneficiary, _amount);
+    }
+}

package/test/units/static/JBDeadline/TestDeadlineFuzz.sol

@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBDeadline} from "../../../../src/JBDeadline.sol";
+import {JBApprovalStatus} from "../../../../src/enums/JBApprovalStatus.sol";
+import {JBRuleset} from "../../../../src/structs/JBRuleset.sol";
+
+/// @notice Fuzz tests for JBDeadline approval hook.
+contract TestDeadlineFuzz_Local is JBTest {
+    JBDeadline deadline;
+
+    uint256 constant DURATION = 3 days;
+
+    function setUp() external {
+        deadline = new JBDeadline(DURATION);
+    }
+
+    /// @notice DURATION is set correctly.
+    function test_durationIsSet() external view {
+        assertEq(deadline.DURATION(), DURATION, "DURATION should match");
+    }
+
+    /// @notice ERC165 support for IJBRulesetApprovalHook.
+    function test_supportsInterface() external view {
+        assertTrue(
+            deadline.supportsInterface(type(IJBRulesetApprovalHook).interfaceId),
+            "should support IJBRulesetApprovalHook"
+        );
+        assertTrue(deadline.supportsInterface(type(IERC165).interfaceId), "should support IERC165");
+    }
+
+    //*********************************************************************//
+    // --- Deterministic Status Tests ----------------------------------- //
+    //*********************************************************************//
+
+    /// @notice Ruleset queued after start time returns Failed.
+    function test_queuedAfterStart_isFailed() external view {
+        JBRuleset memory ruleset = _makeRuleset({queuedAt: 200, start: 100});
+        JBApprovalStatus status = deadline.approvalStatusOf(1, ruleset);
+        assertEq(uint256(status), uint256(JBApprovalStatus.Failed), "queued after start should be Failed");
+    }
+
+    /// @notice Ruleset queued too close to start returns Failed.
+    function test_insufficientGap_isFailed() external {
+        uint48 start = uint48(block.timestamp + 1 days);
+        uint48 queued = start - uint48(DURATION) + 1; // 1 second short of required gap
+
+        JBRuleset memory ruleset = _makeRuleset({queuedAt: queued, start: start});
+        JBApprovalStatus status = deadline.approvalStatusOf(1, ruleset);
+        assertEq(uint256(status), uint256(JBApprovalStatus.Failed), "insufficient gap should be Failed");
+    }
+
+    /// @notice Ruleset with exactly enough gap and deadline not yet passed returns ApprovalExpected.
+    function test_exactGap_deadlineNotPassed_isApprovalExpected() external {
+        // queue far enough in advance, and start is still far in the future
+        uint48 start = uint48(block.timestamp + 2 * DURATION + 100);
+        uint48 queued = start - uint48(DURATION);
+
+        JBRuleset memory ruleset = _makeRuleset({queuedAt: queued, start: start});
+        JBApprovalStatus status = deadline.approvalStatusOf(1, ruleset);
+        assertEq(uint256(status), uint256(JBApprovalStatus.ApprovalExpected), "should be ApprovalExpected");
+    }
+
+    /// @notice Ruleset with enough gap and deadline passed returns Approved.
+    function test_gapSufficient_deadlinePassed_isApproved() external {
+        uint48 start = uint48(block.timestamp + 1); // start is very soon
+        uint48 queued = start - uint48(DURATION) - 1; // plenty of gap
+
+        JBRuleset memory ruleset = _makeRuleset({queuedAt: queued, start: start});
+        JBApprovalStatus status = deadline.approvalStatusOf(1, ruleset);
+        assertEq(uint256(status), uint256(JBApprovalStatus.Approved), "should be Approved");
+    }
+
+    //*********************************************************************//
+    // --- Fuzz Tests --------------------------------------------------- //
+    //*********************************************************************//
+
+    /// @notice Status is always one of: Failed, ApprovalExpected, or Approved.
+    function testFuzz_statusIsValid(uint48 queuedAt, uint48 start) external view {
+        JBRuleset memory ruleset = _makeRuleset({queuedAt: queuedAt, start: start});
+        JBApprovalStatus status = deadline.approvalStatusOf(1, ruleset);
+
+        assertTrue(
+            status == JBApprovalStatus.Failed || status == JBApprovalStatus.ApprovalExpected
+                || status == JBApprovalStatus.Approved,
+            "status must be Failed, ApprovalExpected, or Approved"
+        );
+    }
+
+    /// @notice If queued after start, always Failed.
+    function testFuzz_queuedAfterStart_alwaysFailed(uint48 start) external view {
+        // Ensure start is small enough that start+1 doesn't overflow uint48
+        start = uint48(bound(uint256(start), 1, type(uint48).max - 1));
+        uint48 queuedAt = start + 1; // queued AFTER start
+
+        JBRuleset memory ruleset = _makeRuleset({queuedAt: queuedAt, start: start});
+        JBApprovalStatus status = deadline.approvalStatusOf(1, ruleset);
+        assertEq(uint256(status), uint256(JBApprovalStatus.Failed), "queued after start always Failed");
+    }
+
+    /// @notice If gap is less than DURATION, always Failed.
+    function testFuzz_gapTooSmall_alwaysFailed(uint48 start, uint48 gap) external view {
+        gap = uint48(bound(uint256(gap), 0, DURATION - 1));
+        // Ensure start >= gap to avoid underflow
+        start = uint48(bound(uint256(start), gap, type(uint48).max));
+        uint48 queuedAt = start - gap;
+
+        JBRuleset memory ruleset = _makeRuleset({queuedAt: queuedAt, start: start});
+        JBApprovalStatus status = deadline.approvalStatusOf(1, ruleset);
+        assertEq(uint256(status), uint256(JBApprovalStatus.Failed), "gap < DURATION always Failed");
+    }
+
+    /// @notice If gap >= DURATION and deadline passed, always Approved.
+    function testFuzz_sufficientGap_deadlinePassed_approved(uint256 gapExtra) external view {
+        // gap = DURATION + gapExtra (always >= DURATION)
+        gapExtra = bound(gapExtra, 0, 365 days);
+        uint256 gap = DURATION + gapExtra;
+
+        // start = block.timestamp (deadline already passed since block.timestamp + DURATION >= start)
+        uint48 start = uint48(block.timestamp);
+        // Ensure queuedAt doesn't underflow
+        vm.assume(start >= gap);
+        uint48 queuedAt = start - uint48(gap);
+
+        JBRuleset memory ruleset = _makeRuleset({queuedAt: queuedAt, start: start});
+        JBApprovalStatus status = deadline.approvalStatusOf(1, ruleset);
+        assertEq(uint256(status), uint256(JBApprovalStatus.Approved), "sufficient gap + deadline passed -> Approved");
+    }
+
+    /// @notice Status monotonically transitions: ApprovalExpected -> Approved as time advances.
+    function testFuzz_statusMonotonic(uint48 gap) external {
+        gap = uint48(bound(uint256(gap), DURATION, type(uint32).max));
+        // Ensure arithmetic doesn't overflow uint48
+        uint48 start = uint48(bound(uint256(block.timestamp) + 2 * DURATION + 100, gap, type(uint48).max));
+        uint48 queuedAt = start - gap;
+
+        JBRuleset memory ruleset = _makeRuleset({queuedAt: queuedAt, start: start});
+
+        // At this point, start is far in the future -> ApprovalExpected
+        JBApprovalStatus status1 = deadline.approvalStatusOf(1, ruleset);
+        assertTrue(
+            status1 == JBApprovalStatus.ApprovalExpected || status1 == JBApprovalStatus.Approved,
+            "initial status should be ApprovalExpected or Approved"
+        );
+
+        // Warp to just past the deadline
+        vm.warp(start - DURATION);
+        JBApprovalStatus status2 = deadline.approvalStatusOf(1, ruleset);
+        assertEq(uint256(status2), uint256(JBApprovalStatus.Approved), "after deadline should be Approved");
+
+        // Once Approved, stays Approved
+        vm.warp(start + 1000);
+        JBApprovalStatus status3 = deadline.approvalStatusOf(1, ruleset);
+        assertEq(uint256(status3), uint256(JBApprovalStatus.Approved), "should remain Approved");
+    }
+
+    /// @notice Different durations produce consistent results.
+    function testFuzz_differentDurations(uint256 duration) external {
+        duration = bound(duration, 1, 365 days);
+        JBDeadline d = new JBDeadline(duration);
+
+        uint48 start = uint48(block.timestamp + 1);
+        uint48 queuedAt = uint48(block.timestamp - duration);
+
+        JBRuleset memory ruleset = _makeRuleset({queuedAt: queuedAt, start: start});
+        JBApprovalStatus status = d.approvalStatusOf(1, ruleset);
+
+        // With gap = duration + block.timestamp + 1 - (block.timestamp - duration) = 2*duration + 1
+        // This is always >= duration, so status depends on whether deadline passed
+        assertTrue(
+            status == JBApprovalStatus.Approved || status == JBApprovalStatus.ApprovalExpected,
+            "sufficient gap should be Approved or ApprovalExpected"
+        );
+    }
+
+    //*********************************************************************//
+    // --- Helpers ------------------------------------------------------ //
+    //*********************************************************************//
+
+    function _makeRuleset(uint48 queuedAt, uint48 start) internal pure returns (JBRuleset memory) {
+        return JBRuleset({
+            cycleNumber: 1,
+            id: queuedAt,
+            basedOnId: 0,
+            start: start,
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: 0
+        });
+    }
+}

package/test/units/static/JBDirectory/JBDirectorySetup.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+
+/*
+Contract that deploys a target contract with other mock contracts to satisfy the constructor.
+Tests relative to this contract will be dependent on mock calls/emits and stdStorage.
+*/
+contract JBDirectorySetup is JBTest {
+    // Target Contract
+    IJBDirectory public _directory;
+
+    // Mocks
+    IJBPermissions public permissions = IJBPermissions(makeAddr("permissions"));
+    IJBProjects public projects = IJBProjects(makeAddr("projects"));
+
+    function directorySetup() public virtual {
+        // Instantiate the contract being tested
+        _directory = new JBDirectory(permissions, projects, makeAddr("Juicer"));
+    }
+}