genlayer-test 0.1.3__py3-none-any.whl → 0.3.0__py3-none-any.whl

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()

tests/gltest/artifact/contracts/duplicate_ic_contract_1.py

@@ -0,0 +1,22 @@
+# { "Depends": "py-genlayer:test" }
+
+from genlayer import *
+
+
+# contract class
+class DuplicateContract(gl.Contract):
+    storage: str
+
+    # constructor
+    def __init__(self, initial_storage: str):
+        self.storage = initial_storage
+
+    # read methods must be annotated with view
+    @gl.public.view
+    def get_storage(self) -> str:
+        return self.storage
+
+    # write method
+    @gl.public.write
+    def update_storage(self, new_storage: str) -> None:
+        self.storage = new_storage

tests/gltest/artifact/contracts/duplicate_ic_contract_2.py

@@ -0,0 +1,22 @@
+# { "Depends": "py-genlayer:test" }
+
+from genlayer import *
+
+
+# contract class
+class DuplicateContract(gl.Contract):
+    storage: str
+
+    # constructor
+    def __init__(self, initial_storage: str):
+        self.storage = initial_storage
+
+    # read methods must be annotated with view
+    @gl.public.view
+    def get_storage(self) -> str:
+        return self.storage
+
+    # write method
+    @gl.public.write
+    def update_storage(self, new_storage: str) -> None:
+        self.storage = new_storage

tests/{artifact → gltest/artifact}/test_contract_definition.py

@@ -1,43 +1,44 @@
 import pytest
 from gltest.artifacts.contract import (
-    find_contract_definition,
+    find_contract_definition_from_name,
     compute_contract_code,
 )
-from gltest.plugin_config import set_contracts_dir
+from gltest_cli.config.general import get_general_config
 from pathlib import Path
 
+CONTRACTS_DIR = Path("tests/examples/contracts")
+
 
 def test_single_file():
-    set_contracts_dir(".")
-    contract_definition = find_contract_definition("PredictionMarket")
+    general_config = get_general_config()
+    general_config.set_contracts_dir(Path("."))
+    contract_definition = find_contract_definition_from_name("PredictionMarket")
 
     assert contract_definition.contract_name == "PredictionMarket"
 
     # Assert complete contract definition
-    expected_main_file_path = Path("examples/contracts/football_prediction_market.py")
+    expected_main_file_path = CONTRACTS_DIR / "football_prediction_market.py"
     expected_runner_file_path = None
     contract_code = compute_contract_code(
         expected_main_file_path, expected_runner_file_path
     )
     assert contract_definition.contract_code == contract_code
-    assert (
-        str(contract_definition.main_file_path)
-        == "examples/contracts/football_prediction_market.py"
+    assert str(contract_definition.main_file_path) == str(
+        CONTRACTS_DIR / "football_prediction_market.py"
     )
     assert contract_definition.runner_file_path is None
 
 
 def test_multiple_files():
-    set_contracts_dir(".")
-    contract_definition = find_contract_definition("MultiFileContract")
+    general_config = get_general_config()
+    general_config.set_contracts_dir(Path("."))
+    contract_definition = find_contract_definition_from_name("MultiFileContract")
 
     assert contract_definition.contract_name == "MultiFileContract"
 
     # Assert complete contract definition
-    expected_main_file_path = Path("examples/contracts/multi_file_contract/__init__.py")
-    expected_runner_file_path = Path(
-        "examples/contracts/multi_file_contract/runner.json"
-    )
+    expected_main_file_path = CONTRACTS_DIR / "multi_file_contract/__init__.py"
+    expected_runner_file_path = CONTRACTS_DIR / "multi_file_contract/runner.json"
     assert contract_definition.main_file_path == expected_main_file_path
     assert contract_definition.runner_file_path == expected_runner_file_path
     contract_code = compute_contract_code(
@@ -47,36 +48,33 @@ def test_multiple_files():
 
 
 def test_single_file_legacy():
-    set_contracts_dir(".")
-    contract_definition = find_contract_definition("StorageLegacy")
+    general_config = get_general_config()
+    general_config.set_contracts_dir(Path("."))
+    contract_definition = find_contract_definition_from_name("StorageLegacy")
 
     # Assert complete contract definition
     assert contract_definition.contract_name == "StorageLegacy"
-    expected_main_file_path = Path("examples/contracts/storage_legacy.gpy")
+    expected_main_file_path = CONTRACTS_DIR / "storage_legacy.gpy"
     expected_runner_file_path = None
     contract_code = compute_contract_code(
         expected_main_file_path, expected_runner_file_path
     )
     assert contract_definition.contract_code == contract_code
-    assert (
-        str(contract_definition.main_file_path)
-        == "examples/contracts/storage_legacy.gpy"
+    assert str(contract_definition.main_file_path) == str(
+        CONTRACTS_DIR / "storage_legacy.gpy"
     )
     assert contract_definition.runner_file_path is None
 
 
 def test_multiple_files_legacy():
-    set_contracts_dir(".")
-    contract_definition = find_contract_definition("MultiFileContractLegacy")
+    general_config = get_general_config()
+    general_config.set_contracts_dir(Path("."))
+    contract_definition = find_contract_definition_from_name("MultiFileContractLegacy")
 
     # Assert complete contract definition
     assert contract_definition.contract_name == "MultiFileContractLegacy"
-    expected_main_file_path = Path(
-        "examples/contracts/multi_file_contract_legacy/__init__.gpy"
-    )
-    expected_runner_file_path = Path(
-        "examples/contracts/multi_file_contract_legacy/runner.json"
-    )
+    expected_main_file_path = CONTRACTS_DIR / "multi_file_contract_legacy/__init__.gpy"
+    expected_runner_file_path = CONTRACTS_DIR / "multi_file_contract_legacy/runner.json"
     assert contract_definition.main_file_path == expected_main_file_path
     assert contract_definition.runner_file_path == expected_runner_file_path
     contract_code = compute_contract_code(
@@ -86,7 +84,8 @@ def test_multiple_files_legacy():
 
 
 def test_class_is_not_intelligent_contract():
-    set_contracts_dir(".")
+    general_config = get_general_config()
+    general_config.set_contracts_dir(Path("."))
 
     with pytest.raises(FileNotFoundError):
-        _ = find_contract_definition("NotICContract")
+        _ = find_contract_definition_from_name("NotICContract")