Change pytest scope to function for all integration tests:

- Instantiate a new geth instance for each test to avoid muddied
  context between tests

- Lower the ``dev.period`` to ``1`` since the tests don't need to account for
  each other anymore

- Parallelize the tests in CI with pytest-xdist (``-n 10``)

- Properly disconnect the ``async_await_w3`` ws tests

Author: fselmo

newsfragments/3659.internal.rst

@@ -0,0 +1 @@
+Run each integration test in isolation and parallelize, instead of running them all within a single `geth` (for example) process. This prevents muddied test contexts.

tests/core/eth-module/test_transactions.py

@@ -2,14 +2,24 @@
 import collections
 import itertools
 
+from eth_account import (
+    Account,
+)
 from eth_utils import (
     to_checksum_address,
     to_int,
 )
 from hexbytes import (
     HexBytes,
 )
+import pytest_asyncio
 
+from tests.core.contracts.utils import (
+    async_deploy,
+)
+from web3._utils.contract_sources.contract_data.math_contract import (
+    MATH_CONTRACT_DATA,
+)
 from web3._utils.ens import (
     ens_addresses,
 )
@@ -29,6 +39,20 @@
 RECEIPT_TIMEOUT = 0.2
 
 
+@pytest.fixture
+def async_math_contract_factory(async_w3):
+    return async_w3.eth.contract(**MATH_CONTRACT_DATA)
+
+
+@pytest_asyncio.fixture
+async def async_math_contract(
+    async_w3, async_math_contract_factory, address_conversion_func
+):
+    return await async_deploy(
+        async_w3, async_math_contract_factory, address_conversion_func
+    )
+
+
 def _tx_indexing_response_iterator():
     while True:
         yield {"error": {"message": "transaction indexing in progress"}}
@@ -420,3 +444,80 @@ async def test_async_send_raw_blob_transaction(async_w3):
     assert transaction["blobVersionedHashes"][0] == HexBytes(
         "0x0127c38bcad458d932e828b580b9ad97310be01407dfa0ed88118735980a3e9a"
     )
+
+
+@pytest.mark.asyncio
+async def test_send_set_code_transaction(async_w3, async_math_contract):
+    pkey = async_w3.provider.ethereum_tester.backend.account_keys[0]
+    acct = Account.from_key(pkey)
+
+    nonce = await async_w3.eth.get_transaction_count(acct.address)
+    chain_id = await async_w3.eth.chain_id
+
+    math_contract_address = (
+        f"0x{async_math_contract.address.hex()}"
+        if isinstance(async_math_contract.address, bytes)
+        else async_math_contract.address
+    )
+    auth = {
+        "chainId": chain_id,
+        "address": math_contract_address,
+        "nonce": nonce + 1,
+    }
+    signed_auth = acct.sign_authorization(auth)
+
+    # get current math counter and increase it only in the delegation by n
+    math_counter = await async_math_contract.functions.counter().call()
+    built_tx = await async_math_contract.functions.incrementCounter(
+        math_counter + 1337
+    ).build_transaction({})
+    txn = {
+        "chainId": chain_id,
+        "to": acct.address,
+        "value": 0,
+        "gas": 200_000,
+        "nonce": nonce,
+        "maxPriorityFeePerGas": 10**9,
+        "maxFeePerGas": 10**9,
+        "data": built_tx["data"],
+        "authorizationList": [signed_auth],
+    }
+
+    tx_hash = await async_w3.eth.send_transaction(txn)
+    get_tx = await async_w3.eth.get_transaction(tx_hash)
+    await async_w3.eth.wait_for_transaction_receipt(tx_hash, timeout=10)
+
+    code = await async_w3.eth.get_code(acct.address)
+
+    assert code.to_0x_hex().lower() == f"0xef0100{math_contract_address[2:].lower()}"
+    delegated = async_w3.eth.contract(address=acct.address, abi=async_math_contract.abi)
+    # assert the math counter is increased by 1337 only in delegated acct
+    assert await async_math_contract.functions.counter().call() == math_counter
+    delegated_call = await delegated.functions.counter().call()
+    assert delegated_call == math_counter + 1337
+
+    assert len(get_tx["authorizationList"]) == 1
+    get_auth = get_tx["authorizationList"][0]
+    assert get_auth["chainId"] == chain_id
+    assert get_auth["address"].lower() == math_contract_address.lower()
+    assert get_auth["nonce"] == nonce + 1
+    assert isinstance(get_auth["yParity"], int)
+    assert isinstance(get_auth["r"], HexBytes)
+    assert isinstance(get_auth["s"], HexBytes)
+
+    # reset code
+    reset_auth = {
+        "chainId": chain_id,
+        "address": "0x" + ("00" * 20),
+        "nonce": nonce + 3,
+    }
+    signed_reset_auth = acct.sign_authorization(reset_auth)
+    new_txn = dict(txn)
+    new_txn["authorizationList"] = [signed_reset_auth]
+    new_txn["nonce"] = nonce + 2
+
+    reset_tx_hash = await async_w3.eth.send_transaction(new_txn)
+    await async_w3.eth.wait_for_transaction_receipt(reset_tx_hash, timeout=10)
+
+    reset_code = await async_w3.eth.get_code(acct.address)
+    assert reset_code == HexBytes("0x")

tests/integration/conftest.py

@@ -19,47 +19,47 @@
 )
 
 
-@pytest.fixture(scope="module")
+@pytest.fixture
 def math_contract_factory(w3):
     contract_factory = w3.eth.contract(
         abi=MATH_CONTRACT_ABI, bytecode=MATH_CONTRACT_BYTECODE
     )
     return contract_factory
 
 
-@pytest.fixture(scope="module")
+@pytest.fixture
 def emitter_contract_factory(w3):
     contract_factory = w3.eth.contract(
         abi=EMITTER_CONTRACT_ABI, bytecode=EMITTER_CONTRACT_BYTECODE
     )
     return contract_factory
 
 
-@pytest.fixture(scope="module")
+@pytest.fixture
 def revert_contract_factory(w3):
     contract_factory = w3.eth.contract(
         abi=REVERT_CONTRACT_ABI, bytecode=REVERT_CONTRACT_BYTECODE
     )
     return contract_factory
 
 
-@pytest.fixture(scope="module")
+@pytest.fixture
 def offchain_lookup_contract_factory(w3):
     contract_factory = w3.eth.contract(
         abi=OFFCHAIN_LOOKUP_ABI, bytecode=OFFCHAIN_LOOKUP_BYTECODE
     )
     return contract_factory
 
 
-@pytest.fixture(scope="module")
+@pytest.fixture
 def async_offchain_lookup_contract_factory(async_w3):
     contract_factory = async_w3.eth.contract(
         abi=OFFCHAIN_LOOKUP_ABI, bytecode=OFFCHAIN_LOOKUP_BYTECODE
     )
     return contract_factory
 
 
-@pytest.fixture(scope="module")
+@pytest.fixture
 def event_loop():
     loop = asyncio.get_event_loop_policy().new_event_loop()
     yield loop