Fix lint errors

.golangci.yml

@@ -34,6 +34,7 @@ linters:
     - golint            # deprecated by Go team
     - gomnd             # some unnamed constants are okay
     - ifshort           # deprecated by author
+    - inamedparam       # convention is not followed
     - interfacer        # deprecated by author
     - ireturn           # "accept interfaces, return structs" isn't ironclad
     - lll               # don't want hard limits for line length

cache.go

@@ -63,7 +63,7 @@ func decodeForCache(data []byte) (*prototransformv1alpha1.CacheEntry, error) {
 }
 
 func isCorrectCacheEntry(entry *prototransformv1alpha1.CacheEntry, schemaID string, syms []string) bool {
-	return entry.Id == schemaID && isSuperSet(entry.IncludedSymbols, syms)
+	return entry.GetId() == schemaID && isSuperSet(entry.GetIncludedSymbols(), syms)
 }
 
 func isSuperSet(have, want []string) bool {

cache/filecache/filecache_test.go

@@ -174,7 +174,7 @@ func TestSanitize(t *testing.T) {
 func checkFiles(t *testing.T, dir string, mode fs.FileMode, names map[string]struct{}) {
 	t.Helper()
 	err := fs.WalkDir(os.DirFS(dir), ".", func(path string, dirEntry fs.DirEntry, err error) error {
-		if !assert.NoError(t, err) {
+		if !assert.NoError(t, err) { //nolint:testifylint
 			return nil
 		}
 		if dirEntry.IsDir() {
@@ -190,7 +190,7 @@ func checkFiles(t *testing.T, dir string, mode fs.FileMode, names map[string]str
 		}
 		delete(names, path)
 		info, err := dirEntry.Info()
-		if !assert.NoErrorf(t, err, "failed to get file info for %s", path) {
+		if !assert.NoErrorf(t, err, "failed to get file info for %s", path) { //nolint:testifylint
 			return nil
 		}
 		assert.Equal(t, mode, info.Mode())

config.go

@@ -15,6 +15,7 @@
 package prototransform
 
 import (
+	"errors"
 	"fmt"
 	"time"
 
@@ -83,22 +84,22 @@ type SchemaWatcherConfig struct {
 
 func (c *SchemaWatcherConfig) validate() error {
 	if c.SchemaPoller == nil {
-		return fmt.Errorf("schema poller not provided")
+		return errors.New("schema poller not provided")
 	}
 	if c.PollingPeriod < 0 {
-		return fmt.Errorf("polling period duration cannot be negative")
+		return errors.New("polling period duration cannot be negative")
 	}
 	if c.Jitter < 0 {
-		return fmt.Errorf("jitter cannot be negative")
+		return errors.New("jitter cannot be negative")
 	}
 	if c.Jitter > 1.0 {
-		return fmt.Errorf("jitter cannot be greater than 1.0 (100%%)")
+		return errors.New("jitter cannot be greater than 1.0 (100%)")
 	}
 	if c.Leaser != nil && c.Cache == nil {
-		return fmt.Errorf("leaser config should only be present when cache config also present")
+		return errors.New("leaser config should only be present when cache config also present")
 	}
 	if c.Leaser != nil && c.CurrentProcess != nil && len(c.CurrentProcess) == 0 {
-		return fmt.Errorf("current process is empty but not nil; leave nil or set to non-empty value")
+		return errors.New("current process is empty but not nil; leave nil or set to non-empty value")
 	}
 	for _, sym := range c.IncludeSymbols {
 		if sym == "" {

converter_test.go

@@ -33,7 +33,7 @@ import (
 func TestSchemaService_ConvertMessage(t *testing.T) {
 	t.Parallel()
 	// create schema for message to convert
-	sourceFile := fakeFileDescriptorSet().File[0]
+	sourceFile := fakeFileDescriptorSet().GetFile()[0]
 
 	// create test message
 	fileDescriptor, err := protodesc.NewFile(sourceFile, nil)

filter.go

@@ -90,7 +90,7 @@ func redactList(value protoreflect.Value, redaction func(protoreflect.FieldDescr
 }
 
 func redactMap(value protoreflect.Value, redaction func(protoreflect.FieldDescriptor) bool) {
-	value.Map().Range(func(mapKey protoreflect.MapKey, mapValue protoreflect.Value) bool {
+	value.Map().Range(func(_ protoreflect.MapKey, mapValue protoreflect.Value) bool {
 		redactMessage(mapValue.Message(), redaction)
 		return true
 	})

reflect_client.go

@@ -16,6 +16,7 @@ package prototransform
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"net/http"
 	"os"
@@ -49,7 +50,7 @@ func NewDefaultFileDescriptorSetServiceClient(token string) reflectv1beta1connec
 			connect.UnaryInterceptorFunc(func(call connect.UnaryFunc) connect.UnaryFunc {
 				return func(ctx context.Context, req connect.AnyRequest) (connect.AnyResponse, error) {
 					// decorate user-agent with the name of the package
-					userAgent := fmt.Sprintf("%s prototransform-go", req.Header().Get("User-Agent"))
+					userAgent := req.Header().Get("User-Agent") + " prototransform-go"
 					req.Header().Set("User-Agent", userAgent)
 					return call(ctx, req)
 				}
@@ -68,7 +69,7 @@ func NewDefaultFileDescriptorSetServiceClient(token string) reflectv1beta1connec
 //
 // To get a token from the environment (e.g. BUF_TOKEN env var), see BufTokenFromEnvironment.
 func NewAuthInterceptor(token string) connect.Interceptor {
-	bearerAuthValue := fmt.Sprintf("Bearer %s", token)
+	bearerAuthValue := "Bearer " + token
 	return connect.UnaryInterceptorFunc(func(next connect.UnaryFunc) connect.UnaryFunc {
 		return func(ctx context.Context, request connect.AnyRequest) (connect.AnyResponse, error) {
 			request.Header().Set("Authorization", bearerAuthValue)
@@ -84,7 +85,7 @@ func BufTokenFromEnvironment(moduleRef string) (string, error) {
 	parts := strings.SplitN(moduleRef, "/", 2)
 	envBufToken := os.Getenv("BUF_TOKEN")
 	if envBufToken == "" {
-		return "", fmt.Errorf("no BUF_TOKEN environment variable set")
+		return "", errors.New("no BUF_TOKEN environment variable set")
 	}
 	tok := parseBufToken(envBufToken, parts[0])
 	if tok == "" {

reflect_client_test.go

@@ -71,7 +71,7 @@ func TestReflectClientLargeRequest(t *testing.T) {
 	// downloading the entire response.
 	resp, err := getFileDescriptorSet(ctx, client, req)
 	require.NoError(t, err)
-	require.GreaterOrEqual(t, len(resp.Msg.FileDescriptorSet.File), 42)
+	require.GreaterOrEqual(t, len(resp.Msg.GetFileDescriptorSet().GetFile()), 42)
 
 	// If we ask for one fewer type, we should be below the limit and get back
 	// a "not modified" response code instead of a response body.

resolver.go

@@ -47,7 +47,7 @@ type resolver struct {
 func newResolver(fileDescriptors *descriptorpb.FileDescriptorSet) (*resolver, error) {
 	var result resolver
 	// TODO(TCN-925): maybe should reparse unrecognized fields in fileDescriptors after creating resolver?
-	if len(fileDescriptors.File) == 0 {
+	if len(fileDescriptors.GetFile()) == 0 {
 		return &result, nil
 	}
 	files, err := protodesc.FileOptions{AllowUnresolvable: true}.NewFiles(fileDescriptors)

schema_poller.go

@@ -89,7 +89,7 @@ func (b *bufReflectPoller) GetSchema(ctx context.Context, symbols []string, curr
 		}
 		return nil, "", err
 	}
-	return resp.Msg.FileDescriptorSet, resp.Msg.Version, err
+	return resp.Msg.GetFileDescriptorSet(), resp.Msg.GetVersion(), err
 }
 
 func (b *bufReflectPoller) GetSchemaID() string {

schema_watcher_test.go

@@ -44,7 +44,7 @@ func TestNewSchemaWatcher(t *testing.T) {
 		config := &SchemaWatcherConfig{}
 		got, err := NewSchemaWatcher(ctx, config)
 		require.Error(t, err)
-		assert.EqualError(t, err, "schema poller not provided")
+		require.EqualError(t, err, "schema poller not provided")
 		assert.Nil(t, got)
 	})
 	t.Run("polling period negative", func(t *testing.T) {
@@ -55,7 +55,7 @@ func TestNewSchemaWatcher(t *testing.T) {
 		}
 		got, err := NewSchemaWatcher(ctx, config)
 		require.Error(t, err)
-		assert.EqualError(t, err, "polling period duration cannot be negative")
+		require.EqualError(t, err, "polling period duration cannot be negative")
 		assert.Nil(t, got)
 	})
 	t.Run("jitter negative", func(t *testing.T) {
@@ -66,7 +66,7 @@ func TestNewSchemaWatcher(t *testing.T) {
 		}
 		got, err := NewSchemaWatcher(ctx, config)
 		require.Error(t, err)
-		assert.EqualError(t, err, "jitter cannot be negative")
+		require.EqualError(t, err, "jitter cannot be negative")
 		assert.Nil(t, got)
 	})
 	t.Run("jitter > 1", func(t *testing.T) {
@@ -77,7 +77,7 @@ func TestNewSchemaWatcher(t *testing.T) {
 		}
 		got, err := NewSchemaWatcher(ctx, config)
 		require.Error(t, err)
-		assert.EqualError(t, err, "jitter cannot be greater than 1.0 (100%)")
+		require.EqualError(t, err, "jitter cannot be greater than 1.0 (100%)")
 		assert.Nil(t, got)
 	})
 	t.Run("invalid symbol name", func(t *testing.T) {
@@ -88,7 +88,7 @@ func TestNewSchemaWatcher(t *testing.T) {
 		}
 		got, err := NewSchemaWatcher(ctx, config)
 		require.Error(t, err)
-		assert.EqualError(t, err, `"$poop" is not a valid symbol name`)
+		require.EqualError(t, err, `"$poop" is not a valid symbol name`)
 		assert.Nil(t, got)
 	})
 	t.Run("leaser without cache", func(t *testing.T) {
@@ -102,7 +102,7 @@ func TestNewSchemaWatcher(t *testing.T) {
 		}
 		got, err := NewSchemaWatcher(ctx, config)
 		require.Error(t, err)
-		assert.EqualError(t, err, "leaser config should only be present when cache config also present")
+		require.EqualError(t, err, "leaser config should only be present when cache config also present")
 		assert.Nil(t, got)
 	})
 	t.Run("successfully create schema watcher with default polling period", func(t *testing.T) {
@@ -208,7 +208,7 @@ func TestSchemaWatcher_FindExtensionByName(t *testing.T) {
 	}
 	got, err := schemaWatcher.FindExtensionByName("foo.bar.xt")
 	require.NoError(t, err)
-	assert.Equal(t, "foo.bar.xt", string(got.TypeDescriptor().FullName()))
+	require.Equal(t, "foo.bar.xt", string(got.TypeDescriptor().FullName()))
 }
 
 func TestSchemaWatcher_FindExtensionByNumber(t *testing.T) {
@@ -220,7 +220,7 @@ func TestSchemaWatcher_FindExtensionByNumber(t *testing.T) {
 	}
 	got, err := schemaWatcher.FindExtensionByNumber("foo.bar.Message", protowire.Number(123))
 	require.NoError(t, err)
-	assert.Equal(t, "foo.bar.xt", string(got.TypeDescriptor().FullName()))
+	require.Equal(t, "foo.bar.xt", string(got.TypeDescriptor().FullName()))
 }
 
 func TestSchemaWatcher_FindMessageByName(t *testing.T) {
@@ -232,7 +232,7 @@ func TestSchemaWatcher_FindMessageByName(t *testing.T) {
 	}
 	got, err := schemaWatcher.FindMessageByName("foo.bar.Message")
 	require.NoError(t, err)
-	assert.Equal(t, "foo.bar.Message", string(got.Descriptor().FullName()))
+	require.Equal(t, "foo.bar.Message", string(got.Descriptor().FullName()))
 }
 
 func TestSchemaWatcher_FindMessageByURL(t *testing.T) {
@@ -244,15 +244,15 @@ func TestSchemaWatcher_FindMessageByURL(t *testing.T) {
 	}
 	got, err := schemaWatcher.FindMessageByURL("foo.bar.Message")
 	require.NoError(t, err)
-	assert.Equal(t, "foo.bar.Message", string(got.Descriptor().FullName()))
+	require.Equal(t, "foo.bar.Message", string(got.Descriptor().FullName()))
 }
 
 func TestSchemaWatcher_getResolver(t *testing.T) {
 	t.Parallel()
 	want := &resolver{}
 	schemaWatcher := &SchemaWatcher{resolver: want}
 	assert.True(t, schemaWatcher.resolverMu.TryRLock())
-	assert.Equal(t, want, schemaWatcher.getResolver())
+	require.Equal(t, want, schemaWatcher.getResolver())
 	assert.True(t, schemaWatcher.resolverMu.TryRLock())
 }
 
@@ -281,20 +281,20 @@ func TestSchemaWatcher_updateResolver(t *testing.T) {
 		require.NoError(t, schemaWatcher.updateResolver(context.Background()))
 		got, err := schemaWatcher.resolver.FindMessageByName("foo.bar.Message")
 		require.NoError(t, err)
-		assert.Equal(t, "foo.bar.Message", string(got.Descriptor().FullName()))
+		require.Equal(t, "foo.bar.Message", string(got.Descriptor().FullName()))
 	})
 	t.Run("updateResolver fails", func(t *testing.T) {
 		t.Parallel()
 		schemaWatcher := &SchemaWatcher{
 			poller: NewSchemaPoller(&fakeFileDescriptorSetService{
 				getFileDescriptorSetFunc: func(context.Context, *connect.Request[reflectv1beta1.GetFileDescriptorSetRequest]) (*connect.Response[reflectv1beta1.GetFileDescriptorSetResponse], error) {
-					return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("foo"))
+					return nil, connect.NewError(connect.CodeInternal, errors.New("foo"))
 				},
 			}, "", ""),
 		}
 		err := schemaWatcher.updateResolver(context.Background())
 		require.Error(t, err)
-		assert.EqualError(t, err, "failed to fetch schema: internal: foo")
+		require.EqualError(t, err, "failed to fetch schema: internal: foo")
 	})
 	t.Run("updateResolver fails", func(t *testing.T) {
 		t.Parallel()
@@ -364,7 +364,7 @@ func TestSchemaWatcher_AwaitReady(t *testing.T) {
 		defer cancel()
 		err = watcher.AwaitReady(timeoutCtx)
 		require.Error(t, err)
-		require.True(t, errors.Is(err, context.DeadlineExceeded))
+		require.ErrorIs(t, err, context.DeadlineExceeded)
 		ok, _ := watcher.LastResolved()
 		require.False(t, ok)
 		require.Nil(t, watcher.ResolvedSchema())
@@ -405,7 +405,7 @@ func TestSchemaWatcher_AwaitReady(t *testing.T) {
 		// download should have failed at least once so this should be the RPC error
 		require.Error(t, err)
 		var connErr *connect.Error
-		require.True(t, errors.As(err, &connErr))
+		require.ErrorAs(t, err, &connErr)
 		require.Equal(t, connect.CodeUnavailable, connErr.Code())
 		ok, _ := watcher.LastResolved()
 		require.False(t, ok)
@@ -436,7 +436,7 @@ func TestSchemaWatcher_AwaitReady(t *testing.T) {
 		watcher.Stop()
 		err = watcher.AwaitReady(ctx)
 		require.Error(t, err)
-		require.True(t, errors.Is(err, ErrSchemaWatcherStopped))
+		require.ErrorIs(t, err, ErrSchemaWatcherStopped)
 	})
 }
 
@@ -476,12 +476,12 @@ func TestSchemaWatcher_UsingCache(t *testing.T) {
 		require.GreaterOrEqual(t, len(loads), 1) // racing w/ retry so could be >1
 		require.Equal(t, "foo/bar:main", loads[0].key)
 		saves := cache.getSaveCalls()
-		require.Equal(t, 0, len(saves))
+		require.Empty(t, saves)
 
 		// schema watcher cannot become ready if service unavailable and cache has no entry
 		_, err = watcher.FindMessageByName("foo.bar.Message")
 		require.Error(t, err)
-		require.True(t, errors.Is(err, ErrSchemaWatcherNotReady))
+		require.ErrorIs(t, err, ErrSchemaWatcherNotReady)
 		ok, _ := watcher.LastResolved()
 		require.False(t, ok)
 	})
@@ -509,10 +509,10 @@ func TestSchemaWatcher_UsingCache(t *testing.T) {
 		err = watcher.AwaitReady(readyCtx)
 		require.NoError(t, err)
 		loads := cache.getLoadCalls()
-		require.Equal(t, 1, len(loads))
+		require.Len(t, loads, 1)
 		require.Equal(t, "foo/bar:main", loads[0].key)
 		saves := cache.getSaveCalls()
-		require.Equal(t, 1, len(saves)) // just one call to seed cache above
+		require.Len(t, saves, 1) // just one call to seed cache above
 
 		_, err = watcher.FindMessageByName("foo.bar.Message")
 		require.NoError(t, err)
@@ -547,7 +547,7 @@ func TestSchemaWatcher_UsingCache(t *testing.T) {
 		case <-saveHookChan:
 		}
 		saves := cache.getSaveCalls()
-		require.Equal(t, 1, len(saves))
+		require.Len(t, saves, 1)
 
 		readyCtx, cancel := context.WithTimeout(ctx, time.Second)
 		defer cancel()
@@ -626,7 +626,7 @@ func TestSchemaWatcher_UsingLeaser(t *testing.T) {
 
 	// One cache load for each follower
 	loads := cache.getLoadCalls()
-	require.Equal(t, 3, len(loads))
+	require.Len(t, loads, 3)
 }
 
 func TestSchemaWatcher_callbacks(t *testing.T) {