@bananapus/core-v6 0.0.1

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

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBDirectorySetup} from "./JBDirectorySetup.sol";
+
+contract TestPrimaryTerminalOf_Local is JBDirectorySetup {
+    uint256 _projectId = 1;
+    address _mockTerminal = makeAddr("mockTerminal");
+    address _mockTerminal2 = makeAddr("mockTerminal2");
+    address _mockToken = makeAddr("mockToken");
+
+    function setUp() public {
+        super.directorySetup();
+    }
+
+    function test_WhenThereAreNoTerminalsSupportingTheInputToken() external {
+        // it will return the zero address
+    }
+
+    modifier whenThereIsAPrimaryTerminal() {
+        _;
+    }
+
+    function test_GivenThereIsAPrimaryTerminalForTheToken() external whenThereIsAPrimaryTerminal {
+        // it will return the primary terminal
+
+        // first set the primary terminal
+
+        // mock call to JBProjects ownerOf which will give permission
+        bytes memory _projectsCall = abi.encodeCall(IERC721.ownerOf, (_projectId));
+        bytes memory _projectsCallReturn = abi.encode(address(this));
+        mockExpect(address(projects), _projectsCall, _projectsCallReturn);
+
+        // mock call to the terminal accountingContextForTokenOf
+
+        // accounting context needed for call
+        JBAccountingContext memory _context =
+            JBAccountingContext({token: _mockToken, decimals: 18, currency: uint32(1)});
+        mockExpect(
+            address(_mockTerminal),
+            abi.encodeCall(IJBTerminal.accountingContextForTokenOf, (_projectId, _mockToken)),
+            abi.encode(_context)
+        );
+
+        // mock call to "controller" (zero address here) for interface supp
+        mockExpect(
+            address(0),
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBDirectoryAccessControl).interfaceId)),
+            abi.encode(true)
+        );
+
+        // mock call to "controller" (zero address here) for setTerminalsAllowed
+        mockExpect(
+            address(0), abi.encodeCall(IJBDirectoryAccessControl.setTerminalsAllowed, (_projectId)), abi.encode(true)
+        );
+
+        // Set the primary terminal of using the previous mocks
+        _directory.setPrimaryTerminalOf(_projectId, _mockToken, IJBTerminal(_mockTerminal));
+
+        // Make sure it is stored correctly
+        IJBTerminal _storedTerminal = _directory.primaryTerminalOf(_projectId, _mockToken);
+        assertEq(address(_storedTerminal), _mockTerminal);
+    }
+
+    function test_GivenThereAreMultipleTerminalsWithProperAccountingContextForTokenOf() external {
+        // it will check each terminals accountingContextForTokenOf and return the first
+    }
+
+    function test_GivenThereAreMultipleTerminalsButNoneWithTheProperAccountingContextForTokenOf() external {
+        // it will return the zero address
+
+        // first set the terminals
+
+        // mock call to JBProjects ownerOf which will give permission
+        bytes memory _projectsCall = abi.encodeCall(IERC721.ownerOf, (_projectId));
+        bytes memory _projectsCallReturn = abi.encode(address(this));
+        mockExpect(address(projects), _projectsCall, _projectsCallReturn);
+
+        // mock call to the terminal accountingContextForTokenOf
+
+        // accounting context needed for call
+        JBAccountingContext memory _context = JBAccountingContext({token: address(0), decimals: 0, currency: uint32(0)});
+        mockExpect(
+            address(_mockTerminal),
+            abi.encodeCall(IJBTerminal.accountingContextForTokenOf, (_projectId, address(0))),
+            abi.encode(_context)
+        );
+
+        // mock call the the 2nd terminal accountingContextForTokenOf
+
+        // accounting context needed for call
+        mockExpect(
+            address(_mockTerminal2),
+            abi.encodeCall(IJBTerminal.accountingContextForTokenOf, (_projectId, address(0))),
+            abi.encode(_context)
+        );
+
+        // mock call to "controller" (zero address here) for interface supp
+        mockExpect(
+            address(0),
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBDirectoryAccessControl).interfaceId)),
+            abi.encode(true)
+        );
+
+        // mock call to "controller" (zero address here) for setTerminalsAllowed
+        mockExpect(
+            address(0), abi.encodeCall(IJBDirectoryAccessControl.setTerminalsAllowed, (_projectId)), abi.encode(true)
+        );
+
+        // terminals to set
+        IJBTerminal[] memory _terminals = new IJBTerminal[](2);
+        _terminals[0] = IJBTerminal(_mockTerminal);
+        _terminals[1] = IJBTerminal(_mockTerminal2);
+
+        // Set the primary terminal of using the previous mocks
+        _directory.setTerminalsOf(_projectId, _terminals);
+
+        IJBTerminal returnedTerminal = _directory.primaryTerminalOf(_projectId, address(0));
+        assertEq(address(returnedTerminal), address(0));
+    }
+}

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

@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBDirectorySetup} from "./JBDirectorySetup.sol";
+
+contract TestSetControllerOf_Local is JBDirectorySetup {
+    using stdStorage for StdStorage;
+
+    function setUp() public {
+        super.directorySetup();
+    }
+
+    modifier givenProjectExists() {
+        bytes memory _countCall = abi.encodeCall(IJBProjects.count, ());
+        bytes memory _countReturn = abi.encode(type(uint256).max);
+
+        mockExpect(address(projects), _countCall, _countReturn);
+        _;
+    }
+
+    modifier whenCallerIsAllowedToSetFirstController() {
+        stdstore.target(address(_directory)).sig("isAllowedToSetFirstController(address)").with_key(address(this))
+            .depth(0).checked_write(true);
+
+        stdstore.target(address(_directory)).sig("controllerOf(uint256)").with_key(1).depth(0).checked_write(address(0));
+
+        // mock ownerOf call
+        bytes memory _ownerOfCall = abi.encodeCall(IERC721.ownerOf, (1));
+        bytes memory _ownerData = abi.encode(address(this));
+
+        mockExpect(address(projects), _ownerOfCall, _ownerData);
+
+        _;
+    }
+
+    modifier givenControllerIsAlreadySet() {
+        address _bumController = makeAddr("bum");
+
+        stdstore.target(address(_directory)).sig("controllerOf(uint256)").with_key(1).depth(0)
+            .checked_write(_bumController);
+
+        // mock erc165 call
+        bytes memory _supportCall =
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBDirectoryAccessControl).interfaceId));
+        bytes memory _supportReturned = abi.encode(true);
+
+        mockExpect(address(_bumController), _supportCall, _supportReturned);
+
+        // mock access control call
+        bytes memory _accessCall = abi.encodeCall(IJBDirectoryAccessControl.setControllerAllowed, (1));
+        bytes memory _accessReturned = abi.encode(false);
+
+        mockExpect(address(_bumController), _accessCall, _accessReturned);
+
+        _;
+    }
+
+    function test_RevertWhenCallerDoesNotHaveAnyPermission() 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_CONTROLLER, 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_CONTROLLER
+            )
+        );
+        _directory.setControllerOf(1, IERC165(address(this)));
+    }
+
+    function test_RevertGivenAProjectDoesntExist() external whenCallerIsAllowedToSetFirstController {
+        // it should revert
+
+        // project count mock call
+        bytes memory _countCall = abi.encodeCall(IJBProjects.count, ());
+        bytes memory _countReturn = abi.encode(0);
+
+        mockExpect(address(projects), _countCall, _countReturn);
+
+        vm.expectRevert(abi.encodeWithSelector(JBDirectory.JBDirectory_InvalidProjectIdInDirectory.selector, 1, 0));
+        _directory.setControllerOf(1, IERC165(address(this)));
+    }
+
+    function test_RevertGivenCurrentControllerIsNotSetControllerAllowed()
+        external
+        whenCallerIsAllowedToSetFirstController
+        givenProjectExists
+        givenControllerIsAlreadySet
+    {
+        // it should revert
+        vm.expectRevert(abi.encodeWithSelector(JBDirectory.JBDirectory_SetControllerNotAllowed.selector, 1));
+        _directory.setControllerOf(1, IERC165(address(this)));
+    }
+
+    function test_GivenCurrentControllerIsSetControllerAllowed()
+        external
+        whenCallerIsAllowedToSetFirstController
+        givenProjectExists
+    {
+        // it should set controllerOf and emit SetController
+        vm.expectEmit();
+        emit IJBDirectory.SetController(1, IERC165(address(this)), address(this));
+
+        _directory.setControllerOf(1, IERC165(address(this)));
+    }
+
+    function test_GivenCurrentControllerIsSetAndMigrating() external givenProjectExists {
+        address _bumController = makeAddr("bum");
+
+        stdstore.target(address(_directory)).sig("controllerOf(uint256)").with_key(1).depth(0)
+            .checked_write(_bumController);
+
+        // mock ownerOf call
+        bytes memory _ownerOfCall = abi.encodeCall(IERC721.ownerOf, (1));
+        bytes memory _ownerData = abi.encode(address(this));
+
+        mockExpect(address(projects), _ownerOfCall, _ownerData);
+
+        // Mock call to bum controller setControllerAllowed
+        mockExpect(
+            _bumController, abi.encodeCall(IJBDirectoryAccessControl.setControllerAllowed, (1)), abi.encode(true)
+        );
+
+        // Mock call to it's interface support
+        mockExpect(
+            _bumController,
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBDirectoryAccessControl).interfaceId)),
+            abi.encode(true)
+        );
+        mockExpect(
+            _bumController,
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBMigratable).interfaceId)),
+            abi.encode(true)
+        );
+        mockExpect(
+            address(this),
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBMigratable).interfaceId)),
+            abi.encode(true)
+        );
+        mockExpect(
+            address(this),
+            abi.encodeCall(IJBMigratable.beforeReceiveMigrationFrom, (IERC165(address(_bumController)), 1)),
+            abi.encode("")
+        );
+        mockExpect(
+            address(this),
+            abi.encodeCall(IJBMigratable.afterReceiveMigrationFrom, (IERC165(address(_bumController)), 1)),
+            abi.encode("")
+        );
+
+        // it should set controllerOf and emit SetController
+        vm.expectEmit();
+        emit IJBDirectory.SetController(1, IERC165(address(this)), address(this));
+
+        _directory.setControllerOf(1, IERC165(address(this)));
+    }
+}

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

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBDirectorySetup} from "./JBDirectorySetup.sol";
+
+/// @notice A mock controller that asserts the directory still points to it during migrate().
+/// This validates that controllerOf is NOT updated before migrate() is called.
+contract MockMigratingController is ERC165 {
+    IJBDirectory public immutable DIRECTORY;
+    uint256 public immutable PROJECT_ID;
+    bool public migrateCalled;
+    bool public directoryPointedToSelfDuringMigrate;
+
+    constructor(IJBDirectory directory, uint256 projectId) {
+        DIRECTORY = directory;
+        PROJECT_ID = projectId;
+    }
+
+    function supportsInterface(bytes4 interfaceId) public view override returns (bool) {
+        return interfaceId == type(IJBMigratable).interfaceId
+            || interfaceId == type(IJBDirectoryAccessControl).interfaceId || super.supportsInterface(interfaceId);
+    }
+
+    function setControllerAllowed(uint256) external pure returns (bool) {
+        return true;
+    }
+
+    function migrate(uint256, IERC165) external {
+        migrateCalled = true;
+        // The critical assertion: during migrate(), the directory should still point to this controller.
+        directoryPointedToSelfDuringMigrate = (address(DIRECTORY.controllerOf(PROJECT_ID)) == address(this));
+    }
+
+    function beforeReceiveMigrationFrom(IERC165, uint256) external {}
+
+    function afterReceiveMigrationFrom(IERC165, uint256) external {}
+}
+
+/// @notice A simple new controller that accepts migration.
+contract MockNewController is ERC165 {
+    function supportsInterface(bytes4 interfaceId) public view override returns (bool) {
+        return interfaceId == type(IJBMigratable).interfaceId || super.supportsInterface(interfaceId);
+    }
+
+    function migrate(uint256, IERC165) external {}
+
+    function beforeReceiveMigrationFrom(IERC165, uint256) external {}
+
+    function afterReceiveMigrationFrom(IERC165, uint256) external {}
+}
+
+contract TestSetControllerOfMigrationOrder is JBDirectorySetup {
+    using stdStorage for StdStorage;
+
+    uint256 constant PROJECT_ID = 1;
+
+    function setUp() public {
+        super.directorySetup();
+    }
+
+    /// @notice Verifies that during migrate(), the directory still points to the old controller.
+    /// This test PASSES with the correct ordering (migrate before set) and FAILS if set happens before migrate.
+    function test_DirectoryPointsToOldControllerDuringMigrate() external {
+        // Deploy mock controllers with real code (not mocked addresses).
+        MockMigratingController oldController = new MockMigratingController(_directory, PROJECT_ID);
+        MockNewController newController = new MockNewController();
+
+        // Set the old controller in the directory's storage.
+        stdstore.target(address(_directory)).sig("controllerOf(uint256)").with_key(PROJECT_ID).depth(0)
+            .checked_write(address(oldController));
+
+        // Mock ownerOf to return this test contract as the project owner.
+        mockExpect(address(projects), abi.encodeCall(IERC721.ownerOf, (PROJECT_ID)), abi.encode(address(this)));
+
+        // Mock project count to allow the project to exist.
+        mockExpect(address(projects), abi.encodeCall(IJBProjects.count, ()), abi.encode(type(uint256).max));
+
+        // Perform the migration.
+        _directory.setControllerOf(PROJECT_ID, IERC165(address(newController)));
+
+        // Verify migrate() was called.
+        assertTrue(oldController.migrateCalled(), "migrate() should have been called on old controller");
+
+        // Verify the directory pointed to the old controller during migrate().
+        assertTrue(
+            oldController.directoryPointedToSelfDuringMigrate(),
+            "Directory should point to old controller during migrate()"
+        );
+
+        // Verify the directory now points to the new controller after everything completes.
+        assertEq(
+            address(_directory.controllerOf(PROJECT_ID)),
+            address(newController),
+            "Directory should point to new controller after migration"
+        );
+    }
+}

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

@@ -0,0 +1,169 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBDirectorySetup} from "./JBDirectorySetup.sol";
+
+contract TestSetPrimaryTerminalOf_Local is JBDirectorySetup {
+    using stdStorage for StdStorage;
+
+    IJBTerminal _terminalToAdd = IJBTerminal(makeAddr("newTerminal"));
+    address _mockController = makeAddr("controller");
+    address _token = makeAddr("newToken");
+
+    function setUp() public {
+        super.directorySetup();
+    }
+
+    modifier givenTerminalHasNotBeenAdded() {
+        vm.expectEmit();
+        emit IJBDirectory.AddTerminal(1, _terminalToAdd, address(this));
+        _;
+    }
+
+    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 givenValidAccountingContext() {
+        // accounting context
+        JBAccountingContext memory _context = JBAccountingContext({token: _token, decimals: 6, currency: uint32(1)});
+
+        // mock accountingContext call
+        bytes memory _contextCall = abi.encodeCall(IJBTerminal.accountingContextForTokenOf, (1, _token));
+        bytes memory _contextReturn = abi.encode(_context);
+
+        mockExpect(address(_terminalToAdd), _contextCall, _contextReturn);
+        _;
+    }
+
+    function test_WhenCallerHasNoMaidens() external {
+        // it should revert with UNAUTHORIZED()
+        // 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_PRIMARY_TERMINAL, 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_PRIMARY_TERMINAL
+            )
+        );
+        _directory.setPrimaryTerminalOf(1, _token, _terminalToAdd);
+    }
+
+    function test_GivenNoValidAccountingContextForTokenOf() external whenCallerHasPermission {
+        // it should revert with TOKEN_NOT_ACCEPTED
+        // accounting context
+        JBAccountingContext memory _context = JBAccountingContext({token: address(0), decimals: 6, currency: uint32(1)});
+
+        // mock accountingContext call
+        bytes memory _contextCall = abi.encodeCall(IJBTerminal.accountingContextForTokenOf, (1, _token));
+        bytes memory _contextReturn = abi.encode(_context);
+
+        mockExpect(address(_terminalToAdd), _contextCall, _contextReturn);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(JBDirectory.JBDirectory_TokenNotAccepted.selector, 1, _token, _terminalToAdd)
+        );
+        _directory.setPrimaryTerminalOf(1, _token, _terminalToAdd);
+    }
+
+    function test_RevertIf_GivenTerminalHasAlreadyBeenAdded()
+        external
+        whenCallerHasPermission
+        givenValidAccountingContext
+    {
+        stdstore.target(address(_directory)).sig("controllerOf(uint256)").with_key(1).depth(0)
+            .checked_write(_mockController);
+        // mock erc165 call
+        bytes memory _supportCall =
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBDirectoryAccessControl).interfaceId));
+        bytes memory _supportReturned = abi.encode(false);
+
+        mockExpect(address(_mockController), _supportCall, _supportReturned);
+
+        // it should not add the terminal, but set it as primary
+        IJBTerminal[] memory _terminals = new IJBTerminal[](1);
+        _terminals[0] = _terminalToAdd;
+
+        vm.expectEmit();
+        emit IJBDirectory.SetTerminals(1, _terminals, address(this));
+
+        _directory.setTerminalsOf(1, _terminals);
+
+        // prove that the terminal was not added - forces this test to fail as intended
+        vm.expectEmit();
+        emit IJBDirectory.SetPrimaryTerminal(1, _token, _terminals[0], address(this));
+
+        // set the primary next and mock whatever calls
+        _directory.setPrimaryTerminalOf(1, _token, _terminals[0]);
+    }
+
+    function test_GivenProjectIsNotAllowedToSetTerminals()
+        external
+        whenCallerHasPermission
+        givenValidAccountingContext
+    {
+        // it should revert with SET_TERMINALS_NOT_ALLOWED
+
+        stdstore.target(address(_directory)).sig("controllerOf(uint256)").with_key(1).depth(0)
+            .checked_write(_mockController);
+
+        // mock erc165 call
+        bytes memory _supportCall =
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBDirectoryAccessControl).interfaceId));
+        bytes memory _supportReturned = abi.encode(true);
+
+        mockExpect(address(_mockController), _supportCall, _supportReturned);
+
+        // mock setTerminalsAllowed call
+        bytes memory _allowedCall = abi.encodeCall(IJBDirectoryAccessControl.setTerminalsAllowed, (1));
+        bytes memory _allowedReturn = abi.encode(false);
+
+        mockExpect(address(_mockController), _allowedCall, _allowedReturn);
+
+        vm.expectRevert(abi.encodeWithSelector(JBDirectory.JBDirectory_SetTerminalsNotAllowed.selector, 1));
+        _directory.setPrimaryTerminalOf(1, _token, _terminalToAdd);
+    }
+
+    function test_GivenProjectIsAllowedToSetTerminals()
+        external
+        whenCallerHasPermission
+        givenValidAccountingContext
+        givenTerminalHasNotBeenAdded
+    {
+        // it should set the terminal and emit AddTerminal
+        // it should set the terminal as primary and emit SetPrimaryTerminal
+
+        stdstore.target(address(_directory)).sig("controllerOf(uint256)").with_key(1).depth(0)
+            .checked_write(_mockController);
+        // mock erc165 call
+        bytes memory _supportCall =
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBDirectoryAccessControl).interfaceId));
+        bytes memory _supportReturned = abi.encode(false);
+
+        mockExpect(address(_mockController), _supportCall, _supportReturned);
+
+        _directory.setPrimaryTerminalOf(1, _token, _terminalToAdd);
+    }
+}

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

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBDirectorySetup} from "./JBDirectorySetup.sol";
+
+contract TestSetTerminalsOf_Local is JBDirectorySetup {
+    using stdStorage for StdStorage;
+
+    IJBTerminal _terminalToAdd = IJBTerminal(makeAddr("newTerminal"));
+    address _mockController = makeAddr("controller");
+    address _token = makeAddr("newToken");
+
+    function setUp() public {
+        super.directorySetup();
+    }
+
+    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 givenSetTerminalsAllowed() {
+        // it should revert with revert SET_TERMINALS_NOT_ALLOWED()
+        stdstore.target(address(_directory)).sig("controllerOf(uint256)").with_key(1).depth(0)
+            .checked_write(_mockController);
+
+        // mock erc165 call
+        bytes memory _supportCall =
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBDirectoryAccessControl).interfaceId));
+        bytes memory _supportReturned = abi.encode(true);
+
+        mockExpect(address(_mockController), _supportCall, _supportReturned);
+
+        // mock setTerminalsAllowed call
+        bytes memory _allowedCall = abi.encodeCall(IJBDirectoryAccessControl.setTerminalsAllowed, (1));
+        bytes memory _allowedReturn = abi.encode(true);
+
+        mockExpect(address(_mockController), _allowedCall, _allowedReturn);
+        _;
+    }
+
+    function test_GivenNotSetTerminalsAllowed() external whenCallerHasPermission {
+        // it should revert with revert SET_TERMINALS_NOT_ALLOWED()
+        stdstore.target(address(_directory)).sig("controllerOf(uint256)").with_key(1).depth(0)
+            .checked_write(_mockController);
+
+        // mock erc165 call
+        bytes memory _supportCall =
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBDirectoryAccessControl).interfaceId));
+        bytes memory _supportReturned = abi.encode(true);
+
+        mockExpect(address(_mockController), _supportCall, _supportReturned);
+
+        // mock setTerminalsAllowed call
+        bytes memory _allowedCall = abi.encodeCall(IJBDirectoryAccessControl.setTerminalsAllowed, (1));
+        bytes memory _allowedReturn = abi.encode(false);
+
+        mockExpect(address(_mockController), _allowedCall, _allowedReturn);
+
+        // needed for the call
+        IJBTerminal[] memory _terminals = new IJBTerminal[](1);
+        _terminals[0] = _terminalToAdd;
+
+        vm.expectRevert(abi.encodeWithSelector(JBDirectory.JBDirectory_SetTerminalsNotAllowed.selector, 1));
+        _directory.setTerminalsOf(1, _terminals);
+    }
+
+    function test_WhenCallerHasNoPermission() external {
+        // it should revert with UNAUTHORIZED()
+        // 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_TERMINALS, true, true)
+        );
+        bytes memory _permissionsReturned = abi.encode(false);
+
+        mockExpect(address(permissions), _permissionsCall, _permissionsReturned);
+
+        // needed for the call
+        IJBTerminal[] memory _terminals = new IJBTerminal[](1);
+        _terminals[0] = _terminalToAdd;
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBPermissioned.JBPermissioned_Unauthorized.selector,
+                _ownerData,
+                address(this),
+                1,
+                JBPermissionIds.SET_TERMINALS
+            )
+        );
+        _directory.setTerminalsOf(1, _terminals);
+    }
+
+    function test_GivenDuplicateTerminalsWereAdded() external whenCallerHasPermission givenSetTerminalsAllowed {
+        // it should revert with DUPLICATE_TERMINALS()
+        // needed for the call
+        IJBTerminal[] memory _terminals = new IJBTerminal[](2);
+        _terminals[0] = _terminalToAdd;
+        _terminals[1] = _terminalToAdd;
+
+        vm.expectRevert(abi.encodeWithSelector(JBDirectory.JBDirectory_DuplicateTerminals.selector, _terminalToAdd));
+        _directory.setTerminalsOf(1, _terminals);
+    }
+
+    function test_GivenDuplicateTerminalsWereNotAdded() external whenCallerHasPermission givenSetTerminalsAllowed {
+        // it should set terminals and emit SetTerminals
+
+        // needed for the call
+        IJBTerminal[] memory _terminals = new IJBTerminal[](1);
+        _terminals[0] = _terminalToAdd;
+
+        vm.expectEmit();
+        emit IJBDirectory.SetTerminals(1, _terminals, address(this));
+
+        _directory.setTerminalsOf(1, _terminals);
+    }
+}