feat(orc-483): add unit tests on DelegationModule

Author: chasingrainbows

src/web3py/extensions/delegation.py

@@ -13,21 +13,17 @@
 logger = logging.getLogger(__name__)
 
 
-class DelegationNotConfiguredError(Exception):
-    """Raised when delegation contract has no delegatee assigned"""
-    pass
-
-
-class DelegateMismatchError(Exception):
-    """Raised when delegation contract delegatee doesn't match oracle account"""
-    pass
-
-
 class DelegationModule(Module):
     w3: Web3
     delegation_contract: DelegationContract | None
     delegation_address: str | None
 
+    class NotConfiguredError(Exception):
+        """Raised when delegation contract has no delegatee assigned"""
+
+    class DelegateMismatchError(Exception):
+        """Raised when delegation contract delegatee doesn't match oracle account"""
+
     def __init__(self, w3: Web3, delegation_address: str | None = None):
         super().__init__(w3)
 
@@ -87,17 +83,21 @@ def _validate_delegation_setup(self) -> None:
         if not self.delegation_contract:
             return
 
+        if not variables.ACCOUNT:
+            logger.warning({'msg': 'Skipping delegation validation - ACCOUNT is not set'})
+            return
+
         current_delegatee = self.delegation_contract.get_delegatee()
         oracle_address = cast(ChecksumAddress, variables.ACCOUNT.address)
 
         if current_delegatee == '0x0000000000000000000000000000000000000000':
-            raise DelegationNotConfiguredError(
+            raise DelegationModule.NotConfiguredError(
                 f"Delegation contract has no delegatee assigned. "
                 f"Admin must call assignDelegate({oracle_address})"
             )
 
         if current_delegatee.lower() != oracle_address.lower():
-            raise DelegateMismatchError(
+            raise DelegationModule.DelegateMismatchError(
                 f"Delegation contract delegatee ({current_delegatee}) "
                 f"does not match oracle account ({oracle_address}). "
                 f"Admin must call assignDelegate({oracle_address})"

tests/web3py/test_delegation_module.py

@@ -1,105 +1,69 @@
+from unittest.mock import MagicMock, Mock
+
 import pytest
 
 from src import variables
+from src.web3py.extensions.delegation import DelegationModule
+
 
+DUMMY_ADDRESS = '0x' + '12' * 20
+ORACLE_ADDRESS = '0x' + 'ab' * 20
+ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
 
-@pytest.mark.testnet
-@pytest.mark.integration
+
+@pytest.mark.unit
 class TestDelegationModule:
-    def test_delegation_module_init__real_contract__validates_successfully(self, web3_integration, caplog):
-        delegation_module = web3_integration.delegation
-
-        assert delegation_module.is_enabled() is True
-        assert delegation_module.delegation_address == variables.DELEGATION_CONTRACT_ADDRESS
-        assert delegation_module.delegation_contract is not None
-        assert any('DelegationModule initialized with contract' in message for message in caplog.messages)
-
-    def test_delegation_module_init__real_contract__logs_validation_success(self, web3_integration, caplog):
-        delegation_module = web3_integration.delegation
-
-        assert delegation_module.is_enabled()
-        assert any('Delegation contract validation passed' in message for message in caplog.messages)
-
-    def test_wrap_call_for_delegation__real_contract__builds_execute_call(
-        self, web3_integration, delegation_contract, caplog
-    ):
-        delegation_module = web3_integration.delegation
-        mock_target_call = delegation_contract.functions.admin()
-
-        wrapped_call = delegation_module.wrap_call_for_delegation(mock_target_call)
-
-        assert wrapped_call.address == delegation_contract.address
-        assert wrapped_call.function_identifier == 'execute'
-        assert any('Wrapping call for delegation' in message for message in caplog.messages)
-
-    def test_is_enabled__real_contract__returns_true(self, web3_integration):
-        delegation_module = web3_integration.delegation
-
-        assert delegation_module.is_enabled() is True
-
-    def test_validation_setup__real_delegatee__has_valid_delegatee(self, web3_integration):
-        delegation_module = web3_integration.delegation
-        current_delegatee = delegation_module.delegation_contract.get_delegatee()
-
-        assert current_delegatee != '0x0000000000000000000000000000000000000000'
-        assert delegation_module.is_enabled() is True
-
-    def test_delegation_module_disabled__no_address__initialization_succeeds(self, caplog, monkeypatch):
-        from web3 import Web3
-
-        from src.web3py.contract_tweak import tweak_w3_contracts
-        from src.web3py.extensions import DelegationModule, FallbackProviderModule
-
-        monkeypatch.setattr(variables, 'DELEGATION_CONTRACT_ADDRESS', '')
-
-        w3_no_delegation = Web3(
-            FallbackProviderModule(
-                variables.EXECUTION_CLIENT_URI,
-                request_kwargs={'timeout': variables.HTTP_REQUEST_TIMEOUT_EXECUTION},
-                cache_allowed_requests=True,
-            )
-        )
-        tweak_w3_contracts(w3_no_delegation)
-        w3_no_delegation.attach_modules(
-            {
-                'delegation': lambda: DelegationModule(w3_no_delegation, variables.DELEGATION_CONTRACT_ADDRESS),
-            }
-        )
-
-        delegation_module = w3_no_delegation.delegation
-
-        assert delegation_module.is_enabled() is False
-        assert delegation_module.delegation_address == ''
-        assert delegation_module.delegation_contract is None
-        assert any(
-            'DelegationModule initialized without contract - delegation disabled' in message
-            for message in caplog.messages
-        )
-
-    def test_wrap_call_for_delegation__no_contract__raises_error(self, delegation_contract, monkeypatch):
-        from web3 import Web3
-
-        from src.web3py.contract_tweak import tweak_w3_contracts
-        from src.web3py.extensions import DelegationModule, FallbackProviderModule
-
-        monkeypatch.setattr(variables, 'DELEGATION_CONTRACT_ADDRESS', '')
-
-        w3_no_delegation = Web3(
-            FallbackProviderModule(
-                variables.EXECUTION_CLIENT_URI,
-                request_kwargs={'timeout': variables.HTTP_REQUEST_TIMEOUT_EXECUTION},
-                cache_allowed_requests=True,
-            )
-        )
-        tweak_w3_contracts(w3_no_delegation)
-        w3_no_delegation.attach_modules(
-            {
-                'delegation': lambda: DelegationModule(w3_no_delegation, variables.DELEGATION_CONTRACT_ADDRESS),
-            }
-        )
-
-        delegation_module = w3_no_delegation.delegation
-        mock_target_call = delegation_contract.functions.admin()
-
-        with pytest.raises(RuntimeError, match="Delegation is not enabled"):
-            delegation_module.wrap_call_for_delegation(mock_target_call)
+    @pytest.fixture
+    def mock_w3(self):
+        w3 = MagicMock()
+        w3.eth.contract.return_value = Mock()
+        w3.eth.contract.return_value.address = DUMMY_ADDRESS
+        return w3
+
+    @pytest.fixture
+    def mock_account(self):
+        account = Mock()
+        account.address = ORACLE_ADDRESS
+        return account
+
+    def test_init__no_delegation_address__disabled(self, mock_w3, caplog):
+        module = DelegationModule(mock_w3, delegation_address=None)
+
+        assert module.delegation_contract is None
+        assert module.delegation_address is None
+        assert module.is_enabled() is False
+        assert 'delegation disabled' in caplog.text
+
+    def test_init__valid_delegation_setup__enabled(self, mock_w3, mock_account, monkeypatch, caplog):
+        monkeypatch.setattr(variables, 'ACCOUNT', mock_account)
+        mock_w3.eth.contract.return_value.get_delegatee.return_value = ORACLE_ADDRESS
+        mock_w3.eth.contract.return_value.get_admin.return_value = DUMMY_ADDRESS
+
+        module = DelegationModule(mock_w3, delegation_address=DUMMY_ADDRESS)
+
+        assert module.delegation_contract is not None
+        assert module.is_enabled() is True
+        assert 'Delegation contract validation passed' in caplog.text
+
+    def test_init__no_account__skips_validation(self, mock_w3, monkeypatch, caplog):
+        monkeypatch.setattr(variables, 'ACCOUNT', None)
+
+        module = DelegationModule(mock_w3, delegation_address=DUMMY_ADDRESS)
+
+        assert module.delegation_contract is not None
+        assert 'Skipping delegation validation' in caplog.text
+
+    def test_init__delegatee_is_zero_address__raises_not_configured_error(self, mock_w3, mock_account, monkeypatch):
+        monkeypatch.setattr(variables, 'ACCOUNT', mock_account)
+        mock_w3.eth.contract.return_value.get_delegatee.return_value = ZERO_ADDRESS
+
+        with pytest.raises(DelegationModule.NotConfiguredError):
+            DelegationModule(mock_w3, delegation_address=DUMMY_ADDRESS)
+
+    def test_init__delegatee_mismatch__raises_mismatch_error(self, mock_w3, mock_account, monkeypatch):
+        monkeypatch.setattr(variables, 'ACCOUNT', mock_account)
+        other_address = '0x' + 'cc' * 20
+        mock_w3.eth.contract.return_value.get_delegatee.return_value = other_address
+
+        with pytest.raises(DelegationModule.DelegateMismatchError):
+            DelegationModule(mock_w3, delegation_address=DUMMY_ADDRESS)