test/proxy: Make sure proxy goroutine run as part of proxy test

Looks like proxy go routine also run for other test and since we are
not closing it properly it fails the complete test so in this PR, proxy
server have stop/start functionailty and test is also updated to start
the proxy server for specific test and stop it once test finish.

Author: praveenkumar

test/extended/util/proxy.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"time"
 
 	"github.com/elazarl/goproxy"
 	log "github.com/sirupsen/logrus"
@@ -45,26 +46,38 @@ func setCA() error {
 	return nil
 }
 
-func RunProxy() {
-
-	err := setCA()
-	if err != nil {
-		log.Fatalf("error setting up the CA: %s", err)
+// NewProxy creates and configures a new proxy server.
+// Returns the server, a cleanup function to close the log file, and any error.
+// The caller is responsible for:
+//   - Starting the server with go server.ListenAndServe()
+//   - Shutting it down with server.Shutdown()
+//   - Calling the cleanup function after shutdown to close the log file
+func NewProxy() (*http.Server, func(), error) {
+	if err := setCA(); err != nil {
+		return nil, nil, fmt.Errorf("error setting up the CA: %w", err)
 	}
 
 	// Create a DEDICATED logger for the proxy instead of using the global one
 	proxyLogger := log.New()
 
-	logfile := filepath.Join("out", "goproxylogfile.log")
-	f, err := os.OpenFile(logfile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
+	var logFile *os.File
+	logfilePath := filepath.Join("out", "goproxylogfile.log")
+	f, err := os.OpenFile(logfilePath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
 	if err != nil {
 		log.Printf("error opening file: %v", err)
 		proxyLogger.SetOutput(os.Stderr)
 	} else {
-		defer f.Close()
+		logFile = f
 		proxyLogger.SetOutput(f)
 	}
 
+	// Cleanup function to close log file
+	cleanup := func() {
+		if logFile != nil {
+			logFile.Close()
+		}
+	}
+
 	proxy := goproxy.NewProxyHttpServer()
 
 	// Log and handle all CONNECT requests (HTTPS tunnels)
@@ -94,10 +107,13 @@ func RunProxy() {
 	proxy.Verbose = true
 	proxy.Logger = proxyLogger
 
-	proxyLogger.Infof("Starting goproxy on %s", addr)
-
-	err = http.ListenAndServe(addr, proxy) // #nosec G114
-	if err != nil {
-		proxyLogger.Errorf("error running proxy: %s", err)
+	server := &http.Server{
+		Addr:              addr,
+		Handler:           proxy,
+		ReadHeaderTimeout: 10 * time.Second,
 	}
+
+	proxyLogger.Infof("Proxy server configured on %s", addr)
+
+	return server, cleanup, nil
 }

test/integration/proxy_test.go

@@ -1,9 +1,12 @@
 package test_test
 
 import (
+	"context"
 	"net"
+	"net/http"
 	"os"
 	"os/exec"
+	"time"
 
 	"github.com/crc-org/crc/v2/pkg/crc/adminhelper"
 	crc "github.com/crc-org/crc/v2/test/extended/crc/cmd"
@@ -14,6 +17,42 @@ import (
 
 var _ = Describe("", Serial, Ordered, Label("openshift-preset", "goproxy"), func() {
 
+	var proxyServer *http.Server
+	var proxyCleanup func()
+
+	// Start proxy server before any tests run
+	BeforeAll(func() {
+		// Create proxy server - errors are caught here in the main goroutine
+		var err error
+		proxyServer, proxyCleanup, err = util.NewProxy()
+		Expect(err).NotTo(HaveOccurred())
+
+		ln, err := net.Listen("tcp", "127.0.0.1:8888")
+		Expect(err).NotTo(HaveOccurred())
+
+		errChan := make(chan error, 1)
+
+		go func() {
+			if err := proxyServer.Serve(ln); err != nil && err != http.ErrServerClosed {
+				errChan <- err
+			}
+		}()
+
+		// Wait for proxy to be ready
+		Eventually(func() error {
+			select {
+			case err := <-errChan:
+				return err
+			default:
+			}
+			conn, err := net.Dial("tcp", "127.0.0.1:8888")
+			if err == nil {
+				conn.Close()
+			}
+			return err
+		}).Should(Succeed())
+	})
+
 	// runs 1x after all the It blocks (specs) inside this Describe node
 	AfterAll(func() {
 
@@ -32,16 +71,19 @@ var _ = Describe("", Serial, Ordered, Label("openshift-preset", "goproxy"), func
 		err = os.Unsetenv("HTTP_PROXY")
 		Expect(err).NotTo(HaveOccurred())
 
-	})
+		// Stop the proxy server
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		if proxyServer != nil {
+			err = proxyServer.Shutdown(ctx)
+			Expect(err).NotTo(HaveOccurred())
+		}
 
-	go util.RunProxy()
-	Eventually(func() error {
-		conn, err := net.Dial("tcp", "127.0.0.1:8888")
-		if err == nil {
-			conn.Close()
+		// Close the log file
+		if proxyCleanup != nil {
+			proxyCleanup()
 		}
-		return err
-	}).Should(Succeed())
+	})
 
 	Describe("Behind proxy", Serial, Ordered, func() {