feat(consume): add initial implementation of consume enginex

Author: danceratopz

pyproject.toml

@@ -20,7 +20,7 @@ classifiers = [
 dependencies = [
     "click>=8.1.0,<9",
     "ethereum-execution==1.17.0rc6.dev1",
-    "hive.py @ git+https://github.com/marioevz/hive.py",
+    "hive-py",
     "ethereum-spec-evm-resolver",
     "gitpython>=3.1.31,<4",
     "PyJWT>=2.3.0,<3",
@@ -147,4 +147,5 @@ check-filenames = true
 ignore-words-list = "ingenuous"
 
 [tool.uv.sources]
-ethereum-spec-evm-resolver = { git = "https://github.com/spencer-tb/ethereum-spec-evm-resolver", rev = "ee273e7344e24a739ebfbf0ea1f758530c4d032b" }
+ethereum-spec-evm-resolver = { git = "https://github.com/spencer-tb/ethereum-spec-evm-resolver", rev = "ee273e7344e24a739ebfbf0ea1f758530c4d032b" }
+hive-py = { git = "https://github.com/marioevz/hive.py", rev = "582703e2f94b4d5e61ae495d90d684852c87a580" }

src/cli/pytest_commands/consume.py

@@ -13,14 +13,14 @@
 class ConsumeCommand(PytestCommand):
     """Pytest command for consume operations."""
 
-    def __init__(self, command_paths: List[Path], is_hive: bool = False):
+    def __init__(self, command_paths: List[Path], is_hive: bool = False, command_name: str = ""):
         """Initialize consume command with paths and processors."""
         processors: List[ArgumentProcessor] = [HelpFlagsProcessor("consume")]
 
         if is_hive:
             processors.extend(
                 [
-                    HiveEnvironmentProcessor(),
+                    HiveEnvironmentProcessor(command_name),
                     ConsumeCommandProcessor(is_hive=True),
                 ]
             )
@@ -49,18 +49,20 @@ def create_executions(self, pytest_args: List[str]) -> List[PytestExecution]:
         ]
 
 
-def get_command_paths(command_name: str, is_hive: bool) -> List[Path]:
+def get_command_paths(command_name: str) -> List[Path]:
     """Determine the command paths based on the command name and hive flag."""
     base_path = Path("src/pytest_plugins/consume")
     if command_name == "hive":
         commands = ["rlp", "engine"]
+        command_paths = [base_path / "simulators" / cmd / f"test_via_{cmd}.py" for cmd in commands]
+    elif command_name in ["engine", "engine-reorg", "engine_reorg"]:
+        command_paths = [base_path / "simulators" / "hive_tests" / "test_via_engine.py"]
+    elif command_name == "rlp":
+        command_paths = [base_path / "simulators" / "hive_tests" / "test_via_rlp.py"]
+    elif command_name == "direct":
+        command_paths = [base_path / "direct" / "test_via_direct.py"]
     else:
-        commands = [command_name]
-
-    command_paths = [
-        base_path / ("simulators" if is_hive else "") / cmd / f"test_via_{cmd}.py"
-        for cmd in commands
-    ]
+        raise ValueError(f"Unexpected command: {command_name}.")
     return command_paths
 
 
@@ -76,7 +78,7 @@ def consume_command(is_hive: bool = False) -> Callable[[Callable[..., Any]], cli
     def decorator(func: Callable[..., Any]) -> click.Command:
         command_name = func.__name__
         command_help = func.__doc__
-        command_paths = get_command_paths(command_name, is_hive)
+        command_paths = get_command_paths(command_name)
 
         @consume.command(
             name=command_name,
@@ -86,7 +88,7 @@ def decorator(func: Callable[..., Any]) -> click.Command:
         @common_pytest_options
         @functools.wraps(func)
         def command(pytest_args: List[str], **kwargs) -> None:
-            consume_cmd = ConsumeCommand(command_paths, is_hive)
+            consume_cmd = ConsumeCommand(command_paths, is_hive, command_name)
             consume_cmd.execute(list(pytest_args))
 
         return command
@@ -112,17 +114,33 @@ def engine() -> None:
     pass
 
 
+@consume.command(
+    name="engine-reorg",
+    help="Client consumes via the Engine API with reorg fixtures.",
+    context_settings={"ignore_unknown_options": True},
+)
+@common_pytest_options
+def engine_reorg(
+    pytest_args: List[str], help_flag: bool = False, pytest_help_flag: bool = False
+) -> None:
+    """Client consumes via the Engine API with reorg fixtures."""
+    command_name = "engine_reorg"  # Use underscore for internal logic
+    command_paths = get_command_paths(command_name)
+    consume_cmd = ConsumeCommand(command_paths, is_hive=True, command_name=command_name)
+    consume_cmd.execute(list(pytest_args))
+
+
 @consume_command(is_hive=True)
 def hive() -> None:
-    """Client consumes via all available hive methods (rlp, engine)."""
+    """Client consumes via rlp & engine hive methods."""
     pass
 
 
 @consume.command(
     context_settings={"ignore_unknown_options": True},
 )
 @common_pytest_options
-def cache(pytest_args: List[str], **kwargs) -> None:
+def cache(pytest_args: List[str], help_flag: bool = False, pytest_help_flag: bool = False) -> None:
     """Consume command to cache test fixtures."""
-    cache_cmd = ConsumeCommand([], is_hive=False)
+    cache_cmd = ConsumeCommand([], is_hive=False, command_name="cache")
     cache_cmd.execute(list(pytest_args))

src/cli/pytest_commands/processors.py

@@ -74,6 +74,16 @@ def _is_writing_to_stdout(self, args: List[str]) -> bool:
 class HiveEnvironmentProcessor(ArgumentProcessor):
     """Processes Hive environment variables for consume commands."""
 
+    def __init__(self, command_name: str = ""):
+        """
+        Initialize the processor with command name to determine plugin.
+
+        Args:
+            command_name: The command name to determine which plugin to load.
+
+        """
+        self.command_name = command_name
+
     def process_args(self, args: List[str]) -> List[str]:
         """Convert hive environment variables into pytest flags."""
         modified_args = args[:]
@@ -94,6 +104,14 @@ def process_args(self, args: List[str]) -> List[str]:
 
         modified_args.extend(["-p", "pytest_plugins.pytest_hive.pytest_hive"])
 
+        if self.command_name == "engine":
+            modified_args.extend(["-p", "pytest_plugins.consume.simulators.engine.conftest"])
+        elif self.command_name == "engine_reorg":
+            modified_args.extend(["-p", "pytest_plugins.consume.simulators.engine_reorg.conftest"])
+        elif self.command_name == "rlp":
+            modified_args.extend(["-p", "pytest_plugins.consume.simulators.rlp.conftest"])
+        else:
+            raise ValueError(f"Unknown command name: {self.command_name}")
         return modified_args
 
     def _has_regex_or_sim_limit(self, args: List[str]) -> bool:

src/pytest_plugins/consume/consume.py

@@ -426,7 +426,8 @@ def pytest_generate_tests(metafunc):
             test_case,
             id=test_case.id,
             marks=[getattr(pytest.mark, m) for m in fork_markers]
-            + [getattr(pytest.mark, test_case.format.format_name)],
+            + [getattr(pytest.mark, test_case.format.format_name)]
+            + [pytest.mark.xdist_group(name=test_case.pre_hash)],
         )
         param_list.append(param)
 

src/pytest_plugins/consume/simulators/engine/conftest.py

@@ -1,8 +1,4 @@
-"""
-Pytest fixtures for the `consume engine` simulator.
-
-Configures the hive back-end & EL clients for each individual test execution.
-"""
+"""Pytest plugin for the `consume engine` simulator."""
 
 import io
 from typing import Mapping
@@ -28,6 +24,18 @@ def pytest_configure(config):
     config._supported_fixture_formats = [BlockchainEngineFixture.format_name]
 
 
+@pytest.fixture(scope="module")
+def test_suite_name() -> str:
+    """The name of the hive test suite used in this simulator."""
+    return "eest/consume-engine"
+
+
+@pytest.fixture(scope="module")
+def test_suite_description() -> str:
+    """The description of the hive test suite used in this simulator."""
+    return "Execute blockchain tests against clients using the Engine API."
+
+
 @pytest.fixture(scope="function")
 def engine_rpc(client: Client, client_exception_mapper: ExceptionMapper | None) -> EngineRPC:
     """Initialize engine RPC client for the execution client under test."""
@@ -41,18 +49,6 @@ def engine_rpc(client: Client, client_exception_mapper: ExceptionMapper | None)
     return EngineRPC(f"http://{client.ip}:8551")
 
 
-@pytest.fixture(scope="module")
-def test_suite_name() -> str:
-    """The name of the hive test suite used in this simulator."""
-    return "eest/consume-engine"
-
-
-@pytest.fixture(scope="module")
-def test_suite_description() -> str:
-    """The description of the hive test suite used in this simulator."""
-    return "Execute blockchain tests against clients using the Engine API."
-
-
 @pytest.fixture(scope="function")
 def client_files(buffered_genesis: io.BufferedReader) -> Mapping[str, io.BufferedReader]:
     """Define the files that hive will start the client with."""

src/pytest_plugins/consume/simulators/engine_reorg/__init__.py

@@ -0,0 +1 @@
+"""Consume Engine test functions."""

src/pytest_plugins/consume/simulators/engine_reorg/conftest.py

@@ -0,0 +1,53 @@
+"""
+Pytest fixtures for the `consume engine-reorg` simulator.
+
+Configures the hive back-end & EL clients for test execution with BlockchainEngineReorgFixtures.
+"""
+
+import pytest
+from hive.client import Client
+
+from ethereum_test_exceptions import ExceptionMapper
+from ethereum_test_fixtures import BlockchainEngineReorgFixture
+from ethereum_test_rpc import EngineRPC
+
+pytest_plugins = (
+    "pytest_plugins.consume.simulators.base",
+    "pytest_plugins.consume.simulators.multi_test_client",
+    "pytest_plugins.consume.simulators.test_case_description",
+    "pytest_plugins.consume.simulators.timing_data",
+    "pytest_plugins.consume.simulators.exceptions",
+)
+
+
+def pytest_configure(config):
+    """Set the supported fixture formats for the engine simulator."""
+    config._supported_fixture_formats = [BlockchainEngineReorgFixture.format_name]
+
+
+@pytest.fixture(scope="module")
+def test_suite_name() -> str:
+    """The name of the hive test suite used in this simulator."""
+    return "eest/consume-engine-reorg"
+
+
+@pytest.fixture(scope="module")
+def test_suite_description() -> str:
+    """The description of the hive test suite used in this simulator."""
+    return (
+        "Execute blockchain tests against clients using the Engine API and shared clients "
+        "using engine reorg fixtures."
+    )
+
+
+@pytest.fixture(scope="function")
+def engine_rpc(client: Client, client_exception_mapper: ExceptionMapper | None) -> EngineRPC:
+    """Initialize engine RPC client for the execution client under test."""
+    if client_exception_mapper:
+        return EngineRPC(
+            f"http://{client.ip}:8551",
+            response_validation_context={
+                "exception_mapper": client_exception_mapper,
+            },
+        )
+    return EngineRPC(f"http://{client.ip}:8551")