Migrate L2 Resolver tests to upgradeable

test/UpgradeableL2Resolver/Approve.t.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {UpgradeableL2ResolverBase} from "./UpgradeableL2ResolverBase.t.sol";
+import {UpgradeableL2Resolver} from "src/L2/UpgradeableL2Resolver.sol";
+
+contract Approve is UpgradeableL2ResolverBase {
+    function test_revertsIfCalledForSelf() public {
+        vm.expectRevert(UpgradeableL2Resolver.CantSetSelfAsDelegate.selector);
+        vm.prank(user);
+        resolver.approve(node, user, true);
+    }
+
+    function test_allowsSenderToSetDelegate(address operator) public {
+        vm.assume(operator != user);
+        vm.expectEmit(address(resolver));
+        emit UpgradeableL2Resolver.Approved(user, node, operator, true);
+        vm.prank(user);
+        resolver.approve(node, operator, true);
+        assertTrue(resolver.isApprovedFor(user, node, operator));
+    }
+}

test/UpgradeableL2Resolver/IsAuthorised.t.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {UpgradeableL2ResolverBase} from "./UpgradeableL2ResolverBase.t.sol";
+import {BASE_ETH_NODE} from "src/util/Constants.sol";
+
+// Because isAuthorized() is an internal method, we test it indirectly here by using `setAddr()` which
+// checks the authorization status via `isAuthorized()`.
+contract IsAuthorised is UpgradeableL2ResolverBase {
+    function test_returnsTrue_ifSenderIsController() public {
+        vm.prank(controller);
+        resolver.setAddr(node, user);
+        assertEq(resolver.addr(node), user);
+    }
+
+    function test_returnsTrue_ifSenderIsReverse() public {
+        vm.prank(reverse);
+        resolver.setAddr(node, user);
+        assertEq(resolver.addr(node), user);
+    }
+
+    function test_returnsTrue_ifSenderIOwnerOfNode() public {
+        vm.prank(owner);
+        registry.setSubnodeOwner(BASE_ETH_NODE, label, user);
+        vm.prank(user);
+        resolver.setAddr(node, user);
+        assertEq(resolver.addr(node), user);
+    }
+
+    function test_returnsTrue_ifSenderIOperatorOfNode(address operator) public {
+        vm.assume(operator != owner && operator != user && operator != address(0));
+        vm.prank(owner);
+        registry.setSubnodeOwner(BASE_ETH_NODE, label, user);
+        vm.prank(user);
+        resolver.setApprovalForAll(operator, true);
+        vm.prank(operator);
+        resolver.setAddr(node, user);
+        assertEq(resolver.addr(node), user);
+    }
+
+    function test_returnsTrue_ifSenderIDelegateOfNode(address operator) public {
+        vm.assume(operator != owner && operator != user && operator != address(0));
+        vm.prank(owner);
+        registry.setSubnodeOwner(BASE_ETH_NODE, label, user);
+        vm.prank(user);
+        resolver.approve(node, operator, true);
+        vm.prank(operator);
+        resolver.setAddr(node, user);
+        assertEq(resolver.addr(node), user);
+    }
+}

test/UpgradeableL2Resolver/SetApprovalForAll.t.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {UpgradeableL2ResolverBase} from "./UpgradeableL2ResolverBase.t.sol";
+import {L2Resolver} from "src/L2/L2Resolver.sol";
+
+contract SetApprovalForAll is UpgradeableL2ResolverBase {
+    function test_revertsIfCalledForSelf() public {
+        vm.expectRevert(L2Resolver.CantSetSelfAsOperator.selector);
+        vm.prank(user);
+        resolver.setApprovalForAll(user, true);
+    }
+
+    function test_allowsSenderToSetApproval(address operator) public {
+        vm.assume(operator != user);
+        vm.expectEmit(address(resolver));
+        emit L2Resolver.ApprovalForAll(user, operator, true);
+        vm.prank(user);
+        resolver.setApprovalForAll(operator, true);
+        assertTrue(resolver.isApprovedForAll(user, operator));
+    }
+}

test/UpgradeableL2Resolver/SetRegistrarController.t.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {UpgradeableL2ResolverBase} from "./UpgradeableL2ResolverBase.t.sol";
+import {UpgradeableL2Resolver} from "src/L2/UpgradeableL2Resolver.sol";
+import {Ownable} from "solady/auth/Ownable.sol";
+
+contract SetRegistrarController is UpgradeableL2ResolverBase {
+    function test_reverts_ifCalledByNonOwner(address caller, address newController) public {
+        vm.assume(caller != owner);
+        vm.expectRevert(Ownable.Unauthorized.selector);
+        vm.prank(caller);
+        resolver.setRegistrarController(newController);
+    }
+
+    function test_setsTheRegistrarControllerAccordingly(address newController) public {
+        vm.expectEmit();
+        emit UpgradeableL2Resolver.RegistrarControllerUpdated(newController);
+        vm.prank(owner);
+        resolver.setRegistrarController(newController);
+    }
+}

test/UpgradeableL2Resolver/SetReverseRegistrar.t.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {UpgradeableL2ResolverBase} from "./UpgradeableL2ResolverBase.t.sol";
+import {UpgradeableL2Resolver} from "src/L2/UpgradeableL2Resolver.sol";
+import {Ownable} from "solady/auth/Ownable.sol";
+
+contract SetReverseRegistrar is UpgradeableL2ResolverBase {
+    function test_reverts_ifCalledByNonOwner(address caller, address newReverse) public {
+        vm.assume(caller != owner);
+        vm.expectRevert(Ownable.Unauthorized.selector);
+        vm.prank(caller);
+        resolver.setReverseRegistrar(newReverse);
+    }
+
+    function test_setsTheReverseRegistrarAccordingly(address newReverse) public {
+        vm.expectEmit();
+        emit UpgradeableL2Resolver.ReverseRegistrarUpdated(newReverse);
+        vm.prank(owner);
+        resolver.setReverseRegistrar(newReverse);
+    }
+}

test/UpgradeableL2Resolver/SupportsInterface.t.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {UpgradeableL2ResolverBase} from "./UpgradeableL2ResolverBase.t.sol";
+
+import {IABIResolver} from "ens-contracts/resolvers/profiles/IABIResolver.sol";
+import {IAddrResolver} from "ens-contracts/resolvers/profiles/IAddrResolver.sol";
+import {IContentHashResolver} from "ens-contracts/resolvers/profiles/IContentHashResolver.sol";
+import {IDNSRecordResolver} from "ens-contracts/resolvers/profiles/IDNSRecordResolver.sol";
+import {IDNSZoneResolver} from "ens-contracts/resolvers/profiles/IDNSZoneResolver.sol";
+import {IInterfaceResolver} from "ens-contracts/resolvers/profiles/IInterfaceResolver.sol";
+import {IMulticallable} from "ens-contracts/resolvers/IMulticallable.sol";
+import {INameResolver} from "ens-contracts/resolvers/profiles/INameResolver.sol";
+import {IPubkeyResolver} from "ens-contracts/resolvers/profiles/IPubkeyResolver.sol";
+import {ITextResolver} from "ens-contracts/resolvers/profiles/ITextResolver.sol";
+import {IExtendedResolver} from "ens-contracts/resolvers/profiles/IExtendedResolver.sol";
+
+contract SupportsInterface is UpgradeableL2ResolverBase {
+    function test_supportsABIResolver() public view {
+        assertTrue(resolver.supportsInterface(type(IABIResolver).interfaceId));
+    }
+
+    function test_supportsAddrResolver() public view {
+        assertTrue(resolver.supportsInterface(type(IAddrResolver).interfaceId));
+    }
+
+    function test_supportsContentHashResolver() public view {
+        assertTrue(resolver.supportsInterface(type(IContentHashResolver).interfaceId));
+    }
+
+    function test_supportsDNSRecordResolver() public view {
+        assertTrue(resolver.supportsInterface(type(IDNSRecordResolver).interfaceId));
+    }
+
+    function test_supportsDNSZoneResolver() public view {
+        assertTrue(resolver.supportsInterface(type(IDNSZoneResolver).interfaceId));
+    }
+
+    function test_supportsInterfaceResolver() public view {
+        assertTrue(resolver.supportsInterface(type(IInterfaceResolver).interfaceId));
+    }
+
+    function test_supportsMulticallable() public view {
+        assertTrue(resolver.supportsInterface(type(IMulticallable).interfaceId));
+    }
+
+    function test_supportsNameResolver() public view {
+        assertTrue(resolver.supportsInterface(type(INameResolver).interfaceId));
+    }
+
+    function test_supportsPubkeyResolver() public view {
+        assertTrue(resolver.supportsInterface(type(IPubkeyResolver).interfaceId));
+    }
+
+    function test_supportsTextResolver() public view {
+        assertTrue(resolver.supportsInterface(type(ITextResolver).interfaceId));
+    }
+
+    function test_supportsExtendedResolver() public view {
+        assertTrue(resolver.supportsInterface(type(IExtendedResolver).interfaceId));
+    }
+}

test/UpgradeableL2Resolver/UpgradeableL2ResolverBase.t.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Test} from "forge-std/Test.sol";
+import {UpgradeableL2Resolver} from "src/L2/UpgradeableL2Resolver.sol";
+import {TransparentUpgradeableProxy} from
+    "openzeppelin-contracts/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import {Registry} from "src/L2/Registry.sol";
+import {ENS} from "ens-contracts/registry/ENS.sol";
+import {ETH_NODE, REVERSE_NODE} from "src/util/Constants.sol";
+import {NameEncoder} from "ens-contracts/utils/NameEncoder.sol";
+import {MockReverseRegistrar} from "test/mocks/MockReverseRegistrar.sol";
+
+contract UpgradeableL2ResolverBase is Test {
+    UpgradeableL2Resolver public resolverImpl;
+    TransparentUpgradeableProxy public proxy;
+    UpgradeableL2Resolver public resolver;
+    Registry public registry;
+    address reverse;
+    address controller = makeAddr("controller");
+    address admin = makeAddr("admin");
+    address owner = makeAddr("owner");
+    address user = makeAddr("user");
+    string name = "test.base.eth";
+    bytes32 label = keccak256("test");
+    bytes32 node;
+
+    function setUp() public {
+        registry = new Registry(owner);
+        reverse = address(new MockReverseRegistrar());
+        resolverImpl = new UpgradeableL2Resolver();
+        proxy = new TransparentUpgradeableProxy(
+            address(resolverImpl),
+            admin,
+            abi.encodeWithSelector(
+                UpgradeableL2Resolver.initialize.selector, registry, address(controller), address(reverse), owner
+            )
+        );
+        resolver = UpgradeableL2Resolver(address(proxy));
+        (, node) = NameEncoder.dnsEncodeName(name);
+        _establishNamespace();
+    }
+
+    function _establishNamespace() internal virtual {
+        // establish the base.eth namespace
+        bytes32 ethLabel = keccak256("eth");
+        bytes32 baseLabel = keccak256("base");
+        vm.prank(owner);
+        registry.setSubnodeOwner(0x0, ethLabel, owner);
+        vm.prank(owner);
+        registry.setSubnodeOwner(ETH_NODE, baseLabel, owner);
+
+        // establish the 80002105.reverse namespace
+        vm.prank(owner);
+        registry.setSubnodeOwner(0x0, keccak256("reverse"), owner);
+        vm.prank(owner);
+        registry.setSubnodeOwner(REVERSE_NODE, keccak256("80002105"), address(reverse));
+    }
+}