refactor(testing): delete dead fork machinery (leanEthereum#851)

With a single fork, most of the fork scaffolding had zero callers:

- the fork's state accessor was never called anywhere
- the ignore flag machinery (class keyword, classvar, accessor) was
  always False; no fork ever opted out
- the valid_from and valid_at markers were registered and filtered
  but no test uses them; only valid_until exists in the tree
- three of the four ordering operators existed solely for those
  unused markers

Changes:

- the registry class with its module dir() scan is replaced by a
  literal name-to-fork dict in the consensus forks package;
  lookups stay case-insensitive
- the fork base keeps name, repr, and the older-or-equal comparison
  that the valid_until marker consumes; the rest of the ordering
  algebra and the ignore machinery are gone
- the marker check in the filler handles only valid_until
- the unused fork type alias and metaclass re-exports are dropped

When a second fork lands, the removed pieces can be reintroduced
against real usage.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: tcoratger

packages/testing/src/consensus_testing/forks/__init__.py

@@ -1,20 +1,14 @@
 """Fork definitions for consensus layer testing."""
 
-from typing import Type
+from framework.forks import BaseFork
 
-from framework.forks import BaseFork, BaseForkMeta, ForkRegistry
-
-from consensus_testing.forks import forks as _forks_module
 from consensus_testing.forks.forks import Lstar
 
-Fork = Type[BaseFork]
-
-registry = ForkRegistry(_forks_module)
+FORKS_BY_NAME: dict[str, type[BaseFork]] = {"lstar": Lstar}
+"""Registered consensus forks, keyed by lowercase fork name."""
 
 __all__ = [
     "BaseFork",
-    "BaseForkMeta",
-    "Fork",
+    "FORKS_BY_NAME",
     "Lstar",
-    "registry",
 ]

packages/testing/src/consensus_testing/forks/forks.py

@@ -17,8 +17,3 @@ def name(cls) -> str:
     def spec_class(cls) -> type[LstarSpec]:
         """Return the ForkProtocol implementation for this fork."""
         return LstarSpec
-
-    @classmethod
-    def state_class(cls) -> type:
-        """Return the State container class for this fork."""
-        return LstarSpec.state_class

packages/testing/src/framework/forks/__init__.py

@@ -1,10 +1,7 @@
-"""Base fork infrastructure for Ethereum testing."""
+"""Base fork infrastructure for spec test generation."""
 
-from framework.forks.base import BaseFork, BaseForkMeta
-from framework.forks.registry import ForkRegistry
+from framework.forks.base import BaseFork
 
 __all__ = [
     "BaseFork",
-    "BaseForkMeta",
-    "ForkRegistry",
 ]

packages/testing/src/framework/forks/base.py

@@ -1,18 +1,14 @@
-"""Base fork class for Ethereum layer testing."""
+"""Base fork class for spec test generation."""
 
 from abc import ABC, ABCMeta, abstractmethod
-from typing import ClassVar
 
 
 class BaseForkMeta(ABCMeta):
     """
-    Metaclass for BaseFork enabling fork comparisons via inheritance.
+    Metaclass for BaseFork enabling fork ordering via inheritance.
 
-    Fork comparisons work by checking subclass relationships.
-    For example, if ForkB inherits from ForkA, then ForkA < ForkB.
-
-    This metaclass is shared across both consensus and execution layers,
-    allowing consistent fork comparison logic regardless of layer.
+    Fork ordering works by checking subclass relationships.
+    For example, if ForkB inherits from ForkA, then ForkA precedes ForkB.
     """
 
     @abstractmethod
@@ -24,57 +20,19 @@ def __repr__(cls) -> str:
         """Print the name of the fork, instead of the class."""
         return cls.name()
 
-    def __gt__(cls, other: "BaseForkMeta") -> bool:
-        """Check if this fork is newer than another (cls > other)."""
-        return cls is not other and BaseForkMeta._is_subclass_of(cls, other)
-
-    def __ge__(cls, other: "BaseForkMeta") -> bool:
-        """Check if this fork is newer or equal to another (cls >= other)."""
-        return cls is other or BaseForkMeta._is_subclass_of(cls, other)
-
-    def __lt__(cls, other: "BaseForkMeta") -> bool:
-        """Check if this fork is older than another (cls < other)."""
-        return cls is not other and BaseForkMeta._is_subclass_of(other, cls)
-
     def __le__(cls, other: "BaseForkMeta") -> bool:
         """Check if this fork is older or equal to another (cls <= other)."""
-        return cls is other or BaseForkMeta._is_subclass_of(other, cls)
-
-    @staticmethod
-    def _is_subclass_of(a: "BaseForkMeta", b: "BaseForkMeta") -> bool:
-        """Check if fork `a` is a subclass of fork `b`."""
-        return issubclass(a, b)
+        return cls is other or issubclass(other, cls)
 
 
 class BaseFork(ABC, metaclass=BaseForkMeta):
     """
-    Base class for Ethereum layer forks.
+    Base class for spec test forks.
 
-    Each fork represents a specific version of the protocol (consensus or execution).
+    Each fork represents a specific version of the protocol.
     Forks form an inheritance hierarchy where newer forks inherit from older ones.
-
-    This base class is shared across both consensus and execution layers, but each
-    layer will define its own fork hierarchy with different fork names and properties.
     """
 
-    # Fork metadata
-    _ignore: ClassVar[bool] = False
-    """If True, this fork will be excluded from the primary fork set."""
-
-    def __init_subclass__(
-        cls,
-        *,
-        ignore: bool = False,
-    ) -> None:
-        """
-        Initialize fork subclass with metadata.
-
-        Args:
-            ignore: If True, exclude this fork from ALL_FORKS.
-        """
-        super().__init_subclass__()
-        cls._ignore = ignore
-
     @classmethod
     @abstractmethod
     def name(cls) -> str:
@@ -85,8 +43,3 @@ def name(cls) -> str:
         This is used in the 'network' field of generated fixtures.
         """
         pass
-
-    @classmethod
-    def ignore(cls) -> bool:
-        """Return whether this fork should be ignored in test generation."""
-        return cls._ignore

packages/testing/src/framework/forks/registry.py

@@ -9,7 +9,7 @@
 
 import pytest
 from consensus_testing import generate_pre_state
-from consensus_testing.forks import registry
+from consensus_testing.forks import FORKS_BY_NAME
 from consensus_testing.test_fixtures import (
     ApiEndpointTest,
     ForkChoiceTest,
@@ -182,25 +182,17 @@ def pytest_ignore_collect(collection_path: Path) -> bool | None:
 def pytest_configure(config: pytest.Config) -> None:
     """Setup the fixture generation session."""
     # Register fork validity markers
-    config.addinivalue_line(
-        "markers",
-        "valid_from(fork): specifies from which fork a test case is valid",
-    )
     config.addinivalue_line(
         "markers",
         "valid_until(fork): specifies until which fork a test case is valid",
     )
-    config.addinivalue_line(
-        "markers",
-        "valid_at(fork): specifies at which fork a test case is valid",
-    )
 
     # Get options
     output_directory = Path(config.getoption("--output"))
     fork_name = config.getoption("--fork")
     clean = config.getoption("--clean")
 
-    available_fork_names = sorted(fork.name() for fork in registry.forks)
+    available_fork_names = sorted(fork.name() for fork in FORKS_BY_NAME.values())
 
     # Validate fork
     if not fork_name:
@@ -211,7 +203,7 @@ def pytest_configure(config: pytest.Config) -> None:
         )
         pytest.exit("Missing required --fork option.", returncode=pytest.ExitCode.USAGE_ERROR)
 
-    fork_class = registry.get_fork_by_name(fork_name)
+    fork_class = FORKS_BY_NAME.get(fork_name.lower())
     if fork_class is None:
         print(
             f"Error: Unsupported fork: {fork_name}\n",
@@ -279,49 +271,21 @@ def _check_markers_valid_for_fork(
 
     Shared logic for both collection-time and parametrization-time fork filtering.
     """
-    has_valid_from = False
     has_valid_until = False
-    has_valid_at = False
-
-    valid_from_forks = []
     valid_until_forks = []
-    valid_at_forks = []
 
     for marker in markers:
-        if marker.name == "valid_from":
-            has_valid_from = True
-            for fork_name in marker.args:
-                target_fork = registry.get_fork_by_name(fork_name)
-                if target_fork:
-                    valid_from_forks.append(target_fork)
-        elif marker.name == "valid_until":
+        if marker.name == "valid_until":
             has_valid_until = True
             for fork_name in marker.args:
-                target_fork = registry.get_fork_by_name(fork_name)
+                target_fork = FORKS_BY_NAME.get(fork_name.lower())
                 if target_fork:
                     valid_until_forks.append(target_fork)
-        elif marker.name == "valid_at":
-            has_valid_at = True
-            for fork_name in marker.args:
-                target_fork = registry.get_fork_by_name(fork_name)
-                if target_fork:
-                    valid_at_forks.append(target_fork)
 
-    if not (has_valid_from or has_valid_until or has_valid_at):
+    if not has_valid_until:
         return True
 
-    if has_valid_at:
-        return fork_class in valid_at_forks
-
-    from_valid = True
-    if has_valid_from:
-        from_valid = any(fork_class >= from_fork for from_fork in valid_from_forks)
-
-    until_valid = True
-    if has_valid_until:
-        until_valid = any(fork_class <= until_fork for until_fork in valid_until_forks)
-
-    return from_valid and until_valid
+    return any(fork_class <= until_fork for until_fork in valid_until_forks)
 
 
 def pytest_sessionfinish(session: pytest.Session, exitstatus: int) -> None: