github.com/ethereum-optimism/optimism@v1.7.2/packages/contracts-bedrock/test/governance/GovernanceToken.t.sol (about)

     1  // SPDX-License-Identifier: MIT
     2  pragma solidity 0.8.15;
     3  
     4  // Testing utilities
     5  import { CommonTest } from "test/setup/CommonTest.sol";
     6  
     7  contract GovernanceToken_Test is CommonTest {
     8      address owner;
     9      address rando;
    10  
    11      /// @dev Sets up the test suite.
    12      function setUp() public virtual override {
    13          super.setUp();
    14          owner = governanceToken.owner();
    15          rando = makeAddr("rando");
    16      }
    17  
    18      /// @dev Tests that the constructor sets the correct initial state.
    19      function test_constructor_succeeds() external {
    20          assertEq(governanceToken.owner(), owner);
    21          assertEq(governanceToken.name(), "Optimism");
    22          assertEq(governanceToken.symbol(), "OP");
    23          assertEq(governanceToken.decimals(), 18);
    24          assertEq(governanceToken.totalSupply(), 0);
    25      }
    26  
    27      /// @dev Tests that the owner can successfully call `mint`.
    28      function test_mint_fromOwner_succeeds() external {
    29          // Mint 100 tokens.
    30          vm.prank(owner);
    31          governanceToken.mint(owner, 100);
    32  
    33          // Balances have updated correctly.
    34          assertEq(governanceToken.balanceOf(owner), 100);
    35          assertEq(governanceToken.totalSupply(), 100);
    36      }
    37  
    38      /// @dev Tests that `mint` reverts when called by a non-owner.
    39      function test_mint_fromNotOwner_reverts() external {
    40          // Mint 100 tokens as rando.
    41          vm.prank(rando);
    42          vm.expectRevert("Ownable: caller is not the owner");
    43          governanceToken.mint(owner, 100);
    44  
    45          // Balance does not update.
    46          assertEq(governanceToken.balanceOf(owner), 0);
    47          assertEq(governanceToken.totalSupply(), 0);
    48      }
    49  
    50      /// @dev Tests that the owner can successfully call `burn`.
    51      function test_burn_succeeds() external {
    52          // Mint 100 tokens to rando.
    53          vm.prank(owner);
    54          governanceToken.mint(rando, 100);
    55  
    56          // Rando burns their tokens.
    57          vm.prank(rando);
    58          governanceToken.burn(50);
    59  
    60          // Balances have updated correctly.
    61          assertEq(governanceToken.balanceOf(rando), 50);
    62          assertEq(governanceToken.totalSupply(), 50);
    63      }
    64  
    65      /// @dev Tests that the owner can successfully call `burnFrom`.
    66      function test_burnFrom_succeeds() external {
    67          // Mint 100 tokens to rando.
    68          vm.prank(owner);
    69          governanceToken.mint(rando, 100);
    70  
    71          // Rando approves owner to burn 50 tokens.
    72          vm.prank(rando);
    73          governanceToken.approve(owner, 50);
    74  
    75          // Owner burns 50 tokens from rando.
    76          vm.prank(owner);
    77          governanceToken.burnFrom(rando, 50);
    78  
    79          // Balances have updated correctly.
    80          assertEq(governanceToken.balanceOf(rando), 50);
    81          assertEq(governanceToken.totalSupply(), 50);
    82      }
    83  
    84      /// @dev Tests that `transfer` correctly transfers tokens.
    85      function test_transfer_succeeds() external {
    86          // Mint 100 tokens to rando.
    87          vm.prank(owner);
    88          governanceToken.mint(rando, 100);
    89  
    90          // Rando transfers 50 tokens to owner.
    91          vm.prank(rando);
    92          governanceToken.transfer(owner, 50);
    93  
    94          // Balances have updated correctly.
    95          assertEq(governanceToken.balanceOf(owner), 50);
    96          assertEq(governanceToken.balanceOf(rando), 50);
    97          assertEq(governanceToken.totalSupply(), 100);
    98      }
    99  
   100      /// @dev Tests that `approve` correctly sets allowances.
   101      function test_approve_succeeds() external {
   102          // Mint 100 tokens to rando.
   103          vm.prank(owner);
   104          governanceToken.mint(rando, 100);
   105  
   106          // Rando approves owner to spend 50 tokens.
   107          vm.prank(rando);
   108          governanceToken.approve(owner, 50);
   109  
   110          // Allowances have updated.
   111          assertEq(governanceToken.allowance(rando, owner), 50);
   112      }
   113  
   114      /// @dev Tests that `transferFrom` correctly transfers tokens.
   115      function test_transferFrom_succeeds() external {
   116          // Mint 100 tokens to rando.
   117          vm.prank(owner);
   118          governanceToken.mint(rando, 100);
   119  
   120          // Rando approves owner to spend 50 tokens.
   121          vm.prank(rando);
   122          governanceToken.approve(owner, 50);
   123  
   124          // Owner transfers 50 tokens from rando to owner.
   125          vm.prank(owner);
   126          governanceToken.transferFrom(rando, owner, 50);
   127  
   128          // Balances have updated correctly.
   129          assertEq(governanceToken.balanceOf(owner), 50);
   130          assertEq(governanceToken.balanceOf(rando), 50);
   131          assertEq(governanceToken.totalSupply(), 100);
   132      }
   133  
   134      /// @dev Tests that `increaseAllowance` correctly increases allowances.
   135      function test_increaseAllowance_succeeds() external {
   136          // Mint 100 tokens to rando.
   137          vm.prank(owner);
   138          governanceToken.mint(rando, 100);
   139  
   140          // Rando approves owner to spend 50 tokens.
   141          vm.prank(rando);
   142          governanceToken.approve(owner, 50);
   143  
   144          // Rando increases allowance by 50 tokens.
   145          vm.prank(rando);
   146          governanceToken.increaseAllowance(owner, 50);
   147  
   148          // Allowances have updated.
   149          assertEq(governanceToken.allowance(rando, owner), 100);
   150      }
   151  
   152      /// @dev Tests that `decreaseAllowance` correctly decreases allowances.
   153      function test_decreaseAllowance_succeeds() external {
   154          // Mint 100 tokens to rando.
   155          vm.prank(owner);
   156          governanceToken.mint(rando, 100);
   157  
   158          // Rando approves owner to spend 100 tokens.
   159          vm.prank(rando);
   160          governanceToken.approve(owner, 100);
   161  
   162          // Rando decreases allowance by 50 tokens.
   163          vm.prank(rando);
   164          governanceToken.decreaseAllowance(owner, 50);
   165  
   166          // Allowances have updated.
   167          assertEq(governanceToken.allowance(rando, owner), 50);
   168      }
   169  }