chore: resolve lint findings across packages

salmonumbrella · salmonumbrella · commit 4cb50bebdc5e · 2026-01-03T19:50:20.000-08:00
diff --git a/cmd/gog/main_test.go b/cmd/gog/main_test.go
@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"errors"
 	"os"
 	"os/exec"
@@ -24,7 +25,7 @@ func TestMainExitOnError(t *testing.T) {
 		return
 	}
 
-	cmd := exec.Command(os.Args[0], "-test.run", "^TestMainExitOnError$")
+	cmd := exec.CommandContext(context.Background(), os.Args[0], "-test.run", "^TestMainExitOnError$")
 	cmd.Env = append(os.Environ(), "GOGCLI_TEST_CHILD=1")
 	err := cmd.Run()
 	if err == nil {
diff --git a/internal/cmd/calendar_working_location_test.go b/internal/cmd/calendar_working_location_test.go
@@ -31,7 +31,7 @@ func TestBuildWorkingLocationProperties(t *testing.T) {
 	}
 
 	cmd = &CalendarWorkingLocationCmd{Type: "custom"}
-	if _, err := cmd.buildWorkingLocationProperties(); err == nil {
+	if _, buildErr := cmd.buildWorkingLocationProperties(); buildErr == nil {
 		t.Fatalf("expected error for missing custom label")
 	}
 
@@ -45,7 +45,7 @@ func TestBuildWorkingLocationProperties(t *testing.T) {
 	}
 
 	cmd = &CalendarWorkingLocationCmd{Type: "invalid"}
-	if _, err := cmd.buildWorkingLocationProperties(); err == nil {
+	if _, buildErr := cmd.buildWorkingLocationProperties(); buildErr == nil {
 		t.Fatalf("expected error for invalid type")
 	}
 }
diff --git a/internal/cmd/gmail_send.go b/internal/cmd/gmail_send.go
@@ -122,9 +122,9 @@ func (c *GmailSendCmd) Run(ctx context.Context, flags *RootFlags) error {
 	var trackingID string
 	htmlBody := c.BodyHTML
 	if c.Track {
-		trackingCfg, err := tracking.LoadConfig()
-		if err != nil {
-			return fmt.Errorf("load tracking config: %w", err)
+		trackingCfg, cfgErr := tracking.LoadConfig()
+		if cfgErr != nil {
+			return fmt.Errorf("load tracking config: %w", cfgErr)
 		}
 		if !trackingCfg.IsConfigured() {
 			return fmt.Errorf("tracking not configured; run 'gog gmail track setup' first")
@@ -135,15 +135,15 @@ func (c *GmailSendCmd) Run(ctx context.Context, flags *RootFlags) error {
 
 		// Use first resolved recipient for tracking
 		firstRecipient := toRecipients[0]
-		pixelURL, blob, err := tracking.GeneratePixelURL(trackingCfg, strings.TrimSpace(firstRecipient), c.Subject)
-		if err != nil {
-			return fmt.Errorf("generate tracking pixel: %w", err)
+		pixelURL, blob, pixelErr := tracking.GeneratePixelURL(trackingCfg, strings.TrimSpace(firstRecipient), c.Subject)
+		if pixelErr != nil {
+			return fmt.Errorf("generate tracking pixel: %w", pixelErr)
 		}
 		trackingID = blob
 
 		// Inject pixel at end of HTML body
 		pixelHTML := tracking.GeneratePixelHTML(pixelURL)
-		htmlBody = htmlBody + pixelHTML
+		htmlBody += pixelHTML
 	}
 
 	raw, err := buildRFC822(mailOptions{
diff --git a/internal/cmd/gmail_track_opens.go b/internal/cmd/gmail_track_opens.go
@@ -37,13 +37,18 @@ func (c *GmailTrackOpensCmd) Run(ctx context.Context, flags *RootFlags) error {
 	}
 
 	// Query via admin endpoint
-	return c.queryAdmin(ctx, cfg, u, flags)
+	return c.queryAdmin(ctx, cfg, u)
 }
 
 func (c *GmailTrackOpensCmd) queryByTrackingID(ctx context.Context, cfg *tracking.Config, u *ui.UI) error {
 	reqURL := fmt.Sprintf("%s/q/%s", cfg.WorkerURL, c.TrackingID)
 
-	resp, err := http.Get(reqURL)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, reqURL, nil)
+	if err != nil {
+		return fmt.Errorf("build request: %w", err)
+	}
+
+	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
 		return fmt.Errorf("query tracker: %w", err)
 	}
@@ -88,7 +93,7 @@ func (c *GmailTrackOpensCmd) queryByTrackingID(ctx context.Context, cfg *trackin
 	return nil
 }
 
-func (c *GmailTrackOpensCmd) queryAdmin(ctx context.Context, cfg *tracking.Config, u *ui.UI, flags *RootFlags) error {
+func (c *GmailTrackOpensCmd) queryAdmin(ctx context.Context, cfg *tracking.Config, u *ui.UI) error {
 	reqURL, _ := url.Parse(cfg.WorkerURL + "/opens")
 	q := reqURL.Query()
 	if c.To != "" {
diff --git a/internal/cmd/root.go b/internal/cmd/root.go
@@ -174,7 +174,7 @@ func helpDescription() string {
 	}
 
 	backendInfo, err := secrets.ResolveKeyringBackendInfo()
-	backendLine := "unknown"
+	var backendLine string
 	if err != nil {
 		backendLine = fmt.Sprintf("error: %v", err)
 	} else {
diff --git a/internal/config/config.go b/internal/config/config.go
@@ -16,7 +16,7 @@ type File struct {
 func ConfigPath() (string, error) {
 	dir, err := Dir()
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("config dir: %w", err)
 	}
 
 	return filepath.Join(dir, "config.json"), nil
@@ -32,7 +32,8 @@ func ConfigExists() (bool, error) {
 		if os.IsNotExist(statErr) {
 			return false, nil
 		}
-		return false, statErr
+
+		return false, fmt.Errorf("stat config: %w", statErr)
 	}
 
 	return true, nil
@@ -49,6 +50,7 @@ func ReadConfig() (File, error) {
 		if os.IsNotExist(err) {
 			return File{}, nil
 		}
+
 		return File{}, fmt.Errorf("read config: %w", err)
 	}
 
@@ -58,5 +60,6 @@ func ReadConfig() (File, error) {
 	}
 
 	cfg.KeyringBackend = strings.ToLower(strings.TrimSpace(cfg.KeyringBackend))
+
 	return cfg, nil
 }
diff --git a/internal/config/config_test.go b/internal/config/config_test.go
@@ -16,9 +16,11 @@ func TestConfigPath(t *testing.T) {
 	if err != nil {
 		t.Fatalf("ConfigPath: %v", err)
 	}
+
 	if filepath.Base(path) != "config.json" {
 		t.Fatalf("unexpected config file: %q", filepath.Base(path))
 	}
+
 	if filepath.Base(filepath.Dir(path)) != AppName {
 		t.Fatalf("unexpected config dir: %q", filepath.Dir(path))
 	}
@@ -33,6 +35,7 @@ func TestReadConfig_Missing(t *testing.T) {
 	if err != nil {
 		t.Fatalf("ReadConfig: %v", err)
 	}
+
 	if cfg.KeyringBackend != "" {
 		t.Fatalf("expected empty config, got %q", cfg.KeyringBackend)
 	}
@@ -47,21 +50,24 @@ func TestReadConfig_JSON5(t *testing.T) {
 	if err != nil {
 		t.Fatalf("ConfigPath: %v", err)
 	}
-	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
-		t.Fatalf("mkdir: %v", err)
+
+	if mkErr := os.MkdirAll(filepath.Dir(path), 0o700); mkErr != nil {
+		t.Fatalf("mkdir: %v", mkErr)
 	}
 	data := `{
   // allow comments + trailing commas
   keyring_backend: "file",
 }`
-	if err := os.WriteFile(path, []byte(data), 0o600); err != nil {
-		t.Fatalf("write config: %v", err)
+
+	if writeErr := os.WriteFile(path, []byte(data), 0o600); writeErr != nil {
+		t.Fatalf("write config: %v", writeErr)
 	}
 
 	cfg, err := ReadConfig()
 	if err != nil {
 		t.Fatalf("ReadConfig: %v", err)
 	}
+
 	if got := strings.TrimSpace(cfg.KeyringBackend); got != "file" {
 		t.Fatalf("expected keyring_backend=file, got %q", got)
 	}
diff --git a/internal/googleauth/accounts_server.go b/internal/googleauth/accounts_server.go
@@ -61,7 +61,7 @@ func StartManageServer(ctx context.Context, opts ManageServerOptions) error {
 		return fmt.Errorf("failed to generate CSRF token: %w", err)
 	}
 
-	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	ln, err := (&net.ListenConfig{}).Listen(ctx, "tcp", "127.0.0.1:0")
 	if err != nil {
 		return fmt.Errorf("failed to start listener: %w", err)
 	}
diff --git a/internal/googleauth/accounts_server_test.go b/internal/googleauth/accounts_server_test.go
@@ -187,7 +187,7 @@ func TestManageServer_HandleOAuthCallback_ErrorAndValidation(t *testing.T) {
 		oauthState: "state1",
 	}
 	// Need a listener for redirectURI generation even though we don't reach exchange.
-	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	ln, err := (&net.ListenConfig{}).Listen(context.Background(), "tcp", "127.0.0.1:0")
 	if err != nil {
 		t.Fatalf("listen: %v", err)
 	}
@@ -408,7 +408,7 @@ func TestManageServer_HandleAuthStart(t *testing.T) {
 	randomStateFn = func() (string, error) { return "state123", nil }
 	oauthEndpoint = oauth2.Endpoint{AuthURL: "http://example.com/auth", TokenURL: "http://example.com/token"}
 
-	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	ln, err := (&net.ListenConfig{}).Listen(context.Background(), "tcp", "127.0.0.1:0")
 	if err != nil {
 		t.Fatalf("listen: %v", err)
 	}
@@ -506,7 +506,7 @@ func TestManageServer_HandleOAuthCallback_Success(t *testing.T) {
 
 	oauthEndpoint = oauth2.Endpoint{AuthURL: "http://example.com/auth", TokenURL: srv.URL}
 
-	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	ln, err := (&net.ListenConfig{}).Listen(context.Background(), "tcp", "127.0.0.1:0")
 	if err != nil {
 		t.Fatalf("listen: %v", err)
 	}
diff --git a/internal/googleauth/oauth_flow.go b/internal/googleauth/oauth_flow.go
@@ -131,7 +131,7 @@ func Authorize(ctx context.Context, opts AuthorizeOptions) (string, error) {
 		return tok.RefreshToken, nil
 	}
 
-	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	ln, err := (&net.ListenConfig{}).Listen(ctx, "tcp", "127.0.0.1:0")
 	if err != nil {
 		return "", fmt.Errorf("listen for callback: %w", err)
 	}
diff --git a/internal/secrets/store.go b/internal/secrets/store.go
@@ -67,8 +67,9 @@ func ResolveKeyringBackendInfo() (KeyringBackendInfo, error) {
 
 	cfg, err := config.ReadConfig()
 	if err != nil {
-		return KeyringBackendInfo{}, err
+		return KeyringBackendInfo{}, fmt.Errorf("read config: %w", err)
 	}
+
 	if cfg.KeyringBackend != "" {
 		return KeyringBackendInfo{Value: cfg.KeyringBackend, Source: keyringBackendSourceConfig}, nil
 	}
diff --git a/internal/secrets/store_test.go b/internal/secrets/store_test.go
@@ -19,9 +19,11 @@ func TestResolveKeyringBackendInfo_Default(t *testing.T) {
 	if err != nil {
 		t.Fatalf("ResolveKeyringBackendInfo: %v", err)
 	}
+
 	if info.Value != "auto" {
 		t.Fatalf("expected auto, got %q", info.Value)
 	}
+
 	if info.Source != keyringBackendSourceDefault {
 		t.Fatalf("expected source default, got %q", info.Source)
 	}
@@ -37,20 +39,24 @@ func TestResolveKeyringBackendInfo_Config(t *testing.T) {
 	if err != nil {
 		t.Fatalf("ConfigPath: %v", err)
 	}
-	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
-		t.Fatalf("mkdir: %v", err)
+
+	if mkErr := os.MkdirAll(filepath.Dir(path), 0o700); mkErr != nil {
+		t.Fatalf("mkdir: %v", mkErr)
 	}
-	if err := os.WriteFile(path, []byte(`{ keyring_backend: "file" }`), 0o600); err != nil {
-		t.Fatalf("write config: %v", err)
+
+	if writeErr := os.WriteFile(path, []byte(`{ keyring_backend: "file" }`), 0o600); writeErr != nil {
+		t.Fatalf("write config: %v", writeErr)
 	}
 
 	info, err := ResolveKeyringBackendInfo()
 	if err != nil {
 		t.Fatalf("ResolveKeyringBackendInfo: %v", err)
 	}
+
 	if info.Value != "file" {
 		t.Fatalf("expected file, got %q", info.Value)
 	}
+
 	if info.Source != keyringBackendSourceConfig {
 		t.Fatalf("expected source config, got %q", info.Source)
 	}
@@ -66,20 +72,24 @@ func TestResolveKeyringBackendInfo_EnvOverridesConfig(t *testing.T) {
 	if err != nil {
 		t.Fatalf("ConfigPath: %v", err)
 	}
-	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
-		t.Fatalf("mkdir: %v", err)
+
+	if mkErr := os.MkdirAll(filepath.Dir(path), 0o700); mkErr != nil {
+		t.Fatalf("mkdir: %v", mkErr)
 	}
-	if err := os.WriteFile(path, []byte(`{ keyring_backend: "file" }`), 0o600); err != nil {
-		t.Fatalf("write config: %v", err)
+
+	if writeErr := os.WriteFile(path, []byte(`{ keyring_backend: "file" }`), 0o600); writeErr != nil {
+		t.Fatalf("write config: %v", writeErr)
 	}
 
 	info, err := ResolveKeyringBackendInfo()
 	if err != nil {
 		t.Fatalf("ResolveKeyringBackendInfo: %v", err)
 	}
+
 	if info.Value != "keychain" {
 		t.Fatalf("expected keychain, got %q", info.Value)
 	}
+
 	if info.Source != keyringBackendSourceEnv {
 		t.Fatalf("expected source env, got %q", info.Source)
 	}
@@ -90,6 +100,7 @@ func TestAllowedBackends_Invalid(t *testing.T) {
 	if err == nil {
 		t.Fatalf("expected error")
 	}
+
 	if !errors.Is(err, errInvalidKeyringBackend) {
 		t.Fatalf("expected invalid backend error, got %v", err)
 	}
diff --git a/internal/tracking/config.go b/internal/tracking/config.go
@@ -2,6 +2,7 @@ package tracking
 
 import (
 	"encoding/json"
+	"fmt"
 	"os"
 	"path/filepath"
 )
@@ -18,8 +19,9 @@ type Config struct {
 func ConfigPath() (string, error) {
 	configDir, err := os.UserConfigDir()
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("user config dir: %w", err)
 	}
+
 	return filepath.Join(configDir, "gog", "tracking.json"), nil
 }
 
@@ -30,17 +32,19 @@ func LoadConfig() (*Config, error) {
 		return nil, err
 	}
 
+	// #nosec G304 -- path is derived from user config dir
 	data, err := os.ReadFile(path)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return &Config{Enabled: false}, nil
 		}
-		return nil, err
+
+		return nil, fmt.Errorf("read tracking config: %w", err)
 	}
 
 	var cfg Config
 	if err := json.Unmarshal(data, &cfg); err != nil {
-		return nil, err
+		return nil, fmt.Errorf("parse tracking config: %w", err)
 	}
 
 	return &cfg, nil
@@ -54,16 +58,20 @@ func SaveConfig(cfg *Config) error {
 	}
 
 	// Ensure directory exists
-	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
-		return err
+	if mkErr := os.MkdirAll(filepath.Dir(path), 0o700); mkErr != nil {
+		return fmt.Errorf("create tracking config dir: %w", mkErr)
 	}
 
 	data, err := json.MarshalIndent(cfg, "", "  ")
 	if err != nil {
-		return err
+		return fmt.Errorf("marshal tracking config: %w", err)
+	}
+
+	if writeErr := os.WriteFile(path, data, 0o600); writeErr != nil {
+		return fmt.Errorf("write tracking config: %w", writeErr)
 	}
 
-	return os.WriteFile(path, data, 0o600)
+	return nil
 }
 
 // IsConfigured returns true if tracking is set up
diff --git a/internal/tracking/config_test.go b/internal/tracking/config_test.go
diff --git a/internal/tracking/crypto.go b/internal/tracking/crypto.go
diff --git a/internal/tracking/crypto_test.go b/internal/tracking/crypto_test.go
diff --git a/internal/tracking/pixel.go b/internal/tracking/pixel.go
diff --git a/internal/tracking/pixel_test.go b/internal/tracking/pixel_test.go

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ func TestBuildWorkingLocationProperties(t *testing.T) {`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`cmd = &CalendarWorkingLocationCmd{Type: "custom"}`
`34`		`- if _, err := cmd.buildWorkingLocationProperties(); err == nil {`
	`34`	`+ if _, buildErr := cmd.buildWorkingLocationProperties(); buildErr == nil {`
`35`	`35`	`t.Fatalf("expected error for missing custom label")`
`36`	`36`	`}`
`37`	`37`
`@@ -45,7 +45,7 @@ func TestBuildWorkingLocationProperties(t *testing.T) {`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`cmd = &CalendarWorkingLocationCmd{Type: "invalid"}`
`48`		`- if _, err := cmd.buildWorkingLocationProperties(); err == nil {`
	`48`	`+ if _, buildErr := cmd.buildWorkingLocationProperties(); buildErr == nil {`
`49`	`49`	`t.Fatalf("expected error for invalid type")`
`50`	`50`	`}`
`51`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -174,7 +174,7 @@ func helpDescription() string {`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`backendInfo, err := secrets.ResolveKeyringBackendInfo()`
`177`		`- backendLine := "unknown"`
	`177`	`+ var backendLine string`
`178`	`178`	`if err != nil {`
`179`	`179`	`backendLine = fmt.Sprintf("error: %v", err)`
`180`	`180`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ type File struct {`
`16`	`16`	`func ConfigPath() (string, error) {`
`17`	`17`	`dir, err := Dir()`
`18`	`18`	`if err != nil {`
`19`		`- return "", err`
	`19`	`+ return "", fmt.Errorf("config dir: %w", err)`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`return filepath.Join(dir, "config.json"), nil`
`@@ -32,7 +32,8 @@ func ConfigExists() (bool, error) {`
`32`	`32`	`if os.IsNotExist(statErr) {`
`33`	`33`	`return false, nil`
`34`	`34`	`}`
`35`		`- return false, statErr`
	`35`	`+`
	`36`	`+ return false, fmt.Errorf("stat config: %w", statErr)`
`36`	`37`	`}`
`37`	`38`
`38`	`39`	`return true, nil`
`@@ -49,6 +50,7 @@ func ReadConfig() (File, error) {`
`49`	`50`	`if os.IsNotExist(err) {`
`50`	`51`	`return File{}, nil`
`51`	`52`	`}`
	`53`	`+`
`52`	`54`	`return File{}, fmt.Errorf("read config: %w", err)`
`53`	`55`	`}`
`54`	`56`
`@@ -58,5 +60,6 @@ func ReadConfig() (File, error) {`
`58`	`60`	`}`
`59`	`61`
`60`	`62`	`cfg.KeyringBackend = strings.ToLower(strings.TrimSpace(cfg.KeyringBackend))`
	`63`	`+`
`61`	`64`	`return cfg, nil`
`62`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,9 +16,11 @@ func TestConfigPath(t *testing.T) {`
`16`	`16`	`if err != nil {`
`17`	`17`	`t.Fatalf("ConfigPath: %v", err)`
`18`	`18`	`}`
	`19`	`+`
`19`	`20`	`if filepath.Base(path) != "config.json" {`
`20`	`21`	`t.Fatalf("unexpected config file: %q", filepath.Base(path))`
`21`	`22`	`}`
	`23`	`+`
`22`	`24`	`if filepath.Base(filepath.Dir(path)) != AppName {`
`23`	`25`	`t.Fatalf("unexpected config dir: %q", filepath.Dir(path))`
`24`	`26`	`}`
`@@ -33,6 +35,7 @@ func TestReadConfig_Missing(t *testing.T) {`
`33`	`35`	`if err != nil {`
`34`	`36`	`t.Fatalf("ReadConfig: %v", err)`
`35`	`37`	`}`
	`38`	`+`
`36`	`39`	`if cfg.KeyringBackend != "" {`
`37`	`40`	`t.Fatalf("expected empty config, got %q", cfg.KeyringBackend)`
`38`	`41`	`}`
`@@ -47,21 +50,24 @@ func TestReadConfig_JSON5(t *testing.T) {`
`47`	`50`	`if err != nil {`
`48`	`51`	`t.Fatalf("ConfigPath: %v", err)`
`49`	`52`	`}`
`50`		`- if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {`
`51`		`- t.Fatalf("mkdir: %v", err)`
	`53`	`+`
	`54`	`+ if mkErr := os.MkdirAll(filepath.Dir(path), 0o700); mkErr != nil {`
	`55`	`+ t.Fatalf("mkdir: %v", mkErr)`
`52`	`56`	`}`
`53`	`57`	data := `{
`54`	`58`	`// allow comments + trailing commas`
`55`	`59`	`keyring_backend: "file",`
`56`	`60`	}`
`57`		`- if err := os.WriteFile(path, []byte(data), 0o600); err != nil {`
`58`		`- t.Fatalf("write config: %v", err)`
	`61`	`+`
	`62`	`+ if writeErr := os.WriteFile(path, []byte(data), 0o600); writeErr != nil {`
	`63`	`+ t.Fatalf("write config: %v", writeErr)`
`59`	`64`	`}`
`60`	`65`
`61`	`66`	`cfg, err := ReadConfig()`
`62`	`67`	`if err != nil {`
`63`	`68`	`t.Fatalf("ReadConfig: %v", err)`
`64`	`69`	`}`
	`70`	`+`
`65`	`71`	`if got := strings.TrimSpace(cfg.KeyringBackend); got != "file" {`
`66`	`72`	`t.Fatalf("expected keyring_backend=file, got %q", got)`
`67`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ func StartManageServer(ctx context.Context, opts ManageServerOptions) error {`
`61`	`61`	`return fmt.Errorf("failed to generate CSRF token: %w", err)`
`62`	`62`	`}`
`63`	`63`
`64`		`- ln, err := net.Listen("tcp", "127.0.0.1:0")`
	`64`	`+ ln, err := (&net.ListenConfig{}).Listen(ctx, "tcp", "127.0.0.1:0")`
`65`	`65`	`if err != nil {`
`66`	`66`	`return fmt.Errorf("failed to start listener: %w", err)`
`67`	`67`	`}`
Original file line number	Diff line number	Diff line change
`@@ -187,7 +187,7 @@ func TestManageServer_HandleOAuthCallback_ErrorAndValidation(t *testing.T) {`
`187`	`187`	`oauthState: "state1",`
`188`	`188`	`}`
`189`	`189`	`// Need a listener for redirectURI generation even though we don't reach exchange.`
`190`		`- ln, err := net.Listen("tcp", "127.0.0.1:0")`
	`190`	`+ ln, err := (&net.ListenConfig{}).Listen(context.Background(), "tcp", "127.0.0.1:0")`
`191`	`191`	`if err != nil {`
`192`	`192`	`t.Fatalf("listen: %v", err)`
`193`	`193`	`}`
`@@ -408,7 +408,7 @@ func TestManageServer_HandleAuthStart(t *testing.T) {`
`408`	`408`	`randomStateFn = func() (string, error) { return "state123", nil }`
`409`	`409`	`oauthEndpoint = oauth2.Endpoint{AuthURL: "http://example.com/auth", TokenURL: "http://example.com/token"}`
`410`	`410`
`411`		`- ln, err := net.Listen("tcp", "127.0.0.1:0")`
	`411`	`+ ln, err := (&net.ListenConfig{}).Listen(context.Background(), "tcp", "127.0.0.1:0")`
`412`	`412`	`if err != nil {`
`413`	`413`	`t.Fatalf("listen: %v", err)`
`414`	`414`	`}`
`@@ -506,7 +506,7 @@ func TestManageServer_HandleOAuthCallback_Success(t *testing.T) {`
`506`	`506`
`507`	`507`	`oauthEndpoint = oauth2.Endpoint{AuthURL: "http://example.com/auth", TokenURL: srv.URL}`
`508`	`508`
`509`		`- ln, err := net.Listen("tcp", "127.0.0.1:0")`
	`509`	`+ ln, err := (&net.ListenConfig{}).Listen(context.Background(), "tcp", "127.0.0.1:0")`
`510`	`510`	`if err != nil {`
`511`	`511`	`t.Fatalf("listen: %v", err)`
`512`	`512`	`}`
Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ func Authorize(ctx context.Context, opts AuthorizeOptions) (string, error) {`
`131`	`131`	`return tok.RefreshToken, nil`
`132`	`132`	`}`
`133`	`133`
`134`		`- ln, err := net.Listen("tcp", "127.0.0.1:0")`
	`134`	`+ ln, err := (&net.ListenConfig{}).Listen(ctx, "tcp", "127.0.0.1:0")`
`135`	`135`	`if err != nil {`
`136`	`136`	`return "", fmt.Errorf("listen for callback: %w", err)`
`137`	`137`	`}`