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

tests/legacy_web.py

@@ -0,0 +1,243 @@
+"""Tests for the Web Server module."""
+
+import pytest
+
+
+class TestObscureUrl:
+    """Tests for URL obscuring utility."""
+
+    def test_obscure_url_hides_path(self):
+        """Test that _obscure_url hides the path and query."""
+        from iwa.web.server import _obscure_url
+
+        result = _obscure_url("https://rpc.example.com/v1/api-key-12345")
+        assert result == "https://rpc.example.com/..."
+        assert "api-key" not in result
+
+    def test_obscure_url_handles_empty(self):
+        """Test that _obscure_url handles empty URLs."""
+        from iwa.web.server import _obscure_url
+
+        result = _obscure_url("")
+        # Empty URL gives minimal output
+        assert "..." in result
+
+    def test_obscure_url_preserves_scheme_and_host(self):
+        """Test that scheme and host are preserved."""
+        from iwa.web.server import _obscure_url
+
+        result = _obscure_url("wss://ws.alchemy.com/v2/secret")
+        assert result == "wss://ws.alchemy.com/..."
+
+    def test_obscure_url_handles_no_path(self):
+        """Test URL with no path."""
+        from iwa.web.server import _obscure_url
+
+        result = _obscure_url("https://example.com")
+        assert result == "https://example.com/..."
+
+
+class TestInputValidation:
+    """Tests for Pydantic input validation models."""
+
+    def test_transaction_request_valid(self):
+        """Test valid transaction request passes validation."""
+        from iwa.web.server import TransactionRequest
+
+        req = TransactionRequest(
+            from_address="0x1234567890abcdef1234567890abcdef12345678",
+            to_address="0xabcdef1234567890abcdef1234567890abcdef12",
+            amount_eth=1.0,
+            token="native",
+            chain="gnosis",
+        )
+        assert req.from_address == "0x1234567890abcdef1234567890abcdef12345678"
+        assert req.amount_eth == 1.0
+
+    def test_transaction_request_valid_with_tag(self):
+        """Test valid transaction request with tag passes validation."""
+        from iwa.web.server import TransactionRequest
+
+        req = TransactionRequest(
+            from_address="my_wallet",
+            to_address="receiver_wallet",
+            amount_eth=1.0,
+            token="native",
+            chain="gnosis",
+        )
+        assert req.from_address == "my_wallet"
+
+    def test_transaction_request_invalid_address_xss(self):
+        """Test that XSS in address is rejected."""
+        from pydantic import ValidationError
+
+        from iwa.web.server import TransactionRequest
+
+        with pytest.raises(ValidationError) as exc:
+            TransactionRequest(
+                from_address="<script>alert(1)</script>",
+                to_address="0x1234567890abcdef1234567890abcdef12345678",
+                amount_eth=1.0,
+                token="native",
+                chain="gnosis",
+            )
+        assert "alphanumeric" in str(exc.value).lower()
+
+    def test_transaction_request_invalid_address_format(self):
+        """Test that invalid hex address is rejected."""
+        from pydantic import ValidationError
+
+        from iwa.web.server import TransactionRequest
+
+        with pytest.raises(ValidationError) as exc:
+            TransactionRequest(
+                from_address="0xINVALIDHEXADDRESS",
+                to_address="0x1234567890abcdef1234567890abcdef12345678",
+                amount_eth=1.0,
+                token="native",
+                chain="gnosis",
+            )
+        assert "invalid" in str(exc.value).lower()
+
+    def test_transaction_request_empty_address(self):
+        """Test that empty address is rejected."""
+        from pydantic import ValidationError
+
+        from iwa.web.server import TransactionRequest
+
+        with pytest.raises(ValidationError):
+            TransactionRequest(
+                from_address="",
+                to_address="0x1234567890abcdef1234567890abcdef12345678",
+                amount_eth=1.0,
+                token="native",
+                chain="gnosis",
+            )
+
+    def test_transaction_request_negative_amount(self):
+        """Test that negative amounts are rejected."""
+        from pydantic import ValidationError
+
+        from iwa.web.server import TransactionRequest
+
+        with pytest.raises(ValidationError) as exc:
+            TransactionRequest(
+                from_address="0x1234567890abcdef1234567890abcdef12345678",
+                to_address="0xabcdef1234567890abcdef1234567890abcdef12",
+                amount_eth=-1.0,
+                token="native",
+                chain="gnosis",
+            )
+        assert "positive" in str(exc.value).lower()
+
+    def test_transaction_request_zero_amount(self):
+        """Test that zero amount is rejected."""
+        from pydantic import ValidationError
+
+        from iwa.web.server import TransactionRequest
+
+        with pytest.raises(ValidationError):
+            TransactionRequest(
+                from_address="0x1234567890abcdef1234567890abcdef12345678",
+                to_address="0xabcdef1234567890abcdef1234567890abcdef12",
+                amount_eth=0,
+                token="native",
+                chain="gnosis",
+            )
+
+    def test_transaction_request_excessive_amount(self):
+        """Test that excessive amount is rejected."""
+        from pydantic import ValidationError
+
+        from iwa.web.server import TransactionRequest
+
+        with pytest.raises(ValidationError) as exc:
+            TransactionRequest(
+                from_address="0x1234567890abcdef1234567890abcdef12345678",
+                to_address="0xabcdef1234567890abcdef1234567890abcdef12",
+                amount_eth=1e20,
+                token="native",
+                chain="gnosis",
+            )
+        assert "large" in str(exc.value).lower()
+
+    def test_transaction_request_xss_chain(self):
+        """Test that XSS in chain field is rejected."""
+        from pydantic import ValidationError
+
+        from iwa.web.server import TransactionRequest
+
+        with pytest.raises(ValidationError):
+            TransactionRequest(
+                from_address="0x1234567890abcdef1234567890abcdef12345678",
+                to_address="0xabcdef1234567890abcdef1234567890abcdef12",
+                amount_eth=1.0,
+                token="native",
+                chain="<script>",
+            )
+
+    def test_account_create_request_valid_tag(self):
+        """Test valid tag passes validation."""
+        from iwa.web.server import AccountCreateRequest
+
+        req = AccountCreateRequest(tag="my_wallet_123")
+        assert req.tag == "my_wallet_123"
+
+    def test_account_create_request_none_tag(self):
+        """Test None tag is allowed."""
+        from iwa.web.server import AccountCreateRequest
+
+        req = AccountCreateRequest(tag=None)
+        assert req.tag is None
+
+    def test_account_create_request_empty_tag(self):
+        """Test empty tag becomes None."""
+        from iwa.web.server import AccountCreateRequest
+
+        req = AccountCreateRequest(tag="  ")
+        assert req.tag is None
+
+    def test_account_create_request_xss_tag(self):
+        """Test that XSS in tag is rejected."""
+        from pydantic import ValidationError
+
+        from iwa.web.server import AccountCreateRequest
+
+        with pytest.raises(ValidationError) as exc:
+            AccountCreateRequest(tag="<script>alert(1)</script>")
+        assert "alphanumeric" in str(exc.value).lower()
+
+    def test_account_create_request_long_tag(self):
+        """Test that too-long tags are rejected."""
+        from pydantic import ValidationError
+
+        from iwa.web.server import AccountCreateRequest
+
+        with pytest.raises(ValidationError) as exc:
+            AccountCreateRequest(tag="a" * 51)
+        assert "long" in str(exc.value).lower()
+
+    def test_account_create_request_with_underscore_hyphen(self):
+        """Test that underscores and hyphens are allowed in tags."""
+        from iwa.web.server import AccountCreateRequest
+
+        req = AccountCreateRequest(tag="my-wallet_name")
+        assert req.tag == "my-wallet_name"
+
+
+class TestAppConfiguration:
+    """Tests for app configuration."""
+
+    def test_cors_middleware_configured(self):
+        """Test that CORS middleware is configured."""
+        from iwa.web.server import app
+
+        # Check that user_middleware list is not empty (CORS was added)
+        assert len(app.user_middleware) > 0
+
+    def test_static_files_mounted(self):
+        """Test that static files are mounted."""
+        from iwa.web.server import app
+
+        routes = [r.path for r in app.routes if hasattr(r, "path")]
+        assert "/static" in routes

tests/test_account_service.py

@@ -0,0 +1,120 @@
+"""Tests for AccountService."""
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from iwa.core.constants import NATIVE_CURRENCY_ADDRESS
+from iwa.core.models import EthereumAddress, StoredSafeAccount
+from iwa.core.services.account import AccountService
+
+
+@pytest.fixture
+def mock_key_storage():
+    mock = MagicMock()
+    mock.master_account = StoredSafeAccount(
+        tag="master",
+        address="0x1111111111111111111111111111111111111111",
+        chains=["gnosis"],
+        threshold=1,
+        signers=["0x2222222222222222222222222222222222222222"],
+    )
+    mock.get_account.return_value = MagicMock(address="0x1234")
+    mock.get_tag_by_address.return_value = "my_tag"
+    mock.accounts = {}
+    return mock
+
+
+@pytest.fixture
+def account_service(mock_key_storage):
+    return AccountService(mock_key_storage)
+
+
+def test_init(account_service, mock_key_storage):
+    """Test AccountService initialization."""
+    assert account_service.key_storage == mock_key_storage
+
+
+def test_master_account(account_service, mock_key_storage):
+    """Test master_account property."""
+    result = account_service.master_account
+
+    assert result == mock_key_storage.master_account
+    assert result.tag == "master"
+
+
+def test_get_token_address_native(account_service):
+    """Test get_token_address returns native address."""
+    mock_chain = MagicMock()
+
+    result = account_service.get_token_address("native", mock_chain)
+
+    assert result == EthereumAddress(NATIVE_CURRENCY_ADDRESS)
+
+
+def test_get_token_address_valid_address(account_service):
+    """Test get_token_address with valid Ethereum address."""
+    mock_chain = MagicMock()
+    valid_address = "0x1234567890123456789012345678901234567890"
+
+    result = account_service.get_token_address(valid_address, mock_chain)
+
+    assert result == EthereumAddress(valid_address)
+
+
+def test_get_token_address_by_name(account_service):
+    """Test get_token_address resolves token name."""
+    mock_chain = MagicMock()
+    mock_chain.get_token_address.return_value = EthereumAddress(
+        "0x6B175474E89094C44Da98b954EedeAC495271E01"
+    )
+
+    result = account_service.get_token_address("DAI", mock_chain)
+
+    assert result == EthereumAddress("0x6B175474E89094C44Da98b954EedeAC495271E01")
+    mock_chain.get_token_address.assert_called_with("DAI")
+
+
+def test_get_token_address_not_found(account_service):
+    """Test get_token_address returns None for unknown token."""
+    mock_chain = MagicMock()
+    mock_chain.name = "gnosis"
+    mock_chain.get_token_address.return_value = None
+
+    result = account_service.get_token_address("UNKNOWN", mock_chain)
+
+    assert result is None
+
+
+def test_resolve_account(account_service, mock_key_storage):
+    """Test resolve_account delegates to key_storage."""
+    result = account_service.resolve_account("my_tag")
+
+    mock_key_storage.get_account.assert_called_with("my_tag")
+    assert result.address == "0x1234"
+
+
+def test_resolve_account_not_found(account_service, mock_key_storage):
+    """Test resolve_account returns None for unknown account."""
+    mock_key_storage.get_account.return_value = None
+
+    result = account_service.resolve_account("unknown")
+
+    assert result is None
+
+
+def test_get_tag_by_address(account_service, mock_key_storage):
+    """Test get_tag_by_address delegates to key_storage."""
+    result = account_service.get_tag_by_address("0x1234")
+
+    mock_key_storage.get_tag_by_address.assert_called_with("0x1234")
+    assert result == "my_tag"
+
+
+def test_get_account_data(account_service, mock_key_storage):
+    """Test get_account_data returns accounts dict."""
+    mock_key_storage.accounts = {"0x1234": MagicMock()}
+
+    result = account_service.get_account_data()
+
+    assert result == mock_key_storage.accounts

tests/test_balance_service.py

@@ -0,0 +1,186 @@
+"""Tests for BalanceService."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+@pytest.fixture
+def mock_chain_interfaces():
+    with patch("iwa.core.services.balance.ChainInterfaces") as mock:
+        instance = mock.return_value
+        gnosis_interface = MagicMock()
+        gnosis_interface.chain.name = "Gnosis"
+        gnosis_interface.get_native_balance_eth.return_value = 1.5
+        gnosis_interface.get_native_balance_wei.return_value = 1500000000000000000
+        instance.get.return_value = gnosis_interface
+        yield instance
+
+
+@pytest.fixture
+def mock_account_service():
+    mock = MagicMock()
+    mock.get_token_address.return_value = "0xTokenAddress"
+    mock.resolve_account.return_value = MagicMock(address="0xAccountAddress")
+    return mock
+
+
+@pytest.fixture
+def mock_key_storage():
+    return MagicMock()
+
+
+@pytest.fixture
+def balance_service(mock_key_storage, mock_account_service):
+    from iwa.core.services.balance import BalanceService
+
+    return BalanceService(mock_key_storage, mock_account_service)
+
+
+def test_get_native_balance_eth(balance_service, mock_chain_interfaces, mock_account_service):
+    """Test get_native_balance_eth returns correct value."""
+    result = balance_service.get_native_balance_eth("0xAccount", "gnosis")
+
+    assert result == 1.5
+    # Now resolves account first, so expects resolved address
+    mock_chain_interfaces.get.return_value.get_native_balance_eth.assert_called_with(
+        "0xAccountAddress"
+    )
+    mock_account_service.resolve_account.assert_called_with("0xAccount")
+
+
+def test_get_native_balance_wei(balance_service, mock_chain_interfaces, mock_account_service):
+    """Test get_native_balance_wei returns correct value."""
+    result = balance_service.get_native_balance_wei("0xAccount", "gnosis")
+
+    assert result == 1500000000000000000
+    # Now resolves account first, so expects resolved address
+    mock_chain_interfaces.get.return_value.get_native_balance_wei.assert_called_with(
+        "0xAccountAddress"
+    )
+    mock_account_service.resolve_account.assert_called_with("0xAccount")
+
+
+def test_get_erc20_balance_eth_success(
+    balance_service, mock_chain_interfaces, mock_account_service
+):
+    """Test get_erc20_balance_eth returns correct value."""
+    with patch("iwa.core.services.balance.ERC20Contract") as mock_erc20:
+        mock_erc20.return_value.balance_of_eth.return_value = 100.5
+
+        result = balance_service.get_erc20_balance_eth("0xAccount", "DAI", "gnosis")
+
+        assert result == 100.5
+        mock_account_service.get_token_address.assert_called()
+        mock_account_service.resolve_account.assert_called_with("0xAccount")
+
+
+def test_get_erc20_balance_eth_token_not_found(
+    balance_service, mock_chain_interfaces, mock_account_service
+):
+    """Test get_erc20_balance_eth returns None when token not found."""
+    mock_account_service.get_token_address.return_value = None
+
+    result = balance_service.get_erc20_balance_eth("0xAccount", "UNKNOWN", "gnosis")
+
+    assert result is None
+
+
+def test_get_erc20_balance_eth_account_not_found(
+    balance_service, mock_chain_interfaces, mock_account_service
+):
+    """Test get_erc20_balance_eth returns None when account not found."""
+    mock_account_service.resolve_account.return_value = None
+
+    result = balance_service.get_erc20_balance_eth("unknown_tag", "DAI", "gnosis")
+
+    assert result is None
+
+
+def test_get_erc20_balance_wei_success(
+    balance_service, mock_chain_interfaces, mock_account_service
+):
+    """Test get_erc20_balance_wei returns correct value."""
+    with patch("iwa.core.services.balance.ERC20Contract") as mock_erc20:
+        mock_erc20.return_value.balance_of_wei.return_value = 100500000000000000000
+
+        result = balance_service.get_erc20_balance_wei("0xAccount", "DAI", "gnosis")
+
+        assert result == 100500000000000000000
+
+
+def test_get_erc20_balance_wei_token_not_found(
+    balance_service, mock_chain_interfaces, mock_account_service
+):
+    """Test get_erc20_balance_wei returns None when token not found."""
+    mock_account_service.get_token_address.return_value = None
+
+    result = balance_service.get_erc20_balance_wei("0xAccount", "UNKNOWN", "gnosis")
+
+    assert result is None
+
+
+def test_get_erc20_balance_wei_account_not_found(
+    balance_service, mock_chain_interfaces, mock_account_service
+):
+    """Test get_erc20_balance_wei returns None when account not found."""
+    mock_account_service.resolve_account.return_value = None
+
+    result = balance_service.get_erc20_balance_wei("unknown_tag", "DAI", "gnosis")
+
+    assert result is None
+
+
+def test_get_erc20_balance_with_retry_success(
+    balance_service, mock_chain_interfaces, mock_account_service
+):
+    """Test get_erc20_balance_with_retry succeeds on first try."""
+    with patch("iwa.core.services.balance.ERC20Contract") as mock_erc20:
+        mock_erc20.return_value.balance_of_eth.return_value = 50.0
+
+        result = balance_service.get_erc20_balance_with_retry("0xAccount", "DAI", "gnosis")
+
+        assert result == 50.0
+
+
+def test_get_erc20_balance_with_retry_fails_then_succeeds(
+    balance_service, mock_chain_interfaces, mock_account_service
+):
+    """Test get_erc20_balance_with_retry retries on failure."""
+    with patch("iwa.core.services.balance.ERC20Contract") as mock_erc20, patch("time.sleep"):
+        mock_erc20.return_value.balance_of_eth.side_effect = [
+            Exception("Network error"),
+            25.0,
+        ]
+
+        result = balance_service.get_erc20_balance_with_retry(
+            "0xAccount", "DAI", "gnosis", retries=3
+        )
+
+        assert result == 25.0
+
+
+def test_get_erc20_balance_with_retry_all_attempts_fail(
+    balance_service, mock_chain_interfaces, mock_account_service
+):
+    """Test get_erc20_balance_with_retry returns None after all retries fail."""
+    with patch("iwa.core.services.balance.ERC20Contract") as mock_erc20, patch("time.sleep"):
+        mock_erc20.return_value.balance_of_eth.side_effect = Exception("Network error")
+
+        result = balance_service.get_erc20_balance_with_retry(
+            "0xAccount", "DAI", "gnosis", retries=3
+        )
+
+        assert result is None
+
+
+def test_balance_service_with_wallet(mock_account_service):
+    """Test BalanceService initialization with Wallet (has key_storage attr)."""
+    from iwa.core.services.balance import BalanceService
+
+    mock_wallet = MagicMock()
+    mock_wallet.key_storage = MagicMock()
+
+    service = BalanceService(mock_wallet, mock_account_service)
+
+    assert service.key_storage == mock_wallet.key_storage