How to test ERC1155Upgradeable contract in foundry?

Support Upgrades
1

Hey all!
I'm very new to solidity & smart contracts. I have a contract that is upgradeable using the ERC1155Upgradeable. In the contract scope, I initialize the contract using the initialize function:
function initialize() public initializer {...}
Correct me if I'm wrong, but I understood that for testing it in Foundry, ill need to set up a proxy contract that will kind of "mock" the ERC1155Upgradeable so that it can initialize my contract. but when i run my test it failed with this message:
"[FAIL. Reason: setup failed: revert: Address: invalid delegate call] setUp() (gas: 0)
"
my general question: How to test a contract that is also ERC1155Upgradeable and Initializable in foundry? is my understanding of the proxy "mock" correct?
this is the proxy mock i created:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

import {ProxyForUpgradeable} from "@thirdweb-dev/contracts/extension/ProxyForUpgradeable.sol";

contract XxProxy is ProxyForUpgradeable {
    constructor(address _logic, bytes memory _data) payable ProxyForUpgradeable(_logic, _data) {}
}

this is my contract:

// SPDX-License-Identifier: Apache 2.0
pragma solidity ^0.8.23;

import "@openzeppelin/contracts-upgradeable/token/ERC1155/ERC1155Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

contract Xx is Initializable, ERC1155Upgradeable {
    uint256 public constant X_X = 0;
    mapping(address => bool) public isAdmin;

    function initialize() public initializer {
        __ERC1155_init("");
        _mint(msg.sender, X_X, 1, "");
        isAdmin[msg.sender] = true;
    }

    function grantAdmin(address to) public {
        require(balanceOf(msg.sender, X_X) > 0, "Only admin can grant admin privileges");
        require(balanceOf(to, X_X) == 0, "User already has an admin token");
        _mint(to, X_X, 1, "");
        isAdmin[to] = true;
    }

    function revokeAdmin(address from) public {
        require(balanceOf(msg.sender, X_X) > 0, "Only admin can revoke admin privileges");
        _burn(from, X_X, balanceOf(from, X_X));
        isAdmin[from] = false;
    }
}```


this is my test:
 

```// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

import '../src/AdminTokenProxy.sol';
import '../src/AdminToken.sol';
import "forge-std/Test.sol";

contract AdminTokenTest is Test, ERC1155Upgradeable {
    AdminToken internal adminToken;
    AdminTokenProxy internal adminTokenProxy;
    address user1 = address(0x123);
    address user2 = address(0x124);

    function setUp() public {
        adminToken = new AdminToken();
        bytes memory initializerData = abi.encodeWithSignature("initialize()");

        adminTokenProxy = new AdminTokenProxy(
            address(adminToken),
            initializerData
        );
     adminToken = AdminToken(address(adminTokenProxy));
    }

    function test_contractDeployerGetAdminToken() public {
        uint256 deployerBalance = adminToken.balanceOf(address(this), adminToken.ADMIN_TOKEN());
        assertEq(deployerBalance, 1);
        bool isDeployerAdmin = adminToken.isAdmin(address(this));
        assertTrue(isDeployerAdmin);
    }
    function testFail_nonAdminUserCantGrantToken() public {
        vm.prank(user1);
        vm.expectRevert("Only admin can grant admin privileges");
    }
}```
2

You can use https://github.com/OpenZeppelin/openzeppelin-foundry-upgrades to help with this. It has functions that you can use to help deploy the implementation contract and a proxy that goes with it.