test(e2e benchmark): refactors E2EThroughput

test/e2e/benchmark/benchmark.go

@@ -0,0 +1,82 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/celestiaorg/celestia-app/v2/test/e2e/testnet"
+)
+
+type BenchmarkTest struct {
+	*testnet.Testnet
+	manifest *Manifest
+}
+
+func NewBenchmarkTest(name string, manifest *Manifest) (*BenchmarkTest, error) {
+	// create a new testnet
+	testNet, err := testnet.New(name, seed,
+		testnet.GetGrafanaInfoFromEnvVar(), manifest.ChainID,
+		manifest.GetGenesisModifiers()...)
+	if err != nil {
+		return nil, err
+	}
+
+	testNet.SetConsensusParams(manifest.GetConsensusParams())
+	return &BenchmarkTest{Testnet: testNet, manifest: manifest}, nil
+}
+
+// SetupNodes creates genesis nodes and tx clients based on the manifest.
+// There will be manifest.Validators validators and manifest.TxClients tx clients.
+// Each tx client connects to one validator. If TxClients are fewer than Validators, some validators will not have a tx client.
+func (b *BenchmarkTest) SetupNodes() error {
+	testnet.NoError("failed to create genesis nodes",
+		b.CreateGenesisNodes(b.manifest.Validators,
+			b.manifest.CelestiaAppVersion, b.manifest.SelfDelegation,
+			b.manifest.UpgradeHeight, b.manifest.ValidatorResource))
+
+	// obtain the GRPC endpoints of the validators
+	gRPCEndpoints, err := b.RemoteGRPCEndpoints()
+	testnet.NoError("failed to get validators GRPC endpoints", err)
+	log.Println("validators GRPC endpoints", gRPCEndpoints)
+
+	// create tx clients and point them to the validators
+	log.Println("Creating tx clients")
+
+	err = b.CreateTxClients(b.manifest.TxClientVersion,
+		b.manifest.BlobSequences,
+		b.manifest.BlobSizes,
+		b.manifest.TxClientsResource, gRPCEndpoints)
+	testnet.NoError("failed to create tx clients", err)
+
+	// set up the testnet
+	log.Println("Setting up testnet")
+	testnet.NoError("failed to setup testnet", b.Setup(
+		testnet.WithPerPeerBandwidth(b.manifest.PerPeerBandwidth),
+		testnet.WithTimeoutPropose(b.manifest.TimeoutPropose),
+		testnet.WithTimeoutCommit(b.manifest.TimeoutCommit),
+		testnet.WithPrometheus(b.manifest.Prometheus),
+	))
+	return nil
+}
+
+// Run runs the benchmark test for the specified duration in the manifest.
+func (b *BenchmarkTest) Run() error {
+	log.Println("Starting testnet")
+	err := b.Start()
+	if err != nil {
+		return fmt.Errorf("failed to start testnet: %v", err)
+	}
+
+	// once the testnet is up, start tx clients
+	log.Println("Starting tx clients")
+	err = b.StartTxClients()
+	if err != nil {
+		return fmt.Errorf("failed to start tx clients: %v", err)
+	}
+
+	// wait some time for the tx clients to submit transactions
+	time.Sleep(b.manifest.TestDuration)
+
+	return nil
+}

test/e2e/testnet/manifest.go → test/e2e/benchmark/manifest.go

@@ -1,10 +1,11 @@
-package testnet
+package main
 
 import (
 	"time"
 
 	"github.com/celestiaorg/celestia-app/v2/app"
 	"github.com/celestiaorg/celestia-app/v2/app/encoding"
+	"github.com/celestiaorg/celestia-app/v2/test/e2e/testnet"
 	"github.com/celestiaorg/celestia-app/v2/test/util/genesis"
 	blobtypes "github.com/celestiaorg/celestia-app/v2/x/blob/types"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
@@ -26,9 +27,9 @@ type Manifest struct {
 	// TxClientVersion  a specific version of the txsim container image within celestiaorg repository on GitHub's Container Registry, i.e., https://github.com/celestiaorg/celestia-app/pkgs/container/txsim
 	TxClientVersion string
 	// Resource requirements for a validator node
-	ValidatorResource Resources
+	ValidatorResource testnet.Resources
 	// Resource requirements for a tx client
-	TxClientsResource Resources
+	TxClientsResource testnet.Resources
 
 	// tx client settings
 	// Number of blobs per sequence

test/e2e/benchmark/throughput.go

@@ -27,7 +27,7 @@ func E2EThroughput() error {
 
 	log.Println("=== RUN E2EThroughput", "version:", latestVersion)
 
-	manifest := testnet.Manifest{
+	manifest := Manifest{
 		ChainID:            "test-e2e-throughput",
 		Validators:         2,
 		ValidatorResource:  testnet.DefaultResources,
@@ -50,56 +50,23 @@ func E2EThroughput() error {
 		TestDuration:       30 * time.Second,
 		TxClients:          2,
 	}
-	// create a new testnet
-	testNet, err := testnet.New("E2EThroughput", seed,
-		testnet.GetGrafanaInfoFromEnvVar(), manifest.ChainID,
-		manifest.GetGenesisModifiers()...)
-	testnet.NoError("failed to create testnet", err)
 
-	testNet.SetConsensusParams(manifest.GetConsensusParams())
+	benchTest, err := NewBenchmarkTest("E2EThroughput", &manifest)
+	testnet.NoError("failed to create benchmark test", err)
+
 	defer func() {
 		log.Print("Cleaning up testnet")
-		testNet.Cleanup()
+		benchTest.Cleanup()
 	}()
 
-	testnet.NoError("failed to create genesis nodes",
-		testNet.CreateGenesisNodes(manifest.Validators,
-			manifest.CelestiaAppVersion, manifest.SelfDelegation,
-			manifest.UpgradeHeight, manifest.ValidatorResource))
-
-	// obtain the GRPC endpoints of the validators
-	gRPCEndpoints, err := testNet.RemoteGRPCEndpoints()
-	testnet.NoError("failed to get validators GRPC endpoints", err)
-	log.Println("validators GRPC endpoints", gRPCEndpoints)
-
-	// create tx clients and point them to the validators
-	log.Println("Creating tx clients")
-
-	err = testNet.CreateTxClients(manifest.TxClientVersion, manifest.BlobSequences,
-		manifest.BlobSizes,
-		manifest.TxClientsResource, gRPCEndpoints[:manifest.TxClients])
-	testnet.NoError("failed to create tx clients", err)
+	testnet.NoError("failed to setup nodes", benchTest.SetupNodes())
 
-	// start the testnet
-	log.Println("Setting up testnet")
-	testnet.NoError("failed to setup testnet", testNet.Setup(
-		testnet.WithPerPeerBandwidth(manifest.PerPeerBandwidth),
-		testnet.WithTimeoutPropose(manifest.TimeoutPropose),
-		testnet.WithTimeoutCommit(manifest.TimeoutCommit),
-		testnet.WithPrometheus(manifest.Prometheus),
-	))
-	log.Println("Starting testnet")
-	testnet.NoError("failed to start testnet", testNet.Start())
-
-	// once the testnet is up, start the tx clients
-	log.Println("Starting tx clients")
-	testnet.NoError("failed to start tx clients", testNet.StartTxClients())
-
-	// wait some time for the tx clients to submit transactions
-	time.Sleep(manifest.TestDuration)
+	testnet.NoError("failed to run the benchmark test", benchTest.Run())
 
+	// post test data collection and validation
 	log.Println("Reading blockchain")
-	blockchain, err := testnode.ReadBlockchain(context.Background(), testNet.Node(0).AddressRPC())
+	blockchain, err := testnode.ReadBlockchain(context.Background(),
+		benchTest.Node(0).AddressRPC())
 	testnet.NoError("failed to read blockchain", err)
 
 	totalTxs := 0
@@ -112,6 +79,7 @@ func E2EThroughput() error {
 	if totalTxs < 10 {
 		return fmt.Errorf("expected at least 10 transactions, got %d", totalTxs)
 	}
+
 	log.Println("--- PASS ✅: E2EThroughput")
 	return nil
 }