1  // SPDX-License-Identifier: UNLICENSED
  2  pragma solidity ^0.8.17;
  3  
  4  import { Test } from "forge-std/Test.sol";
  5  import { DeployContracts } from "../script/DeployContracts.s.sol";
  6  import { DeploymentConfig } from "../script/DeploymentConfig.s.sol";
  7  import { BaseTokenFactory } from "../contracts/factories/BaseTokenFactory.sol";
  8  import { CommunityOwnerTokenFactory } from "../contracts/factories/CommunityOwnerTokenFactory.sol";
  9  import { OwnerToken } from "../contracts/tokens/OwnerToken.sol";
 10  import { CommunityTokenDeployer } from "../contracts/CommunityTokenDeployer.sol";
 11  
 12  contract CommunityOwnerTokenFactoryTest is Test {
 13      DeploymentConfig internal deploymentConfig;
 14  
 15      address internal deployer;
 16  
 17      CommunityTokenDeployer internal tokenDeployer;
 18  
 19      CommunityOwnerTokenFactory internal ownerTokenFactory;
 20  
 21      function setUp() public virtual {
 22          DeployContracts deployment = new DeployContracts();
 23          (tokenDeployer,, ownerTokenFactory,, deploymentConfig) = deployment.run();
 24          deployer = deploymentConfig.deployer();
 25      }
 26  }
 27  
 28  contract DeploymentTest is CommunityOwnerTokenFactoryTest {
 29      function setUp() public virtual override {
 30          CommunityOwnerTokenFactoryTest.setUp();
 31      }
 32  
 33      function test_Deployment() public {
 34          assertEq(ownerTokenFactory.owner(), deployer);
 35          assertEq(ownerTokenFactory.tokenDeployer(), address(tokenDeployer));
 36      }
 37  }
 38  
 39  contract SetTokenDeployerAddressTest is CommunityOwnerTokenFactoryTest {
 40      event TokenDeployerAddressChange(address indexed);
 41  
 42      function setUp() public virtual override {
 43          CommunityOwnerTokenFactoryTest.setUp();
 44      }
 45  
 46      function test_RevertWhen_SenderIsNotOwner() public {
 47          vm.expectRevert(bytes("Ownable: caller is not the owner"));
 48          ownerTokenFactory.setTokenDeployerAddress(makeAddr("something"));
 49      }
 50  
 51      function test_RevertWhen_InvalidTokenDeployerAddress() public {
 52          vm.prank(deployer);
 53          vm.expectRevert(BaseTokenFactory.BaseTokenFactory_InvalidTokenDeployerAddress.selector);
 54          ownerTokenFactory.setTokenDeployerAddress(address(0));
 55      }
 56  
 57      function test_SetTokenDeployerAddress() public {
 58          address someAddress = makeAddr("someAddress");
 59          vm.prank(deployer);
 60          vm.expectEmit(true, true, true, true);
 61          emit TokenDeployerAddressChange(someAddress);
 62          ownerTokenFactory.setTokenDeployerAddress(someAddress);
 63          assertEq(ownerTokenFactory.tokenDeployer(), someAddress);
 64      }
 65  }
 66  
 67  contract CreateTest is CommunityOwnerTokenFactoryTest {
 68      event CreateToken(address indexed);
 69  
 70      function setUp() public virtual override {
 71          CommunityOwnerTokenFactoryTest.setUp();
 72      }
 73  
 74      function test_RevertWhen_SenderIsNotTokenDeployer() public {
 75          string memory name = "TestToken";
 76          string memory symbol = "TEST";
 77          string memory baseURI = "http://test.dev";
 78          address receiver = makeAddr("receiver");
 79          bytes memory signerPublicKey = bytes("some public key");
 80  
 81          vm.prank(makeAddr("notTokenDeployer"));
 82          vm.expectRevert(BaseTokenFactory.BaseTokenFactory_NotAuthorized.selector);
 83          ownerTokenFactory.create(name, symbol, baseURI, receiver, signerPublicKey);
 84      }
 85  
 86      function test_RevertWhen_InvalidTokenMetadata() public {
 87          string memory name = "";
 88          string memory symbol = "";
 89          string memory baseURI = "";
 90          address receiver = makeAddr("receiver");
 91          bytes memory signerPublicKey = bytes("some public key");
 92  
 93          vm.startPrank(address(tokenDeployer));
 94          vm.expectRevert(BaseTokenFactory.BaseTokenFactory_InvalidTokenMetadata.selector);
 95          ownerTokenFactory.create(name, symbol, baseURI, receiver, signerPublicKey);
 96  
 97          baseURI = "http://test.dev";
 98          vm.expectRevert(BaseTokenFactory.BaseTokenFactory_InvalidTokenMetadata.selector);
 99          ownerTokenFactory.create(name, symbol, baseURI, receiver, signerPublicKey);
100  
101          symbol = "TEST";
102          vm.expectRevert(BaseTokenFactory.BaseTokenFactory_InvalidTokenMetadata.selector);
103          ownerTokenFactory.create(name, symbol, baseURI, receiver, signerPublicKey);
104      }
105  
106      function test_RevertWhen_InvalidReceiverAddress() public {
107          string memory name = "TestToken";
108          string memory symbol = "TEST";
109          string memory baseURI = "http://test.dev";
110          address receiver = address(0);
111          bytes memory signerPublicKey = bytes("some public key");
112  
113          vm.prank(address(tokenDeployer));
114          vm.expectRevert(CommunityOwnerTokenFactory.CommunityOwnerTokenFactory_InvalidReceiverAddress.selector);
115          ownerTokenFactory.create(name, symbol, baseURI, receiver, signerPublicKey);
116      }
117  
118      function test_RevertWhen_InvalidSignerPublicKey() public {
119          string memory name = "TestToken";
120          string memory symbol = "TEST";
121          string memory baseURI = "http://test.dev";
122          address receiver = makeAddr("receiver");
123          bytes memory signerPublicKey = bytes("");
124  
125          vm.prank(address(tokenDeployer));
126          vm.expectRevert(CommunityOwnerTokenFactory.CommunityOwnerTokenFactory_InvalidSignerPublicKey.selector);
127          ownerTokenFactory.create(name, symbol, baseURI, receiver, signerPublicKey);
128      }
129  
130      function test_Create() public {
131          string memory name = "TestToken";
132          string memory symbol = "TEST";
133          string memory baseURI = "http://test.dev";
134          address receiver = makeAddr("receiver");
135          bytes memory signerPublicKey = bytes("some public key");
136  
137          vm.prank(address(tokenDeployer));
138          vm.expectEmit(false, false, false, false);
139          emit CreateToken(makeAddr("some address"));
140          address ownerTokenAddress = ownerTokenFactory.create(name, symbol, baseURI, receiver, signerPublicKey);
141  
142          assertEq(OwnerToken(ownerTokenAddress).totalSupply(), 1);
143          assertEq(OwnerToken(ownerTokenAddress).maxSupply(), 1);
144          assertEq(OwnerToken(ownerTokenAddress).balanceOf(receiver), 1);
145      }
146  }