Fix test files to work without jhump/protoreflect

Created testutils helpers for lint package tests and fixed all test files
to use the new Google protobuf library:

- Added lint/testutils_test.go with builder-style helpers for test proto creation
- Fixed lint test files to use new testutils (rule_test.go, rule_enabled_test.go, problem_test.go)
- Updated rules/internal/testutils/problems_test.go to use ParseProto3String
- Added timestamp import to support well-known types in tests
- Fixed common_lints_test.go and resource_test.go to use descriptorpb types
- Added WithStandardImports to protocompile for well-known types support
- Partially implemented registry resolver for aep/api and google/api imports

Test status:
- lint package: all tests pass
- rules/internal/testutils: all tests pass
- rules/internal/utils: build error (registry resolver needs completion)
- Other rule packages: need registry resolver to be completed

The registry resolver implementation is in progress to handle imports of
aep/api/* and google/api/* proto files that are registered but not available
as source files.

Author: claude

internal/protoparse/parser.go

@@ -28,6 +28,7 @@ import (
 	"github.com/bufbuild/protocompile"
 	"github.com/bufbuild/protocompile/reporter"
 	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
 )
 
 // ErrorWithPos represents a parse error with position information.
@@ -87,17 +88,35 @@ func (m mapAccessor) Open(filename string) (io.ReadCloser, error) {
 
 // ParseFiles parses the given proto files.
 func (p *Parser) ParseFiles(filenames ...string) ([]*desc.FileDescriptor, error) {
-	resolver := protocompile.SourceResolver{
+	resolver := &protocompile.SourceResolver{
 		ImportPaths: p.ImportPaths,
 	}
 
 	if p.Accessor != nil {
-		adapter := &accessorAdapter{accessor: p.Accessor, importPaths: p.ImportPaths}
+		adapter := &accessorAdapter{accessor: p.Accessor, importPaths: p.ImportPaths, lookupImport: p.LookupImport}
 		resolver.Accessor = adapter.Open
 	}
 
+	// Wrap resolver with standard imports (well-known types)
+	resolverWithStdImports := protocompile.WithStandardImports(resolver)
+
+	// Create a composite resolver that checks the global registry first
+	compositeResolver := protocompile.CompositeResolver{
+		protocompile.ResolverFunc(func(path string) (protocompile.SearchResult, error) {
+			// Try to find in global registry
+			fd, err := protoregistry.GlobalFiles.FindFileByPath(path)
+			if err == nil {
+				// Found in registry, return it
+				return &registrySearchResult{fd: fd}, nil
+			}
+			// Not in registry, fall through to next resolver
+			return nil, fs.ErrNotExist
+		}),
+		resolverWithStdImports,
+	}
+
 	compiler := &protocompile.Compiler{
-		Resolver:       &resolver,
+		Resolver:       compositeResolver,
 		SourceInfoMode: protocompile.SourceInfoStandard,
 	}
 
@@ -138,8 +157,9 @@ func (er *errorReporter) Warning(reporter.ErrorWithPos) {
 }
 
 type accessorAdapter struct {
-	accessor    FileAccessor
-	importPaths []string
+	accessor     FileAccessor
+	importPaths  []string
+	lookupImport func(string) (*desc.FileDescriptor, error)
 }
 
 func (a *accessorAdapter) Open(path string) (io.ReadCloser, error) {
@@ -156,10 +176,32 @@ func (a *accessorAdapter) Open(path string) (io.ReadCloser, error) {
 		}
 	}
 
+	// Try lookup import (for well-known types)
+	if a.lookupImport != nil {
+		if fd, err := a.lookupImport(path); err == nil {
+			// Convert the FileDescriptor to a proto and return it as a reader
+			proto := fd.AsProto()
+			// Note: protocompile needs the source, but we have the compiled descriptor.
+			// This won't work for source info. For well-known types, we'll skip them
+			// by returning an error and let protocompile use its built-in resolution.
+			_ = proto
+			// Fall through to filesystem
+		}
+	}
+
 	// Fall back to file system
 	return os.Open(path)
 }
 
+// registrySearchResult implements protocompile.SearchResult for registry lookups.
+type registrySearchResult struct {
+	fd protoreflect.FileDescriptor
+}
+
+func (r *registrySearchResult) Desc() protoreflect.FileDescriptor {
+	return r.fd
+}
+
 // ResolveFilenames resolves file paths relative to import paths.
 func ResolveFilenames(importPaths []string, filenames ...string) ([]string, error) {
 	resolved := make([]string, len(filenames))

lint/problem_test.go

@@ -84,12 +84,12 @@ func TestProblemYAML(t *testing.T) {
 
 func TestProblemDescriptor(t *testing.T) {
 	mb := testutils.NewMessage(t, "Foo")
-	testutils.NewFile(t, "foo.proto").AddMessage(mb)
-
-	m, err := mb.Build()
+	fd, err := testutils.NewFile(t, "foo.proto").AddMessage(mb).Build()
 	if err != nil {
 		t.Fatalf("%v", err)
 	}
+
+	m := fd.GetMessageTypes()[0]
 	m.GetSourceInfo().Span = []int32{42, 0, 79}
 	problem := &Problem{
 		Message:    "foo bar",

lint/rule_enabled_test.go

@@ -70,10 +70,10 @@ func TestRuleIsEnabled(t *testing.T) {
 	// Run the specific tests individually.
 	for _, test := range tests {
 		t.Run(test.testName, func(t *testing.T) {
-			f, err := testutils.NewFile(t, "test.proto").SetSyntaxComments(builder.Comments{
+			f, err := testutils.NewFile(t, "test.proto").SetSyntaxComments(Comments{
 				LeadingComment: test.fileComment,
 			}).AddMessage(
-				testutils.NewMessage(t, "MyMessage").SetComments(builder.Comments{
+				testutils.NewMessage(t, "MyMessage").SetComments(Comments{
 					LeadingComment: test.messageComment,
 				}),
 			).Build()
@@ -93,10 +93,10 @@ func TestRuleIsEnabled(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(fmt.Sprintf("MustRule/%s", test.testName), func(t *testing.T) {
-			f, err := testutils.NewFile(t, "test.proto").SetSyntaxComments(builder.Comments{
+			f, err := testutils.NewFile(t, "test.proto").SetSyntaxComments(Comments{
 				LeadingComment: test.fileComment,
 			}).AddMessage(
-				testutils.NewMessage(t, "MyMessage").SetComments(builder.Comments{
+				testutils.NewMessage(t, "MyMessage").SetComments(Comments{
 					LeadingComment: test.messageComment,
 				}),
 			).Build()
@@ -121,7 +121,7 @@ func TestRuleIsEnabledFirstMessage(t *testing.T) {
 
 	// Build a proto and check that ruleIsEnabled does the right thing.
 	f, err := testutils.NewFile(t, "test.proto").AddMessage(
-		testutils.NewMessage(t, "FirstMessage").SetComments(builder.Comments{
+		testutils.NewMessage(t, "FirstMessage").SetComments(Comments{
 			LeadingComment: "api-linter: test=disabled",
 		}),
 	).AddMessage(
@@ -149,11 +149,11 @@ func TestRuleIsEnabledParent(t *testing.T) {
 
 	// Build a proto with two messages, one of which disables the rule.
 	f, err := testutils.NewFile(t, "test.proto").AddMessage(
-		testutils.NewMessage(t, "Foo").SetComments(builder.Comments{
+		testutils.NewMessage(t, "Foo").SetComments(Comments{
 			LeadingComment: "api-linter: test=disabled",
-		}).AddField(/* field: "foo", testutils.FieldTypeBool( */)),
+		}).AddField(newField("foo", "bool", 1)),
 	).AddMessage(
-		testutils.NewMessage(t, "Bar").AddField(/* field: "bar", testutils.FieldTypeBool( */)),
+		testutils.NewMessage(t, "Bar").AddField(newField("bar", "bool", 1)),
 	).Build()
 	if err != nil {
 		t.Fatalf("Error building test file: %q", err)
@@ -191,7 +191,7 @@ func TestRuleIsEnabledDeprecated(t *testing.T) {
 			f, err := testutils.NewFile(t, "test.proto").AddMessage(
 				testutils.NewMessage(t, "Foo").SetOptions(&dpb.MessageOptions{
 					Deprecated: &test.msgDeprecated,
-				}).AddField(/* field: "bar", testutils.FieldTypeBool( */).SetOptions(
+				}).AddField(newField("bar", "bool", 1).SetOptions(
 					&dpb.FieldOptions{Deprecated: &test.fieldDeprecated},
 				)),
 			).Build()

lint/rule_test.go

@@ -113,9 +113,9 @@ func TestFieldRule(t *testing.T) {
 	// Create a file descriptor with one message and two fields in that message.
 	fd, err := testutils.NewFile(t, "test.proto").AddMessage(
 		testutils.NewMessage(t, "Book").AddField(
-			/* field: "title", testutils.FieldTypeString( */),
+			newField("title", "string", 1),
 		).AddField(
-			/* field: "edition_count", testutils.FieldTypeInt32( */),
+			newField("edition_count", "int32", 2),
 		),
 	).Build()
 	if err != nil {
@@ -170,19 +170,22 @@ func TestServiceRule(t *testing.T) {
 
 func TestMethodRule(t *testing.T) {
 	// Create a file descriptor with a service.
-	book := builder.RpcTypeMessage(testutils.NewMessage(t, "Book"), false)
-	fd, err := testutils.NewFile(t, "test.proto").AddService(
+	book := testutils.NewMessage(t, "Book")
+	getBookRequest := testutils.NewMessage(t, "GetBookRequest")
+	createBookRequest := testutils.NewMessage(t, "CreateBookRequest")
+
+	fd, err := testutils.NewFile(t, "test.proto").AddMessage(book).AddMessage(getBookRequest).AddMessage(createBookRequest).AddService(
 		builder.NewService("Library").AddMethod(
 			builder.NewMethod(
 				"GetBook",
-				builder.RpcTypeMessage(testutils.NewMessage(t, "GetBookRequest"), false),
-				book,
+				builder.RpcTypeMessage(getBookRequest, false),
+				builder.RpcTypeMessage(book, false),
 			),
 		).AddMethod(
 			builder.NewMethod(
 				"CreateBook",
-				builder.RpcTypeMessage(testutils.NewMessage(t, "CreateBookRequest"), false),
-				book,
+				builder.RpcTypeMessage(createBookRequest, false),
+				builder.RpcTypeMessage(book, false),
 			),
 		),
 	).Build()
@@ -213,9 +216,9 @@ func TestMethodRule(t *testing.T) {
 func TestEnumRule(t *testing.T) {
 	// Create a file descriptor with top-level enums.
 	fd, err := testutils.NewFile(t, "test.proto").AddEnum(
-		/* enum: "Format" */.AddValue(/* enum_value: "PDF" */),
+		newEnum("Format").AddValue(newEnumValue("PDF", 0)),
 	).AddEnum(
-		/* enum: "Edition" */.AddValue(/* enum_value: "PUBLISHER_ONLY" */),
+		newEnum("Edition").AddValue(newEnumValue("PUBLISHER_ONLY", 0)),
 	).Build()
 	if err != nil {
 		t.Fatalf("Error building test proto:%s ", err)
@@ -243,7 +246,7 @@ func TestEnumRule(t *testing.T) {
 func TestEnumValueRule(t *testing.T) {
 	// Create a file descriptor with a top-level enum with values.
 	fd, err := testutils.NewFile(t, "test.proto").AddEnum(
-		/* enum: "Format" */.AddValue(/* enum_value: "YAML" */).AddValue(/* enum_value: "JSON" */),
+		newEnum("Format").AddValue(newEnumValue("YAML", 0)).AddValue(newEnumValue("JSON", 1)),
 	).Build()
 	if err != nil {
 		t.Fatalf("Error building test proto:%s ", err)
@@ -272,9 +275,9 @@ func TestEnumRuleNested(t *testing.T) {
 	// Create a file descriptor with top-level enums.
 	fd, err := testutils.NewFile(t, "test.proto").AddMessage(
 		testutils.NewMessage(t, "Book").AddNestedEnum(
-			/* enum: "Format" */.AddValue(/* enum_value: "PDF" */),
+			newEnum("Format").AddValue(newEnumValue("PDF", 0)),
 		).AddNestedEnum(
-			/* enum: "Edition" */.AddValue(/* enum_value: "PUBLISHER_ONLY" */),
+			newEnum("Edition").AddValue(newEnumValue("PUBLISHER_ONLY", 0)),
 		),
 	).Build()
 	if err != nil {
@@ -303,10 +306,10 @@ func TestEnumRuleNested(t *testing.T) {
 func TestDescriptorRule(t *testing.T) {
 	// Create a file with one of everything in it.
 	book := testutils.NewMessage(t, "Book").AddNestedEnum(
-		/* enum: "Format" */.AddValue(
-			/* enum_value: "FORMAT_UNSPECIFIED" */,
-		).AddValue(/* enum_value: "PAPERBACK" */),
-	).AddField(/* field: "name", testutils.FieldTypeString( */)).AddNestedMessage(
+		newEnum("Format").AddValue(
+			newEnumValue("FORMAT_UNSPECIFIED", 0),
+		).AddValue(newEnumValue("PAPERBACK", 1)),
+	).AddField(newField("name", "string", 1)).AddNestedMessage(
 		testutils.NewMessage(t, "Author"),
 	)
 	fd, err := testutils.NewFile(t, "library.proto").AddMessage(book).AddService(
@@ -317,7 +320,7 @@ func TestDescriptorRule(t *testing.T) {
 				builder.RpcTypeMessage(book, false),
 			),
 		),
-	).AddEnum(/* enum: "State" */.AddValue(/* enum_value: "AVAILABLE" */)).Build()
+	).AddEnum(newEnum("State").AddValue(newEnumValue("AVAILABLE", 0))).Build()
 	if err != nil {
 		t.Fatalf("%v", err)
 	}