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

tests/test_rate_limiter.py

@@ -0,0 +1,199 @@
+"""Tests for RPC rate limiting."""
+
+import threading
+import time
+from unittest.mock import patch
+
+from iwa.core.chain import RPCRateLimiter, get_rate_limiter
+
+
+class TestRPCRateLimiter:
+    """Test cases for RPCRateLimiter."""
+
+    def test_init_defaults(self):
+        """Test default initialization."""
+        limiter = RPCRateLimiter()
+        assert limiter.rate == RPCRateLimiter.DEFAULT_RATE
+        assert limiter.burst == RPCRateLimiter.DEFAULT_BURST
+        assert limiter.tokens == float(limiter.burst)
+
+    def test_init_custom_values(self):
+        """Test custom initialization."""
+        limiter = RPCRateLimiter(rate=10.0, burst=20)
+        assert limiter.rate == 10.0
+        assert limiter.burst == 20
+
+    def test_acquire_success(self):
+        """Test successful token acquisition."""
+        limiter = RPCRateLimiter(rate=100.0, burst=10)
+        assert limiter.acquire(timeout=1.0) is True
+        assert limiter.tokens == 9.0
+
+    def test_acquire_multiple(self):
+        """Test acquiring multiple tokens."""
+        limiter = RPCRateLimiter(rate=100.0, burst=10)
+        for _ in range(5):
+            assert limiter.acquire(timeout=1.0) is True
+        # Allow small floating point variance due to time passage
+        assert 4.9 <= limiter.tokens <= 5.1
+
+    def test_acquire_exhausted_waits(self):
+        """Test that acquire waits when tokens exhausted."""
+        limiter = RPCRateLimiter(rate=100.0, burst=2)
+        # Exhaust tokens
+        limiter.tokens = 0.0
+        limiter.last_update = time.monotonic()
+
+        start = time.monotonic()
+        result = limiter.acquire(timeout=1.0)
+        elapsed = time.monotonic() - start
+
+        assert result is True
+        # Should have waited a bit for token refill
+        assert elapsed >= 0.005  # At least some wait
+
+    def test_acquire_timeout(self):
+        """Test that acquire times out."""
+        limiter = RPCRateLimiter(rate=0.1, burst=1)  # Very slow refill
+        limiter.tokens = 0.0
+        limiter.last_update = time.monotonic()
+
+        result = limiter.acquire(timeout=0.01)
+        assert result is False
+
+    def test_trigger_backoff(self):
+        """Test backoff triggering."""
+        limiter = RPCRateLimiter()
+        _ = limiter.tokens  # Check tokens exist
+
+        limiter.trigger_backoff(seconds=1.0)
+
+        assert limiter.tokens == 0
+        status = limiter.get_status()
+        assert status["in_backoff"] is True
+        assert status["backoff_remaining"] > 0
+
+    def test_backoff_blocks_acquire(self):
+        """Test that backoff blocks acquire."""
+        limiter = RPCRateLimiter(rate=100.0, burst=50)
+        limiter.trigger_backoff(seconds=10.0)
+
+        # Should timeout waiting for backoff
+        result = limiter.acquire(timeout=0.01)
+        assert result is False
+
+    def test_get_status(self):
+        """Test status reporting."""
+        limiter = RPCRateLimiter(rate=25.0, burst=50)
+        status = limiter.get_status()
+
+        assert "tokens" in status
+        assert "rate" in status
+        assert "burst" in status
+        assert "in_backoff" in status
+        assert status["rate"] == 25.0
+        assert status["burst"] == 50
+
+    def test_thread_safety(self):
+        """Test that rate limiter is thread-safe."""
+        limiter = RPCRateLimiter(rate=1000.0, burst=100)
+        acquired = []
+
+        def acquire_tokens():
+            for _ in range(10):
+                if limiter.acquire(timeout=1.0):
+                    acquired.append(1)
+
+        threads = [threading.Thread(target=acquire_tokens) for _ in range(5)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        # All should have acquired
+        assert len(acquired) == 50
+
+
+class TestGetRateLimiter:
+    """Test get_rate_limiter function."""
+
+    def test_creates_new_limiter(self):
+        """Test creating a new rate limiter."""
+        # Use unique chain name to avoid interference
+        limiter = get_rate_limiter("test_chain_unique_1")
+        assert isinstance(limiter, RPCRateLimiter)
+
+    def test_returns_same_limiter(self):
+        """Test that same chain returns same limiter."""
+        limiter1 = get_rate_limiter("test_chain_unique_2")
+        limiter2 = get_rate_limiter("test_chain_unique_2")
+        assert limiter1 is limiter2
+
+    def test_different_chains_different_limiters(self):
+        """Test that different chains get different limiters."""
+        limiter1 = get_rate_limiter("chain_a")
+        limiter2 = get_rate_limiter("chain_b")
+        assert limiter1 is not limiter2
+
+    def test_custom_rate(self):
+        """Test creating limiter with custom rate."""
+        limiter = get_rate_limiter("test_chain_unique_3", rate=50.0, burst=100)
+        assert limiter.rate == 50.0
+        assert limiter.burst == 100
+
+
+class TestRateLimitRotationInterplay:
+    """Test interaction between rate limiting and RPC rotation."""
+
+    def test_rate_limit_triggers_rotation_first(self):
+        """Test that rate limit error triggers RPC rotation before backoff."""
+        from unittest.mock import MagicMock, PropertyMock
+
+        from iwa.core.chain import ChainInterface, SupportedChain
+
+        # Create a mock chain with multiple RPCs
+        with patch("iwa.core.chain.interface.Web3"):
+            chain = MagicMock(spec=SupportedChain)
+            chain.name = "TestChain"
+            chain.rpcs = ["https://rpc1", "https://rpc2", "https://rpc3"]
+            type(chain).rpc = PropertyMock(return_value="https://rpc1")
+
+            ci = ChainInterface(chain)
+            original_index = ci._current_rpc_index
+
+            # Mock health check to pass
+            with patch.object(ci, "check_rpc_health", return_value=True):
+                # Simulate rate limit error
+                rate_limit_error = Exception("Error 429: Too Many Requests")
+                result = ci._handle_rpc_error(rate_limit_error)
+
+                # Should have rotated
+                assert result["rotated"] is True
+                assert result["should_retry"] is True
+                assert ci._current_rpc_index != original_index
+                # Backoff should NOT be triggered since rotation succeeded
+                assert ci._rate_limiter.get_status()["in_backoff"] is False
+
+    def test_rate_limit_triggers_backoff_when_no_rotation(self):
+        """Test that rate limit triggers backoff when no other RPCs available."""
+        from unittest.mock import MagicMock, PropertyMock
+
+        from iwa.core.chain import ChainInterface, SupportedChain
+
+        # Create a mock chain with single RPC (can't rotate)
+        with patch("iwa.core.chain.interface.Web3"):
+            chain = MagicMock(spec=SupportedChain)
+            chain.name = "TestChainSingle"
+            chain.rpcs = ["https://rpc1"]  # Only one RPC
+            type(chain).rpc = PropertyMock(return_value="https://rpc1")
+
+            ci = ChainInterface(chain)
+
+            # Simulate rate limit error
+            rate_limit_error = Exception("Error 429: Too Many Requests")
+            result = ci._handle_rpc_error(rate_limit_error)
+
+            # Should have triggered backoff since can't rotate
+            assert result["should_retry"] is True
+            assert result["rotated"] is False
+            assert ci._rate_limiter.get_status()["in_backoff"] is True

tests/test_reset_tenderly.py

@@ -0,0 +1,202 @@
+import os
+from unittest.mock import MagicMock, mock_open, patch
+
+import pytest
+
+from iwa.core.models import FundRequirements, TenderlyConfig, TokenAmount, VirtualNet
+from iwa.tools.reset_tenderly import (
+    _create_vnet,
+    _delete_vnet,
+    _fund_wallet,
+    _generate_vnet_slug,
+    main,
+    update_rpc_variables,
+)
+
+
+@pytest.fixture
+def mock_requests():
+    with patch("iwa.tools.reset_tenderly.requests") as mock:
+        import requests
+
+        mock.exceptions.JSONDecodeError = requests.exceptions.JSONDecodeError
+        yield mock
+
+
+@pytest.fixture
+def mock_tenderly_config():
+    config = MagicMock(spec=TenderlyConfig)
+    vnet = MagicMock(spec=VirtualNet)
+    vnet.vnet_id = "old_id"
+    vnet.chain_id = 1
+    vnet.public_rpc = "https://rpc.com"
+    vnet.admin_rpc = "https://admin.rpc.com"
+    vnet.funds_requirements = {
+        "tag1": FundRequirements(
+            native_eth=1.0,
+            tokens=[
+                TokenAmount(
+                    address="0x1234567890123456789012345678901234567890",
+                    amount_eth=10.0,
+                    symbol="TKN",
+                )
+            ],
+        )
+    }
+    config.vnets = {"Gnosis": vnet}
+    return config
+
+
+def test_delete_vnet(mock_requests):
+    _delete_vnet("key", "account", "project", "vnet_id")
+    mock_requests.delete.assert_called_once()
+    args, kwargs = mock_requests.delete.call_args
+    assert "vnet_id" in kwargs["url"]
+    assert kwargs["headers"]["X-Access-Key"] == "key"
+
+
+def test_create_vnet(mock_requests):
+    mock_response = MagicMock()
+    mock_response.json.return_value = {
+        "id": "new_id",
+        "rpcs": [
+            {"name": "Admin RPC", "url": "admin_url"},
+            {"name": "Public RPC", "url": "public_url"},
+        ],
+    }
+    mock_requests.post.return_value = mock_response
+
+    vnet_id, admin_rpc, public_rpc = _create_vnet("key", "account", "project", 1, 1, "slug", "name")
+
+    assert vnet_id == "new_id"
+    assert admin_rpc == "admin_url"
+    assert public_rpc == "public_url"
+
+
+def test_generate_vnet_slug():
+    slug = _generate_vnet_slug("prefix", 5)
+    assert slug.startswith("prefix-")
+    assert len(slug) == len("prefix-") + 5
+
+
+def test_update_rpc_variables(mock_tenderly_config):
+    mock_file_content = "gnosis_test_rpc=old_url\nother_var=1"
+    with patch("builtins.open", mock_open(read_data=mock_file_content)) as mock_file:
+        update_rpc_variables(mock_tenderly_config)
+
+        mock_file().write.assert_called_once()
+        written_content = mock_file().write.call_args[0][0]
+        assert "gnosis_test_rpc=https://rpc.com" in written_content
+
+
+def test_update_rpc_variables_new(mock_tenderly_config):
+    mock_file_content = "other_var=1"
+    with patch("builtins.open", mock_open(read_data=mock_file_content)) as mock_file:
+        update_rpc_variables(mock_tenderly_config)
+
+        mock_file().write.assert_called_once()
+        written_content = mock_file().write.call_args[0][0]
+        assert "gnosis_test_rpc=https://rpc.com" in written_content
+
+
+def test_fund_wallet_native(mock_requests):
+    mock_requests.post.return_value.status_code = 200
+    _fund_wallet("admin_url", ["0x1"], 1.0, "native")
+
+    mock_requests.post.assert_called_once()
+    kwargs = mock_requests.post.call_args[1]
+    assert kwargs["json"]["method"] == "tenderly_setBalance"
+    assert kwargs["json"]["params"][1] == hex(int(1e18))
+
+
+def test_fund_wallet_token(mock_requests):
+    mock_requests.post.return_value.status_code = 200
+    _fund_wallet("admin_url", ["0x1"], 1.0, "0xToken")
+
+    mock_requests.post.assert_called_once()
+    kwargs = mock_requests.post.call_args[1]
+    assert kwargs["json"]["method"] == "tenderly_setErc20Balance"
+    assert kwargs["json"]["params"][0] == "0xToken"
+
+
+def test_fund_wallet_error(mock_requests, capsys):
+    mock_requests.post.return_value.status_code = 500
+    mock_requests.post.return_value.json.return_value = {"error": "fail"}
+
+    _fund_wallet("admin_url", ["0x1"], 1.0)
+
+    captured = capsys.readouterr()
+    assert "500" in captured.out
+    assert "{'error': 'fail'}" in captured.out
+
+
+def test_fund_wallet_json_error(mock_requests, capsys):
+    import requests
+
+    mock_requests.post.return_value.status_code = 500
+    mock_requests.post.return_value.json.side_effect = requests.exceptions.JSONDecodeError(
+        "msg", "doc", 0
+    )
+
+    _fund_wallet("admin_url", ["0x1"], 1.0)
+
+    captured = capsys.readouterr()
+    assert "500" in captured.out
+    # Should not print json error
+    assert "msg" not in captured.out
+
+
+def test_main(mock_requests, mock_tenderly_config):
+    # Mock env vars
+    with patch.dict(
+        os.environ,
+        {
+            "tenderly_account_slug": "acc",
+            "tenderly_project_slug": "proj",
+            "tenderly_access_key": "key",
+        },
+    ):
+        # Mock TenderlyConfig.load
+        with patch("iwa.core.models.TenderlyConfig.load", return_value=mock_tenderly_config):
+            with patch(
+                "iwa.tools.reset_tenderly.get_tenderly_credentials",
+                return_value=("acc", "proj", "key"),
+            ):
+                # Mock KeyStorage
+                with patch("iwa.tools.reset_tenderly.KeyStorage") as mock_key_storage:
+                    mock_keys = mock_key_storage.return_value
+                    mock_keys.get_account.return_value.address = "0xAddress"
+                    mock_keys.accounts.keys.return_value = ["tag1"]
+
+                    # Mock _create_vnet return values (since we mock requests, _create_vnet logic runs, but we can also mock _create_vnet directly)
+                    # But let's let it run with mocked requests
+                    mock_response_create = MagicMock()
+                    mock_response_create.json.return_value = {
+                        "id": "new_id",
+                        "rpcs": [
+                            {"name": "Admin RPC", "url": "admin"},
+                            {"name": "Public RPC", "url": "public"},
+                        ],
+                    }
+
+                    # Mock requests.post for create and fund
+                    # We need side_effect to handle different calls
+                    def post_side_effect(*args, **kwargs):
+                        if "vnets" in kwargs.get("url", ""):
+                            return mock_response_create
+                        return MagicMock(status_code=200)
+
+                    mock_requests.post.side_effect = post_side_effect
+
+                    # Mock update_rpc_variables to avoid file I/O
+                    with patch("iwa.tools.reset_tenderly.update_rpc_variables") as mock_update:
+                        # Mock SafeService
+                        with patch("iwa.core.services.SafeService") as mock_safe_service_cls:
+                            main()
+
+                            # Verify interactions
+                            mock_requests.delete.assert_called()  # _delete_vnet
+                            mock_tenderly_config.save.assert_called()
+                            mock_update.assert_called()
+                            # mock_keys.redeploy_safes.assert_called() # Removed
+                            mock_safe_service_cls.return_value.redeploy_safes.assert_called()

tests/test_rpc_view.py

@@ -0,0 +1,73 @@
+"""Tests for TUI RPC View."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from iwa.tui.rpc import RPCView
+
+
+@pytest.fixture
+def mock_chain_interfaces():
+    with patch("iwa.tui.rpc.ChainInterfaces") as mock:
+        yield mock
+
+
+def test_rpc_view_compose():
+    """Test RPCView compose method returns expected widgets."""
+    view = RPCView()
+    result = list(view.compose())
+
+    assert len(result) == 2  # Label and DataTable
+
+
+def test_check_rpcs_interface_not_found(mock_chain_interfaces):
+    """Test check_rpcs handles missing interface."""
+    mock_chain_interfaces.return_value.get.return_value = None
+
+    view = RPCView()
+
+    # Verify the method exists and is callable
+    assert hasattr(view, "check_rpcs")
+    assert callable(view.check_rpcs)
+
+
+def test_check_rpcs_no_rpc_url(mock_chain_interfaces):
+    """Test check_rpcs handles missing RPC URL."""
+    mock_interface = MagicMock()
+    mock_interface.chain.rpc = ""
+    mock_chain_interfaces.return_value.get.return_value = mock_interface
+
+    view = RPCView()
+
+    # Verify method exists and has correct signature
+    assert callable(view.check_rpcs)
+
+
+def test_check_rpcs_connection_error(mock_chain_interfaces):
+    """Test check_rpcs handles connection errors."""
+    mock_interface = MagicMock()
+    mock_interface.chain.rpc = "http://localhost:8545"
+    mock_interface.web3.is_connected.side_effect = Exception("Connection refused")
+    mock_chain_interfaces.return_value.get.return_value = mock_interface
+
+    view = RPCView()
+
+    assert callable(view.check_rpcs)
+
+
+def test_update_table():
+    """Test update_table method updates DataTable."""
+    view = RPCView()
+
+    mock_table = MagicMock()
+    with patch.object(view, "query_one", return_value=mock_table):
+        results = [
+            ("gnosis", "http://rpc1", "Online", "50.00"),
+            ("ethereum", "http://rpc2", "Offline", "-"),
+        ]
+
+        view.update_table(results)
+
+        mock_table.clear.assert_called_once()
+        assert mock_table.add_row.call_count == 2

tests/test_safe_coverage.py

@@ -0,0 +1,139 @@
+"""Tests for SafeService coverage."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from iwa.core.models import StoredSafeAccount
+from iwa.core.services.safe import SafeService
+
+
+@pytest.fixture
+def mock_deps():
+    """Mock dependencies for SafeService."""
+    mock_key_storage = MagicMock()
+    mock_account_service = MagicMock()
+
+    return {
+        "key_storage": mock_key_storage,
+        "account_service": mock_account_service,
+    }
+
+
+@pytest.fixture
+def safe_service(mock_deps):
+    """SafeService instance."""
+    return SafeService(mock_deps["key_storage"], mock_deps["account_service"])
+
+
+def test_execute_safe_transaction_success(safe_service, mock_deps):
+    """Test execute_safe_transaction success."""
+    # Mock inputs
+    safe_address = "0xSafe"
+    to_address = "0xTo"
+    value = 1000
+    chain_name = "gnosis"
+
+    # Mock Safe Account
+    mock_account = MagicMock(spec=StoredSafeAccount)
+    mock_account.address = safe_address
+    mock_account.signers = ["0xSigner1", "0xSigner2"]
+    mock_account.threshold = 1
+    mock_deps["key_storage"].find_stored_account.return_value = mock_account
+
+    # Mock Private Keys
+    mock_deps["key_storage"]._get_private_key.return_value = "0xPrivKey"
+
+    # Mock SafeMultisig via patch
+    # The import is inside the method: from iwa.plugins.gnosis.safe import SafeMultisig
+    # We need to patch where it is IMPORTED from
+    with patch("iwa.plugins.gnosis.safe.SafeMultisig") as mock_safe_multisig_cls:
+        # But wait, execute_safe_transaction does local import.
+        # patch('iwa.core.services.safe.SafeMultisig') won't work if it's not global.
+        # We must patch 'iwa.plugins.gnosis.safe.SafeMultisig'.
+        # And since it's imported INSIDE the function, patching the source module works.
+
+        mock_safe_instance = mock_safe_multisig_cls.return_value
+        mock_safe_tx = MagicMock()
+        mock_safe_instance.build_tx.return_value = mock_safe_tx
+        mock_safe_tx.tx_hash.hex.return_value = "0xTxHash"
+
+        # Execute
+        tx_hash = safe_service.execute_safe_transaction(safe_address, to_address, value, chain_name)
+
+        # Verify
+        assert tx_hash == "0xTxHash"
+        mock_safe_tx.sign.assert_called()
+        mock_safe_tx.execute.assert_called()
+
+
+def test_execute_safe_transaction_account_not_found(safe_service, mock_deps):
+    """Test execute_safe_transaction fails if account not found."""
+    mock_deps["key_storage"].find_stored_account.return_value = None
+
+    with pytest.raises(ValueError, match="Safe account '0xSafe' not found"):
+        safe_service.execute_safe_transaction("0xSafe", "0xTo", 0, "gnosis")
+
+
+def test_get_sign_and_execute_callback(safe_service, mock_deps):
+    """Test get_sign_and_execute_callback returns working callback."""
+    safe_address = "0xSafe"
+    mock_account = MagicMock(spec=StoredSafeAccount)
+    mock_account.address = safe_address
+    mock_account.signers = ["0xSigner1"]
+    mock_account.threshold = 1
+    mock_deps["key_storage"].find_stored_account.return_value = mock_account
+    mock_deps["key_storage"]._get_private_key.return_value = "0xPrivKey"
+
+    callback = safe_service.get_sign_and_execute_callback(safe_address)
+    assert callable(callback)
+
+    # Test executing callback
+    mock_safe_tx = MagicMock()
+    mock_safe_tx.tx_hash.hex.return_value = "0xTxHash"
+
+    result = callback(mock_safe_tx)
+
+    assert result == "0xTxHash"
+    mock_safe_tx.sign.assert_called()
+    mock_safe_tx.execute.assert_called()
+
+
+def test_get_sign_and_execute_callback_fail(safe_service, mock_deps):
+    """Test callback generation fails if account missing."""
+    mock_deps["key_storage"].find_stored_account.return_value = None
+    with pytest.raises(ValueError):
+        safe_service.get_sign_and_execute_callback("0xSafe")
+
+
+def test_redeploy_safes(safe_service, mock_deps):
+    """Test redeploy_safes logic."""
+    # Mock accounts
+    account1 = MagicMock(spec=StoredSafeAccount)
+    account1.address = "0xSafe1"
+    account1.chains = ["gnosis"]
+    account1.signers = ["0xSigner"]
+    account1.threshold = 1
+    # account1.tag needs to be accessible
+    account1.tag = " Safe1"
+
+    mock_deps["key_storage"].accounts = {"0xSafe1": account1}
+
+    with patch("iwa.core.services.safe.settings") as mock_settings:
+        mock_settings.gnosis_rpc.get_secret_value.return_value = "http://rpc"
+
+        with patch("iwa.core.services.safe.EthereumClient") as mock_eth_client:
+            with patch.object(safe_service, "create_safe") as mock_create:
+                mock_w3 = mock_eth_client.return_value.w3
+
+                # Case 1: Code exists (no redeploy)
+                mock_w3.eth.get_code.return_value = b"code"
+                safe_service.redeploy_safes()
+                mock_create.assert_not_called()
+
+                # Case 2: No code (redeploy)
+                mock_w3.eth.get_code.return_value = b""
+                # Need to mock remove_account
+                safe_service.redeploy_safes()
+                mock_deps["key_storage"].remove_account.assert_called_with("0xSafe1")
+                mock_create.assert_called()