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

tests/gltest/artifact/test_contract_definition.py

@@ -0,0 +1,91 @@
+import pytest
+from gltest.artifacts.contract import (
+    find_contract_definition_from_name,
+    compute_contract_code,
+)
+from gltest_cli.config.general import get_general_config
+from pathlib import Path
+
+CONTRACTS_DIR = Path("tests/examples/contracts")
+
+
+def test_single_file():
+    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 = 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) == str(
+        CONTRACTS_DIR / "football_prediction_market.py"
+    )
+    assert contract_definition.runner_file_path is None
+
+
+def test_multiple_files():
+    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 = 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(
+        expected_main_file_path, expected_runner_file_path
+    )
+    assert contract_definition.contract_code == contract_code
+
+
+def test_single_file_legacy():
+    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 = 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) == str(
+        CONTRACTS_DIR / "storage_legacy.gpy"
+    )
+    assert contract_definition.runner_file_path is None
+
+
+def test_multiple_files_legacy():
+    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 = 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(
+        expected_main_file_path, expected_runner_file_path
+    )
+    assert contract_definition.contract_code == contract_code
+
+
+def test_class_is_not_intelligent_contract():
+    general_config = get_general_config()
+    general_config.set_contracts_dir(Path("."))
+
+    with pytest.raises(FileNotFoundError):
+        _ = find_contract_definition_from_name("NotICContract")

tests/gltest_cli/config/test_plugin.py

@@ -0,0 +1,127 @@
+def test_help_message(pytester):
+    result = pytester.runpytest(
+        "--help",
+    )
+    # fnmatch_lines does an assertion internally
+    result.stdout.fnmatch_lines(
+        [
+            "gltest:",
+            "  --contracts-dir=CONTRACTS_DIR",
+            "                        Path to directory containing contract files",
+            "  --default-wait-interval=DEFAULT_WAIT_INTERVAL",
+            "                        Default interval (ms) between transaction receipt checks",
+            "  --default-wait-retries=DEFAULT_WAIT_RETRIES",
+            "                        Default number of retries for transaction receipt checks",
+            "  --rpc-url=RPC_URL     RPC endpoint URL for the GenLayer network",
+            "  --network=NETWORK     Target network (defaults to 'localnet' if no config",
+            "                        file)",
+        ]
+    )
+
+
+def test_default_wait_interval(pytester):
+
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_default_wait_interval():
+            general_config = get_general_config()
+            assert general_config.get_default_wait_interval() == 5000
+    """
+    )
+
+    result = pytester.runpytest("--default-wait-interval=5000", "-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_default_wait_interval PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_default_wait_retries(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_default_wait_retries():
+            general_config = get_general_config()
+            assert general_config.get_default_wait_retries() == 4000
+    """
+    )
+
+    result = pytester.runpytest("--default-wait-retries=4000", "-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_default_wait_retries PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_rpc_url(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_rpc_url():
+            general_config = get_general_config()
+            assert general_config.get_rpc_url() == 'http://custom-rpc-url:8545' 
+    """
+    )
+
+    result = pytester.runpytest("--rpc-url=http://custom-rpc-url:8545", "-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_rpc_url PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_network_localnet(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_network():
+            general_config = get_general_config()
+            assert general_config.get_network_name() == "localnet"
+    """
+    )
+
+    result = pytester.runpytest("--network=localnet", "-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_network PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_network_testnet(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_network():
+            general_config = get_general_config()
+            assert general_config.get_network_name() == "testnet_asimov"
+    """
+    )
+
+    result = pytester.runpytest(
+        "--network=testnet_asimov", "--rpc-url=http://test.example.com:9151", "-v"
+    )
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_network PASSED*",
+        ]
+    )
+    assert result.ret == 0

tests/gltest_cli/config/test_user.py

@@ -0,0 +1,351 @@
+import pytest
+import yaml
+from unittest.mock import patch, mock_open
+from gltest_cli.config.user import (
+    get_default_user_config,
+    load_user_config,
+    validate_raw_user_config,
+    transform_raw_to_user_config_with_defaults,
+    user_config_exists,
+    VALID_ROOT_KEYS,
+    DEFAULT_NETWORK,
+    DEFAULT_ENVIRONMENT,
+    DEFAULT_CONTRACTS_DIR,
+)
+from gltest_cli.config.constants import DEFAULT_RPC_URL
+from gltest_cli.config.types import UserConfig, NetworkConfigData, PathConfig
+from unittest.mock import MagicMock
+from pathlib import Path
+
+# Test data
+VALID_CONFIG = {
+    "networks": {
+        "default": "localnet",
+        "localnet": {
+            "url": "http://localhost:8545",
+            "accounts": ["0x123", "0x456"],
+            "from": "0x123",
+        },
+        "testnet_asimov": {
+            "id": 4221,
+            "url": "http://34.32.169.58:9151",
+            "accounts": ["0x123", "0x456"],
+            "from": "0x123",
+        },
+    },
+    "paths": {"contracts": "contracts"},
+    "environment": ".env",
+}
+
+INVALID_CONFIG = {
+    "networks": {
+        "default": "invalid_network",
+        "localnet": {
+            "url": 123,  # Invalid type
+            "accounts": "not_a_list",  # Invalid type
+            "from": 456,  # Invalid type
+        },
+    },
+    "paths": {"invalid_path": "value"},
+    "environment": 123,  # Invalid type
+}
+
+
+def test_get_default_user_config():
+    config = get_default_user_config()
+
+    # Check root structure
+    assert isinstance(config, UserConfig)
+    assert all(key in config.__dict__ for key in VALID_ROOT_KEYS)
+
+    # Check networks
+    assert DEFAULT_NETWORK == config.default_network
+    assert DEFAULT_NETWORK in config.networks
+
+    # Check network configuration
+    network = config.networks[DEFAULT_NETWORK]
+    assert isinstance(network, NetworkConfigData)
+    assert network.url == DEFAULT_RPC_URL
+    assert isinstance(network.accounts, list)
+    assert isinstance(network.from_account, str)
+    assert network.from_account in network.accounts
+
+    # Check paths
+    assert isinstance(config.paths, PathConfig)
+    assert config.paths.contracts == DEFAULT_CONTRACTS_DIR
+
+    # Check environment
+    assert config.environment == DEFAULT_ENVIRONMENT
+
+
+def test_validate_raw_user_config_valid():
+    # Should not raise any exceptions
+    validate_raw_user_config(VALID_CONFIG)
+
+
+def test_validate_raw_user_config_invalid():
+    with pytest.raises(ValueError, match="Invalid configuration keys"):
+        validate_raw_user_config({"invalid_key": "value"})
+
+    with pytest.raises(ValueError, match="networks must be a dictionary"):
+        validate_raw_user_config({"networks": "not_a_dict"})
+
+    with pytest.raises(ValueError, match="default network invalid_network not found"):
+        validate_raw_user_config(
+            {
+                "networks": {
+                    "default": "invalid_network",
+                    "localnet": {"url": "http://localhost:8545"},
+                }
+            }
+        )
+
+    with pytest.raises(ValueError, match="network localnet must be a dictionary"):
+        validate_raw_user_config(
+            {"networks": {"default": "localnet", "localnet": "not_a_dict"}}
+        )
+
+    with pytest.raises(ValueError, match="Invalid network key"):
+        validate_raw_user_config(
+            {"networks": {"default": "localnet", "localnet": {"invalid_key": "value"}}}
+        )
+
+    with pytest.raises(ValueError, match="url must be a string"):
+        validate_raw_user_config(
+            {"networks": {"default": "localnet", "localnet": {"url": 123}}}
+        )
+
+    with pytest.raises(ValueError, match="accounts must be a list"):
+        validate_raw_user_config(
+            {
+                "networks": {
+                    "default": "localnet",
+                    "localnet": {"accounts": "not_a_list"},
+                }
+            }
+        )
+
+    with pytest.raises(ValueError, match="accounts must be strings"):
+        validate_raw_user_config(
+            {"networks": {"default": "localnet", "localnet": {"accounts": [123]}}}
+        )
+
+    with pytest.raises(ValueError, match="from must be a string"):
+        validate_raw_user_config(
+            {"networks": {"default": "localnet", "localnet": {"from": 123}}}
+        )
+
+    with pytest.raises(ValueError, match="paths must be a dictionary"):
+        validate_raw_user_config({"paths": "not_a_dict"})
+
+    with pytest.raises(ValueError, match="Invalid path keys"):
+        validate_raw_user_config({"paths": {"invalid_path": "value"}})
+
+    with pytest.raises(ValueError, match="environment must be a string"):
+        validate_raw_user_config({"environment": 123})
+
+    # Test validation for non-default networks
+    with pytest.raises(ValueError, match="network testnet must be a dictionary"):
+        validate_raw_user_config(
+            {"networks": {"default": "localnet", "testnet": "not_a_dict"}}
+        )
+
+    with pytest.raises(ValueError, match="Invalid network key"):
+        validate_raw_user_config(
+            {"networks": {"default": "localnet", "testnet": {"invalid_key": "value"}}}
+        )
+
+    with pytest.raises(ValueError, match="url must be a string"):
+        validate_raw_user_config(
+            {"networks": {"default": "localnet", "testnet": {"url": 123}}}
+        )
+
+    with pytest.raises(ValueError, match="accounts must be a list"):
+        validate_raw_user_config(
+            {
+                "networks": {
+                    "default": "localnet",
+                    "testnet": {"accounts": "not_a_list"},
+                }
+            }
+        )
+
+    with pytest.raises(ValueError, match="accounts must be strings"):
+        validate_raw_user_config(
+            {"networks": {"default": "localnet", "testnet": {"accounts": [123]}}}
+        )
+
+    with pytest.raises(ValueError, match="from must be a string"):
+        validate_raw_user_config(
+            {"networks": {"default": "localnet", "testnet": {"from": 123}}}
+        )
+
+    # Test required fields for non-default networks
+    with pytest.raises(ValueError, match="network testnet must have an id"):
+        validate_raw_user_config(
+            {"networks": {"default": "localnet", "testnet": {"accounts": ["0x123"]}}}
+        )
+
+    with pytest.raises(ValueError, match="network testnet must have a url"):
+        validate_raw_user_config(
+            {
+                "networks": {
+                    "default": "localnet",
+                    "testnet": {"id": 4221, "accounts": ["0x123"]},
+                }
+            }
+        )
+
+    with pytest.raises(ValueError, match="network testnet must have accounts"):
+        validate_raw_user_config(
+            {
+                "networks": {
+                    "default": "localnet",
+                    "testnet": {"id": 4221, "url": "http://testnet:8545"},
+                }
+            }
+        )
+
+    # Test that 'from' is optional for non-default networks
+    valid_config_without_from = {
+        "networks": {
+            "default": "localnet",
+            "testnet": {
+                "id": 4221,
+                "url": "http://testnet:8545",
+                "accounts": ["0x123", "0x456"],
+            },
+        }
+    }
+    # Should not raise any exception
+    validate_raw_user_config(valid_config_without_from)
+
+
+@patch("builtins.open", new_callable=mock_open, read_data=yaml.dump(VALID_CONFIG))
+@patch("gltest_cli.config.user.load_dotenv")
+def test_load_user_config(mock_load_dotenv, mock_file):
+    config = load_user_config("dummy_path")
+
+    # Check if file was opened
+    mock_file.assert_called_once_with("dummy_path", "r")
+
+    # Check if environment was loaded
+    mock_load_dotenv.assert_called_once_with(
+        dotenv_path=DEFAULT_ENVIRONMENT, override=True
+    )
+
+    # Check config structure
+    assert isinstance(config, UserConfig)
+
+    # Check default network
+    assert config.default_network == "localnet"
+    assert isinstance(config.networks["localnet"], NetworkConfigData)
+    assert config.networks["localnet"].id == 61999
+    assert config.networks["localnet"].url == "http://localhost:8545"
+    assert config.networks["localnet"].accounts == ["0x123", "0x456"]
+    assert config.networks["localnet"].from_account == "0x123"
+
+    # Check testnet_asimov network
+    assert isinstance(config.networks["testnet_asimov"], NetworkConfigData)
+    assert config.networks["testnet_asimov"].id == 4221
+    assert config.networks["testnet_asimov"].url == "http://34.32.169.58:9151"
+    assert config.networks["testnet_asimov"].accounts == ["0x123", "0x456"]
+    assert config.networks["testnet_asimov"].from_account == "0x123"
+
+    # Check paths
+    assert isinstance(config.paths, PathConfig)
+    assert config.paths.contracts == Path("contracts")
+
+    # Check environment
+    assert config.environment == ".env"
+
+
+def test_transform_raw_to_user_config_with_defaults():
+    # Test with empty config
+    config = transform_raw_to_user_config_with_defaults({})
+    assert isinstance(config, UserConfig)
+    assert all(key in config.__dict__ for key in VALID_ROOT_KEYS)
+
+    # Test with partial config
+    partial_config = {
+        "networks": {"default": "localnet", "localnet": {"url": "custom_url"}}
+    }
+    config = transform_raw_to_user_config_with_defaults(partial_config)
+    assert isinstance(config.networks["localnet"], NetworkConfigData)
+    assert config.networks["localnet"].url == "custom_url"
+    assert config.networks["localnet"].accounts is not None
+    assert config.networks["localnet"].from_account is not None
+
+    # Test with None network config
+    config = transform_raw_to_user_config_with_defaults(
+        {"networks": {"default": "localnet", "localnet": None}}
+    )
+    assert config.networks["localnet"] is not None
+    assert isinstance(config.networks["localnet"], NetworkConfigData)
+
+    # Test setting 'from' for non-default networks
+    test_config = {
+        "networks": {
+            "default": "localnet",
+            "localnet": {"url": "http://localhost:8545"},
+            "testnet": {"url": "http://testnet:8545", "accounts": ["0x123", "0x456"]},
+            "mainnet": {
+                "url": "http://mainnet:8545",
+                "accounts": ["0xabc", "0x789"],
+                "from": "0x789",  # Already set
+            },
+        }
+    }
+    config = transform_raw_to_user_config_with_defaults(test_config)
+
+    # Verify testnet got 'from' set to first account
+    assert config.networks["testnet"].from_account == "0x123"
+
+    # Verify mainnet kept its existing 'from' value
+    assert config.networks["mainnet"].from_account == "0x789"
+
+    # Verify localnet (default network) behavior remains unchanged
+    assert config.networks["localnet"].from_account is not None
+    assert (
+        config.networks["localnet"].from_account in config.networks["localnet"].accounts
+    )
+
+    # Test with custom paths
+    custom_paths_config = {
+        "networks": {"default": "localnet"},
+        "paths": {"contracts": "custom/contracts/path"},
+    }
+    config = transform_raw_to_user_config_with_defaults(custom_paths_config)
+    assert config.paths.contracts == Path("custom/contracts/path")
+
+    # Test with custom environment
+    custom_env_config = {
+        "networks": {"default": "localnet"},
+        "environment": "custom.env",
+    }
+    config = transform_raw_to_user_config_with_defaults(custom_env_config)
+    assert config.environment == "custom.env"
+
+
+@patch("pathlib.Path.cwd")
+def test_user_config_exists(mock_cwd):
+    mock_path = MagicMock()
+    mock_cwd.return_value = mock_path
+
+    # Test when config exists
+    config_file = MagicMock()
+    config_file.name = "gltest.config.yaml"
+    config_file.is_file.return_value = True
+    mock_path.iterdir.return_value = [config_file]
+    assert user_config_exists() is True
+
+    # Test when config doesn't exist
+    other_file = MagicMock()
+    other_file.name = "other_file.txt"
+    other_file.is_file.return_value = True
+    mock_path.iterdir.return_value = [other_file]
+    assert user_config_exists() is False
+
+    # Test with no files
+    mock_path.iterdir.return_value = []
+    assert user_config_exists() is False

genlayer_test-0.2.0.dist-info/RECORD

@@ -1,55 +0,0 @@
-genlayer_test-0.2.0.dist-info/licenses/LICENSE,sha256=che_H4vE0QUx3HvWrAa1_jDEVInift0U6VO15-QqEls,1064
-gltest/__init__.py,sha256=AK_YfRvwlhrOheOelUG8qIRG17on0-nFCF747dopg2w,332
-gltest/assertions.py,sha256=0dEk0VxcHK4I7GZPHxJmz-2jaA60V499gOSR74rZbfM,1748
-gltest/exceptions.py,sha256=deJPmrTe5gF33qkkKF2IVJY7lc_knI7Ql3N7jZ8aLZs,510
-gltest/plugin_config.py,sha256=8Z97RtEJ89OcRbki_oRuBBVct_q56BFmKvthan1y9Y4,840
-gltest/plugin_hooks.py,sha256=py1rzIR9QSsFOt8SEePPL96e-8DeiPFxvcPZurRlExM,1436
-gltest/types.py,sha256=BODmwTr2gAUEiO9FjiuTiWwuKvXgo4xZWstQWNUfnlw,156
-gltest/artifacts/__init__.py,sha256=qTt3TE19gVNWnQLUlt5aDe4nNvJ2YJ1jzDkMmYIsCG0,194
-gltest/artifacts/contract.py,sha256=jqdsJD9B4aUTpR4EODHaag5j-IvdWm3Ac4ektbpTxFo,6152
-gltest/glchain/__init__.py,sha256=X-mEbREoAOe9K4n74C55gCiXH4wItzY5HTJcg3_F3mI,412
-gltest/glchain/account.py,sha256=ZxYsfbtBXKVC5vV4pko3yyL6lhPljqIb68NgIgvInSc,403
-gltest/glchain/client.py,sha256=q04LIQy5SCIrYZflZiTapfeQ-AaSTa0w369ehnVbJLM,532
-gltest/glchain/contract.py,sha256=aNS2Wm93BG4kug4iyWembBDaNb2mYCTJOTfDzMPoiRE,10042
-gltest/helpers/__init__.py,sha256=I7HiTu_H7_hP65zY6Wl02r-5eAMr2eZvqBVmusuQLX4,180
-gltest/helpers/fixture_snapshot.py,sha256=DWLTsMbTnfhpv0_7_gkJpDKX4hJx-tlruX7x3FWL6UI,2073
-gltest/helpers/take_snapshot.py,sha256=eXqEKXM2hcox3pLGIcNddobU8zXPQvD-Iwf87eHqW2s,1276
-gltest_cli/main.py,sha256=Ti2-0Ev1x5_cM0D1UKqdgaDt80CDHEQGtdRne2qLm4M,53
-tests/artifact/test_contract_definition.py,sha256=vr3guuJOvsQorUyv_ahbNvUwfDi6cq_NKAbQMATMp1g,13803
-tests/artifact/contracts/duplicate_ic_contract_1.py,sha256=bSWsUVjBy5cGtI72cjnkstsMzuUJbB3IG5JjTxOF-dc,500
-tests/artifact/contracts/duplicate_ic_contract_2.py,sha256=bSWsUVjBy5cGtI72cjnkstsMzuUJbB3IG5JjTxOF-dc,500
-tests/artifact/contracts/not_ic_contract.py,sha256=hQyGnYiiVceYdLI2WrvcFgPqzy1S4-YMb9FPhiHEGSA,510
-tests/assertions/test_assertions.py,sha256=qzVrOdOM4xYtIy1sFHVAD_-naDHOequ23tEN0MELh0k,10781
-tests/examples/contracts/football_prediction_market.py,sha256=kdouFijjeCdIJyaVJlgXcqbBAXecA9_YdhklSsIW-QM,3219
-tests/examples/contracts/intelligent_oracle.py,sha256=WrNZWWoi1sz22Azt2EXgdWHDg5Ihca2pWUHrM9pVfQE,12319
-tests/examples/contracts/intelligent_oracle_factory.py,sha256=ax496IZuDCA728rRcbjwTaM4Q4E-Y1jGkHsEcyf1cig,1490
-tests/examples/contracts/llm_erc20.py,sha256=nfIs-7A79L46NgHQzWbPyEOUlzAlFLsf4K05acwKr_M,2523
-tests/examples/contracts/log_indexer.py,sha256=VwMC8_Gy1Z1qjuy5GeEMyepjZ3Z5y7VAOrHMl5MrjxI,1852
-tests/examples/contracts/multi_read_erc20.py,sha256=HsMJKGT9a9eZAO43Em7hCRfh1yyHDgcUbQ0gmOE1MXs,850
-tests/examples/contracts/multi_tenant_storage.py,sha256=aGLPC76FegXdnIjMjeGsu3s3AbKK9dtV6t1d_KoI8rI,1897
-tests/examples/contracts/read_erc20.py,sha256=kstiB93JHHajJe1GldzeawxnVYutjT8KE2d1bYTgggU,390
-tests/examples/contracts/storage.py,sha256=GZHBXhjc94eEkdSO1UWgcop0fEo0hD57KZM0ds3pUFM,490
-tests/examples/contracts/user_storage.py,sha256=j-RXxTIqb1dePYqP_pkeoCxxDq07VURryvzF_Q-sZmI,638
-tests/examples/contracts/wizard_of_coin.py,sha256=BJ0Nv6N-JJP_Pk7YUSXPPRxX5_mDRBDlfL6nabeaoyA,1606
-tests/examples/contracts/multi_file_contract/__init__.py,sha256=8O3BvoUrLSmc4uTf2jm7MyrmcaiGD0w8wPwotdAqZHQ,485
-tests/examples/contracts/multi_file_contract/other.py,sha256=jHDtjUL3eAUgE6yOYKFw_RfAH7kIwk8CvxUjbWHNruk,236
-tests/examples/tests/test_football_prediction_market.py,sha256=wFu024sq3IURLL1zyLyO_G1sRCjPTV7iImi87__dZ4Y,657
-tests/examples/tests/test_intelligent_oracle_factory.py,sha256=Nw7jO9bjD79AETT2QQl0Vun-yxSAAuqGSdkQn2Y3WUw,5377
-tests/examples/tests/test_llm_erc20.py,sha256=yL_5bbH2VC7jL3E6dDvSI6PfZ36bPtA4OxoysZpuLFc,1390
-tests/examples/tests/test_log_indexer.py,sha256=Km44SiA8dlA4WBqwugXVBCQUlODdf1dB4p4nt24HG9k,2649
-tests/examples/tests/test_multi_file_contract.py,sha256=pWmK6lcZrSAnDH09Z6Q-cXs8V6VGFhHkvgThvJKEB4U,512
-tests/examples/tests/test_multi_file_contract_legacy.py,sha256=Jx_u0rDrQJspQgFo1KUddcFgTcOhcE-YLuLgk3tKrCA,527
-tests/examples/tests/test_multi_read_erc20.py,sha256=Q3AKK7OZyTKRrG-tXmkPkoQOzQqVVDnFEWKDVVNVQLI,3062
-tests/examples/tests/test_multi_tenant_storage.py,sha256=XNR1AUpxkzXlRv_ltdgAF-HUkpAvWqIQ7Fb93zEeR2o,2376
-tests/examples/tests/test_read_erc20.py,sha256=_dXwdZoUTSMKwPhEmU3N2X3wNu2ke9ob0L3JKEyNjdE,1198
-tests/examples/tests/test_storage.py,sha256=FmA-pJohMBHlNFVzLlY3-asnq0kV33E5SRDCM-lWzoQ,664
-tests/examples/tests/test_storage_legacy.py,sha256=RNVnD0G9ilb4I2s0CPAAgJEuKUgEkkbItuesOfmv-pg,677
-tests/examples/tests/test_user_storage.py,sha256=QEgt2p22LAyzBnBb0YW4BWa_Jasrt15vrr1GuxXqqbI,2180
-tests/examples/tests/test_wizard_of_coin.py,sha256=aUDeV5w0XONMMS71Vzw80lHfcSM0z8RKPJSXAuDwRto,392
-tests/plugin/conftest.py,sha256=RKdoE5_zcMimeojAoA_GSFI9du4pMzMi1vZ1njtfoAs,28
-tests/plugin/test_plugin_hooks.py,sha256=FQOrkhoXLinq0sjvoYjr63Oqg-ZVPcNFeUrK4bqrn4E,2020
-genlayer_test-0.2.0.dist-info/METADATA,sha256=_okLWSmaUrqZVrIZ5fLCJvXFBlhmUoItqEoioj2JV2U,14814
-genlayer_test-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-genlayer_test-0.2.0.dist-info/entry_points.txt,sha256=rXhrPVq2IhVsd4uWzxzwCTx7jA1KcQIVNxDCUuxq4f8,89
-genlayer_test-0.2.0.dist-info/top_level.txt,sha256=-qiGZxTRBytujzgVcKpxjvQ-WNeUDjXa59ceGMwMpko,24
-genlayer_test-0.2.0.dist-info/RECORD,,

gltest/plugin_config.py

@@ -1,42 +0,0 @@
-from pathlib import Path
-
-_contracts_dir = None
-_rpc_url = None
-_default_wait_interval = None
-_default_wait_retries = None
-
-
-def set_contracts_dir(path: Path):
-    global _contracts_dir
-    _contracts_dir = path
-
-
-def get_contracts_dir() -> Path:
-    return Path(_contracts_dir)
-
-
-def set_rpc_url(rpc_url: str):
-    global _rpc_url
-    _rpc_url = rpc_url
-
-
-def get_rpc_url() -> str:
-    return _rpc_url
-
-
-def set_default_wait_interval(default_wait_interval: int):
-    global _default_wait_interval
-    _default_wait_interval = default_wait_interval
-
-
-def get_default_wait_interval() -> int:
-    return _default_wait_interval
-
-
-def set_default_wait_retries(default_wait_retries: int):
-    global _default_wait_retries
-    _default_wait_retries = default_wait_retries
-
-
-def get_default_wait_retries() -> int:
-    return _default_wait_retries