github.com/Hnampk/fabric@v2.1.1+incompatible/gossip/protoext/message_test.go (about)

     1  /*
     2  Copyright IBM Corp. All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package protoext_test
     8  
     9  import (
    10  	"testing"
    11  
    12  	"github.com/hyperledger/fabric-protos-go/gossip"
    13  	"github.com/hyperledger/fabric/gossip/protoext"
    14  	"github.com/stretchr/testify/assert"
    15  )
    16  
    17  func TestCheckGossipMessageTypes(t *testing.T) {
    18  	var msg *gossip.GossipMessage
    19  
    20  	// Create State info pull request
    21  	msg = &gossip.GossipMessage{
    22  		Content: &gossip.GossipMessage_StateInfoPullReq{
    23  			StateInfoPullReq: &gossip.StateInfoPullRequest{
    24  				Channel_MAC: []byte{17},
    25  			},
    26  		},
    27  	}
    28  	assert.True(t, protoext.IsStateInfoPullRequestMsg(msg))
    29  
    30  	// Create alive message
    31  	msg = &gossip.GossipMessage{
    32  		Content: &gossip.GossipMessage_AliveMsg{
    33  			AliveMsg: &gossip.AliveMessage{
    34  				Identity: []byte("peerID"),
    35  				Membership: &gossip.Member{
    36  					PkiId:    []byte("pkiID"),
    37  					Metadata: []byte{17},
    38  					Endpoint: "localhost",
    39  				},
    40  				Timestamp: &gossip.PeerTime{
    41  					SeqNum: 1,
    42  					IncNum: 1,
    43  				},
    44  			},
    45  		},
    46  	}
    47  	assert.True(t, protoext.IsAliveMsg(msg))
    48  
    49  	// Create gossip data message
    50  	msg = &gossip.GossipMessage{
    51  		Content: dataMessage(1, []byte{1, 2, 3, 4, 5}),
    52  	}
    53  	assert.True(t, protoext.IsDataMsg(msg))
    54  
    55  	// Create data request message
    56  	msg = &gossip.GossipMessage{
    57  		Content: &gossip.GossipMessage_DataReq{
    58  			DataReq: &gossip.DataRequest{
    59  				MsgType: gossip.PullMsgType_UNDEFINED,
    60  				Nonce:   0,
    61  				Digests: [][]byte{[]byte("msg1"), []byte("msg2"), []byte("msg3")},
    62  			},
    63  		},
    64  	}
    65  	assert.True(t, protoext.IsDataReq(msg))
    66  	assert.True(t, protoext.IsPullMsg(msg))
    67  
    68  	// Create data request message
    69  	msg = &gossip.GossipMessage{
    70  		Content: &gossip.GossipMessage_DataDig{
    71  			DataDig: &gossip.DataDigest{
    72  				MsgType: gossip.PullMsgType_UNDEFINED,
    73  				Nonce:   0,
    74  				Digests: [][]byte{[]byte("msg1"), []byte("msg2"), []byte("msg3")},
    75  			},
    76  		},
    77  	}
    78  	assert.True(t, protoext.IsDigestMsg(msg))
    79  	assert.True(t, protoext.IsPullMsg(msg))
    80  
    81  	// Create data update message
    82  	msg = &gossip.GossipMessage{
    83  		Content: &gossip.GossipMessage_DataUpdate{
    84  			DataUpdate: &gossip.DataUpdate{
    85  				MsgType: gossip.PullMsgType_UNDEFINED,
    86  				Nonce:   0,
    87  				Data:    []*gossip.Envelope{envelopes()[0]},
    88  			},
    89  		},
    90  	}
    91  	assert.True(t, protoext.IsDataUpdate(msg))
    92  	assert.True(t, protoext.IsPullMsg(msg))
    93  
    94  	// Create gossip hello message
    95  	msg = &gossip.GossipMessage{
    96  		Content: &gossip.GossipMessage_Hello{
    97  			Hello: &gossip.GossipHello{
    98  				MsgType: gossip.PullMsgType_UNDEFINED,
    99  				Nonce:   0,
   100  			},
   101  		},
   102  	}
   103  	assert.True(t, protoext.IsHelloMsg(msg))
   104  	assert.True(t, protoext.IsPullMsg(msg))
   105  
   106  	// Create state request message
   107  	msg = &gossip.GossipMessage{
   108  		Content: &gossip.GossipMessage_StateRequest{
   109  			StateRequest: &gossip.RemoteStateRequest{
   110  				StartSeqNum: 1,
   111  				EndSeqNum:   10,
   112  			},
   113  		},
   114  	}
   115  	assert.True(t, protoext.IsRemoteStateMessage(msg))
   116  
   117  	// Create state response message
   118  	msg = &gossip.GossipMessage{
   119  		Content: &gossip.GossipMessage_StateResponse{
   120  			StateResponse: &gossip.RemoteStateResponse{
   121  				Payloads: []*gossip.Payload{{
   122  					SeqNum: 1,
   123  					Data:   []byte{1, 2, 3, 4, 5},
   124  				}},
   125  			},
   126  		},
   127  	}
   128  	assert.True(t, protoext.IsRemoteStateMessage(msg))
   129  }
   130  
   131  func TestGossipPullMessageType(t *testing.T) {
   132  	var msg *gossip.GossipMessage
   133  
   134  	// Create gossip hello message
   135  	msg = &gossip.GossipMessage{
   136  		Content: &gossip.GossipMessage_Hello{
   137  			Hello: &gossip.GossipHello{
   138  				MsgType: gossip.PullMsgType_BLOCK_MSG,
   139  				Nonce:   0,
   140  			},
   141  		},
   142  	}
   143  	assert.True(t, protoext.IsHelloMsg(msg))
   144  	assert.True(t, protoext.IsPullMsg(msg))
   145  	assert.Equal(t, protoext.GetPullMsgType(msg), gossip.PullMsgType_BLOCK_MSG)
   146  
   147  	// Create data request message
   148  	msg = &gossip.GossipMessage{
   149  		Content: &gossip.GossipMessage_DataDig{
   150  			DataDig: &gossip.DataDigest{
   151  				MsgType: gossip.PullMsgType_IDENTITY_MSG,
   152  				Nonce:   0,
   153  				Digests: [][]byte{[]byte("msg1"), []byte("msg2"), []byte("msg3")},
   154  			},
   155  		},
   156  	}
   157  	assert.True(t, protoext.IsDigestMsg(msg))
   158  	assert.True(t, protoext.IsPullMsg(msg))
   159  	assert.Equal(t, protoext.GetPullMsgType(msg), gossip.PullMsgType_IDENTITY_MSG)
   160  
   161  	// Create data request message
   162  	msg = &gossip.GossipMessage{
   163  		Content: &gossip.GossipMessage_DataReq{
   164  			DataReq: &gossip.DataRequest{
   165  				MsgType: gossip.PullMsgType_BLOCK_MSG,
   166  				Nonce:   0,
   167  				Digests: [][]byte{[]byte("msg1"), []byte("msg2"), []byte("msg3")},
   168  			},
   169  		},
   170  	}
   171  	assert.True(t, protoext.IsDataReq(msg))
   172  	assert.True(t, protoext.IsPullMsg(msg))
   173  	assert.Equal(t, protoext.GetPullMsgType(msg), gossip.PullMsgType_BLOCK_MSG)
   174  
   175  	// Create data update message
   176  	msg = &gossip.GossipMessage{
   177  		Content: &gossip.GossipMessage_DataUpdate{
   178  			DataUpdate: &gossip.DataUpdate{
   179  				MsgType: gossip.PullMsgType_IDENTITY_MSG,
   180  				Nonce:   0,
   181  				Data:    []*gossip.Envelope{envelopes()[0]},
   182  			},
   183  		},
   184  	}
   185  	assert.True(t, protoext.IsDataUpdate(msg))
   186  	assert.True(t, protoext.IsPullMsg(msg))
   187  	assert.Equal(t, protoext.GetPullMsgType(msg), gossip.PullMsgType_IDENTITY_MSG)
   188  
   189  	// Create gossip data message
   190  	msg = &gossip.GossipMessage{
   191  		Content: dataMessage(1, []byte{1, 2, 3, 4, 5}),
   192  	}
   193  	assert.True(t, protoext.IsDataMsg(msg))
   194  	assert.Equal(t, protoext.GetPullMsgType(msg), gossip.PullMsgType_UNDEFINED)
   195  }
   196  
   197  func TestGossipMessageDataMessageTagType(t *testing.T) {
   198  	var msg *gossip.GossipMessage
   199  
   200  	msg = &gossip.GossipMessage{
   201  		Tag:     gossip.GossipMessage_CHAN_AND_ORG,
   202  		Content: dataMessage(1, []byte{1}),
   203  	}
   204  	assert.True(t, protoext.IsChannelRestricted(msg))
   205  	assert.True(t, protoext.IsOrgRestricted(msg))
   206  	assert.NoError(t, protoext.IsTagLegal(msg))
   207  
   208  	msg = &gossip.GossipMessage{
   209  		Tag:     gossip.GossipMessage_EMPTY,
   210  		Content: dataMessage(1, []byte{1}),
   211  	}
   212  	assert.Error(t, protoext.IsTagLegal(msg))
   213  
   214  	msg = &gossip.GossipMessage{
   215  		Tag:     gossip.GossipMessage_UNDEFINED,
   216  		Content: dataMessage(1, []byte{1}),
   217  	}
   218  	assert.Error(t, protoext.IsTagLegal(msg))
   219  
   220  	msg = &gossip.GossipMessage{
   221  		Tag:     gossip.GossipMessage_ORG_ONLY,
   222  		Content: dataMessage(1, []byte{1}),
   223  	}
   224  	assert.False(t, protoext.IsChannelRestricted(msg))
   225  	assert.True(t, protoext.IsOrgRestricted(msg))
   226  
   227  	msg = &gossip.GossipMessage{
   228  		Tag:     gossip.GossipMessage_CHAN_OR_ORG,
   229  		Content: dataMessage(1, []byte{1}),
   230  	}
   231  	assert.True(t, protoext.IsChannelRestricted(msg))
   232  	assert.False(t, protoext.IsOrgRestricted(msg))
   233  
   234  	msg = &gossip.GossipMessage{
   235  		Tag:     gossip.GossipMessage_EMPTY,
   236  		Content: dataMessage(1, []byte{1}),
   237  	}
   238  	assert.False(t, protoext.IsChannelRestricted(msg))
   239  	assert.False(t, protoext.IsOrgRestricted(msg))
   240  
   241  	msg = &gossip.GossipMessage{
   242  		Tag:     gossip.GossipMessage_UNDEFINED,
   243  		Content: dataMessage(1, []byte{1}),
   244  	}
   245  	assert.False(t, protoext.IsChannelRestricted(msg))
   246  	assert.False(t, protoext.IsOrgRestricted(msg))
   247  }
   248  
   249  func TestGossipMessageAliveMessageTagType(t *testing.T) {
   250  	var msg *gossip.GossipMessage
   251  
   252  	msg = &gossip.GossipMessage{
   253  		Tag: gossip.GossipMessage_EMPTY,
   254  		Content: &gossip.GossipMessage_AliveMsg{
   255  			AliveMsg: &gossip.AliveMessage{},
   256  		},
   257  	}
   258  	assert.NoError(t, protoext.IsTagLegal(msg))
   259  
   260  	msg = &gossip.GossipMessage{
   261  		Tag: gossip.GossipMessage_ORG_ONLY,
   262  		Content: &gossip.GossipMessage_AliveMsg{
   263  			AliveMsg: &gossip.AliveMessage{},
   264  		},
   265  	}
   266  	assert.Error(t, protoext.IsTagLegal(msg))
   267  }
   268  
   269  func TestGossipMessageMembershipMessageTagType(t *testing.T) {
   270  	var msg *gossip.GossipMessage
   271  
   272  	msg = &gossip.GossipMessage{
   273  		Tag: gossip.GossipMessage_EMPTY,
   274  		Content: &gossip.GossipMessage_MemReq{
   275  			MemReq: &gossip.MembershipRequest{},
   276  		},
   277  	}
   278  	assert.NoError(t, protoext.IsTagLegal(msg))
   279  
   280  	msg = &gossip.GossipMessage{
   281  		Tag: gossip.GossipMessage_EMPTY,
   282  		Content: &gossip.GossipMessage_MemRes{
   283  			MemRes: &gossip.MembershipResponse{},
   284  		},
   285  	}
   286  	assert.NoError(t, protoext.IsTagLegal(msg))
   287  }
   288  
   289  func TestGossipMessageIdentityMessageTagType(t *testing.T) {
   290  	var msg *gossip.GossipMessage
   291  
   292  	msg = &gossip.GossipMessage{
   293  		Tag: gossip.GossipMessage_ORG_ONLY,
   294  		Content: &gossip.GossipMessage_PeerIdentity{
   295  			PeerIdentity: &gossip.PeerIdentity{},
   296  		},
   297  	}
   298  	assert.NoError(t, protoext.IsTagLegal(msg))
   299  
   300  	msg = &gossip.GossipMessage{
   301  		Tag: gossip.GossipMessage_EMPTY,
   302  		Content: &gossip.GossipMessage_PeerIdentity{
   303  			PeerIdentity: &gossip.PeerIdentity{},
   304  		},
   305  	}
   306  	assert.Error(t, protoext.IsTagLegal(msg))
   307  }
   308  
   309  func TestGossipMessagePullMessageTagType(t *testing.T) {
   310  	var msg *gossip.GossipMessage
   311  
   312  	msg = &gossip.GossipMessage{
   313  		Tag: gossip.GossipMessage_CHAN_AND_ORG,
   314  		Content: &gossip.GossipMessage_DataReq{
   315  			DataReq: &gossip.DataRequest{
   316  				MsgType: gossip.PullMsgType_BLOCK_MSG,
   317  			},
   318  		},
   319  	}
   320  	assert.NoError(t, protoext.IsTagLegal(msg))
   321  
   322  	msg = &gossip.GossipMessage{
   323  		Tag: gossip.GossipMessage_EMPTY,
   324  		Content: &gossip.GossipMessage_DataReq{
   325  			DataReq: &gossip.DataRequest{
   326  				MsgType: gossip.PullMsgType_BLOCK_MSG,
   327  			},
   328  		},
   329  	}
   330  	assert.Error(t, protoext.IsTagLegal(msg))
   331  
   332  	msg = &gossip.GossipMessage{
   333  		Tag: gossip.GossipMessage_EMPTY,
   334  		Content: &gossip.GossipMessage_DataDig{
   335  			DataDig: &gossip.DataDigest{
   336  				MsgType: gossip.PullMsgType_IDENTITY_MSG,
   337  			},
   338  		},
   339  	}
   340  	assert.NoError(t, protoext.IsTagLegal(msg))
   341  
   342  	msg = &gossip.GossipMessage{
   343  		Tag: gossip.GossipMessage_ORG_ONLY,
   344  		Content: &gossip.GossipMessage_DataDig{
   345  			DataDig: &gossip.DataDigest{
   346  				MsgType: gossip.PullMsgType_IDENTITY_MSG,
   347  			},
   348  		},
   349  	}
   350  	assert.Error(t, protoext.IsTagLegal(msg))
   351  
   352  	msg = &gossip.GossipMessage{
   353  		Tag: gossip.GossipMessage_ORG_ONLY,
   354  		Content: &gossip.GossipMessage_DataDig{
   355  			DataDig: &gossip.DataDigest{
   356  				MsgType: gossip.PullMsgType_UNDEFINED,
   357  			},
   358  		},
   359  	}
   360  	assert.Error(t, protoext.IsTagLegal(msg))
   361  }
   362  
   363  func TestGossipMessageStateInfoMessageTagType(t *testing.T) {
   364  	var msg *gossip.GossipMessage
   365  
   366  	msg = &gossip.GossipMessage{
   367  		Tag: gossip.GossipMessage_CHAN_OR_ORG,
   368  		Content: &gossip.GossipMessage_StateInfo{
   369  			StateInfo: &gossip.StateInfo{},
   370  		},
   371  	}
   372  	assert.NoError(t, protoext.IsTagLegal(msg))
   373  
   374  	msg = &gossip.GossipMessage{
   375  		Tag: gossip.GossipMessage_CHAN_OR_ORG,
   376  		Content: &gossip.GossipMessage_StateInfoPullReq{
   377  			StateInfoPullReq: &gossip.StateInfoPullRequest{},
   378  		},
   379  	}
   380  	assert.NoError(t, protoext.IsTagLegal(msg))
   381  
   382  	msg = &gossip.GossipMessage{
   383  		Tag: gossip.GossipMessage_CHAN_OR_ORG,
   384  		Content: &gossip.GossipMessage_StateResponse{
   385  			StateResponse: &gossip.RemoteStateResponse{},
   386  		},
   387  	}
   388  	assert.NoError(t, protoext.IsTagLegal(msg))
   389  
   390  	msg = &gossip.GossipMessage{
   391  		Tag: gossip.GossipMessage_CHAN_OR_ORG,
   392  		Content: &gossip.GossipMessage_StateRequest{
   393  			StateRequest: &gossip.RemoteStateRequest{},
   394  		},
   395  	}
   396  	assert.NoError(t, protoext.IsTagLegal(msg))
   397  
   398  	msg = &gossip.GossipMessage{
   399  		Tag: gossip.GossipMessage_CHAN_OR_ORG,
   400  		Content: &gossip.GossipMessage_StateSnapshot{
   401  			StateSnapshot: &gossip.StateInfoSnapshot{},
   402  		},
   403  	}
   404  	assert.NoError(t, protoext.IsTagLegal(msg))
   405  
   406  	msg = &gossip.GossipMessage{
   407  		Tag: gossip.GossipMessage_EMPTY,
   408  		Content: &gossip.GossipMessage_StateInfo{
   409  			StateInfo: &gossip.StateInfo{},
   410  		},
   411  	}
   412  	assert.Error(t, protoext.IsTagLegal(msg))
   413  }
   414  
   415  func TestGossipMessageLeadershipMessageTagType(t *testing.T) {
   416  	var msg *gossip.GossipMessage
   417  
   418  	msg = &gossip.GossipMessage{
   419  		Tag: gossip.GossipMessage_CHAN_AND_ORG,
   420  		Content: &gossip.GossipMessage_LeadershipMsg{
   421  			LeadershipMsg: &gossip.LeadershipMessage{},
   422  		},
   423  	}
   424  	assert.NoError(t, protoext.IsTagLegal(msg))
   425  
   426  	msg = &gossip.GossipMessage{
   427  		Tag: gossip.GossipMessage_CHAN_OR_ORG, Content: &gossip.GossipMessage_LeadershipMsg{
   428  			LeadershipMsg: &gossip.LeadershipMessage{},
   429  		},
   430  	}
   431  	assert.Error(t, protoext.IsTagLegal(msg))
   432  
   433  	msg = &gossip.GossipMessage{
   434  		Tag:     gossip.GossipMessage_CHAN_OR_ORG,
   435  		Content: &gossip.GossipMessage_Empty{},
   436  	}
   437  	assert.Error(t, protoext.IsTagLegal(msg))
   438  }