genlayer-test 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

gltest_cli/config/plugin.py

@@ -0,0 +1,102 @@
+from pathlib import Path
+from gltest_cli.logging import logger
+from gltest_cli.config.user import (
+    user_config_exists,
+    load_user_config,
+    get_default_user_config,
+)
+from gltest_cli.config.general import (
+    get_general_config,
+)
+from gltest_cli.config.types import PluginConfig
+
+
+def pytest_addoption(parser):
+    group = parser.getgroup("gltest")
+    group.addoption(
+        "--contracts-dir",
+        action="store",
+        default=None,
+        help="Path to directory containing contract files",
+    )
+
+    group.addoption(
+        "--default-wait-interval",
+        action="store",
+        default=10000,
+        help="Default interval (ms) between transaction receipt checks",
+    )
+
+    group.addoption(
+        "--default-wait-retries",
+        action="store",
+        default=15,
+        help="Default number of retries for transaction receipt checks",
+    )
+
+    group.addoption(
+        "--rpc-url",
+        action="store",
+        default=None,
+        help="RPC endpoint URL for the GenLayer network",
+    )
+
+    group.addoption(
+        "--network",
+        action="store",
+        default=None,
+        help="Target network (defaults to 'localnet' if no config file)",
+    )
+
+
+def pytest_configure(config):
+    general_config = get_general_config()
+
+    # Handle user config from gltest.config.yaml
+    if not user_config_exists():
+        logger.warning(
+            "File `gltest.config.yaml` not found in the current directory, using default config"
+        )
+        logger.info("Create a `gltest.config.yaml` file to manage multiple networks")
+        user_config = get_default_user_config()
+    else:
+        logger.info(
+            "File `gltest.config.yaml` found in the current directory, using it"
+        )
+        user_config = load_user_config("gltest.config.yaml")
+
+    general_config.user_config = user_config
+
+    # Handle plugin config from command line
+    contracts_dir = config.getoption("--contracts-dir")
+    default_wait_interval = config.getoption("--default-wait-interval")
+    default_wait_retries = config.getoption("--default-wait-retries")
+    rpc_url = config.getoption("--rpc-url")
+    network = config.getoption("--network")
+
+    plugin_config = PluginConfig()
+    plugin_config.contracts_dir = (
+        Path(contracts_dir) if contracts_dir is not None else None
+    )
+    plugin_config.default_wait_interval = int(default_wait_interval)
+    plugin_config.default_wait_retries = int(default_wait_retries)
+    plugin_config.rpc_url = rpc_url
+    plugin_config.network_name = network
+
+    general_config.plugin_config = plugin_config
+
+
+def pytest_sessionstart(session):
+    general_config = get_general_config()
+    logger.info("Using the following configuration:")
+    logger.info(f"  RPC URL: {general_config.get_rpc_url()}")
+    logger.info(f"  Selected Network: {general_config.get_network_name()}")
+    logger.info(
+        f"  Available networks: {list(general_config.user_config.networks.keys())}"
+    )
+    logger.info(f"  Contracts directory: {general_config.get_contracts_dir()}")
+    logger.info(f"  Environment: {general_config.user_config.environment}")
+    logger.info(
+        f"  Default wait interval: {general_config.get_default_wait_interval()} ms"
+    )
+    logger.info(f"  Default wait retries: {general_config.get_default_wait_retries()}")

gltest_cli/config/types.py

@@ -0,0 +1,137 @@
+from enum import Enum
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional
+from genlayer_py.chains import localnet, testnet_asimov
+from genlayer_py.types import GenLayerChain
+
+
+class NetworkConfig(str, Enum):
+    LOCALNET = "localnet"
+    TESTNET_ASIMOV = "testnet_asimov"
+
+
+@dataclass
+class PluginConfig:
+    contracts_dir: Optional[Path] = None
+    rpc_url: Optional[str] = None
+    default_wait_interval: Optional[int] = None
+    default_wait_retries: Optional[int] = None
+    network_name: Optional[str] = None
+
+
+@dataclass
+class NetworkConfigData:
+    id: Optional[int] = None
+    url: Optional[str] = None
+    accounts: Optional[List[str]] = None
+    from_account: Optional[str] = None
+
+    def __post_init__(self):
+        if self.id is not None and not isinstance(self.id, int):
+            raise ValueError("id must be an integer")
+        if self.url is not None and not isinstance(self.url, str):
+            raise ValueError("url must be a string")
+        if self.accounts is not None:
+            if not isinstance(self.accounts, list):
+                raise ValueError("accounts must be a list")
+            if not all(isinstance(acc, str) for acc in self.accounts):
+                raise ValueError("accounts must be strings")
+        if self.from_account is not None and not isinstance(self.from_account, str):
+            raise ValueError("from_account must be a string")
+
+
+@dataclass
+class PathConfig:
+    contracts: Optional[Path] = None
+
+    def __post_init__(self):
+        if self.contracts is not None and not isinstance(self.contracts, (str, Path)):
+            raise ValueError("contracts must be a string or Path")
+
+
+@dataclass
+class UserConfig:
+    networks: Dict[str, NetworkConfigData] = field(default_factory=dict)
+    paths: PathConfig = field(default_factory=PathConfig)
+    environment: Optional[str] = None
+    default_network: Optional[str] = None
+
+    def __post_init__(self):
+        if not isinstance(self.networks, dict):
+            raise ValueError("networks must be a dictionary")
+
+        if not isinstance(self.paths, PathConfig):
+            raise ValueError("paths must be a PathConfig instance")
+
+        if self.environment is not None and not isinstance(self.environment, str):
+            raise ValueError("environment must be a string")
+
+        if self.default_network is not None and not isinstance(
+            self.default_network, str
+        ):
+            raise ValueError("default_network must be a string")
+
+        # Validate network configurations
+        for name, network_config in self.networks.items():
+            if not isinstance(network_config, NetworkConfigData):
+                raise ValueError(f"network {name} must be a NetworkConfigData instance")
+
+
+@dataclass
+class GeneralConfig:
+    user_config: UserConfig = field(default_factory=UserConfig)
+    plugin_config: PluginConfig = field(default_factory=PluginConfig)
+
+    def get_contracts_dir(self) -> Path:
+        if self.plugin_config.contracts_dir is not None:
+            return self.plugin_config.contracts_dir
+        return self.user_config.paths.contracts
+
+    def set_contracts_dir(self, contracts_dir: Path):
+        self.plugin_config.contracts_dir = contracts_dir
+
+    def get_rpc_url(self) -> str:
+        if self.plugin_config.rpc_url is not None:
+            return self.plugin_config.rpc_url
+        network_name = self.get_network_name()
+        return self.user_config.networks[network_name].url
+
+    def get_default_account_key(self, network_name: Optional[str] = None) -> str:
+        if network_name is not None:
+            return self.user_config.networks[network_name].from_account
+        return self.user_config.networks[self.user_config.default_network].from_account
+
+    def get_accounts_keys(self, network_name: Optional[str] = None) -> List[str]:
+        if network_name is not None:
+            return self.user_config.networks[network_name].accounts
+        return self.user_config.networks[self.user_config.default_network].accounts
+
+    def get_chain(self) -> GenLayerChain:
+        chain_map_by_id = {
+            61999: localnet,
+            4221: testnet_asimov,
+        }
+        network_name = self.get_network_name()
+        network_id = self.user_config.networks[network_name].id
+        if network_id not in chain_map_by_id:
+            known = ", ".join(map(str, chain_map_by_id.keys()))
+            raise ValueError(
+                f"Unknown network: {network_name}, possible values: {known}"
+            )
+        return chain_map_by_id[network_id]
+
+    def get_default_wait_interval(self) -> int:
+        if self.plugin_config.default_wait_interval is not None:
+            return self.plugin_config.default_wait_interval
+        raise ValueError("default_wait_interval is not set")
+
+    def get_default_wait_retries(self) -> int:
+        if self.plugin_config.default_wait_retries is not None:
+            return self.plugin_config.default_wait_retries
+        raise ValueError("default_wait_retries is not set")
+
+    def get_network_name(self) -> str:
+        if self.plugin_config.network_name is not None:
+            return self.plugin_config.network_name
+        return self.user_config.default_network

gltest_cli/config/user.py

@@ -0,0 +1,222 @@
+import os
+import yaml
+import re
+from dotenv import load_dotenv
+from pathlib import Path
+from functools import lru_cache
+from gltest.glchain.account import create_accounts
+from gltest_cli.config.constants import (
+    GLTEST_CONFIG_FILE,
+    DEFAULT_NETWORK,
+    DEFAULT_RPC_URL,
+    DEFAULT_ENVIRONMENT,
+    DEFAULT_CONTRACTS_DIR,
+    DEFAULT_NETWORK_ID,
+)
+from gltest_cli.config.types import UserConfig, NetworkConfigData, PathConfig
+
+VALID_ROOT_KEYS = ["networks", "paths", "environment"]
+VALID_NETWORK_KEYS = ["id", "url", "accounts", "from"]
+VALID_PATHS_KEYS = ["contracts"]
+
+
+@lru_cache(maxsize=1)
+def get_default_user_config() -> UserConfig:
+    accounts = create_accounts(n_accounts=10)
+    accounts_private_keys = [account.key.hex() for account in accounts]
+
+    return UserConfig(
+        networks={
+            DEFAULT_NETWORK: NetworkConfigData(
+                id=DEFAULT_NETWORK_ID,
+                url=DEFAULT_RPC_URL,
+                accounts=accounts_private_keys,
+                from_account=accounts_private_keys[0],
+            ),
+        },
+        paths=PathConfig(contracts=DEFAULT_CONTRACTS_DIR),
+        environment=DEFAULT_ENVIRONMENT,
+        default_network=DEFAULT_NETWORK,
+    )
+
+
+def resolve_env_vars(obj):
+    if isinstance(obj, str):
+        return re.sub(
+            r"\${(\w+)}",
+            lambda m: os.getenv(m.group(1), f"<UNSET:{m.group(1)}>"),
+            obj,
+        )
+    elif isinstance(obj, dict):
+        return {k: resolve_env_vars(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [resolve_env_vars(i) for i in obj]
+    return obj
+
+
+def validate_network_config(network_name: str, network_config: dict):
+    if not isinstance(network_config, dict):
+        raise ValueError(f"network {network_name} must be a dictionary")
+
+    for key in network_config:
+        if key not in VALID_NETWORK_KEYS:
+            raise ValueError(
+                f"Invalid network key: {key}, valid keys are: {VALID_NETWORK_KEYS}"
+            )
+
+    if "id" in network_config and not isinstance(network_config["id"], int):
+        raise ValueError(f"network {network_name} id must be an integer")
+
+    if "url" in network_config and not isinstance(network_config["url"], str):
+        raise ValueError(f"network {network_name} url must be a string")
+
+    if "accounts" in network_config and not isinstance(
+        network_config["accounts"], list
+    ):
+        raise ValueError(f"network {network_name} accounts must be a list")
+    if "accounts" in network_config and not all(
+        isinstance(acc, str) for acc in network_config["accounts"]
+    ):
+        raise ValueError(f"network {network_name} accounts must be strings")
+
+    if "from" in network_config and not isinstance(network_config["from"], str):
+        raise ValueError(f"network {network_name} from must be a string")
+
+    # For non-default networks, url and accounts are required
+    if network_name != DEFAULT_NETWORK:
+        if "id" not in network_config:
+            raise ValueError(f"network {network_name} must have an id")
+        if "url" not in network_config:
+            raise ValueError(f"network {network_name} must have a url")
+        if "accounts" not in network_config:
+            raise ValueError(f"network {network_name} must have accounts")
+
+
+def validate_raw_user_config(config: dict):
+    # Validate root keys
+    if not all(key in VALID_ROOT_KEYS for key in config):
+        raise ValueError(
+            f"Invalid configuration keys. Valid keys are: {VALID_ROOT_KEYS}"
+        )
+
+    # Validate networks
+    if "networks" in config:
+        networks = config["networks"]
+        if not isinstance(networks, dict):
+            raise ValueError("networks must be a dictionary")
+
+        default_network = networks.get("default", DEFAULT_NETWORK)
+        if default_network != DEFAULT_NETWORK and default_network not in networks:
+            raise ValueError(f"default network {default_network} not found in networks")
+
+        for name, network_config in networks.items():
+            if name == "default" or (
+                name == DEFAULT_NETWORK and network_config is None
+            ):
+                continue
+            validate_network_config(name, network_config)
+
+    # Validate paths
+    if "paths" in config:
+        if not isinstance(config["paths"], dict):
+            raise ValueError("paths must be a dictionary")
+        if not all(key in VALID_PATHS_KEYS for key in config["paths"]):
+            raise ValueError(f"Invalid path keys. Valid keys are: {VALID_PATHS_KEYS}")
+
+    # Validate environment
+    if "environment" in config and not isinstance(config["environment"], str):
+        raise ValueError("environment must be a string")
+
+
+def load_user_config(path: str) -> UserConfig:
+    with open(path, "r") as f:
+        raw_config = yaml.safe_load(f) or {}
+
+    validate_raw_user_config(raw_config)
+    load_dotenv(
+        dotenv_path=raw_config.get("environment", DEFAULT_ENVIRONMENT), override=True
+    )
+    resolved_config = resolve_env_vars(raw_config)
+    user_config = transform_raw_to_user_config_with_defaults(resolved_config)
+    return user_config
+
+
+def transform_raw_to_user_config_with_defaults(raw_config: dict) -> UserConfig:
+    networks_config, user_default_network = _get_overridden_networks(raw_config)
+    return UserConfig(
+        networks=networks_config,
+        paths=_get_overridden_paths(raw_config),
+        environment=_get_overridden_environment(raw_config),
+        default_network=user_default_network,
+    )
+
+
+def _get_overridden_networks(raw_config: dict) -> tuple[dict, str]:
+    default_config = get_default_user_config()
+    if "networks" not in raw_config:
+        return default_config.networks, default_config.default_network
+
+    networks = dict(raw_config["networks"])
+    user_default_network = networks.pop("default")
+    if user_default_network is None and DEFAULT_NETWORK in set(networks.keys()):
+        user_default_network = DEFAULT_NETWORK
+
+    if user_default_network is None:
+        raise ValueError(
+            "'networks.default' is required in config since you don't have 'localnet' network in 'networks'"
+        )
+
+    networks_config = {}
+    for network_name, network_config in networks.items():
+        if network_name == DEFAULT_NETWORK:
+            networks_config[network_name] = default_config.networks[DEFAULT_NETWORK]
+            if network_config is None:
+                continue
+
+            if "url" in network_config:
+                networks_config[network_name].url = network_config["url"]
+            if "accounts" in network_config:
+                networks_config[network_name].accounts = network_config["accounts"]
+                networks_config[network_name].from_account = network_config["accounts"][
+                    0
+                ]
+            if "from" in network_config:
+                networks_config[network_name].from_account = network_config["from"]
+            continue
+
+        url = network_config["url"]
+        accounts = network_config["accounts"]
+        from_account = network_config.get("from", accounts[0])
+        network_id = network_config.get("id")
+
+        networks_config[network_name] = NetworkConfigData(
+            id=network_id,
+            url=url,
+            accounts=accounts,
+            from_account=from_account,
+        )
+    return networks_config, user_default_network
+
+
+def _get_overridden_environment(raw_config: dict) -> str:
+    default_config = get_default_user_config()
+    if "environment" in raw_config:
+        return raw_config["environment"]
+    return default_config.environment
+
+
+def _get_overridden_paths(raw_config: dict) -> PathConfig:
+    default_config = get_default_user_config()
+    if "paths" in raw_config:
+        return PathConfig(
+            contracts=Path(
+                raw_config.get("paths", {}).get("contracts", DEFAULT_CONTRACTS_DIR)
+            )
+        )
+    return default_config.paths
+
+
+def user_config_exists() -> bool:
+    return any(
+        p.name == GLTEST_CONFIG_FILE for p in Path.cwd().iterdir() if p.is_file()
+    )

gltest_cli/logging.py

@@ -0,0 +1,51 @@
+import logging
+from colorama import Fore, Style, init
+
+
+init()
+
+
+class ColoredFormatter(logging.Formatter):
+    """Custom formatter that adds colors to the log levels"""
+
+    COLORS = {
+        "DEBUG": Fore.BLUE,
+        "INFO": Fore.GREEN,
+        "WARNING": Fore.YELLOW,
+        "ERROR": Fore.RED,
+        "CRITICAL": Fore.RED + Style.BRIGHT,
+    }
+
+    def format(self, record):
+        levelname_plain = record.levelname
+        if levelname_plain in self.COLORS:
+            colored = (
+                f"{self.COLORS[levelname_plain]}{levelname_plain}{Style.RESET_ALL}"
+            )
+            record.levelname = colored
+            formatted = super().format(record)
+            record.levelname = levelname_plain
+            return formatted
+        return super().format(record)
+
+
+def setup_logger():
+    logger = logging.getLogger("gltest")
+    logger.setLevel(logging.DEBUG)
+
+    if logger.handlers:
+        return logger
+
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.DEBUG)
+
+    formatter = ColoredFormatter("%(levelname)s: %(message)s")
+    console_handler.setFormatter(formatter)
+
+    logger.addHandler(console_handler)
+    return logger
+
+
+logger = setup_logger()
+
+__all__ = ["logger"]

tests/examples/tests/test_llm_erc20.py

@@ -1,4 +1,4 @@
-from gltest import get_contract_factory, default_account, create_account
+from gltest import get_contract_factory, get_default_account, create_account
 from gltest.assertions import tx_execution_succeeded
 
 TOKEN_TOTAL_SUPPLY = 1000
@@ -7,7 +7,7 @@ TRANSFER_AMOUNT = 100
 
 def test_llm_erc20():
     # Account Setup
-    from_account_a = default_account
+    from_account_a = get_default_account()
     from_account_b = create_account()
 
     # Deploy Contract

tests/examples/tests/test_multi_read_erc20.py

@@ -1,5 +1,7 @@
-from gltest import get_contract_factory, create_account
+from gltest import get_contract_factory, create_account, get_accounts
 from gltest.assertions import tx_execution_succeeded
+from gltest_cli.config.general import get_general_config
+from genlayer_py.chains import testnet_asimov
 
 
 def test_multi_read_erc20():
@@ -15,9 +17,17 @@ def test_multi_read_erc20():
 
     This test demonstrates the integration contract to contract reads
     """
+    general_config = get_general_config()
+    chain = general_config.get_chain()
+
     TOKEN_TOTAL_SUPPLY = 1000
-    from_account_doge = create_account()
-    from_account_shiba = create_account()
+
+    if chain.id == testnet_asimov.id:
+        from_account_doge = get_accounts()[0]
+        from_account_shiba = get_accounts()[1]
+    else:
+        from_account_doge = create_account()
+        from_account_shiba = create_account()
 
     # LLM ERC20
     llm_erc20_factory = get_contract_factory("LlmErc20")

tests/examples/tests/test_multi_tenant_storage.py

@@ -1,5 +1,7 @@
-from gltest import get_contract_factory, create_account
+from gltest import get_contract_factory, create_account, get_accounts
 from gltest.assertions import tx_execution_succeeded
+from gltest_cli.config.general import get_general_config
+from genlayer_py.chains import testnet_asimov
 
 
 def test_multi_tenant_storage():
@@ -15,8 +17,15 @@ def test_multi_tenant_storage():
 
     This test demonstrates contract-to-contract interactions and multi-tenant data management.
     """
-    user_account_a = create_account()
-    user_account_b = create_account()
+    general_config = get_general_config()
+    chain = general_config.get_chain()
+
+    if chain.id == testnet_asimov.id:
+        user_account_a = get_accounts()[0]
+        user_account_b = get_accounts()[1]
+    else:
+        user_account_a = create_account()
+        user_account_b = create_account()
 
     # Storage Contracts
     storage_factory = get_contract_factory("Storage")

tests/examples/tests/test_read_erc20.py

@@ -1,4 +1,4 @@
-from gltest import get_contract_factory, default_account
+from gltest import get_contract_factory, get_default_account
 
 
 def test_read_erc20():
@@ -32,6 +32,6 @@ def test_read_erc20():
 
         # check balance
         contract_state = read_erc20_contract.get_balance_of(
-            args=[default_account.address]
+            args=[get_default_account().address]
         )
         assert contract_state == TOKEN_TOTAL_SUPPLY

tests/examples/tests/test_storage.py

@@ -8,14 +8,16 @@ UPDATED_STATE = "b"
 
 def test_storage():
     factory = get_contract_factory("Storage")
-    contract = factory.deploy(args=[INITIAL_STATE])
+    contract = factory.deploy(args=[INITIAL_STATE], wait_retries=40)
 
     # Get initial state
     contract_state_1 = contract.get_storage(args=[])
     assert contract_state_1 == INITIAL_STATE
 
     # Update State
-    transaction_response_call_1 = contract.update_storage(args=[UPDATED_STATE])
+    transaction_response_call_1 = contract.update_storage(
+        args=[UPDATED_STATE], wait_retries=40
+    )
     assert tx_execution_succeeded(transaction_response_call_1)
 
     # Get Updated State

tests/examples/tests/test_user_storage.py

@@ -1,5 +1,12 @@
-from gltest import get_contract_factory, default_account, create_account
+from gltest import (
+    get_contract_factory,
+    get_default_account,
+    create_account,
+    get_accounts,
+)
 from gltest.assertions import tx_execution_succeeded
+from gltest_cli.config.general import get_general_config
+from genlayer_py.chains import testnet_asimov
 
 
 INITIAL_STATE_USER_A = "user_a_initial_state"
@@ -9,9 +16,16 @@ UPDATED_STATE_USER_B = "user_b_updated_state"
 
 
 def test_user_storage():
+    general_config = get_general_config()
+    chain = general_config.get_chain()
+
     # Account Setup
-    from_account_a = default_account
-    from_account_b = create_account()
+    if chain.id == testnet_asimov.id:
+        from_account_a = get_accounts()[0]
+        from_account_b = get_accounts()[1]
+    else:
+        from_account_a = get_default_account()
+        from_account_b = create_account()
 
     factory = get_contract_factory("UserStorage")
     contract = factory.deploy()