genlayer-test 0.4.1__py3-none-any.whl → 0.5.1__py3-none-any.whl

gltest/contracts/stats_collector.py

@@ -0,0 +1,259 @@
+"""
+Stats collector module for contract method analysis.
+
+This module contains classes and functions to collect and analyze statistics
+from contract method executions, simplifying the analyze_method implementation.
+"""
+
+import time
+import json
+import hashlib
+from datetime import datetime, timezone
+from typing import List, Dict, Any, Optional
+from dataclasses import dataclass
+
+from gltest.clients import get_gl_client
+from gltest.types import CalldataEncodable
+from .method_stats import StateGroup, FailedRun, MethodStatsDetailed, MethodStatsSummary
+from gltest_cli.config.general import get_general_config
+from gltest_cli.config.pytest_context import get_current_test_nodeid
+from .utils import safe_filename
+
+
+@dataclass
+class SimulationConfig:
+    """Configuration for simulation runs."""
+
+    provider: str
+    model: str
+    config: Optional[Dict[str, Any]] = None
+    plugin: Optional[str] = None
+    plugin_config: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class SimulationResults:
+    """Results from simulation runs."""
+
+    sim_results: List[Dict[str, Any]]
+    failed_runs: List[FailedRun]
+    server_errors: int
+    execution_time: float
+    timestamp: str
+
+
+class StatsCollector:
+    """Collects and analyzes statistics for contract method executions."""
+
+    def __init__(
+        self,
+        contract_address: str,
+        method_name: str,
+        account: Any,
+        args: Optional[List[CalldataEncodable]] = None,
+    ):
+        self.contract_address = contract_address
+        self.method_name = method_name
+        self.account = account
+        self.args = args or []
+        self.client = get_gl_client()
+
+    def run_simulations(
+        self, sim_config: SimulationConfig, runs: int
+    ) -> SimulationResults:
+        """Execute multiple simulation runs and collect results."""
+        start_time = time.time()
+        timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+        sim_results = []
+        failed_runs_list = []
+        server_errors = 0
+
+        for run_idx in range(runs):
+            try:
+                sim_result = self._execute_single_simulation(sim_config)
+                sim_results.append(sim_result)
+
+                if sim_result.get("execution_result") != "SUCCESS":
+                    failed_runs_list.append(
+                        self._create_failed_run(run_idx, sim_result)
+                    )
+            except Exception as e:
+                server_errors += 1
+                failed_runs_list.append(
+                    FailedRun(
+                        run=run_idx,
+                        error=str(e),
+                        error_type="server",
+                        genvm_result=None,
+                    )
+                )
+
+        execution_time = time.time() - start_time
+
+        return SimulationResults(
+            sim_results=sim_results,
+            failed_runs=failed_runs_list,
+            server_errors=server_errors,
+            execution_time=execution_time,
+            timestamp=timestamp,
+        )
+
+    def _execute_single_simulation(
+        self, sim_config: SimulationConfig
+    ) -> Dict[str, Any]:
+        """Execute a single simulation."""
+        config_dict = {
+            "provider": sim_config.provider,
+            "model": sim_config.model,
+        }
+
+        if (
+            sim_config.config is not None
+            and sim_config.plugin is not None
+            and sim_config.plugin_config is not None
+        ):
+            config_dict["config"] = sim_config.config
+            config_dict["plugin"] = sim_config.plugin
+            config_dict["plugin_config"] = sim_config.plugin_config
+
+        return self.client.simulate_write_contract(
+            address=self.contract_address,
+            function_name=self.method_name,
+            account=self.account,
+            args=self.args,
+            sim_config=config_dict,
+        )
+
+    def _create_failed_run(self, run_idx: int, sim_result: Dict[str, Any]) -> FailedRun:
+        """Create a FailedRun object from a failed simulation result."""
+        return FailedRun(
+            run=run_idx,
+            error=sim_result.get("error", "unknown error"),
+            error_type="simulation",
+            genvm_result={
+                "stderr": sim_result.get("genvm_result", {}).get("stderr", ""),
+                "stdout": sim_result.get("genvm_result", {}).get("stdout", ""),
+            },
+        )
+
+    def analyze_results(
+        self,
+        sim_results: SimulationResults,
+        runs: int,
+        sim_config: SimulationConfig,
+    ) -> MethodStatsSummary:
+        """Analyze simulation results and generate statistics."""
+        state_groups = self._analyze_states(sim_results.sim_results)
+
+        executed_runs = runs - sim_results.server_errors
+        successful_runs = sum(
+            1
+            for sim_receipt in sim_results.sim_results
+            if sim_receipt.get("execution_result") == "SUCCESS"
+        )
+
+        most_common_count = max((group.count for group in state_groups), default=0)
+        reliability_score = (
+            (most_common_count / executed_runs) if executed_runs > 0 else 0.0
+        )
+
+        # Save detailed stats
+        detailed_stats = self._create_detailed_stats(
+            sim_results=sim_results,
+            state_groups=state_groups,
+            runs=runs,
+            executed_runs=executed_runs,
+            successful_runs=successful_runs,
+            most_common_count=most_common_count,
+            reliability_score=reliability_score,
+            sim_config=sim_config,
+        )
+        self._save_detailed_stats(detailed_stats)
+
+        # Return summary
+        return MethodStatsSummary(
+            method=self.method_name,
+            args=self.args,
+            total_runs=runs,
+            server_error_runs=sim_results.server_errors,
+            executed_runs=executed_runs,
+            failed_runs=len(sim_results.failed_runs),
+            successful_runs=successful_runs,
+            unique_states=len(state_groups),
+            most_common_state_count=most_common_count,
+            reliability_score=reliability_score,
+            execution_time=sim_results.execution_time,
+            provider=sim_config.provider,
+            model=sim_config.model,
+        )
+
+    def _analyze_states(self, sim_results: List[Dict[str, Any]]) -> List[StateGroup]:
+        """Analyze contract states from simulation results."""
+        state_counts = {}
+        state_to_hash_str = {}
+
+        for sim_receipt in sim_results:
+            contract_state = sim_receipt.get("contract_state", {})
+            state_json = json.dumps(contract_state, sort_keys=True)
+            state_hash = hashlib.sha256(state_json.encode()).hexdigest()
+            state_hash_str = f"0x{state_hash}"
+            state_to_hash_str[state_hash] = state_hash_str
+            state_counts[state_hash] = state_counts.get(state_hash, 0) + 1
+
+        return [
+            StateGroup(count=count, state_hash=state_to_hash_str[state_hash])
+            for state_hash, count in sorted(
+                state_counts.items(), key=lambda x: x[1], reverse=True
+            )
+        ]
+
+    def _create_detailed_stats(
+        self,
+        sim_results: SimulationResults,
+        state_groups: List[StateGroup],
+        runs: int,
+        executed_runs: int,
+        successful_runs: int,
+        most_common_count: int,
+        reliability_score: float,
+        sim_config: SimulationConfig,
+    ) -> MethodStatsDetailed:
+        """Create detailed statistics object."""
+        configuration = {
+            "runs": runs,
+            "provider": sim_config.provider,
+            "model": sim_config.model,
+            "config": sim_config.config,
+            "plugin": sim_config.plugin,
+            "plugin_config": sim_config.plugin_config,
+        }
+
+        return MethodStatsDetailed(
+            method=self.method_name,
+            params=self.args,
+            timestamp=sim_results.timestamp,
+            configuration=configuration,
+            execution_time=sim_results.execution_time,
+            executed_runs=executed_runs,
+            failed_runs=len(sim_results.failed_runs),
+            successful_runs=successful_runs,
+            server_error_runs=sim_results.server_errors,
+            unique_states=len(state_groups),
+            most_common_state_count=most_common_count,
+            reliability_score=reliability_score,
+            state_groups=state_groups,
+            failed_runs_results=sim_results.failed_runs,
+            sim_results=sim_results.sim_results,
+        )
+
+    def _save_detailed_stats(self, detailed_stats: MethodStatsDetailed) -> None:
+        """Save detailed statistics to the configured directory."""
+        general_config = get_general_config()
+        current_nodeid = get_current_test_nodeid()
+        if current_nodeid is None:
+            safe_name = "no_test"
+        else:
+            safe_name = safe_filename(current_nodeid)
+        stats_dir = general_config.get_analysis_dir() / safe_name
+        detailed_stats.save_to_directory(stats_dir)

gltest/contracts/utils.py

@@ -0,0 +1,12 @@
+def safe_filename(filename: str) -> str:
+    """
+    Replace problematic characters in filename.
+    """
+    return (
+        filename.replace("/", "_")
+        .replace("\\", "_")
+        .replace(":", "_")
+        .replace("-", "_")
+        .replace(" ", "_")
+        .replace(".py", "")
+    )

gltest/fixtures.py

@@ -4,12 +4,8 @@ These fixtures can be imported and used in test files.
 """
 
 import pytest
-from gltest.glchain import (
-    get_gl_client,
-    get_accounts,
-    get_default_account,
-    get_gl_provider,
-)
+from gltest.clients import get_gl_client, get_gl_provider
+from gltest.accounts import get_accounts, get_default_account
 from gltest_cli.config.general import get_general_config
 
 

gltest/helpers/take_snapshot.py

@@ -1,4 +1,4 @@
-from gltest.glchain import get_gl_provider
+from gltest.clients import get_gl_provider
 from dataclasses import dataclass
 from typing import Callable
 from gltest.exceptions import HelperError, InvalidSnapshotError

gltest/types.py

@@ -4,4 +4,5 @@ from genlayer_py.types import (
     GenLayerTransaction,
     TransactionStatus,
     CalldataEncodable,
+    TransactionHashVariant,
 )

gltest_cli/config/constants.py

@@ -4,7 +4,9 @@ from pathlib import Path
 
 GLTEST_CONFIG_FILE = "gltest.config.yaml"
 DEFAULT_NETWORK = "localnet"
+PRECONFIGURED_NETWORKS = ["localnet", "studionet", "testnet_asimov"]
 DEFAULT_RPC_URL = SIMULATOR_JSON_RPC_URL
 DEFAULT_ENVIRONMENT = ".env"
 DEFAULT_CONTRACTS_DIR = Path("contracts")
+DEFAULT_ARTIFACTS_DIR = Path("artifacts")
 DEFAULT_NETWORK_ID = 61999

gltest_cli/config/plugin.py

@@ -1,4 +1,6 @@
+import pytest
 from pathlib import Path
+import shutil
 from gltest_cli.logging import logger
 from gltest_cli.config.user import (
     user_config_exists,
@@ -9,6 +11,7 @@ from gltest_cli.config.general import (
     get_general_config,
 )
 from gltest_cli.config.types import PluginConfig
+from gltest_cli.config.pytest_context import _pytest_context
 
 
 def pytest_addoption(parser):
@@ -20,17 +23,24 @@ def pytest_addoption(parser):
         help="Path to directory containing contract files",
     )
 
+    group.addoption(
+        "--artifacts-dir",
+        action="store",
+        default=None,
+        help="Path to directory for storing contract artifacts",
+    )
+
     group.addoption(
         "--default-wait-interval",
         action="store",
-        default=10000,
+        default=3000,
         help="Default interval (ms) between transaction receipt checks",
     )
 
     group.addoption(
         "--default-wait-retries",
         action="store",
-        default=15,
+        default=50,
         help="Default number of retries for transaction receipt checks",
     )
 
@@ -55,61 +65,123 @@ def pytest_addoption(parser):
         help="Test with mocks",
     )
 
+    group.addoption(
+        "--leader-only",
+        action="store_true",
+        default=False,
+        help="Run contracts in leader-only mode",
+    )
 
-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"
+def pytest_configure(config):
+    try:
+        general_config = get_general_config()
+
+        network_name = config.getoption("--network")
+
+        if not user_config_exists():
+            logger.warning(
+                "File `gltest.config.yaml` not found in the current directory, using default config, create a `gltest.config.yaml` file to manage multiple networks"
+            )
+            user_config = get_default_user_config()
+
+            # Special handling for testnet_asimov - check if accounts are configured
+            if network_name == "testnet_asimov":
+                logger.error(
+                    "For testnet_asimov, you need to configure accounts in gltest.config.yaml, see https://docs.genlayer.com/api-references/genlayer-test"
+                )
+                pytest.exit("gltest configuration error")
+        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")
+        artifacts_dir = config.getoption("--artifacts-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")
+        test_with_mocks = config.getoption("--test-with-mocks")
+        leader_only = config.getoption("--leader-only")
+
+        plugin_config = PluginConfig()
+        plugin_config.contracts_dir = (
+            Path(contracts_dir) if contracts_dir is not None else None
         )
-        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"
+        plugin_config.artifacts_dir = (
+            Path(artifacts_dir) if artifacts_dir is not None else None
         )
-        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")
-    test_with_mocks = config.getoption("--test-with-mocks")
+        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
+        plugin_config.test_with_mocks = test_with_mocks
+        plugin_config.leader_only = leader_only
 
-    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
-    plugin_config.test_with_mocks = test_with_mocks
-
-    general_config.plugin_config = plugin_config
+        general_config.plugin_config = plugin_config
+    except Exception as e:
+        logger.error(f"Gltest configure error: {e}")
+        pytest.exit("gltest configuration error")
 
 
 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()}")
-    logger.info(f"  Test with mocks: {general_config.get_test_with_mocks()}")
+    try:
+        general_config = get_general_config()
+        artifacts_dir = general_config.get_artifacts_dir()
+        if artifacts_dir and artifacts_dir.exists():
+            logger.info(f"Clearing artifacts directory: {artifacts_dir}")
+            try:
+                shutil.rmtree(artifacts_dir)
+                artifacts_dir.mkdir(parents=True, exist_ok=True)
+            except Exception as e:
+                logger.warning(f"Failed to clear artifacts directory: {e}")
+        elif artifacts_dir:
+            artifacts_dir.mkdir(parents=True, exist_ok=True)
+        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()}")
+        # Show available networks including preconfigured ones
+        all_networks = general_config.get_networks_keys()
+        logger.info(f"  Available networks: {all_networks}")
+        logger.info(f"  Contracts directory: {general_config.get_contracts_dir()}")
+        logger.info(f"  Artifacts directory: {general_config.get_artifacts_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()}"
+        )
+        logger.info(f"  Test with mocks: {general_config.get_test_with_mocks()}")
+
+        if (
+            general_config.get_leader_only()
+            and not general_config.check_studio_based_rpc()
+        ):
+            logger.warning(
+                "Leader only mode: True (enabled on non-studio network - will have no effect)"
+            )
+        else:
+            logger.info(f"  Leader only mode: {general_config.get_leader_only()}")
+    except Exception as e:
+        logger.error(f"Gltest session start error: {e}")
+        pytest.exit("gltest session start error")
+
+
+def pytest_runtest_setup(item):
+    _pytest_context.current_item = item
+
+
+def pytest_runtest_teardown(item):
+    try:
+        del _pytest_context.current_item
+    except AttributeError:
+        pass
 
 
 pytest_plugins = ["gltest.fixtures"]

gltest_cli/config/pytest_context.py

@@ -0,0 +1,9 @@
+from typing import Optional
+import threading
+
+_pytest_context = threading.local()
+
+
+def get_current_test_nodeid() -> Optional[str]:
+    item = getattr(_pytest_context, "current_item", None)
+    return item.nodeid if item is not None else None

gltest_cli/config/types.py

@@ -2,24 +2,22 @@ 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.chains import localnet, studionet, testnet_asimov
 from genlayer_py.types import GenLayerChain
 from urllib.parse import urlparse
-
-
-class NetworkConfig(str, Enum):
-    LOCALNET = "localnet"
-    TESTNET_ASIMOV = "testnet_asimov"
+from gltest_cli.config.constants import PRECONFIGURED_NETWORKS
 
 
 @dataclass
 class PluginConfig:
     contracts_dir: Optional[Path] = None
+    artifacts_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
     test_with_mocks: bool = False
+    leader_only: bool = False
 
 
 @dataclass
@@ -28,6 +26,7 @@ class NetworkConfigData:
     url: Optional[str] = None
     accounts: Optional[List[str]] = None
     from_account: Optional[str] = None
+    leader_only: bool = False
 
     def __post_init__(self):
         if self.id is not None and not isinstance(self.id, int):
@@ -46,10 +45,13 @@ class NetworkConfigData:
 @dataclass
 class PathConfig:
     contracts: Optional[Path] = None
+    artifacts: 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")
+        if self.artifacts is not None and not isinstance(self.artifacts, (str, Path)):
+            raise ValueError("artifacts must be a string or Path")
 
 
 @dataclass
@@ -93,10 +95,29 @@ class GeneralConfig:
     def set_contracts_dir(self, contracts_dir: Path):
         self.plugin_config.contracts_dir = contracts_dir
 
+    def get_artifacts_dir(self) -> Path:
+        if self.plugin_config.artifacts_dir is not None:
+            return self.plugin_config.artifacts_dir
+        return self.user_config.paths.artifacts
+
+    def set_artifacts_dir(self, artifacts_dir: Path):
+        self.plugin_config.artifacts_dir = artifacts_dir
+
+    def get_analysis_dir(self) -> Path:
+        artifacts_dir = self.get_artifacts_dir()
+        return artifacts_dir / "analysis"
+
+    def get_networks_keys(self) -> List[str]:
+        return list(self.user_config.networks.keys())
+
     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()
+        if network_name not in self.user_config.networks:
+            raise ValueError(
+                f"Unknown network: {network_name}, possible values: {self.get_networks_keys()}"
+            )
         return self.user_config.networks[network_name].url
 
     def get_default_account_key(self, network_name: Optional[str] = None) -> str:
@@ -110,16 +131,37 @@ class GeneralConfig:
         return self.user_config.networks[self.user_config.default_network].accounts
 
     def get_chain(self) -> GenLayerChain:
+        network_name = self.get_network_name()
+        if network_name not in self.user_config.networks:
+            raise ValueError(
+                f"Unknown network: {network_name}, possible values: {self.get_networks_keys()}"
+            )
+
+        # Reserved network names
+        chain_map_by_name = {
+            "localnet": localnet,
+            "studionet": studionet,
+            "testnet_asimov": testnet_asimov,
+        }
+
+        if network_name in chain_map_by_name:
+            return chain_map_by_name[network_name]
+
+        if network_name in PRECONFIGURED_NETWORKS:
+            raise ValueError(
+                f"Network {network_name} should be handled by reserved mapping"
+            )
+
+        # Custom networks
         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}"
+                f"Unknown network id: {network_id}, possible values: {known}"
             )
         return chain_map_by_id[network_id]
 
@@ -141,8 +183,31 @@ class GeneralConfig:
     def get_test_with_mocks(self) -> bool:
         return self.plugin_config.test_with_mocks
 
+    def get_leader_only(self) -> bool:
+        if self.plugin_config.leader_only:
+            return True
+        network_name = self.get_network_name()
+        if network_name in self.user_config.networks:
+            network_config = self.user_config.networks[network_name]
+            return network_config.leader_only
+        return False
+
     def check_local_rpc(self) -> bool:
         SUPPORTED_RPC_DOMAINS = ["localhost", "127.0.0.1"]
         rpc_url = self.get_rpc_url()
         domain = urlparse(rpc_url).netloc.split(":")[0]  # Extract domain without port
         return domain in SUPPORTED_RPC_DOMAINS
+
+    def check_studio_based_rpc(self) -> bool:
+        SUPPORTED_RPC_DOMAINS = ["localhost", "127.0.0.1"]
+        rpc_url = self.get_rpc_url()
+        domain = urlparse(rpc_url).netloc.split(":")[0]  # Extract domain without port
+
+        if domain in SUPPORTED_RPC_DOMAINS:
+            return True
+
+        # Check .genlayer.com or .genlayerlabs.com subdomains
+        if domain.endswith(".genlayer.com") or domain.endswith(".genlayerlabs.com"):
+            return True
+
+        return False