mirror of
https://github.com/protocolbuffers/protobuf-go.git
synced 2025-01-06 00:55:51 +00:00
095e462e1c
Package protoregistry provides data structures to register and lookup
protobuf descriptor types.
High-level API:
var GlobalFiles = new(Files)
var NotFound = errors.New("not found")
type Files struct{ ... }
func NewFiles(...pref.FileDescriptor) *Files
func (*Files) Register(...pref.FileDescriptor) error
func (*Files) FindDescriptorByName(pref.FullName) (pref.Descriptor, error)
func (*Files) RangeFiles(func(pref.FileDescriptor) bool)
func (*Files) RangeFilesByPackage(pref.FullName, func(pref.FileDescriptor) bool)
func (*Files) RangeFilesByPath(string, func(pref.FileDescriptor) bool)
To support the FindDescriptorByName method, we add a DescriptorByName to
protoreflect.FileDescriptor and associated logic to prototype.
Change-Id: I14d65f74d2bd9f4f48641da9dfa70190310e5878
Reviewed-on: https://go-review.googlesource.com/129499
Reviewed-by: Damien Neil <dneil@google.com>
314 lines
8.7 KiB
Go
314 lines
8.7 KiB
Go
// Copyright 2018 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package protoregistry
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/google/go-cmp/cmp"
|
|
"github.com/google/go-cmp/cmp/cmpopts"
|
|
|
|
pref "google.golang.org/proto/reflect/protoreflect"
|
|
ptype "google.golang.org/proto/reflect/prototype"
|
|
)
|
|
|
|
func TestFiles(t *testing.T) {
|
|
type (
|
|
file struct {
|
|
Path string
|
|
Pkg pref.FullName
|
|
}
|
|
testFile struct {
|
|
inFile *ptype.File
|
|
wantErr string
|
|
}
|
|
testFindDesc struct {
|
|
inName pref.FullName
|
|
wantOk bool
|
|
}
|
|
testRangePkg struct {
|
|
inPkg pref.FullName
|
|
wantFiles []file
|
|
}
|
|
testRangePath struct {
|
|
inPath string
|
|
wantFiles []file
|
|
}
|
|
)
|
|
|
|
tests := []struct {
|
|
files []testFile
|
|
findDescs []testFindDesc
|
|
rangePkgs []testRangePkg
|
|
rangePaths []testRangePath
|
|
}{{
|
|
// Test that overlapping packages and files are permitted.
|
|
files: []testFile{
|
|
{inFile: &ptype.File{Syntax: pref.Proto2, Package: "foo.bar"}},
|
|
{inFile: &ptype.File{Syntax: pref.Proto2, Path: "foo/bar/test.proto", Package: "my.test"}},
|
|
{inFile: &ptype.File{Syntax: pref.Proto2, Path: "foo/bar/test.proto", Package: "foo.bar.baz"}},
|
|
{inFile: &ptype.File{Syntax: pref.Proto2, Package: "my.test.package"}},
|
|
{inFile: &ptype.File{Syntax: pref.Proto2, Package: "foo.bar"}},
|
|
{inFile: &ptype.File{Syntax: pref.Proto2, Path: "foo/bar/baz/../test.proto", Package: "my.test"}},
|
|
},
|
|
|
|
rangePkgs: []testRangePkg{{
|
|
inPkg: "nothing",
|
|
}, {
|
|
inPkg: "",
|
|
wantFiles: []file{
|
|
{"", "foo.bar"},
|
|
{"", "foo.bar"},
|
|
{"foo/bar/test.proto", "foo.bar.baz"},
|
|
{"foo/bar/test.proto", "my.test"},
|
|
{"", "my.test.package"},
|
|
{"foo/bar/baz/../test.proto", "my.test"},
|
|
},
|
|
}, {
|
|
inPkg: ".",
|
|
}, {
|
|
inPkg: "foo",
|
|
wantFiles: []file{
|
|
{"", "foo.bar"},
|
|
{"", "foo.bar"},
|
|
{"foo/bar/test.proto", "foo.bar.baz"},
|
|
},
|
|
}, {
|
|
inPkg: "foo.",
|
|
}, {
|
|
inPkg: "foo..",
|
|
}, {
|
|
inPkg: "foo.bar.baz",
|
|
wantFiles: []file{
|
|
{"foo/bar/test.proto", "foo.bar.baz"},
|
|
},
|
|
}, {
|
|
inPkg: "fo",
|
|
}},
|
|
|
|
rangePaths: []testRangePath{{
|
|
inPath: "nothing",
|
|
}, {
|
|
inPath: "",
|
|
wantFiles: []file{
|
|
{"", "foo.bar"},
|
|
{"", "foo.bar"},
|
|
{"", "my.test.package"},
|
|
},
|
|
}, {
|
|
inPath: "foo/bar/test.proto",
|
|
wantFiles: []file{
|
|
{"foo/bar/test.proto", "foo.bar.baz"},
|
|
{"foo/bar/test.proto", "my.test"},
|
|
},
|
|
}},
|
|
}, {
|
|
// Test when new enum conflicts with existing package.
|
|
files: []testFile{{
|
|
inFile: &ptype.File{Syntax: pref.Proto2, Path: "test1a.proto", Package: "foo.bar.baz"},
|
|
}, {
|
|
inFile: &ptype.File{Syntax: pref.Proto2, Path: "test1b.proto", Enums: []ptype.Enum{{Name: "foo"}}},
|
|
wantErr: `file "test1b.proto" has a name conflict over foo`,
|
|
}},
|
|
}, {
|
|
// Test when new package conflicts with existing enum.
|
|
files: []testFile{{
|
|
inFile: &ptype.File{Syntax: pref.Proto2, Path: "test2a.proto", Enums: []ptype.Enum{{Name: "foo"}}},
|
|
}, {
|
|
inFile: &ptype.File{Syntax: pref.Proto2, Path: "test2b.proto", Package: "foo.bar.baz"},
|
|
wantErr: `file "test2b.proto" has a name conflict over foo`,
|
|
}},
|
|
}, {
|
|
// Test when new enum conflicts with existing enum in same package.
|
|
files: []testFile{{
|
|
inFile: &ptype.File{Syntax: pref.Proto2, Path: "test3a.proto", Package: "foo", Enums: []ptype.Enum{{Name: "BAR"}}},
|
|
}, {
|
|
inFile: &ptype.File{Syntax: pref.Proto2, Path: "test3b.proto", Package: "foo", Enums: []ptype.Enum{{Name: "BAR"}}},
|
|
wantErr: `file "test3b.proto" has a name conflict over foo.BAR`,
|
|
}},
|
|
}, {
|
|
files: []testFile{{
|
|
inFile: &ptype.File{
|
|
Syntax: pref.Proto2,
|
|
Package: "fizz.buzz",
|
|
Messages: []ptype.Message{{
|
|
Name: "Message",
|
|
Fields: []ptype.Field{{
|
|
Name: "Field",
|
|
Number: 1,
|
|
Cardinality: pref.Optional,
|
|
Kind: pref.StringKind,
|
|
OneofName: "Oneof",
|
|
}},
|
|
Oneofs: []ptype.Oneof{{Name: "Oneof"}},
|
|
ExtensionRanges: [][2]pref.FieldNumber{{1000, 2000}},
|
|
}},
|
|
Enums: []ptype.Enum{{
|
|
Name: "Enum",
|
|
Values: []ptype.EnumValue{{Name: "EnumValue", Number: 0}},
|
|
}},
|
|
Extensions: []ptype.Extension{{
|
|
Name: "Extension",
|
|
Number: 1000,
|
|
Cardinality: pref.Optional,
|
|
Kind: pref.StringKind,
|
|
ExtendedType: ptype.PlaceholderMessage("fizz.buzz.Message"),
|
|
}},
|
|
Services: []ptype.Service{{
|
|
Name: "Service",
|
|
Methods: []ptype.Method{{
|
|
Name: "Method",
|
|
InputType: ptype.PlaceholderMessage("fizz.buzz.Message"),
|
|
OutputType: ptype.PlaceholderMessage("fizz.buzz.Message"),
|
|
IsStreamingClient: true,
|
|
IsStreamingServer: true,
|
|
}},
|
|
}},
|
|
},
|
|
}, {
|
|
inFile: &ptype.File{
|
|
Syntax: pref.Proto2,
|
|
Package: "fizz.buzz.gazz",
|
|
Enums: []ptype.Enum{{
|
|
Name: "Enum",
|
|
Values: []ptype.EnumValue{{Name: "EnumValue", Number: 0}},
|
|
}},
|
|
},
|
|
}, {
|
|
// Conflict over a single declaration.
|
|
inFile: &ptype.File{
|
|
Syntax: pref.Proto2,
|
|
Package: "fizz.buzz",
|
|
Enums: []ptype.Enum{{
|
|
Name: "Enum1",
|
|
Values: []ptype.EnumValue{{Name: "EnumValue1", Number: 0}},
|
|
}, {
|
|
Name: "Enum2",
|
|
Values: []ptype.EnumValue{{Name: "EnumValue2", Number: 0}},
|
|
}, {
|
|
Name: "Enum3",
|
|
Values: []ptype.EnumValue{{Name: "Enum", Number: 0}}, // conflict
|
|
}},
|
|
},
|
|
wantErr: "name conflict over fizz.buzz.Enum",
|
|
}, {
|
|
// Previously failed registration should not pollute the namespace.
|
|
inFile: &ptype.File{
|
|
Syntax: pref.Proto2,
|
|
Package: "fizz.buzz",
|
|
Enums: []ptype.Enum{{
|
|
Name: "Enum1",
|
|
Values: []ptype.EnumValue{{Name: "EnumValue1", Number: 0}},
|
|
}, {
|
|
Name: "Enum2",
|
|
Values: []ptype.EnumValue{{Name: "EnumValue2", Number: 0}},
|
|
}},
|
|
},
|
|
}, {
|
|
// Make sure we can register without package name.
|
|
inFile: &ptype.File{
|
|
Syntax: pref.Proto2,
|
|
Messages: []ptype.Message{{
|
|
Name: "Message",
|
|
Messages: []ptype.Message{{
|
|
Name: "Message",
|
|
Messages: []ptype.Message{{
|
|
Name: "Message",
|
|
}},
|
|
}},
|
|
}},
|
|
},
|
|
}},
|
|
|
|
findDescs: []testFindDesc{
|
|
{"", false},
|
|
{"Enum", false},
|
|
{"Message", true},
|
|
{"Message.", false},
|
|
{"Message.Message", true},
|
|
{"Message.Message.Message", true},
|
|
{"Message.Message.Message.Message", false},
|
|
{"fizz.buzz", false},
|
|
{"fizz.buzz.Enum", true},
|
|
{"fizz.buzz.Enum1", true},
|
|
{"fizz.buzz.Enum1.EnumValue", false},
|
|
{"fizz.buzz.EnumValue", true},
|
|
{"fizz.buzz.Message", true},
|
|
{"fizz.buzz.Message.Field", true},
|
|
{"fizz.buzz.Message.Oneof", true},
|
|
{"fizz.buzz.Extension", true},
|
|
{"fizz.buzz.Service", true},
|
|
{"fizz.buzz.Service.Method", true},
|
|
{"fizz.buzz.Method", false},
|
|
},
|
|
}}
|
|
|
|
sortFiles := cmpopts.SortSlices(func(x, y file) bool {
|
|
return x.Path < y.Path || (x.Path == y.Path && x.Pkg < y.Pkg)
|
|
})
|
|
for _, tt := range tests {
|
|
t.Run("", func(t *testing.T) {
|
|
var files Files
|
|
for i, tc := range tt.files {
|
|
fd, err := ptype.NewFile(tc.inFile)
|
|
if err != nil {
|
|
t.Fatalf("file %d, prototype.NewFile() error: %v", i, err)
|
|
}
|
|
gotErr := files.Register(fd)
|
|
if (gotErr == nil && tc.wantErr != "") || !strings.Contains(fmt.Sprint(gotErr), tc.wantErr) {
|
|
t.Errorf("file %d, Register() = %v, want %v", i, gotErr, tc.wantErr)
|
|
}
|
|
}
|
|
|
|
for _, tc := range tt.findDescs {
|
|
got, err := files.FindDescriptorByName(tc.inName)
|
|
if (got == nil) == (err == nil) {
|
|
if tc.wantOk {
|
|
t.Errorf("FindDescriptorByName(%v) = (%v, %v), want (non-nil, nil)", tc.inName, got, err)
|
|
} else {
|
|
t.Errorf("FindDescriptorByName(%v) = (%v, %v), want (nil, NotFound)", tc.inName, got, err)
|
|
}
|
|
}
|
|
|
|
gotName := pref.FullName("<nil>")
|
|
if got != nil {
|
|
gotName = got.FullName()
|
|
}
|
|
wantName := pref.FullName("<nil>")
|
|
if tc.wantOk {
|
|
wantName = tc.inName
|
|
}
|
|
if gotName != wantName {
|
|
t.Errorf("FindDescriptorByName(%v) = %v, want %v", tc.inName, gotName, wantName)
|
|
}
|
|
}
|
|
|
|
for _, tc := range tt.rangePkgs {
|
|
var gotFiles []file
|
|
files.RangeFilesByPackage(tc.inPkg, func(fd pref.FileDescriptor) bool {
|
|
gotFiles = append(gotFiles, file{fd.Path(), fd.Package()})
|
|
return true
|
|
})
|
|
if diff := cmp.Diff(tc.wantFiles, gotFiles, sortFiles); diff != "" {
|
|
t.Errorf("RangeFilesByPackage(%v) mismatch (-want +got):\n%v", tc.inPkg, diff)
|
|
}
|
|
}
|
|
|
|
for _, tc := range tt.rangePaths {
|
|
var gotFiles []file
|
|
files.RangeFilesByPath(tc.inPath, func(fd pref.FileDescriptor) bool {
|
|
gotFiles = append(gotFiles, file{fd.Path(), fd.Package()})
|
|
return true
|
|
})
|
|
if diff := cmp.Diff(tc.wantFiles, gotFiles, sortFiles); diff != "" {
|
|
t.Errorf("RangeFilesByPath(%v) mismatch (-want +got):\n%v", tc.inPath, diff)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|