feat(plugins/forks): Fix covariant markers, add selector/marks parameters (#762)

* fix(plugins/forks): fix case where the covariant fork method returns tuple or list

* fix(plugins/forks): Disallow args in `with_all` markers

* fix(plugins/forks): Add test

* feat(plugins/forks): Fix covariant markers

* feat(plugins/forks): Support for markers on covariant values

* tests(filler): check correct error string is reported

* test(forks): add marks_selector tests for `with_all` decorators

* tests(forks): remove bad test case from previous commit

* Apply suggestions from code review

Co-authored-by: danceratopz <[email protected]>

* refactor(forks): Move helpers to forks library

* fix(plugins/forks): Fix `with_all` `marks` field

* feat(docs): Add `marks` field to docs

* fix(docs): tox

* docs: changelog

---------

Co-authored-by: danceratopz <[email protected]>

Author: marioevz

docs/CHANGELOG.md

@@ -32,7 +32,9 @@ Test fixtures for use by clients are available for each release on the [Github r
 - ✨ Added `Container.Init` to `ethereum_test_types.EOF.V1` package, which allows generation of an EOF init container more easily ([#739](https://github.com/ethereum/execution-spec-tests/pull/739)).
 - ✨ Introduce method valid_opcodes() to the fork class ([#748](https://github.com/ethereum/execution-spec-tests/pull/748)).
 - 🐞 Fixed `consume` exit code return values, ensuring that pytest's return value is correctly propagated to the shell. This allows the shell to accurately reflect the test results (e.g., failures) based on the pytest exit code ([#765](https://github.com/ethereum/execution-spec-tests/pull/765)).
-- ✨ Added a new flag `--solc-version` to the `fill` command, which allows the user to specify the version of the Solidity compiler to use when compiling Yul source code; this version will now be automatically downloaded by `fill` via [`solc-select`](https://github.com/crytic/solc-select) ([#772](https://github.com/ethereum/execution-spec-tests/pull/772).
+- ✨ Added a new flag `--solc-version` to the `fill` command, which allows the user to specify the version of the Solidity compiler to use when compiling Yul source code; this version will now be automatically downloaded by `fill` via [`solc-select`](https://github.com/crytic/solc-select) ([#772](https://github.com/ethereum/execution-spec-tests/pull/772)).
+- 🐞 Fix usage of multiple `@pytest.mark.with_all*` markers which shared parameters, such as `with_all_call_opcodes` and `with_all_create_opcodes` which shared `evm_code_type`, and now only parametrize compatible values ([#762](https://github.com/ethereum/execution-spec-tests/pull/762)).
+- ✨ Added `selector` and `marks` fields to all `@pytest.mark.with_all*` markers, which allows passing lambda functions to select or mark specific parametrized values (see [documentation](https://ethereum.github.io/execution-spec-tests/main/writing_tests/test_markers/#covariant-marker-keyword-arguments) for more information) ([#762](https://github.com/ethereum/execution-spec-tests/pull/762)).
 
 ### 🔧 EVM Tools
 

docs/writing_tests/test_markers.md

@@ -253,6 +253,24 @@ def test_something_with_all_tx_types(
 
 Ideally, the lambda function should be used to explicitly filter out values that are not compatible with the test (exclusive filter), rather than explicitly selecting values (inclusive filter), as the parametrized values might change with future forks.
 
+#### `marks`
+
+A marker, list of markers, or a lambda function that can be used to add additional markers to the test.
+
+```python
+import pytest
+
+@pytest.mark.with_all_tx_types(
+    marks=lambda tx_type: pytest.mark.skip("incompatible") if tx_type == 1 else None,
+)
+@pytest.mark.valid_from("London")
+def test_something_with_all_tx_types_but_skip_type_1(state_test_only, tx_type):
+    assert tx_type != 1
+    ...
+```
+
+In this example, the test will be skipped if `tx_type` is equal to 1 by returning a `pytest.mark.skip` marker, and return `None` otherwise.
+
 ## Other Markers
 
 ### `@pytest.mark.slow`

src/ethereum_test_forks/__init__.py

@@ -33,8 +33,12 @@
     get_deployed_forks,
     get_development_forks,
     get_forks,
+    get_forks_with_no_descendants,
+    get_forks_with_no_parents,
     get_forks_with_solc_support,
     get_forks_without_solc_support,
+    get_from_until_fork_set,
+    get_last_descendants,
     get_transition_forks,
     transition_fork_from_to,
     transition_fork_to,
@@ -65,12 +69,16 @@
     "get_transition_forks",
     "forks_from",
     "forks_from_until",
+    "get_closest_fork_with_solc_support",
     "get_deployed_forks",
     "get_development_forks",
-    "get_forks",
+    "get_forks_with_no_descendants",
+    "get_forks_with_no_parents",
     "get_forks_with_solc_support",
     "get_forks_without_solc_support",
-    "get_closest_fork_with_solc_support",
+    "get_forks",
+    "get_from_until_fork_set",
+    "get_last_descendants",
     "transition_fork_from_to",
     "transition_fork_to",
 ]

src/ethereum_test_forks/helpers.py

@@ -1,7 +1,7 @@
 """
 Helper methods to resolve forks during test filling
 """
-from typing import List, Optional
+from typing import List, Optional, Set
 
 from semver import Version
 
@@ -103,6 +103,66 @@ def get_transition_forks() -> List[Fork]:
     return transition_forks
 
 
+def get_from_until_fork_set(
+    forks: Set[Fork], forks_from: Set[Fork], forks_until: Set[Fork]
+) -> Set[Fork]:
+    """
+    Get the fork range from forks_from to forks_until.
+    """
+    resulting_set = set()
+    for fork_from in forks_from:
+        for fork_until in forks_until:
+            for fork in forks:
+                if fork <= fork_until and fork >= fork_from:
+                    resulting_set.add(fork)
+    return resulting_set
+
+
+def get_forks_with_no_parents(forks: Set[Fork]) -> Set[Fork]:
+    """
+    Get the forks with no parents in the inheritance hierarchy.
+    """
+    resulting_forks: Set[Fork] = set()
+    for fork in forks:
+        parents = False
+        for next_fork in forks - {fork}:
+            if next_fork < fork:
+                parents = True
+                break
+        if not parents:
+            resulting_forks = resulting_forks | {fork}
+    return resulting_forks
+
+
+def get_forks_with_no_descendants(forks: Set[Fork]) -> Set[Fork]:
+    """
+    Get the forks with no descendants in the inheritance hierarchy.
+    """
+    resulting_forks: Set[Fork] = set()
+    for fork in forks:
+        descendants = False
+        for next_fork in forks - {fork}:
+            if next_fork > fork:
+                descendants = True
+                break
+        if not descendants:
+            resulting_forks = resulting_forks | {fork}
+    return resulting_forks
+
+
+def get_last_descendants(forks: Set[Fork], forks_from: Set[Fork]) -> Set[Fork]:
+    """
+    Get the last descendant of a class in the inheritance hierarchy.
+    """
+    resulting_forks: Set[Fork] = set()
+    forks = get_forks_with_no_descendants(forks)
+    for fork_from in forks_from:
+        for fork in forks:
+            if fork >= fork_from:
+                resulting_forks = resulting_forks | {fork}
+    return resulting_forks
+
+
 def transition_fork_from_to(fork_from: Fork, fork_to: Fork) -> Fork | None:
     """
     Returns the transition fork that transitions to and from the specified