Update static epoch test to use same testing flow (#2761)

* update static epoch test to use same testing flow

* updated bft-tests.yml for debugging TestEpochStaticTransition/TestStaticEpochTransition

* added scheduled run every hour

* kick off another CI test run for TestEpochStaticTransition/TestStaticEpochTransition #1

* kick off another CI test run for TestEpochStaticTransition/TestStaticEpochTransition #2

* #3 kick off another CI test run for TestEpochStaticTransition/TestStaticEpochTransition

* #4 kick off another CI test run for TestEpochStaticTransition/TestStaticEpochTransition

* #5 kick off another CI test run for TestEpochStaticTransition/TestStaticEpochTransition

* #6 kick off another CI test run for TestEpochStaticTransition/TestStaticEpochTransition

* #7 kick off another CI test run for TestEpochStaticTransition/TestStaticEpochTransition

* #8 kick off another CI test run for TestEpochStaticTransition/TestStaticEpochTransition

* #9 kick off another CI test run for TestEpochStaticTransition/TestStaticEpochTransition

* #10 kick off another CI test run for TestEpochStaticTransition/TestStaticEpochTransition

* remove sleep

* Dummy commit

* dummy commit

* dummy commit

* dummy commit

* dummy commit

* dummy commit

* dummy commit

* dummy commit

* dummy commit

* dummy commit

* 7699 dummy commit

* 3651 dummy commit

* 21538 dummy commit

* 7108 dummy commit

* 7186 dummy commit

* 1772 dummy commit

* 30464 dummy commit

* 15633 dummy commit

* 11129 dummy commit

* 15839 dummy commit

* remove dummy file

* remove dummy file

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

Author: jordanschalm

.github/workflows/bft-tests.yml

@@ -6,9 +6,11 @@ name: BFT Tests
 # this workflow should be disabled in Github when not needed: https://docs.github.com/en/actions/managing-workflow-runs/disabling-and-enabling-a-workflow
 
 on:
+  schedule:
+    - cron: '0 */1 * * *' # every 1 hour
   push:
     branches:
-      - '**/*bft*'
+      - '**/*6313*'
 
 env:
   GO_VERSION: 1.18
@@ -46,7 +48,7 @@ jobs:
       fail-fast: false
       matrix:
         test-category:
-          - integration-bft
+          - integration-epochs
     env:
       TEST_CATEGORY: ${{ matrix.test-category }}
     runs-on: ubuntu-latest

integration/tests/epochs/epoch_join_and_leave_an_test.go

@@ -3,9 +3,10 @@ package epochs
 import (
 	"testing"
 
+	"github.com/stretchr/testify/suite"
+
 	"github.com/onflow/flow-go/model/flow"
 	"github.com/onflow/flow-go/utils/unittest"
-	"github.com/stretchr/testify/suite"
 )
 
 func TestEpochJoinAndLeaveAN(t *testing.T) {

integration/tests/epochs/epoch_static_transition_test.go

@@ -3,13 +3,10 @@ package epochs
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 
-	"github.com/onflow/flow-go/integration/testnet"
 	"github.com/onflow/flow-go/model/flow"
-	"github.com/onflow/flow-go/state/protocol"
 )
 
 func TestEpochStaticTransition(t *testing.T) {
@@ -33,107 +30,40 @@ func (s *StaticEpochTransitionSuite) SetupTest() {
 	s.Suite.SetupTest()
 }
 
-// TestStaticEpochTransition asserts epoch state transitions over two full epochs
-// without any nodes joining or leaving.
+// TestStaticEpochTransition asserts epoch state transitions over full epoch
+// without any nodes joining or leaving. In particular, we assert that we enter
+// the EpochSetup phase, then successfully enter the second epoch (implying a
+// successful DKG).
+// This is equivalent to runTestEpochJoinAndLeave, without any committee changes.
 func (s *StaticEpochTransitionSuite) TestStaticEpochTransition() {
 
-	// phaseCheck is a utility struct that contains information about the
-	// final view of each epoch/phase.
-	type phaseCheck struct {
-		epoch     uint64
-		phase     flow.EpochPhase
-		finalView uint64 // the final view of the phase as defined by the EpochSetup
-	}
+	s.TimedLogf("waiting for EpochSetup phase of first epoch to begin")
+	s.WaitForPhase(s.ctx, flow.EpochPhaseSetup)
+	s.TimedLogf("successfully reached EpochSetup phase of first epoch")
 
-	phaseChecks := []*phaseCheck{}
-	// iterate through two epochs and populate a list of phase checks
-	for counter := 0; counter < 2; counter++ {
+	snapshot, err := s.client.GetLatestProtocolSnapshot(s.ctx)
+	require.NoError(s.T(), err)
 
-		// wait until the access node reaches the desired epoch
-		var epoch protocol.Epoch
-		var epochCounter uint64
-		for epoch == nil || epochCounter != uint64(counter) {
-			snapshot, err := s.client.GetLatestProtocolSnapshot(s.ctx)
-			require.NoError(s.T(), err)
-			epoch = snapshot.Epochs().Current()
-			epochCounter, err = epoch.Counter()
-			require.NoError(s.T(), err)
-		}
+	header, err := snapshot.Head()
+	require.NoError(s.T(), err)
+	s.TimedLogf("retrieved header after entering EpochSetup phase: height=%d, view=%d", header.Height, header.View)
 
-		epochFirstView, err := epoch.FirstView()
-		require.NoError(s.T(), err)
-		epochDKGPhase1Final, err := epoch.DKGPhase1FinalView()
-		require.NoError(s.T(), err)
-		epochDKGPhase2Final, err := epoch.DKGPhase2FinalView()
-		require.NoError(s.T(), err)
-		epochDKGPhase3Final, err := epoch.DKGPhase3FinalView()
-		require.NoError(s.T(), err)
-		epochFinal, err := epoch.FinalView()
-		require.NoError(s.T(), err)
+	epoch1FinalView, err := snapshot.Epochs().Current().FinalView()
+	require.NoError(s.T(), err)
+	epoch1Counter, err := snapshot.Epochs().Current().Counter()
+	require.NoError(s.T(), err)
 
-		epochViews := []*phaseCheck{
-			{epoch: epochCounter, phase: flow.EpochPhaseStaking, finalView: epochFirstView},
-			{epoch: epochCounter, phase: flow.EpochPhaseSetup, finalView: epochDKGPhase1Final},
-			{epoch: epochCounter, phase: flow.EpochPhaseSetup, finalView: epochDKGPhase2Final},
-			{epoch: epochCounter, phase: flow.EpochPhaseSetup, finalView: epochDKGPhase3Final},
-			{epoch: epochCounter, phase: flow.EpochPhaseCommitted, finalView: epochFinal},
-		}
+	// wait for the final view of the first epoch
+	s.TimedLogf("waiting for the final view (%d) of epoch %d", epoch1FinalView, epoch1Counter)
+	s.BlockState.WaitForSealedView(s.T(), epoch1FinalView+5)
+	s.TimedLogf("sealed final view (%d) of epoch %d", epoch1FinalView, epoch1Counter)
 
-		for _, v := range epochViews {
-			s.BlockState.WaitForSealedView(s.T(), v.finalView)
-		}
+	// assert transition to second epoch happened as expected
+	// if counter is still 0, epoch emergency fallback was triggered and we can fail early
+	s.assertEpochCounter(s.ctx, 1)
 
-		phaseChecks = append(phaseChecks, epochViews...)
-	}
-
-	s.net.StopContainers()
-
-	consensusContainers := make([]*testnet.Container, 0)
-	for _, c := range s.net.Containers {
-		if c.Config.Role == flow.RoleConsensus {
-			consensusContainers = append(consensusContainers, c)
-		}
-	}
-
-	for _, c := range consensusContainers {
-		containerState, err := c.OpenState()
-		require.NoError(s.T(), err)
-
-		// create a map of [view] => {epoch-counter, phase}
-		lookup := map[uint64]struct {
-			epochCounter uint64
-			phase        flow.EpochPhase
-		}{}
-
-		final, err := containerState.Final().Head()
-		require.NoError(s.T(), err)
-
-		var h uint64
-		for h = 0; h <= final.Height; h++ {
-			snapshot := containerState.AtHeight(h)
-
-			head, err := snapshot.Head()
-			require.NoError(s.T(), err)
-
-			epoch := snapshot.Epochs().Current()
-			currentEpochCounter, err := epoch.Counter()
-			require.NoError(s.T(), err)
-			currentPhase, err := snapshot.Phase()
-			require.NoError(s.T(), err)
-
-			lookup[head.View] = struct {
-				epochCounter uint64
-				phase        flow.EpochPhase
-			}{
-				currentEpochCounter,
-				currentPhase,
-			}
-		}
-
-		for _, v := range phaseChecks {
-			item := lookup[v.finalView]
-			assert.Equal(s.T(), v.epoch, item.epochCounter, "wrong epoch at view %d", v.finalView)
-			assert.Equal(s.T(), v.phase, item.phase, "wrong phase at view %d", v.finalView)
-		}
-	}
+	// submit a smoke test transaction to verify the network can seal a transaction
+	s.TimedLogf("sending smoke test transaction in second epoch")
+	s.submitSmokeTestTransaction(s.ctx)
+	s.TimedLogf("successfully submitted and observed sealing of smoke test transaction")
 }

integration/tests/epochs/suite.go

@@ -129,6 +129,12 @@ func (s *Suite) Ghost() *client.GhostClient {
 	return client
 }
 
+// TimedLogf logs the message using t.Log, but prefixes the current time.
+func (s *Suite) TimedLogf(msg string, args ...interface{}) {
+	args = append([]interface{}{time.Now().String()}, args...)
+	s.T().Logf("%s - "+msg, args...)
+}
+
 func (s *Suite) TearDownTest() {
 	s.log.Info().Msg("================> Start TearDownTest")
 	s.net.Remove()
@@ -762,27 +768,39 @@ func (s *Suite) runTestEpochJoinAndLeave(role flow.Role, checkNetworkHealth node
 	}
 
 	// staking our new node and add get the corresponding container for that node
+	s.TimedLogf("staking joining node with role %s", role.String())
 	info, testContainer := s.StakeNewNode(s.ctx, env, role)
+	s.TimedLogf("successfully staked joining node: %s", info.NodeID)
 
 	// use admin transaction to remove node, this simulates a node leaving the network
+	s.TimedLogf("removing node %s with role %s", containerToReplace.Config.NodeID, role.String())
 	s.removeNodeFromProtocol(s.ctx, env, containerToReplace.Config.NodeID)
+	s.TimedLogf("successfully removed node: %s", containerToReplace.Config.NodeID)
 
 	// wait for epoch setup phase before we start our container and pause the old container
+	s.TimedLogf("waiting for EpochSetup phase of first epoch to begin")
 	s.WaitForPhase(s.ctx, flow.EpochPhaseSetup)
+	s.TimedLogf("successfully reached EpochSetup phase of first epoch")
 
 	// get latest snapshot and start new container
 	snapshot, err := s.client.GetLatestProtocolSnapshot(s.ctx)
 	require.NoError(s.T(), err)
 	testContainer.WriteRootSnapshot(snapshot)
 	testContainer.Container.Start(s.ctx)
 
-	currentEpochFinalView, err := snapshot.Epochs().Current().FinalView()
+	header, err := snapshot.Head()
+	require.NoError(s.T(), err)
+	s.TimedLogf("retrieved header after entering EpochSetup phase: height=%d, view=%d", header.Height, header.View)
+
+	epoch1FinalView, err := snapshot.Epochs().Current().FinalView()
 	require.NoError(s.T(), err)
 
 	// wait for 5 views after the start of the next epoch before we pause our container to replace
-	s.BlockState.WaitForSealedView(s.T(), currentEpochFinalView+5)
+	s.TimedLogf("waiting for sealed view %d before pausing container", epoch1FinalView+5)
+	s.BlockState.WaitForSealedView(s.T(), epoch1FinalView+5)
+	s.TimedLogf("observed sealed view %d -> pausing container", epoch1FinalView+5)
 
-	//make sure container to replace removed from smart contract state
+	// make sure container to replace removed from smart contract state
 	s.assertNodeNotApprovedOrProposed(s.ctx, env, containerToReplace.Config.NodeID)
 
 	// assert transition to second epoch happened as expected
@@ -793,7 +811,9 @@ func (s *Suite) runTestEpochJoinAndLeave(role flow.Role, checkNetworkHealth node
 	require.NoError(s.T(), err)
 
 	// wait for 5 views after pausing our container to replace before we assert healthy network
-	s.BlockState.WaitForSealedView(s.T(), currentEpochFinalView+10)
+	s.TimedLogf("waiting for sealed view %d before asserting network health", epoch1FinalView+10)
+	s.BlockState.WaitForSealedView(s.T(), epoch1FinalView+10)
+	s.TimedLogf("observed sealed view %d -> asserting network health", epoch1FinalView+10)
 
 	// make sure the network is healthy after adding new node
 	checkNetworkHealth(s.ctx, env, snapshot, info)