test: add integration tests for Anvil migrations

packages/protocol/migrations_sol/integration_tests.sh

@@ -1,4 +1,66 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-forge test --fork-url http://127.0.0.1:$ANVIL_PORT --match-contract=IntegrationTest -vvv # || echo "Test failed" # TODO for some reason the echo didn't work
+: '
+  The following runs specific integration tests.
+  '
+# Run integration tests
+forge test \
+--match-contract=IntegrationTest \
+-vvv \
+--fork-url http://127.0.0.1:$ANVIL_PORT
+
+: '
+  The following tests assert that existing unit tests pass when run against the migrated anvil fork.
+  These are necessary, but not sufficient requirements.
+  The idea is that existing unit tests, which are known to pass in a testing environment, should
+  also pass if they are run against the devchain using the "--fork-url" flag.
+  '
+# Run tests common
+# can't use gas limit because some setUp function use more than the limit
+forge test \
+--match-path "test-sol/common/*" \
+-vvv \
+--fork-url http://127.0.0.1:$ANVIL_PORT
+
+# Run tests governance/network
+forge test \
+--match-path "test-sol/governance/network/*" \
+--block-gas-limit 50000000 \
+-vvv \
+--fork-url http://127.0.0.1:$ANVIL_PORT
+
+# Run tests governance/validators
+forge test \
+--match-path "test-sol/governance/validators/*" \
+--block-gas-limit 50000000 \
+-vvv \
+--fork-url http://127.0.0.1:$ANVIL_PORT
+
+# Run tests governance/voting
+# can't use gas limit because some setUp function use more than the limit
+forge test \
+--match-path "test-sol/governance/voting/*" \
+--block-gas-limit 50000000 \
+-vvv \
+--fork-url http://127.0.0.1:$ANVIL_PORT
+
+# Run tests stability
+forge test \
+--match-path "test-sol/stability/*" \
+--block-gas-limit 50000000 \
+-vvv \
+--fork-url http://127.0.0.1:$ANVIL_PORT
+
+# Run tests identity
+forge test \
+--match-path "test-sol/identity/*" \
+--block-gas-limit 50000000 \
+-vvv \
+--fork-url http://127.0.0.1:$ANVIL_PORT
+
+# Run Everything just in case something was missed
+# can't use gas limit because some setUp function use more than the limit
+forge test \
+-vvv \
+--fork-url http://127.0.0.1:$ANVIL_PORT #TODO this should ignore integration tests

packages/protocol/test-sol/integration/Integration.t.sol

@@ -1,19 +1,90 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.5.13;
+pragma solidity >=0.5.13 <0.8.20;
 
+// import "forge-std/console2.sol";
+
+// import { Constants } from "@test-sol/constants.sol";
 import "celo-foundry/Test.sol";
-import "@celo-contracts/common/GoldToken.sol";
-// import "@celo-contracts/common/test/MockGoldToken.sol";
-import "forge-std/console.sol";
+import { Utils } from "@test-sol/utils.sol";
 import "@celo-contracts/common/interfaces/IRegistry.sol";
+import "@celo-contracts/common/interfaces/IProxy.sol";
+
 
 contract IntegrationTest is Test {
   address constant registryAddress = address(0x000000000000000000000000000000000000ce10);
-  address account1 = actor("account1");
-  address account2 = actor("account2");
   IRegistry registry = IRegistry(registryAddress);
 
-  function setUp() public {}
+  // address account1 = actor("account1");
+  // address account2 = actor("account2");
 
-  function test_dummy() public {}
+  function setUp() public {}
 }
+
+contract RegistryIntegrationTest is IntegrationTest, Utils {
+  string[23] expectedContractsInRegistry;
+  IProxy proxy;
+
+  // TODO(Arthur): Consider moving this to a config file. Perhaps make the migration depend
+  // on that file too?
+  constructor() public {
+    expectedContractsInRegistry = [
+      "Accounts",
+      "BlockchainParameters",
+      "DoubleSigningSlasher",
+      "DowntimeSlasher",
+      "Election",
+      "EpochRewards",
+      "Escrow",
+      "FederatedAttestations",
+      "FeeCurrencyWhitelist",
+      "FeeCurrencyDirectory",
+      "Freezer",
+      "FeeHandler",
+      "GoldToken",
+      "Governance",
+      "GovernanceSlasher",
+      "LockedGold",
+      "OdisPayments",
+      "Random",
+      "Registry",
+      "SortedOracles",
+      "UniswapFeeHandlerSeller",
+      "MentoFeeHandlerSeller",
+      "Validators"
+    ];
+  }
+
+  function test_shouldHaveAddressInRegistry() public view {
+    for (uint256 i = 0; i < expectedContractsInRegistry.length; i++) { 
+      string memory contractName = expectedContractsInRegistry[i];
+      address contractAddress = registry.getAddressFor(keccak256(abi.encodePacked(contractName)));
+      console2.log(contractName, "address in Registry is: ", contractAddress);
+      assert(contractAddress != address(0));
+    }
+  }
+
+  function test_shouldHaveCorrectBytecode() public {
+    ////////////////////DEBUGGING: START/////////////////////////
+    // SPECIFIC EXAMPLE REGISTRY.SOL BEFORE LOOPING OVER ALL CONTRACTS
+    string memory contractName = "Registry";
+    address proxyAddress = registry.getAddressForStringOrDie(contractName);
+    proxy = IProxy(address(uint160(proxyAddress)));
+    ////////////////////DEBUGGING: END///////////////////////////
+
+    address implementationAddress = proxy._getImplementation();
+    console2.log("Implementation address is :", implementationAddress);
+
+    // Get bytecode from deployed contract (in Solidity 0.5)
+    bytes memory actualBytecode = getCodeAt(implementationAddress); // IProxy.sol and Proxy.sol are 0.5
+    // Get bytecode from build artifacts
+    bytes memory expectedBytecode = vm.getDeployedCode("Registry.sol");
+
+    // // Get bytecode from deployed contract (in Solidity 0.8)
+    // bytes memory actualBytecode = implementationAddress.code;
+    // // Get bytecode from build artifacts (in Solidity 0.8)
+    // bytes memory expectedBytecode = vm.getDeployedCode(string.concat(contractName, ".sol"));
+
+    // Compare the bytecodes
+    assertEq(actualBytecode, expectedBytecode, "Bytecode does not match");
+  }
+}

packages/protocol/test-sol/utils.sol

@@ -75,4 +75,25 @@ contract Utils is Test {
       (uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty, msg.sender, salt))) %
         (max - min + 1)) + min;
   }
+
+  // Get the runtime code or "deployedBytecode" at a contract address.
+  // Using the `.code` or `.runtime` property on a contract is only available in Solidity 0.8.0 and later.
+  // On Solity <0.8.0, inline assembly is necessary to retrieve the bytecode of a contract.
+  // This implementation is taken from the Solidity documentation.
+  // Source: https://docs.soliditylang.org/en/v0.4.24/assembly.html#example
+  function getCodeAt(address _addr) public view returns (bytes memory o_code) {
+    assembly {
+      // retrieve the size of the code, this needs assembly
+      let size := extcodesize(_addr)
+      // allocate output byte array - this could also be done without assembly
+      // by using o_code = new bytes(size)
+      o_code := mload(0x40)
+      // new "memory end" including padding
+      mstore(0x40, add(o_code, and(add(add(size, 0x20), 0x1f), not(0x1f))))
+      // store length in memory
+      mstore(o_code, size)
+      // actually retrieve the code, this needs assembly
+      extcodecopy(_addr, add(o_code, 0x20), 0, size)
+    }
+  }
 }