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

tests/legacy_cow.py

@@ -0,0 +1,248 @@
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+
+# We need to mock cowdao_cowpy before importing CowSwap to avoid import errors
+# if the library is not installed.
+@pytest.fixture(autouse=True)
+def mock_cowpy_modules():
+    """Mock cowdao_cowpy modules and submodules globally for these tests."""
+    mock_cow = MagicMock()
+    mock_common = MagicMock()
+    mock_chains = MagicMock()
+
+    # Configure Chain enum mock
+    mock_chain_enum = MagicMock()
+    mock_chain_enum.value = [100]  # Gnosis
+    mock_chains.Chain = [mock_chain_enum]
+    mock_chains.SupportedChainId = lambda x: x
+
+    modules = {
+        "cowdao_cowpy": MagicMock(),
+        "cowdao_cowpy.cow": mock_cow,
+        "cowdao_cowpy.cow.swap": MagicMock(),
+        "cowdao_cowpy.common": mock_common,
+        "cowdao_cowpy.common.chains": mock_chains,
+        "cowdao_cowpy.app_data": MagicMock(),
+        "cowdao_cowpy.app_data.utils": MagicMock(),
+        "cowdao_cowpy.contracts": MagicMock(),
+        "cowdao_cowpy.contracts.order": MagicMock(),
+        "cowdao_cowpy.contracts.sign": MagicMock(),
+        "cowdao_cowpy.order_book": MagicMock(),
+        "cowdao_cowpy.order_book.api": MagicMock(),
+        "cowdao_cowpy.order_book.config": MagicMock(),
+        "cowdao_cowpy.order_book.generated": MagicMock(),
+        "cowdao_cowpy.order_book.generated.model": MagicMock(),
+    }
+
+    with patch.dict("sys.modules", modules):
+        yield modules
+
+
+@pytest.fixture(autouse=True)
+def clear_cowswap_cache():
+    """Clear the lazy loading cache in CowSwap module."""
+    from iwa.plugins.gnosis.cow import _cowpy_cache
+
+    _cowpy_cache.clear()
+    yield
+    _cowpy_cache.clear()
+
+
+from iwa.core.chain import Gnosis
+from iwa.plugins.gnosis.cow import CowSwap, OrderType
+
+
+@pytest.fixture
+def mock_account():
+    with patch("iwa.plugins.gnosis.cow.Account") as mock:
+        mock.from_key.return_value = MagicMock(address="0xAccount", _address="0xAccount")
+        yield mock
+
+
+@pytest.fixture
+def cow_swap(mock_account):
+    return CowSwap("private_key", Gnosis())
+
+
+@pytest.mark.asyncio
+async def test_swap_sell(cow_swap):
+    with patch("iwa.plugins.gnosis.cow.swap_tokens", new_callable=AsyncMock) as mock_swap_tokens:
+        mock_swap_tokens.return_value = MagicMock(uid=MagicMock(root="order_uid"))
+
+        with patch.object(CowSwap, "check_cowswap_order", return_value=True):
+            success = await cow_swap.swap(1000, "OLAS", "WXDAI", order_type=OrderType.SELL)
+            assert success is True
+            mock_swap_tokens.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_swap_buy(cow_swap):
+    with patch(
+        "iwa.plugins.gnosis.cow.CowSwap.swap_tokens_to_exact_tokens", new_callable=AsyncMock
+    ) as mock_swap_tokens:
+        mock_swap_tokens.return_value = MagicMock(uid=MagicMock(root="order_uid"))
+
+        with patch.object(CowSwap, "check_cowswap_order", return_value=True):
+            success = await cow_swap.swap(1000, "OLAS", "WXDAI", order_type=OrderType.BUY)
+            assert success is True
+            mock_swap_tokens.assert_called_once()
+
+
+def test_check_cowswap_order_executed(cow_swap):
+    order = MagicMock()
+    order.url = "http://order.url"
+
+    with patch("iwa.plugins.gnosis.cow.requests.get") as mock_get:
+        mock_get.return_value.status_code = 200
+        mock_get.return_value.json.return_value = {
+            "status": "fulfilled",
+            "executedSellAmount": "100",
+            "executedBuyAmount": "100",
+            "quote": {"sellTokenPrice": 1.0, "buyTokenPrice": 1.0},
+        }
+
+        success = cow_swap.check_cowswap_order(order)
+        assert success is True
+
+
+def test_check_cowswap_order_expired(cow_swap):
+    order = MagicMock()
+    order.url = "http://order.url"
+
+    with patch("iwa.plugins.gnosis.cow.requests.get") as mock_get:
+        mock_get.return_value.status_code = 200
+        mock_get.return_value.json.return_value = {"status": "expired"}
+
+        success = cow_swap.check_cowswap_order(order)
+        assert success is False
+
+
+def test_get_chain_unsupported(cow_swap):
+    # Set to an ID that won't be found in our mock Chain list
+    cow_swap.supported_chain_id = 999
+    with pytest.raises(ValueError, match="Unsupported SupportedChainId"):
+        cow_swap.get_chain()
+
+
+def test_check_cowswap_order_retries(cow_swap):
+    order = MagicMock()
+    order.url = "http://order.url"
+
+    with (
+        patch("iwa.plugins.gnosis.cow.requests.get") as mock_get,
+        patch("iwa.plugins.gnosis.cow.time.sleep") as mock_sleep,
+    ):
+        mock_get.side_effect = [
+            MagicMock(status_code=404),
+            MagicMock(
+                status_code=200, json=lambda: {"status": "fulfilled", "executedSellAmount": "100"}
+            ),
+        ]
+
+        success = cow_swap.check_cowswap_order(order)
+        assert success is True
+        assert mock_get.call_count == 2
+        mock_sleep.assert_called_once()
+
+
+def test_check_cowswap_order_max_retries(cow_swap):
+    order = MagicMock()
+    order.url = "http://order.url"
+
+    with (
+        patch("iwa.plugins.gnosis.cow.requests.get") as mock_get,
+        patch("iwa.plugins.gnosis.cow.time.sleep"),
+    ):
+        mock_get.return_value.status_code = 404
+
+        success = cow_swap.check_cowswap_order(order)
+        assert success is False
+        assert mock_get.call_count == 8
+
+
+@pytest.mark.asyncio
+async def test_swap_exception(cow_swap):
+    with patch("iwa.plugins.gnosis.cow.swap_tokens", side_effect=Exception("Swap failed")):
+        success = await cow_swap.swap(1000, "OLAS", "WXDAI")
+        assert success is False
+
+
+@pytest.mark.asyncio
+async def test_get_max_sell_amount_wei(cow_swap):
+    with patch("iwa.plugins.gnosis.cow.get_order_quote", new_callable=AsyncMock) as mock_get_quote:
+        mock_quote = MagicMock()
+        mock_quote.quote.sellAmount.root = "1000"
+        mock_get_quote.return_value = mock_quote
+
+        amount = await cow_swap.get_max_sell_amount_wei(1000, "0xSell", "0xBuy")
+        assert amount == int(1000 * 1.005)
+
+
+@pytest.mark.asyncio
+async def test_swap_tokens_to_exact_tokens(cow_swap):
+    with (
+        patch("iwa.plugins.gnosis.cow.get_order_quote", new_callable=AsyncMock) as mock_get_quote,
+        patch("iwa.plugins.gnosis.cow.post_order", new_callable=AsyncMock) as mock_post_order,
+        patch("iwa.plugins.gnosis.cow.sign_order"),
+        patch("iwa.plugins.gnosis.cow.CompletedOrder") as mock_completed_order,
+    ):
+        mock_quote = MagicMock()
+        mock_quote.quote.sellAmount.root = "1000"
+        mock_quote.quote.validTo = 1234567890
+        mock_get_quote.return_value = mock_quote
+
+        mock_post_order.return_value = MagicMock(root="order_uid")
+
+        cow_swap.order_book_api = MagicMock()
+        cow_swap.order_book_api.get_order_link.return_value = "http://order.link"
+
+        mock_order_instance = MagicMock()
+        mock_order_instance.uid = MagicMock(root="order_uid")
+        mock_order_instance.url = "http://order.link"
+        mock_completed_order.return_value = mock_order_instance
+
+        order = await CowSwap.swap_tokens_to_exact_tokens(
+            amount=1000,
+            account=MagicMock(address="0xAccount", _address="0xAccount"),
+            chain=MagicMock(value=[100]),
+            sell_token="0xSell",
+            buy_token="0xBuy",
+        )
+
+        assert order.uid.root == "order_uid"
+        assert order.url == "http://order.link"
+
+
+def test_check_cowswap_order_pending(cow_swap):
+    order = MagicMock()
+    order.url = "http://order.url"
+
+    with (
+        patch("iwa.plugins.gnosis.cow.requests.get") as mock_get,
+        patch("iwa.plugins.gnosis.cow.time.sleep") as mock_sleep,
+    ):
+        mock_get.side_effect = [
+            MagicMock(
+                status_code=200,
+                json=lambda: {
+                    "status": "open",
+                    "executedSellAmount": "0",
+                    "executedBuyAmount": "0",
+                },
+            ),
+            MagicMock(
+                status_code=200,
+                json=lambda: {
+                    "status": "fulfilled",
+                    "executedSellAmount": "100",
+                    "executedBuyAmount": "0",
+                },
+            ),
+        ]
+
+        success = cow_swap.check_cowswap_order(order)
+        assert success is True
+        assert mock_get.call_count == 2
+        mock_sleep.assert_called_once()

tests/legacy_safe.py

@@ -0,0 +1,93 @@
+import sys
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+# Mock safe_eth before importing SafeMultisig
+sys.modules["safe_eth"] = MagicMock()
+sys.modules["safe_eth.eth"] = MagicMock()
+sys.modules["safe_eth.eth.constants"] = MagicMock()
+sys.modules["safe_eth.safe"] = MagicMock()
+
+from iwa.core.models import StoredSafeAccount
+from iwa.plugins.gnosis.safe import SafeMultisig
+
+
+@pytest.fixture
+def mock_secrets():
+    with patch("iwa.plugins.gnosis.safe.settings") as mock:
+        mock.gnosis_rpc.get_secret_value.return_value = "http://rpc"
+        yield mock
+
+
+@pytest.fixture
+def mock_safe_account():
+    account = MagicMock(spec=StoredSafeAccount)
+    account.address = "0xSafe"
+    account.chains = ["gnosis"]
+    return account
+
+
+@pytest.fixture
+def mock_safe_lib():
+    with (
+        patch("iwa.plugins.gnosis.safe.Safe") as mock_safe,
+        patch("iwa.plugins.gnosis.safe.EthereumClient") as mock_client,
+    ):
+        yield mock_safe, mock_client
+
+
+def test_init_success(mock_safe_account, mock_secrets, mock_safe_lib):
+    safe = SafeMultisig(mock_safe_account, "gnosis")
+    assert safe.multisig is not None
+    mock_safe_lib[1].assert_called_with("http://rpc")  # EthereumClient
+    mock_safe_lib[0].assert_called_with("0xSafe", mock_safe_lib[1].return_value)  # Safe
+
+
+def test_init_invalid_chain(mock_safe_account, mock_secrets):
+    with pytest.raises(ValueError, match="Safe account is not deployed on chain"):
+        SafeMultisig(mock_safe_account, "ethereum")
+
+
+def test_get_owners(mock_safe_account, mock_secrets, mock_safe_lib):
+    safe = SafeMultisig(mock_safe_account, "gnosis")
+    safe.multisig.retrieve_owners.return_value = ["0xOwner"]
+    assert safe.get_owners() == ["0xOwner"]
+
+
+def test_get_threshold(mock_safe_account, mock_secrets, mock_safe_lib):
+    safe = SafeMultisig(mock_safe_account, "gnosis")
+    safe.multisig.retrieve_threshold.return_value = 2
+    assert safe.get_threshold() == 2
+
+
+def test_get_nonce(mock_safe_account, mock_secrets, mock_safe_lib):
+    safe = SafeMultisig(mock_safe_account, "gnosis")
+    safe.multisig.retrieve_nonce.return_value = 5
+    assert safe.get_nonce() == 5
+
+
+def test_retrieve_all_info(mock_safe_account, mock_secrets, mock_safe_lib):
+    safe = SafeMultisig(mock_safe_account, "gnosis")
+    safe.multisig.retrieve_all_info.return_value = {"owners": []}
+    assert safe.retrieve_all_info() == {"owners": []}
+
+
+def test_send_tx_with_callback(mock_safe_account, mock_secrets, mock_safe_lib):
+    """Test the new send_tx method with callback."""
+    safe = SafeMultisig(mock_safe_account, "gnosis")
+    mock_tx = MagicMock()
+    safe.multisig.build_multisig_tx.return_value = mock_tx
+
+    def sign_callback(safe_tx):
+        return "0xCallbackHash"
+
+    result = safe.send_tx(
+        to="0xTo",
+        value=100,
+        sign_and_execute_callback=sign_callback,
+        data="0x1234",
+    )
+
+    assert result == "0xCallbackHash"
+    safe.multisig.build_multisig_tx.assert_called()

tests/legacy_transaction_retry_logic.py

@@ -0,0 +1,51 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from iwa.tui.app import IwaApp
+from iwa.tui.modals import CreateEOAModal
+from iwa.tui.screens.wallets import WalletsScreen
+
+# --- TUI Modal Tests ---
+
+
+@pytest.mark.asyncio
+async def test_create_eoa_modal():
+    modal = CreateEOAModal()
+    mock_event = MagicMock()
+    mock_event.button.id = "cancel"
+    with patch.object(modal, "dismiss") as mock_dismiss:
+        modal.on_button_pressed(mock_event)
+        mock_dismiss.assert_called()
+    mock_event.button.id = "create"
+    try:
+        modal.on_button_pressed(mock_event)
+    except Exception:
+        pass
+
+
+# --- WalletsScreen Filtering Tests ---
+
+
+@pytest.mark.asyncio
+async def test_wallets_view_filtering():
+    with patch("iwa.core.db.db"):
+        app = IwaApp()
+        async with app.run_test() as _:
+            view = app.query_one(WalletsScreen)
+
+            with (
+                patch.object(view, "fetch_all_balances") as mock_fetch,
+                patch.object(view, "refresh_table_structure_and_data") as mock_refresh,
+            ):
+                mock_chk_event = MagicMock()
+                mock_chk_event.checkbox.id = "cb_Token"
+                mock_chk_event.value = True
+
+                view.on_checkbox_changed(mock_chk_event)
+
+                mock_fetch.assert_called_with(view.active_chain, ["Token"])
+
+                mock_chk_event.value = False
+                view.on_checkbox_changed(mock_chk_event)
+                mock_refresh.assert_called()