github.com/defanghe/fabric@v2.1.1+incompatible/common/tools/protolator/statically_opaque_test.go (about)

     1  /*
     2  Copyright IBM Corp. 2017 All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package protolator
     8  
     9  import (
    10  	"bytes"
    11  	"testing"
    12  
    13  	"github.com/golang/protobuf/proto"
    14  	"github.com/hyperledger/fabric/common/tools/protolator/testprotos"
    15  	"github.com/hyperledger/fabric/protoutil"
    16  	"github.com/stretchr/testify/assert"
    17  )
    18  
    19  func extractSimpleMsgPlainField(source []byte) string {
    20  	result := &testprotos.SimpleMsg{}
    21  	err := proto.Unmarshal(source, result)
    22  	if err != nil {
    23  		panic(err)
    24  	}
    25  	return result.PlainField
    26  }
    27  
    28  func TestPlainStaticallyOpaqueMsg(t *testing.T) {
    29  	fromPrefix := "from"
    30  	toPrefix := "to"
    31  	tppff := &testProtoPlainFieldFactory{
    32  		fromPrefix: fromPrefix,
    33  		toPrefix:   toPrefix,
    34  	}
    35  
    36  	fieldFactories = []protoFieldFactory{tppff}
    37  
    38  	pfValue := "foo"
    39  	startMsg := &testprotos.StaticallyOpaqueMsg{
    40  		PlainOpaqueField: protoutil.MarshalOrPanic(&testprotos.SimpleMsg{
    41  			PlainField: pfValue,
    42  		}),
    43  	}
    44  
    45  	var buffer bytes.Buffer
    46  	assert.NoError(t, DeepMarshalJSON(&buffer, startMsg))
    47  	newMsg := &testprotos.StaticallyOpaqueMsg{}
    48  	assert.NoError(t, DeepUnmarshalJSON(bytes.NewReader(buffer.Bytes()), newMsg))
    49  	assert.NotEqual(t, fromPrefix+toPrefix+extractSimpleMsgPlainField(startMsg.PlainOpaqueField), extractSimpleMsgPlainField(newMsg.PlainOpaqueField))
    50  
    51  	fieldFactories = []protoFieldFactory{tppff, staticallyOpaqueFieldFactory{}}
    52  
    53  	buffer.Reset()
    54  	assert.NoError(t, DeepMarshalJSON(&buffer, startMsg))
    55  	assert.NoError(t, DeepUnmarshalJSON(bytes.NewReader(buffer.Bytes()), newMsg))
    56  	assert.Equal(t, fromPrefix+toPrefix+extractSimpleMsgPlainField(startMsg.PlainOpaqueField), extractSimpleMsgPlainField(newMsg.PlainOpaqueField))
    57  }
    58  
    59  func TestMapStaticallyOpaqueMsg(t *testing.T) {
    60  	fromPrefix := "from"
    61  	toPrefix := "to"
    62  	tppff := &testProtoPlainFieldFactory{
    63  		fromPrefix: fromPrefix,
    64  		toPrefix:   toPrefix,
    65  	}
    66  
    67  	fieldFactories = []protoFieldFactory{tppff}
    68  
    69  	pfValue := "foo"
    70  	mapKey := "bar"
    71  	startMsg := &testprotos.StaticallyOpaqueMsg{
    72  		MapOpaqueField: map[string][]byte{
    73  			mapKey: protoutil.MarshalOrPanic(&testprotos.SimpleMsg{
    74  				PlainField: pfValue,
    75  			}),
    76  		},
    77  	}
    78  
    79  	var buffer bytes.Buffer
    80  	assert.NoError(t, DeepMarshalJSON(&buffer, startMsg))
    81  	newMsg := &testprotos.StaticallyOpaqueMsg{}
    82  	assert.NoError(t, DeepUnmarshalJSON(bytes.NewReader(buffer.Bytes()), newMsg))
    83  	assert.NotEqual(t, fromPrefix+toPrefix+extractSimpleMsgPlainField(startMsg.MapOpaqueField[mapKey]), extractSimpleMsgPlainField(newMsg.MapOpaqueField[mapKey]))
    84  
    85  	fieldFactories = []protoFieldFactory{tppff, staticallyOpaqueMapFieldFactory{}}
    86  
    87  	buffer.Reset()
    88  	assert.NoError(t, DeepMarshalJSON(&buffer, startMsg))
    89  	assert.NoError(t, DeepUnmarshalJSON(bytes.NewReader(buffer.Bytes()), newMsg))
    90  	assert.Equal(t, fromPrefix+toPrefix+extractSimpleMsgPlainField(startMsg.MapOpaqueField[mapKey]), extractSimpleMsgPlainField(newMsg.MapOpaqueField[mapKey]))
    91  }
    92  
    93  func TestSliceStaticallyOpaqueMsg(t *testing.T) {
    94  	fromPrefix := "from"
    95  	toPrefix := "to"
    96  	tppff := &testProtoPlainFieldFactory{
    97  		fromPrefix: fromPrefix,
    98  		toPrefix:   toPrefix,
    99  	}
   100  
   101  	fieldFactories = []protoFieldFactory{tppff}
   102  
   103  	pfValue := "foo"
   104  	startMsg := &testprotos.StaticallyOpaqueMsg{
   105  		SliceOpaqueField: [][]byte{
   106  			protoutil.MarshalOrPanic(&testprotos.SimpleMsg{
   107  				PlainField: pfValue,
   108  			}),
   109  		},
   110  	}
   111  
   112  	var buffer bytes.Buffer
   113  	assert.NoError(t, DeepMarshalJSON(&buffer, startMsg))
   114  	newMsg := &testprotos.StaticallyOpaqueMsg{}
   115  	assert.NoError(t, DeepUnmarshalJSON(bytes.NewReader(buffer.Bytes()), newMsg))
   116  	assert.NotEqual(t, fromPrefix+toPrefix+extractSimpleMsgPlainField(startMsg.SliceOpaqueField[0]), extractSimpleMsgPlainField(newMsg.SliceOpaqueField[0]))
   117  
   118  	fieldFactories = []protoFieldFactory{tppff, staticallyOpaqueSliceFieldFactory{}}
   119  
   120  	buffer.Reset()
   121  	assert.NoError(t, DeepMarshalJSON(&buffer, startMsg))
   122  	assert.NoError(t, DeepUnmarshalJSON(bytes.NewReader(buffer.Bytes()), newMsg))
   123  	assert.Equal(t, fromPrefix+toPrefix+extractSimpleMsgPlainField(startMsg.SliceOpaqueField[0]), extractSimpleMsgPlainField(newMsg.SliceOpaqueField[0]))
   124  }
   125  
   126  func TestIgnoredNilFields(t *testing.T) {
   127  	_ = StaticallyOpaqueFieldProto(&testprotos.UnmarshalableDeepFields{})
   128  	_ = StaticallyOpaqueMapFieldProto(&testprotos.UnmarshalableDeepFields{})
   129  	_ = StaticallyOpaqueSliceFieldProto(&testprotos.UnmarshalableDeepFields{})
   130  
   131  	fieldFactories = []protoFieldFactory{
   132  		staticallyOpaqueFieldFactory{},
   133  		staticallyOpaqueMapFieldFactory{},
   134  		staticallyOpaqueSliceFieldFactory{},
   135  	}
   136  
   137  	assert.Error(t, DeepMarshalJSON(&bytes.Buffer{}, &testprotos.UnmarshalableDeepFields{
   138  		PlainOpaqueField: []byte("fake"),
   139  	}))
   140  	assert.Error(t, DeepMarshalJSON(&bytes.Buffer{}, &testprotos.UnmarshalableDeepFields{
   141  		MapOpaqueField: map[string][]byte{"foo": []byte("bar")},
   142  	}))
   143  	assert.Error(t, DeepMarshalJSON(&bytes.Buffer{}, &testprotos.UnmarshalableDeepFields{
   144  		SliceOpaqueField: [][]byte{[]byte("bar")},
   145  	}))
   146  	assert.NoError(t, DeepMarshalJSON(&bytes.Buffer{}, &testprotos.UnmarshalableDeepFields{}))
   147  }