1  // SPDX-License-Identifier: UNLICENSED
  2  pragma solidity ^0.8.13;
  3  
  4  import "forge-std/Test.sol";
  5  import "../src/Hats.sol";
  6  import "../src/Interfaces/HatsEvents.sol";
  7  import "../src/Interfaces/HatsErrors.sol";
  8  
  9  abstract contract TestVariables is HatsEvents, HatsErrors {
 10      Hats hats;
 11  
 12      address internal topHatWearer;
 13      address internal secondWearer;
 14      address internal thirdWearer;
 15      address internal fourthWearer;
 16      address internal nonWearer;
 17  
 18      uint256 internal _admin;
 19      string internal _details;
 20      uint32 internal _maxSupply;
 21      address internal _eligibility;
 22      address internal _toggle;
 23      string internal _baseImageURI;
 24  
 25      string internal topHatImageURI;
 26      string internal secondHatImageURI;
 27      string internal thirdHatImageURI;
 28  
 29      uint256 internal topHatId;
 30      uint256 internal secondHatId;
 31      uint256 internal thirdHatId;
 32  
 33      string internal name;
 34  
 35      uint256[] adminsBatch;
 36      string[] detailsBatch;
 37      uint32[] maxSuppliesBatch;
 38      address[] eligibilityModulesBatch;
 39      address[] toggleModulesBatch;
 40      bool[] mutablesBatch;
 41      string[] imageURIsBatch;
 42  
 43      string retdetails;
 44      uint32 retmaxSupply;
 45      uint32 retsupply;
 46      address reteligibility;
 47      address rettoggle;
 48      string retimageURI;
 49      uint16 retlastHatId;
 50      bool retmutable;
 51      bool retactive;
 52  
 53      bool active_;
 54      bool mutable_;
 55  
 56      event TransferSingle(
 57          address indexed operator, address indexed from, address indexed to, uint256 id, uint256 amount
 58      );
 59  
 60      error InvalidChildHat();
 61  }
 62  
 63  abstract contract TestSetup is Test, TestVariables {
 64      function setUp() public virtual {
 65          setUpVariables();
 66          // instantiate Hats contract
 67          hats = new Hats(name, _baseImageURI);
 68  
 69          // create TopHat
 70          createTopHat();
 71      }
 72  
 73      function setUpVariables() internal {
 74          // set variables: deploy
 75          _baseImageURI = "https://www.images.hats.work/";
 76  
 77          // set variables: addresses
 78          topHatWearer = address(1);
 79          secondWearer = address(2);
 80          thirdWearer = address(3);
 81          fourthWearer = address(4);
 82          nonWearer = address(100);
 83  
 84          // set variables: Hat parameters
 85          _maxSupply = 1;
 86          _eligibility = address(555);
 87          _toggle = address(333);
 88  
 89          topHatImageURI = "http://www.tophat.com/";
 90          secondHatImageURI = "http://www.second.com/";
 91          thirdHatImageURI = "http://www.third.com/";
 92  
 93          name = "Hats Test Contract";
 94      }
 95  
 96      function createTopHat() internal {
 97          // create TopHat
 98          topHatId = hats.mintTopHat(topHatWearer, "tophat", "http://www.tophat.com/");
 99      }
100  
101      /// @dev assumes a tophat has already been created
102      /// @dev doesn't apply any imageURIs
103      function createHatsBranch(uint256 _length, uint256 _topHatId, address _topHatWearer, bool _mutable)
104          internal
105          returns (uint256[] memory ids, address[] memory wearers)
106      {
107          uint256 id;
108          address wearer;
109          uint256 admin;
110          address adminWearer;
111  
112          ids = new uint256[](_length);
113          wearers = new address[](_length);
114  
115          for (uint256 i = 0; i < _length; ++i) {
116              admin = (i == 0) ? _topHatId : ids[i - 1];
117  
118              adminWearer = (i == 0) ? _topHatWearer : wearers[i - 1];
119  
120              // create ith hat from the admin
121              vm.prank(adminWearer);
122  
123              id = hats.createHat(
124                  admin,
125                  string.concat("hat ", vm.toString(i + 2)),
126                  _maxSupply,
127                  _eligibility,
128                  _toggle,
129                  _mutable,
130                  "" // imageURI
131              );
132              ids[i] = id;
133  
134              // mint ith hat from the admin, to the ith wearer
135              vm.prank(adminWearer);
136              wearer = address(uint160(i));
137              hats.mintHat(id, wearer);
138  
139              wearers[i] = wearer;
140          }
141      }
142  }
143  
144  // in addition to TestSetup, TestSetup2 creates and mints a second hat
145  abstract contract TestSetup2 is TestSetup {
146      function setUp() public virtual override {
147          // expand on TestSetup
148          super.setUp();
149  
150          // create second Hat
151          vm.prank(topHatWearer);
152          secondHatId = hats.createHat(
153              topHatId,
154              "second hat",
155              2, // maxSupply
156              _eligibility,
157              _toggle,
158              false,
159              secondHatImageURI
160          );
161  
162          // mint second hat
163          vm.prank(address(topHatWearer));
164          hats.mintHat(secondHatId, secondWearer);
165      }
166  }
167  
168  abstract contract TestSetupMutable is TestSetup {
169      function setUp() public virtual override {
170          // expand on TestSetup
171          super.setUp();
172  
173          // create a mutable Hat
174          vm.prank(topHatWearer);
175          secondHatId = hats.createHat(
176              topHatId,
177              "mutable hat",
178              2, // maxSupply
179              _eligibility,
180              _toggle,
181              true,
182              secondHatImageURI
183          );
184      }
185  }
186  
187  abstract contract TestSetupBatch is TestSetup {
188      function setUp() public override {
189          // expand on TestSetup
190          super.setUp();
191  
192          // create empty batch create arrays
193      }
194  }