add parallel entity creation testing

Author: Matthias Zimmermann

.env.testing

@@ -7,6 +7,43 @@ WS_URL=wss://kaolin.hoodi.arkiv.network/rpc/ws
 
 # External Wallet Configuration (required when using external node)
 WALLET_FILE_1=wallet_alice.json
-WALLET_PASSWORD_1=s3cret
 WALLET_FILE_2=wallet_bob.json
+WALLET_FILE_3=wallet_3.json
+WALLET_FILE_4=wallet_4.json
+WALLET_FILE_5=wallet_5.json
+WALLET_FILE_6=wallet_6.json
+WALLET_FILE_7=wallet_7.json
+WALLET_FILE_8=wallet_8.json
+WALLET_FILE_9=wallet_9.json
+WALLET_FILE_10=wallet_10.json
+WALLET_FILE_11=wallet_11.json
+WALLET_FILE_12=wallet_12.json
+WALLET_FILE_13=wallet_13.json
+WALLET_FILE_14=wallet_14.json
+WALLET_FILE_15=wallet_15.json
+WALLET_FILE_16=wallet_16.json
+WALLET_FILE_17=wallet_17.json
+WALLET_FILE_18=wallet_18.json
+WALLET_FILE_19=wallet_19.json
+WALLET_FILE_20=wallet_20.json
+
+WALLET_PASSWORD_1=s3cret
 WALLET_PASSWORD_2=s3cret
+WALLET_PASSWORD_3=s3cret
+WALLET_PASSWORD_4=s3cret
+WALLET_PASSWORD_5=s3cret
+WALLET_PASSWORD_6=s3cret
+WALLET_PASSWORD_7=s3cret
+WALLET_PASSWORD_8=s3cret
+WALLET_PASSWORD_9=s3cret
+WALLET_PASSWORD_10=s3cret
+WALLET_PASSWORD_11=s3cret
+WALLET_PASSWORD_12=s3cret
+WALLET_PASSWORD_13=s3cret
+WALLET_PASSWORD_14=s3cret
+WALLET_PASSWORD_15=s3cret
+WALLET_PASSWORD_16=s3cret
+WALLET_PASSWORD_17=s3cret
+WALLET_PASSWORD_18=s3cret
+WALLET_PASSWORD_19=s3cret
+WALLET_PASSWORD_20=s3cret

README.md

@@ -114,6 +114,28 @@ SDK versions are tracked in the following files:
 - `pyproject.toml`
 - `uv.lock`
 
+### Testing
+
+Pytest is used for unit and integration testing.
+```bash
+uv run pytest # Run all tests
+uv run pytest -k test_create_entity_simple --log-cli-level=INFO # Specific tests via keyword, print at info log level
+```
+
+If an `.env` file is present the unit tests are run against the specifice RPC coordinates and test accounts.
+An example wallet file is provided in `.env.testing`
+Make sure that the specified test accounts are properly funded before running the tests.
+
+Otherwise, the tests are run against a testcontainer containing an Arkiv RPC Node.
+Test accounts are created on the fly and using the CLI inside the local RPC Nonde.
+
+Account wallets for such tests can be created via the command shown below.
+The provided example creates the wallet file `wallet_alice.json` using the password provided during the execution of the command.
+
+```bash
+uv run python uv run python -m arkiv.account alice
+```
+
 ### Code Quality
 
 This project uses comprehensive unit testing, linting and type checking to maintain high code quality:

src/arkiv/account.py

@@ -1,6 +1,9 @@
 """Account management for Arkiv client."""
 
+import getpass
 import json
+import sys
+from pathlib import Path
 from typing import Any
 
 from eth_account import Account
@@ -147,3 +150,38 @@ def _check_and_trim(self, name: str) -> str:
         if name is None or len(name.strip()) == 0:
             raise AccountNameException("Account name must be a non-empty string.")
         return name.strip()
+
+
+def main() -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Create a new named account and write a JSON wallet file."
+    )
+    parser.add_argument("name", help="Name of the account (used in wallet_<name>.json)")
+    args = parser.parse_args()
+
+    # Sanitize name for filename (alphanumeric, dash, underscore only)
+    import re
+
+    account_name = re.sub(r"[^a-zA-Z0-9_-]", "_", args.name.strip())
+    wallet_path = Path(f"wallet_{account_name}.json")
+
+    if wallet_path.exists():
+        print(f'File "{wallet_path}" already exists. Aborting.')
+        sys.exit(1)
+
+    account = NamedAccount(account_name, Account.create())
+    password = getpass.getpass("Enter wallet password: ")
+    encrypted = account.local_account.encrypt(password)
+
+    with wallet_path.open("w") as f:
+        json.dump(encrypted, f)
+
+    print(f"Named account: {account}")
+    print(f"Wallet file: {wallet_path}")
+
+
+# add main entry point
+if __name__ == "__main__":
+    main()

src/arkiv/module.py

@@ -43,12 +43,12 @@ def __init__(self, client: "Arkiv") -> None:
         # Attach custom Arkiv RPC methods to the eth object
         self.client.eth.attach_methods(FUNCTIONS_ABI)
         for method_name in FUNCTIONS_ABI.keys():
-            logger.info(f"Custom RPC method: eth.{method_name}")
+            logger.debug(f"Custom RPC method: eth.{method_name}")
 
         # Create contract instance for events (using EVENTS_ABI)
         self.contract = client.eth.contract(address=STORAGE_ADDRESS, abi=EVENTS_ABI)
         for event in self.contract.all_events():
-            logger.info(f"Entity event {event.topic}: {event.signature}")
+            logger.debug(f"Entity event {event.topic}: {event.signature}")
 
     def is_available(self) -> bool:
         """Check if Arkiv functionality is available."""
@@ -167,12 +167,12 @@ def _get_storage_value(self, entity_key: EntityKey) -> bytes:
         """Get the storage value stored in the given entity."""
         # EntityKey is automatically converted by arkiv_munger
         storage_value = base64.b64decode(self.client.eth.get_storage_value(entity_key))  # type: ignore[attr-defined]
-        logger.info(f"Storage value (decoded): {storage_value!r}")
+        logger.debug(f"Storage value (decoded): {storage_value!r}")
         return storage_value
 
     def _get_entity_metadata(self, entity_key: EntityKey) -> dict[str, Any]:
         """Get the metadata of the given entity."""
         # EntityKey is automatically converted by arkiv_munger
         metadata: dict[str, Any] = self.client.eth.get_entity_metadata(entity_key)  # type: ignore[attr-defined]
-        logger.info(f"Raw metadata: {metadata}")
+        logger.debug(f"Raw metadata: {metadata}")
         return metadata

tests/conftest.py

@@ -15,8 +15,9 @@
 
 from arkiv import Arkiv
 from arkiv.account import NamedAccount
+from tests.node_container import create_container_node
 
-from .node_container import create_container_node
+from .utils import create_account
 
 # Environment variable names for external node configuration
 RPC_URL_ENV = "RPC_URL"
@@ -132,65 +133,11 @@ def arkiv_client_http(
 def account_1(arkiv_node: tuple[DockerContainer | None, str, str]) -> NamedAccount:
     """Provide the first (alice) account."""
     container, _, _ = arkiv_node
-    return _create_account(1, ALICE, container)
+    return create_account(1, ALICE, container)
 
 
 @pytest.fixture(scope="session")
 def account_2(arkiv_node: tuple[DockerContainer | None, str, str]) -> NamedAccount:
     """Provide the second (bob) account."""
     container, _, _ = arkiv_node
-    return _create_account(2, BOB, container)
-
-
-def _create_account(
-    index: int, name: str, container: DockerContainer | None
-) -> NamedAccount:
-    """Create a named account from env vars or generate a new one."""
-    wallet_file = os.getenv(f"{WALLET_FILE_ENV_PREFIX}_{index}")
-    wallet_password = os.getenv(f"{WALLET_PASSWORD_ENV_PREFIX}_{index}")
-
-    if not wallet_file or not wallet_password:
-        account = NamedAccount.create(name)
-        if type(container) is DockerContainer:
-            _fund_account(container, account)
-
-        return account
-
-    wallet_json = _load_wallet_json(wallet_file)
-    return NamedAccount.from_wallet(name, wallet_json, wallet_password)
-
-
-def _load_wallet_json(wallet_file: str) -> str:
-    """Load account from encrypted wallet file."""
-    wallet_path = Path(wallet_file)
-
-    if not wallet_path.exists():
-        raise FileNotFoundError(f"Wallet file not found: {wallet_file}")
-
-    with wallet_path.open() as f:
-        wallet_json = f.read()
-
-    return wallet_json
-
-
-def _fund_account(arkivContainer: DockerContainer, account: NamedAccount) -> None:
-    """Fixture to create and fund a test account in the Arkiv node."""
-    # Get the private key (as hex)
-    acct_address = account.address
-    acct_private_key = account.key.hex()
-
-    # Import account inside the container
-    exit_code, output = arkivContainer.exec(
-        ["golembase", "account", "import", "--key", acct_private_key]
-    )
-    assert exit_code == 0, f"Account import failed: {output.decode()}"
-
-    # Fund account inside the container
-    exit_code, output = arkivContainer.exec(["golembase", "account", "fund"])
-    assert exit_code == 0, f"Account funding failed: {output.decode()}"
-    logger.info(f"Imported and funded account: {acct_address}")
-
-    # Printing account balance
-    exit_code, output = arkivContainer.exec(["golembase", "account", "balance"])
-    assert exit_code == 0, f"Account balance check failed: {output.decode()}"
-    logger.info(f"Account balance: {output.decode().strip()}, exit_code: {exit_code}")
+    return create_account(2, BOB, container)

tests/test_entity_create.py

@@ -38,7 +38,7 @@ def check_tx_hash(label: str, tx_hash: HexBytes) -> None:
 class TestEntityCreate:
     """Test cases for create_entity function."""
 
-    def test_create_entity_with_payload_web3(self, arkiv_client_http: Arkiv) -> None:
+    def test_create_entity_via_web3(self, arkiv_client_http: Arkiv) -> None:
         """Test create_entity with custom payload checking against Web3 client behavior."""
         payload = b"Hello world!"
         annotations: dict[str, str | int] = {"type": "Greeting", "version": 1}
@@ -150,7 +150,7 @@ def test_create_entity_with_payload_web3(self, arkiv_client_http: Arkiv) -> None
             "Entity expiration block should be in the future"
         )
 
-    def test_create_entity(self, arkiv_client_http: Arkiv) -> None:
+    def test_create_entity_simple(self, arkiv_client_http: Arkiv) -> None:
         """Test create_entity."""
         pl: bytes = b"Hello world!"
         ann: dict[str, str | int] = {"type": "Greeting", "version": 1}