Refactor Besu

Author: Ilan

framework/components/blockchain/anvil.go

@@ -25,7 +25,7 @@ func defaultAnvil(in *Input) {
 // newAnvil deploy foundry anvil node
 func newAnvil(in *Input) (*Output, error) {
 	defaultAnvil(in)
-	req := baseRequest(in)
+	req := baseRequest(in, false)
 
 	req.Image = in.Image
 	req.AlwaysPullImage = in.PullImage
@@ -38,5 +38,5 @@ func newAnvil(in *Input) (*Output, error) {
 
 	framework.L.Info().Any("Cmd", strings.Join(entryPoint, " ")).Msg("Creating anvil with command")
 
-	return createGenericEvmContainer(in, req)
+	return createGenericEvmContainer(in, req, false)
 }

framework/components/blockchain/anvil_zksync.go

@@ -43,7 +43,7 @@ RUN curl -L https://raw.githubusercontent.com/matter-labs/foundry-zksync/main/in
 // see: https://foundry-book.zksync.io/getting-started/installation#using-foundry-with-docker
 func newAnvilZksync(in *Input) (*Output, error) {
 	defaultAnvilZksync(in)
-	req := baseRequest(in)
+	req := baseRequest(in, false)
 
 	tempDir, err := os.MkdirTemp(".", "anvil-zksync-dockercontext")
 	if err != nil {
@@ -76,7 +76,7 @@ func newAnvilZksync(in *Input) (*Output, error) {
 
 	framework.L.Info().Any("Cmd", strings.Join(req.Entrypoint, " ")).Msg("Creating anvil zkSync with command")
 
-	output, err := createGenericEvmContainer(in, req)
+	output, err := createGenericEvmContainer(in, req, false)
 	if err != nil {
 		return nil, err
 	}

framework/components/blockchain/besu.go

@@ -1,19 +1,5 @@
 package blockchain
 
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/docker/docker/api/types/container"
-
-	"github.com/smartcontractkit/chainlink-testing-framework/framework"
-
-	"github.com/docker/go-connections/nat"
-	"github.com/testcontainers/testcontainers-go"
-	"github.com/testcontainers/testcontainers-go/wait"
-)
-
 const (
 	DefaultBesuPrivateKey1 = "8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63"
 	DefaultBesuPrivateKey2 = "c87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3"
@@ -37,7 +23,11 @@ func defaultBesu(in *Input) {
 
 func newBesu(in *Input) (*Output, error) {
 	defaultBesu(in)
-	ctx := context.Background()
+	req := baseRequest(in, true)
+
+	req.Image = in.Image
+	req.AlwaysPullImage = in.PullImage
+
 	defaultCmd := []string{
 		"--network=dev",
 		"--miner-enabled",
@@ -53,64 +43,7 @@ func newBesu(in *Input) (*Output, error) {
 		"--data-path=/tmp/tmpDatdir",
 	}
 	entryPoint := append(defaultCmd, in.DockerCmdParamsOverrides...)
+	req.Cmd = entryPoint
 
-	containerName := framework.DefaultTCName("blockchain-node")
-	bindPort := fmt.Sprintf("%s/tcp", in.Port)
-	bindPortWs := fmt.Sprintf("%s/tcp", in.WSPort)
-
-	req := testcontainers.ContainerRequest{
-		AlwaysPullImage: in.PullImage,
-		Image:           in.Image,
-		Name:            containerName,
-		ExposedPorts:    []string{bindPort, bindPortWs},
-		Networks:        []string{framework.DefaultNetworkName},
-		NetworkAliases: map[string][]string{
-			framework.DefaultNetworkName: {containerName},
-		},
-		Labels: framework.DefaultTCLabels(),
-		HostConfigModifier: func(h *container.HostConfig) {
-			h.PortBindings = framework.MapTheSamePort(bindPortWs, bindPort)
-			framework.ResourceLimitsFunc(h, in.ContainerResources)
-		},
-		WaitingFor: wait.ForListeningPort(nat.Port(in.Port)).WithStartupTimeout(15 * time.Second).WithPollInterval(200 * time.Millisecond),
-		Cmd:        entryPoint,
-	}
-
-	c, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
-		ContainerRequest: req,
-		Started:          true,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	host, err := c.Host(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	mp, err := c.MappedPort(ctx, nat.Port(bindPort))
-	if err != nil {
-		return nil, err
-	}
-	mpWs, err := c.MappedPort(ctx, nat.Port(bindPortWs))
-	if err != nil {
-		return nil, err
-	}
-
-	return &Output{
-		UseCache:      true,
-		ChainID:       in.ChainID,
-		Family:        "evm",
-		ContainerName: containerName,
-		Container:     c,
-		Nodes: []*Node{
-			{
-				HostHTTPUrl:           fmt.Sprintf("http://%s:%s", host, mp.Port()),
-				HostWSUrl:             fmt.Sprintf("ws://%s:%s", host, mpWs.Port()),
-				DockerInternalHTTPUrl: fmt.Sprintf("http://%s:%s", containerName, in.Port),
-				DockerInternalWSUrl:   fmt.Sprintf("ws://%s:%s", containerName, in.WSPort),
-			},
-		},
-	}, nil
+	return createGenericEvmContainer(in, req, true)
 }

framework/components/blockchain/blockchain_test.go

@@ -36,6 +36,15 @@ func TestChains(t *testing.T) {
 				ChainID: "260",
 			},
 		},
+		{
+			name: "Besu",
+			input: &blockchain.Input{
+				Type:    "besu",
+				Port:    "8111",
+				WSPort:  "8112",
+				ChainID: "1337",
+			},
+		},
 	}
 
 	for _, tc := range testCases {
@@ -53,6 +62,7 @@ func testChain(t *testing.T, input *blockchain.Input) {
 	require.NoError(t, err)
 
 	rpcUrl := output.Nodes[0].HostHTTPUrl
+	t.Logf("Testing RPC: %s", rpcUrl)
 	reqBody := `{"jsonrpc": "2.0", "method": "eth_chainId", "params": [], "id": 1}`
 	resp, err := http.Post(rpcUrl, "application/json", strings.NewReader(reqBody)) // nolint:gosec
 	require.NoError(t, err)

framework/components/blockchain/containers.go

@@ -13,29 +13,32 @@ import (
 	"github.com/smartcontractkit/chainlink-testing-framework/framework"
 )
 
-func baseRequest(in *Input) testcontainers.ContainerRequest {
+func baseRequest(in *Input, useWS bool) testcontainers.ContainerRequest {
 	containerName := framework.DefaultTCName("blockchain-node")
 	bindPort := fmt.Sprintf("%s/tcp", in.Port)
+	exposedPorts := []string{bindPort}
+	if useWS {
+		exposedPorts = append(exposedPorts, fmt.Sprintf("%s/tcp", in.WSPort))
+	}
 
 	return testcontainers.ContainerRequest{
-		Labels:       framework.DefaultTCLabels(),
-		Name:         containerName,
-		ExposedPorts: []string{bindPort},
-		HostConfigModifier: func(h *container.HostConfig) {
-			h.PortBindings = framework.MapTheSamePort(bindPort)
-			framework.ResourceLimitsFunc(h, in.ContainerResources)
-		},
+		Name:     containerName,
+		Labels:   framework.DefaultTCLabels(),
 		Networks: []string{framework.DefaultNetworkName},
 		NetworkAliases: map[string][]string{
 			framework.DefaultNetworkName: {containerName},
 		},
-		WaitingFor: wait.ForListeningPort(nat.Port(in.Port)).WithStartupTimeout(10 * time.Second).WithPollInterval(200 * time.Millisecond),
+		ExposedPorts: exposedPorts,
+		HostConfigModifier: func(h *container.HostConfig) {
+			h.PortBindings = framework.MapTheSamePort(exposedPorts...)
+			framework.ResourceLimitsFunc(h, in.ContainerResources)
+		},
+		WaitingFor: wait.ForListeningPort(nat.Port(in.Port)).WithStartupTimeout(15 * time.Second).WithPollInterval(200 * time.Millisecond),
 	}
 }
 
-func createGenericEvmContainer(in *Input, req testcontainers.ContainerRequest) (*Output, error) {
+func createGenericEvmContainer(in *Input, req testcontainers.ContainerRequest, useWS bool) (*Output, error) {
 	ctx := context.Background()
-
 	c, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
 		ContainerRequest: req,
 		Started:          true,
@@ -57,7 +60,7 @@ func createGenericEvmContainer(in *Input, req testcontainers.ContainerRequest) (
 
 	containerName := req.Name
 
-	return &Output{
+	output := Output{
 		UseCache:      true,
 		Family:        "evm",
 		ChainID:       in.ChainID,
@@ -71,5 +74,15 @@ func createGenericEvmContainer(in *Input, req testcontainers.ContainerRequest) (
 				DockerInternalHTTPUrl: fmt.Sprintf("http://%s:%s", containerName, in.Port),
 			},
 		},
-	}, nil
+	}
+
+	if useWS {
+		mp, err := c.MappedPort(ctx, nat.Port(req.ExposedPorts[1]))
+		if err != nil {
+			return nil, err
+		}
+		output.Nodes[0].HostWSUrl = fmt.Sprintf("ws://%s:%s", host, mp.Port())
+	}
+
+	return &output, nil
 }