[FAB-4101] Proto translator nested msg component

The proto translation framework introduced in FAB-4100 needs to be
recursively applied to sub-messages within proto messages.

This CR adds a nested proto msg handler to the proto translation
framework.

Change-Id: Ib992908c431a1c5fe376b44070dec32a4b675675
Signed-off-by: Jason Yellick <jyellick@us.ibm.com>

Author: Jason Yellick

common/tools/protolator/json.go

@@ -54,6 +54,11 @@ type protoField interface {
 	PopulateTo() (interface{}, error)
 }
 
+var (
+	protoMsgType           = reflect.TypeOf((*proto.Message)(nil)).Elem()
+	mapStringInterfaceType = reflect.TypeOf(map[string]interface{}{})
+)
+
 type baseField struct {
 	msg   proto.Message
 	name  string
@@ -235,7 +240,11 @@ func jsonToMap(marshaled []byte) (map[string]interface{}, error) {
 // The factory implementations, listed in order of most greedy to least.
 // Factories listed lower, may depend on factories listed higher being
 // evaluated first.
-var fieldFactories = []protoFieldFactory{}
+var fieldFactories = []protoFieldFactory{
+	nestedSliceFieldFactory{},
+	nestedMapFieldFactory{},
+	nestedFieldFactory{},
+}
 
 func protoFields(msg proto.Message, uMsg proto.Message) ([]protoField, error) {
 	var result []protoField

common/tools/protolator/nested.go

@@ -0,0 +1,106 @@
+/*
+Copyright IBM Corp. 2017 All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+                 http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package protolator
+
+import (
+	"reflect"
+
+	"github.com/golang/protobuf/proto"
+)
+
+func nestedFrom(value interface{}, destType reflect.Type) (reflect.Value, error) {
+	tree := value.(map[string]interface{}) // Safe, already checked
+	result := reflect.New(destType.Elem())
+	nMsg := result.Interface().(proto.Message) // Safe, already checked
+	if err := recursivelyPopulateMessageFromTree(tree, nMsg); err != nil {
+		return reflect.Value{}, err
+	}
+	return result, nil
+}
+
+func nestedTo(value reflect.Value) (interface{}, error) {
+	nMsg := value.Interface().(proto.Message) // Safe, already checked
+	return recursivelyCreateTreeFromMessage(nMsg)
+}
+
+type nestedFieldFactory struct{}
+
+func (nff nestedFieldFactory) Handles(msg proto.Message, fieldName string, fieldType reflect.Type, fieldValue reflect.Value) bool {
+	return fieldType.Kind() == reflect.Ptr && fieldType.AssignableTo(protoMsgType)
+}
+
+func (nff nestedFieldFactory) NewProtoField(msg proto.Message, fieldName string, fieldType reflect.Type, fieldValue reflect.Value) (protoField, error) {
+	return &plainField{
+		baseField: baseField{
+			msg:   msg,
+			name:  fieldName,
+			fType: mapStringInterfaceType,
+			vType: fieldType,
+			value: fieldValue,
+		},
+		populateFrom: nestedFrom,
+		populateTo:   nestedTo,
+	}, nil
+}
+
+type nestedMapFieldFactory struct{}
+
+func (nmff nestedMapFieldFactory) Handles(msg proto.Message, fieldName string, fieldType reflect.Type, fieldValue reflect.Value) bool {
+	return fieldType.Kind() == reflect.Map && fieldType.Elem().AssignableTo(protoMsgType)
+}
+
+func (nmff nestedMapFieldFactory) NewProtoField(msg proto.Message, fieldName string, fieldType reflect.Type, fieldValue reflect.Value) (protoField, error) {
+	return &mapField{
+		baseField: baseField{
+			msg:   msg,
+			name:  fieldName,
+			fType: mapStringInterfaceType,
+			vType: fieldType,
+			value: fieldValue,
+		},
+		populateFrom: func(k string, v interface{}, dT reflect.Type) (reflect.Value, error) {
+			return nestedFrom(v, dT)
+		},
+		populateTo: func(k string, v reflect.Value) (interface{}, error) {
+			return nestedTo(v)
+		},
+	}, nil
+}
+
+type nestedSliceFieldFactory struct{}
+
+func (nmff nestedSliceFieldFactory) Handles(msg proto.Message, fieldName string, fieldType reflect.Type, fieldValue reflect.Value) bool {
+	return fieldType.Kind() == reflect.Slice && fieldType.Elem().AssignableTo(protoMsgType)
+}
+
+func (nmff nestedSliceFieldFactory) NewProtoField(msg proto.Message, fieldName string, fieldType reflect.Type, fieldValue reflect.Value) (protoField, error) {
+	return &sliceField{
+		baseField: baseField{
+			msg:   msg,
+			name:  fieldName,
+			fType: mapStringInterfaceType,
+			vType: fieldType,
+			value: fieldValue,
+		},
+		populateFrom: func(i int, v interface{}, dT reflect.Type) (reflect.Value, error) {
+			return nestedFrom(v, dT)
+		},
+		populateTo: func(i int, v reflect.Value) (interface{}, error) {
+			return nestedTo(v)
+		},
+	}, nil
+}

common/tools/protolator/nested_test.go

@@ -0,0 +1,124 @@
+/*
+Copyright IBM Corp. 2017 All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+                 http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package protolator
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/hyperledger/fabric/common/tools/protolator/testprotos"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPlainNestedMsg(t *testing.T) {
+	fromPrefix := "from"
+	toPrefix := "to"
+	tppff := &testProtoPlainFieldFactory{
+		fromPrefix: fromPrefix,
+		toPrefix:   toPrefix,
+	}
+
+	fieldFactories = []protoFieldFactory{tppff}
+
+	pfValue := "foo"
+	startMsg := &testprotos.NestedMsg{
+		PlainNestedField: &testprotos.SimpleMsg{
+			PlainField: pfValue,
+		},
+	}
+
+	var buffer bytes.Buffer
+	assert.NoError(t, DeepMarshalJSON(&buffer, startMsg))
+	newMsg := &testprotos.NestedMsg{}
+	assert.NoError(t, DeepUnmarshalJSON(bytes.NewReader(buffer.Bytes()), newMsg))
+	assert.NotEqual(t, fromPrefix+toPrefix+startMsg.PlainNestedField.PlainField, newMsg.PlainNestedField.PlainField)
+
+	fieldFactories = []protoFieldFactory{tppff, nestedFieldFactory{}}
+
+	buffer.Reset()
+	assert.NoError(t, DeepMarshalJSON(&buffer, startMsg))
+	assert.NoError(t, DeepUnmarshalJSON(bytes.NewReader(buffer.Bytes()), newMsg))
+	assert.Equal(t, fromPrefix+toPrefix+startMsg.PlainNestedField.PlainField, newMsg.PlainNestedField.PlainField)
+}
+
+func TestMapNestedMsg(t *testing.T) {
+	fromPrefix := "from"
+	toPrefix := "to"
+	tppff := &testProtoPlainFieldFactory{
+		fromPrefix: fromPrefix,
+		toPrefix:   toPrefix,
+	}
+
+	fieldFactories = []protoFieldFactory{tppff}
+
+	pfValue := "foo"
+	mapKey := "bar"
+	startMsg := &testprotos.NestedMsg{
+		MapNestedField: map[string]*testprotos.SimpleMsg{
+			mapKey: &testprotos.SimpleMsg{
+				PlainField: pfValue,
+			},
+		},
+	}
+
+	var buffer bytes.Buffer
+	assert.NoError(t, DeepMarshalJSON(&buffer, startMsg))
+	newMsg := &testprotos.NestedMsg{}
+	assert.NoError(t, DeepUnmarshalJSON(bytes.NewReader(buffer.Bytes()), newMsg))
+	assert.NotEqual(t, fromPrefix+toPrefix+startMsg.MapNestedField[mapKey].PlainField, newMsg.MapNestedField[mapKey].PlainField)
+
+	fieldFactories = []protoFieldFactory{tppff, nestedMapFieldFactory{}}
+
+	buffer.Reset()
+	assert.NoError(t, DeepMarshalJSON(&buffer, startMsg))
+	assert.NoError(t, DeepUnmarshalJSON(bytes.NewReader(buffer.Bytes()), newMsg))
+	assert.Equal(t, fromPrefix+toPrefix+startMsg.MapNestedField[mapKey].PlainField, newMsg.MapNestedField[mapKey].PlainField)
+}
+
+func TestSliceNestedMsg(t *testing.T) {
+	fromPrefix := "from"
+	toPrefix := "to"
+	tppff := &testProtoPlainFieldFactory{
+		fromPrefix: fromPrefix,
+		toPrefix:   toPrefix,
+	}
+
+	fieldFactories = []protoFieldFactory{tppff}
+
+	pfValue := "foo"
+	startMsg := &testprotos.NestedMsg{
+		SliceNestedField: []*testprotos.SimpleMsg{
+			&testprotos.SimpleMsg{
+				PlainField: pfValue,
+			},
+		},
+	}
+
+	var buffer bytes.Buffer
+	assert.NoError(t, DeepMarshalJSON(&buffer, startMsg))
+	newMsg := &testprotos.NestedMsg{}
+	assert.NoError(t, DeepUnmarshalJSON(bytes.NewReader(buffer.Bytes()), newMsg))
+	assert.NotEqual(t, fromPrefix+toPrefix+startMsg.SliceNestedField[0].PlainField, newMsg.SliceNestedField[0].PlainField)
+
+	fieldFactories = []protoFieldFactory{tppff, nestedSliceFieldFactory{}}
+
+	buffer.Reset()
+	assert.NoError(t, DeepMarshalJSON(&buffer, startMsg))
+	assert.NoError(t, DeepUnmarshalJSON(bytes.NewReader(buffer.Bytes()), newMsg))
+	assert.Equal(t, fromPrefix+toPrefix+startMsg.SliceNestedField[0].PlainField, newMsg.SliceNestedField[0].PlainField)
+}

common/tools/protolator/testprotos/sample.pb.go

@@ -27,3 +27,10 @@ message SimpleMsg {
     map<string, string> map_field = 2;
     repeated string slice_field = 3;
 }
+
+// NestedMsg is designed to test the nested message component
+message NestedMsg {
+	SimpleMsg plain_nested_field = 1;
+	map<string,SimpleMsg> map_nested_field = 2;
+	repeated SimpleMsg slice_nested_field = 3;
+}