[tmpnet] Refactor in preparation for addition of kube runtime

 - move process-specific behavior into ProcessRuntime
   - save API port
   - process-specific default and computed flags

 - move runtime-agnostic code (like github labels) from ProcessRuntime
 to Node

 - add restart method to enable the runtime to determine this
 behavior (stop/start for processes but scale down/scale up for kube)

 - ensure all runtime methods accept a context to account for needing
 make network calls in the kube runtime

 - add a log field to tmpnet.Network to ensure a log is always
 available to runtime methods

Author: maru-ava

tests/antithesis/compose.go

@@ -174,7 +174,7 @@ func newComposeProject(network *tmpnet.Network, nodeImageName string, workloadIm
 		}
 
 		// Apply configuration appropriate to a test network
-		for k, v := range tmpnet.DefaultTestFlags() {
+		for k, v := range tmpnet.DefaultTmpnetFlags() {
 			switch value := v.(type) {
 			case string:
 				env[k] = value

tests/e2e/e2e_test.go

@@ -61,23 +61,27 @@ var _ = ginkgo.SynchronizedBeforeSuite(func() []byte {
 	require.NoError(tc, err)
 
 	upgradeBase64 := base64.StdEncoding.EncodeToString(upgradeJSON)
+
+	defaultFlags := tmpnet.FlagsMap{
+		config.UpgradeFileContentKey: upgradeBase64,
+		// Ensure a min stake duration compatible with testing staking logic
+		config.MinStakeDurationKey: "1s",
+	}
+	defaultFlags.SetDefaults(tmpnet.DefaultE2EFlags())
+
 	return e2e.NewTestEnvironment(
 		tc,
 		flagVars,
 		&tmpnet.Network{
-			Owner: flagVars.NetworkOwner(),
-			DefaultFlags: tmpnet.FlagsMap{
-				config.UpgradeFileContentKey: upgradeBase64,
-				// Ensure a min stake duration compatible with testing staking logic
-				config.MinStakeDurationKey: tmpnet.DefaultMinStakeDuration,
-			},
-			Nodes:   nodes,
-			Subnets: subnets,
+			Owner:        flagVars.NetworkOwner(),
+			DefaultFlags: defaultFlags,
+			Nodes:        nodes,
+			Subnets:      subnets,
 		},
 	).Marshal()
 }, func(envBytes []byte) {
 	// Run in every ginkgo process
 
 	// Initialize the local test environment from the global state
-	e2e.InitSharedTestEnvironment(ginkgo.GinkgoT(), envBytes)
+	e2e.InitSharedTestEnvironment(e2e.NewTestContext(), envBytes)
 })

tests/e2e/faultinjection/duplicate_node_id.go

@@ -44,7 +44,7 @@ var _ = ginkgo.Describe("Duplicate node handling", func() {
 		_ = e2e.AddEphemeralNode(tc, network, node2)
 
 		tc.By("checking that the second new node fails to become healthy before timeout")
-		err := tmpnet.WaitForHealthy(tc.DefaultContext(), node2)
+		err := tmpnet.WaitForHealthyNode(tc.DefaultContext(), tc.Log(), node2)
 		require.ErrorIs(err, context.DeadlineExceeded)
 
 		tc.By("stopping the first new node")

tests/fixture/e2e/env.go

@@ -26,11 +26,12 @@ import (
 // access to the shared env to GetEnv which adds a test context.
 var env *TestEnvironment
 
-func InitSharedTestEnvironment(t require.TestingT, envBytes []byte) {
-	require := require.New(t)
+func InitSharedTestEnvironment(tc tests.TestContext, envBytes []byte) {
+	require := require.New(tc)
 	require.Nil(env, "env already initialized")
 	env = &TestEnvironment{}
 	require.NoError(json.Unmarshal(envBytes, env))
+	env.testContext = tc
 
 	// Ginkgo parallelization is at the process level, so a given key
 	// can safely be used by all tests in a given process without fear
@@ -126,7 +127,7 @@ func NewTestEnvironment(tc tests.TestContext, flagVars *FlagVars, desiredNetwork
 
 		if len(networkDir) > 0 {
 			var err error
-			network, err = tmpnet.ReadNetwork(networkDir)
+			network, err = tmpnet.ReadNetwork(tc.DefaultContext(), tc.Log(), networkDir)
 			require.NoError(err)
 			tc.Log().Info("loaded a network",
 				zap.String("networkDir", networkDir),
@@ -153,7 +154,7 @@ func NewTestEnvironment(tc tests.TestContext, flagVars *FlagVars, desiredNetwork
 		}
 
 		if network != nil && networkCmd == RestartNetworkCmd {
-			require.NoError(network.Restart(tc.DefaultContext(), tc.Log()))
+			require.NoError(network.Restart(tc.DefaultContext()))
 		}
 	}
 
@@ -221,8 +222,9 @@ func (te *TestEnvironment) GetRandomNodeURI() tmpnet.NodeURI {
 
 // Retrieve the network to target for testing.
 func (te *TestEnvironment) GetNetwork() *tmpnet.Network {
-	network, err := tmpnet.ReadNetwork(te.NetworkDir)
-	require.NoError(te.testContext, err)
+	tc := te.testContext
+	network, err := tmpnet.ReadNetwork(tc.DefaultContext(), tc.Log(), te.NetworkDir)
+	require.NoError(tc, err)
 	return network
 }
 
@@ -233,14 +235,15 @@ func (te *TestEnvironment) NewKeychain() *secp256k1fx.Keychain {
 
 // Create a new private network that is not shared with other tests.
 func (te *TestEnvironment) StartPrivateNetwork(network *tmpnet.Network) {
-	require := require.New(te.testContext)
+	tc := te.testContext
+	require := require.New(tc)
 	// Use the same configuration as the shared network
-	sharedNetwork, err := tmpnet.ReadNetwork(te.NetworkDir)
+	sharedNetwork, err := tmpnet.ReadNetwork(tc.DefaultContext(), tc.Log(), te.NetworkDir)
 	require.NoError(err)
 	network.DefaultRuntimeConfig = sharedNetwork.DefaultRuntimeConfig
 
 	StartNetwork(
-		te.testContext,
+		tc,
 		network,
 		te.RootNetworkDir,
 		te.PrivateNetworkShutdownDelay,

tests/fixture/e2e/helpers.go

@@ -136,7 +136,7 @@ func NewEthClient(tc tests.TestContext, nodeURI tmpnet.NodeURI) ethclient.Client
 func AddEphemeralNode(tc tests.TestContext, network *tmpnet.Network, node *tmpnet.Node) *tmpnet.Node {
 	require := require.New(tc)
 
-	require.NoError(network.StartNode(tc.DefaultContext(), tc.Log(), node))
+	require.NoError(network.StartNode(tc.DefaultContext(), node))
 
 	tc.DeferCleanup(func() {
 		tc.Log().Info("shutting down ephemeral node",
@@ -150,11 +150,11 @@ func AddEphemeralNode(tc tests.TestContext, network *tmpnet.Network, node *tmpne
 }
 
 // Wait for the given node to report healthy.
-func WaitForHealthy(t require.TestingT, node *tmpnet.Node) {
+func WaitForHealthy(tc tests.TestContext, node *tmpnet.Node) {
 	// Need to use explicit context (vs DefaultContext()) to support use with DeferCleanup
 	ctx, cancel := context.WithTimeout(context.Background(), DefaultTimeout)
 	defer cancel()
-	require.NoError(t, tmpnet.WaitForHealthy(ctx, node))
+	require.NoError(tc, tmpnet.WaitForHealthyNode(ctx, tc.Log(), node))
 }
 
 // Sends an eth transaction and waits for the transaction receipt from the
@@ -236,7 +236,7 @@ func CheckBootstrapIsPossible(tc tests.TestContext, network *tmpnet.Network) *tm
 	}
 
 	node := tmpnet.NewEphemeralNode(flags)
-	require.NoError(network.StartNode(tc.DefaultContext(), tc.Log(), node))
+	require.NoError(network.StartNode(tc.DefaultContext(), node))
 	// StartNode will initiate node stop if an error is encountered during start,
 	// so no further cleanup effort is required if an error is seen here.
 
@@ -248,7 +248,7 @@ func CheckBootstrapIsPossible(tc tests.TestContext, network *tmpnet.Network) *tm
 	})
 
 	// Check that the node becomes healthy within timeout
-	require.NoError(tmpnet.WaitForHealthy(tc.DefaultContext(), node))
+	require.NoError(tmpnet.WaitForHealthyNode(tc.DefaultContext(), tc.Log(), node))
 
 	// Ensure that the primary validators are still healthy
 	for _, node := range network.Nodes {

tests/fixture/tmpnet/check_monitoring.go

@@ -13,6 +13,7 @@ import (
 	"math"
 	"net/http"
 	"net/url"
+	"os"
 	"strconv"
 	"strings"
 	"time"
@@ -271,16 +272,11 @@ func getSelectors(networkUUID string) (string, error) {
 
 	// Fall back to using Github labels as selectors
 	selectors := []string{}
-	githubLabels := githubLabelsFromEnv()
-	for label := range githubLabels {
-		value, err := githubLabels.GetStringVal(label)
-		if err != nil {
-			return "", err
+	for _, label := range githubLabels {
+		value := os.Getenv(strings.ToUpper(label))
+		if len(value) > 0 {
+			selectors = append(selectors, fmt.Sprintf(`%s="%s"`, label, value))
 		}
-		if len(value) == 0 {
-			continue
-		}
-		selectors = append(selectors, fmt.Sprintf(`%s="%s"`, label, value))
 	}
 	if len(selectors) == 0 {
 		return "", errors.New("no GH_* env vars set to use for selectors")

tests/fixture/tmpnet/defaults.go

@@ -35,8 +35,8 @@ const (
 	defaultConfigFilename = "config.json"
 )
 
-// Flags appropriate for networks used for all types of testing.
-func DefaultTestFlags() FlagsMap {
+// Flags suggested for temporary networks. Applied by default.
+func DefaultTmpnetFlags() FlagsMap {
 	return FlagsMap{
 		config.NetworkPeerListPullGossipFreqKey: "250ms",
 		config.NetworkMaxReconnectDelayKey:      "1s",
@@ -46,26 +46,14 @@ func DefaultTestFlags() FlagsMap {
 	}
 }
 
-// Flags appropriate for tmpnet networks.
-func DefaultTmpnetFlags() FlagsMap {
-	// Supply only non-default configuration to ensure that default values will be used.
-	flags := FlagsMap{
-		// Default to dynamic port allocation
-		config.HTTPPortKey:    "0",
-		config.StakingPortKey: "0",
-		// Specific to tmpnet deployment
-		config.PublicIPKey:        "127.0.0.1",
-		config.HTTPHostKey:        "127.0.0.1",
-		config.StakingHostKey:     "127.0.0.1",
-		config.LogDisplayLevelKey: logging.Off.String(), // Display logging not needed since nodes run headless
-		config.LogLevelKey:        logging.Debug.String(),
-		// Specific to e2e testing
+// Flags suggested for e2e testing
+func DefaultE2EFlags() FlagsMap {
+	return FlagsMap{
 		config.ProposerVMUseCurrentHeightKey: true,
 		// Reducing this from the 1s default speeds up tx acceptance
 		config.ProposerVMMinBlockDelayKey: "0s",
+		config.LogLevelKey:                logging.Debug.String(),
 	}
-	flags.SetDefaults(DefaultTestFlags())
-	return flags
 }
 
 // A set of chain configurations appropriate for testing.