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

iwa/tui/tests/test_app.py

@@ -0,0 +1,125 @@
+"""Tests for TUI App."""
+
+import importlib
+import sys
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+# Fixture to mock dependencies
+@pytest.fixture
+def mock_dependencies():
+    """Mock app dependencies."""
+    # Start patches for Textual widgets at source to persist through reload
+    patch_header = patch("textual.widgets.Header")
+    patch_footer = patch("textual.widgets.Footer")
+    patch_tabbed = patch("textual.widgets.TabbedContent")
+    patch_pane = patch("textual.widgets.TabPane")
+
+    mock_header = patch_header.start()
+    mock_footer = patch_footer.start()
+    mock_tabbed = patch_tabbed.start()
+    mock_pane = patch_pane.start()
+
+    # Setup TabbedContent and TabPane as context managers
+    mock_tabbed.return_value.__enter__.return_value = MagicMock()
+    mock_pane.return_value.__enter__.return_value = MagicMock()
+
+    with (
+        patch("iwa.core.wallet.Wallet") as mock_wallet,
+        patch("iwa.tui.rpc.RPCView") as mock_rpc_view,
+        patch("iwa.tui.screens.wallets.WalletsScreen") as mock_wallets_screen,
+        patch("loguru.logger") as mock_global_logger,
+    ):
+        mock_wallet_instance = mock_wallet.return_value
+        mock_plugin = MagicMock()
+        mock_plugin.name = "Olas"
+        mock_plugin.get_tui_view.return_value = MagicMock()
+
+        mock_wallet_instance.plugin_service.get_all_plugins.return_value = {"olas": mock_plugin}
+
+        yield {
+            "wallet": mock_wallet,
+            "rpc_view": mock_rpc_view,
+            "wallets_screen": mock_wallets_screen,
+            "logger": mock_global_logger,
+            "widgets": [mock_header, mock_footer, mock_tabbed, mock_pane],
+        }
+
+    # Stop global patches after the test yields
+    patch_header.stop()
+    patch_footer.stop()
+    patch_tabbed.stop()
+    patch_pane.stop()
+
+
+@pytest.fixture
+def iwa_app_cls(mock_dependencies):
+    """Fixture to reload and return IwaApp class."""
+    if "iwa.tui.app" in sys.modules:
+        importlib.reload(sys.modules["iwa.tui.app"])
+    else:
+        importlib.import_module("iwa.tui.app")
+    return sys.modules["iwa.tui.app"].IwaApp
+
+
+def test_init(iwa_app_cls, mock_dependencies):
+    """Test app initialization."""
+    app = iwa_app_cls()
+    assert app.wallet is not None
+    assert "olas" in app.plugins
+    mock_dependencies["logger"].add.assert_called()
+
+
+def test_compose_runs(iwa_app_cls, mock_dependencies):
+    """Test compose method runs."""
+    app = iwa_app_cls()
+
+    # Run compose
+    widgets = list(app.compose())
+
+    assert len(widgets) > 0
+    mock_dependencies["wallets_screen"].assert_called()
+    mock_dependencies["rpc_view"].assert_called()
+
+
+def test_action_refresh(iwa_app_cls, mock_dependencies):
+    """Test refresh action."""
+    app = iwa_app_cls()
+
+    mock_screen = MagicMock()
+    app.query_one = MagicMock(return_value=mock_screen)
+
+    app.action_refresh()
+
+    app.query_one.assert_called()
+    mock_screen.refresh_accounts.assert_called_once()
+
+
+def test_action_refresh_error(iwa_app_cls, mock_dependencies):
+    """Test refresh action error handling."""
+    app = iwa_app_cls()
+    app.query_one = MagicMock(side_effect=Exception("No screen"))
+    app.action_refresh()
+
+
+def test_copy_to_clipboard(iwa_app_cls, mock_dependencies):
+    """Test copy to clipboard."""
+    app = iwa_app_cls()
+
+    with patch.dict(sys.modules, {"pyperclip": MagicMock()}):
+        app.copy_to_clipboard("test")
+        sys.modules["pyperclip"].copy.assert_called_with("test")  # type: ignore
+
+
+def test_copy_to_clipboard_error(iwa_app_cls, mock_dependencies):
+    """Test copy to clipboard error."""
+    app = iwa_app_cls()
+
+    mock_pyperclip = MagicMock()
+    mock_pyperclip.copy.side_effect = Exception("Copy fail")
+
+    with patch.dict(sys.modules, {"pyperclip": mock_pyperclip}):
+        app.copy_to_clipboard("test")
+        mock_dependencies["logger"].error.assert_called()

iwa/tui/tests/test_rpc.py

@@ -0,0 +1,139 @@
+"""Tests for RPC view."""
+
+import importlib
+import sys
+from unittest.mock import MagicMock, PropertyMock, patch
+
+import pytest
+
+
+# Mock textual's work decorator to run synchronously or just return the function
+@pytest.fixture(autouse=True)
+def mock_work_decorator():
+    """Mock textual work decorator."""
+
+    # Patch textual.work before import/reload
+    def decorator(*args, **kwargs):
+        if args and callable(args[0]):
+            return args[0]
+
+        def real_decorator(func):
+            return func
+
+        return real_decorator
+
+    with patch("textual.work", side_effect=decorator):
+        yield
+
+
+@pytest.fixture
+def rpc_view_cls(mock_chain_interfaces):
+    """Fixture to reload and return RPCView class."""
+    if "iwa.tui.rpc" in sys.modules:
+        importlib.reload(sys.modules["iwa.tui.rpc"])
+    else:
+        importlib.import_module("iwa.tui.rpc")
+    return sys.modules["iwa.tui.rpc"].RPCView
+
+
+@pytest.fixture
+def mock_chain_interfaces():
+    """Mock ChainInterfaces."""
+    # Patch the source class so it works even after reload
+    with patch("iwa.core.chain.ChainInterfaces") as mock_ci:
+        mock_instance = mock_ci.return_value
+        yield mock_instance
+
+
+@pytest.fixture
+def rpc_view(rpc_view_cls):
+    """Fixture to create an RPCView instance."""
+    view = rpc_view_cls()
+    # Mock app property
+    mock_app = MagicMock()
+    with patch.object(view.__class__, "app", new_callable=PropertyMock) as mock_app_prop:
+        mock_app_prop.return_value = mock_app
+        view.query_one = MagicMock()
+        yield view
+
+
+def test_compose(rpc_view):
+    """Test compose method."""
+    # Just check it yields valid widgets
+    widgets = list(rpc_view.compose())
+    assert len(widgets) == 2
+    # Check first widget is a Label with correct text
+    # Check first widget is a Label
+    assert "Label" in str(widgets[0]) or widgets[0].__class__.__name__ == "Label"
+
+
+def test_check_rpcs_success(rpc_view, mock_chain_interfaces):
+    """Test check_rpcs with successful connections."""
+    # Setup mock chain interfaces
+    mock_gnosis = MagicMock()
+    mock_gnosis.chain.rpc = "http://gnosis"
+    mock_gnosis.web3.is_connected.return_value = True
+
+    mock_chain_interfaces.get.side_effect = lambda name: mock_gnosis if name == "gnosis" else None
+
+    # We need to ensure check_rpcs calls update_table via call_from_thread
+    # Since we mocked @work to simply return the function, calling check_rpcs runs logic in main thread
+    # But check_rpcs calls self.app.call_from_thread(self.update_table, results)
+
+    # Run
+    rpc_view.check_rpcs()
+
+    # Verify results
+    assert rpc_view.app.call_from_thread.called
+    args = rpc_view.app.call_from_thread.call_args[0]
+    assert args[0] == rpc_view.update_table
+    results = args[1]
+
+    # We mocked gnosis to return interface, others None
+    # expected results: (chain, url, status, latency)
+    gnosis_result = next(r for r in results if r[0] == "gnosis")
+    assert gnosis_result[1] == "http://gnosis"
+    assert gnosis_result[2] == "Online"
+
+
+def test_check_rpcs_error(rpc_view, mock_chain_interfaces):
+    """Test check_rpcs with connection error."""
+    mock_eth = MagicMock()
+    mock_eth.chain.rpc = "http://eth"
+    mock_eth.web3.is_connected.side_effect = Exception("Connection fail")
+
+    mock_chain_interfaces.get.side_effect = lambda name: mock_eth if name == "ethereum" else None
+
+    rpc_view.check_rpcs()
+
+    args = rpc_view.app.call_from_thread.call_args[0]
+    results = args[1]
+
+    eth_result = next(r for r in results if r[0] == "ethereum")
+    assert "Error" in eth_result[2]
+
+
+def test_check_rpcs_missing_interface(rpc_view, mock_chain_interfaces):
+    """Test check_rpcs with missing configuration."""
+    mock_chain_interfaces.get.return_value = None
+
+    rpc_view.check_rpcs()
+
+    args = rpc_view.app.call_from_thread.call_args[0]
+    results = args[1]
+
+    # All Should be Not Configured
+    for res in results:
+        assert res[2] == "Not Configured"
+
+
+def test_update_table(rpc_view):
+    """Test update_table method."""
+    mock_table = MagicMock()
+    rpc_view.query_one.return_value = mock_table
+
+    results = [("gnosis", "url", "Online", "10ms")]
+    rpc_view.update_table(results)
+
+    mock_table.clear.assert_called_once()
+    mock_table.add_row.assert_called_with("gnosis", "url", "Online", "10ms")

iwa/tui/tests/test_wallets_refactor.py

@@ -0,0 +1,30 @@
+"""Tests for Wallets Refactor."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from iwa.tui.screens.wallets import WalletsScreen
+
+
+@pytest.fixture
+def mock_wallet():
+    """Mock wallet."""
+    return MagicMock()
+
+
+def test_wallets_screen_initialization(mock_wallet):
+    """Test that WalletsScreen can be initialized with the new import structure."""
+    with patch("iwa.core.chain.ChainInterfaces"):
+        # Mock MonitorWorker import if needed, but it should be imported from workers.py now
+        screen = WalletsScreen(wallet=mock_wallet)
+        assert screen is not None
+        assert hasattr(screen, "monitor_worker") or hasattr(screen, "start_monitor")
+
+
+def test_monitor_worker_integration():
+    """Test that MonitorWorker is imported from the correct location."""
+    from iwa.tui.screens.wallets import MonitorWorker as WalletsMonitorWorker
+    from iwa.tui.workers import MonitorWorker as DefinedMonitorWorker
+
+    assert WalletsMonitorWorker is DefinedMonitorWorker

iwa/tui/tests/test_widgets.py

@@ -0,0 +1,123 @@
+"""Tests for TUI widgets."""
+
+import importlib
+import sys
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+# Fixture to reload module to pick up mocks
+@pytest.fixture
+def widgets_module():
+    """Fixture to reload module and mock dependencies."""
+    # Patch dependencies at source textual.widgets before import/reload
+    with (
+        patch("textual.widgets.Label"),
+        patch("textual.widgets.Select"),
+    ):
+        # Do NOT patch DataTable, let it be real so inheritance works
+        # But we will verify logic by mocking methods on instance or via patch.object
+
+        if "iwa.tui.widgets.base" in sys.modules:
+            importlib.reload(sys.modules["iwa.tui.widgets.base"])
+        else:
+            pass
+
+        yield sys.modules["iwa.tui.widgets.base"]
+
+
+@pytest.fixture
+def mock_chain_interfaces():
+    """Mock ChainInterfaces."""
+    # Patch at source or where imported. Code imports ChainInterfaces from iwa.core.chain
+    # But it calls ChainInterfaces().get()
+    # Let's patch iwa.core.chain.ChainInterfaces
+    with patch("iwa.core.chain.ChainInterfaces") as mock_ci:
+        yield mock_ci.return_value
+
+
+def test_chain_selector_compose(widgets_module, mock_chain_interfaces):
+    """Test ChainSelector composition."""
+    chain_selector_cls = widgets_module.ChainSelector
+    label_cls = widgets_module.Label  # This is the mock now
+    select_cls = widgets_module.Select  # This is the mock now
+
+    # Setup mock interfaces
+    mock_gnosis = MagicMock()
+    mock_gnosis.chain.rpc = "http://rpc"
+
+    mock_eth = MagicMock()
+    mock_eth.chain.rpc = ""  # No RPC
+
+    def get_interface(name):
+        if name == "gnosis":
+            return mock_gnosis
+        if name == "ethereum":
+            return mock_eth
+        return MagicMock()  # base
+
+    mock_chain_interfaces.get.side_effect = get_interface
+
+    selector = chain_selector_cls(active_chain="gnosis")
+    widgets = list(selector.compose())
+
+    assert len(widgets) == 2
+    assert widgets[0] == label_cls.return_value
+    assert widgets[1] == select_cls.return_value
+
+    # Verify Label called with correct text
+    label_cls.assert_called_with("Chain:", classes="label")
+
+    # Verify Select options
+    select_cls.assert_called()
+    call_kwargs = select_cls.call_args.kwargs
+    assert call_kwargs["value"] == "gnosis"
+    assert len(call_kwargs["options"]) == 3  # gnosis, ethereum, base
+
+
+def test_chain_selector_message(widgets_module):
+    """Test ChainSelector message posting."""
+    chain_selector_cls = widgets_module.ChainSelector
+
+    selector = chain_selector_cls()
+    selector.post_message = MagicMock()
+
+
+def test_account_table_setup_columns(widgets_module):
+    """Test AccountTable columns setup."""
+    account_table_cls = widgets_module.AccountTable
+
+    # We must patch DataTable.__init__ so it doesn't fail due to missing app context
+    with (
+        patch("textual.widgets.DataTable.__init__", return_value=None),
+        patch("textual.widgets.DataTable.clear") as mock_clear,
+        patch("textual.widgets.DataTable.add_column") as mock_add_column,
+    ):
+        table = account_table_cls()
+        table.setup_columns("gnosis", "xDAI", ["GNO", "COW"])
+
+        mock_clear.assert_called_with(columns=True)
+        assert mock_add_column.call_count == 4 + 2
+
+
+def test_transaction_table_setup_columns(widgets_module):
+    """Test TransactionTable columns setup."""
+    transaction_table_cls = widgets_module.TransactionTable
+
+    with (
+        patch("textual.widgets.DataTable.__init__", return_value=None),
+        patch("textual.widgets.DataTable.add_column") as mock_add_column,
+    ):
+        table = transaction_table_cls()
+        # Mock columns property which exists on DataTable
+        table.columns = []
+
+        table.setup_columns()
+        assert mock_add_column.call_count > 5
+
+        # Test idempotency
+        table.columns = ["Time"]
+        mock_add_column.reset_mock()
+        table.setup_columns()
+        mock_add_column.assert_not_called()

iwa/tui/widgets/__init__.py

@@ -0,0 +1,5 @@
+"""Widgets for the IWA TUI."""
+
+from .base import AccountTable, ChainSelector, TransactionTable
+
+__all__ = ["AccountTable", "ChainSelector", "TransactionTable"]

iwa/tui/widgets/base.py

@@ -0,0 +1,100 @@
+"""Custom widgets for the IWA TUI."""
+
+from typing import List, Optional
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.widgets import (
+    DataTable,
+    Label,
+    Select,
+)
+
+from iwa.core.chain import ChainInterfaces
+
+
+class ChainSelector(Horizontal):
+    """Widget for selecting the active blockchain."""
+
+    def __init__(self, active_chain: str = "gnosis", id: Optional[str] = None):
+        """Initialize ChainSelector.
+
+        Args:
+            active_chain: The chain to be selected by default.
+            id: The widget ID.
+
+        """
+        super().__init__(id=id)
+        self.active_chain = active_chain
+
+    def compose(self) -> ComposeResult:
+        """Compose the widget.
+
+        Yields a Label and a Select widget populated with available chains.
+        Chains without RPC endpoints are disabled/struck-through.
+        """
+        chain_options = []
+        chain_names = ["gnosis", "ethereum", "base"]
+
+        for name in chain_names:
+            interface = ChainInterfaces().get(name)
+            if interface.chain.rpc:
+                label = name.title()
+                chain_options.append((label, name))
+            else:
+                label = Text(f"{name.title()} (No RPC)", style="dim strike")
+                chain_options.append((label, name))
+
+        yield Label("Chain:", classes="label")
+        yield Select(
+            options=chain_options,
+            value=self.active_chain,
+            id="chain_select",
+            allow_blank=False,
+        )
+
+
+class AccountTable(DataTable):
+    """Table for displaying account addresses and balances."""
+
+    def setup_columns(self, chain_name: str, native_symbol: str, token_names: List[str]):
+        """Setup table columns dynamically based on chain and token list.
+
+        Clears existing columns and adds new ones structure:
+        Tag | Address | Type | Native Symbol | Token 1 | Token 2 ...
+
+        Args:
+            chain_name: Name of the current chain (unused in col setup but contextually relevant).
+            native_symbol: Symbol of the native currency (e.g., ETH, xDAI).
+            token_names: List of additional token names/symbols to display.
+
+        """
+        self.clear(columns=True)
+        self.add_column("Tag", width=12)
+        self.add_column("Address", width=44)
+        self.add_column("Type", width=6)
+        self.add_column(Text(native_symbol.upper(), justify="center"), width=12)
+
+        for token_name in token_names:
+            self.add_column(Text(f"{token_name.upper()}", justify="center"), width=12)
+
+
+class TransactionTable(DataTable):
+    """Table for displaying transaction history."""
+
+    def setup_columns(self):
+        """Setup initial table columns."""
+        if not self.columns:
+            self.add_column("Time", width=22)
+            self.add_column("Chain", width=10)
+            self.add_column("From", width=20)
+            self.add_column("To", width=20)
+            self.add_column("Token", width=10)
+            self.add_column("Amount", width=12)
+            self.add_column("Value (€)", width=12)
+            self.add_column("Status", width=12)
+            self.add_column("Hash", width=14)
+            self.add_column("Gas (wei)", width=12)
+            self.add_column("Gas (€)", width=10)
+            self.add_column("Tags", width=20)

iwa/tui/workers.py

@@ -0,0 +1,42 @@
+"""Background workers for TUI."""
+
+import asyncio
+from typing import TYPE_CHECKING
+
+from loguru import logger
+
+if TYPE_CHECKING:
+    from iwa.core.monitor import EventMonitor
+    from iwa.tui.app import IwaApp
+
+
+class MonitorWorker:
+    """Worker to run the EventMonitor."""
+
+    def __init__(self, monitor: "EventMonitor", app: "IwaApp"):
+        """Initialize MonitorWorker."""
+        self.monitor = monitor
+        self.app = app
+        self._running = False
+
+    async def run(self):
+        """Run the monitor loop."""
+        self._running = True
+        self.monitor.running = True
+        logger.info(f"Starting MonitorWorker for {self.monitor.chain_name}")
+
+        while self._running:
+            try:
+                # Run check_activity in a thread to avoid blocking the async loop
+                # since web3 calls are synchronous
+                await asyncio.to_thread(self.monitor.check_activity)
+            except Exception as e:
+                logger.error(f"Error in MonitorWorker: {e}")
+
+            # Non-blocking sleep
+            await asyncio.sleep(6)
+
+    def stop(self):
+        """Stop the worker."""
+        self._running = False
+        self.monitor.stop()

iwa/web/dependencies.py

@@ -0,0 +1,76 @@
+"""Shared dependencies for Web API routers."""
+
+import logging
+import secrets
+from typing import Optional
+
+from fastapi import Header, HTTPException, Security
+from fastapi.security import APIKeyHeader
+
+from iwa.core.wallet import Wallet
+
+logger = logging.getLogger(__name__)
+
+# Singleton wallet instance for the web app
+wallet = Wallet()
+
+# Authentication
+api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)
+
+
+def _get_webui_password() -> Optional[str]:
+    """Get WEBUI_PASSWORD from settings (lazy load to ensure secrets.env is loaded)."""
+    from iwa.core.settings import settings
+
+    if hasattr(settings, "webui_password") and settings.webui_password:
+        return settings.webui_password.get_secret_value()
+    return None
+
+
+async def verify_auth(
+    x_api_key: Optional[str] = Security(api_key_header), authorization: Optional[str] = Header(None)
+) -> bool:
+    """Verify authentication via API key or Password.
+
+    Uses timing-safe comparison to prevent timing attacks.
+    """
+    password = _get_webui_password()
+
+    # If no password configured, allow everything
+    if not password:
+        return True
+
+    # Check X-API-Key header (timing-safe comparison)
+    if x_api_key and secrets.compare_digest(x_api_key, password):
+        return True
+
+    # Check Authorization header (Bearer token)
+    if authorization:
+        scheme, _, param = authorization.partition(" ")
+        if scheme.lower() == "bearer" and param and secrets.compare_digest(param, password):
+            return True
+
+    raise HTTPException(
+        status_code=401,
+        detail="Invalid authentication credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+
+
+def get_config():
+    """Dependency to provide the Config object."""
+    import yaml
+
+    from iwa.core.constants import CONFIG_PATH
+    from iwa.core.models import Config
+
+    if not CONFIG_PATH.exists():
+        return Config()
+
+    try:
+        with open(CONFIG_PATH, "r") as f:
+            data = yaml.safe_load(f) or {}
+        return Config(**data)
+    except Exception as e:
+        logger.error(f"Error loading config: {e}")
+        return Config()