test(evm): test IAuth and Boostcore passthrough auth

Author: Quazia

packages/evm/contracts/auth/IAuth.sol

@@ -8,4 +8,4 @@ interface IAuth {
     /// @param addr The address to check for authorization
     /// @return bool Returns true if the address is authorized, false otherwise
     function isAuthorized(address addr) external view returns (bool);
-}
+}

packages/evm/contracts/auth/PassthroughAuth.sol

@@ -1,8 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0
 pragma solidity ^0.8.24;
+
 import {IAuth} from "contracts/auth/IAuth.sol";
 /// @title Passthrough Authorization Contract
 /// @dev Implements the IAuth interface, always authorizing access.
+
 contract PassthroughAuth is IAuth {
     /// @notice Checks if an address is authorized
     /// @dev In this implementation, all addresses are authorized.
@@ -11,4 +13,4 @@ contract PassthroughAuth is IAuth {
     function isAuthorized(address user) public view override returns (bool) {
         return true;
     }
-}
+}

packages/evm/contracts/shared/Mocks.sol

@@ -5,6 +5,7 @@ import {LibString} from "@solady/utils/LibString.sol";
 import {ERC20} from "@solady/tokens/ERC20.sol";
 import {ERC721} from "@solady/tokens/ERC721.sol";
 import {ERC1155} from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
+import {IAuth} from "contracts/auth/IAuth.sol";
 
 /**
  * 🚨 WARNING: The mocks in this file are for testing purposes only. DO NOT use
@@ -72,3 +73,27 @@ contract MockERC1155 is ERC1155 {
         _burn(from, id, amount);
     }
 }
+
+/// @title Mock Authorization Contract
+/// @dev Mock implementation of the IAuth interface for testing purposes.
+/// Allows setting authorized addresses via the constructor.
+contract MockAuth is IAuth {
+    mapping(address => bool) private _isAuthorized;
+
+    /// @notice Initializes the contract with a list of authorized addresses.
+    /// @param authorizedAddresses An array of addresses to be marked as authorized.
+    /// @dev Addresses not included in the list will default to unauthorized.
+    constructor(address[] memory authorizedAddresses) {
+        for (uint256 i = 0; i < authorizedAddresses.length; i++) {
+            _isAuthorized[authorizedAddresses[i]] = true;
+        }
+    }
+
+    /// @notice Checks if an address is authorized.
+    /// @param addr The address to check for authorization.
+    /// @return bool Returns true if the address is authorized, false otherwise.
+    /// @dev This function overrides the isAuthorized function in the IAuth interface.
+    function isAuthorized(address addr) external view override returns (bool) {
+        return _isAuthorized[addr];
+    }
+}

packages/evm/test/BoostCore.t.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.24;
 
 import {Test, console} from "lib/forge-std/src/Test.sol";
-import {MockERC20, MockERC721} from "contracts/shared/Mocks.sol";
+import {MockERC20, MockERC721, MockAuth} from "contracts/shared/Mocks.sol";
 
 import {LibClone} from "@solady/utils/LibClone.sol";
 import {LibZip} from "@solady/utils/LibZip.sol";
@@ -41,6 +41,8 @@ contract BoostCoreTest is Test {
 
     MockERC20 mockERC20 = new MockERC20();
     MockERC721 mockERC721 = new MockERC721();
+    MockAuth mockAuth;
+    address[] mockAddresses;
 
     BoostCore boostCore = new BoostCore(new BoostRegistry(), address(1));
     BoostLib.Target action = _makeAction(address(mockERC721), MockERC721.mint.selector, mockERC721.mintPrice());
@@ -78,6 +80,8 @@ contract BoostCoreTest is Test {
                 })
             )
         );
+        mockAddresses.push(address(this));
+        mockAuth = new MockAuth(mockAddresses);
     }
 
     /////////////////////////////
@@ -242,6 +246,42 @@ contract BoostCoreTest is Test {
         boostCore.createBoost(invalidActionCalldata);
     }
 
+    //////////////////////////////////
+    // BoostCore.setCreateBoostAuth //
+    /////////////////////////////////
+
+    function testSetAuthToMockAuth() public {
+        // Assuming BoostCore has a function to set the auth strategy
+        boostCore.setCreateBoostAuth(address(mockAuth));
+        assertTrue(address(boostCore.createBoostAuth()) == address(mockAuth), "Auth strategy not set correctly");
+    }
+
+    function testAuthorizedUserCanCreateBoost() public {
+        // Set the auth strategy to MockAuth
+        boostCore.setCreateBoostAuth(address(mockAuth));
+
+        // Use an authorized address (this contract)
+        boostCore.createBoost(validCreateCalldata);
+
+        // Verify the boost was created
+        assertEq(1, boostCore.getBoostCount(), "Authorized user should be able to create boost");
+    }
+
+    function testUnauthorizedUserCannotCreateBoost() public {
+        // Set the auth strategy to MockAuth
+        boostCore.setCreateBoostAuth(address(mockAuth));
+
+        // Use an unauthorized address
+        vm.prank(makeAddr("unauthorizedBoostCreator"));
+
+        // Expect a revert due to unauthorized access
+        vm.expectRevert(BoostError.Unauthorized.selector);
+        boostCore.createBoost(validCreateCalldata);
+
+        // Verify no boost was created
+        assertEq(0, boostCore.getBoostCount(), "Unauthorized user should not be able to create boost");
+    }
+
     ///////////////////////////
     // Test Helper Functions //
     ///////////////////////////

packages/evm/test/shared/Mocks.t.sol

@@ -3,14 +3,20 @@ pragma solidity ^0.8.24;
 
 import {Test, console} from "lib/forge-std/src/Test.sol";
 import {MockERC20, MockERC721} from "contracts/shared/Mocks.sol";
+import {MockAuth} from "contracts/shared/Mocks.sol"; // Add this import at the top with the others
 
 contract MocksTest is Test {
     MockERC20 mockERC20;
     MockERC721 mockERC721;
+    MockAuth mockAuth;
+    address[] mockAddresses;
+    address authorizedBoostCreator = makeAddr("authorizedBoostCreator");
 
     function setUp() public {
         mockERC20 = new MockERC20();
         mockERC721 = new MockERC721();
+        mockAddresses.push(authorizedBoostCreator);
+        mockAuth = new MockAuth(mockAddresses);
     }
 
     ///////////////
@@ -88,4 +94,15 @@ contract MocksTest is Test {
             "https://example.com/token/115792089237316195423570985008687907853269984665640564039457584007913129639935"
         );
     }
+
+    //////////////
+    // MockAuth //
+    //////////////
+    function testMockAuthIsAuthorized() public {
+        assertTrue(mockAuth.isAuthorized(authorizedBoostCreator));
+    }
+
+    function testMockAuthIsNotAuthorized() public {
+        assertFalse(mockAuth.isAuthorized(address(this)));
+    }
 }