iwa 0.0.0__py3-none-any.whl → 0.0.1a2__py3-none-any.whl

tests/test_monitor.py

@@ -0,0 +1,202 @@
+from unittest.mock import MagicMock, PropertyMock, patch
+
+import pytest
+from web3 import Web3
+
+from iwa.core.monitor import EventMonitor
+
+
+@pytest.fixture
+def mock_chain_interfaces():
+    with patch("iwa.core.monitor.ChainInterfaces") as mock:
+        instance = mock.return_value
+        gnosis_interface = MagicMock()
+        gnosis_interface.chain.name = "Gnosis"
+        gnosis_interface.chain.rpc = "https://rpc"
+        gnosis_interface.web3 = MagicMock()
+        instance.get.return_value = gnosis_interface
+        yield instance
+
+
+@pytest.fixture
+def mock_callback():
+    return MagicMock()
+
+
+def test_monitor_init_success(mock_chain_interfaces, mock_callback):
+    chain_interface = mock_chain_interfaces.get.return_value
+    chain_interface.web3.eth.block_number = 100
+
+    monitor = EventMonitor(["0x1234567890123456789012345678901234567890"], mock_callback)
+
+    assert monitor.last_checked_block == 100
+    assert monitor.callback == mock_callback
+    assert len(monitor.addresses) == 1
+
+
+def test_monitor_init_rpc_fail(mock_chain_interfaces, mock_callback):
+    chain_interface = mock_chain_interfaces.get.return_value
+    # Use PropertyMock to raise exception on attribute access
+    type(chain_interface.web3.eth).block_number = PropertyMock(side_effect=Exception("RPC Error"))
+
+    monitor = EventMonitor(["0x1234567890123456789012345678901234567890"], mock_callback)
+    # Should catch exception and set to 0
+    assert monitor.last_checked_block == 0
+
+
+def test_monitor_init_no_rpc(mock_chain_interfaces, mock_callback):
+    chain_interface = mock_chain_interfaces.get.return_value
+    chain_interface.chain.rpc = ""
+
+    monitor = EventMonitor(["0x1234567890123456789012345678901234567890"], mock_callback)
+    assert monitor.last_checked_block == 0
+
+
+def test_start_no_rpc(mock_chain_interfaces, mock_callback):
+    chain_interface = mock_chain_interfaces.get.return_value
+    chain_interface.chain.rpc = ""
+
+    monitor = EventMonitor(["0x1234567890123456789012345678901234567890"], mock_callback)
+
+    # Patch time.sleep to raise SystemExit if called (invoking cleanup/failure), preventing infinite loop
+    # SystemExit is not caught by 'except Exception'
+    with patch("time.sleep", side_effect=SystemExit):
+        monitor.start()
+
+    assert monitor.running is False
+
+
+def test_check_activity_no_new_block(mock_chain_interfaces, mock_callback):
+    chain_interface = mock_chain_interfaces.get.return_value
+    chain_interface.web3.eth.block_number = 100
+
+    monitor = EventMonitor(["0x1234567890123456789012345678901234567890"], mock_callback)
+    monitor.last_checked_block = 100
+
+    monitor.check_activity()
+
+    mock_callback.assert_not_called()
+    assert monitor.last_checked_block == 100
+
+
+def test_check_activity_block_fetch_failed(mock_chain_interfaces, mock_callback, caplog):
+    chain_interface = mock_chain_interfaces.get.return_value
+    # Reset property mock if needed or just use consistent mock
+
+    monitor = EventMonitor(["0x1234567890123456789012345678901234567890"], mock_callback)
+
+    # We need to mock block_number raising specifically during check_activity
+    # Since we can't easily switch PropertyMock on an instance dynamically without patching the class or instance dict
+    # Let's just create a monitor where web3.eth is a specific mock
+
+    # Actually, patch.object on the INSTANCE attribute works for properties if they are data descriptors or if we patch the class.
+    # Easier: Just set the side_effect on the PropertyMock if we used one, or re-assign.
+    type(chain_interface.web3.eth).block_number = PropertyMock(side_effect=Exception("RPC Fail"))
+
+    monitor.check_activity()
+
+    assert "Failed to get block number" in caplog.text
+
+
+def test_check_activity_new_native_tx(mock_chain_interfaces, mock_callback):
+    chain_interface = mock_chain_interfaces.get.return_value
+    chain_interface.web3.eth.block_number = 101
+
+    # Mock Block
+    block = MagicMock()
+    block.timestamp = 12345
+    # Transaction matching address
+    tx = {
+        "hash": b"hash",
+        "from": "0x1234567890123456789012345678901234567890",
+        "to": "0x0000000000000000000000000000000000000000",
+        "value": 100,
+    }
+    block.transactions = [tx]
+
+    chain_interface.web3.eth.get_block.return_value = block
+    chain_interface.web3.eth.get_logs.return_value = []  # No logs
+
+    monitor = EventMonitor(["0x1234567890123456789012345678901234567890"], mock_callback)
+    monitor.last_checked_block = 100
+
+    monitor.check_activity()
+
+    assert monitor.last_checked_block == 101
+    mock_callback.assert_called_once()
+    args, _ = mock_callback.call_args
+    found_txs = args[0]
+    assert len(found_txs) == 1
+    assert found_txs[0]["token"] == "NATIVE"
+    assert found_txs[0]["from"] == "0x1234567890123456789012345678901234567890"  # Checksummed
+
+
+def test_check_activity_hash_in_block(mock_chain_interfaces, mock_callback):
+    # Case where get_block returns tx hash strings instead of objects
+    chain_interface = mock_chain_interfaces.get.return_value
+    chain_interface.web3.eth.block_number = 101
+
+    monitor = EventMonitor(["0x1234567890123456789012345678901234567890"], mock_callback)
+    monitor.last_checked_block = 100
+
+    block = MagicMock()
+    block.timestamp = 12345
+    block.transactions = [b"hash_bytes"]
+    chain_interface.web3.eth.get_block.return_value = block
+
+    tx_obj = {
+        "hash": b"hash_bytes",
+        "from": "0x1234567890123456789012345678901234567890",
+        "to": "0x0000000000000000000000000000000000000000",
+        "value": 100,
+    }
+    chain_interface.web3.eth.get_transaction.return_value = tx_obj
+    chain_interface.web3.eth.get_logs.return_value = []
+
+    monitor.check_activity()
+
+    chain_interface.web3.eth.get_transaction.assert_called_with(b"hash_bytes")
+    mock_callback.assert_called()
+
+
+def test_check_activity_logs(mock_chain_interfaces, mock_callback):
+    chain_interface = mock_chain_interfaces.get.return_value
+    chain_interface.web3.eth.block_number = 101
+    chain_interface.web3.eth.get_block.return_value = MagicMock(transactions=[])
+
+    # Mock Log matching address
+
+    my_addr = "0x1234567890123456789012345678901234567890".lower()
+    monitor = EventMonitor([my_addr], mock_callback)
+    monitor.last_checked_block = 100
+
+    # 20 bytes address
+    addr_bytes = Web3.to_bytes(hexstr=my_addr)  # 20 bytes
+    padded_addr_bytes = b"\x00" * 12 + addr_bytes  # 32 bytes
+
+    log = {
+        "topics": [
+            b"sig",
+            b"\x00" * 32,  # from (don't care)
+            padded_addr_bytes,  # to (me) -- This MUST match the padded address logic in monitor.py
+        ],
+        "transactionHash": MagicMock(hex=lambda: "0xloghash"),
+        "address": "0xContractAddr",
+    }
+
+    chain_interface.web3.eth.get_logs.side_effect = [[], [log]]  # sent, received
+
+    monitor.check_activity()
+
+    mock_callback.assert_called()
+    found = mock_callback.call_args[0][0]
+    assert len(found) == 1
+    assert found[0]["token"] == "TOKEN"
+    assert found[0]["to"] == my_addr
+
+
+def test_stop(mock_chain_interfaces, mock_callback):
+    monitor = EventMonitor(["0x1234567890123456789012345678901234567890"], mock_callback)
+    monitor.running = True
+    monitor.stop()
+    assert monitor.running is False

tests/test_multisend.py

@@ -0,0 +1,84 @@
+from unittest.mock import patch
+
+import pytest
+from safe_eth.safe import SafeOperationEnum
+
+from iwa.core.contracts.multisend import MultiSendCallOnlyContract, MultiSendContract
+
+
+@pytest.fixture
+def mock_contract_instance():
+    with (
+        patch("iwa.core.contracts.contract.ContractInstance.__init__", return_value=None),
+        patch("iwa.core.contracts.contract.ContractInstance.call") as mock_call,
+        patch("iwa.core.contracts.contract.ContractInstance.prepare_transaction") as mock_prep,
+    ):
+        yield mock_call, mock_prep
+
+
+def test_encode_data():
+    tx = {
+        "operation": SafeOperationEnum.CALL,
+        "to": "0x1111111111111111111111111111111111111111",
+        "value": 100,
+        "data": b"\x01\x02",
+    }
+    encoded = MultiSendCallOnlyContract.encode_data(tx)
+    # Operation (1 byte) + To (20 bytes) + Value (32 bytes) + Data Length (32 bytes) + Data (2 bytes)
+    # But wait, implementation uses HexBytes formatting which might produce different output if not careful.
+    # Let's check length.
+    # 1 + 20 + 32 + 32 + 2 = 87 bytes.
+    assert len(encoded) == 87
+    assert encoded[0] == 0  # CALL is 0
+
+
+def test_to_bytes():
+    tx1 = {
+        "operation": SafeOperationEnum.CALL,
+        "to": "0x1111111111111111111111111111111111111111",
+        "value": 100,
+        "data": b"\x01",
+    }
+    tx2 = {
+        "operation": SafeOperationEnum.DELEGATE_CALL,
+        "to": "0x2222222222222222222222222222222222222222",
+        "value": 0,
+        "data": b"",
+    }
+    encoded = MultiSendCallOnlyContract.to_bytes([tx1, tx2])
+    # tx1: 1+20+32+32+1 = 86
+    # tx2: 1+20+32+32+0 = 85
+    # Total: 171
+    assert len(encoded) == 171
+
+
+def test_prepare_tx(mock_contract_instance):
+    mock_call, mock_prep = mock_contract_instance
+    mock_prep.return_value = {"data": "0x"}
+
+    multisend = MultiSendCallOnlyContract("0xMulti", "gnosis")
+
+    transactions = [
+        {
+            "operation": SafeOperationEnum.CALL,
+            "to": "0x1111111111111111111111111111111111111111",
+            "value": 100,
+            "data": b"",
+        }
+    ]
+
+    tx = multisend.prepare_tx("0xFrom", transactions)
+    assert tx == {"data": "0x"}
+
+    mock_prep.assert_called_once()
+    call_args = mock_prep.call_args[1]
+    assert call_args["method_name"] == "multiSend"
+    assert "encoded_multisend_data" in call_args["method_kwargs"]
+    assert call_args["tx_params"]["from"] == "0xFrom"
+    assert call_args["tx_params"]["value"] == 100
+
+
+def test_multisend_contract_init(mock_contract_instance):
+    # Just verify it can be instantiated and has correct name
+    ms = MultiSendContract("0xMulti", "gnosis")
+    assert ms.name == "multisend"

tests/test_plugin_service.py

@@ -0,0 +1,119 @@
+"""Tests for PluginService."""
+
+from unittest.mock import MagicMock, patch
+
+from iwa.core.plugins import Plugin
+from iwa.core.services.plugin import PluginService
+
+
+class MockPlugin(Plugin):
+    """Mock plugin for testing."""
+
+    @property
+    def name(self):
+        return "mock_plugin"
+
+    def get_cli_commands(self):
+        return {"mock": lambda: None}
+
+
+def test_plugin_service_init():
+    """Test PluginService initialization loads plugins."""
+    with patch.object(PluginService, "_load_plugins"):
+        service = PluginService()
+        assert service.plugins_package == "iwa.plugins"
+
+
+def test_discover_plugins_import_error():
+    """Test _discover_plugins handles ImportError."""
+    with patch.object(PluginService, "_load_plugins"):
+        service = PluginService()
+
+    with patch(
+        "iwa.core.services.plugin.importlib.import_module",
+        side_effect=ImportError("Module not found"),
+    ):
+        plugins = service._discover_plugins()
+        assert plugins == []
+
+
+def test_discover_plugins_no_path():
+    """Test _discover_plugins handles package without __path__."""
+    with patch.object(PluginService, "_load_plugins"):
+        service = PluginService()
+
+    with patch("iwa.core.services.plugin.importlib.import_module") as mock_import:
+        mock_package = MagicMock(spec=[])  # No __path__
+        del mock_package.__path__  # Ensure hasattr returns False
+        mock_import.return_value = mock_package
+
+        plugins = service._discover_plugins()
+        assert plugins == []
+
+
+def test_load_plugins_module_error():
+    """Test _load_plugins handles module import errors."""
+    with (
+        patch.object(PluginService, "_discover_plugins", return_value=["bad_module"]),
+        patch(
+            "iwa.core.services.plugin.importlib.import_module",
+            side_effect=ImportError("Bad module"),
+        ),
+    ):
+        # Should not raise, just log error
+        service = PluginService()
+
+        assert "bad_module" not in service.loaded_plugins
+
+
+def test_get_plugin():
+    """Test get_plugin returns correct plugin."""
+    with patch.object(PluginService, "_load_plugins"):
+        service = PluginService()
+        mock_plugin = MockPlugin()
+        service.loaded_plugins["mock_plugin"] = mock_plugin
+
+        result = service.get_plugin("mock_plugin")
+
+        assert result == mock_plugin
+
+
+def test_get_plugin_not_found():
+    """Test get_plugin returns None for unknown plugin."""
+    with patch.object(PluginService, "_load_plugins"):
+        service = PluginService()
+
+        result = service.get_plugin("nonexistent")
+
+        assert result is None
+
+
+def test_get_all_plugins():
+    """Test get_all_plugins returns copy of plugins."""
+    with patch.object(PluginService, "_load_plugins"):
+        service = PluginService()
+        mock_plugin = MockPlugin()
+        service.loaded_plugins["mock_plugin"] = mock_plugin
+
+        result = service.get_all_plugins()
+
+        assert "mock_plugin" in result
+        # Verify it's a copy
+        result["new_plugin"] = None
+        assert "new_plugin" not in service.loaded_plugins
+
+
+def test_skip_already_loaded():
+    """Test _load_plugins skips already loaded plugins."""
+    with patch.object(PluginService, "_discover_plugins", return_value=["mock"]):
+        with patch.object(PluginService, "_load_plugins"):
+            service = PluginService()
+
+        # Pre-populate loaded plugins with key matching discovered name
+        mock_plugin = MockPlugin()
+        service.loaded_plugins["mock"] = mock_plugin
+
+        # Now load - should skip "mock" since it's in loaded_plugins
+        with patch("iwa.core.services.plugin.importlib.import_module") as mock_import:
+            service._load_plugins()
+            mock_import.assert_not_called()

tests/test_pricing.py

@@ -0,0 +1,143 @@
+from datetime import timedelta
+from unittest.mock import patch
+
+import pytest
+
+from iwa.core.pricing import PriceService
+
+
+@pytest.fixture
+def mock_secrets():
+    with patch("iwa.core.pricing.settings") as mock:
+        mock.coingecko_api_key.get_secret_value.return_value = "test_api_key"
+        yield mock
+
+
+@pytest.fixture
+def price_service(mock_secrets):
+    return PriceService()
+
+
+def test_get_token_price_success(price_service):
+    with patch("iwa.core.pricing.requests.get") as mock_get:
+        mock_get.return_value.status_code = 200
+        mock_get.return_value.json.return_value = {"ethereum": {"eur": 2000.50}}
+
+        price = price_service.get_token_price("ethereum", "eur")
+
+        assert price == 2000.50
+        mock_get.assert_called_once()
+        # Verify API key in headers
+        args, kwargs = mock_get.call_args
+        assert kwargs["headers"]["x-cg-demo-api-key"] == "test_api_key"
+
+
+def test_get_token_price_cached(price_service):
+    # Pre-populate cache
+    from datetime import datetime
+
+    price_service.cache["ethereum_eur"] = {"price": 100.0, "timestamp": datetime.now()}
+
+    with patch("iwa.core.pricing.requests.get") as mock_get:
+        price = price_service.get_token_price("ethereum", "eur")
+        assert price == 100.0
+        mock_get.assert_not_called()
+
+
+def test_get_token_price_cache_expired(price_service):
+    # Pre-populate expired cache
+    from datetime import datetime
+
+    price_service.cache["ethereum_eur"] = {
+        "price": 100.0,
+        "timestamp": datetime.now() - timedelta(minutes=10),
+    }
+
+    with patch("iwa.core.pricing.requests.get") as mock_get:
+        mock_get.return_value.status_code = 200
+        mock_get.return_value.json.return_value = {"ethereum": {"eur": 200.0}}
+
+        price = price_service.get_token_price("ethereum", "eur")
+        assert price == 200.0
+        mock_get.assert_called_once()
+
+
+def test_get_token_price_api_error(price_service):
+    with patch("iwa.core.pricing.requests.get") as mock_get:
+        mock_get.side_effect = Exception("API Error")
+
+        price = price_service.get_token_price("ethereum", "eur")
+        assert price is None
+
+
+def test_get_token_price_key_not_found(price_service):
+    with patch("iwa.core.pricing.requests.get") as mock_get:
+        mock_get.return_value.status_code = 200
+        mock_get.return_value.json.return_value = {}  # Empty response
+
+        price = price_service.get_token_price("ethereum", "eur")
+        assert price is None
+
+
+def test_get_token_price_rate_limit():
+    """Test rate limit (429) handling with retries."""
+    with patch("iwa.core.pricing.settings") as mock_settings:
+        mock_settings.coingecko_api_key = None
+
+        service = PriceService()
+
+        with patch("iwa.core.pricing.requests.get") as mock_get, patch("time.sleep"):
+            # Return 429 for all attempts
+            mock_response = type("Response", (), {"status_code": 429})()
+            mock_get.return_value = mock_response
+
+            price = service.get_token_price("ethereum", "eur")
+
+            assert price is None
+            # Should have tried max_retries + 1 times
+            assert mock_get.call_count == 3
+
+
+def test_get_token_price_rate_limit_then_success():
+    """Test rate limit recovery on retry."""
+    from unittest.mock import MagicMock
+
+    with patch("iwa.core.pricing.settings") as mock_settings:
+        mock_settings.coingecko_api_key = None
+
+        service = PriceService()
+
+        with patch("iwa.core.pricing.requests.get") as mock_get, patch("time.sleep"):
+            # First call returns 429, second succeeds
+            mock_429 = MagicMock()
+            mock_429.status_code = 429
+
+            mock_ok = MagicMock()
+            mock_ok.status_code = 200
+            mock_ok.json.return_value = {"ethereum": {"eur": 1500.0}}
+
+            mock_get.side_effect = [mock_429, mock_ok]
+
+            price = service.get_token_price("ethereum", "eur")
+
+            assert price == 1500.0
+            assert mock_get.call_count == 2
+
+
+def test_get_token_price_no_api_key():
+    """Test getting price without API key."""
+    with patch("iwa.core.pricing.settings") as mock_settings:
+        mock_settings.coingecko_api_key = None
+
+        service = PriceService()
+
+        with patch("iwa.core.pricing.requests.get") as mock_get:
+            mock_get.return_value.status_code = 200
+            mock_get.return_value.json.return_value = {"gnosis": {"eur": 100.0}}
+
+            price = service.get_token_price("gnosis", "eur")
+
+            assert price == 100.0
+            # Verify no API key header
+            args, kwargs = mock_get.call_args
+            assert "x-cg-demo-api-key" not in kwargs.get("headers", {})