Adding logging to functional tests

tests/framework/generate_manifests.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"text/template"
 
+	. "github.com/onsi/ginkgo/v2"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/util/yaml"
 	"sigs.k8s.io/controller-runtime/pkg/client"
@@ -221,6 +222,7 @@ func GenerateScaleListenerObjects(numListeners int, tls bool) (ScaleObjects, err
 }
 
 func generateSecrets(secrets []string) ([]client.Object, error) {
+	GinkgoWriter.Printf("Generating secrets\n")
 	objects := make([]client.Object, 0, len(secrets))
 
 	for _, secret := range secrets {
@@ -237,6 +239,7 @@ func generateSecrets(secrets []string) ([]client.Object, error) {
 
 		objects = append(objects, objs...)
 	}
+	GinkgoWriter.Printf("Generated %d secrets\n", len(objects))
 
 	return objects, nil
 }

tests/framework/logging.go

@@ -0,0 +1,13 @@
+package framework
+
+type Option func(*Options)
+
+type Options struct {
+	logEnabled bool
+}
+
+func WithLoggingDisabled() Option {
+	return func(opts *Options) {
+		opts.logEnabled = false
+	}
+}

tests/framework/ngf.go

@@ -41,27 +41,35 @@ type InstallationConfig struct {
 // InstallGatewayAPI installs the specified version of the Gateway API resources.
 func InstallGatewayAPI(apiVersion string) ([]byte, error) {
 	apiPath := fmt.Sprintf("%s/v%s/standard-install.yaml", gwInstallBasePath, apiVersion)
+	GinkgoWriter.Printf("Installing Gateway API version %q at API path %q\n", apiVersion, apiPath)
 
 	cmd := exec.CommandContext(
 		context.Background(),
 		"kubectl", "apply", "-f", apiPath,
 	)
 	output, err := cmd.CombinedOutput()
 	if err != nil {
+		GinkgoWriter.Printf("Error installing Gateway API version %q: %v\n", apiVersion, err)
+
 		return output, err
 	}
+	GinkgoWriter.Printf("Successfully installed Gateway API version %q\n", apiVersion)
 
 	return nil, nil
 }
 
 // UninstallGatewayAPI uninstalls the specified version of the Gateway API resources.
 func UninstallGatewayAPI(apiVersion string) ([]byte, error) {
 	apiPath := fmt.Sprintf("%s/v%s/standard-install.yaml", gwInstallBasePath, apiVersion)
+	GinkgoWriter.Printf("Uninstalling Gateway API version %q at API path %q\n", apiVersion, apiPath)
 
 	output, err := exec.CommandContext(context.Background(), "kubectl", "delete", "-f", apiPath).CombinedOutput()
 	if err != nil && !strings.Contains(string(output), "not found") {
+		GinkgoWriter.Printf("Error uninstalling Gateway API version %q: %v\n", apiVersion, err)
+
 		return output, err
 	}
+	GinkgoWriter.Printf("Successfully uninstalled Gateway API version %q\n", apiVersion)
 
 	return nil, nil
 }
@@ -94,9 +102,14 @@ func InstallNGF(cfg InstallationConfig, extraArgs ...string) ([]byte, error) {
 
 // CreateLicenseSecret creates the NGINX Plus JWT secret.
 func CreateLicenseSecret(k8sClient client.Client, namespace, filename string) error {
+	GinkgoWriter.Printf("Creating NGINX Plus license secret in namespace %q from file %q\n", namespace, filename)
+
 	conf, err := os.ReadFile(filename)
 	if err != nil {
-		return fmt.Errorf("error reading file %q: %w", filename, err)
+		readFileErr := fmt.Errorf("error reading file %q: %w", filename, err)
+		GinkgoWriter.Printf("%v\n", readFileErr)
+
+		return readFileErr
 	}
 
 	ctx, cancel := context.WithTimeout(context.Background(), DefaultTimeoutConfig().CreateTimeout)
@@ -109,7 +122,10 @@ func CreateLicenseSecret(k8sClient client.Client, namespace, filename string) er
 	}
 
 	if err := k8sClient.Create(ctx, ns); err != nil && !apierrors.IsAlreadyExists(err) {
-		return fmt.Errorf("error creating namespace: %w", err)
+		createNSErr := fmt.Errorf("error creating namespace: %w", err)
+		GinkgoWriter.Printf("%v\n", createNSErr)
+
+		return createNSErr
 	}
 
 	secret := &core.Secret{
@@ -123,7 +139,10 @@ func CreateLicenseSecret(k8sClient client.Client, namespace, filename string) er
 	}
 
 	if err := k8sClient.Create(ctx, secret); err != nil && !apierrors.IsAlreadyExists(err) {
-		return fmt.Errorf("error creating secret: %w", err)
+		createSecretErr := fmt.Errorf("error creating secret: %w", err)
+		GinkgoWriter.Printf("%v\n", createSecretErr)
+
+		return createSecretErr
 	}
 
 	return nil
@@ -170,6 +189,7 @@ func UninstallNGF(cfg InstallationConfig, k8sClient client.Client) ([]byte, erro
 	args := []string{
 		"uninstall", cfg.ReleaseName, "--namespace", cfg.Namespace,
 	}
+	GinkgoWriter.Printf("Uninstalling NGF with command: helm %v\n", strings.Join(args, " "))
 
 	output, err := exec.CommandContext(context.Background(), "helm", args...).CombinedOutput()
 	if err != nil && !strings.Contains(string(output), "release: not found") {
@@ -204,6 +224,7 @@ func UninstallNGF(cfg InstallationConfig, k8sClient client.Client) ([]byte, erro
 func setTelemetryArgs(cfg InstallationConfig) []string {
 	var args []string
 
+	GinkgoWriter.Printf("Setting telemetry to %v\n", cfg.Telemetry)
 	if cfg.Telemetry {
 		args = append(args, formatValueSet("nginxGateway.productTelemetry.enable", "true")...)
 	} else {

tests/framework/portforward.go

@@ -11,6 +11,7 @@ import (
 	"sync"
 	"time"
 
+	. "github.com/onsi/ginkgo/v2"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/portforward"
 	"k8s.io/client-go/transport/spdy"
@@ -20,12 +21,18 @@ import (
 func PortForward(config *rest.Config, namespace, podName string, ports []string, stopCh <-chan struct{}) error {
 	roundTripper, upgrader, err := spdy.RoundTripperFor(config)
 	if err != nil {
-		return fmt.Errorf("error creating roundtripper: %w", err)
+		roundTripperErr := fmt.Errorf("error creating roundtripper: %w", err)
+		GinkgoWriter.Printf("%v\n", roundTripperErr)
+
+		return roundTripperErr
 	}
 
 	serverURL, err := url.Parse(config.Host)
 	if err != nil {
-		return fmt.Errorf("error parsing rest config host: %w", err)
+		parseConfigErr := fmt.Errorf("error parsing rest config host: %w", err)
+		GinkgoWriter.Printf("%v\n", parseConfigErr)
+
+		return parseConfigErr
 	}
 
 	serverURL.Path = path.Join(
@@ -35,14 +42,24 @@ func PortForward(config *rest.Config, namespace, podName string, ports []string,
 		"portforward",
 	)
 
+	GinkgoWriter.Printf("Creating new dialer for serverURL: %q\n", serverURL)
 	dialer := spdy.NewDialer(upgrader, &http.Client{Transport: roundTripper}, http.MethodPost, serverURL)
 
 	forward := func() error {
 		readyCh := make(chan struct{}, 1)
 
+		GinkgoWriter.Printf(
+			"Starting port-forward to pod %q in namespace %q for ports %v\n",
+			podName,
+			namespace,
+			ports,
+		)
 		forwarder, err := portforward.New(dialer, ports, stopCh, readyCh, newSafeBuffer(), newSafeBuffer())
 		if err != nil {
-			return fmt.Errorf("error creating port forwarder: %w", err)
+			createPortForwardErr := fmt.Errorf("error creating port forwarder: %w", err)
+			GinkgoWriter.Printf("%v\n", createPortForwardErr)
+
+			return createPortForwardErr
 		}
 
 		return forwarder.ForwardPorts()

tests/framework/prometheus.go

@@ -456,9 +456,9 @@ func CreateEndTimeFinder(
 }
 
 // CreateResponseChecker returns a function that checks if there is a successful response from a url.
-func CreateResponseChecker(url, address string, requestTimeout time.Duration) func() error {
+func CreateResponseChecker(url, address string, requestTimeout time.Duration, opts ...Option) func() error {
 	return func() error {
-		status, _, err := Get(url, address, requestTimeout, nil, nil)
+		status, _, err := Get(url, address, requestTimeout, nil, nil, opts...)
 		if err != nil {
 			return fmt.Errorf("bad response: %w", err)
 		}

tests/framework/request.go

@@ -11,6 +11,8 @@ import (
 	"net/http"
 	"strings"
 	"time"
+
+	. "github.com/onsi/ginkgo/v2"
 )
 
 // Get sends a GET request to the specified url.
@@ -20,18 +22,35 @@ func Get(
 	url, address string,
 	timeout time.Duration,
 	headers, queryParams map[string]string,
+	opts ...Option,
 ) (int, string, error) {
-	resp, err := makeRequest(http.MethodGet, url, address, nil, timeout, headers, queryParams)
+	options := &Options{logEnabled: true}
+	for _, opt := range opts {
+		opt(options)
+	}
+
+	resp, err := makeRequest(http.MethodGet, url, address, nil, timeout, headers, queryParams, opts...)
 	if err != nil {
+		if options.logEnabled {
+			GinkgoWriter.Printf(
+				"ERROR occurred during getting response, error: %s\nReturning status: 0, body: ''\n",
+				err,
+			)
+		}
+
 		return 0, "", err
 	}
 	defer resp.Body.Close()
 
 	body := new(bytes.Buffer)
 	_, err = body.ReadFrom(resp.Body)
 	if err != nil {
+		GinkgoWriter.Printf("ERROR in Body content: %v returning body: ''\n", err)
 		return resp.StatusCode, "", err
 	}
+	if options.logEnabled {
+		GinkgoWriter.Printf("Successfully received response and parsed body: %s\n", body.String())
+	}
 
 	return resp.StatusCode, body.String(), nil
 }
@@ -44,14 +63,20 @@ func Post(
 	timeout time.Duration,
 	headers, queryParams map[string]string,
 ) (*http.Response, error) {
-	return makeRequest(http.MethodPost, url, address, body, timeout, headers, queryParams)
+	response, err := makeRequest(http.MethodPost, url, address, body, timeout, headers, queryParams)
+	if err != nil {
+		GinkgoWriter.Printf("ERROR occurred during getting response, error: %s\n", err)
+	}
+
+	return response, err
 }
 
 func makeRequest(
 	method, url, address string,
 	body io.Reader,
 	timeout time.Duration,
 	headers, queryParams map[string]string,
+	opts ...Option,
 ) (*http.Response, error) {
 	dialer := &net.Dialer{}
 
@@ -74,6 +99,23 @@ func makeRequest(
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 
+	options := &Options{logEnabled: true}
+
+	for _, opt := range opts {
+		opt(options)
+	}
+	if options.logEnabled {
+		requestDetails := fmt.Sprintf(
+			"Method: %s, URL: %s, Address: %s, Headers: %v, QueryParams: %v\n",
+			strings.ToUpper(method),
+			url,
+			address,
+			headers,
+			queryParams,
+		)
+		GinkgoWriter.Printf("Sending request: %s", requestDetails)
+	}
+
 	req, err := http.NewRequestWithContext(ctx, method, url, body)
 	if err != nil {
 		return nil, err