From 9d4267f1d0af59b51d5e87a01cdbd2f414191b8f Mon Sep 17 00:00:00 2001 From: Tim Pechersky Date: Tue, 15 Feb 2022 21:15:48 +0000 Subject: [PATCH] tests wip --- contracts/terminus/TerminusInitializer.sol | 3 +- .../migrations/PoolControllerEnumeration.sol | 12 +- dao/core.py | 12 ++ .../ERC1155WithTerminusStorageFixture.py | 2 +- dao/fixtures/TerminusFacetFixture.py | 2 +- dao/fixtures/TerminusInitializerFixture.py | 2 +- dao/fixtures/TestFixture.py | 2 +- dao/test_PoolControllerEnumerateMigration.py | 1 + dao/test_core.py | 32 ++++- dao/test_terminus.py | 109 +++++++++++++++++- 10 files changed, 166 insertions(+), 11 deletions(-) diff --git a/contracts/terminus/TerminusInitializer.sol b/contracts/terminus/TerminusInitializer.sol index d57ec9e..7d06f6d 100644 --- a/contracts/terminus/TerminusInitializer.sol +++ b/contracts/terminus/TerminusInitializer.sol @@ -12,6 +12,7 @@ pragma solidity ^0.8.9; import "@openzeppelin-contracts/contracts/token/ERC1155/IERC1155.sol"; import "@openzeppelin-contracts/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol"; import "../diamond/libraries/LibDiamond.sol"; +import "./IERC1155Enumerable.sol"; import "./LibTerminus.sol"; contract TerminusInitializer { @@ -19,7 +20,7 @@ contract TerminusInitializer { LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage(); ds.supportedInterfaces[type(IERC1155).interfaceId] = true; ds.supportedInterfaces[type(IERC1155MetadataURI).interfaceId] = true; - ds.supportedInterfaces[type(IERC1155MetadataURI).interfaceId] = true; + ds.supportedInterfaces[type(IERC1155Enumerable).interfaceId] = true; LibTerminus.TerminusStorage storage ts = LibTerminus.terminusStorage(); ts.controller = msg.sender; diff --git a/contracts/terminus/migrations/PoolControllerEnumeration.sol b/contracts/terminus/migrations/PoolControllerEnumeration.sol index 45415a0..a97eac8 100644 --- a/contracts/terminus/migrations/PoolControllerEnumeration.sol +++ b/contracts/terminus/migrations/PoolControllerEnumeration.sol @@ -10,18 +10,22 @@ pragma solidity ^0.8.9; import "../LibTerminus.sol"; +import "../../diamond/libraries/LibDiamond.sol"; +import "../IERC1155Enumerable.sol"; contract PoolControllerEnumeration { function init() external { + LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage(); + ds.supportedInterfaces[type(IERC1155Enumerable).interfaceId] = true; LibTerminus.TerminusStorage storage ts = LibTerminus.terminusStorage(); - for(uint256 i = 0; i < ts.currentPoolID; i++) - { + for (uint256 i = 0; i < ts.currentPoolID; i++) { address poolController = ts.poolController[i]; - ts.controlledPools[poolController][ts.controllerPoolsNumber[poolController]] = i; + ts.controlledPools[poolController][ + ts.controllerPoolsNumber[poolController] + ] = i; ts.controllerPoolsNumber[poolController]++; } - } } diff --git a/dao/core.py b/dao/core.py index 0b1ab11..16f6ee3 100644 --- a/dao/core.py +++ b/dao/core.py @@ -21,6 +21,10 @@ from . import ( TerminusFacet, TerminusInitializer, ) +from .fixtures import ( + TerminusFacetFixture, + TerminusInitializerFixture, +) FACETS: Dict[str, Any] = { "DiamondCutFacet": DiamondCutFacet, @@ -28,6 +32,7 @@ FACETS: Dict[str, Any] = { "ERC20Facet": ERC20Facet, "OwnershipFacet": OwnershipFacet, "TerminusFacet": TerminusFacet, + "TerminusFacetFixture": TerminusFacetFixture, } FACET_PRECEDENCE: List[str] = [ @@ -36,6 +41,7 @@ FACET_PRECEDENCE: List[str] = [ "DiamondLoupeFacet", "ERC20Facet", "TerminusFacet", + "TerminusFacetFixture", ] FACET_ACTIONS: Dict[str, int] = {"add": 0, "replace": 1, "remove": 2} @@ -117,6 +123,12 @@ def facet_cut( initializer_address ) calldata = terminus_initializer.contract.init.encode_input() + elif facet_name == "TerminusFacetFixture": + if initializer_address != ZERO_ADDRESS and action != "remove": + terminus_initializer = TerminusInitializerFixture.TerminusInitializerFixture( + initializer_address + ) + calldata = terminus_initializer.contract.init.encode_input() diamond = DiamondCutFacet.DiamondCutFacet(diamond_address) transaction = diamond.diamond_cut( diff --git a/dao/fixtures/ERC1155WithTerminusStorageFixture.py b/dao/fixtures/ERC1155WithTerminusStorageFixture.py index f273f8a..bb50e70 100644 --- a/dao/fixtures/ERC1155WithTerminusStorageFixture.py +++ b/dao/fixtures/ERC1155WithTerminusStorageFixture.py @@ -12,7 +12,7 @@ from brownie.network.contract import ContractContainer from eth_typing.evm import ChecksumAddress -PROJECT_DIRECTORY = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) +PROJECT_DIRECTORY = os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")) BUILD_DIRECTORY = os.path.join(PROJECT_DIRECTORY, "build", "contracts") diff --git a/dao/fixtures/TerminusFacetFixture.py b/dao/fixtures/TerminusFacetFixture.py index 70eb254..d852acf 100644 --- a/dao/fixtures/TerminusFacetFixture.py +++ b/dao/fixtures/TerminusFacetFixture.py @@ -12,7 +12,7 @@ from brownie.network.contract import ContractContainer from eth_typing.evm import ChecksumAddress -PROJECT_DIRECTORY = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) +PROJECT_DIRECTORY = os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")) BUILD_DIRECTORY = os.path.join(PROJECT_DIRECTORY, "build", "contracts") diff --git a/dao/fixtures/TerminusInitializerFixture.py b/dao/fixtures/TerminusInitializerFixture.py index 5399fd4..e62ba67 100644 --- a/dao/fixtures/TerminusInitializerFixture.py +++ b/dao/fixtures/TerminusInitializerFixture.py @@ -12,7 +12,7 @@ from brownie.network.contract import ContractContainer from eth_typing.evm import ChecksumAddress -PROJECT_DIRECTORY = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) +PROJECT_DIRECTORY = os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")) BUILD_DIRECTORY = os.path.join(PROJECT_DIRECTORY, "build", "contracts") diff --git a/dao/fixtures/TestFixture.py b/dao/fixtures/TestFixture.py index 770acbf..f71b5a8 100644 --- a/dao/fixtures/TestFixture.py +++ b/dao/fixtures/TestFixture.py @@ -12,7 +12,7 @@ from brownie.network.contract import ContractContainer from eth_typing.evm import ChecksumAddress -PROJECT_DIRECTORY = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) +PROJECT_DIRECTORY = os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")) BUILD_DIRECTORY = os.path.join(PROJECT_DIRECTORY, "build", "contracts") diff --git a/dao/test_PoolControllerEnumerateMigration.py b/dao/test_PoolControllerEnumerateMigration.py index 4a0cb1d..02b0c2e 100644 --- a/dao/test_PoolControllerEnumerateMigration.py +++ b/dao/test_PoolControllerEnumerateMigration.py @@ -25,6 +25,7 @@ class TestPoolControllerEnumerationMigration(MoonstreamDAOSingleContractTestCase fixture_terminus_facet.deploy({"from": accounts[0]}) # deploy, intialize, setup and test new diamond contract + # facet_cut fixtures onto newly created diamond diff --git a/dao/test_core.py b/dao/test_core.py index 0c95231..4059726 100644 --- a/dao/test_core.py +++ b/dao/test_core.py @@ -6,7 +6,8 @@ from .core import facet_cut, gogogo from .ERC20Facet import ERC20Facet from .ERC20Initializer import ERC20Initializer from . import TerminusFacet -from . import TerminusInitializer +from . import TerminusInitializer, PoolControllerEnumeration +from .fixtures import TerminusFacetFixture, TerminusInitializerFixture class MoonstreamDAOSingleContractTestCase(unittest.TestCase): @@ -73,6 +74,35 @@ class TerminusTestCase(MoonstreamTokenTestCase): cls.terminus_facet = terminus_facet.address +class TerminusFixtureTestCase(MoonstreamTokenTestCase): + @classmethod + def setUpClass(cls) -> None: + super().setUpClass() + + cls.terminus_fixture_contracts = gogogo(accounts[0], {"from": accounts[0]}) + + # Deploy Terminus + fixture_initializer = TerminusInitializerFixture.TerminusInitializerFixture(None) + fixture_initializer.deploy({"from": accounts[0]}) + + terminus_fixture_facet = TerminusFacetFixture.TerminusFacetFixture(None) + terminus_fixture_facet.deploy({"from": accounts[0]}) + + diamond_fixture_address = cls.terminus_fixture_contracts["Diamond"] + + facet_cut( + diamond_fixture_address, + "TerminusFacetFixture", + terminus_fixture_facet.address, + "add", + {"from": accounts[0]}, + fixture_initializer.address, + ) + + cls.terminus_fixture_initializer = fixture_initializer.address + cls.terminus_fixture_facet = terminus_fixture_facet.address + + class TestCoreDeployment(MoonstreamDAOSingleContractTestCase): def test_gogogo(self): self.assertIn("DiamondCutFacet", self.contracts) diff --git a/dao/test_terminus.py b/dao/test_terminus.py index b0e8a10..e050959 100644 --- a/dao/test_terminus.py +++ b/dao/test_terminus.py @@ -4,9 +4,11 @@ import unittest from brownie import accounts from brownie.exceptions import VirtualMachineError + from . import ERC20Facet, TerminusFacet, TerminusInitializer from .core import facet_cut -from .test_core import MoonstreamDAOSingleContractTestCase, TerminusTestCase +from .test_core import MoonstreamDAOSingleContractTestCase, TerminusTestCase, TerminusFixtureTestCase, PoolControllerEnumeration +from .fixtures import TerminusFacetFixture, TerminusInitializerFixture class TestDeployment(MoonstreamDAOSingleContractTestCase): @@ -742,6 +744,111 @@ class TestCreatePoolV1(TestPoolOperations): self.assertEqual(final_pool_supply, initial_pool_supply) self.assertEqual(final_owner_balance, initial_owner_balance) +class TestPoolControllerEnumerationMigration(TerminusFixtureTestCase): + @classmethod + def setUpClass(cls) -> None: + super().setUpClass() + moonstream_diamond_address = cls.contracts["Diamond"] + diamond_moonstream = ERC20Facet.ERC20Facet(moonstream_diamond_address) + terminus_diamond_fixture_address = cls.terminus_fixture_contracts["Diamond"] + diamond_terminus_fixture = TerminusFacetFixture.TerminusFacetFixture(terminus_diamond_fixture_address) + diamond_terminus_fixture.set_payment_token( + moonstream_diamond_address, {"from": accounts[0]} + ) + diamond_terminus_fixture.set_pool_base_price(1000, {"from": accounts[0]}) + diamond_moonstream.mint(accounts[1], 1000000, {"from": accounts[0]}) + diamond_moonstream.approve( + terminus_diamond_fixture_address, 1000000, {"from": accounts[1]} + ) + cls.diamond_terminus_fixture = diamond_terminus_fixture + cls.diamond_moonstream = diamond_moonstream + + cls.diamond_terminus_fixture.set_controller(accounts[1].address, {"from": accounts[0]}) + + cls.diamond_terminus_fixture.create_simple_pool(10, {"from": accounts[1]}) + + def test_migration_from_old_state(self): + + + #test - create test pools and check that they are correctly saved + #teardown - after test + + diamond_fixture_address = self.terminus_fixture_contracts["Diamond"] + terminus_fixture_facet = self.terminus_fixture_facet + + terminus_facet = TerminusFacet.TerminusFacet(None) + terminus_facet.deploy({"from": accounts[0]}) + + migration_initializer = PoolControllerEnumeration.PoolControllerEnumeration(None) + migration_initializer.deploy({"from": accounts[0]}) + + facet_cut( + diamond_fixture_address, + "TerminusFacetFixture", + terminus_fixture_facet, + "remove", + {"from": accounts[0]}, + ) + + facet_cut( + diamond_fixture_address, + "TerminusFacet", + terminus_facet.address, + "add", + {"from": accounts[0]}, + migration_initializer.address, + ) + + # final_total_pools = self.diamond_terminus_fixture.total_pools() + # print("final_total_pools:", final_total_pools) + # self.assertEqual(final_total_pools, initial_total_pools + 1) + + + + + + # def test_migration_from_old_state(self): + + # # old state + # fixture_initializer = TerminusInitializerFixture.TerminusInitializerFixture(None) + # fixture_initializer.deploy({"from": accounts[0]}) + + # fixture_terminus_facet = TerminusFacetFixture.TerminusFacetFixture(None) + # fixture_terminus_facet.deploy({"from": accounts[0]}) + + # # deploy, intialize, setup and test new diamond contract + + + # # facet_cut fixtures onto newly created diamond + + # # test that facets are fixtures + + # # run standard facet tests + + # # replace facet with PoolControllerEnumeration update + + # initializer = PoolControllerEnumeration.PoolControllerEnumeration(None) + # initializer.deploy({"from": accounts[0]}) + + # terminus_facet = TerminusFacet.TerminusFacet(None) + # terminus_facet.deploy({"from": accounts[0]}) + + # diamond_address = self.contracts["Diamond"] + # facet_cut( + # diamond_address, + # "TerminusFacet", + # terminus_facet.address, + # "add", + # {"from": accounts[0]}, + # initializer.address, + # ) + + # # test that pool enumeration migrated successfully + # diamond_terminus = TerminusFacet.TerminusFacet(diamond_address) + # for poolId in range(diamond_terminus.total_pools()): + # controller = diamond_terminus.terminus_pool_controller(poolId) + + if __name__ == "__main__": unittest.main()