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

tests/test_main.py

@@ -0,0 +1,13 @@
+import runpy
+import sys
+from unittest.mock import patch
+
+
+def test_main_execution():
+    """Test that python -m iwa executes the CLI."""
+    # We mock iwa.core.cli.iwa_cli to verify it gets called
+    with patch("iwa.core.cli.iwa_cli") as mock_cli:
+        # We also need to mock sys.argv to avoid interfering with pytest args
+        with patch.object(sys, "argv", ["iwa"]):
+            runpy.run_module("iwa", run_name="__main__")
+            mock_cli.assert_called_once()

tests/test_mnemonic.py

@@ -0,0 +1,217 @@
+import base64
+import json
+from pathlib import Path
+from unittest.mock import mock_open, patch
+
+import pytest
+from cryptography.exceptions import InvalidTag
+
+from iwa.core.mnemonic import (
+    WALLET_PATH,
+    EncryptedMnemonic,
+    MnemonicManager,
+    MnemonicStorage,
+)
+
+
+@pytest.fixture
+def mock_scrypt():
+    with patch("iwa.core.mnemonic.Scrypt") as mock:
+        mock.return_value.derive.return_value = b"derived_key"
+        yield mock
+
+
+@pytest.fixture
+def mock_aesgcm():
+    with patch("iwa.core.mnemonic.AESGCM") as mock:
+        mock.return_value.encrypt.return_value = b"ciphertext"
+        mock.return_value.decrypt.return_value = b"plaintext"
+        yield mock
+
+
+@pytest.fixture
+def mock_bip39_generator():
+    with patch("iwa.core.mnemonic.Bip39MnemonicGenerator") as mock:
+        mock.return_value.FromWordsNumber.return_value.ToStr.return_value = "word1 word2 word3"
+        yield mock
+
+
+@pytest.fixture
+def mock_bip39_seed_generator():
+    with patch("iwa.core.mnemonic.Bip39SeedGenerator") as mock:
+        mock.return_value.Generate.return_value = b"seed"
+        yield mock
+
+
+@pytest.fixture
+def mock_bip44():
+    with patch("iwa.core.mnemonic.Bip44") as mock:
+        mock.FromSeed.return_value.Purpose.return_value.Coin.return_value.Account.return_value.Change.return_value.AddressIndex.return_value.PrivateKey.return_value.Raw.return_value.ToHex.return_value = "1234"
+        yield mock
+
+
+@pytest.fixture
+def mock_console():
+    with patch("iwa.core.mnemonic.Console") as mock:
+        yield mock.return_value
+
+
+def test_encrypted_mnemonic_derive_key(mock_scrypt):
+    em = EncryptedMnemonic(kdf_salt="salt", nonce="nonce", ciphertext="ciphertext")
+    key = em.derive_key(b"password")
+    assert key == b"derived_key"
+    mock_scrypt.assert_called_once()
+
+
+def test_encrypted_mnemonic_decrypt_success(mock_scrypt, mock_aesgcm):
+    em = EncryptedMnemonic(
+        kdf_salt=base64.b64encode(b"salt").decode(),
+        nonce=base64.b64encode(b"nonce").decode(),
+        ciphertext=base64.b64encode(b"ciphertext").decode(),
+    )
+    plaintext = em.decrypt("password")
+    assert plaintext == "plaintext"
+
+
+def test_encrypted_mnemonic_decrypt_unsupported_kdf():
+    em = EncryptedMnemonic(
+        kdf="unsupported", kdf_salt="salt", nonce="nonce", ciphertext="ciphertext"
+    )
+    with pytest.raises(ValueError, match="Unsupported kdf"):
+        em.decrypt("password")
+
+
+def test_encrypted_mnemonic_decrypt_unsupported_cipher():
+    em = EncryptedMnemonic(
+        cypher="unsupported", kdf_salt="salt", nonce="nonce", ciphertext="ciphertext"
+    )
+    with pytest.raises(ValueError, match="Unsupported cipher"):
+        em.decrypt("password")
+
+
+def test_encrypted_mnemonic_encrypt(mock_scrypt, mock_aesgcm):
+    with patch("os.urandom", return_value=b"random"):
+        data = EncryptedMnemonic.encrypt("mnemonic", "password")
+        assert data["kdf"] == "scrypt"
+        assert data["cipher"] == "aesgcm"
+        assert data["ciphertext"] == base64.b64encode(b"ciphertext").decode()
+
+
+def test_mnemonic_storage_load():
+    data = {
+        "encrypted_mnemonic": {"kdf_salt": "salt", "nonce": "nonce", "ciphertext": "ciphertext"},
+        "accounts": {},
+    }
+    with patch("builtins.open", mock_open(read_data=json.dumps(data))):
+        storage = MnemonicStorage.load(Path("test.json"))
+        assert isinstance(storage.encrypted_mnemonic, EncryptedMnemonic)
+
+
+def test_mnemonic_storage_save():
+    storage = MnemonicStorage(
+        encrypted_mnemonic=EncryptedMnemonic(
+            kdf_salt="salt", nonce="nonce", ciphertext="ciphertext"
+        )
+    )
+    with patch("builtins.open", mock_open()) as mock_file, patch("os.chmod") as mock_chmod:
+        storage.save(Path("test.json"))
+        mock_file.assert_called_once()
+        mock_chmod.assert_called_once()
+
+
+def test_mnemonic_manager_init():
+    mgr = MnemonicManager()
+    assert mgr.mnemonic_file == WALLET_PATH
+
+
+def test_mnemonic_manager_derive_key(mock_scrypt):
+    mgr = MnemonicManager()
+    key = mgr.derive_key(b"password", b"salt")
+    assert key == b"derived_key"
+
+
+def test_mnemonic_manager_encrypt_mnemonic(mock_scrypt, mock_aesgcm):
+    mgr = MnemonicManager()
+    with patch("os.urandom", return_value=b"random"):
+        data = mgr.encrypt_mnemonic("mnemonic", "password")
+        assert data["kdf"] == "scrypt"
+        assert data["cipher"] == "aesgcm"
+
+
+def test_mnemonic_manager_decrypt_mnemonic_success(mock_scrypt, mock_aesgcm):
+    mgr = MnemonicManager()
+    encobj = {
+        "kdf": "scrypt",
+        "kdf_salt": base64.b64encode(b"salt").decode(),
+        "nonce": base64.b64encode(b"nonce").decode(),
+        "ciphertext": base64.b64encode(b"ciphertext").decode(),
+        "cipher": "aesgcm",
+    }
+    plaintext = mgr.decrypt_mnemonic(encobj, "password")
+    assert plaintext == "plaintext"
+
+
+def test_mnemonic_manager_decrypt_mnemonic_unsupported_kdf():
+    mgr = MnemonicManager()
+    encobj = {"kdf": "unsupported"}
+    with pytest.raises(ValueError, match="Unsupported kdf"):
+        mgr.decrypt_mnemonic(encobj, "password")
+
+
+def test_mnemonic_manager_decrypt_mnemonic_unsupported_cipher():
+    mgr = MnemonicManager()
+    encobj = {"kdf": "scrypt", "cipher": "unsupported"}
+    with pytest.raises(ValueError, match="Unsupported cipher"):
+        mgr.decrypt_mnemonic(encobj, "password")
+
+
+def test_mnemonic_manager_generate_and_store_mnemonic(
+    mock_bip39_generator, mock_scrypt, mock_aesgcm
+):
+    mgr = MnemonicManager()
+    with patch("builtins.open", mock_open()) as mock_file, patch("os.chmod") as mock_chmod:
+        mnemonic = mgr.generate_and_store_mnemonic("password", "test.json")
+        mock_file.assert_called_once()
+        mock_chmod.assert_called_once()
+        assert mnemonic == "word1 word2 word3"
+
+
+def test_mnemonic_manager_load_and_decrypt_mnemonic_invalid_tag(mock_scrypt, mock_aesgcm):
+    mgr = MnemonicManager()
+    mock_aesgcm.return_value.decrypt.side_effect = InvalidTag()
+    encobj = {
+        "kdf": "scrypt",
+        "kdf_salt": base64.b64encode(b"salt").decode(),
+        "nonce": base64.b64encode(b"nonce").decode(),
+        "ciphertext": base64.b64encode(b"ciphertext").decode(),
+        "cipher": "aesgcm",
+    }
+    with patch("builtins.open", mock_open(read_data=json.dumps(encobj))):
+        with pytest.raises(ValueError, match="Incorrect password"):
+            mgr.load_and_decrypt_mnemonic("password", "test.json")
+
+
+def test_mnemonic_manager_derive_eth_accounts_from_mnemonic(
+    mock_scrypt, mock_aesgcm, mock_bip39_seed_generator, mock_bip44
+):
+    mgr = MnemonicManager()
+    # Mock load_and_decrypt_mnemonic to return a mnemonic
+    with (
+        patch.object(mgr, "load_and_decrypt_mnemonic", return_value="mnemonic"),
+        patch("iwa.core.mnemonic.Account") as mock_account,
+    ):
+        mock_account.from_key.return_value.address = "0xAddress"
+
+        accounts = mgr.derive_eth_accounts_from_mnemonic("password", n_accounts=1)
+        assert len(accounts) == 1
+        assert accounts[0]["address"] == "0xAddress"
+        assert accounts[0]["private_key_hex"] == "1234"
+
+
+def test_mnemonic_manager_derive_eth_accounts_from_mnemonic_none(mock_scrypt, mock_aesgcm):
+    mgr = MnemonicManager()
+    with (
+        patch.object(mgr, "load_and_decrypt_mnemonic", return_value=None),
+    ):
+        accounts = mgr.derive_eth_accounts_from_mnemonic("password")
+        assert accounts is None

tests/test_modals.py

@@ -0,0 +1,109 @@
+"""Tests for TUI modals to boost coverage."""
+
+import pytest
+from textual.app import App, ComposeResult
+from textual.containers import Container
+
+# === Modal compose tests - these test the UI rendering paths ===
+
+
+@pytest.mark.asyncio
+async def test_create_eoa_modal_compose():
+    """Cover CreateEOAModal.compose (lines 56-64)."""
+    from iwa.tui.modals.base import CreateEOAModal
+
+    modal = CreateEOAModal()
+
+    class TestApp(App):
+        def compose(self) -> ComposeResult:
+            yield Container()
+
+    app = TestApp()
+    async with app.run_test() as pilot:
+        app.push_screen(modal)
+        await pilot.pause()
+
+        # Verify modal is mounted
+        assert modal.is_mounted
+
+
+@pytest.mark.asyncio
+async def test_create_safe_modal_compose():
+    """Cover CreateSafeModal.compose (lines 128-149)."""
+    from iwa.tui.modals.base import CreateSafeModal
+
+    accounts = [("wallet1", "0x123"), ("wallet2", "0x456")]
+    modal = CreateSafeModal(existing_accounts=accounts)
+
+    class TestApp(App):
+        def compose(self) -> ComposeResult:
+            yield Container()
+
+    app = TestApp()
+    async with app.run_test() as pilot:
+        app.push_screen(modal)
+        await pilot.pause()
+
+        assert modal.is_mounted
+
+
+@pytest.mark.asyncio
+async def test_stake_service_modal_compose():
+    """Cover StakeServiceModal.compose (lines 205-214)."""
+    from iwa.tui.modals.base import StakeServiceModal
+
+    contracts = [("Contract1", "0xabc"), ("Contract2", "0xdef")]
+    modal = StakeServiceModal(contracts=contracts)
+
+    class TestApp(App):
+        def compose(self) -> ComposeResult:
+            yield Container()
+
+    app = TestApp()
+    async with app.run_test() as pilot:
+        app.push_screen(modal)
+        await pilot.pause()
+
+        assert modal.is_mounted
+
+
+@pytest.mark.asyncio
+async def test_create_service_modal_compose():
+    """Cover CreateServiceModal.compose (lines 280-303)."""
+    from iwa.tui.modals.base import CreateServiceModal
+
+    chains = ["gnosis", "ethereum"]
+    staking_contracts = [("Staking1", "0xabc")]
+    modal = CreateServiceModal(
+        chains=chains, default_chain="gnosis", staking_contracts=staking_contracts
+    )
+
+    class TestApp(App):
+        def compose(self) -> ComposeResult:
+            yield Container()
+
+    app = TestApp()
+    async with app.run_test() as pilot:
+        app.push_screen(modal)
+        await pilot.pause()
+
+        assert modal.is_mounted
+
+
+@pytest.mark.asyncio
+async def test_fund_service_modal_compose():
+    """Cover FundServiceModal.compose (lines 371-382)."""
+    from iwa.tui.modals.base import FundServiceModal
+
+    modal = FundServiceModal(service_key="gnosis:1", native_symbol="xDAI")
+
+    class TestApp(App):
+        def compose(self) -> ComposeResult:
+            yield Container()
+
+    app = TestApp()
+    async with app.run_test() as pilot:
+        app.push_screen(modal)
+        await pilot.pause()
+
+        assert modal.is_mounted

tests/test_models.py

@@ -0,0 +1,213 @@
+from pathlib import Path
+from unittest.mock import mock_open, patch
+
+import pytest
+
+from iwa.core.models import EthereumAddress, StorableModel
+
+
+def test_ethereum_address_valid():
+    addr_str = "0x1111111111111111111111111111111111111111"
+    addr = EthereumAddress(addr_str)
+    assert addr == addr_str
+
+
+def test_ethereum_address_invalid():
+    with pytest.raises(ValueError, match="Invalid Ethereum address"):
+        EthereumAddress("0xInvalid")
+
+
+def test_ethereum_address_checksum():
+    # Test that it converts to checksum address
+    addr_lower = "0x1111111111111111111111111111111111111111"  # All 1s is same
+    # Let's use one that changes
+    addr_lower = "0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed"
+    addr_checksum = "0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed"
+    addr = EthereumAddress(addr_lower)
+    assert addr == addr_checksum
+
+
+class MockStorableModel(StorableModel):
+    name: str
+    value: int
+
+
+def test_storable_model_save_json():
+    model = MockStorableModel(name="test", value=123)
+    with patch("pathlib.Path.open", mock_open()) as mock_file:
+        model.save_json(Path("test.json"))
+        mock_file.assert_called_once()
+
+
+def test_storable_model_save_toml():
+    model = MockStorableModel(name="test", value=123)
+    with patch("pathlib.Path.open", mock_open()) as mock_file:
+        model.save_toml(Path("test.toml"))
+        mock_file.assert_called_once()
+
+
+def test_storable_model_save_yaml():
+    model = MockStorableModel(name="test", value=123)
+    with patch("pathlib.Path.open", mock_open()) as mock_file:
+        model.save_yaml(Path("test.yaml"))
+        mock_file.assert_called_once()
+
+
+def test_storable_model_save_auto_json():
+    model = MockStorableModel(name="test", value=123)
+    with patch("pathlib.Path.open", mock_open()) as mock_file:
+        model.save("test.json")
+        mock_file.assert_called_once()
+
+
+def test_storable_model_save_auto_toml():
+    model = MockStorableModel(name="test", value=123)
+    with patch("pathlib.Path.open", mock_open()) as mock_file:
+        model.save("test.toml")
+        mock_file.assert_called_once()
+
+
+def test_storable_model_save_auto_yaml():
+    model = MockStorableModel(name="test", value=123)
+    with patch("pathlib.Path.open", mock_open()) as mock_file:
+        model.save("test.yaml")
+        mock_file.assert_called_once()
+
+
+def test_storable_model_save_no_path():
+    model = MockStorableModel(name="test", value=123)
+    with pytest.raises(ValueError, match="Save path not specified"):
+        model.save()
+
+
+def test_storable_model_save_stored_path():
+    model = MockStorableModel(name="test", value=123)
+    model._path = Path("stored.json")
+    model._storage_format = "json"
+    with patch("pathlib.Path.open", mock_open()) as mock_file:
+        model.save()
+        mock_file.assert_called_once()
+
+
+def test_storable_model_load_json():
+    json_content = '{"name": "test", "value": 123}'
+    with patch("pathlib.Path.open", mock_open(read_data=json_content)):
+        model = MockStorableModel.load_json("test.json")
+        assert model.name == "test"
+        assert model.value == 123
+
+
+def test_storable_model_load_toml():
+    toml_content = b'name = "test"\nvalue = 123'
+    with patch("pathlib.Path.open", mock_open(read_data=toml_content)):
+        model = MockStorableModel.load_toml("test.toml")
+        assert model.name == "test"
+        assert model.value == 123
+
+
+def test_storable_model_load_yaml():
+    yaml_content = "name: test\nvalue: 123"
+    with patch("pathlib.Path.open", mock_open(read_data=yaml_content)):
+        model = MockStorableModel.load_yaml("test.yaml")
+        assert model.name == "test"
+        assert model.value == 123
+
+
+def test_storable_model_load_auto():
+    json_content = '{"name": "test", "value": 123}'
+    with patch("pathlib.Path.open", mock_open(read_data=json_content)):
+        model = MockStorableModel.load(Path("test.json"))
+        assert model.name == "test"
+
+
+def test_ethereum_address_validate_method():
+    # Test the validate class method directly
+    with pytest.raises(ValueError, match="Invalid Ethereum address"):
+        EthereumAddress.validate("0xInvalid", None)
+
+    addr = EthereumAddress.validate("0x1111111111111111111111111111111111111111", None)
+    assert addr == "0x1111111111111111111111111111111111111111"
+
+
+def test_storable_model_save_methods_no_path_error():
+    model = MockStorableModel(name="test", value=123)
+    # Ensure no _path is set
+    if hasattr(model, "_path"):
+        del model._path
+
+    with pytest.raises(ValueError, match="Save path not specified"):
+        model.save_json()
+
+    with pytest.raises(ValueError, match="Save path not specified"):
+        model.save_toml()
+
+    with pytest.raises(ValueError, match="Save path not specified"):
+        model.save_yaml()
+
+
+def test_storable_model_save_unsupported_extension():
+    model = MockStorableModel(name="test", value=123)
+    with pytest.raises(ValueError, match="Extension not supported"):
+        model.save("test.txt")
+
+
+def test_storable_model_save_fallback_format():
+    model = MockStorableModel(name="test", value=123)
+    model._storage_format = "json"
+    with patch("pathlib.Path.open", mock_open()) as mock_file:
+        model.save("test.txt")  # Unknown extension, fallback to _storage_format
+        mock_file.assert_called_once()  # Should call save_json
+
+    model._storage_format = "toml"
+    with patch("pathlib.Path.open", mock_open()) as mock_file:
+        model.save("test.txt")
+        mock_file.assert_called_once()  # Should call save_toml
+
+    model._storage_format = "yaml"
+    with patch("pathlib.Path.open", mock_open()) as mock_file:
+        model.save("test.txt")
+        mock_file.assert_called_once()  # Should call save_yaml
+
+
+def test_storable_model_load_unsupported_extension():
+    with pytest.raises(ValueError, match="Unsupported file extension"):
+        MockStorableModel.load(Path("test.txt"))
+
+
+from iwa.core.models import Config
+
+
+def test_config_singleton():
+    c1 = Config()
+    c2 = Config()
+    assert c1 is c2
+
+
+def test_storable_model_save_with_stored_path():
+    model = MockStorableModel(name="test", value=123)
+    model._path = Path("stored.json")
+    with patch("pathlib.Path.open", mock_open()) as mock_file:
+        model.save_json()
+        mock_file.assert_called_once()
+
+    model._path = Path("stored.toml")
+    with patch("pathlib.Path.open", mock_open()) as mock_file:
+        model.save_toml()
+        mock_file.assert_called_once()
+
+    model._path = Path("stored.yaml")
+    with patch("pathlib.Path.open", mock_open()) as mock_file:
+        model.save_yaml()
+        mock_file.assert_called_once()
+
+
+def test_storable_model_load_auto_toml_yaml():
+    toml_content = b'name = "test"\nvalue = 123'
+    with patch("pathlib.Path.open", mock_open(read_data=toml_content)):
+        model = MockStorableModel.load(Path("test.toml"))
+        assert model.name == "test"
+
+    yaml_content = "name: test\nvalue: 123"
+    with patch("pathlib.Path.open", mock_open(read_data=yaml_content)):
+        model = MockStorableModel.load(Path("test.yaml"))
+        assert model.name == "test"