From 0b0fe15c75408ff6419848132c798ba0d4e0d4d3 Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Fri, 29 Oct 2021 23:17:57 +0800 Subject: [PATCH 1/6] Make altair transition tests support merge forks --- .../transition/test_activations_and_exits.py | 31 ++- .../test/altair/transition/test_leaking.py | 19 +- .../test/altair/transition/test_operations.py | 31 ++- .../test/altair/transition/test_slashing.py | 15 +- .../test/altair/transition/test_transition.py | 39 +-- tests/core/pyspec/eth2spec/test/context.py | 249 +++++++++++++----- .../pyspec/eth2spec/test/helpers/constants.py | 5 + .../eth2spec/test/helpers/fork_transition.py | 22 +- .../pyspec/eth2spec/test/utils/__init__.py | 2 - .../core/pyspec/eth2spec/test/utils/utils.py | 48 ---- tests/generators/transition/main.py | 40 +-- 11 files changed, 300 insertions(+), 201 deletions(-) diff --git a/tests/core/pyspec/eth2spec/test/altair/transition/test_activations_and_exits.py b/tests/core/pyspec/eth2spec/test/altair/transition/test_activations_and_exits.py index 12aa815ad..0f5b28db6 100644 --- a/tests/core/pyspec/eth2spec/test/altair/transition/test_activations_and_exits.py +++ b/tests/core/pyspec/eth2spec/test/altair/transition/test_activations_and_exits.py @@ -1,12 +1,15 @@ import random from eth2spec.test.context import ( - MINIMAL, - fork_transition_test, + ForkMeta, with_presets, + with_fork_metas, +) +from eth2spec.test.helpers.constants import ( + ALL_FORKS, + MINIMAL, ) -from eth2spec.test.helpers.constants import PHASE0, ALTAIR from eth2spec.test.helpers.fork_transition import ( - do_altair_fork, + do_fork, transition_until_fork, transition_to_next_epoch_and_append_blocks, ) @@ -21,7 +24,7 @@ from eth2spec.test.helpers.random import ( # Exit # -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=2) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) @with_presets([MINIMAL], reason="only test with enough validators such that at least one exited index is not in sync committee") def test_transition_with_one_fourth_exiting_validators_exit_post_fork(state, @@ -59,7 +62,7 @@ def test_transition_with_one_fourth_exiting_validators_exit_post_fork(state, # irregular state transition to handle fork: blocks = [] - state, block = do_altair_fork(state, spec, post_spec, fork_epoch) + state, block = do_fork(state, spec, post_spec, fork_epoch) blocks.append(post_tag(block)) # ensure that some of the current sync committee members are exiting @@ -81,7 +84,7 @@ def test_transition_with_one_fourth_exiting_validators_exit_post_fork(state, yield "post", state -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=2) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) def test_transition_with_one_fourth_exiting_validators_exit_at_fork(state, fork_epoch, spec, @@ -117,7 +120,7 @@ def test_transition_with_one_fourth_exiting_validators_exit_at_fork(state, # irregular state transition to handle fork: blocks = [] - state, block = do_altair_fork(state, spec, post_spec, fork_epoch) + state, block = do_fork(state, spec, post_spec, fork_epoch) blocks.append(post_tag(block)) # check post transition state @@ -127,10 +130,6 @@ def test_transition_with_one_fourth_exiting_validators_exit_at_fork(state, assert not post_spec.is_active_validator(validator, post_spec.get_current_epoch(state)) assert not post_spec.is_in_inactivity_leak(state) - # ensure that none of the current sync committee members are exited validators - exited_pubkeys = [state.validators[index].pubkey for index in exited_indices] - assert not any(set(exited_pubkeys).intersection(list(state.current_sync_committee.pubkeys))) - # continue regular state transition with new spec into next epoch transition_to_next_epoch_and_append_blocks(post_spec, state, post_tag, blocks, only_last_block=True) @@ -143,7 +142,7 @@ def test_transition_with_one_fourth_exiting_validators_exit_at_fork(state, # -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=2) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) def test_transition_with_non_empty_activation_queue(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Create some deposits before the transition @@ -161,7 +160,7 @@ def test_transition_with_non_empty_activation_queue(state, fork_epoch, spec, pos # irregular state transition to handle fork: blocks = [] - state, block = do_altair_fork(state, spec, post_spec, fork_epoch) + state, block = do_fork(state, spec, post_spec, fork_epoch) blocks.append(post_tag(block)) # continue regular state transition with new spec into next epoch @@ -171,7 +170,7 @@ def test_transition_with_non_empty_activation_queue(state, fork_epoch, spec, pos yield "post", state -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=2) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) def test_transition_with_activation_at_fork_epoch(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Create some deposits before the transition @@ -191,7 +190,7 @@ def test_transition_with_activation_at_fork_epoch(state, fork_epoch, spec, post_ # irregular state transition to handle fork: blocks = [] - state, block = do_altair_fork(state, spec, post_spec, fork_epoch) + state, block = do_fork(state, spec, post_spec, fork_epoch) blocks.append(post_tag(block)) # continue regular state transition with new spec into next epoch diff --git a/tests/core/pyspec/eth2spec/test/altair/transition/test_leaking.py b/tests/core/pyspec/eth2spec/test/altair/transition/test_leaking.py index 6cdac1661..3ed2e37ee 100644 --- a/tests/core/pyspec/eth2spec/test/altair/transition/test_leaking.py +++ b/tests/core/pyspec/eth2spec/test/altair/transition/test_leaking.py @@ -1,13 +1,18 @@ -from eth2spec.test.context import fork_transition_test -from eth2spec.test.helpers.constants import PHASE0, ALTAIR +from eth2spec.test.context import ( + ForkMeta, + with_fork_metas, +) +from eth2spec.test.helpers.constants import ( + ALL_FORKS, +) from eth2spec.test.helpers.fork_transition import ( - do_altair_fork, + do_fork, transition_until_fork, transition_to_next_epoch_and_append_blocks, ) -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=7) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=7) for pre, post in ALL_FORKS.items()]) def test_transition_with_leaking_pre_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Leaking starts at epoch 6 (MIN_EPOCHS_TO_INACTIVITY_PENALTY + 2). @@ -22,7 +27,7 @@ def test_transition_with_leaking_pre_fork(state, fork_epoch, spec, post_spec, pr # irregular state transition to handle fork: blocks = [] - state, block = do_altair_fork(state, spec, post_spec, fork_epoch) + state, block = do_fork(state, spec, post_spec, fork_epoch) blocks.append(post_tag(block)) # check post transition state @@ -35,7 +40,7 @@ def test_transition_with_leaking_pre_fork(state, fork_epoch, spec, post_spec, pr yield "post", state -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=6) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=6) for pre, post in ALL_FORKS.items()]) def test_transition_with_leaking_at_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Leaking starts at epoch 6 (MIN_EPOCHS_TO_INACTIVITY_PENALTY + 2). @@ -50,7 +55,7 @@ def test_transition_with_leaking_at_fork(state, fork_epoch, spec, post_spec, pre # irregular state transition to handle fork: blocks = [] - state, block = do_altair_fork(state, spec, post_spec, fork_epoch) + state, block = do_fork(state, spec, post_spec, fork_epoch) blocks.append(post_tag(block)) # check post transition state diff --git a/tests/core/pyspec/eth2spec/test/altair/transition/test_operations.py b/tests/core/pyspec/eth2spec/test/altair/transition/test_operations.py index e19c57fb1..54f37a235 100644 --- a/tests/core/pyspec/eth2spec/test/altair/transition/test_operations.py +++ b/tests/core/pyspec/eth2spec/test/altair/transition/test_operations.py @@ -1,8 +1,13 @@ from eth2spec.test.context import ( + ForkMeta, always_bls, - fork_transition_test, + with_fork_metas, + with_presets, +) +from eth2spec.test.helpers.constants import ( + ALL_FORKS, + MINIMAL, ) -from eth2spec.test.helpers.constants import PHASE0, ALTAIR from eth2spec.test.helpers.fork_transition import ( OperationType, run_transition_with_operation, @@ -13,7 +18,7 @@ from eth2spec.test.helpers.fork_transition import ( # PROPOSER_SLASHING # -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=2) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) @always_bls def test_transition_with_proposer_slashing_right_after_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ @@ -31,7 +36,7 @@ def test_transition_with_proposer_slashing_right_after_fork(state, fork_epoch, s ) -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=2) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) @always_bls def test_transition_with_proposer_slashing_right_before_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ @@ -54,7 +59,7 @@ def test_transition_with_proposer_slashing_right_before_fork(state, fork_epoch, # -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=2) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) @always_bls def test_transition_with_attester_slashing_right_after_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ @@ -72,7 +77,7 @@ def test_transition_with_attester_slashing_right_after_fork(state, fork_epoch, s ) -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=2) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) @always_bls def test_transition_with_attester_slashing_right_before_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ @@ -95,7 +100,7 @@ def test_transition_with_attester_slashing_right_before_fork(state, fork_epoch, # -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=2) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) def test_transition_with_deposit_right_after_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Create a deposit right *after* the transition @@ -112,7 +117,7 @@ def test_transition_with_deposit_right_after_fork(state, fork_epoch, spec, post_ ) -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=2) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) def test_transition_with_deposit_right_before_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Create a deposit right *before* the transition @@ -134,11 +139,12 @@ def test_transition_with_deposit_right_before_fork(state, fork_epoch, spec, post # -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=260) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=66) for pre, post in ALL_FORKS.items()]) +@with_presets([MINIMAL], reason="too slow") def test_transition_with_voluntary_exit_right_after_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Create a voluntary exit right *after* the transition. - fork_epoch=260 because mainnet `SHARD_COMMITTEE_PERIOD` is 256 epochs. + fork_epoch=66 because minimal preset `SHARD_COMMITTEE_PERIOD` is 64 epochs. """ # Fast forward to the future epoch so that validator can do voluntary exit state.slot = spec.config.SHARD_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH @@ -155,11 +161,12 @@ def test_transition_with_voluntary_exit_right_after_fork(state, fork_epoch, spec ) -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=260) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=66) for pre, post in ALL_FORKS.items()]) +@with_presets([MINIMAL], reason="too slow") def test_transition_with_voluntary_exit_right_before_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Create a voluntary exit right *before* the transition. - fork_epoch=260 because mainnet `SHARD_COMMITTEE_PERIOD` is 256 epochs. + fork_epoch=66 because minimal preset `SHARD_COMMITTEE_PERIOD` is 64 epochs. """ # Fast forward to the future epoch so that validator can do voluntary exit state.slot = spec.config.SHARD_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH diff --git a/tests/core/pyspec/eth2spec/test/altair/transition/test_slashing.py b/tests/core/pyspec/eth2spec/test/altair/transition/test_slashing.py index 211a4fbfe..6d8f23b7d 100644 --- a/tests/core/pyspec/eth2spec/test/altair/transition/test_slashing.py +++ b/tests/core/pyspec/eth2spec/test/altair/transition/test_slashing.py @@ -1,12 +1,15 @@ import random from eth2spec.test.context import ( - MINIMAL, - fork_transition_test, + ForkMeta, + with_fork_metas, with_presets, ) -from eth2spec.test.helpers.constants import PHASE0, ALTAIR +from eth2spec.test.helpers.constants import ( + ALL_FORKS, + MINIMAL, +) from eth2spec.test.helpers.fork_transition import ( - do_altair_fork, + do_fork, transition_to_next_epoch_and_append_blocks, transition_until_fork, ) @@ -15,7 +18,7 @@ from eth2spec.test.helpers.random import ( ) -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=1) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=1) for pre, post in ALL_FORKS.items()]) @with_presets([MINIMAL], reason="only test with enough validators such that at least one exited index is not in sync committee") def test_transition_with_one_fourth_slashed_active_validators_pre_fork(state, @@ -45,7 +48,7 @@ def test_transition_with_one_fourth_slashed_active_validators_pre_fork(state, yield "pre", state # irregular state transition to handle fork: - state, _ = do_altair_fork(state, spec, post_spec, fork_epoch, with_block=False) + state, _ = do_fork(state, spec, post_spec, fork_epoch, with_block=False) # ensure that some of the current sync committee members are slashed slashed_pubkeys = [state.validators[index].pubkey for index in slashed_indices] diff --git a/tests/core/pyspec/eth2spec/test/altair/transition/test_transition.py b/tests/core/pyspec/eth2spec/test/altair/transition/test_transition.py index fe6248c5f..2439b79fc 100644 --- a/tests/core/pyspec/eth2spec/test/altair/transition/test_transition.py +++ b/tests/core/pyspec/eth2spec/test/altair/transition/test_transition.py @@ -1,12 +1,17 @@ import random -from eth2spec.test.context import fork_transition_test -from eth2spec.test.helpers.constants import PHASE0, ALTAIR +from eth2spec.test.context import ( + ForkMeta, + with_fork_metas, +) +from eth2spec.test.helpers.constants import ( + ALL_FORKS, +) from eth2spec.test.helpers.state import ( next_epoch_via_signed_block, ) from eth2spec.test.helpers.attestations import next_slots_with_attestations from eth2spec.test.helpers.fork_transition import ( - do_altair_fork, + do_fork, no_blocks, only_at, skip_slots, @@ -15,7 +20,7 @@ from eth2spec.test.helpers.fork_transition import ( ) -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=2) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) def test_normal_transition(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Transition from the initial ``state`` to the epoch after the ``fork_epoch``, @@ -34,7 +39,7 @@ def test_normal_transition(state, fork_epoch, spec, post_spec, pre_tag, post_tag ]) # irregular state transition to handle fork: - state, block = do_altair_fork(state, spec, post_spec, fork_epoch) + state, block = do_fork(state, spec, post_spec, fork_epoch) blocks.append(post_tag(block)) # continue regular state transition with new spec into next epoch @@ -51,7 +56,7 @@ def test_normal_transition(state, fork_epoch, spec, post_spec, pre_tag, post_tag yield "post", state -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=2) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) def test_transition_missing_first_post_block(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Transition from the initial ``state`` to the epoch after the ``fork_epoch``, @@ -71,7 +76,7 @@ def test_transition_missing_first_post_block(state, fork_epoch, spec, post_spec, ]) # irregular state transition to handle fork: - state, _ = do_altair_fork(state, spec, post_spec, fork_epoch, with_block=False) + state, _ = do_fork(state, spec, post_spec, fork_epoch, with_block=False) # continue regular state transition with new spec into next epoch transition_to_next_epoch_and_append_blocks(post_spec, state, post_tag, blocks) @@ -88,7 +93,7 @@ def test_transition_missing_first_post_block(state, fork_epoch, spec, post_spec, yield "post", state -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=2) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) def test_transition_missing_last_pre_fork_block(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Transition from the initial ``state`` to the epoch after the ``fork_epoch``, @@ -109,7 +114,7 @@ def test_transition_missing_last_pre_fork_block(state, fork_epoch, spec, post_sp ]) # irregular state transition to handle fork: - state, block = do_altair_fork(state, spec, post_spec, fork_epoch) + state, block = do_fork(state, spec, post_spec, fork_epoch) blocks.append(post_tag(block)) # continue regular state transition with new spec into next epoch @@ -127,7 +132,7 @@ def test_transition_missing_last_pre_fork_block(state, fork_epoch, spec, post_sp yield "post", state -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=2) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) def test_transition_only_blocks_post_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Transition from the initial ``state`` to the epoch after the ``fork_epoch``, @@ -148,7 +153,7 @@ def test_transition_only_blocks_post_fork(state, fork_epoch, spec, post_spec, pr ]) # irregular state transition to handle fork: - state, _ = do_altair_fork(state, spec, post_spec, fork_epoch, with_block=False) + state, _ = do_fork(state, spec, post_spec, fork_epoch, with_block=False) # continue regular state transition with new spec into next epoch to_slot = post_spec.SLOTS_PER_EPOCH + state.slot @@ -215,7 +220,7 @@ def _run_transition_test_with_attestations(state, assert (state.slot + 1) % spec.SLOTS_PER_EPOCH == 0 # irregular state transition to handle fork: - state, block = do_altair_fork(state, spec, post_spec, fork_epoch) + state, block = do_fork(state, spec, post_spec, fork_epoch) blocks.append(post_tag(block)) # continue regular state transition with new spec into next epoch @@ -253,7 +258,7 @@ def _run_transition_test_with_attestations(state, yield "post", state -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=3) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=3) for pre, post in ALL_FORKS.items()]) def test_transition_with_finality(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Transition from the initial ``state`` to the epoch after the ``fork_epoch``, @@ -262,7 +267,7 @@ def test_transition_with_finality(state, fork_epoch, spec, post_spec, pre_tag, p yield from _run_transition_test_with_attestations(state, fork_epoch, spec, post_spec, pre_tag, post_tag) -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=3) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=3) for pre, post in ALL_FORKS.items()]) def test_transition_with_random_three_quarters_participation(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Transition from the initial ``state`` to the epoch after the ``fork_epoch``, @@ -289,7 +294,7 @@ def test_transition_with_random_three_quarters_participation(state, fork_epoch, ) -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=3) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=3) for pre, post in ALL_FORKS.items()]) def test_transition_with_random_half_participation(state, fork_epoch, spec, post_spec, pre_tag, post_tag): rng = random.Random(2020) @@ -313,7 +318,7 @@ def test_transition_with_random_half_participation(state, fork_epoch, spec, post ) -@fork_transition_test(PHASE0, ALTAIR, fork_epoch=2) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=3) for pre, post in ALL_FORKS.items()]) def test_transition_with_no_attestations_until_after_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Transition from the initial ``state`` to the ``fork_epoch`` with no attestations, @@ -332,7 +337,7 @@ def test_transition_with_no_attestations_until_after_fork(state, fork_epoch, spe ]) # irregular state transition to handle fork: - state, block = do_altair_fork(state, spec, post_spec, fork_epoch) + state, block = do_fork(state, spec, post_spec, fork_epoch) blocks.append(post_tag(block)) # continue regular state transition but add attestations diff --git a/tests/core/pyspec/eth2spec/test/context.py b/tests/core/pyspec/eth2spec/test/context.py index 944351bfd..8dd7c88d5 100644 --- a/tests/core/pyspec/eth2spec/test/context.py +++ b/tests/core/pyspec/eth2spec/test/context.py @@ -1,5 +1,7 @@ import pytest from copy import deepcopy +from dataclasses import dataclass + from eth2spec.phase0 import mainnet as spec_phase0_mainnet, minimal as spec_phase0_minimal from eth2spec.altair import mainnet as spec_altair_mainnet, minimal as spec_altair_minimal from eth2spec.merge import mainnet as spec_merge_mainnet, minimal as spec_merge_minimal @@ -7,12 +9,16 @@ from eth2spec.utils import bls from .exceptions import SkippedTest from .helpers.constants import ( - SpecForkName, PresetBaseName, PHASE0, ALTAIR, MERGE, MINIMAL, MAINNET, ALL_PHASES, FORKS_BEFORE_ALTAIR, FORKS_BEFORE_MERGE, + ALL_FORKS, ) +from .helpers.typing import SpecForkName, PresetBaseName from .helpers.genesis import create_genesis_state -from .utils import vector_test, with_meta_tags, build_transition_test +from .utils import ( + vector_test, + with_meta_tags, +) from random import Random from typing import Any, Callable, Sequence, TypedDict, Protocol, Dict @@ -50,6 +56,13 @@ class SpecMerge(Spec): ... +@dataclass(frozen=True) +class ForkMeta: + pre_fork_name: str + post_fork_name: str + fork_epoch: int + + spec_targets: Dict[PresetBaseName, Dict[SpecForkName, Spec]] = { MINIMAL: { PHASE0: spec_phase0_minimal, @@ -86,7 +99,6 @@ _custom_state_cache_dict = LRU(size=10) def with_custom_state(balances_fn: Callable[[Any], Sequence[int]], threshold_fn: Callable[[Any], int]): def deco(fn): - def entry(*args, spec: Spec, phases: SpecForks, **kw): # make a key for the state, unique to the fork + config (incl preset choice) and balances/activations key = (spec.fork, spec.config.__hash__(), spec.__file__, balances_fn, threshold_fn) @@ -104,7 +116,7 @@ def with_custom_state(balances_fn: Callable[[Any], Sequence[int]], return deco -def default_activation_threshold(spec): +def default_activation_threshold(spec: Spec): """ Helper method to use the default balance activation threshold for state creation for tests. Usage: `@with_custom_state(threshold_fn=default_activation_threshold, ...)` @@ -112,7 +124,7 @@ def default_activation_threshold(spec): return spec.MAX_EFFECTIVE_BALANCE -def zero_activation_threshold(spec): +def zero_activation_threshold(spec: Spec): """ Helper method to use 0 gwei as the activation threshold for state creation for tests. Usage: `@with_custom_state(threshold_fn=zero_activation_threshold, ...)` @@ -120,7 +132,7 @@ def zero_activation_threshold(spec): return 0 -def default_balances(spec): +def default_balances(spec: Spec): """ Helper method to create a series of default balances. Usage: `@with_custom_state(balances_fn=default_balances, ...)` @@ -129,7 +141,7 @@ def default_balances(spec): return [spec.MAX_EFFECTIVE_BALANCE] * num_validators -def scaled_churn_balances(spec): +def scaled_churn_balances(spec: Spec): """ Helper method to create enough validators to scale the churn limit. (This is *firmly* over the churn limit -- thus the +2 instead of just +1) @@ -143,7 +155,7 @@ def scaled_churn_balances(spec): with_state = with_custom_state(default_balances, default_activation_threshold) -def low_balances(spec): +def low_balances(spec: Spec): """ Helper method to create a series of low balances. Usage: `@with_custom_state(balances_fn=low_balances, ...)` @@ -154,7 +166,7 @@ def low_balances(spec): return [low_balance] * num_validators -def misc_balances(spec): +def misc_balances(spec: Spec): """ Helper method to create a series of balances that includes some misc. balances. Usage: `@with_custom_state(balances_fn=misc_balances, ...)` @@ -166,7 +178,7 @@ def misc_balances(spec): return balances -def misc_balances_in_default_range_with_many_validators(spec): +def misc_balances_in_default_range_with_many_validators(spec: Spec): """ Helper method to create a series of balances that includes some misc. balances but none that are below the ``EJECTION_BALANCE``. @@ -182,7 +194,7 @@ def misc_balances_in_default_range_with_many_validators(spec): return balances -def low_single_balance(spec): +def low_single_balance(spec: Spec): """ Helper method to create a single of balance of 1 Gwei. Usage: `@with_custom_state(balances_fn=low_single_balance, ...)` @@ -190,7 +202,7 @@ def low_single_balance(spec): return [1] -def large_validator_set(spec): +def large_validator_set(spec: Spec): """ Helper method to create a large series of default balances. Usage: `@with_custom_state(balances_fn=default_balances, ...)` @@ -347,6 +359,66 @@ def with_all_phases_except(exclusion_phases): return decorator +def _get_preset_targets(kw): + preset_name = DEFAULT_TEST_PRESET + if 'preset' in kw: + preset_name = kw.pop('preset') + return spec_targets[preset_name] + + +def _get_run_phases(phases, kw): + """ + Return the fork names for the base `spec` in test cases + """ + if 'phase' in kw: + # Limit phases if one explicitly specified + phase = kw.pop('phase') + if phase not in phases: + dump_skipping_message(f"doesn't support this fork: {phase}") + return None + run_phases = [phase] + else: + # If pytest `--fork` flag is set, filter out the rest forks + run_phases = set(phases).intersection(DEFAULT_PYTEST_FORKS) + + return run_phases + + +def _get_available_phases(run_phases, other_phases): + """ + The return the available fork names for multi-phase tests + """ + available_phases = set(run_phases) + if other_phases is not None: + available_phases |= set(other_phases) + return available_phases + + +def _run_test_case_with_phases(fn, phases, other_phases, kw, args, is_fork_transition=False): + run_phases = _get_run_phases(phases, kw) + + if len(run_phases) == 0: + if not is_fork_transition: + dump_skipping_message("none of the recognized phases are executable, skipping test.") + return None + + available_phases = _get_available_phases(run_phases, other_phases) + + targets = _get_preset_targets(kw) + + # Populate all phases for multi-phase tests + phase_dir = {} + for phase in available_phases: + phase_dir[phase] = targets[phase] + + # Return is ignored whenever multiple phases are ran. + # This return is for test generators to emit python generators (yielding test vector outputs) + for phase in run_phases: + ret = fn(spec=targets[phase], phases=phase_dir, *args, **kw) + + return ret + + def with_phases(phases, other_phases=None): """ Decorator factory that returns a decorator that runs a test for the appropriate phases. @@ -354,49 +426,24 @@ def with_phases(phases, other_phases=None): """ def decorator(fn): def wrapper(*args, **kw): - run_phases = set(phases).intersection(DEFAULT_PYTEST_FORKS) - - # limit phases if one explicitly specified - if 'phase' in kw: - phase = kw.pop('phase') - if phase not in phases: - dump_skipping_message(f"doesn't support this fork: {phase}") - return None - run_phases = [phase] - - if PHASE0 not in run_phases and ALTAIR not in run_phases and MERGE not in run_phases: - dump_skipping_message("none of the recognized phases are executable, skipping test.") - return None - - available_phases = set(run_phases) - if other_phases is not None: - available_phases |= set(other_phases) - - preset_name = DEFAULT_TEST_PRESET - if 'preset' in kw: - preset_name = kw.pop('preset') - targets = spec_targets[preset_name] - - # Populate all phases for multi-phase tests - phase_dir = {} - if PHASE0 in available_phases: - phase_dir[PHASE0] = targets[PHASE0] - if ALTAIR in available_phases: - phase_dir[ALTAIR] = targets[ALTAIR] - if MERGE in available_phases: - phase_dir[MERGE] = targets[MERGE] - - # return is ignored whenever multiple phases are ran. - # This return is for test generators to emit python generators (yielding test vector outputs) - if PHASE0 in run_phases: - ret = fn(spec=targets[PHASE0], phases=phase_dir, *args, **kw) - if ALTAIR in run_phases: - ret = fn(spec=targets[ALTAIR], phases=phase_dir, *args, **kw) - if MERGE in run_phases: - ret = fn(spec=targets[MERGE], phases=phase_dir, *args, **kw) - - # TODO: merge, sharding, custody_game and das are not executable yet. - # Tests that specify these features will not run, and get ignored for these specific phases. + if 'fork_metas' in kw: + fork_metas = kw.pop('fork_metas') + if 'phase' in kw: + # When running test generator, it sets specific `phase` + phase = kw['phase'] + _phases = [phase] + _other_phases = [ALL_FORKS[phase]] + ret = _run_test_case_with_phases(fn, _phases, _other_phases, kw, args, is_fork_transition=True) + else: + # When running pytest, go through `fork_metas` + for fork_meta in fork_metas: + pre_fork_name = fork_meta.pre_fork_name + post_fork_name = fork_meta.post_fork_name + _phases = [pre_fork_name] + _other_phases = [post_fork_name] + ret = _run_test_case_with_phases(fn, _phases, _other_phases, kw, args, is_fork_transition=True) + else: + ret = _run_test_case_with_phases(fn, phases, other_phases, kw, args) return ret return wrapper return decorator @@ -481,10 +528,25 @@ def only_generator(reason): return _decorator -def fork_transition_test(pre_fork_name, post_fork_name, fork_epoch=None): +# +# Fork transition state tests +# + + +def set_fork_metas(fork_metas: Sequence[ForkMeta]): + def decorator(fn): + def wrapper(*args, **kwargs): + return fn(*args, fork_metas=fork_metas, **kwargs) + return wrapper + return decorator + + +def with_fork_metas(fork_metas: Sequence[ForkMeta]): """ - A decorator to construct a "transition" test from one fork of the eth2 spec - to another. + A decorator to construct a "transition" test from one fork to another. + + Decorator takes a list of `ForkMeta` and each item defines `pre_fork_name`, + `post_fork_name`, and `fork_epoch`. Decorator assumes a transition from the `pre_fork_name` fork to the `post_fork_name` fork. The user can supply a `fork_epoch` at which the @@ -502,15 +564,62 @@ def fork_transition_test(pre_fork_name, post_fork_name, fork_epoch=None): `post_tag`: a function to tag data as belonging to `post_fork_name` fork. Used to discriminate data during consumption of the generated spec tests. """ - def _wrapper(fn): - @with_phases([pre_fork_name], other_phases=[post_fork_name]) - @spec_test - @with_state - def _adapter(*args, **kwargs): - wrapped = build_transition_test(fn, - pre_fork_name, - post_fork_name, - fork_epoch=fork_epoch) - return wrapped(*args, **kwargs) - return _adapter - return _wrapper + run_yield_fork_meta = yield_fork_meta(fork_metas) + run_with_phases = with_phases(ALL_PHASES) + run_set_fork_metas = set_fork_metas(fork_metas) + + def decorator(fn): + return run_set_fork_metas(run_with_phases(spec_test(with_state(run_yield_fork_meta(fn))))) + return decorator + + +def yield_fork_meta(fork_metas: Sequence[ForkMeta]): + """ + Yield meta fields to `meta.yaml` and pass post spec and meta fields to `fn`. + """ + def decorator(fn): + def wrapper(*args, **kw): + phases = kw.pop('phases') + spec = kw["spec"] + fork_meta = [m for m in fork_metas if m.pre_fork_name == spec.fork][0] + fork_meta = next(filter(lambda m: m.pre_fork_name == spec.fork, fork_metas)) + post_spec = phases[fork_meta.post_fork_name] + + # Reset counter + pre_fork_counter = 0 + + def pre_tag(obj): + nonlocal pre_fork_counter + pre_fork_counter += 1 + return obj + + def post_tag(obj): + return obj + + yield "post_fork", "meta", fork_meta.post_fork_name + + has_fork_epoch = False + if fork_meta.fork_epoch: + kw["fork_epoch"] = fork_meta.fork_epoch + has_fork_epoch = True + yield "fork_epoch", "meta", fork_meta.fork_epoch + + result = fn( + *args, + post_spec=post_spec, + pre_tag=pre_tag, + post_tag=post_tag, + **kw, + ) + if result is not None: + for part in result: + if part[0] == "fork_epoch": + has_fork_epoch = True + yield part + assert has_fork_epoch + + if pre_fork_counter > 0: + yield "fork_block", "meta", pre_fork_counter - 1 + + return wrapper + return decorator diff --git a/tests/core/pyspec/eth2spec/test/helpers/constants.py b/tests/core/pyspec/eth2spec/test/helpers/constants.py index 5ab847327..4b2f37b66 100644 --- a/tests/core/pyspec/eth2spec/test/helpers/constants.py +++ b/tests/core/pyspec/eth2spec/test/helpers/constants.py @@ -21,6 +21,11 @@ TESTGEN_FORKS = (PHASE0, ALTAIR, MERGE) FORKS_BEFORE_ALTAIR = (PHASE0,) FORKS_BEFORE_MERGE = (PHASE0, ALTAIR) +ALL_FORKS = { + # pre_fork_name: post_fork_name + PHASE0: ALTAIR, + ALTAIR: MERGE, +} # # Config diff --git a/tests/core/pyspec/eth2spec/test/helpers/fork_transition.py b/tests/core/pyspec/eth2spec/test/helpers/fork_transition.py index 310c4a8d2..853863e51 100644 --- a/tests/core/pyspec/eth2spec/test/helpers/fork_transition.py +++ b/tests/core/pyspec/eth2spec/test/helpers/fork_transition.py @@ -9,6 +9,10 @@ from eth2spec.test.helpers.block import ( build_empty_block, sign_block, ) +from eth2spec.test.helpers.constants import ( + ALTAIR, + MERGE, +) from eth2spec.test.helpers.deposits import ( prepare_state_and_deposit, ) @@ -133,17 +137,25 @@ def state_transition_across_slots_with_ignoring_proposers(spec, next_slot(spec, state) -def do_altair_fork(state, spec, post_spec, fork_epoch, with_block=True, operation_dict=None): +def do_fork(state, spec, post_spec, fork_epoch, with_block=True, operation_dict=None): spec.process_slots(state, state.slot + 1) assert state.slot % spec.SLOTS_PER_EPOCH == 0 assert spec.get_current_epoch(state) == fork_epoch - state = post_spec.upgrade_to_altair(state) + if post_spec.fork == ALTAIR: + state = post_spec.upgrade_to_altair(state) + elif post_spec.fork == MERGE: + state = post_spec.upgrade_to_merge(state) assert state.fork.epoch == fork_epoch - assert state.fork.previous_version == post_spec.config.GENESIS_FORK_VERSION - assert state.fork.current_version == post_spec.config.ALTAIR_FORK_VERSION + + if post_spec.fork == ALTAIR: + assert state.fork.previous_version == post_spec.config.GENESIS_FORK_VERSION + assert state.fork.current_version == post_spec.config.ALTAIR_FORK_VERSION + elif post_spec.fork == MERGE: + assert state.fork.previous_version == post_spec.config.ALTAIR_FORK_VERSION + assert state.fork.current_version == post_spec.config.MERGE_FORK_VERSION if with_block: return state, _state_transition_and_sign_block_at_slot(post_spec, state, operation_dict=operation_dict) @@ -280,7 +292,7 @@ def run_transition_with_operation(state, # irregular state transition to handle fork: _operation_at_slot = operation_dict if is_at_fork else None - state, block = do_altair_fork(state, spec, post_spec, fork_epoch, operation_dict=_operation_at_slot) + state, block = do_fork(state, spec, post_spec, fork_epoch, operation_dict=_operation_at_slot) blocks.append(post_tag(block)) if is_at_fork: diff --git a/tests/core/pyspec/eth2spec/test/utils/__init__.py b/tests/core/pyspec/eth2spec/test/utils/__init__.py index f6b2a8a44..abd79f9ed 100644 --- a/tests/core/pyspec/eth2spec/test/utils/__init__.py +++ b/tests/core/pyspec/eth2spec/test/utils/__init__.py @@ -1,12 +1,10 @@ from .utils import ( vector_test, with_meta_tags, - build_transition_test, ) __all__ = [ # avoid "unused import" lint error "vector_test", "with_meta_tags", - "build_transition_test", ] diff --git a/tests/core/pyspec/eth2spec/test/utils/utils.py b/tests/core/pyspec/eth2spec/test/utils/utils.py index 61fc75040..bad6c867b 100644 --- a/tests/core/pyspec/eth2spec/test/utils/utils.py +++ b/tests/core/pyspec/eth2spec/test/utils/utils.py @@ -1,4 +1,3 @@ -import inspect from typing import Dict, Any from eth2spec.utils.ssz.ssz_typing import View from eth2spec.utils.ssz.ssz_impl import serialize @@ -94,50 +93,3 @@ def with_meta_tags(tags: Dict[str, Any]): yield k, 'meta', v return entry return runner - - -def build_transition_test(fn, pre_fork_name, post_fork_name, fork_epoch=None): - """ - Handles the inner plumbing to generate `transition_test`s. - See that decorator in `context.py` for more information. - """ - def _adapter(*args, **kwargs): - post_spec = kwargs["phases"][post_fork_name] - - pre_fork_counter = 0 - - def pre_tag(obj): - nonlocal pre_fork_counter - pre_fork_counter += 1 - return obj - - def post_tag(obj): - return obj - - yield "post_fork", "meta", post_fork_name - - has_fork_epoch = False - if fork_epoch: - kwargs["fork_epoch"] = fork_epoch - has_fork_epoch = True - yield "fork_epoch", "meta", fork_epoch - - # massage args to handle an optional custom state using - # `with_custom_state` decorator - expected_args = inspect.getfullargspec(fn) - if "phases" not in expected_args.kwonlyargs: - kwargs.pop("phases", None) - - for part in fn(*args, - post_spec=post_spec, - pre_tag=pre_tag, - post_tag=post_tag, - **kwargs): - if part[0] == "fork_epoch": - has_fork_epoch = True - yield part - assert has_fork_epoch - - if pre_fork_counter > 0: - yield "fork_block", "meta", pre_fork_counter - 1 - return _adapter diff --git a/tests/generators/transition/main.py b/tests/generators/transition/main.py index a850a7f45..80aef8fec 100644 --- a/tests/generators/transition/main.py +++ b/tests/generators/transition/main.py @@ -1,6 +1,14 @@ from typing import Iterable -from eth2spec.test.helpers.constants import ALTAIR, MINIMAL, MAINNET, PHASE0 +from eth2spec.test.helpers.constants import ( + MINIMAL, + MAINNET, + ALL_FORKS, +) +from eth2spec.gen_helpers.gen_base import gen_runner, gen_typing +from eth2spec.gen_helpers.gen_from_tests.gen import ( + generate_from_tests, +) from eth2spec.test.altair.transition import ( test_transition as test_altair_transition, test_activations_and_exits as test_altair_activations_and_exits, @@ -9,9 +17,6 @@ from eth2spec.test.altair.transition import ( test_operations as test_altair_operations, ) -from eth2spec.gen_helpers.gen_base import gen_runner, gen_typing -from eth2spec.gen_helpers.gen_from_tests.gen import generate_from_tests - def create_provider(tests_src, preset_name: str, pre_fork_name: str, post_fork_name: str) -> gen_typing.TestProvider: @@ -31,18 +36,17 @@ def create_provider(tests_src, preset_name: str, pre_fork_name: str, post_fork_n return gen_typing.TestProvider(prepare=prepare_fn, make_cases=cases_fn) -TRANSITION_TESTS = ( - (PHASE0, ALTAIR, test_altair_transition), - (PHASE0, ALTAIR, test_altair_activations_and_exits), - (PHASE0, ALTAIR, test_altair_leaking), - (PHASE0, ALTAIR, test_altair_slashing), - (PHASE0, ALTAIR, test_altair_operations), -) - - if __name__ == "__main__": - for pre_fork, post_fork, transition_test_module in TRANSITION_TESTS: - gen_runner.run_generator("transition", [ - create_provider(transition_test_module, MINIMAL, pre_fork, post_fork), - create_provider(transition_test_module, MAINNET, pre_fork, post_fork), - ]) + altair_tests = ( + test_altair_transition, + test_altair_activations_and_exits, + test_altair_leaking, + test_altair_slashing, + test_altair_operations, + ) + for transition_test_module in altair_tests: + for pre_fork, post_fork in ALL_FORKS.items(): + gen_runner.run_generator("transition", [ + create_provider(transition_test_module, MINIMAL, pre_fork, post_fork), + create_provider(transition_test_module, MAINNET, pre_fork, post_fork), + ]) From fa4dc0c1681b4068f6b180374ffff4abbe8ad277 Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Tue, 2 Nov 2021 18:38:24 +0800 Subject: [PATCH 2/6] Apply suggestions from code review Co-authored-by: Alex Stokes --- tests/core/pyspec/eth2spec/test/context.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/tests/core/pyspec/eth2spec/test/context.py b/tests/core/pyspec/eth2spec/test/context.py index 8dd7c88d5..3001946aa 100644 --- a/tests/core/pyspec/eth2spec/test/context.py +++ b/tests/core/pyspec/eth2spec/test/context.py @@ -378,7 +378,7 @@ def _get_run_phases(phases, kw): return None run_phases = [phase] else: - # If pytest `--fork` flag is set, filter out the rest forks + # If pytest `--fork` flag is set, filter out the rest of the forks run_phases = set(phases).intersection(DEFAULT_PYTEST_FORKS) return run_phases @@ -386,7 +386,7 @@ def _get_run_phases(phases, kw): def _get_available_phases(run_phases, other_phases): """ - The return the available fork names for multi-phase tests + Return the available fork names for multi-phase tests """ available_phases = set(run_phases) if other_phases is not None: @@ -581,7 +581,6 @@ def yield_fork_meta(fork_metas: Sequence[ForkMeta]): def wrapper(*args, **kw): phases = kw.pop('phases') spec = kw["spec"] - fork_meta = [m for m in fork_metas if m.pre_fork_name == spec.fork][0] fork_meta = next(filter(lambda m: m.pre_fork_name == spec.fork, fork_metas)) post_spec = phases[fork_meta.post_fork_name] From 0641d1c1840f1b374ae4d1383ba720fb1879d99c Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Tue, 2 Nov 2021 19:01:32 +0800 Subject: [PATCH 3/6] `ALL_FORKS` sounds like a list of fork names. Rename it to `ALL_FORK_UPGRADES` --- .../transition/test_activations_and_exits.py | 10 +++++----- .../test/altair/transition/test_leaking.py | 6 +++--- .../test/altair/transition/test_operations.py | 18 +++++++++--------- .../test/altair/transition/test_slashing.py | 4 ++-- .../test/altair/transition/test_transition.py | 18 +++++++++--------- tests/core/pyspec/eth2spec/test/context.py | 4 ++-- .../pyspec/eth2spec/test/helpers/constants.py | 4 +++- tests/generators/transition/main.py | 4 ++-- 8 files changed, 35 insertions(+), 33 deletions(-) diff --git a/tests/core/pyspec/eth2spec/test/altair/transition/test_activations_and_exits.py b/tests/core/pyspec/eth2spec/test/altair/transition/test_activations_and_exits.py index 0f5b28db6..e698c56ba 100644 --- a/tests/core/pyspec/eth2spec/test/altair/transition/test_activations_and_exits.py +++ b/tests/core/pyspec/eth2spec/test/altair/transition/test_activations_and_exits.py @@ -5,7 +5,7 @@ from eth2spec.test.context import ( with_fork_metas, ) from eth2spec.test.helpers.constants import ( - ALL_FORKS, + ALL_PRE_POST_FORKS, MINIMAL, ) from eth2spec.test.helpers.fork_transition import ( @@ -24,7 +24,7 @@ from eth2spec.test.helpers.random import ( # Exit # -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_PRE_POST_FORKS]) @with_presets([MINIMAL], reason="only test with enough validators such that at least one exited index is not in sync committee") def test_transition_with_one_fourth_exiting_validators_exit_post_fork(state, @@ -84,7 +84,7 @@ def test_transition_with_one_fourth_exiting_validators_exit_post_fork(state, yield "post", state -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_PRE_POST_FORKS]) def test_transition_with_one_fourth_exiting_validators_exit_at_fork(state, fork_epoch, spec, @@ -142,7 +142,7 @@ def test_transition_with_one_fourth_exiting_validators_exit_at_fork(state, # -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_PRE_POST_FORKS]) def test_transition_with_non_empty_activation_queue(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Create some deposits before the transition @@ -170,7 +170,7 @@ def test_transition_with_non_empty_activation_queue(state, fork_epoch, spec, pos yield "post", state -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_PRE_POST_FORKS]) def test_transition_with_activation_at_fork_epoch(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Create some deposits before the transition diff --git a/tests/core/pyspec/eth2spec/test/altair/transition/test_leaking.py b/tests/core/pyspec/eth2spec/test/altair/transition/test_leaking.py index 3ed2e37ee..338289597 100644 --- a/tests/core/pyspec/eth2spec/test/altair/transition/test_leaking.py +++ b/tests/core/pyspec/eth2spec/test/altair/transition/test_leaking.py @@ -3,7 +3,7 @@ from eth2spec.test.context import ( with_fork_metas, ) from eth2spec.test.helpers.constants import ( - ALL_FORKS, + ALL_PRE_POST_FORKS, ) from eth2spec.test.helpers.fork_transition import ( do_fork, @@ -12,7 +12,7 @@ from eth2spec.test.helpers.fork_transition import ( ) -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=7) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=7) for pre, post in ALL_PRE_POST_FORKS]) def test_transition_with_leaking_pre_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Leaking starts at epoch 6 (MIN_EPOCHS_TO_INACTIVITY_PENALTY + 2). @@ -40,7 +40,7 @@ def test_transition_with_leaking_pre_fork(state, fork_epoch, spec, post_spec, pr yield "post", state -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=6) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=6) for pre, post in ALL_PRE_POST_FORKS]) def test_transition_with_leaking_at_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Leaking starts at epoch 6 (MIN_EPOCHS_TO_INACTIVITY_PENALTY + 2). diff --git a/tests/core/pyspec/eth2spec/test/altair/transition/test_operations.py b/tests/core/pyspec/eth2spec/test/altair/transition/test_operations.py index 54f37a235..121053186 100644 --- a/tests/core/pyspec/eth2spec/test/altair/transition/test_operations.py +++ b/tests/core/pyspec/eth2spec/test/altair/transition/test_operations.py @@ -5,7 +5,7 @@ from eth2spec.test.context import ( with_presets, ) from eth2spec.test.helpers.constants import ( - ALL_FORKS, + ALL_PRE_POST_FORKS, MINIMAL, ) from eth2spec.test.helpers.fork_transition import ( @@ -18,7 +18,7 @@ from eth2spec.test.helpers.fork_transition import ( # PROPOSER_SLASHING # -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_PRE_POST_FORKS]) @always_bls def test_transition_with_proposer_slashing_right_after_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ @@ -36,7 +36,7 @@ def test_transition_with_proposer_slashing_right_after_fork(state, fork_epoch, s ) -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_PRE_POST_FORKS]) @always_bls def test_transition_with_proposer_slashing_right_before_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ @@ -59,7 +59,7 @@ def test_transition_with_proposer_slashing_right_before_fork(state, fork_epoch, # -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_PRE_POST_FORKS]) @always_bls def test_transition_with_attester_slashing_right_after_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ @@ -77,7 +77,7 @@ def test_transition_with_attester_slashing_right_after_fork(state, fork_epoch, s ) -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_PRE_POST_FORKS]) @always_bls def test_transition_with_attester_slashing_right_before_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ @@ -100,7 +100,7 @@ def test_transition_with_attester_slashing_right_before_fork(state, fork_epoch, # -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_PRE_POST_FORKS]) def test_transition_with_deposit_right_after_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Create a deposit right *after* the transition @@ -117,7 +117,7 @@ def test_transition_with_deposit_right_after_fork(state, fork_epoch, spec, post_ ) -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_PRE_POST_FORKS]) def test_transition_with_deposit_right_before_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Create a deposit right *before* the transition @@ -139,7 +139,7 @@ def test_transition_with_deposit_right_before_fork(state, fork_epoch, spec, post # -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=66) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=66) for pre, post in ALL_PRE_POST_FORKS]) @with_presets([MINIMAL], reason="too slow") def test_transition_with_voluntary_exit_right_after_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ @@ -161,7 +161,7 @@ def test_transition_with_voluntary_exit_right_after_fork(state, fork_epoch, spec ) -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=66) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=66) for pre, post in ALL_PRE_POST_FORKS]) @with_presets([MINIMAL], reason="too slow") def test_transition_with_voluntary_exit_right_before_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ diff --git a/tests/core/pyspec/eth2spec/test/altair/transition/test_slashing.py b/tests/core/pyspec/eth2spec/test/altair/transition/test_slashing.py index 6d8f23b7d..b3ba92321 100644 --- a/tests/core/pyspec/eth2spec/test/altair/transition/test_slashing.py +++ b/tests/core/pyspec/eth2spec/test/altair/transition/test_slashing.py @@ -5,7 +5,7 @@ from eth2spec.test.context import ( with_presets, ) from eth2spec.test.helpers.constants import ( - ALL_FORKS, + ALL_PRE_POST_FORKS, MINIMAL, ) from eth2spec.test.helpers.fork_transition import ( @@ -18,7 +18,7 @@ from eth2spec.test.helpers.random import ( ) -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=1) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=1) for pre, post in ALL_PRE_POST_FORKS]) @with_presets([MINIMAL], reason="only test with enough validators such that at least one exited index is not in sync committee") def test_transition_with_one_fourth_slashed_active_validators_pre_fork(state, diff --git a/tests/core/pyspec/eth2spec/test/altair/transition/test_transition.py b/tests/core/pyspec/eth2spec/test/altair/transition/test_transition.py index 2439b79fc..2ac8bfb48 100644 --- a/tests/core/pyspec/eth2spec/test/altair/transition/test_transition.py +++ b/tests/core/pyspec/eth2spec/test/altair/transition/test_transition.py @@ -4,7 +4,7 @@ from eth2spec.test.context import ( with_fork_metas, ) from eth2spec.test.helpers.constants import ( - ALL_FORKS, + ALL_PRE_POST_FORKS, ) from eth2spec.test.helpers.state import ( next_epoch_via_signed_block, @@ -20,7 +20,7 @@ from eth2spec.test.helpers.fork_transition import ( ) -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_PRE_POST_FORKS]) def test_normal_transition(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Transition from the initial ``state`` to the epoch after the ``fork_epoch``, @@ -56,7 +56,7 @@ def test_normal_transition(state, fork_epoch, spec, post_spec, pre_tag, post_tag yield "post", state -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_PRE_POST_FORKS]) def test_transition_missing_first_post_block(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Transition from the initial ``state`` to the epoch after the ``fork_epoch``, @@ -93,7 +93,7 @@ def test_transition_missing_first_post_block(state, fork_epoch, spec, post_spec, yield "post", state -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_PRE_POST_FORKS]) def test_transition_missing_last_pre_fork_block(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Transition from the initial ``state`` to the epoch after the ``fork_epoch``, @@ -132,7 +132,7 @@ def test_transition_missing_last_pre_fork_block(state, fork_epoch, spec, post_sp yield "post", state -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in ALL_PRE_POST_FORKS]) def test_transition_only_blocks_post_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Transition from the initial ``state`` to the epoch after the ``fork_epoch``, @@ -258,7 +258,7 @@ def _run_transition_test_with_attestations(state, yield "post", state -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=3) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=3) for pre, post in ALL_PRE_POST_FORKS]) def test_transition_with_finality(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Transition from the initial ``state`` to the epoch after the ``fork_epoch``, @@ -267,7 +267,7 @@ def test_transition_with_finality(state, fork_epoch, spec, post_spec, pre_tag, p yield from _run_transition_test_with_attestations(state, fork_epoch, spec, post_spec, pre_tag, post_tag) -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=3) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=3) for pre, post in ALL_PRE_POST_FORKS]) def test_transition_with_random_three_quarters_participation(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Transition from the initial ``state`` to the epoch after the ``fork_epoch``, @@ -294,7 +294,7 @@ def test_transition_with_random_three_quarters_participation(state, fork_epoch, ) -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=3) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=3) for pre, post in ALL_PRE_POST_FORKS]) def test_transition_with_random_half_participation(state, fork_epoch, spec, post_spec, pre_tag, post_tag): rng = random.Random(2020) @@ -318,7 +318,7 @@ def test_transition_with_random_half_participation(state, fork_epoch, spec, post ) -@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=3) for pre, post in ALL_FORKS.items()]) +@with_fork_metas([ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=3) for pre, post in ALL_PRE_POST_FORKS]) def test_transition_with_no_attestations_until_after_fork(state, fork_epoch, spec, post_spec, pre_tag, post_tag): """ Transition from the initial ``state`` to the ``fork_epoch`` with no attestations, diff --git a/tests/core/pyspec/eth2spec/test/context.py b/tests/core/pyspec/eth2spec/test/context.py index 3001946aa..04da8e653 100644 --- a/tests/core/pyspec/eth2spec/test/context.py +++ b/tests/core/pyspec/eth2spec/test/context.py @@ -11,7 +11,7 @@ from .exceptions import SkippedTest from .helpers.constants import ( PHASE0, ALTAIR, MERGE, MINIMAL, MAINNET, ALL_PHASES, FORKS_BEFORE_ALTAIR, FORKS_BEFORE_MERGE, - ALL_FORKS, + ALL_FORK_UPGRADES, ) from .helpers.typing import SpecForkName, PresetBaseName from .helpers.genesis import create_genesis_state @@ -432,7 +432,7 @@ def with_phases(phases, other_phases=None): # When running test generator, it sets specific `phase` phase = kw['phase'] _phases = [phase] - _other_phases = [ALL_FORKS[phase]] + _other_phases = [ALL_FORK_UPGRADES[phase]] ret = _run_test_case_with_phases(fn, _phases, _other_phases, kw, args, is_fork_transition=True) else: # When running pytest, go through `fork_metas` diff --git a/tests/core/pyspec/eth2spec/test/helpers/constants.py b/tests/core/pyspec/eth2spec/test/helpers/constants.py index 4b2f37b66..4f0f8bd6d 100644 --- a/tests/core/pyspec/eth2spec/test/helpers/constants.py +++ b/tests/core/pyspec/eth2spec/test/helpers/constants.py @@ -21,11 +21,13 @@ TESTGEN_FORKS = (PHASE0, ALTAIR, MERGE) FORKS_BEFORE_ALTAIR = (PHASE0,) FORKS_BEFORE_MERGE = (PHASE0, ALTAIR) -ALL_FORKS = { +ALL_FORK_UPGRADES = { # pre_fork_name: post_fork_name PHASE0: ALTAIR, ALTAIR: MERGE, } +ALL_PRE_POST_FORKS = ALL_FORK_UPGRADES.items() + # # Config diff --git a/tests/generators/transition/main.py b/tests/generators/transition/main.py index 80aef8fec..de00e774a 100644 --- a/tests/generators/transition/main.py +++ b/tests/generators/transition/main.py @@ -3,7 +3,7 @@ from typing import Iterable from eth2spec.test.helpers.constants import ( MINIMAL, MAINNET, - ALL_FORKS, + ALL_FORK_UPGRADES, ) from eth2spec.gen_helpers.gen_base import gen_runner, gen_typing from eth2spec.gen_helpers.gen_from_tests.gen import ( @@ -45,7 +45,7 @@ if __name__ == "__main__": test_altair_operations, ) for transition_test_module in altair_tests: - for pre_fork, post_fork in ALL_FORKS.items(): + for pre_fork, post_fork in ALL_PRE_POST_FORKS: gen_runner.run_generator("transition", [ create_provider(transition_test_module, MINIMAL, pre_fork, post_fork), create_provider(transition_test_module, MAINNET, pre_fork, post_fork), From 49d96f92ef6f6750e55b0cf089d173de5a643852 Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Fri, 12 Nov 2021 17:06:10 +0800 Subject: [PATCH 4/6] Add a sample altair-to-merge-only transition --- tests/core/pyspec/eth2spec/test/context.py | 6 +++- .../pyspec/eth2spec/test/helpers/constants.py | 3 +- .../test/merge/transition/__init__.py | 0 .../test/merge/transition/test_transition.py | 35 +++++++++++++++++++ tests/generators/transition/main.py | 11 ++++-- 5 files changed, 51 insertions(+), 4 deletions(-) create mode 100644 tests/core/pyspec/eth2spec/test/merge/transition/__init__.py create mode 100644 tests/core/pyspec/eth2spec/test/merge/transition/test_transition.py diff --git a/tests/core/pyspec/eth2spec/test/context.py b/tests/core/pyspec/eth2spec/test/context.py index 04da8e653..7f7c6bf28 100644 --- a/tests/core/pyspec/eth2spec/test/context.py +++ b/tests/core/pyspec/eth2spec/test/context.py @@ -581,7 +581,11 @@ def yield_fork_meta(fork_metas: Sequence[ForkMeta]): def wrapper(*args, **kw): phases = kw.pop('phases') spec = kw["spec"] - fork_meta = next(filter(lambda m: m.pre_fork_name == spec.fork, fork_metas)) + try: + fork_meta = next(filter(lambda m: m.pre_fork_name == spec.fork, fork_metas)) + except StopIteration: + dump_skipping_message(f"doesn't support this fork: {spec.fork}") + post_spec = phases[fork_meta.post_fork_name] # Reset counter diff --git a/tests/core/pyspec/eth2spec/test/helpers/constants.py b/tests/core/pyspec/eth2spec/test/helpers/constants.py index 4f0f8bd6d..bb8f49cbc 100644 --- a/tests/core/pyspec/eth2spec/test/helpers/constants.py +++ b/tests/core/pyspec/eth2spec/test/helpers/constants.py @@ -27,7 +27,8 @@ ALL_FORK_UPGRADES = { ALTAIR: MERGE, } ALL_PRE_POST_FORKS = ALL_FORK_UPGRADES.items() - +AFTER_MERGE_UPGRADES = {key: value for key, value in ALL_FORK_UPGRADES.items() if key not in FORKS_BEFORE_ALTAIR} +AFTER_MERGE_PRE_POST_FORKS = AFTER_MERGE_UPGRADES.items() # # Config diff --git a/tests/core/pyspec/eth2spec/test/merge/transition/__init__.py b/tests/core/pyspec/eth2spec/test/merge/transition/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/core/pyspec/eth2spec/test/merge/transition/test_transition.py b/tests/core/pyspec/eth2spec/test/merge/transition/test_transition.py new file mode 100644 index 000000000..d488d81dc --- /dev/null +++ b/tests/core/pyspec/eth2spec/test/merge/transition/test_transition.py @@ -0,0 +1,35 @@ +from eth2spec.test.context import ( + ForkMeta, + with_fork_metas, +) +from eth2spec.test.helpers.constants import ( + AFTER_MERGE_PRE_POST_FORKS, +) +from eth2spec.test.helpers.fork_transition import ( + do_fork, + transition_to_next_epoch_and_append_blocks, + transition_until_fork, +) + + +@with_fork_metas([ + ForkMeta(pre_fork_name=pre, post_fork_name=post, fork_epoch=2) for pre, post in AFTER_MERGE_PRE_POST_FORKS +]) +def test_sample_transition(state, fork_epoch, spec, post_spec, pre_tag, post_tag): + transition_until_fork(spec, state, fork_epoch) + + # check pre state + assert spec.get_current_epoch(state) < fork_epoch + + yield "pre", state + + # irregular state transition to handle fork: + blocks = [] + state, block = do_fork(state, spec, post_spec, fork_epoch) + blocks.append(post_tag(block)) + + # continue regular state transition with new spec into next epoch + transition_to_next_epoch_and_append_blocks(post_spec, state, post_tag, blocks, only_last_block=True) + + yield "blocks", blocks + yield "post", state diff --git a/tests/generators/transition/main.py b/tests/generators/transition/main.py index de00e774a..d6195de68 100644 --- a/tests/generators/transition/main.py +++ b/tests/generators/transition/main.py @@ -3,7 +3,7 @@ from typing import Iterable from eth2spec.test.helpers.constants import ( MINIMAL, MAINNET, - ALL_FORK_UPGRADES, + ALL_PRE_POST_FORKS, ) from eth2spec.gen_helpers.gen_base import gen_runner, gen_typing from eth2spec.gen_helpers.gen_from_tests.gen import ( @@ -16,6 +16,9 @@ from eth2spec.test.altair.transition import ( test_slashing as test_altair_slashing, test_operations as test_altair_operations, ) +from eth2spec.test.merge.transition import ( + test_transition as test_merge_transition, +) def create_provider(tests_src, preset_name: str, pre_fork_name: str, post_fork_name: str) -> gen_typing.TestProvider: @@ -44,7 +47,11 @@ if __name__ == "__main__": test_altair_slashing, test_altair_operations, ) - for transition_test_module in altair_tests: + merge_tests = ( + test_merge_transition, + ) + all_tests = altair_tests + merge_tests + for transition_test_module in all_tests: for pre_fork, post_fork in ALL_PRE_POST_FORKS: gen_runner.run_generator("transition", [ create_provider(transition_test_module, MINIMAL, pre_fork, post_fork), From f0bb032eb17ae441429405b89b7c158623f865c0 Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Mon, 15 Nov 2021 23:46:40 +0800 Subject: [PATCH 5/6] Fix `test_transition_with_one_fourth_exiting_validators_exit_at_fork` assertions --- .../test/altair/transition/test_activations_and_exits.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/tests/core/pyspec/eth2spec/test/altair/transition/test_activations_and_exits.py b/tests/core/pyspec/eth2spec/test/altair/transition/test_activations_and_exits.py index e698c56ba..438e2c20c 100644 --- a/tests/core/pyspec/eth2spec/test/altair/transition/test_activations_and_exits.py +++ b/tests/core/pyspec/eth2spec/test/altair/transition/test_activations_and_exits.py @@ -1,6 +1,7 @@ import random from eth2spec.test.context import ( ForkMeta, + ALTAIR, with_presets, with_fork_metas, ) @@ -130,6 +131,14 @@ def test_transition_with_one_fourth_exiting_validators_exit_at_fork(state, assert not post_spec.is_active_validator(validator, post_spec.get_current_epoch(state)) assert not post_spec.is_in_inactivity_leak(state) + exited_pubkeys = [state.validators[index].pubkey for index in exited_indices] + some_sync_committee_exited = any(set(exited_pubkeys).intersection(list(state.current_sync_committee.pubkeys))) + if post_spec.fork == ALTAIR: + # in Altair fork, the sync committee members would be set with only active validators + assert not some_sync_committee_exited + else: + assert some_sync_committee_exited + # continue regular state transition with new spec into next epoch transition_to_next_epoch_and_append_blocks(post_spec, state, post_tag, blocks, only_last_block=True) From 63c9e5ea56b1daa725d2d9ee9a1e368adc9d64d1 Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Tue, 16 Nov 2021 00:15:39 +0800 Subject: [PATCH 6/6] Minor refactoring and add comments --- tests/core/pyspec/eth2spec/test/context.py | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/tests/core/pyspec/eth2spec/test/context.py b/tests/core/pyspec/eth2spec/test/context.py index 7f7c6bf28..184c0d609 100644 --- a/tests/core/pyspec/eth2spec/test/context.py +++ b/tests/core/pyspec/eth2spec/test/context.py @@ -435,12 +435,10 @@ def with_phases(phases, other_phases=None): _other_phases = [ALL_FORK_UPGRADES[phase]] ret = _run_test_case_with_phases(fn, _phases, _other_phases, kw, args, is_fork_transition=True) else: - # When running pytest, go through `fork_metas` + # When running pytest, go through `fork_metas` instead of using `phases` for fork_meta in fork_metas: - pre_fork_name = fork_meta.pre_fork_name - post_fork_name = fork_meta.post_fork_name - _phases = [pre_fork_name] - _other_phases = [post_fork_name] + _phases = [fork_meta.pre_fork_name] + _other_phases = [fork_meta.post_fork_name] ret = _run_test_case_with_phases(fn, _phases, _other_phases, kw, args, is_fork_transition=True) else: ret = _run_test_case_with_phases(fn, phases, other_phases, kw, args)