Fix linter errors from CI

Author: brianwcook

pkg/remoteresolution/cache/cache_test.go

@@ -409,7 +409,7 @@ func TestResolverCache(t *testing.T) {
 
 	// Wait for expiration with polling to make test more reliable
 	expired := false
-	for i := 0; i < 20; i++ { // Max 200ms wait
+	for range 20 { // Max 200ms wait
 		time.Sleep(10 * time.Millisecond)
 		if _, ok := cache.Get("http", expiringParams); !ok {
 			expired = true
@@ -533,10 +533,8 @@ func TestResolverCacheOperations(t *testing.T) {
 
 	if v, found := cache.Get(resolverType, params); !found {
 		t.Error("Expected to find value in cache")
-	} else {
-		if string(v.Data()) != "test-value" {
-			t.Errorf("Expected data 'test-value', got %s", string(v.Data()))
-		}
+	} else if string(v.Data()) != "test-value" {
+		t.Errorf("Expected data 'test-value', got %s", string(v.Data()))
 	}
 
 	// Verify Add returns annotated resource
@@ -561,17 +559,15 @@ func TestResolverCacheOperations(t *testing.T) {
 
 	if v, found := cache.Get("bundle", expirationParams); !found {
 		t.Error("Expected to find value in cache")
-	} else {
-		if string(v.Data()) != "expiring-value" {
-			t.Errorf("Expected data 'expiring-value', got %s", string(v.Data()))
-		}
+	} else if string(v.Data()) != "expiring-value" {
+		t.Errorf("Expected data 'expiring-value', got %s", string(v.Data()))
 	}
 
 	// Wait for expiration with polling for more reliable test
 	expired := false
 	maxWait := customTTL + 100*time.Millisecond
 	iterations := int(maxWait / (10 * time.Millisecond))
-	for i := 0; i < iterations; i++ {
+	for range iterations {
 		time.Sleep(10 * time.Millisecond)
 		if _, found := cache.Get("bundle", expirationParams); !found {
 			expired = true

pkg/remoteresolution/cache/injection/cache_test.go

@@ -31,7 +31,7 @@ func TestKey(t *testing.T) {
 	key2 := Key{}
 
 	// Keys should be equivalent when used as context keys
-	ctx := context.Background()
+	ctx := t.Context()
 	ctx = context.WithValue(ctx, key1, "test-value")
 
 	value := ctx.Value(key2)
@@ -55,27 +55,27 @@ func TestSharedCacheInitialization(t *testing.T) {
 func TestWithCacheFromConfig(t *testing.T) {
 	tests := []struct {
 		name        string
-		ctx         context.Context
+		setupCtx    func() context.Context
 		cfg         *rest.Config
 		expectCache bool
 	}{
 		{
 			name:        "basic context with config",
-			ctx:         context.Background(),
+			setupCtx:    func() context.Context { return t.Context() },
 			cfg:         &rest.Config{},
 			expectCache: true,
 		},
 		{
 			name:        "context with logger",
-			ctx:         logtesting.TestContextWithLogger(t),
+			setupCtx:    func() context.Context { return logtesting.TestContextWithLogger(t) },
 			cfg:         &rest.Config{},
 			expectCache: true,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := withCacheFromConfig(tt.ctx, tt.cfg)
+			result := withCacheFromConfig(tt.setupCtx(), tt.cfg)
 
 			// Check that result context contains cache
 			cache := result.Value(Key{})
@@ -86,10 +86,7 @@ func TestWithCacheFromConfig(t *testing.T) {
 			// Check that cache is functional (don't need type assertion for this test)
 			if tt.expectCache && cache != nil {
 				// The fact that it was stored and retrieved indicates correct type
-				// Just check that we have a non-nil interface value
-				if cache == nil {
-					t.Errorf("Expected non-nil cache")
-				}
+				// Cache is non-nil as verified by outer condition, so it's functional
 			}
 		})
 	}
@@ -105,15 +102,15 @@ func TestGet(t *testing.T) {
 		{
 			name: "context without cache",
 			setupContext: func() context.Context {
-				return context.Background()
+				return t.Context()
 			},
 			expectNotNil:       true,
 			expectSameInstance: false, // Should get fallback instance
 		},
 		{
 			name: "context with cache",
 			setupContext: func() context.Context {
-				ctx := context.Background()
+				ctx := t.Context()
 				testCache := cache.NewResolverCache(100)
 				return context.WithValue(ctx, Key{}, testCache)
 			},
@@ -150,7 +147,7 @@ func TestGet(t *testing.T) {
 
 func TestGetConsistency(t *testing.T) {
 	// Test that Get returns consistent results for fallback case
-	ctx := context.Background()
+	ctx := t.Context()
 
 	cache1 := Get(ctx)
 	cache2 := Get(ctx)
@@ -166,7 +163,7 @@ func TestGetConsistency(t *testing.T) {
 
 func TestGetWithInjectedCache(t *testing.T) {
 	// Test that Get returns the injected cache when available
-	ctx := context.Background()
+	ctx := t.Context()
 	testCache := cache.NewResolverCache(50)
 	ctx = context.WithValue(ctx, Key{}, testCache)
 

pkg/remoteresolution/resolver/cluster/resolver_integration_test.go

@@ -51,8 +51,6 @@ import (
 	"knative.dev/pkg/system"
 	_ "knative.dev/pkg/system/testing"
 	"sigs.k8s.io/yaml"
-
-
 )
 
 const (
@@ -527,9 +525,6 @@ func resolverDisabledContext() context.Context {
 	return frameworktesting.ContextWithClusterResolverDisabled(context.Background())
 }
 
-/*
-*/
-
 func TestResolveWithDisabledResolver(t *testing.T) {
 	ctx := frameworktesting.ContextWithClusterResolverDisabled(t.Context())
 	resolver := &cluster.Resolver{}

pkg/remoteresolution/resolver/framework/cache.go

@@ -42,7 +42,7 @@ type ImmutabilityChecker interface {
 
 // ShouldUseCache determines whether caching should be used based on:
 // 1. Task/Pipeline cache parameter (highest priority)
-// 2. ConfigMap default-cache-mode (middle priority)  
+// 2. ConfigMap default-cache-mode (middle priority)
 // 3. System default for resolver type (lowest priority)
 func ShouldUseCache(ctx context.Context, resolver ImmutabilityChecker, params []pipelinev1.Param, resolverType string) bool {
 	// Get cache mode from task parameter

pkg/remoteresolution/resolver/framework/cache_test.go

@@ -222,7 +222,7 @@ func TestShouldUseCache(t *testing.T) {
 			resolver := &mockImmutabilityChecker{immutable: tt.immutable}
 
 			// Create context with config
-			ctx := context.Background()
+			ctx := t.Context()
 			ctx = resolutionframework.InjectResolverConfigToContext(ctx, tt.configMap)
 
 			// Test ShouldUseCache
@@ -327,7 +327,7 @@ func TestShouldUseCachePrecedence(t *testing.T) {
 			}
 
 			// Setup context with resolver config
-			ctx := context.Background()
+			ctx := t.Context()
 			if len(tt.configMap) > 0 {
 				ctx = resolutionframework.InjectResolverConfigToContext(ctx, tt.configMap)
 			}
@@ -554,7 +554,7 @@ func TestShouldUseCacheBundleResolver(t *testing.T) {
 				},
 			}...)
 
-			ctx := context.Background()
+			ctx := t.Context()
 
 			// Test the cache decision logic
 			actual := framework.ShouldUseCache(ctx, resolver, params, "bundle")
@@ -614,7 +614,7 @@ func TestRunCacheOperations(t *testing.T) {
 			}
 
 			// Create context with cache injection
-			ctx := context.Background()
+			ctx := t.Context()
 			ctx = context.WithValue(ctx, cacheinjection.Key{}, testCache)
 
 			// Track if resolve function was called