refactor(tests) Changes from comments on pr ethereum#1890:

- Move default transaction logic to a ``conftest.py`` setup.
- Add ``conftest.py`` files for each fork with the respective
  transaction pytest fixtures.
- Opt for `Type | None` over `Optional[Type]` to avoid an extra import.

Author: fselmo

src/pytest_plugins/forks/forks.py

@@ -25,16 +25,6 @@
     transition_fork_to,
 )
 
-# Import transaction fixtures to make them available when this plugin is loaded
-from .transaction_fixtures import (  # noqa: F401
-    type_0_default_transaction,
-    type_1_default_transaction,
-    type_2_default_transaction,
-    type_3_default_transaction,
-    type_4_default_transaction,
-    typed_transaction,
-)
-
 
 def pytest_addoption(parser):
     """Add command-line options to pytest."""
@@ -349,13 +339,6 @@ def covariant_decorator(
         fork_attribute_name="tx_types",
         argnames=["tx_type"],
     ),
-    covariant_decorator(
-        marker_name="with_all_typed_transactions",
-        description="marks a test to be parametrized with transaction types, the typed_tx fixture "
-        "will provide the corresponding Transaction object for each type",
-        fork_attribute_name="tx_types",
-        argnames=["typed_transaction"],
-    ),
     covariant_decorator(
         marker_name="with_all_contract_creating_tx_types",
         description="marks a test to be parametrized for all tx types that can create a contract"
@@ -989,26 +972,9 @@ def add_fork_covariant_parameters(
     metafunc: Metafunc, fork_parametrizers: List[ForkParametrizer]
 ) -> None:
     """Iterate over the fork covariant descriptors and add their values to the test function."""
-    # Special handling for with_all_typed_transactions
-    if list(metafunc.definition.iter_markers("with_all_typed_transactions")):
-        # This marker needs special handling for indirect parametrization
+    for covariant_descriptor in fork_covariant_decorators:
         for fork_parametrizer in fork_parametrizers:
-            fork = fork_parametrizer.fork
-            tx_types = fork.tx_types(block_number=0, timestamp=0)
-            values = [pytest.param(tx_type) for tx_type in tx_types]
-            fork_parametrizer.fork_covariant_parameters.append(
-                ForkCovariantParameter(names=["typed_transaction"], values=values)
-            )
-    else:
-        # Regular covariant descriptors
-        for covariant_descriptor in fork_covariant_decorators:
-            # Skip with_all_typed_transactions as it's handled above
-            if covariant_descriptor.marker_name == "with_all_typed_transactions":
-                continue
-            for fork_parametrizer in fork_parametrizers:
-                covariant_descriptor(metafunc=metafunc).add_values(
-                    fork_parametrizer=fork_parametrizer
-                )
+            covariant_descriptor(metafunc=metafunc).add_values(fork_parametrizer=fork_parametrizer)
 
     for marker in metafunc.definition.iter_markers():
         if marker.name == "parametrize_by_fork":
@@ -1063,11 +1029,6 @@ def parameters_from_fork_parametrizer_list(
 
 def parametrize_fork(metafunc: Metafunc, fork_parametrizers: List[ForkParametrizer]) -> None:
     """Add the fork parameters to the test function."""
-    param_names, param_values = parameters_from_fork_parametrizer_list(fork_parametrizers)
-
-    # Check if typed_transaction is in the parameters and needs indirect parametrization
-    indirect = []
-    if "typed_transaction" in param_names:
-        indirect.append("typed_transaction")
-
-    metafunc.parametrize(param_names, param_values, scope="function", indirect=indirect)
+    metafunc.parametrize(
+        *parameters_from_fork_parametrizer_list(fork_parametrizers), scope="function"
+    )

src/pytest_plugins/forks/transaction_fixtures.py

@@ -0,0 +1,23 @@
+"""Fixtures for Berlin fork tests."""
+
+import pytest
+
+from ethereum_test_base_types import AccessList
+from ethereum_test_types import Transaction
+
+
+@pytest.fixture
+def type_1_default_transaction(sender):
+    """Type 1 (access list) default transaction introduced in Berlin fork."""
+    return Transaction(
+        ty=1,
+        sender=sender,
+        gas_price=10**9,
+        gas_limit=100_000,
+        data=b"\x00" * 100,
+        access_list=[
+            AccessList(address=0x1234, storage_keys=[0, 1, 2]),
+            AccessList(address=0x5678, storage_keys=[3, 4, 5]),
+            AccessList(address=0x9ABC, storage_keys=[]),
+        ],
+    )

tests/berlin/conftest.py

@@ -0,0 +1,31 @@
+"""Fixtures for Cancun fork tests."""
+
+import pytest
+
+from ethereum_test_base_types import AccessList
+from ethereum_test_types import Transaction, add_kzg_version
+
+
+@pytest.fixture
+def type_3_default_transaction(sender):
+    """Type 3 (blob) default transaction introduced in Cancun fork."""
+    return Transaction(
+        ty=3,
+        sender=sender,
+        max_fee_per_gas=10**10,
+        max_priority_fee_per_gas=10**9,
+        max_fee_per_blob_gas=10**9,
+        gas_limit=100_000,
+        data=b"\x00" * 150,
+        access_list=[
+            AccessList(address=0x3690, storage_keys=[100, 200]),
+            AccessList(address=0xBEEF, storage_keys=[300]),
+        ],
+        blob_versioned_hashes=add_kzg_version(
+            [
+                0x1111111111111111111111111111111111111111111111111111111111111111,
+                0x2222222222222222222222222222222222222222222222222222222222222222,
+            ],
+            0x01,
+        ),
+    )

tests/cancun/conftest.py

@@ -0,0 +1,49 @@
+"""Global fixtures available to all fork tests."""
+
+import pytest
+
+from ethereum_test_types import Transaction
+
+
+@pytest.fixture
+def type_0_default_transaction(pre):
+    """Type 0 (legacy) default transaction available in all forks."""
+    sender = pre.fund_eoa()
+    return Transaction(
+        ty=0,
+        sender=sender,
+        gas_price=10**9,
+        gas_limit=100_000,
+        data=b"\x00" * 100,
+    )
+
+
+@pytest.fixture
+def typed_transaction(
+    tx_type,
+    type_0_default_transaction,
+    type_1_default_transaction,
+    type_2_default_transaction,
+    type_3_default_transaction,
+    type_4_default_transaction,
+):
+    """
+    Fixture that provides a Transaction object based on the parametrized tx type.
+
+    This fixture works with the @pytest.mark.with_all_tx_types marker,
+    which parametrizes the test with all transaction types supported by the fork.
+    """
+    if tx_type == 0:
+        return type_0_default_transaction
+    elif tx_type == 1:
+        return type_1_default_transaction
+    elif tx_type == 2:
+        return type_2_default_transaction
+    elif tx_type == 3:
+        return type_3_default_transaction
+    elif tx_type == 4:
+        return type_4_default_transaction
+    else:
+        raise ValueError(
+            f"Transaction type `{tx_type}` needs `typed_transaction` fixture support."
+        )

tests/conftest.py

@@ -0,0 +1 @@
+"""Test cases for EVM functionality introduced in London."""

tests/london/__init__.py

@@ -0,0 +1,23 @@
+"""Fixtures for London fork tests."""
+
+import pytest
+
+from ethereum_test_base_types import AccessList
+from ethereum_test_types import Transaction
+
+
+@pytest.fixture
+def type_2_default_transaction(sender):
+    """Type 2 (dynamic fee) default transaction introduced in London fork."""
+    return Transaction(
+        ty=2,
+        sender=sender,
+        max_fee_per_gas=10**10,
+        max_priority_fee_per_gas=10**9,
+        gas_limit=100_000,
+        data=b"\x00" * 200,
+        access_list=[
+            AccessList(address=0x2468, storage_keys=[10, 20, 30]),
+            AccessList(address=0xACE0, storage_keys=[40, 50]),
+        ],
+    )