added tests for ens to permit binary addresses

Author: voith

ens/main.py

@@ -1,5 +1,6 @@
 
 from eth_utils import (
+    is_binary_address,
     is_checksum_address,
     to_checksum_address,
 )
@@ -122,6 +123,8 @@ def setup_address(self, name, address=default, transact={}):
             address = None
         elif address is default:
             address = owner
+        elif is_binary_address(address):
+            address = to_checksum_address(address)
         elif not is_checksum_address(address):
             raise ValueError("You must supply the address in checksum format")
         if self.address(name) == address:
@@ -166,6 +169,8 @@ def setup_name(self, name, address=None, transact={}):
                 address = self.owner(name)
             if not address:
                 raise UnownedName("claim subdomain using setup_address() first")
+            if is_binary_address(address):
+                address = to_checksum_address(address)
             if not is_checksum_address(address):
                 raise ValueError("You must supply the address in checksum format")
             self._assert_control(address, name)

tests/ens/conftest.py

@@ -5,6 +5,9 @@
 from eth_tester import (
     EthereumTester,
 )
+from eth_utils import (
+    to_bytes,
+)
 
 from ens import ENS
 from ens.contract_data import (
@@ -28,6 +31,9 @@
 from web3.providers.eth_tester import (
     EthereumTesterProvider,
 )
+from web3.utils.toolz import (
+    identity,
+)
 
 
 def bytes32(val):
@@ -222,3 +228,13 @@ def ens(ens_setup, mocker):
     mocker.patch('web3.middleware.stalecheck._isfresh', return_value=True)
     ens_setup.web3.eth.defaultAccount = ens_setup.web3.eth.coinbase
     return ens_setup
+
+
+@pytest.fixture(scope="module", params=[lambda x: to_bytes(hexstr=x), identity])
+def address_conversion_func(request):
+    return request.param
+
+
+@pytest.fixture()
+def TEST_ADDRESS(address_conversion_func):
+    return address_conversion_func("0x000000000000000000000000000000000000dEaD")

tests/ens/test_get_registry.py

@@ -26,7 +26,8 @@ def test_resolver_empty(ens):
         ),
     ],
 )
-def test_reverse_domain(address, expected_reverse):
+def test_reverse_domain(address, expected_reverse, address_conversion_func):
+    address = address_conversion_func(address)
     assert ENS.reverse_domain(address) == expected_reverse
 
 

tests/ens/test_setup_address.py

@@ -4,6 +4,11 @@
     patch,
 )
 
+from eth_utils import (
+    is_same_address,
+    to_bytes,
+)
+
 from ens.constants import (
     EMPTY_ADDR_HEX,
 )
@@ -12,12 +17,11 @@
 )
 from web3 import Web3
 
+
 '''
 API at: https://github.com/carver/ens.py/issues/2
 '''
 
-TEST_ADDRESS = "0x000000000000000000000000000000000000dEaD"
-
 
 @pytest.mark.parametrize(
     'name, full_name, namehash_hex',
@@ -66,23 +70,23 @@
         ),
     ],
 )
-def test_set_address(ens, name, full_name, namehash_hex):
+def test_set_address(ens, name, full_name, namehash_hex, TEST_ADDRESS):
     assert ens.address(name) is None
     owner = ens.owner('tester')
 
     ens.setup_address(name, TEST_ADDRESS)
-    assert ens.address(name) == TEST_ADDRESS
+    assert is_same_address(ens.address(name), TEST_ADDRESS)
 
     # check that .eth is only appended if guess_tld is True
     namehash = Web3.toBytes(hexstr=namehash_hex)
     normal_name = ens.nameprep(full_name)
     if ens.nameprep(name) == normal_name:
-        assert ens.address(name, guess_tld=False) == TEST_ADDRESS
+        assert is_same_address(ens.address(name, guess_tld=False), TEST_ADDRESS)
     else:
         assert ens.address(name, guess_tld=False) is None
 
     # check that the correct namehash is set:
-    assert ens.resolver(normal_name).addr(namehash) == TEST_ADDRESS
+    assert is_same_address(ens.resolver(normal_name).addr(namehash), TEST_ADDRESS)
 
     # check that the correct owner is set:
     assert ens.owner(name) == owner
@@ -98,12 +102,12 @@ def test_set_address(ens, name, full_name, namehash_hex):
         ('unicÖde.tester.eth', 'unicöde.tester.eth'),
     ],
 )
-def test_set_address_equivalence(ens, name, equivalent):
+def test_set_address_equivalence(ens, name, equivalent, TEST_ADDRESS):
     assert ens.address(name) is None
 
     ens.setup_address(name, TEST_ADDRESS)
-    assert ens.address(name) == TEST_ADDRESS
-    assert ens.address(equivalent) == TEST_ADDRESS
+    assert is_same_address(ens.address(name), TEST_ADDRESS)
+    assert is_same_address(ens.address(equivalent), TEST_ADDRESS)
 
     ens.setup_address(name, None)
     assert ens.address(name) is None
@@ -112,7 +116,11 @@ def test_set_address_equivalence(ens, name, equivalent):
 @pytest.mark.parametrize(
     'set_address',
     [
-        TEST_ADDRESS,
+        # since the test uses getTransactionCount,
+        # using a same address converted to bytes and hex will error with same count,
+        # use two different addresses of each type (hex, bytes)
+        "0x000000000000000000000000000000000000dEaD",
+        to_bytes(hexstr="0x5B2063246F2191f18F2675ceDB8b28102e957458"),
         EMPTY_ADDR_HEX,
         None,
         '',
@@ -129,7 +137,7 @@ def test_set_address_noop(ens, set_address):
     assert eth.getTransactionCount(owner) == starting_transactions
 
 
-def test_set_address_unauthorized(ens):
+def test_set_address_unauthorized(ens, TEST_ADDRESS):
     with pytest.raises(UnauthorizedError):
         ens.setup_address('eth', TEST_ADDRESS)
 
@@ -156,7 +164,7 @@ def getowner(name):
             (addr, ['abcdefg', 'bcdefgh'], 'cdefghi.eth')
 
 
-def test_set_resolver_leave_default(ens):
+def test_set_resolver_leave_default(ens, TEST_ADDRESS):
     owner = ens.owner('tester')
     ens.setup_address('leave-default-resolver.tester.eth', TEST_ADDRESS)
     eth = ens.web3.eth

tests/ens/test_setup_name.py

@@ -8,11 +8,15 @@
 )
 from web3 import Web3
 
+
 '''
 API at: https://github.com/carver/ens.py/issues/2
 '''
 
-TEST_ADDRESS = "0x000000000000000000000000000000000000dEaD"
+
+@pytest.fixture()
+def TEST_ADDRESS(address_conversion_func):
+    return address_conversion_func("0x000000000000000000000000000000000000dEaD")
 
 
 @pytest.mark.parametrize(
@@ -86,7 +90,7 @@ def test_setup_name(ens, name, normalized_name, namehash_hex):
     assert not ens.address(name)
 
 
-def test_cannot_set_name_on_mismatch_address(ens):
+def test_cannot_set_name_on_mismatch_address(ens, TEST_ADDRESS):
     ens.setup_address('mismatch-reverse.tester.eth', TEST_ADDRESS)
     with pytest.raises(AddressMismatch):
         ens.setup_name('mismatch-reverse.tester.eth', '0xBB9bc244D798123fDe783fCc1C72d3Bb8C189413')
@@ -121,7 +125,7 @@ def test_setup_name_unowned_exception(ens):
         ens.setup_name('unowned-name.tester.eth')
 
 
-def test_setup_name_unauthorized(ens):
+def test_setup_name_unauthorized(ens, TEST_ADDRESS):
     with pytest.raises(UnauthorizedError):
         ens.setup_name('root-owned-tld', TEST_ADDRESS)