mirror of
https://github.com/protocolbuffers/protobuf-go.git
synced 2025-01-29 00:32:43 +00:00
e4fcb9f7e7
The protopath package provides a means to programmatically represent
a sequence of protobuf reflection operations.
The protorange package traverses through a message and
calls a user-provided function as it iterates.
This feature sets the groundwork for the often requested feature
of being able to exclude certain fields when merging or serializing.
package protopath
type Path []Step
type Step struct{ ... }
func Root(protoreflect.MessageDescriptor) Step
func FieldAccess(protoreflect.FieldDescriptor) Step
func UnknownAccess() Step
func ListIndex(int) Step
func MapIndex(protoreflect.MapKey) Step
func AnyExpand(protoreflect.MessageDescriptor) Step
func (Step) Kind() StepKind
func (Step) FieldDescriptor() protoreflect.FieldDescriptor
func (Step) MessageDescriptor() protoreflect.MessageDescriptor
func (Step) ListIndex() int
func (Step) MapIndex() protoreflect.MapKey
func (Step) String() string
type StepKind int
const RootStep StepKind
const FieldAccessStep StepKind
const UnknownAccessStep StepKind
const ListIndexStep StepKind
const MapIndexStep StepKind
const AnyExpandStep StepKind
type Values struct {
Path Path
Values []protoreflect.Value
}
func (Values) Index(int) (out struct{ ... })
func (Values) Len() int
func (Values) String() string
package protorange
var Break error
var Terminate error
func Range(protoreflect.Message, func(protopath.Values) error) error
type Options struct {
Stable bool
Resolver interface { ... }
}
func (Options) Range(m protoreflect.Message, push, pop func(protopath.Values) error) error
Change-Id: I29cbd5142fe169d78367d54a95d37801888b64f4
Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/236540
Trust: Joe Tsai <joetsai@digital-static.net>
Reviewed-by: Damien Neil <dneil@google.com>
254 lines
8.3 KiB
Go
254 lines
8.3 KiB
Go
// Copyright 2020 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 protorange
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/google/go-cmp/cmp"
|
|
"github.com/google/go-cmp/cmp/cmpopts"
|
|
"google.golang.org/protobuf/proto"
|
|
"google.golang.org/protobuf/reflect/protopath"
|
|
"google.golang.org/protobuf/reflect/protoreflect"
|
|
"google.golang.org/protobuf/reflect/protoregistry"
|
|
"google.golang.org/protobuf/testing/protocmp"
|
|
|
|
newspb "google.golang.org/protobuf/internal/testprotos/news"
|
|
anypb "google.golang.org/protobuf/types/known/anypb"
|
|
timestamppb "google.golang.org/protobuf/types/known/timestamppb"
|
|
)
|
|
|
|
func mustMarshal(m proto.Message) []byte {
|
|
b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return b
|
|
}
|
|
|
|
var transformReflectValue = cmp.Transformer("", func(v protoreflect.Value) interface{} {
|
|
switch v := v.Interface().(type) {
|
|
case protoreflect.Message:
|
|
return v.Interface()
|
|
case protoreflect.Map:
|
|
ms := map[interface{}]protoreflect.Value{}
|
|
v.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
|
|
ms[k.Interface()] = v
|
|
return true
|
|
})
|
|
return ms
|
|
case protoreflect.List:
|
|
ls := []protoreflect.Value{}
|
|
for i := 0; i < v.Len(); i++ {
|
|
ls = append(ls, v.Get(i))
|
|
}
|
|
return ls
|
|
default:
|
|
return v
|
|
}
|
|
})
|
|
|
|
func TestRange(t *testing.T) {
|
|
m2 := (&newspb.KeyValueAttachment{
|
|
Name: "checksums.txt",
|
|
Data: map[string]string{
|
|
"go1.10.src.tar.gz": "07cbb9d0091b846c6aea40bf5bc0cea7",
|
|
"go1.10.darwin-amd64.pkg": "cbb38bb6ff6ea86279e01745984445bf",
|
|
"go1.10.linux-amd64.tar.gz": "6b3d0e4a5c77352cf4275573817f7566",
|
|
"go1.10.windows-amd64.msi": "57bda02030f58f5d2bf71943e1390123",
|
|
},
|
|
}).ProtoReflect()
|
|
m := (&newspb.Article{
|
|
Author: "Brad Fitzpatrick",
|
|
Date: timestamppb.New(time.Date(2018, time.February, 16, 0, 0, 0, 0, time.UTC)),
|
|
Title: "Go 1.10 is released",
|
|
Content: "Happy Friday, happy weekend! Today the Go team is happy to announce the release of Go 1.10...",
|
|
Status: newspb.Article_PUBLISHED,
|
|
Tags: []string{"go1.10", "release"},
|
|
Attachments: []*anypb.Any{{
|
|
TypeUrl: "google.golang.org.KeyValueAttachment",
|
|
Value: mustMarshal(m2.Interface()),
|
|
}},
|
|
}).ProtoReflect()
|
|
|
|
// Nil push and pop functions should not panic.
|
|
noop := func(protopath.Values) error { return nil }
|
|
Options{}.Range(m, nil, nil)
|
|
Options{}.Range(m, noop, nil)
|
|
Options{}.Range(m, nil, noop)
|
|
|
|
getByName := func(m protoreflect.Message, s protoreflect.Name) protoreflect.Value {
|
|
fds := m.Descriptor().Fields()
|
|
return m.Get(fds.ByName(s))
|
|
}
|
|
|
|
wantPaths := []string{
|
|
``,
|
|
`.author`,
|
|
`.date`,
|
|
`.date.seconds`,
|
|
`.title`,
|
|
`.content`,
|
|
`.attachments`,
|
|
`.attachments[0]`,
|
|
`.attachments[0].(google.golang.org.KeyValueAttachment)`,
|
|
`.attachments[0].(google.golang.org.KeyValueAttachment).name`,
|
|
`.attachments[0].(google.golang.org.KeyValueAttachment).data`,
|
|
`.attachments[0].(google.golang.org.KeyValueAttachment).data["go1.10.darwin-amd64.pkg"]`,
|
|
`.attachments[0].(google.golang.org.KeyValueAttachment).data["go1.10.linux-amd64.tar.gz"]`,
|
|
`.attachments[0].(google.golang.org.KeyValueAttachment).data["go1.10.src.tar.gz"]`,
|
|
`.attachments[0].(google.golang.org.KeyValueAttachment).data["go1.10.windows-amd64.msi"]`,
|
|
`.tags`,
|
|
`.tags[0]`,
|
|
`.tags[1]`,
|
|
`.status`,
|
|
}
|
|
wantValues := []protoreflect.Value{
|
|
protoreflect.ValueOfMessage(m),
|
|
getByName(m, "author"),
|
|
getByName(m, "date"),
|
|
getByName(getByName(m, "date").Message(), "seconds"),
|
|
getByName(m, `title`),
|
|
getByName(m, `content`),
|
|
getByName(m, `attachments`),
|
|
getByName(m, `attachments`).List().Get(0),
|
|
protoreflect.ValueOfMessage(m2),
|
|
getByName(m2, `name`),
|
|
getByName(m2, `data`),
|
|
getByName(m2, `data`).Map().Get(protoreflect.ValueOfString("go1.10.darwin-amd64.pkg").MapKey()),
|
|
getByName(m2, `data`).Map().Get(protoreflect.ValueOfString("go1.10.linux-amd64.tar.gz").MapKey()),
|
|
getByName(m2, `data`).Map().Get(protoreflect.ValueOfString("go1.10.src.tar.gz").MapKey()),
|
|
getByName(m2, `data`).Map().Get(protoreflect.ValueOfString("go1.10.windows-amd64.msi").MapKey()),
|
|
getByName(m, `tags`),
|
|
getByName(m, `tags`).List().Get(0),
|
|
getByName(m, `tags`).List().Get(1),
|
|
getByName(m, `status`),
|
|
}
|
|
|
|
tests := []struct {
|
|
resolver interface {
|
|
protoregistry.ExtensionTypeResolver
|
|
protoregistry.MessageTypeResolver
|
|
}
|
|
|
|
errorAt int
|
|
breakAt int
|
|
terminateAt int
|
|
|
|
wantPaths []string
|
|
wantValues []protoreflect.Value
|
|
wantError error
|
|
}{{
|
|
wantPaths: wantPaths,
|
|
wantValues: wantValues,
|
|
}, {
|
|
resolver: (*protoregistry.Types)(nil),
|
|
wantPaths: append(append(wantPaths[:8:8],
|
|
`.attachments[0].type_url`,
|
|
`.attachments[0].value`,
|
|
), wantPaths[15:]...),
|
|
wantValues: append(append(wantValues[:8:8],
|
|
protoreflect.ValueOfString("google.golang.org.KeyValueAttachment"),
|
|
protoreflect.ValueOfBytes(mustMarshal(m2.Interface())),
|
|
), wantValues[15:]...),
|
|
}, {
|
|
errorAt: 5, // return error within newspb.Article
|
|
wantPaths: wantPaths[:5],
|
|
wantValues: wantValues[:5],
|
|
wantError: cmpopts.AnyError,
|
|
}, {
|
|
terminateAt: 11, // terminate within newspb.KeyValueAttachment
|
|
wantPaths: wantPaths[:11],
|
|
wantValues: wantValues[:11],
|
|
}, {
|
|
breakAt: 11, // break within newspb.KeyValueAttachment
|
|
wantPaths: append(wantPaths[:11:11], wantPaths[15:]...),
|
|
wantValues: append(wantValues[:11:11], wantValues[15:]...),
|
|
}, {
|
|
errorAt: 17, // return error within newspb.Article.Tags
|
|
wantPaths: wantPaths[:17],
|
|
wantValues: wantValues[:17],
|
|
wantError: cmpopts.AnyError,
|
|
}, {
|
|
breakAt: 17, // break within newspb.Article.Tags
|
|
wantPaths: append(wantPaths[:17:17], wantPaths[18:]...),
|
|
wantValues: append(wantValues[:17:17], wantValues[18:]...),
|
|
}, {
|
|
terminateAt: 17, // terminate within newspb.Article.Tags
|
|
wantPaths: wantPaths[:17],
|
|
wantValues: wantValues[:17],
|
|
}, {
|
|
errorAt: 13, // return error within newspb.KeyValueAttachment.Data
|
|
wantPaths: wantPaths[:13],
|
|
wantValues: wantValues[:13],
|
|
wantError: cmpopts.AnyError,
|
|
}, {
|
|
breakAt: 13, // break within newspb.KeyValueAttachment.Data
|
|
wantPaths: append(wantPaths[:13:13], wantPaths[15:]...),
|
|
wantValues: append(wantValues[:13:13], wantValues[15:]...),
|
|
}, {
|
|
terminateAt: 13, // terminate within newspb.KeyValueAttachment.Data
|
|
wantPaths: wantPaths[:13],
|
|
wantValues: wantValues[:13],
|
|
}}
|
|
for _, tt := range tests {
|
|
t.Run("", func(t *testing.T) {
|
|
var gotPaths []string
|
|
var gotValues []protoreflect.Value
|
|
var stackPaths []string
|
|
var stackValues []protoreflect.Value
|
|
gotError := Options{
|
|
Stable: true,
|
|
Resolver: tt.resolver,
|
|
}.Range(m,
|
|
func(p protopath.Values) error {
|
|
gotPaths = append(gotPaths, p.Path[1:].String())
|
|
stackPaths = append(stackPaths, p.Path[1:].String())
|
|
gotValues = append(gotValues, p.Index(-1).Value)
|
|
stackValues = append(stackValues, p.Index(-1).Value)
|
|
switch {
|
|
case tt.errorAt > 0 && tt.errorAt == len(gotPaths):
|
|
return cmpopts.AnyError
|
|
case tt.breakAt > 0 && tt.breakAt == len(gotPaths):
|
|
return Break
|
|
case tt.terminateAt > 0 && tt.terminateAt == len(gotPaths):
|
|
return Terminate
|
|
default:
|
|
return nil
|
|
}
|
|
},
|
|
func(p protopath.Values) error {
|
|
gotPath := p.Path[1:].String()
|
|
wantPath := stackPaths[len(stackPaths)-1]
|
|
if wantPath != gotPath {
|
|
t.Errorf("%d: pop path mismatch: got %v, want %v", len(gotPaths), gotPath, wantPath)
|
|
}
|
|
gotValue := p.Index(-1).Value
|
|
wantValue := stackValues[len(stackValues)-1]
|
|
if diff := cmp.Diff(wantValue, gotValue, transformReflectValue, protocmp.Transform()); diff != "" {
|
|
t.Errorf("%d: pop value mismatch (-want +got):\n%v", len(gotValues), diff)
|
|
}
|
|
stackPaths = stackPaths[:len(stackPaths)-1]
|
|
stackValues = stackValues[:len(stackValues)-1]
|
|
return nil
|
|
},
|
|
)
|
|
if n := len(stackPaths) + len(stackValues); n > 0 {
|
|
t.Errorf("stack mismatch: got %d unpopped items", n)
|
|
}
|
|
if diff := cmp.Diff(tt.wantPaths, gotPaths); diff != "" {
|
|
t.Errorf("paths mismatch (-want +got):\n%s", diff)
|
|
}
|
|
if diff := cmp.Diff(tt.wantValues, gotValues, transformReflectValue, protocmp.Transform()); diff != "" {
|
|
t.Errorf("values mismatch (-want +got):\n%s", diff)
|
|
}
|
|
if !cmp.Equal(gotError, tt.wantError, cmpopts.EquateErrors()) {
|
|
t.Errorf("error mismatch: got %v, want %v", gotError, tt.wantError)
|
|
}
|
|
})
|
|
}
|
|
}
|