genlayer-test 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

tests/examples/tests/test_multi_read_erc20.py

@@ -61,11 +61,11 @@ def test_multi_read_erc20(setup_validators):
             from_account_doge.address,
             [doge_contract.address, shiba_contract.address],
         ]
-    )
+    ).transact()
     assert tx_execution_succeeded(transaction_response_call)
 
     # check balances
-    call_method_response_get_balances = multi_read_contract.get_balances(args=[])
+    call_method_response_get_balances = multi_read_contract.get_balances(args=[]).call()
     assert call_method_response_get_balances == {
         from_account_doge.address: {
             doge_contract.address: TOKEN_TOTAL_SUPPLY,
@@ -74,20 +74,22 @@ def test_multi_read_erc20(setup_validators):
     }
 
     # update balances for shiba account
-    transaction_response_call = multi_read_contract.connect(
-        from_account_shiba
-    ).update_token_balances(
-        args=[
-            from_account_shiba.address,
-            [doge_contract.address, shiba_contract.address],
-        ]
+    transaction_response_call = (
+        multi_read_contract.connect(from_account_shiba)
+        .update_token_balances(
+            args=[
+                from_account_shiba.address,
+                [doge_contract.address, shiba_contract.address],
+            ]
+        )
+        .transact()
     )
     assert tx_execution_succeeded(transaction_response_call)
 
     # check balances
-    call_method_response_get_balances = multi_read_contract.connect(
-        from_account_shiba
-    ).get_balances(args=[])
+    call_method_response_get_balances = (
+        multi_read_contract.connect(from_account_shiba).get_balances(args=[]).call()
+    )
 
     assert call_method_response_get_balances == {
         from_account_doge.address: {

tests/examples/tests/test_multi_tenant_storage.py

@@ -48,19 +48,23 @@ def test_multi_tenant_storage(setup_validators):
         ]
     )
     # update storage for first contract
-    transaction_response_call = multi_tenant_storage_contract.connect(
-        account=user_account_a
-    ).update_storage(args=["user_a_storage"])
+    transaction_response_call = (
+        multi_tenant_storage_contract.connect(account=user_account_a)
+        .update_storage(args=["user_a_storage"])
+        .transact()
+    )
     assert tx_execution_succeeded(transaction_response_call)
 
     # update storage for second contract
-    transaction_response_call = multi_tenant_storage_contract.connect(
-        account=user_account_b
-    ).update_storage(args=["user_b_storage"])
+    transaction_response_call = (
+        multi_tenant_storage_contract.connect(account=user_account_b)
+        .update_storage(args=["user_b_storage"])
+        .transact()
+    )
     assert tx_execution_succeeded(transaction_response_call)
 
     # get all storages
-    storages = multi_tenant_storage_contract.get_all_storages(args=[])
+    storages = multi_tenant_storage_contract.get_all_storages(args=[]).call()
 
     assert storages == {
         second_storage_contract.address: "user_a_storage",

tests/examples/tests/test_read_erc20.py

@@ -34,5 +34,5 @@ def test_read_erc20(setup_validators):
         # check balance
         contract_state = read_erc20_contract.get_balance_of(
             args=[get_default_account().address]
-        )
+        ).call()
         assert contract_state == TOKEN_TOTAL_SUPPLY

tests/examples/tests/test_storage.py

@@ -12,15 +12,15 @@ def test_storage(setup_validators):
     contract = factory.deploy(args=[INITIAL_STATE], wait_retries=40)
 
     # Get initial state
-    contract_state_1 = contract.get_storage(args=[])
+    contract_state_1 = contract.get_storage(args=[]).call()
     assert contract_state_1 == INITIAL_STATE
 
     # Update State
     transaction_response_call_1 = contract.update_storage(
-        args=[UPDATED_STATE], wait_retries=40
-    )
+        args=[UPDATED_STATE]
+    ).transact(wait_retries=40)
     assert tx_execution_succeeded(transaction_response_call_1)
 
     # Get Updated State
-    contract_state_2 = contract.get_storage(args=[])
+    contract_state_2 = contract.get_storage(args=[]).call()
     assert contract_state_2 == UPDATED_STATE

tests/examples/tests/test_storage_legacy.py

@@ -12,13 +12,15 @@ def test_storage_legacy(setup_validators):
     contract = factory.deploy(args=[INITIAL_STATE])
 
     # Get initial state
-    contract_state_1 = contract.get_storage(args=[])
+    contract_state_1 = contract.get_storage(args=[]).call()
     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]
+    ).transact()
     assert tx_execution_succeeded(transaction_response_call_1)
 
     # Get Updated State
-    contract_state_2 = contract.get_storage(args=[])
+    contract_state_2 = contract.get_storage(args=[]).call()
     assert contract_state_2 == UPDATED_STATE

tests/examples/tests/test_user_storage.py

@@ -37,41 +37,51 @@ def test_user_storage(setup_validators):
     contract = factory.deploy()
 
     # GET Initial State
-    contract_state_1 = contract.get_complete_storage(args=[])
+    contract_state_1 = contract.get_complete_storage(args=[]).call()
     assert contract_state_1 == {}
 
     # ADD User A State
-    transaction_response_call_1 = contract.update_storage(args=[INITIAL_STATE_USER_A])
+    transaction_response_call_1 = contract.update_storage(
+        args=[INITIAL_STATE_USER_A]
+    ).transact()
     assert tx_execution_succeeded(transaction_response_call_1)
 
     # Get Updated State
-    contract_state_2_1 = contract.get_complete_storage(args=[])
+    contract_state_2_1 = contract.get_complete_storage(args=[]).call()
     assert contract_state_2_1[from_account_a.address] == INITIAL_STATE_USER_A
 
     # Get Updated State
-    contract_state_2_2 = contract.get_account_storage(args=[from_account_a.address])
+    contract_state_2_2 = contract.get_account_storage(
+        args=[from_account_a.address]
+    ).call()
     assert contract_state_2_2 == INITIAL_STATE_USER_A
 
     # ADD User B State
-    transaction_response_call_2 = contract.connect(from_account_b).update_storage(
-        args=[INITIAL_STATE_USER_B]
+    transaction_response_call_2 = (
+        contract.connect(from_account_b)
+        .update_storage(args=[INITIAL_STATE_USER_B])
+        .transact()
     )
     assert tx_execution_succeeded(transaction_response_call_2)
 
     # Get Updated State
-    contract_state_3 = contract.get_complete_storage(args=[])
+    contract_state_3 = contract.get_complete_storage(args=[]).call()
     assert contract_state_3[from_account_a.address] == INITIAL_STATE_USER_A
     assert contract_state_3[from_account_b.address] == INITIAL_STATE_USER_B
 
     # UPDATE User A State
-    transaction_response_call_3 = contract.update_storage(args=[UPDATED_STATE_USER_A])
+    transaction_response_call_3 = contract.update_storage(
+        args=[UPDATED_STATE_USER_A]
+    ).transact()
     assert tx_execution_succeeded(transaction_response_call_3)
 
     # Get Updated State
-    contract_state_4_1 = contract.get_complete_storage(args=[])
+    contract_state_4_1 = contract.get_complete_storage(args=[]).call()
     assert contract_state_4_1[from_account_a.address] == UPDATED_STATE_USER_A
     assert contract_state_4_1[from_account_b.address] == INITIAL_STATE_USER_B
 
     # Get Updated State
-    contract_state_4_2 = contract.get_account_storage(args=[from_account_b.address])
+    contract_state_4_2 = contract.get_account_storage(
+        args=[from_account_b.address]
+    ).call()
     assert contract_state_4_2 == INITIAL_STATE_USER_B

tests/examples/tests/test_wizard_of_coin.py

@@ -23,5 +23,5 @@ def test_wizard_of_coin(setup_validators):
 
     transaction_response_call_1 = contract.ask_for_coin(
         args=["Can you please give me my coin?"]
-    )
+    ).transact()
     assert tx_execution_succeeded(transaction_response_call_1)

tests/gltest_cli/config/test_config_integration.py

@@ -0,0 +1,432 @@
+def test_leader_only_network_config_true(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_leader_only_network_config():
+            general_config = get_general_config()
+            assert general_config.get_leader_only() == True
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    url: "http://127.0.0.1:4000/api"
+    leader_only: true
+
+paths:
+  contracts: "contracts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest("-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_leader_only_network_config PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_leader_only_network_config_false(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_leader_only_network_config():
+            general_config = get_general_config()
+            assert general_config.get_leader_only() == False
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    url: "http://127.0.0.1:4000/api"
+    leader_only: false
+
+paths:
+  contracts: "contracts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest("-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_leader_only_network_config PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_leader_only_cli_overrides_network_config(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_leader_only_cli_overrides():
+            general_config = get_general_config()
+            assert general_config.get_leader_only() == True
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    url: "http://127.0.0.1:4000/api"
+    leader_only: false
+
+paths:
+  contracts: "contracts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    # CLI flag should override network config
+    result = pytester.runpytest("--leader-only", "-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_leader_only_cli_overrides PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_leader_only_network_config_default(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_leader_only_network_config_default():
+            general_config = get_general_config()
+            assert general_config.get_leader_only() == False
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    url: "http://127.0.0.1:4000/api"
+
+paths:
+  contracts: "contracts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest("-v")
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_leader_only_network_config_default PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_custom_accounts_config(pytester):
+    """Test custom accounts configuration."""
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_custom_accounts():
+            general_config = get_general_config()
+            accounts = general_config.get_accounts_keys()
+            assert len(accounts) == 3
+            assert accounts[0] == "account1_private_key"
+            assert accounts[1] == "account2_private_key"
+            assert accounts[2] == "account3_private_key"
+            from_account = general_config.get_default_account_key()
+            assert from_account == "account1_private_key"
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    url: "http://127.0.0.1:4000/api"
+    accounts:
+      - "account1_private_key"
+      - "account2_private_key"
+      - "account3_private_key"
+
+paths:
+  contracts: "contracts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest("-v")
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_custom_accounts PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_from_account_config(pytester):
+    """Test 'from' account configuration."""
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_from_account():
+            general_config = get_general_config()
+            from_account = general_config.get_default_account_key()
+            assert from_account == "account2_private_key"
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    url: "http://127.0.0.1:4000/api"
+    accounts:
+      - "account1_private_key"
+      - "account2_private_key"
+      - "account3_private_key"
+    from: "account2_private_key"
+
+paths:
+  contracts: "contracts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest("-v")
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_from_account PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_multiple_networks_config(pytester):
+    """Test multiple networks configuration."""
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_multiple_networks():
+            general_config = get_general_config()
+            # Default should be testnet
+            assert general_config.get_network_name() == "testnet"
+            rpc_url = general_config.get_rpc_url()
+            assert rpc_url == "https://testnet.example.com"
+    """
+    )
+
+    config_content = """
+networks:
+  default: testnet
+  localnet:
+    id: 61999
+    url: "http://127.0.0.1:4000/api"
+    accounts:
+      - "local_account1"
+      - "local_account2"
+  testnet:
+    id: 5555
+    url: "https://testnet.example.com"
+    accounts:
+      - "testnet_account1"
+      - "testnet_account2"
+    leader_only: true
+
+paths:
+  contracts: "contracts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest("-v")
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_multiple_networks PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_custom_paths_config(pytester):
+    """Test custom paths configuration."""
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+        from pathlib import Path
+
+        def test_custom_paths():
+            general_config = get_general_config()
+            assert general_config.get_contracts_dir() == Path("src/contracts")
+            assert general_config.get_artifacts_dir() == Path("build/artifacts")
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    url: "http://127.0.0.1:4000/api"
+
+paths:
+  contracts: "src/contracts"
+  artifacts: "build/artifacts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest("-v")
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_custom_paths PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_custom_environment_file(pytester):
+    """Test custom environment file configuration."""
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_custom_environment():
+            general_config = get_general_config()
+            assert general_config.user_config.environment == ".env.test"
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    url: "http://127.0.0.1:4000/api"
+
+paths:
+  contracts: "contracts"
+
+environment: .env.test
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest("-v")
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_custom_environment PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_cli_network_override(pytester):
+    """Test CLI network override of config file."""
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_network_override():
+            general_config = get_general_config()
+            assert general_config.get_network_name() == "testnet"
+            rpc_url = general_config.get_rpc_url()
+            assert rpc_url == "https://testnet.example.com"
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    id: 61999
+    url: "http://127.0.0.1:4000/api"
+    accounts:
+      - "local_account1"
+  testnet:
+    id: 5555
+    url: "https://testnet.example.com"
+    accounts:
+      - "testnet_account1"
+
+paths:
+  contracts: "contracts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest("--network=testnet", "-v")
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_network_override PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_wait_interval_and_retries_config(pytester):
+    """Test default wait interval and retries from CLI."""
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_wait_config():
+            general_config = get_general_config()
+            assert general_config.get_default_wait_interval() == 3000
+            assert general_config.get_default_wait_retries() == 20
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    url: "http://127.0.0.1:4000/api"
+
+paths:
+  contracts: "contracts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest(
+        "--default-wait-interval=3000", "--default-wait-retries=20", "-v"
+    )
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_wait_config PASSED*",
+        ]
+    )
+    assert result.ret == 0