op-e2e: Extract init logic to a separate helper file.

Remove duplication for verboseGethNodes support

op-e2e/bridge_test.go

@@ -20,10 +20,7 @@ import (
 // TestERC20BridgeDeposits tests the the L1StandardBridge bridge ERC20
 // functionality.
 func TestERC20BridgeDeposits(t *testing.T) {
-	parallel(t)
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 
 	cfg := DefaultSystemConfig(t)
 

op-e2e/helper.go

+package op_e2e
+
+import (
+	"flag"
+	"os"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/log"
+)
+
+var enableParallelTesting bool = true
+
+// Init testing to enable test flags
+var _ = func() bool {
+	testing.Init()
+	return true
+}()
+
+var verboseGethNodes bool
+
+func init() {
+	flag.BoolVar(&verboseGethNodes, "gethlogs", true, "Enable logs on geth nodes")
+	flag.Parse()
+	if os.Getenv("OP_E2E_DISABLE_PARALLEL") == "true" {
+		enableParallelTesting = false
+	}
+}
+
+func InitParallel(t *testing.T) {
+	t.Helper()
+	if enableParallelTesting {
+		t.Parallel()
+	}
+	if !verboseGethNodes {
+		log.Root().SetHandler(log.DiscardHandler())
+	}
+}

op-e2e/migration_test.go

@@ -121,7 +121,7 @@ var hardcodedSlots = []storageSlot{
 }
 
 func TestMigration(t *testing.T) {
-	parallel(t)
+	InitParallel(t)
 	if !config.enabled {
 		t.Skipf("skipping migration tests")
 		return

op-e2e/op_geth_test.go

@@ -20,7 +20,7 @@ import (
 
 // TestMissingGasLimit tests that op-geth cannot build a block without gas limit while optimism is active in the chain config.
 func TestMissingGasLimit(t *testing.T) {
-	parallel(t)
+	InitParallel(t)
 	cfg := DefaultSystemConfig(t)
 	cfg.DeployConfig.FundDevAccounts = false
 	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
@@ -43,7 +43,7 @@ func TestMissingGasLimit(t *testing.T) {
 // TestInvalidDepositInFCU runs an invalid deposit through a FCU/GetPayload/NewPayload/FCU set of calls.
 // This tests that deposits must always allow the block to be built even if they are invalid.
 func TestInvalidDepositInFCU(t *testing.T) {
-	parallel(t)
+	InitParallel(t)
 	cfg := DefaultSystemConfig(t)
 	cfg.DeployConfig.FundDevAccounts = false
 	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
@@ -78,7 +78,7 @@ func TestInvalidDepositInFCU(t *testing.T) {
 }
 
 func TestPreregolith(t *testing.T) {
-	parallel(t)
+	InitParallel(t)
 	futureTimestamp := hexutil.Uint64(4)
 	tests := []struct {
 		name         string
@@ -90,6 +90,7 @@ func TestPreregolith(t *testing.T) {
 	for _, test := range tests {
 		test := test
 		t.Run("GasUsed_"+test.name, func(t *testing.T) {
+			InitParallel(t)
 			// Setup an L2 EE and create a client connection to the engine.
 			// We also need to setup a L1 Genesis to create the rollup genesis.
 			cfg := DefaultSystemConfig(t)
@@ -138,6 +139,7 @@ func TestPreregolith(t *testing.T) {
 		})
 
 		t.Run("DepositNonce_"+test.name, func(t *testing.T) {
+			InitParallel(t)
 			// Setup an L2 EE and create a client connection to the engine.
 			// We also need to setup a L1 Genesis to create the rollup genesis.
 			cfg := DefaultSystemConfig(t)
@@ -196,6 +198,7 @@ func TestPreregolith(t *testing.T) {
 		})
 
 		t.Run("UnusedGasConsumed_"+test.name, func(t *testing.T) {
+			InitParallel(t)
 			cfg := DefaultSystemConfig(t)
 			cfg.DeployConfig.L2GenesisRegolithTimeOffset = test.regolithTime
 
@@ -237,6 +240,7 @@ func TestPreregolith(t *testing.T) {
 		})
 
 		t.Run("AllowSystemTx_"+test.name, func(t *testing.T) {
+			InitParallel(t)
 			cfg := DefaultSystemConfig(t)
 			cfg.DeployConfig.L2GenesisRegolithTimeOffset = test.regolithTime
 
@@ -258,7 +262,7 @@ func TestPreregolith(t *testing.T) {
 }
 
 func TestRegolith(t *testing.T) {
-	parallel(t)
+	InitParallel(t)
 	tests := []struct {
 		name             string
 		regolithTime     hexutil.Uint64
@@ -273,6 +277,7 @@ func TestRegolith(t *testing.T) {
 	for _, test := range tests {
 		test := test
 		t.Run("GasUsedIsAccurate_"+test.name, func(t *testing.T) {
+			InitParallel(t)
 			// Setup an L2 EE and create a client connection to the engine.
 			// We also need to setup a L1 Genesis to create the rollup genesis.
 			cfg := DefaultSystemConfig(t)
@@ -324,6 +329,7 @@ func TestRegolith(t *testing.T) {
 		})
 
 		t.Run("DepositNonceCorrect_"+test.name, func(t *testing.T) {
+			InitParallel(t)
 			// Setup an L2 EE and create a client connection to the engine.
 			// We also need to setup a L1 Genesis to create the rollup genesis.
 			cfg := DefaultSystemConfig(t)
@@ -385,6 +391,7 @@ func TestRegolith(t *testing.T) {
 		})
 
 		t.Run("ReturnUnusedGasToPool_"+test.name, func(t *testing.T) {
+			InitParallel(t)
 			cfg := DefaultSystemConfig(t)
 			cfg.DeployConfig.L2GenesisRegolithTimeOffset = &test.regolithTime
 
@@ -427,6 +434,7 @@ func TestRegolith(t *testing.T) {
 		})
 
 		t.Run("RejectSystemTx_"+test.name, func(t *testing.T) {
+			InitParallel(t)
 			cfg := DefaultSystemConfig(t)
 			cfg.DeployConfig.L2GenesisRegolithTimeOffset = &test.regolithTime
 
@@ -448,6 +456,7 @@ func TestRegolith(t *testing.T) {
 		})
 
 		t.Run("IncludeGasRefunds_"+test.name, func(t *testing.T) {
+			InitParallel(t)
 			// Simple constructor that is prefixed to the actual contract code
 			// Results in the contract code being returned as the code for the new contract
 			deployPrefixSize := byte(16)

op-e2e/system_test.go

@@ -2,10 +2,8 @@ package op_e2e
 
 import (
 	"context"
-	"flag"
 	"fmt"
 	"math/big"
-	"os"
 	"testing"
 	"time"
 
@@ -41,36 +39,8 @@ import (
 	oppprof "github.com/ethereum-optimism/optimism/op-service/pprof"
 )
 
-var enableParallelTesting bool = true
-
-// Init testing to enable test flags
-var _ = func() bool {
-	testing.Init()
-	return true
-}()
-
-var verboseGethNodes bool
-
-func init() {
-	flag.BoolVar(&verboseGethNodes, "gethlogs", true, "Enable logs on geth nodes")
-	flag.Parse()
-	if os.Getenv("OP_E2E_DISABLE_PARALLEL") == "true" {
-		enableParallelTesting = false
-	}
-}
-
-func parallel(t *testing.T) {
-	t.Helper()
-	if enableParallelTesting {
-		t.Parallel()
-	}
-}
-
 func TestL2OutputSubmitter(t *testing.T) {
-	parallel(t)
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 
 	cfg := DefaultSystemConfig(t)
 	cfg.NonFinalizedProposals = true // speed up the time till we see output proposals
@@ -141,10 +111,7 @@ func TestL2OutputSubmitter(t *testing.T) {
 // TestSystemE2E sets up a L1 Geth node, a rollup node, and a L2 geth node and then confirms that L1 deposits are reflected on L2.
 // All nodes are run in process (but are the full nodes, not mocked or stubbed).
 func TestSystemE2E(t *testing.T) {
-	parallel(t)
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 
 	cfg := DefaultSystemConfig(t)
 
@@ -249,10 +216,7 @@ func TestSystemE2E(t *testing.T) {
 
 // TestConfirmationDepth runs the rollup with both sequencer and verifier not immediately processing the tip of the chain.
 func TestConfirmationDepth(t *testing.T) {
-	parallel(t)
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 
 	cfg := DefaultSystemConfig(t)
 	cfg.DeployConfig.SequencerWindowSize = 4
@@ -300,10 +264,7 @@ func TestConfirmationDepth(t *testing.T) {
 // TestPendingGasLimit tests the configuration of the gas limit of the pending block,
 // and if it does not conflict with the regular gas limit on the verifier or sequencer.
 func TestPendingGasLimit(t *testing.T) {
-	parallel(t)
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 
 	cfg := DefaultSystemConfig(t)
 
@@ -360,10 +321,7 @@ func TestPendingGasLimit(t *testing.T) {
 
 // TestFinalize tests if L2 finalizes after sufficient time after L1 finalizes
 func TestFinalize(t *testing.T) {
-	parallel(t)
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 
 	cfg := DefaultSystemConfig(t)
 
@@ -388,10 +346,7 @@ func TestFinalize(t *testing.T) {
 }
 
 func TestMintOnRevertedDeposit(t *testing.T) {
-	parallel(t)
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 	cfg := DefaultSystemConfig(t)
 
 	sys, err := cfg.Start()
@@ -462,10 +417,7 @@ func TestMintOnRevertedDeposit(t *testing.T) {
 }
 
 func TestMissingBatchE2E(t *testing.T) {
-	parallel(t)
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 	// Note this test zeroes the balance of the batch-submitter to make the batches unable to go into L1.
 	// The test logs may look scary, but this is expected:
 	// 'batcher unable to publish transaction    role=batcher   err="insufficient funds for gas * price + value"'
@@ -585,10 +537,7 @@ func L1InfoFromState(ctx context.Context, contract *bindings.L1Block, l2Number *
 // TestSystemMockP2P sets up a L1 Geth node, a rollup node, and a L2 geth node and then confirms that
 // the nodes can sync L2 blocks before they are confirmed on L1.
 func TestSystemMockP2P(t *testing.T) {
-	parallel(t)
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 
 	cfg := DefaultSystemConfig(t)
 	// Disable batcher, so we don't sync from L1 & set a large sequence window so we only have unsafe blocks
@@ -691,10 +640,7 @@ func TestSystemMockP2P(t *testing.T) {
 // 7. Wait for the verifier to sync the unsafe chain into the safe chain.
 // 8. Verify that the TX is included in the verifier's safe chain.
 func TestSystemRPCAltSync(t *testing.T) {
-	parallel(t)
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 
 	cfg := DefaultSystemConfig(t)
 	// the default is nil, but this may change in the future.
@@ -768,10 +714,7 @@ func TestSystemRPCAltSync(t *testing.T) {
 }
 
 func TestSystemP2PAltSync(t *testing.T) {
-	parallel(t)
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 
 	cfg := DefaultSystemConfig(t)
 
@@ -924,10 +867,7 @@ func TestSystemP2PAltSync(t *testing.T) {
 func TestSystemDenseTopology(t *testing.T) {
 	t.Skip("Skipping dense topology test to avoid flakiness. @refcell address in p2p scoring pr.")
 
-	parallel(t)
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 
 	cfg := DefaultSystemConfig(t)
 	// slow down L1 blocks so we can see the L2 blocks arrive well before the L1 blocks do.
@@ -1048,10 +988,7 @@ func TestSystemDenseTopology(t *testing.T) {
 }
 
 func TestL1InfoContract(t *testing.T) {
-	parallel(t)
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 
 	cfg := DefaultSystemConfig(t)
 
@@ -1176,10 +1113,7 @@ func calcL1GasUsed(data []byte, overhead *big.Int) *big.Int {
 // balance changes on L1 and L2 and has to include gas fees in the balance checks.
 // It does not check that the withdrawal can be executed prior to the end of the finality period.
 func TestWithdrawals(t *testing.T) {
-	parallel(t)
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 
 	cfg := DefaultSystemConfig(t)
 	cfg.DeployConfig.FinalizationPeriodSeconds = 2 // 2s finalization period
@@ -1380,10 +1314,7 @@ func TestWithdrawals(t *testing.T) {
 
 // TestFees checks that L1/L2 fees are handled.
 func TestFees(t *testing.T) {
-	parallel(t)
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 
 	cfg := DefaultSystemConfig(t)
 	// TODO: after we have the system config contract and new op-geth L1 cost utils,
@@ -1531,10 +1462,7 @@ func TestFees(t *testing.T) {
 }
 
 func TestStopStartSequencer(t *testing.T) {
-	parallel(t)
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 
 	cfg := DefaultSystemConfig(t)
 	sys, err := cfg.Start()
@@ -1575,10 +1503,7 @@ func TestStopStartSequencer(t *testing.T) {
 }
 
 func TestStopStartBatcher(t *testing.T) {
-	parallel(t)
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 
 	cfg := DefaultSystemConfig(t)
 	sys, err := cfg.Start()

op-e2e/system_tob_test.go

@@ -24,7 +24,6 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/ethclient/gethclient"
-	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rpc"
 	fuzz "github.com/google/gofuzz"
@@ -33,18 +32,13 @@ import (
 
 // TestGasPriceOracleFeeUpdates checks that the gas price oracle cannot be locked by mis-configuring parameters.
 func TestGasPriceOracleFeeUpdates(t *testing.T) {
-	parallel(t)
+	InitParallel(t)
 	// Define our values to set in the GasPriceOracle (we set them high to see if it can lock L2 or stop bindings
 	// from updating the prices once again.
 	overheadValue := abi.MaxUint256
 	scalarValue := abi.MaxUint256
 	var cancel context.CancelFunc
 
-	// Setup our logger handler
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
-
 	// Create our system configuration for L1/L2 and start it
 	cfg := DefaultSystemConfig(t)
 	sys, err := cfg.Start()
@@ -126,11 +120,7 @@ func TestGasPriceOracleFeeUpdates(t *testing.T) {
 // TestL2SequencerRPCDepositTx checks that the L2 sequencer will not accept DepositTx type transactions.
 // The acceptance of these transactions would allow for arbitrary minting of ETH in L2.
 func TestL2SequencerRPCDepositTx(t *testing.T) {
-	parallel(t)
-	// Setup our logger handler
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 
 	// Create our system configuration for L1/L2 and start it
 	cfg := DefaultSystemConfig(t)
@@ -233,7 +223,7 @@ func startConfigWithTestAccounts(cfg *SystemConfig, accountsToGenerate int) (*Sy
 // TestMixedDepositValidity makes a number of deposit transactions, some which will succeed in transferring value,
 // while others do not. It ensures that the expected nonces/balances match after several interactions.
 func TestMixedDepositValidity(t *testing.T) {
-	parallel(t)
+	InitParallel(t)
 	// Define how many deposit txs we'll make. Each deposit mints a fixed amount and transfers up to 1/3 of the user's
 	// balance. As such, this number cannot be too high or else the test will always fail due to lack of balance in L1.
 	const depositTxCount = 15
@@ -241,11 +231,6 @@ func TestMixedDepositValidity(t *testing.T) {
 	// Define how many accounts we'll use to deposit funds
 	const accountUsedToDeposit = 5
 
-	// Setup our logger handler
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
-
 	// Create our system configuration, funding all accounts we created for L1/L2, and start it
 	cfg := DefaultSystemConfig(t)
 	sys, testAccounts, err := startConfigWithTestAccounts(&cfg, accountUsedToDeposit)
@@ -415,17 +400,13 @@ func TestMixedDepositValidity(t *testing.T) {
 // TestMixedWithdrawalValidity makes a number of withdrawal transactions and ensures ones with modified parameters are
 // rejected while unmodified ones are accepted. This runs test cases in different systems.
 func TestMixedWithdrawalValidity(t *testing.T) {
-	parallel(t)
-	// Setup our logger handler
-	if !verboseGethNodes {
-		log.Root().SetHandler(log.DiscardHandler())
-	}
+	InitParallel(t)
 
 	// There are 7 different fields we try modifying to cause a failure, plus one "good" test result we test.
 	for i := 0; i <= 8; i++ {
 		i := i // avoid loop var capture
 		t.Run(fmt.Sprintf("withdrawal test#%d", i+1), func(t *testing.T) {
-			parallel(t)
+			InitParallel(t)
 
 			// Create our system configuration, funding all accounts we created for L1/L2, and start it
 			cfg := DefaultSystemConfig(t)