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

iwa/plugins/olas/tests/test_plugin.py

@@ -0,0 +1,70 @@
+"""Tests for Olas Plugin."""
+
+from unittest.mock import MagicMock, patch
+
+from iwa.plugins.olas.models import OlasConfig
+from iwa.plugins.olas.plugin import OlasPlugin
+
+
+class TestOlasPlugin:
+    """Tests for OlasPlugin class."""
+
+    def test_name_property(self):
+        """Test plugin name property."""
+        plugin = OlasPlugin()
+        assert plugin.name == "olas"
+
+    def test_config_model_returns_olas_config(self):
+        """Test config_model property returns OlasConfig."""
+        plugin = OlasPlugin()
+        assert plugin.config_model == OlasConfig
+
+    def test_get_cli_commands(self):
+        """Test get_cli_commands returns dict with commands."""
+        plugin = OlasPlugin()
+        commands = plugin.get_cli_commands()
+
+        assert isinstance(commands, dict)
+        assert "create" in commands
+        assert callable(commands["create"])
+
+    @patch("iwa.plugins.olas.plugin.Wallet")
+    @patch("iwa.plugins.olas.plugin.ServiceManager")
+    def test_create_service(self, mock_sm_class, mock_wallet_class):
+        """Test create_service calls ServiceManager.create."""
+        mock_wallet = MagicMock()
+        mock_wallet_class.return_value = mock_wallet
+
+        mock_manager = MagicMock()
+        mock_sm_class.return_value = mock_manager
+
+        plugin = OlasPlugin()
+        plugin.create_service(
+            chain_name="gnosis",
+            owner="0x1234",
+            token="OLAS",
+            bond=100,
+        )
+
+        mock_wallet_class.assert_called_once()
+        mock_sm_class.assert_called_once_with(mock_wallet)
+        mock_manager.create.assert_called_once_with("gnosis", "0x1234", "OLAS", 100)
+
+    @patch("iwa.plugins.olas.plugin.Wallet")
+    @patch("iwa.plugins.olas.plugin.ServiceManager")
+    def test_create_service_defaults(self, mock_sm_class, mock_wallet_class):
+        """Test create_service with default parameters."""
+        mock_wallet = MagicMock()
+        mock_wallet_class.return_value = mock_wallet
+
+        mock_manager = MagicMock()
+        mock_sm_class.return_value = mock_manager
+
+        plugin = OlasPlugin()
+        # Note: when called directly (not via typer), defaults are OptionInfo objects
+        # so we can only verify the method was called
+        plugin.create_service()
+
+        mock_wallet_class.assert_called_once()
+        mock_sm_class.assert_called_once_with(mock_wallet)
+        mock_manager.create.assert_called_once()  # Any arguments

iwa/plugins/olas/tests/test_plugin_full.py

@@ -0,0 +1,212 @@
+"""Integration tests for OlasPlugin."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+import typer
+from typer.testing import CliRunner
+
+from iwa.plugins.olas.importer import DiscoveredKey, DiscoveredService, ImportResult
+from iwa.plugins.olas.plugin import OlasPlugin
+
+
+@pytest.fixture
+def plugin():
+    """Mock Olas plugin."""
+    return OlasPlugin()
+
+
+@pytest.fixture
+def runner():
+    """CLI runner fixture."""
+    return CliRunner()
+
+
+def test_plugin_metadata(plugin):
+    """Test plugin metadata methods."""
+    assert plugin.name == "olas"
+    assert plugin.config_model.__name__ == "OlasConfig"
+    assert "create" in plugin.get_cli_commands()
+    assert "import" in plugin.get_cli_commands()
+
+
+def test_get_tui_view(plugin):
+    """Test TUI view creation."""
+    with patch("iwa.plugins.olas.tui.olas_view.OlasView") as mock_view:
+        view = plugin.get_tui_view()
+        assert view is not None
+        mock_view.assert_called_once()
+
+
+def test_create_service_cli(plugin, runner):
+    """Test create_service CLI command."""
+    app = typer.Typer()
+    app.command()(plugin.create_service)
+
+    with (
+        patch("iwa.plugins.olas.plugin.ServiceManager") as mock_sm_cls,
+        patch("iwa.plugins.olas.plugin.Wallet"),
+    ):
+        mock_sm = mock_sm_cls.return_value
+        result = runner.invoke(app, ["--chain", "gnosis", "--bond", "1"])
+        assert result.exit_code == 0
+        mock_sm.create.assert_called_once()
+
+
+def test_import_services_cli_scan_only(plugin, runner):
+    """Test import_services CLI in dry-run mode."""
+    app = typer.Typer()
+    app.command()(plugin.import_services)
+
+    with (
+        patch("iwa.plugins.olas.importer.OlasServiceImporter") as mock_importer_cls,
+        patch.object(OlasPlugin, "_get_safe_signers", return_value=(None, None)),
+    ):
+        mock_importer = mock_importer_cls.return_value
+        mock_importer.scan_directory.return_value = [
+            DiscoveredService(service_id=1, service_name="Test", chain_name="gnosis")
+        ]
+
+        # Test dry-run
+        result = runner.invoke(app, ["/tmp/test", "--dry-run"])
+        assert result.exit_code == 0
+        assert "Found 1 service(s)" in result.output
+        assert "Dry run mode" in result.output
+
+
+def test_import_services_cli_full(plugin, runner):
+    """Test full import_services CLI with confirmation."""
+    app = typer.Typer()
+    app.command()(plugin.import_services)
+
+    with patch("iwa.plugins.olas.importer.OlasServiceImporter") as mock_importer_cls:
+        mock_importer = mock_importer_cls.return_value
+        # Mock discovered service with an encrypted key to trigger password prompt
+        key = DiscoveredKey(address="0x1", is_encrypted=True, role="agent")
+        service = DiscoveredService(
+            service_id=1, service_name="Test", chain_name="gnosis", keys=[key]
+        )
+        mock_importer.scan_directory.return_value = [service]
+
+        # Mock successful import
+        mock_importer.import_service.return_value = ImportResult(
+            success=True, message="Imported", imported_services=["gnosis:1"]
+        )
+
+        # Test with -y and providing password
+        result = runner.invoke(app, ["/tmp/test", "-y", "-p", "secret"])
+        assert result.exit_code == 0
+        assert "Imported services: gnosis:1" in result.output
+        assert "Summary" in result.output
+
+
+def test_get_safe_signers_edge_cases(plugin):
+    """Test _get_safe_signers with various failure scenarios."""
+    # 1. No RPC configured
+    with patch("iwa.core.settings.settings") as mock_settings:
+        mock_settings.gnosis_rpc = None
+        signers, exists = plugin._get_safe_signers("0x1", "gnosis")
+        assert signers is None
+        assert exists is None
+
+    # 2. Safe doesn't exist (raises exception)
+    with patch("iwa.core.settings.settings") as mock_settings:
+        mock_settings.gnosis_rpc = MagicMock()
+        with patch("safe_eth.eth.EthereumClient"), patch("safe_eth.safe.Safe") as mock_safe_cls:
+            mock_safe = mock_safe_cls.return_value
+            mock_safe.retrieve_owners.side_effect = Exception("Generic error")
+
+            signers, exists = plugin._get_safe_signers("0x1", "gnosis")
+            assert signers == []
+            assert exists is False
+
+    # 3. Success path
+    with patch("iwa.core.settings.settings") as mock_settings:
+        mock_settings.gnosis_rpc = MagicMock()
+        with patch("safe_eth.eth.EthereumClient"), patch("safe_eth.safe.Safe") as mock_safe_cls:
+            mock_safe = mock_safe_cls.return_value
+            mock_safe.retrieve_owners.return_value = ["0xAgent"]
+
+            signers, exists = plugin._get_safe_signers("0x1", "gnosis")
+            assert signers == ["0xAgent"]
+            assert exists is True
+
+
+def test_import_services_cli_abort(plugin, runner):
+    """Test import_services CLI aborting on confirmation."""
+    app = typer.Typer()
+    app.command()(plugin.import_services)
+
+    with patch("iwa.plugins.olas.importer.OlasServiceImporter") as mock_importer_cls:
+        mock_importer = mock_importer_cls.return_value
+        mock_importer.scan_directory.return_value = [
+            DiscoveredService(service_id=1, service_name="Test", chain_name="gnosis")
+        ]
+
+        # Simulate 'n' to confirmation prompt
+        result = runner.invoke(app, ["/tmp/test"], input="n\n")
+        assert result.exit_code == 0
+        assert "Aborted" in result.output
+        mock_importer.import_service.assert_not_called()
+
+
+def test_import_services_cli_no_services(plugin, runner):
+    """Test import_services CLI when no services are found."""
+    app = typer.Typer()
+    app.command()(plugin.import_services)
+
+    with patch("iwa.plugins.olas.importer.OlasServiceImporter") as mock_importer_cls:
+        mock_importer = mock_importer_cls.return_value
+        mock_importer.scan_directory.return_value = []
+
+        result = runner.invoke(app, ["/tmp/test"])
+        assert result.exit_code == 0
+        assert "No Olas services found" in result.output
+
+
+def test_import_services_cli_complex_display(plugin, runner):
+    """Test import_services CLI display logic with Safe verification and signer check."""
+    app = typer.Typer()
+    app.command()(plugin.import_services)
+
+    with (
+        patch("iwa.plugins.olas.importer.OlasServiceImporter") as mock_importer_cls,
+        patch.object(OlasPlugin, "_get_safe_signers") as mock_get_signers,
+    ):
+        mock_importer = mock_importer_cls.return_value
+        # 1. Service with valid Safe and agent is signer
+        key = DiscoveredKey(address="0xAgent", role="agent")
+        service = DiscoveredService(service_id=1, safe_address="0xSafe", keys=[key])
+        mock_importer.scan_directory.return_value = [service]
+
+        # Mock Safe exists with Agent as signer
+        mock_get_signers.return_value = (["0xAgent"], True)
+
+        result = runner.invoke(app, ["/tmp/test", "--dry-run"])
+        assert "0xSafe" in result.output
+        assert "✓" in result.output
+        assert "0xAgent 🔓 plaintext" in result.output  # Not a warning
+
+        # 2. Service where agent is NOT a signer
+        mock_get_signers.return_value = (["0xOther"], True)
+        result = runner.invoke(app, ["/tmp/test", "--dry-run"])
+        assert "NOT A SIGNER OF THE SAFE" in result.output
+
+
+def test_import_services_cli_password_prompt(plugin, runner):
+    """Test import_services CLI prompting for password."""
+    app = typer.Typer()
+    app.command()(plugin.import_services)
+
+    with patch("iwa.plugins.olas.importer.OlasServiceImporter") as mock_importer_cls:
+        mock_importer = mock_importer_cls.return_value
+        key = DiscoveredKey(address="0x1", is_encrypted=True, role="agent")
+        service = DiscoveredService(service_id=1, keys=[key])
+        mock_importer.scan_directory.return_value = [service]
+        mock_importer.import_service.return_value = ImportResult(success=True, message="OK")
+
+        # input="y\nsecret\n" -> 'y' for confirm import, 'secret' for password prompt
+        result = runner.invoke(app, ["/tmp/test"], input="y\nsecret\n")
+        assert result.exit_code == 0
+        assert "password" in result.output.lower()
+        mock_importer.import_service.assert_called_with(service, "secret")

iwa/plugins/olas/tests/test_service_lifecycle.py

@@ -0,0 +1,150 @@
+"""Tests for Olas service lifecycle: create, activate, register, deploy."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from iwa.plugins.olas.contracts.service import ServiceState
+from iwa.plugins.olas.importer import DiscoveredKey, DiscoveredService, OlasServiceImporter
+from iwa.plugins.olas.models import OlasConfig, Service
+from iwa.plugins.olas.service_manager import ServiceManager
+
+
+@pytest.fixture
+def mock_wallet():
+    """Mock wallet with master account."""
+    w = MagicMock()
+    w.master_account.address = "0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB"
+    return w
+
+
+@pytest.fixture
+def sm(mock_wallet):
+    """ServiceManager fixture."""
+    with (
+        patch("iwa.core.models.Config"),
+        patch("iwa.core.contracts.contract.ChainInterfaces") as mock_ci,
+    ):
+        mock_ci.get_instance.return_value.get.return_value.chain.get_token_address.side_effect = (
+            lambda x: x
+        )
+        return ServiceManager(mock_wallet)
+
+
+@pytest.fixture
+def importer(mock_wallet):
+    """OlasServiceImporter fixture."""
+    with patch("iwa.core.models.Config"):
+        return OlasServiceImporter(mock_wallet)
+
+
+# --- ServiceManager Edge Cases ---
+
+
+def test_sm_create_utility_not_found(sm):
+    """Target service_manager.py:203 (utility not found)."""
+    with patch("iwa.plugins.olas.constants.OLAS_CONTRACTS", {"gnosis": {}}):
+        sm.wallet.sign_and_send_transaction.return_value = (True, {"status": 1})
+        # Mocking registry.extract_events which is what sm.create now uses
+        sm.registry.extract_events = MagicMock(
+            return_value=[{"name": "CreateService", "args": {"serviceId": 42}}]
+        )
+
+        sid = sm.create("gnosis", "test")
+        assert sid == 42
+
+
+def test_sm_create_approve_fail(sm):
+    """Target service_manager.py:217 (approve fail)."""
+    sm.wallet.sign_and_send_transaction.return_value = (True, {"status": 1})
+    sm.registry.extract_events = MagicMock(
+        return_value=[{"name": "CreateService", "args": {"serviceId": 42}}]
+    )
+
+    sm.transfer_service.approve_erc20.return_value = False
+    sid = sm.create(
+        "gnosis", "test", token_address_or_tag="0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB"
+    )
+    assert sid == 42
+
+
+def test_sm_activate_not_preregistration(sm):
+    """Target service_manager.py:228 (state mismatch)."""
+    sm.service = Service(service_name="t", chain_name="gnosis", service_id=1)
+    sm.registry = MagicMock()
+    sm.registry.get_service.return_value = {"state": ServiceState.DEPLOYED}
+    success = sm.activate_registration()
+    assert success is False
+
+
+def test_sm_checkpoint_check_exception(sm):
+    """Target service_manager.py:597 (checkpoint check exception)."""
+    with patch("iwa.plugins.olas.contracts.staking.StakingContract") as mock_stk_cls:
+        mock_stk = mock_stk_cls.return_value
+        mock_stk.is_checkpoint_needed.side_effect = Exception("error")
+        success = sm.call_checkpoint("gnosis")
+        assert success is False
+
+
+def test_sm_stake_fail(sm):
+    """Target service_manager.py:690 (stake fail)."""
+    addr = "0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB"
+    sm.service = Service(service_name="t", chain_name="gnosis", service_id=1)
+    sm.registry = MagicMock()
+    sm.registry.get_service.return_value = {"state": ServiceState.DEPLOYED, "security_deposit": 1}
+    sm.transfer_service.approve_erc20.return_value = True
+    sm.wallet.sign_and_send_transaction.return_value = (False, None)
+
+    with (
+        patch("iwa.plugins.olas.contracts.staking.StakingContract") as mock_stk_cls,
+        patch("iwa.plugins.olas.service_manager.staking.ERC20Contract"),
+    ):
+        mock_stk = mock_stk_cls.return_value
+        mock_stk.get_service_info.return_value = {"staking_state": 1}
+        mock_stk.staking_token_address = addr
+        mock_stk.get_requirements.return_value = {
+            "staking_token": addr,
+            "min_staking_deposit": 50000000000000000000,
+            "num_agent_instances": 1,
+            "required_agent_bond": 50000000000000000000,
+        }
+        success = sm.stake(mock_stk)
+        assert success is False
+
+
+# --- Importer Edge Cases ---
+
+
+def test_importer_encrypted_no_pwd(importer):
+    """Target importer.py:192 (encrypted key without password)."""
+    addr = "0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB"
+    key = DiscoveredKey(address=addr, is_encrypted=True, encrypted_keystore={"crypto": {}})
+    importer.key_storage.find_stored_account.return_value = None
+    success, msg = importer._import_key(key, "service", password=None)
+    assert success is False
+    assert "password" in msg
+
+
+def test_importer_safe_duplicate(importer):
+    """Target importer.py:308 (duplicate safe)."""
+    addr = "0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB"
+    service = DiscoveredService(service_id=1, chain_name="gnosis", safe_address=addr)
+    importer.key_storage.find_stored_account.return_value = MagicMock()
+    success, msg = importer._import_safe(service)
+    assert success is False
+    assert msg == "duplicate"
+
+
+def test_olas_config_remove_not_exists():
+    """Target models.py:85-88 (remove service not exists)."""
+    config = OlasConfig()
+    assert config.remove_service("not:exists") is False
+
+
+def test_olas_config_get_service_by_multisig():
+    """Target models.py:106-110 (get by multisig)."""
+    addr = "0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB"
+    s = Service(service_name="t", chain_name="g", service_id=1, multisig_address=addr)
+    config = OlasConfig(services={"g:1": s})
+    assert config.get_service_by_multisig(addr) == s
+    assert config.get_service_by_multisig("0x0000000000000000000000000000000000000000") is None