test framework: refactor fork system

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

@@ -2,27 +2,19 @@
 
 from typing import Type
 
-from framework.forks import BaseFork, BaseForkMeta
+from framework.forks import BaseFork, BaseForkMeta, ForkRegistry
 
+from . import forks as _forks_module
 from .forks import Devnet
-from .helpers import (
-    ALL_FORKS,
-    get_fork_by_name,
-    get_forks,
-    get_forks_with_no_parents,
-    get_from_until_fork_set,
-)
 
 Fork = Type[BaseFork]
 
+registry = ForkRegistry(_forks_module)
+
 __all__ = [
-    "ALL_FORKS",
     "BaseFork",
     "BaseForkMeta",
     "Devnet",
     "Fork",
-    "get_fork_by_name",
-    "get_forks",
-    "get_forks_with_no_parents",
-    "get_from_until_fork_set",
+    "registry",
 ]

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

@@ -1,22 +1,10 @@
 """Base fork infrastructure for Ethereum testing."""
 
 from framework.forks.base import BaseFork, BaseForkMeta
-from framework.forks.helpers import (
-    discover_forks,
-    get_all_forks,
-    get_fork_by_name,
-    get_forks,
-    get_forks_with_no_parents,
-    get_from_until_fork_set,
-)
+from framework.forks.registry import ForkRegistry
 
 __all__ = [
     "BaseFork",
     "BaseForkMeta",
-    "discover_forks",
-    "get_all_forks",
-    "get_fork_by_name",
-    "get_forks",
-    "get_forks_with_no_parents",
-    "get_from_until_fork_set",
+    "ForkRegistry",
 ]

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

@@ -0,0 +1,32 @@
+"""Fork registry for discovering and looking up forks by name."""
+
+from types import ModuleType
+from typing import Type
+
+from framework.forks.base import BaseFork
+
+
+class ForkRegistry:
+    """Discovers forks from a module and provides O(1) name-based lookup."""
+
+    def __init__(self, forks_module: ModuleType) -> None:
+        """Scan a forks module and build the name index."""
+        discovered: set[type[BaseFork]] = set()
+        for name in dir(forks_module):
+            obj = getattr(forks_module, name)
+            if isinstance(obj, type) and issubclass(obj, BaseFork) and obj is not BaseFork:
+                discovered.add(obj)
+
+        self._forks = frozenset(fork for fork in discovered if not fork.ignore())
+        self._by_name: dict[str, type[BaseFork]] = {
+            fork.name().lower(): fork for fork in self._forks
+        }
+
+    @property
+    def forks(self) -> frozenset[type[BaseFork]]:
+        """All available non-ignored forks."""
+        return self._forks
+
+    def get_fork_by_name(self, fork_name: str) -> Type[BaseFork] | None:
+        """Case-insensitive fork lookup."""
+        return self._by_name.get(fork_name.lower())

packages/testing/src/framework/pytest_plugins/filler.py

@@ -233,11 +233,8 @@ def pytest_configure(config: pytest.Config) -> None:
     clean = config.getoption("--clean")
 
     # Get available forks from layer-specific module
-    get_forks = layer_module.forks.get_forks
-    get_fork_by_name = layer_module.forks.get_fork_by_name
-
-    available_forks = get_forks()
-    available_fork_names = sorted(fork.name() for fork in available_forks)
+    registry = layer_module.forks.registry
+    available_fork_names = sorted(fork.name() for fork in registry.forks)
 
     # Validate fork
     if not fork_name:
@@ -248,7 +245,7 @@ def pytest_configure(config: pytest.Config) -> None:
         )
         pytest.exit("Missing required --fork option.", returncode=pytest.ExitCode.USAGE_ERROR)
 
-    fork_class = get_fork_by_name(fork_name)
+    fork_class = registry.get_fork_by_name(fork_name)
     if fork_class is None:
         print(
             f"Error: Unsupported fork for {layer} layer: {fork_name}\n",
@@ -289,13 +286,13 @@ def pytest_collection_modifyitems(config: pytest.Config, items: List[pytest.Item
 
     fork_class = config.test_fork_class
     layer_module = config.layer_module  # type: ignore[attr-defined]
-    get_fork_by_name = layer_module.forks.get_fork_by_name
+    registry = layer_module.forks.registry
     verbose = config.getoption("verbose")
     deselected = []
     selected = []
 
     for item in items:
-        if not _is_test_item_valid_for_fork(item, fork_class, get_fork_by_name):
+        if not _is_test_item_valid_for_fork(item, fork_class, registry.get_fork_by_name):
             if verbose < 2:
                 deselected.append(item)
             else:
@@ -500,9 +497,9 @@ def pytest_generate_tests(metafunc: pytest.Metafunc) -> None:
 
     fork_class = metafunc.config.test_fork_class  # type: ignore[attr-defined]
     layer_module = metafunc.config.layer_module  # type: ignore[attr-defined]
-    get_fork_by_name = layer_module.forks.get_fork_by_name
+    registry = layer_module.forks.registry
 
-    if not _is_test_valid_for_fork(metafunc, fork_class, get_fork_by_name):
+    if not _is_test_valid_for_fork(metafunc, fork_class, registry.get_fork_by_name):
         verbose = metafunc.config.getoption("verbose")
         if verbose >= 2:
             metafunc.parametrize(