@bananapus/core-v6 0.0.1

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

@@ -0,0 +1,282 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBControllerSetup} from "./JBControllerSetup.sol";
+
+contract TestLaunchProjectFor_Local is JBControllerSetup {
+    using JBRulesetMetadataResolver for JBRulesetMetadata;
+
+    address payable _splitsBeneficiary = payable(makeAddr("someone"));
+    string _metadata = "JUICAY_DATA";
+    string _memo = "JUICAY_MEMO";
+
+    function setUp() public {
+        super.controllerSetup();
+    }
+
+    modifier whenCalledDefault() {
+        // we must mock calls to Projects, Directory, Rulesets, possibly Splits, and possibly a second call to directory
+
+        bytes memory projectsCall = abi.encodeCall(IJBProjects.createFor, (address(this)));
+        bytes memory projectsReturn = abi.encode(1);
+        mockExpect(address(projects), projectsCall, projectsReturn);
+
+        bytes memory setControllerCall =
+            abi.encodeCall(IJBDirectory.setControllerOf, (1, IERC165(address(_controller))));
+        bytes memory setControllerReturn = "";
+        mockExpect(address(directory), setControllerCall, setControllerReturn);
+        _;
+    }
+
+    function test_GivenMetadataIsProvided() external whenCalledDefault {
+        // it will set metadata
+
+        JBRulesetConfig[] memory _rulesets = new JBRulesetConfig[](0);
+        JBTerminalConfig[] memory _terminals = new JBTerminalConfig[](0);
+
+        vm.expectEmit();
+        emit IJBController.LaunchProject(0, 1, _metadata, "", address(this));
+
+        _controller.launchProjectFor(address(this), _metadata, _rulesets, _terminals, "");
+    }
+
+    function test_GivenRulesetHasInvalidReservedPercent() external whenCalledDefault {
+        // it will revert INVALID_RESERVED_PERCENT()
+
+        JBRulesetMetadata memory _rulesMetadata = JBRulesetMetadata({
+            reservedPercent: JBConstants.MAX_RESERVED_PERCENT + 1, // invalid
+            cashOutTaxRate: JBConstants.MAX_CASH_OUT_TAX_RATE / 2, //50%
+            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
+        });
+
+        JBFundAccessLimitGroup[] memory _fundAccessLimitGroup = new JBFundAccessLimitGroup[](0);
+        JBTerminalConfig[] memory _terminals = new JBTerminalConfig[](0);
+
+        // Package up the ruleset configuration.
+        JBRulesetConfig[] memory _rulesetConfigurations = new JBRulesetConfig[](1);
+        _rulesetConfigurations[0].mustStartAtOrAfter = 0;
+        _rulesetConfigurations[0].duration = 0;
+        _rulesetConfigurations[0].weight = 1e18;
+        _rulesetConfigurations[0].weightCutPercent = 0;
+        _rulesetConfigurations[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        _rulesetConfigurations[0].metadata = _rulesMetadata;
+        _rulesetConfigurations[0].splitGroups = new JBSplitGroup[](0);
+        _rulesetConfigurations[0].fundAccessLimitGroups = _fundAccessLimitGroup;
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBController.JBController_InvalidReservedPercent.selector,
+                JBConstants.MAX_RESERVED_PERCENT + 1,
+                JBConstants.MAX_RESERVED_PERCENT
+            )
+        );
+        _controller.launchProjectFor(address(this), _metadata, _rulesetConfigurations, _terminals, _memo);
+    }
+
+    function test_GivenRulesetHasInvalidCashOutTaxRate() external whenCalledDefault {
+        // it will revert INVALID_CASH_OUT_RATE()
+
+        JBRulesetMetadata memory _rulesMetadata = JBRulesetMetadata({
+            reservedPercent: JBConstants.MAX_RESERVED_PERCENT / 2,
+            cashOutTaxRate: JBConstants.MAX_CASH_OUT_TAX_RATE + 1, // invalid
+            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
+        });
+
+        JBFundAccessLimitGroup[] memory _fundAccessLimitGroup = new JBFundAccessLimitGroup[](0);
+        JBTerminalConfig[] memory _terminals = new JBTerminalConfig[](0);
+
+        // Package up the ruleset configuration.
+        JBRulesetConfig[] memory _rulesetConfigurations = new JBRulesetConfig[](1);
+        _rulesetConfigurations[0].mustStartAtOrAfter = 0;
+        _rulesetConfigurations[0].duration = 0;
+        _rulesetConfigurations[0].weight = 1e18;
+        _rulesetConfigurations[0].weightCutPercent = 0;
+        _rulesetConfigurations[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        _rulesetConfigurations[0].metadata = _rulesMetadata;
+        _rulesetConfigurations[0].splitGroups = new JBSplitGroup[](0);
+        _rulesetConfigurations[0].fundAccessLimitGroups = _fundAccessLimitGroup;
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBController.JBController_InvalidCashOutTaxRate.selector,
+                JBConstants.MAX_CASH_OUT_TAX_RATE + 1,
+                JBConstants.MAX_CASH_OUT_TAX_RATE
+            )
+        );
+        _controller.launchProjectFor(address(this), _metadata, _rulesetConfigurations, _terminals, _memo);
+    }
+
+    function test_GivenSplitsRulesetsAndFundAccessConstraintsAreConfigured() external whenCalledDefault {
+        // it will set split groups, ruleset, fundAccessConstraints
+
+        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();
+
+        JBFundAccessLimitGroup[] memory _fundAccessLimitGroup = new JBFundAccessLimitGroup[](0);
+        JBTerminalConfig[] memory _terminals = new JBTerminalConfig[](0);
+
+        // splits
+        JBSplitGroup[] memory _splitsGroup = new JBSplitGroup[](1);
+        JBSplit[] memory _splits = new JBSplit[](1);
+
+        _splits[0] = JBSplit({
+            preferAddToBalance: false,
+            percent: JBConstants.SPLITS_TOTAL_PERCENT,
+            projectId: 1,
+            beneficiary: _splitsBeneficiary,
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+
+        _splitsGroup[0] = JBSplitGroup({groupId: uint32(uint160(JBConstants.NATIVE_TOKEN)), splits: _splits});
+
+        // Package up the ruleset configuration.
+        JBRulesetConfig[] memory _rulesetConfigurations = new JBRulesetConfig[](1);
+        _rulesetConfigurations[0].mustStartAtOrAfter = 0;
+        _rulesetConfigurations[0].duration = 0;
+        _rulesetConfigurations[0].weight = 1e18;
+        _rulesetConfigurations[0].weightCutPercent = 0;
+        _rulesetConfigurations[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        _rulesetConfigurations[0].metadata = _rulesMetadata;
+        _rulesetConfigurations[0].splitGroups = _splitsGroup;
+        _rulesetConfigurations[0].fundAccessLimitGroups = _fundAccessLimitGroup;
+
+        // JBRulesets calldata
+        JBRuleset memory returnedRuleset = JBRuleset({
+            cycleNumber: uint48(block.timestamp),
+            id: uint48(block.timestamp),
+            basedOnId: 0,
+            start: uint48(block.timestamp),
+            duration: _rulesetConfigurations[0].duration,
+            weight: _rulesetConfigurations[0].weight,
+            weightCutPercent: _rulesetConfigurations[0].weightCutPercent,
+            approvalHook: _rulesetConfigurations[0].approvalHook,
+            metadata: _packed
+        });
+        bytes memory rulesetsCall = abi.encodeCall(
+            IJBRulesets.queueFor,
+            (
+                1,
+                _rulesetConfigurations[0].duration,
+                _rulesetConfigurations[0].weight,
+                _rulesetConfigurations[0].weightCutPercent,
+                _rulesetConfigurations[0].approvalHook,
+                _packed,
+                _rulesetConfigurations[0].mustStartAtOrAfter
+            )
+        );
+        bytes memory rulesetsReturned = abi.encode(returnedRuleset);
+
+        // JBRulesets call
+        mockExpect(address(rulesets), rulesetsCall, rulesetsReturned);
+
+        // JBSplits call
+        bytes memory splitsCall = abi.encodeCall(IJBSplits.setSplitGroupsOf, (1, block.timestamp, _splitsGroup));
+        bytes memory splitsReturned = "";
+        mockExpect(address(splits), splitsCall, splitsReturned);
+
+        // JBFundAccess call
+        bytes memory fundsCall =
+            abi.encodeCall(IJBFundAccessLimits.setFundAccessLimitsFor, (1, block.timestamp, _fundAccessLimitGroup));
+        bytes memory fundsReturned = "";
+        mockExpect(address(fundAccessLimits), fundsCall, fundsReturned);
+
+        _controller.launchProjectFor(address(this), _metadata, _rulesetConfigurations, _terminals, _memo);
+    }
+
+    function test_GivenTerminalsAreProvided() external whenCalledDefault {
+        // it will set terminals
+        IJBTerminal _terminal = IJBTerminal(makeAddr("terminal"));
+        address _token = makeAddr("token");
+
+        JBRulesetConfig[] memory _rulesets = new JBRulesetConfig[](0);
+        JBTerminalConfig[] memory _terminals = new JBTerminalConfig[](1);
+        JBAccountingContext[] memory _tokensToAccept = new JBAccountingContext[](1);
+        _tokensToAccept[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+
+        _terminals[0] = JBTerminalConfig({terminal: _terminal, accountingContextsToAccept: _tokensToAccept});
+
+        // mock call return data
+        JBAccountingContext memory _returnedContext =
+            JBAccountingContext({token: _token, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))});
+
+        // mock call to the terminal addAccountingContextsFor()
+        bytes memory addCall = abi.encodeCall(IJBTerminal.addAccountingContextsFor, (1, _tokensToAccept));
+        bytes memory addReturned = abi.encode(_returnedContext);
+
+        mockExpect(address(_terminal), addCall, addReturned);
+
+        vm.expectEmit();
+        emit IJBController.LaunchProject(0, 1, _metadata, _memo, address(this));
+
+        _controller.launchProjectFor(address(this), _metadata, _rulesets, _terminals, _memo);
+    }
+
+    function test_GivenMemoIsProvided() external whenCalledDefault {
+        // it will be included in the emit
+
+        JBRulesetConfig[] memory _rulesets = new JBRulesetConfig[](0);
+        JBTerminalConfig[] memory _terminals = new JBTerminalConfig[](0);
+
+        vm.expectEmit();
+        emit IJBController.LaunchProject(0, 1, _metadata, _memo, address(this));
+
+        _controller.launchProjectFor(address(this), _metadata, _rulesets, _terminals, _memo);
+    }
+}

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

@@ -0,0 +1,322 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBControllerSetup} from "./JBControllerSetup.sol";
+
+contract TestLaunchRulesetsFor_Local is JBControllerSetup {
+    function setUp() public {
+        super.controllerSetup();
+    }
+
+    modifier whenCallerHasPermission() {
+        // mock ownerOf call
+        bytes memory _ownerOfCall = abi.encodeCall(IERC721.ownerOf, (1));
+        bytes memory _ownerData = abi.encode(address(this));
+
+        mockExpect(address(projects), _ownerOfCall, _ownerData);
+        _;
+    }
+
+    modifier whenCallerWithoutPermission() {
+        // mock ownerOf call
+        bytes memory _ownerOfCall = abi.encodeCall(IERC721.ownerOf, (1));
+        bytes memory _ownerData = abi.encode(address(1));
+
+        mockExpect(address(projects), _ownerOfCall, _ownerData);
+
+        // mock permission call
+        bytes memory _call = abi.encodeCall(
+            IJBPermissions.hasPermission, (address(this), address(1), 1, JBPermissionIds.LAUNCH_RULESETS, true, true)
+        );
+        mockExpect(address(permissions), _call, abi.encode(false));
+        _;
+    }
+
+    function genRuleset()
+        public
+        pure
+        returns (JBTerminalConfig[] memory _terminalConfig, JBRulesetConfig[] memory _rulesetConfig)
+    {
+        // it should set the controller, queue the rulesets, configure terminals, and emit LaunchRulesets
+        JBTerminalConfig[] memory _terminalConfigs = new JBTerminalConfig[](0);
+        JBRulesetConfig[] memory _rulesetConfigs = new JBRulesetConfig[](1);
+
+        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: 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
+        });
+
+        // Package up the limits for the given terminal.
+        JBFundAccessLimitGroup[] memory _fundAccessLimitGroup = new JBFundAccessLimitGroup[](1);
+
+        // Specify a payout limit.
+        JBCurrencyAmount[] memory _payoutLimits = new JBCurrencyAmount[](1);
+        _payoutLimits[0] = JBCurrencyAmount({amount: 0, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))});
+
+        // Specify a surplus allowance.
+        JBCurrencyAmount[] memory _surplusAllowances = new JBCurrencyAmount[](1);
+        _surplusAllowances[0] = JBCurrencyAmount({amount: 0, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))});
+
+        _fundAccessLimitGroup[0] = JBFundAccessLimitGroup({
+            terminal: address(0),
+            token: JBConstants.NATIVE_TOKEN,
+            payoutLimits: _payoutLimits,
+            surplusAllowances: _surplusAllowances
+        });
+
+        // Package up the ruleset configuration.
+        _rulesetConfigs[0].mustStartAtOrAfter = 0;
+        _rulesetConfigs[0].duration = 0;
+        _rulesetConfigs[0].weight = 0;
+        _rulesetConfigs[0].weightCutPercent = 0;
+        _rulesetConfigs[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        _rulesetConfigs[0].metadata = _metadata;
+        _rulesetConfigs[0].splitGroups = new JBSplitGroup[](0);
+        _rulesetConfigs[0].fundAccessLimitGroups = _fundAccessLimitGroup;
+
+        return (_terminalConfigs, _rulesetConfigs);
+    }
+
+    function test_RevertWhen_RulesetLengthIsZero() external {
+        // it should revert
+        JBTerminalConfig[] memory _terminalConfigs = new JBTerminalConfig[](0);
+        JBRulesetConfig[] memory _rulesetConfigs = new JBRulesetConfig[](0);
+
+        vm.expectRevert(JBController.JBController_RulesetsArrayEmpty.selector);
+
+        _controller.launchRulesetsFor(1, _rulesetConfigs, _terminalConfigs, "");
+    }
+
+    function test_RevertWhen_CallerDoesNotHavePermission() external whenCallerWithoutPermission {
+        // it should revert
+        JBTerminalConfig[] memory _terminalConfigs = new JBTerminalConfig[](0);
+        JBRulesetConfig[] memory _rulesetConfigs = new JBRulesetConfig[](1);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBPermissioned.JBPermissioned_Unauthorized.selector,
+                address(1),
+                address(this),
+                1,
+                JBPermissionIds.LAUNCH_RULESETS
+            )
+        );
+
+        _controller.launchRulesetsFor(1, _rulesetConfigs, _terminalConfigs, "");
+    }
+
+    function test_Revert_GivenTheProjectAlreadyHasRulesets() external whenCallerHasPermission {
+        // it should revert
+        JBTerminalConfig[] memory _terminalConfigs = new JBTerminalConfig[](0);
+        JBRulesetConfig[] memory _rulesetConfigs = new JBRulesetConfig[](1);
+
+        bytes memory _latestRulesetIdOfCall = abi.encodeCall(IJBRulesets.latestRulesetIdOf, (1));
+        bytes memory _returnData = abi.encode(1);
+
+        mockExpect(address(rulesets), _latestRulesetIdOfCall, _returnData);
+
+        vm.expectRevert(abi.encodeWithSelector(JBController.JBController_RulesetsAlreadyLaunched.selector, 1));
+
+        _controller.launchRulesetsFor(1, _rulesetConfigs, _terminalConfigs, "");
+    }
+
+    function test_GivenTheProjectDoesNotYetHaveRulesets() external whenCallerHasPermission {
+        // setup: needed for the call chain
+        JBTerminalConfig[] memory _terminalConfigs;
+        JBRulesetConfig[] memory _rulesetConfigs;
+        uint48 _ts = uint48(block.timestamp);
+        uint256 _projectId = 1;
+        (_terminalConfigs, _rulesetConfigs) = genRuleset();
+
+        // inlined to avoid stack2deep
+        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.latestRulesetIdOf, (_projectId)), abi.encode(0));
+        mockExpect(
+            address(directory),
+            abi.encodeCall(IJBDirectory.setControllerOf, (_projectId, IERC165(address(_controller)))),
+            ""
+        );
+
+        // mock call to rulesets queueFor
+        // setup: return data
+        JBRuleset memory data = JBRuleset({
+            cycleNumber: 1,
+            id: _ts,
+            basedOnId: 0,
+            start: _ts,
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: 0
+        });
+
+        // Mock call to rulesets queueFor
+        bytes memory _queueForCall = abi.encodeCall(
+            IJBRulesets.queueFor,
+            (
+                _projectId,
+                0,
+                0,
+                0,
+                _rulesetConfigs[0].approvalHook,
+                JBRulesetMetadataResolver.packRulesetMetadata(_rulesetConfigs[0].metadata),
+                0
+            )
+        );
+        bytes memory _queueReturn = abi.encode(data);
+        mockExpect(address(rulesets), _queueForCall, _queueReturn);
+
+        // Mock call to splits setSplitGroupsOf
+        bytes memory _setSplitsCall =
+            abi.encodeCall(IJBSplits.setSplitGroupsOf, (_projectId, _ts, _rulesetConfigs[0].splitGroups));
+        bytes memory _splitsReturn = "";
+        mockExpect(address(splits), _setSplitsCall, _splitsReturn);
+
+        // Mock call to fundaccesslimits setFundAccessLimitsFor
+        bytes memory _fundAccessCall = abi.encodeCall(
+            IJBFundAccessLimits.setFundAccessLimitsFor, (_projectId, _ts, _rulesetConfigs[0].fundAccessLimitGroups)
+        );
+        bytes memory _accessReturn = "";
+        mockExpect(address(fundAccessLimits), _fundAccessCall, _accessReturn);
+
+        // event as expected
+        /* vm.expectEmit();
+        emit IJBController.LaunchRulesets(_ts, 1, "", address(this)); */
+
+        _controller.launchRulesetsFor(_projectId, _rulesetConfigs, _terminalConfigs, "");
+    }
+
+    function test_GivenCallerOnlyHasLaunchPermission() 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 permission call - caller has LAUNCH_RULESETS
+        bytes memory _call = abi.encodeCall(
+            IJBPermissions.hasPermission, (address(this), address(1), 1, JBPermissionIds.LAUNCH_RULESETS, true, true)
+        );
+        mockExpect(address(permissions), _call, abi.encode(true));
+
+        // SET_TERMINALS - caller does NOT have this
+        bytes memory _call3 = abi.encodeCall(
+            IJBPermissions.hasPermission, (address(this), address(1), 1, JBPermissionIds.SET_TERMINALS, true, true)
+        );
+        mockExpect(address(permissions), _call3, abi.encode(false));
+
+        // it should revert
+        JBTerminalConfig[] memory _terminalConfigs = new JBTerminalConfig[](0);
+        JBRulesetConfig[] memory _rulesetConfigs = new JBRulesetConfig[](1);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBPermissioned.JBPermissioned_Unauthorized.selector,
+                _ownerData,
+                address(this),
+                1,
+                JBPermissionIds.SET_TERMINALS
+            )
+        );
+
+        _controller.launchRulesetsFor(1, _rulesetConfigs, _terminalConfigs, "");
+    }
+
+    function test_GivenNonOwnerHasBothPermissions() external {
+        // it will launch rulesets
+
+        // mock ownerOf call
+        bytes memory _ownerOfCall = abi.encodeCall(IERC721.ownerOf, (1));
+        bytes memory _ownerData = abi.encode(address(1));
+
+        mockExpect(address(projects), _ownerOfCall, _ownerData);
+
+        // mock permission call - caller has LAUNCH_RULESETS
+        bytes memory _call = abi.encodeCall(
+            IJBPermissions.hasPermission, (address(this), address(1), 1, JBPermissionIds.LAUNCH_RULESETS, true, true)
+        );
+        mockExpect(address(permissions), _call, abi.encode(true));
+
+        // SET_TERMINALS
+        bytes memory _call3 = abi.encodeCall(
+            IJBPermissions.hasPermission, (address(this), address(1), 1, JBPermissionIds.SET_TERMINALS, true, true)
+        );
+        mockExpect(address(permissions), _call3, abi.encode(true));
+
+        // setup: needed for the call chain
+        JBTerminalConfig[] memory _terminalConfigs;
+        JBRulesetConfig[] memory _rulesetConfigs;
+        uint48 _ts = uint48(block.timestamp);
+        uint256 _projectId = 1;
+        (_terminalConfigs, _rulesetConfigs) = genRuleset();
+
+        // inlined to avoid stack2deep
+        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.latestRulesetIdOf, (_projectId)), abi.encode(0));
+        mockExpect(
+            address(directory),
+            abi.encodeCall(IJBDirectory.setControllerOf, (_projectId, IERC165(address(_controller)))),
+            ""
+        );
+
+        // mock call to rulesets queueFor
+        // setup: return data
+        JBRuleset memory data = JBRuleset({
+            cycleNumber: 1,
+            id: _ts,
+            basedOnId: 0,
+            start: _ts,
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: 0
+        });
+
+        // Mock call to rulesets queueFor
+        bytes memory _queueForCall = abi.encodeCall(
+            IJBRulesets.queueFor,
+            (_projectId, 0, 0, 0, _rulesetConfigs[0].approvalHook, 642_241_845_873_572_506_056_833, 0)
+        );
+        bytes memory _queueReturn = abi.encode(data);
+        mockExpect(address(rulesets), _queueForCall, _queueReturn);
+
+        // Mock call to splits setSplitGroupsOf
+        bytes memory _setSplitsCall =
+            abi.encodeCall(IJBSplits.setSplitGroupsOf, (_projectId, _ts, _rulesetConfigs[0].splitGroups));
+        bytes memory _splitsReturn = "";
+        mockExpect(address(splits), _setSplitsCall, _splitsReturn);
+
+        // Mock call to fundaccesslimits setFundAccessLimitsFor
+        bytes memory _fundAccessCall = abi.encodeCall(
+            IJBFundAccessLimits.setFundAccessLimitsFor, (_projectId, _ts, _rulesetConfigs[0].fundAccessLimitGroups)
+        );
+        bytes memory _accessReturn = "";
+        mockExpect(address(fundAccessLimits), _fundAccessCall, _accessReturn);
+
+        // event as expected
+        vm.expectEmit();
+        emit IJBController.LaunchRulesets(_ts, 1, "", address(this));
+
+        _controller.launchRulesetsFor(1, _rulesetConfigs, _terminalConfigs, "");
+    }
+}