golangci-lint: fix noctx issues in tests

mstoykov · mstoykov · commit 0b41c90d8ba3 · 2025-10-07T16:30:46.000+03:00
diff --git a/internal/cmd/tests/grpc.go b/internal/cmd/tests/grpc.go
@@ -24,7 +24,7 @@ func NewGRPC(t testing.TB) *GRPC {
 
 	addr := getFreeBindAddr(t)
 
-	lis, err := net.Listen("tcp", addr)
+	lis, err := (&net.ListenConfig{}).Listen(t.Context(), "tcp", addr)
 	if err != nil {
 		t.Fatalf("failed to listen: %v", err)
 	}
diff --git a/internal/cmd/tests/test_state.go b/internal/cmd/tests/test_state.go
@@ -16,6 +16,7 @@ import (
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
 	"go.k6.io/k6/cmd/state"
 	"go.k6.io/k6/internal/event"
 	"go.k6.io/k6/internal/lib/testutils"
@@ -128,7 +129,7 @@ func getFreeBindAddr(tb testing.TB) string {
 		port := atomic.AddUint64(&portRangeStart, 1)
 		addr := net.JoinHostPort("localhost", strconv.FormatUint(port, 10))
 
-		listener, err := net.Listen("tcp", addr)
+		listener, err := (&net.ListenConfig{}).Listen(tb.Context(), "tcp", addr)
 		if err != nil {
 			continue // port was busy for some reason
 		}
diff --git a/internal/js/modules/k6/browser/browser/helpers.go b/internal/js/modules/k6/browser/browser/helpers.go
@@ -14,7 +14,7 @@ import (
 
 func panicIfFatalError(ctx context.Context, err error) {
 	if errors.Is(err, k6error.ErrFatal) {
-		k6ext.Abort(ctx, err.Error())
+		k6ext.Abortf(ctx, err.Error())
 	}
 }
 
diff --git a/internal/js/modules/k6/browser/browser/module.go b/internal/js/modules/k6/browser/browser/module.go
@@ -113,15 +113,15 @@ func (m *RootModule) initialize(vu k6modules.VU) {
 	)
 	m.remoteRegistry, err = newRemoteRegistry(initEnv.LookupEnv)
 	if err != nil {
-		k6ext.Abort(vu.Context(), "failed to create remote registry: %v", err)
+		k6ext.Abortf(vu.Context(), "failed to create remote registry: %v", err)
 	}
 	m.tracesMetadata, err = parseTracesMetadata(initEnv.LookupEnv)
 	if err != nil {
-		k6ext.Abort(vu.Context(), "parsing browser traces metadata: %v", err)
+		k6ext.Abortf(vu.Context(), "parsing browser traces metadata: %v", err)
 	}
 	m.filePersister, err = newScreenshotPersister(initEnv.LookupEnv)
 	if err != nil {
-		k6ext.Abort(vu.Context(), "failed to create file persister: %v", err)
+		k6ext.Abortf(vu.Context(), "failed to create file persister: %v", err)
 	}
 	if e, ok := initEnv.LookupEnv(env.K6TestRunID); ok && e != "" {
 		m.testRunID = e
diff --git a/internal/js/modules/k6/browser/browser/registry.go b/internal/js/modules/k6/browser/browser/registry.go
@@ -281,7 +281,7 @@ func (r *browserRegistry) handleIterEvents(
 
 		if data, ok = e.Data.(k6event.IterData); !ok {
 			e.Done()
-			k6ext.Abort(vuCtx, "unexpected iteration event data format: %v", e.Data)
+			k6ext.Abortf(vuCtx, "unexpected iteration event data format: %v", e.Data)
 			// Continue so we don't block the k6 event system producer.
 			// Test will be aborted by k6, which will previously send the
 			// 'Exit' event so browser resources cleanup can be guaranteed.
@@ -306,7 +306,7 @@ func (r *browserRegistry) handleIterEvents(
 			b, err := r.buildFn(ctx, tracedCtx)
 			if err != nil {
 				e.Done()
-				k6ext.Abort(vuCtx, "error building browser on IterStart: %v", err)
+				k6ext.Abortf(vuCtx, "error building browser on IterStart: %v", err)
 				// Continue so we don't block the k6 event system producer.
 				// Test will be aborted by k6, which will previously send the
 				// 'Exit' event so browser resources cleanup can be guaranteed.
diff --git a/internal/js/modules/k6/browser/common/browser.go b/internal/js/modules/k6/browser/common/browser.go
@@ -235,7 +235,7 @@ func (b *Browser) initEvents() error {
 				if ev, ok := event.data.(*target.EventAttachedToTarget); ok {
 					b.logger.Debugf("Browser:initEvents:onAttachedToTarget", "sid:%v tid:%v", ev.SessionID, ev.TargetInfo.TargetID)
 					if err := b.onAttachedToTarget(ev); err != nil {
-						k6ext.Panic(b.vuCtx, "browser is attaching to target: %w", err)
+						k6ext.Panicf(b.vuCtx, "browser is attaching to target: %w", err)
 					}
 				} else if ev, ok := event.data.(*target.EventDetachedFromTarget); ok {
 					b.logger.Debugf("Browser:initEvents:onDetachedFromTarget", "sid:%v", ev.SessionID)
diff --git a/internal/js/modules/k6/browser/common/frame_session.go b/internal/js/modules/k6/browser/common/frame_session.go
@@ -682,7 +682,7 @@ func (fs *FrameSession) onExecutionContextCreated(event *cdpruntime.EventExecuti
 		Type      string      `json:"type"`
 	}
 	if err := json.Unmarshal(auxData, &i); err != nil {
-		k6ext.Panic(fs.ctx, "unmarshaling executionContextCreated event JSON: %w", err)
+		k6ext.Panicf(fs.ctx, "unmarshaling executionContextCreated event JSON: %w", err)
 	}
 
 	frame, ok := fs.manager.getFrameByID(i.FrameID)
@@ -767,7 +767,7 @@ func (fs *FrameSession) onFrameDetached(frameID cdp.FrameID, reason cdppage.Fram
 		fs.session.ID(), fs.targetID, frameID, reason)
 
 	if err := fs.manager.frameDetached(frameID, reason); err != nil {
-		k6ext.Panic(fs.ctx, "handling frameDetached event: %w", err)
+		k6ext.Panicf(fs.ctx, "handling frameDetached event: %w", err)
 	}
 }
 
@@ -780,7 +780,7 @@ func (fs *FrameSession) onFrameNavigated(frame *cdp.Frame, initial bool) {
 		frame.ID, frame.ParentID, frame.LoaderID.String(),
 		frame.Name, frame.URL+frame.URLFragment, initial)
 	if err != nil {
-		k6ext.Panic(fs.ctx, "handling frameNavigated event to %q: %w",
+		k6ext.Panicf(fs.ctx, "handling frameNavigated event to %q: %w",
 			frame.URL+frame.URLFragment, err)
 	}
 
@@ -855,7 +855,7 @@ func (fs *FrameSession) onFrameRequestedNavigation(event *cdppage.EventFrameRequ
 	if event.Disposition == "currentTab" {
 		err := fs.manager.frameRequestedNavigation(event.FrameID, event.URL, "")
 		if err != nil {
-			k6ext.Panic(fs.ctx, "handling frameRequestedNavigation event to %q: %w", event.URL, err)
+			k6ext.Panicf(fs.ctx, "handling frameRequestedNavigation event to %q: %w", event.URL, err)
 		}
 	}
 }
@@ -995,7 +995,7 @@ func (fs *FrameSession) onAttachedToTarget(event *target.EventAttachedToTarget)
 			return // ignore
 		}
 		reason = "fatal"
-		k6ext.Panic(fs.ctx, "attaching %v: %w", ti.Type, err)
+		k6ext.Panicf(fs.ctx, "attaching %v: %w", ti.Type, err)
 	}
 }
 
@@ -1064,7 +1064,7 @@ func (fs *FrameSession) onTargetCrashed() {
 	// TODO:?
 	s, ok := fs.session.(*Session)
 	if !ok {
-		k6ext.Panic(fs.ctx, "unexpected type %T", fs.session)
+		k6ext.Panicf(fs.ctx, "unexpected type %T", fs.session)
 	}
 	s.markAsCrashed()
 }
diff --git a/internal/js/modules/k6/browser/common/helpers.go b/internal/js/modules/k6/browser/common/helpers.go
@@ -210,7 +210,7 @@ func createWaitForEventPredicateHandler(
 //nolint:unused
 func panicOrSlowMo(ctx context.Context, err error) {
 	if err != nil {
-		k6ext.Panic(ctx, "%w", err)
+		k6ext.Panicf(ctx, "%w", err)
 	}
 	applySlowMo(ctx)
 }
diff --git a/internal/js/modules/k6/browser/common/network_manager.go b/internal/js/modules/k6/browser/common/network_manager.go
@@ -1041,14 +1041,14 @@ func (m *NetworkManager) ThrottleNetwork(networkProfile NetworkProfile) error {
 func (m *NetworkManager) SetUserAgent(userAgent string) {
 	action := emulation.SetUserAgentOverride(userAgent)
 	if err := action.Do(cdp.WithExecutor(m.ctx, m.session)); err != nil {
-		k6ext.Panic(m.ctx, "setting user agent: %w", err)
+		k6ext.Panicf(m.ctx, "setting user agent: %w", err)
 	}
 }
 
 // SetCacheEnabled toggles cache on/off.
 func (m *NetworkManager) SetCacheEnabled(enabled bool) {
 	m.userCacheDisabled = !enabled
 	if err := m.updateProtocolCacheDisabled(); err != nil {
-		k6ext.Panic(m.ctx, "%v", err)
+		k6ext.Panicf(m.ctx, "%v", err)
 	}
 }
diff --git a/internal/js/modules/k6/browser/k6ext/panic.go b/internal/js/modules/k6/browser/k6ext/panic.go
@@ -14,23 +14,23 @@ import (
 	k6common "go.k6.io/k6/js/common"
 )
 
-// Abort will shutdown the whole test run. This should
+// Abortf will shutdown the whole test run. This should
 // only be used from the sobek mapping layer. It is only
 // to be used when an error will occur in all iterations,
 // so it's permanent.
-func Abort(ctx context.Context, format string, a ...any) {
+func Abortf(ctx context.Context, format string, a ...any) {
 	failFunc := func(rt *sobek.Runtime, a ...any) {
 		reason := fmt.Errorf(format, a...).Error()
 		rt.Interrupt(&errext.InterruptError{Reason: reason})
 	}
 	sharedPanic(ctx, failFunc, a...)
 }
 
-// Panic will cause a panic with the given error which will stop
+// Panicf will cause a panic with the given error which will stop
 // the current iteration. Before panicking, it will find the
 // browser process from the context and kill it if it still exists.
 // TODO: test.
-func Panic(ctx context.Context, format string, a ...any) {
+func Panicf(ctx context.Context, format string, a ...any) {
 	failFunc := func(rt *sobek.Runtime, a ...any) {
 		k6common.Throw(rt, fmt.Errorf(format, a...))
 	}
diff --git a/internal/js/modules/k6/browser/tests/browser_test.go b/internal/js/modules/k6/browser/tests/browser_test.go
@@ -282,7 +282,7 @@ func TestMultiBrowserPanic(t *testing.T) {
 
 		func() {
 			defer func() { _ = recover() }()
-			k6ext.Panic(b1.ctx, "forcing a panic")
+			k6ext.Panicf(b1.ctx, "forcing a panic")
 		}()
 	})
 
diff --git a/internal/js/runner_test.go b/internal/js/runner_test.go
@@ -865,7 +865,7 @@ func getTestServerWithCertificate(t *testing.T, certPem, key []byte) *httptest.S
 		},
 		ForceAttemptHTTP2: s.EnableHTTP2,
 	}
-	s.Listener, err = net.Listen("tcp", "")
+	s.Listener, err = (&net.ListenConfig{}).Listen(context.Background(), "tcp", "")
 	require.NoError(t, err)
 	s.Listener = tls.NewListener(s.Listener, s.TLS)
 	s.URL = "https://" + s.Listener.Addr().String()
diff --git a/internal/output/influxdb/output_test.go b/internal/output/influxdb/output_test.go
@@ -60,7 +60,7 @@ func testOutputCycle(t testing.TB, handler http.HandlerFunc, body func(testing.T
 		MaxHeaderBytes:    1 << 20,
 		ReadHeaderTimeout: time.Second,
 	}
-	l, err := net.Listen("tcp", "127.0.0.1:0")
+	l, err := (&net.ListenConfig{}).Listen(context.Background(), "tcp", "127.0.0.1:0")
 	require.NoError(t, err)
 	defer func() {
 		_ = l.Close()
diff --git a/internal/output/opentelemetry/output_test.go b/internal/output/opentelemetry/output_test.go
@@ -13,14 +13,15 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"go.k6.io/k6/internal/lib/testutils"
-	"go.k6.io/k6/metrics"
-	"go.k6.io/k6/output"
 	collectormetrics "go.opentelemetry.io/proto/otlp/collector/metrics/v1"
 	commonpb "go.opentelemetry.io/proto/otlp/common/v1"
 	metricpb "go.opentelemetry.io/proto/otlp/metrics/v1"
 	"google.golang.org/grpc"
 	"google.golang.org/protobuf/proto"
+
+	"go.k6.io/k6/internal/lib/testutils"
+	"go.k6.io/k6/metrics"
+	"go.k6.io/k6/output"
 )
 
 type MetricsServer interface {
@@ -82,7 +83,7 @@ type grpcMetricsServer struct {
 }
 
 func newGRPCServer() (*grpcMetricsServer, error) {
-	listener, err := net.Listen("tcp", "localhost:0")
+	listener, err := (&net.ListenConfig{}).Listen(context.Background(), "tcp", "localhost:0")
 	if err != nil {
 		return nil, fmt.Errorf("failed to create listener: %w", err)
 	}
diff --git a/js/modules/k6/http/request_test.go b/js/modules/k6/http/request_test.go
@@ -2373,7 +2373,7 @@ func GetTestServerWithCertificate(t *testing.T, certPem, key []byte, suitesIDs .
 		ResponseHeaderTimeout: time.Second,
 		IdleConnTimeout:       time.Second,
 	}
-	s.Listener, err = net.Listen("tcp", "")
+	s.Listener, err = (&net.ListenConfig{}).Listen(context.Background(), "tcp", "")
 	require.NoError(t, err)
 	s.Listener = tls.NewListener(s.Listener, s.TLS)
 	return s, client
diff --git a/lib/netext/httpext/error_codes_test.go b/lib/netext/httpext/error_codes_test.go
@@ -126,7 +126,7 @@ func testMapOfErrorCodes(t *testing.T, testTable map[errCode]error) {
 func TestConnReset(t *testing.T) {
 	t.Parallel()
 	// based on https://gist.github.com/jpittis/4357d817dc425ae99fbf719828ab1800
-	ln, err := net.Listen("tcp", "localhost:0")
+	ln, err := (&net.ListenConfig{}).Listen(context.Background(), "tcp", "localhost:0")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -261,7 +261,7 @@ func TestX509UnknownAuthorityError(t *testing.T) {
 func TestDefaultTLSError(t *testing.T) {
 	t.Parallel()
 
-	l, err := net.Listen("tcp", "127.0.0.1:0")
+	l, err := (&net.ListenConfig{}).Listen(context.Background(), "tcp", "127.0.0.1:0")
 	require.NoError(t, err)
 	go func() {
 		conn, err := l.Accept()
diff --git a/lib/netext/httpext/request_test.go b/lib/netext/httpext/request_test.go
@@ -18,10 +18,11 @@ import (
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"go.k6.io/k6/lib"
-	"go.k6.io/k6/metrics"
 	"golang.org/x/time/rate"
 	"gopkg.in/guregu/null.v3"
+
+	"go.k6.io/k6/lib"
+	"go.k6.io/k6/metrics"
 )
 
 type reader func([]byte) (int, error)
@@ -86,7 +87,7 @@ func TestMakeRequestError(t *testing.T) {
 
 	t.Run("bad compression algorithm body", func(t *testing.T) {
 		t.Parallel()
-		req, err := http.NewRequest(http.MethodGet, "https://wont.be.used", nil)
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://wont.be.used", nil)
 
 		require.NoError(t, err)
 		badCompressionType := CompressionType(13)
@@ -123,7 +124,7 @@ func TestMakeRequestError(t *testing.T) {
 			Logger:    logger,
 			Tags:      lib.NewVUStateTags(metrics.NewRegistry().RootTagSet()),
 		}
-		req, _ := http.NewRequest(http.MethodGet, srv.URL, nil)
+		req, _ := http.NewRequestWithContext(ctx, http.MethodGet, srv.URL, nil)
 		preq := &ParsedHTTPRequest{
 			Req:         req,
 			URL:         &URL{u: req.URL},
@@ -175,7 +176,7 @@ func TestResponseStatus(t *testing.T) {
 					BuiltinMetrics: metrics.RegisterBuiltinMetrics(registry),
 					Tags:           lib.NewVUStateTags(registry.RootTagSet()),
 				}
-				req, err := http.NewRequest(http.MethodGet, server.URL, nil)
+				req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, server.URL, nil)
 				require.NoError(t, err)
 
 				preq := &ParsedHTTPRequest{
@@ -256,7 +257,7 @@ func TestMakeRequestTimeoutInTheMiddle(t *testing.T) {
 		BuiltinMetrics: metrics.RegisterBuiltinMetrics(registry),
 		Tags:           lib.NewVUStateTags(registry.RootTagSet()),
 	}
-	req, _ := http.NewRequest(http.MethodGet, srv.URL, nil)
+	req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, srv.URL, nil)
 	preq := &ParsedHTTPRequest{
 		Req:              req,
 		URL:              &URL{u: req.URL, URL: srv.URL},
@@ -334,7 +335,7 @@ func TestTrailFailed(t *testing.T) {
 				BuiltinMetrics: metrics.RegisterBuiltinMetrics(registry),
 				Tags:           lib.NewVUStateTags(registry.RootTagSet()),
 			}
-			req, _ := http.NewRequest(http.MethodGet, srv.URL, nil)
+			req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, srv.URL, nil)
 			preq := &ParsedHTTPRequest{
 				Req:              req,
 				URL:              &URL{u: req.URL, URL: srv.URL},
@@ -374,7 +375,7 @@ func TestMakeRequestDialTimeout(t *testing.T) {
 		t.Skipf("dial timeout doesn't get returned on windows") // or we don't match it correctly
 	}
 	t.Parallel()
-	ln, err := net.Listen("tcp", "localhost:0")
+	ln, err := (&net.ListenConfig{}).Listen(context.Background(), "tcp", "localhost:0")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -404,7 +405,7 @@ func TestMakeRequestDialTimeout(t *testing.T) {
 		Tags:           lib.NewVUStateTags(registry.RootTagSet()),
 	}
 
-	req, _ := http.NewRequest(http.MethodGet, "http://"+addr.String(), nil)
+	req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://"+addr.String(), nil)
 	preq := &ParsedHTTPRequest{
 		Req:              req,
 		URL:              &URL{u: req.URL, URL: req.URL.String()},
@@ -459,7 +460,7 @@ func TestMakeRequestTimeoutInTheBegining(t *testing.T) {
 		BuiltinMetrics: metrics.RegisterBuiltinMetrics(registry),
 		Tags:           lib.NewVUStateTags(registry.RootTagSet()),
 	}
-	req, _ := http.NewRequest(http.MethodGet, srv.URL, nil)
+	req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, srv.URL, nil)
 	preq := &ParsedHTTPRequest{
 		Req:              req,
 		URL:              &URL{u: req.URL, URL: srv.URL},
@@ -540,7 +541,7 @@ func TestMakeRequestRPSLimit(t *testing.T) {
 			assert.InDelta(t, val, 3, 3)
 			return
 		default:
-			req, _ := http.NewRequest(http.MethodGet, ts.URL, nil)
+			req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, ts.URL, nil)
 			preq := &ParsedHTTPRequest{
 				Req:         req,
 				URL:         &URL{u: req.URL, URL: ts.URL, Name: ts.URL},
diff --git a/lib/netext/httpext/tracer_test.go b/lib/netext/httpext/tracer_test.go

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ func NewGRPC(t testing.TB) *GRPC {`
`24`	`24`
`25`	`25`	`addr := getFreeBindAddr(t)`
`26`	`26`
`27`		`- lis, err := net.Listen("tcp", addr)`
	`27`	`+ lis, err := (&net.ListenConfig{}).Listen(t.Context(), "tcp", addr)`
`28`	`28`	`if err != nil {`
`29`	`29`	`t.Fatalf("failed to listen: %v", err)`
`30`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ import (`
`14`	`14`
`15`	`15`	`func panicIfFatalError(ctx context.Context, err error) {`
`16`	`16`	`if errors.Is(err, k6error.ErrFatal) {`
`17`		`- k6ext.Abort(ctx, err.Error())`
	`17`	`+ k6ext.Abortf(ctx, err.Error())`
`18`	`18`	`}`
`19`	`19`	`}`
`20`	`20`
Original file line number	Diff line number	Diff line change
`@@ -113,15 +113,15 @@ func (m *RootModule) initialize(vu k6modules.VU) {`
`113`	`113`	`)`
`114`	`114`	`m.remoteRegistry, err = newRemoteRegistry(initEnv.LookupEnv)`
`115`	`115`	`if err != nil {`
`116`		`- k6ext.Abort(vu.Context(), "failed to create remote registry: %v", err)`
	`116`	`+ k6ext.Abortf(vu.Context(), "failed to create remote registry: %v", err)`
`117`	`117`	`}`
`118`	`118`	`m.tracesMetadata, err = parseTracesMetadata(initEnv.LookupEnv)`
`119`	`119`	`if err != nil {`
`120`		`- k6ext.Abort(vu.Context(), "parsing browser traces metadata: %v", err)`
	`120`	`+ k6ext.Abortf(vu.Context(), "parsing browser traces metadata: %v", err)`
`121`	`121`	`}`
`122`	`122`	`m.filePersister, err = newScreenshotPersister(initEnv.LookupEnv)`
`123`	`123`	`if err != nil {`
`124`		`- k6ext.Abort(vu.Context(), "failed to create file persister: %v", err)`
	`124`	`+ k6ext.Abortf(vu.Context(), "failed to create file persister: %v", err)`
`125`	`125`	`}`
`126`	`126`	`if e, ok := initEnv.LookupEnv(env.K6TestRunID); ok && e != "" {`
`127`	`127`	`m.testRunID = e`
Original file line number	Diff line number	Diff line change
`@@ -235,7 +235,7 @@ func (b *Browser) initEvents() error {`
`235`	`235`	`if ev, ok := event.data.(*target.EventAttachedToTarget); ok {`
`236`	`236`	`b.logger.Debugf("Browser:initEvents:onAttachedToTarget", "sid:%v tid:%v", ev.SessionID, ev.TargetInfo.TargetID)`
`237`	`237`	`if err := b.onAttachedToTarget(ev); err != nil {`
`238`		`- k6ext.Panic(b.vuCtx, "browser is attaching to target: %w", err)`
	`238`	`+ k6ext.Panicf(b.vuCtx, "browser is attaching to target: %w", err)`
`239`	`239`	`}`
`240`	`240`	`} else if ev, ok := event.data.(*target.EventDetachedFromTarget); ok {`
`241`	`241`	`b.logger.Debugf("Browser:initEvents:onDetachedFromTarget", "sid:%v", ev.SessionID)`
Original file line number	Diff line number	Diff line change
`@@ -682,7 +682,7 @@ func (fs FrameSession) onExecutionContextCreated(event cdpruntime.EventExecuti`
`682`	`682`	Type string `json:"type"`
`683`	`683`	`}`
`684`	`684`	`if err := json.Unmarshal(auxData, &i); err != nil {`
`685`		`- k6ext.Panic(fs.ctx, "unmarshaling executionContextCreated event JSON: %w", err)`
	`685`	`+ k6ext.Panicf(fs.ctx, "unmarshaling executionContextCreated event JSON: %w", err)`
`686`	`686`	`}`
`687`	`687`
`688`	`688`	`frame, ok := fs.manager.getFrameByID(i.FrameID)`
`@@ -767,7 +767,7 @@ func (fs *FrameSession) onFrameDetached(frameID cdp.FrameID, reason cdppage.Fram`
`767`	`767`	`fs.session.ID(), fs.targetID, frameID, reason)`
`768`	`768`
`769`	`769`	`if err := fs.manager.frameDetached(frameID, reason); err != nil {`
`770`		`- k6ext.Panic(fs.ctx, "handling frameDetached event: %w", err)`
	`770`	`+ k6ext.Panicf(fs.ctx, "handling frameDetached event: %w", err)`
`771`	`771`	`}`
`772`	`772`	`}`
`773`	`773`
`@@ -780,7 +780,7 @@ func (fs FrameSession) onFrameNavigated(frame cdp.Frame, initial bool) {`
`780`	`780`	`frame.ID, frame.ParentID, frame.LoaderID.String(),`
`781`	`781`	`frame.Name, frame.URL+frame.URLFragment, initial)`
`782`	`782`	`if err != nil {`
`783`		`- k6ext.Panic(fs.ctx, "handling frameNavigated event to %q: %w",`
	`783`	`+ k6ext.Panicf(fs.ctx, "handling frameNavigated event to %q: %w",`
`784`	`784`	`frame.URL+frame.URLFragment, err)`
`785`	`785`	`}`
`786`	`786`
`@@ -855,7 +855,7 @@ func (fs FrameSession) onFrameRequestedNavigation(event cdppage.EventFrameRequ`
`855`	`855`	`if event.Disposition == "currentTab" {`
`856`	`856`	`err := fs.manager.frameRequestedNavigation(event.FrameID, event.URL, "")`
`857`	`857`	`if err != nil {`
`858`		`- k6ext.Panic(fs.ctx, "handling frameRequestedNavigation event to %q: %w", event.URL, err)`
	`858`	`+ k6ext.Panicf(fs.ctx, "handling frameRequestedNavigation event to %q: %w", event.URL, err)`
`859`	`859`	`}`
`860`	`860`	`}`
`861`	`861`	`}`
`@@ -995,7 +995,7 @@ func (fs FrameSession) onAttachedToTarget(event target.EventAttachedToTarget)`
`995`	`995`	`return // ignore`
`996`	`996`	`}`
`997`	`997`	`reason = "fatal"`
`998`		`- k6ext.Panic(fs.ctx, "attaching %v: %w", ti.Type, err)`
	`998`	`+ k6ext.Panicf(fs.ctx, "attaching %v: %w", ti.Type, err)`
`999`	`999`	`}`
`1000`	`1000`	`}`
`1001`	`1001`
`@@ -1064,7 +1064,7 @@ func (fs *FrameSession) onTargetCrashed() {`
`1064`	`1064`	`// TODO:?`
`1065`	`1065`	`s, ok := fs.session.(*Session)`
`1066`	`1066`	`if !ok {`
`1067`		`- k6ext.Panic(fs.ctx, "unexpected type %T", fs.session)`
	`1067`	`+ k6ext.Panicf(fs.ctx, "unexpected type %T", fs.session)`
`1068`	`1068`	`}`
`1069`	`1069`	`s.markAsCrashed()`
`1070`	`1070`	`}`
Original file line number	Diff line number	Diff line change
`@@ -210,7 +210,7 @@ func createWaitForEventPredicateHandler(`
`210`	`210`	`//nolint:unused`
`211`	`211`	`func panicOrSlowMo(ctx context.Context, err error) {`
`212`	`212`	`if err != nil {`
`213`		`- k6ext.Panic(ctx, "%w", err)`
	`213`	`+ k6ext.Panicf(ctx, "%w", err)`
`214`	`214`	`}`
`215`	`215`	`applySlowMo(ctx)`
`216`	`216`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1041,14 +1041,14 @@ func (m *NetworkManager) ThrottleNetwork(networkProfile NetworkProfile) error {`
`1041`	`1041`	`func (m *NetworkManager) SetUserAgent(userAgent string) {`
`1042`	`1042`	`action := emulation.SetUserAgentOverride(userAgent)`
`1043`	`1043`	`if err := action.Do(cdp.WithExecutor(m.ctx, m.session)); err != nil {`
`1044`		`- k6ext.Panic(m.ctx, "setting user agent: %w", err)`
	`1044`	`+ k6ext.Panicf(m.ctx, "setting user agent: %w", err)`
`1045`	`1045`	`}`
`1046`	`1046`	`}`
`1047`	`1047`
`1048`	`1048`	`// SetCacheEnabled toggles cache on/off.`
`1049`	`1049`	`func (m *NetworkManager) SetCacheEnabled(enabled bool) {`
`1050`	`1050`	`m.userCacheDisabled = !enabled`
`1051`	`1051`	`if err := m.updateProtocolCacheDisabled(); err != nil {`
`1052`		`- k6ext.Panic(m.ctx, "%v", err)`
	`1052`	`+ k6ext.Panicf(m.ctx, "%v", err)`
`1053`	`1053`	`}`
`1054`	`1054`	`}`