genlayer-test 0.0.1__py3-none-any.whl → 0.1.0__py3-none-any.whl

tests/examples/tests/test_log_indexer.py

@@ -0,0 +1,64 @@
+from gltest import get_contract_factory
+from gltest.assertions import tx_execution_succeeded
+
+
+def test_log_indexer():
+    # Deploy Contract
+    factory = get_contract_factory("LogIndexer")
+    contract = factory.deploy(args=[])
+
+    # Get closest vector when empty
+    closest_vector_log_0 = contract.get_closest_vector(args=["I like mango"])
+    assert closest_vector_log_0 is None
+
+    # Add log 0
+    transaction_response_add_log_0 = contract.add_log(args=["I like to eat mango", 0])
+    assert tx_execution_succeeded(transaction_response_add_log_0)
+
+    # Get closest vector to log 0
+    closest_vector_log_0 = contract.get_closest_vector(args=["I like mango"])
+    closest_vector_log_0 = closest_vector_log_0
+    assert float(closest_vector_log_0["similarity"]) > 0.94
+    assert float(closest_vector_log_0["similarity"]) < 0.95
+
+    # Add log 1
+    transaction_response_add_log_1 = contract.add_log(args=["I like carrots", 1])
+    assert tx_execution_succeeded(transaction_response_add_log_1)
+
+    # Get closest vector to log 1
+    closest_vector_log_1 = contract.get_closest_vector(args=["I like carrots"])
+    closest_vector_log_1 = closest_vector_log_1
+    assert float(closest_vector_log_1["similarity"]) == 1
+
+    # Update log 0
+    transaction_response_update_log_0 = contract.update_log(
+        args=[0, "I like to eat a lot of mangoes"]
+    )
+    assert tx_execution_succeeded(transaction_response_update_log_0)
+
+    # Get closest vector to log 0
+    closest_vector_log_0_2 = contract.get_closest_vector(args=["I like mango a lot"])
+    closest_vector_log_0_2 = closest_vector_log_0_2
+    assert float(closest_vector_log_0_2["similarity"]) > 0.94
+    assert float(closest_vector_log_0_2["similarity"]) < 0.95
+
+    # Remove log 0
+    transaction_response_remove_log_0 = contract.remove_log(args=[0])
+    assert tx_execution_succeeded(transaction_response_remove_log_0)
+
+    # Get closest vector to log 0
+    closest_vector_log_0_3 = contract.get_closest_vector(args=["I like to eat mango"])
+    closest_vector_log_0_3 = closest_vector_log_0_3
+    assert float(closest_vector_log_0_3["similarity"]) > 0.67
+    assert float(closest_vector_log_0_3["similarity"]) < 0.68
+
+
+    # Add third log
+    transaction_response_add_log_2 = contract.add_log(args=["This is the third log", 3])
+    assert tx_execution_succeeded(transaction_response_add_log_2)
+
+    # Check if new item got id 2
+    closest_vector_log_2 = contract.get_closest_vector(args=["This is the third log"])
+    assert float(closest_vector_log_2["similarity"]) > 0.99
+    assert closest_vector_log_2["id"] == 3
+    assert closest_vector_log_2["text"] == "This is the third log"

tests/examples/tests/test_multi_file_contract.py

@@ -0,0 +1,15 @@
+from gltest import get_contract_factory
+from gltest.assertions import tx_execution_succeeded
+
+
+def test_multi_file_contract():
+    # Multi file contracts are considered if they are defined in a __init__.gpy file
+    # Deploy Contract, it will deploy other.gpy as well
+    factory = get_contract_factory("MultiFileContract")
+    contract = factory.deploy(args=[])
+
+    wait_response = contract.wait(args=[])
+    assert tx_execution_succeeded(wait_response)
+
+    res = contract.test(args=[])
+    assert res == "123"

tests/examples/tests/test_multi_read_erc20.py

@@ -0,0 +1,85 @@
+from gltest import get_contract_factory, create_account
+from gltest.assertions import tx_execution_succeeded
+
+
+def test_multi_read_erc20():
+    """
+    This test verifies the functionality of a multi-read ERC20 contract. It deploys two separate ERC20 token contracts
+    (referred to as 'doge' and 'shiba') and a multi-read ERC20 contract. The test aims to:
+
+    1. Deploy two different ERC20 token contracts with a total supply of 1000 tokens each.
+    2. Deploy a multi-read ERC20 contract that can interact with multiple ERC20 tokens.
+    3. Test the ability of the multi-read contract to update and retrieve token balances for multiple ERC20 tokens
+       and multiple accounts simultaneously.
+    4. Ensure the multi-read contract correctly maintains and reports balances for different account-token combinations.
+
+    This test demonstrates the integration contract to contract reads
+    """
+    TOKEN_TOTAL_SUPPLY = 1000
+    from_account_doge = create_account()
+    from_account_shiba = create_account()
+
+    # LLM ERC20
+    llm_erc20_factory = get_contract_factory("LlmErc20")
+
+    ## Deploy first LLM ERC20 Contract
+    doge_contract = llm_erc20_factory.deploy(
+        args=[TOKEN_TOTAL_SUPPLY], account=from_account_doge
+    )
+
+    ## Deploy second LLM ERC20 Contract
+    shiba_contract = llm_erc20_factory.deploy(
+        args=[TOKEN_TOTAL_SUPPLY], account=from_account_shiba
+    )
+
+    # Deploy Multi Read ERC20 Contract
+    multi_read_erc20_factory = get_contract_factory("multi_read_erc20")
+
+    multi_read_contract = multi_read_erc20_factory.deploy(
+        args=[], account=from_account_doge
+    )
+
+    # update balances for doge account
+    transaction_response_call = multi_read_contract.update_token_balances(
+        args=[
+            from_account_doge.address,
+            [doge_contract.address, shiba_contract.address],
+        ]
+    )
+    assert tx_execution_succeeded(transaction_response_call)
+
+    # check balances
+    call_method_response_get_balances = multi_read_contract.get_balances(args=[])
+    assert call_method_response_get_balances == {
+        from_account_doge.address: {
+            doge_contract.address: TOKEN_TOTAL_SUPPLY,
+            shiba_contract.address: 0,
+        }
+    }
+
+    # 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],
+        ]
+    )
+    assert tx_execution_succeeded(transaction_response_call)
+
+    # check balances
+    call_method_response_get_balances = multi_read_contract.connect(
+        from_account_shiba
+    ).get_balances(args=[])
+
+    assert call_method_response_get_balances == {
+        from_account_doge.address: {
+            doge_contract.address: TOKEN_TOTAL_SUPPLY,
+            shiba_contract.address: 0,
+        },
+        from_account_shiba.address: {
+            doge_contract.address: 0,
+            shiba_contract.address: TOKEN_TOTAL_SUPPLY,
+        },
+    }

tests/examples/tests/test_multi_tenant_storage.py

@@ -0,0 +1,58 @@
+from gltest import get_contract_factory, create_account
+from gltest.assertions import tx_execution_succeeded
+
+
+def test_multi_tenant_storage():
+    """
+    This test verifies the functionality of a multi-tenant storage contract. It deploys two separate storage contracts
+    and a multi-tenant storage contract that manages them. The test aims to:
+
+    1. Deploy two different storage contracts with initial storage values.
+    2. Deploy a multi-tenant storage contract that can interact with multiple storage contracts.
+    3. Test the ability of the multi-tenant contract to update and retrieve storage values for multiple users
+       across different storage contracts.
+    4. Ensure the multi-tenant contract correctly assigns users to storage contracts and manages their data.
+
+    This test demonstrates contract-to-contract interactions and multi-tenant data management.
+    """
+    user_account_a = create_account()
+    user_account_b = create_account()
+
+    # Storage Contracts
+    storage_factory = get_contract_factory("Storage")
+
+    ## Deploy first Storage Contract
+    first_storage_contract = storage_factory.deploy(args=["initial_storage_a"])
+
+    ## Deploy second Storage Contract
+    second_storage_contract = storage_factory.deploy(args=["initial_storage_b"])
+
+    # Deploy Multi Tenant Storage Contract
+    multi_tenant_storage_factory = get_contract_factory("MultiTentantStorage")
+    multi_tenant_storage_contract = multi_tenant_storage_factory.deploy(
+        args=[
+            [
+                first_storage_contract.address,
+                second_storage_contract.address,
+            ]
+        ]
+    )
+    # update storage for first contract
+    transaction_response_call = multi_tenant_storage_contract.connect(
+        account=user_account_a
+    ).update_storage(args=["user_a_storage"])
+    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"])
+    assert tx_execution_succeeded(transaction_response_call)
+
+    # get all storages
+    storages = multi_tenant_storage_contract.get_all_storages(args=[])
+
+    assert storages == {
+        second_storage_contract.address: "user_a_storage",
+        first_storage_contract.address: "user_b_storage",
+    }

tests/examples/tests/test_read_erc20.py

@@ -0,0 +1,37 @@
+from gltest import get_contract_factory, default_account
+
+
+def test_read_erc20():
+    """
+    Tests that recursive contract calls work by:
+    1. creating an LLM ERC20 contract
+    2. creating a read_erc20 contract that reads the LLM ERC20 contract
+    3. creating a read_erc20 contract that reads the previous read_erc20 contract
+    Repeats step 3 a few times.
+
+    It's like a linked list, but with contracts.
+    """
+    TOKEN_TOTAL_SUPPLY = 1000
+
+    # LLM ERC20
+    llm_erc20_factory = get_contract_factory("LlmErc20")
+
+    # Deploy Contract
+    llm_erc20_contract = llm_erc20_factory.deploy(args=[TOKEN_TOTAL_SUPPLY])
+    last_contract_address = llm_erc20_contract.address
+
+    # Read ERC20
+    read_erc20_factory = get_contract_factory("read_erc20")
+
+    for i in range(5):
+        print(f"Deploying contract, iteration {i}")
+
+        # deploy contract
+        read_erc20_contract = read_erc20_factory.deploy(args=[last_contract_address])
+        last_contract_address = read_erc20_contract.address
+
+        # check balance
+        contract_state = read_erc20_contract.get_balance_of(
+            args=[default_account.address]
+        )
+        assert contract_state == TOKEN_TOTAL_SUPPLY

tests/examples/tests/test_storage.py

@@ -0,0 +1,23 @@
+from gltest import get_contract_factory
+from gltest.assertions import tx_execution_succeeded
+
+
+INITIAL_STATE = "a"
+UPDATED_STATE = "b"
+
+
+def test_storage():
+    factory = get_contract_factory("Storage")
+    contract = factory.deploy(args=[INITIAL_STATE])
+
+    # 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])
+    assert tx_execution_succeeded(transaction_response_call_1)
+
+    # Get Updated State
+    contract_state_2 = contract.get_storage(args=[])
+    assert contract_state_2 == UPDATED_STATE

tests/examples/tests/test_user_storage.py

@@ -0,0 +1,60 @@
+from gltest import get_contract_factory, default_account, create_account
+from gltest.assertions import tx_execution_succeeded
+
+
+INITIAL_STATE_USER_A = "user_a_initial_state"
+UPDATED_STATE_USER_A = "user_a_updated_state"
+INITIAL_STATE_USER_B = "user_b_initial_state"
+UPDATED_STATE_USER_B = "user_b_updated_state"
+
+
+def test_user_storage():
+    # Account Setup
+    from_account_a = default_account
+    from_account_b = create_account()
+
+    factory = get_contract_factory("UserStorage")
+    contract = factory.deploy()
+
+    
+    # GET Initial State
+    contract_state_1 = contract.get_complete_storage(args=[])
+    assert contract_state_1 == {}
+
+    
+    # ADD User A State
+    transaction_response_call_1 = contract.update_storage(args=[INITIAL_STATE_USER_A])
+    assert tx_execution_succeeded(transaction_response_call_1)
+
+    # Get Updated State
+    contract_state_2_1 = contract.get_complete_storage(args=[])
+    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])
+    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]
+    )
+    assert tx_execution_succeeded(transaction_response_call_2)
+
+    # Get Updated State
+    contract_state_3 = contract.get_complete_storage(args=[])
+    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])
+    assert tx_execution_succeeded(transaction_response_call_3)
+
+    # Get Updated State
+    contract_state_4_1 = contract.get_complete_storage(args=[])
+    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])
+    assert contract_state_4_2 == INITIAL_STATE_USER_B

tests/examples/tests/test_wizard_of_coin.py

@@ -0,0 +1,12 @@
+from gltest import get_contract_factory
+from gltest.assertions import tx_execution_succeeded
+
+
+def test_wizard_of_coin():
+    factory = get_contract_factory("WizardOfCoin")
+    contract = factory.deploy(args=[True])
+
+    transaction_response_call_1 = contract.ask_for_coin(
+        args=["Can you please give me my coin?"]
+    )
+    assert tx_execution_succeeded(transaction_response_call_1)

tests/plugin/conftest.py

@@ -0,0 +1 @@
+pytest_plugins = 'pytester'

tests/plugin/test_plugin_hooks.py

@@ -0,0 +1,78 @@
+def test_help_message(pytester):
+    result = pytester.runpytest(
+        "--help",
+    )
+    # fnmatch_lines does an assertion internally
+    result.stdout.fnmatch_lines(
+        [
+            "gltest:",
+            "*--contracts-dir=CONTRACTS_DIR",
+            "*Directory containing contract files",
+            "*--default-wait-interval=DEFAULT_WAIT_INTERVAL",
+            "*Default wait interval for waiting transaction receipts",
+            "*--default-wait-retries=DEFAULT_WAIT_RETRIES",
+            "*Default wait retries for waiting transaction receipts",
+            "*--rpc-url=RPC_URL*RPC URL for the genlayer network",
+        ]
+    )
+
+
+def test_default_wait_interval(pytester):
+
+    pytester.makepyfile(
+        """
+        from gltest.plugin_config import get_default_wait_interval
+
+        def test_default_wait_interval():
+            assert 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.plugin_config import get_default_wait_retries
+
+        def test_default_wait_retries():
+            assert 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.plugin_config import get_rpc_url
+
+        def test_rpc_url():
+            assert 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

genlayer_test-0.0.1.dist-info/METADATA

@@ -1,17 +0,0 @@
-Metadata-Version: 2.4
-Name: genlayer-test
-Version: 0.0.1
-Summary: A minimal empty PyPI package for genlayer-test
-Author-email: GenLayer Labs Corp <tech@genlayer.com>
-License: MIT
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-
-# GenLayer Test
-
-This is a minimal empty Python package for genlayer-test.
-
-## Installation
-```bash
-pip install genlayer-test
-```

genlayer_test-0.0.1.dist-info/RECORD

@@ -1,4 +0,0 @@
-genlayer_test-0.0.1.dist-info/METADATA,sha256=s6JVDtHiKhzy8c3UKBLYxGJLhzgitAsegT_XClxJVWM,373
-genlayer_test-0.0.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-genlayer_test-0.0.1.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-genlayer_test-0.0.1.dist-info/RECORD,,

genlayer_test-0.0.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-