github.com/darrenli6/fabric-sdk-example@v0.0.0-20220109053535-94b13b56df8c/protos/common/common_test.go (about)

     1  /*
     2  Copyright IBM Corp. All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package common
     8  
     9  import (
    10  	"testing"
    11  
    12  	"github.com/golang/protobuf/proto"
    13  	google_protobuf "github.com/golang/protobuf/ptypes/timestamp"
    14  	"github.com/stretchr/testify/assert"
    15  )
    16  
    17  func TestCommonEnums(t *testing.T) {
    18  	var status Status
    19  
    20  	status = 0
    21  	assert.Equal(t, "UNKNOWN", status.String())
    22  	status = 200
    23  	assert.Equal(t, "SUCCESS", status.String())
    24  	status = 400
    25  	assert.Equal(t, "BAD_REQUEST", status.String())
    26  	status = 403
    27  	assert.Equal(t, "FORBIDDEN", status.String())
    28  	status = 404
    29  	assert.Equal(t, "NOT_FOUND", status.String())
    30  	status = 413
    31  	assert.Equal(t, "REQUEST_ENTITY_TOO_LARGE", status.String())
    32  	status = 500
    33  	assert.Equal(t, "INTERNAL_SERVER_ERROR", status.String())
    34  	status = 503
    35  	assert.Equal(t, "SERVICE_UNAVAILABLE", status.String())
    36  	_, _ = status.EnumDescriptor()
    37  
    38  	var header HeaderType
    39  	header = 0
    40  	assert.Equal(t, "MESSAGE", header.String())
    41  	header = 1
    42  	assert.Equal(t, "CONFIG", header.String())
    43  	header = 2
    44  	assert.Equal(t, "CONFIG_UPDATE", header.String())
    45  	header = 3
    46  	assert.Equal(t, "ENDORSER_TRANSACTION", header.String())
    47  	header = 4
    48  	assert.Equal(t, "ORDERER_TRANSACTION", header.String())
    49  	header = 5
    50  	assert.Equal(t, "DELIVER_SEEK_INFO", header.String())
    51  	header = 6
    52  	assert.Equal(t, "CHAINCODE_PACKAGE", header.String())
    53  	_, _ = header.EnumDescriptor()
    54  
    55  	var index BlockMetadataIndex
    56  	index = 0
    57  	assert.Equal(t, "SIGNATURES", index.String())
    58  	index = 1
    59  	assert.Equal(t, "LAST_CONFIG", index.String())
    60  	index = 2
    61  	assert.Equal(t, "TRANSACTIONS_FILTER", index.String())
    62  	index = 3
    63  	assert.Equal(t, "ORDERER", index.String())
    64  	_, _ = index.EnumDescriptor()
    65  }
    66  
    67  func TestCommonStructs(t *testing.T) {
    68  	var last *LastConfig
    69  	last = nil
    70  	assert.Equal(t, uint64(0), last.GetIndex())
    71  	last = &LastConfig{
    72  		Index: uint64(1),
    73  	}
    74  	assert.Equal(t, uint64(1), last.GetIndex())
    75  	last.Reset()
    76  	assert.Equal(t, uint64(0), last.GetIndex())
    77  	_, _ = last.Descriptor()
    78  	_ = last.String()
    79  	last.ProtoMessage()
    80  
    81  	var meta *Metadata
    82  	meta = nil
    83  	assert.Nil(t, meta.GetSignatures())
    84  	assert.Nil(t, meta.GetValue())
    85  	meta = &Metadata{
    86  		Value:      []byte("value"),
    87  		Signatures: []*MetadataSignature{&MetadataSignature{}},
    88  	}
    89  	assert.NotNil(t, meta.GetSignatures())
    90  	assert.NotNil(t, meta.GetValue())
    91  	meta.Reset()
    92  	assert.Nil(t, meta.GetSignatures())
    93  	_, _ = meta.Descriptor()
    94  	_ = meta.String()
    95  	meta.ProtoMessage()
    96  
    97  	var sig *MetadataSignature
    98  	sig = nil
    99  	assert.Nil(t, sig.GetSignature())
   100  	assert.Nil(t, sig.GetSignatureHeader())
   101  	sig = &MetadataSignature{
   102  		SignatureHeader: []byte("header"),
   103  		Signature:       []byte("signature"),
   104  	}
   105  	assert.NotNil(t, sig.GetSignature())
   106  	assert.NotNil(t, sig.GetSignatureHeader())
   107  	sig.Reset()
   108  	assert.Nil(t, sig.GetSignature())
   109  	assert.Nil(t, sig.GetSignatureHeader())
   110  	_, _ = sig.Descriptor()
   111  	_ = sig.String()
   112  	sig.ProtoMessage()
   113  
   114  	var header *Header
   115  	header = nil
   116  	assert.Nil(t, header.GetChannelHeader())
   117  	assert.Nil(t, header.GetSignatureHeader())
   118  	header = &Header{
   119  		ChannelHeader:   []byte("channel header"),
   120  		SignatureHeader: []byte("signature header"),
   121  	}
   122  	assert.NotNil(t, header.GetChannelHeader())
   123  	assert.NotNil(t, header.GetSignatureHeader())
   124  	header.Reset()
   125  	assert.Nil(t, header.GetChannelHeader())
   126  	assert.Nil(t, header.GetSignatureHeader())
   127  	_, _ = header.Descriptor()
   128  	_ = header.String()
   129  	header.ProtoMessage()
   130  
   131  	var chheader *ChannelHeader
   132  	chheader = nil
   133  	assert.Equal(t, "", chheader.GetChannelId())
   134  	assert.Equal(t, "", chheader.GetTxId())
   135  	assert.Equal(t, uint64(0), chheader.GetEpoch())
   136  	assert.Equal(t, int32(0), chheader.GetType())
   137  	assert.Equal(t, int32(0), chheader.GetVersion())
   138  	assert.Nil(t, chheader.GetExtension())
   139  	assert.Nil(t, chheader.GetTimestamp())
   140  	chheader = &ChannelHeader{
   141  		ChannelId: "ChannelId",
   142  		TxId:      "TxId",
   143  		Timestamp: &google_protobuf.Timestamp{},
   144  		Extension: []byte{},
   145  	}
   146  	assert.Equal(t, "ChannelId", chheader.GetChannelId())
   147  	assert.Equal(t, "TxId", chheader.GetTxId())
   148  	assert.Equal(t, uint64(0), chheader.GetEpoch())
   149  	assert.Equal(t, int32(0), chheader.GetType())
   150  	assert.Equal(t, int32(0), chheader.GetVersion())
   151  	assert.NotNil(t, chheader.GetExtension())
   152  	assert.NotNil(t, chheader.GetTimestamp())
   153  	chheader.Reset()
   154  	assert.Nil(t, chheader.GetTimestamp())
   155  	_, _ = chheader.Descriptor()
   156  	_ = chheader.String()
   157  	chheader.ProtoMessage()
   158  
   159  	var sigheader *SignatureHeader
   160  	sigheader = nil
   161  	assert.Nil(t, sigheader.GetCreator())
   162  	assert.Nil(t, sigheader.GetNonce())
   163  	sigheader = &SignatureHeader{
   164  		Creator: []byte("creator"),
   165  		Nonce:   []byte("nonce"),
   166  	}
   167  	assert.NotNil(t, sigheader.GetCreator())
   168  	assert.NotNil(t, sigheader.GetNonce())
   169  	sigheader.Reset()
   170  	assert.Nil(t, sigheader.Creator)
   171  	_, _ = sigheader.Descriptor()
   172  	_ = sigheader.String()
   173  	sigheader.ProtoMessage()
   174  
   175  	var payload *Payload
   176  	payload = nil
   177  	assert.Nil(t, payload.GetHeader())
   178  	assert.Nil(t, payload.GetData())
   179  	payload = &Payload{
   180  		Header: &Header{},
   181  		Data:   []byte("data"),
   182  	}
   183  	assert.NotNil(t, payload.GetHeader())
   184  	assert.NotNil(t, payload.GetData())
   185  	payload.Reset()
   186  	assert.Nil(t, payload.Data)
   187  	_, _ = payload.Descriptor()
   188  	_ = payload.String()
   189  	payload.ProtoMessage()
   190  
   191  	var env *Envelope
   192  	env = nil
   193  	assert.Nil(t, env.GetPayload())
   194  	assert.Nil(t, env.GetSignature())
   195  	env = &Envelope{
   196  		Payload:   []byte("payload"),
   197  		Signature: []byte("signature"),
   198  	}
   199  	assert.NotNil(t, env.GetPayload())
   200  	assert.NotNil(t, env.GetSignature())
   201  	env.Reset()
   202  	assert.Nil(t, env.Payload)
   203  	_, _ = env.Descriptor()
   204  	_ = env.String()
   205  	env.ProtoMessage()
   206  
   207  	b := &Block{
   208  		Data: &BlockData{},
   209  	}
   210  	b.Reset()
   211  	assert.Nil(t, b.GetData())
   212  	_, _ = b.Descriptor()
   213  	_ = b.String()
   214  	b.ProtoMessage()
   215  
   216  	var bh *BlockHeader
   217  	bh = nil
   218  	assert.Nil(t, bh.GetDataHash())
   219  	assert.Nil(t, bh.GetPreviousHash())
   220  	assert.Equal(t, uint64(0), bh.GetNumber())
   221  	bh = &BlockHeader{
   222  		PreviousHash: []byte("hash"),
   223  		DataHash:     []byte("dataHash"),
   224  		Number:       uint64(1),
   225  	}
   226  	assert.NotNil(t, bh.GetDataHash())
   227  	assert.NotNil(t, bh.GetPreviousHash())
   228  	assert.Equal(t, uint64(1), bh.GetNumber())
   229  	bh.Reset()
   230  	assert.Nil(t, bh.GetPreviousHash())
   231  	_, _ = bh.Descriptor()
   232  	_ = bh.String()
   233  	bh.ProtoMessage()
   234  
   235  	var bd *BlockData
   236  	bd = nil
   237  	assert.Nil(t, bd.GetData())
   238  	bd = &BlockData{
   239  		Data: [][]byte{},
   240  	}
   241  	assert.NotNil(t, bd.GetData())
   242  	bd.Reset()
   243  	assert.Nil(t, bd.GetData())
   244  	_, _ = bd.Descriptor()
   245  	_ = bd.String()
   246  	bd.ProtoMessage()
   247  
   248  	var bm *BlockMetadata
   249  	bm = nil
   250  	assert.Nil(t, bm.GetMetadata())
   251  	bm = &BlockMetadata{
   252  		Metadata: [][]byte{},
   253  	}
   254  	assert.NotNil(t, bm.GetMetadata())
   255  	bm.Reset()
   256  	assert.Nil(t, bm.GetMetadata())
   257  	_, _ = bm.Descriptor()
   258  	_ = bm.String()
   259  	bm.ProtoMessage()
   260  
   261  }
   262  
   263  func TestCommonProtolator(t *testing.T) {
   264  	// Envelope
   265  	env := &Envelope{}
   266  	assert.Equal(t, []string{"payload"}, env.StaticallyOpaqueFields())
   267  	msg, err := env.StaticallyOpaqueFieldProto("badproto")
   268  	assert.Nil(t, msg)
   269  	assert.Error(t, err)
   270  	msg, err = env.StaticallyOpaqueFieldProto("payload")
   271  	// Payload
   272  	payload := &Payload{}
   273  	assert.Equal(t, &Payload{}, msg)
   274  	assert.NoError(t, err)
   275  	assert.Equal(t, []string{"data"}, payload.VariablyOpaqueFields())
   276  	msg, err = payload.VariablyOpaqueFieldProto("badproto")
   277  	assert.Nil(t, msg)
   278  	assert.Error(t, err)
   279  	msg, err = payload.VariablyOpaqueFieldProto("data")
   280  	assert.Nil(t, msg)
   281  	assert.Error(t, err)
   282  
   283  	payload = &Payload{
   284  		Header: &Header{
   285  			ChannelHeader: []byte("badbytes"),
   286  		},
   287  	}
   288  	msg, err = payload.VariablyOpaqueFieldProto("data")
   289  	assert.Nil(t, msg)
   290  	assert.Error(t, err)
   291  
   292  	ch := &ChannelHeader{
   293  		Type: int32(HeaderType_CONFIG),
   294  	}
   295  	chbytes, _ := proto.Marshal(ch)
   296  	payload = &Payload{
   297  		Header: &Header{
   298  			ChannelHeader: chbytes,
   299  		},
   300  	}
   301  	msg, err = payload.VariablyOpaqueFieldProto("data")
   302  	assert.Equal(t, &ConfigEnvelope{}, msg)
   303  	assert.NoError(t, err)
   304  
   305  	ch = &ChannelHeader{
   306  		Type: int32(HeaderType_CONFIG_UPDATE),
   307  	}
   308  	chbytes, _ = proto.Marshal(ch)
   309  	payload = &Payload{
   310  		Header: &Header{
   311  			ChannelHeader: chbytes,
   312  		},
   313  	}
   314  	msg, err = payload.VariablyOpaqueFieldProto("data")
   315  	assert.Equal(t, &ConfigUpdateEnvelope{}, msg)
   316  	assert.NoError(t, err)
   317  
   318  	ch = &ChannelHeader{
   319  		Type: int32(HeaderType_CHAINCODE_PACKAGE),
   320  	}
   321  	chbytes, _ = proto.Marshal(ch)
   322  	payload = &Payload{
   323  		Header: &Header{
   324  			ChannelHeader: chbytes,
   325  		},
   326  	}
   327  	msg, err = payload.VariablyOpaqueFieldProto("data")
   328  	assert.Nil(t, msg)
   329  	assert.Error(t, err)
   330  
   331  	// Header
   332  	var header *Header
   333  	assert.Equal(t, []string{"channel_header", "signature_header"},
   334  		header.StaticallyOpaqueFields())
   335  
   336  	msg, err = header.StaticallyOpaqueFieldProto("badproto")
   337  	assert.Nil(t, msg)
   338  	assert.Error(t, err)
   339  
   340  	msg, err = header.StaticallyOpaqueFieldProto("channel_header")
   341  	assert.Equal(t, &ChannelHeader{}, msg)
   342  	assert.NoError(t, err)
   343  
   344  	msg, err = header.StaticallyOpaqueFieldProto("signature_header")
   345  	assert.Equal(t, &SignatureHeader{}, msg)
   346  	assert.NoError(t, err)
   347  
   348  	// BlockData
   349  	var bd *BlockData
   350  	assert.Equal(t, []string{"data"}, bd.StaticallyOpaqueSliceFields())
   351  
   352  	msg, err = bd.StaticallyOpaqueSliceFieldProto("badslice", 0)
   353  	assert.Nil(t, msg)
   354  	assert.Error(t, err)
   355  	msg, err = bd.StaticallyOpaqueSliceFieldProto("data", 0)
   356  	assert.Equal(t, &Envelope{}, msg)
   357  	assert.NoError(t, err)
   358  
   359  }