chore(grafana): use Run function (#3412)

* chore(grafana): use Run function

* chore: add test for endpoints

Author: mdelapenya

modules/grafana-lgtm/grafana.go

@@ -3,6 +3,7 @@ package grafanalgtm
 import (
 	"context"
 	"fmt"
+	"time"
 
 	"github.com/testcontainers/testcontainers-go"
 	"github.com/testcontainers/testcontainers-go/log"
@@ -25,30 +26,30 @@ type GrafanaLGTMContainer struct {
 
 // Run creates an instance of the Grafana LGTM container type
 func Run(ctx context.Context, img string, opts ...testcontainers.ContainerCustomizer) (*GrafanaLGTMContainer, error) {
-	req := testcontainers.ContainerRequest{
-		Image:        img,
-		ExposedPorts: []string{GrafanaPort, LokiPort, TempoPort, OtlpGrpcPort, OtlpHttpPort, PrometheusPort},
-		WaitingFor:   wait.ForLog(".*The OpenTelemetry collector and the Grafana LGTM stack are up and running.*\\s").AsRegexp().WithOccurrence(1),
+	moduleOpts := []testcontainers.ContainerCustomizer{
+		testcontainers.WithExposedPorts(GrafanaPort, LokiPort, TempoPort, OtlpGrpcPort, OtlpHttpPort, PrometheusPort),
+		testcontainers.WithWaitStrategyAndDeadline(2*time.Minute,
+			wait.ForLog(".*The OpenTelemetry collector and the Grafana LGTM stack are up and running.*\\s").AsRegexp().WithOccurrence(1),
+			wait.ForListeningPort(GrafanaPort),
+			wait.ForListeningPort(LokiPort),
+			wait.ForListeningPort(TempoPort),
+			wait.ForListeningPort(OtlpGrpcPort),
+			wait.ForListeningPort(OtlpHttpPort),
+			wait.ForListeningPort(PrometheusPort),
+		),
+	}
+
+	moduleOpts = append(moduleOpts, opts...)
+
+	var c *GrafanaLGTMContainer
+	ctr, err := testcontainers.Run(ctx, img, moduleOpts...)
+	if ctr != nil {
+		c = &GrafanaLGTMContainer{Container: ctr}
 	}
-
-	genericContainerReq := testcontainers.GenericContainerRequest{
-		ContainerRequest: req,
-		Started:          true,
-	}
-
-	for _, opt := range opts {
-		if err := opt.Customize(&genericContainerReq); err != nil {
-			return nil, fmt.Errorf("customize: %w", err)
-		}
-	}
-
-	container, err := testcontainers.GenericContainer(ctx, genericContainerReq)
 	if err != nil {
-		return nil, fmt.Errorf("generic container: %w", err)
+		return nil, fmt.Errorf("run grafana lgtm: %w", err)
 	}
 
-	c := &GrafanaLGTMContainer{Container: container}
-
 	url, err := c.OtlpHttpEndpoint(ctx)
 	if err != nil {
 		// return the container instance to allow the caller to clean up

modules/grafana-lgtm/grafana_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"net"
 	"net/http"
 	"net/url"
 	"testing"
@@ -23,7 +24,7 @@ func TestGrafanaLGTM(t *testing.T) {
 
 	// perform assertions
 
-	t.Run("container is running with right version", func(t *testing.T) {
+	t.Run("right-version", func(t *testing.T) {
 		healthURL, err := url.Parse(fmt.Sprintf("http://%s/api/health", grafanaLgtmContainer.MustHttpEndpoint(ctx)))
 		require.NoError(t, err)
 
@@ -46,4 +47,53 @@ func TestGrafanaLGTM(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, "11.0.0", body["version"])
 	})
+
+	availableURL := func(t *testing.T, url string) {
+		t.Helper()
+
+		conn, err := net.Dial("tcp", url)
+		defer func() {
+			if conn != nil {
+				err := conn.Close()
+				require.NoError(t, err)
+			}
+		}()
+		require.NoError(t, err)
+	}
+
+	t.Run("loki-endpoint", func(t *testing.T) {
+		lokiEndpoint := grafanaLgtmContainer.MustLokiEndpoint(ctx)
+		require.NotEmpty(t, lokiEndpoint)
+		availableURL(t, lokiEndpoint)
+	})
+
+	t.Run("tempo-endpoint", func(t *testing.T) {
+		tempoEndpoint := grafanaLgtmContainer.MustTempoEndpoint(ctx)
+		require.NotEmpty(t, tempoEndpoint)
+		availableURL(t, tempoEndpoint)
+	})
+
+	t.Run("otlp-http-endpoint", func(t *testing.T) {
+		otlpHTTPEndpoint := grafanaLgtmContainer.MustOtlpHttpEndpoint(ctx)
+		require.NotEmpty(t, otlpHTTPEndpoint)
+		availableURL(t, otlpHTTPEndpoint)
+	})
+
+	t.Run("otlp-grpc-endpoint", func(t *testing.T) {
+		otlpGrpcEndpoint := grafanaLgtmContainer.MustOtlpGrpcEndpoint(ctx)
+		require.NotEmpty(t, otlpGrpcEndpoint)
+		availableURL(t, otlpGrpcEndpoint)
+	})
+
+	t.Run("prometheus-http-endpoint", func(t *testing.T) {
+		prometheusHTTPEndpoint := grafanaLgtmContainer.MustPrometheusHttpEndpoint(ctx)
+		require.NotEmpty(t, prometheusHTTPEndpoint)
+		availableURL(t, prometheusHTTPEndpoint)
+	})
+
+	t.Run("grafana-endpoint", func(t *testing.T) {
+		grafanaEndpoint := grafanaLgtmContainer.MustHttpEndpoint(ctx)
+		require.NotEmpty(t, grafanaEndpoint)
+		availableURL(t, grafanaEndpoint)
+	})
 }