netsync/consensusmgr/consensus_msg_test.go

   1 package consensusmgr
   2
   3 import (
   4         "reflect"
   5         "testing"
   6
   7         "github.com/davecgh/go-spew/spew"
   8         "github.com/tendermint/go-wire"
   9
  10         "github.com/vapor/protocol/bc"
  11         "github.com/vapor/protocol/bc/types"
  12 )
  13
  14 var _ = wire.RegisterInterface(
  15         struct{ ConsensusMessage }{},
  16         wire.ConcreteType{O: &BlockSignatureMsg{}, Byte: blockSignatureByte},
  17         wire.ConcreteType{O: &BlockProposeMsg{}, Byte: blockProposeByte},
  18 )
  19
  20 func TestDecodeMessage(t *testing.T) {
  21         testCases := []struct {
  22                 msg     ConsensusMessage
  23                 msgType byte
  24         }{
  25                 {
  26                         msg: &BlockSignatureMsg{
  27                                 BlockHash: [32]byte{0x01},
  28                                 Signature: []byte{0x00},
  29                                 PubKey:    [32]byte{0x01},
  30                         },
  31                         msgType: blockSignatureByte,
  32                 },
  33                 {
  34                         msg: &BlockProposeMsg{
  35                                 RawBlock: []byte{0x01, 0x02},
  36                         },
  37                         msgType: blockProposeByte,
  38                 },
  39         }
  40         for i, c := range testCases {
  41                 binMsg := wire.BinaryBytes(struct{ ConsensusMessage }{c.msg})
  42                 gotMsgType, gotMsg, err := decodeMessage(binMsg)
  43                 if err != nil {
  44                         t.Fatalf("index:%d decode Message err %s", i, err)
  45                 }
  46                 if gotMsgType != c.msgType {
  47                         t.Fatalf("index:%d decode Message type err. got:%d want:%d", i, gotMsgType, c.msg)
  48                 }
  49                 if !reflect.DeepEqual(gotMsg, c.msg) {
  50                         t.Fatalf("index:%d decode Message err. got:%s\n want:%s", i, spew.Sdump(gotMsg), spew.Sdump(c.msg))
  51                 }
  52         }
  53 }
  54
  55 func TestBlockSignBroadcastMsg(t *testing.T) {
  56         blockSignMsg := &BlockSignatureMsg{
  57                 BlockHash: [32]byte{0x01},
  58                 Height:    100,
  59                 Signature: []byte{0x00},
  60                 PubKey:    [32]byte{0x01},
  61         }
  62         signatureBroadcastMsg := NewBroadcastMsg(NewBlockSignatureMsg(bc.NewHash(blockSignMsg.BlockHash), blockSignMsg.Height, blockSignMsg.Signature, blockSignMsg.PubKey), consensusChannel)
  63
  64         binMsg := wire.BinaryBytes(signatureBroadcastMsg.GetMsg())
  65         gotMsgType, gotMsg, err := decodeMessage(binMsg)
  66         if err != nil {
  67                 t.Fatalf("decode Message err %s", err)
  68         }
  69         if gotMsgType != blockSignatureByte {
  70                 t.Fatalf("decode Message type err. got:%d want:%d", gotMsgType, blockSignatureByte)
  71         }
  72         if !reflect.DeepEqual(gotMsg, blockSignMsg) {
  73                 t.Fatalf("decode Message err. got:%s\n want:%s", spew.Sdump(gotMsg), spew.Sdump(blockSignMsg))
  74         }
  75 }
  76
  77 func TestBlockProposeBroadcastMsg(t *testing.T) {
  78         blockProposeMsg, _ := NewBlockProposeMsg(testBlock)
  79
  80         proposeBroadcastMsg := NewBroadcastMsg(blockProposeMsg, consensusChannel)
  81
  82         binMsg := wire.BinaryBytes(proposeBroadcastMsg.GetMsg())
  83         gotMsgType, gotMsg, err := decodeMessage(binMsg)
  84         if err != nil {
  85                 t.Fatalf("decode Message err %s", err)
  86         }
  87         if gotMsgType != blockProposeByte {
  88                 t.Fatalf("decode Message type err. got:%d want:%d", gotMsgType, blockProposeByte)
  89         }
  90         if !reflect.DeepEqual(gotMsg, blockProposeMsg) {
  91                 t.Fatalf("decode Message err. got:%s\n want:%s", spew.Sdump(gotMsg), spew.Sdump(blockProposeMsg))
  92         }
  93 }
  94
  95 var testBlock = &types.Block{
  96         BlockHeader: types.BlockHeader{
  97                 Version:   1,
  98                 Height:    0,
  99                 Timestamp: 1528945000,
 100                 BlockCommitment: types.BlockCommitment{
 101                         TransactionsMerkleRoot: bc.Hash{V0: uint64(0x11)},
 102                         TransactionStatusHash:  bc.Hash{V0: uint64(0x55)},
 103                 },
 104         },
 105 }
 106
 107 func TestBlockProposeMsg(t *testing.T) {
 108         blockMsg, err := NewBlockProposeMsg(testBlock)
 109         if err != nil {
 110                 t.Fatalf("create new mine block msg err:%s", err)
 111         }
 112
 113         gotBlock, err := blockMsg.(*BlockProposeMsg).GetProposeBlock()
 114         if err != nil {
 115                 t.Fatalf("got block err:%s", err)
 116         }
 117
 118         if !reflect.DeepEqual(gotBlock.BlockHeader, testBlock.BlockHeader) {
 119                 t.Errorf("block msg test err: got %s\nwant %s", spew.Sdump(gotBlock.BlockHeader), spew.Sdump(testBlock.BlockHeader))
 120         }
 121
 122         wantString := "{block_height: 0, block_hash: f59514e2541488a38bc2667940bc2c24027e4a3a371d884b55570d036997bb57}"
 123         if blockMsg.String() != wantString {
 124                 t.Errorf("block msg test err. got:%s want:%s", blockMsg.String(), wantString)
 125         }
 126
 127         blockMsg.(*BlockProposeMsg).RawBlock[1] = blockMsg.(*BlockProposeMsg).RawBlock[1] + 0x1
 128         _, err = blockMsg.(*BlockProposeMsg).GetProposeBlock()
 129         if err == nil {
 130                 t.Fatalf("get mine block err")
 131         }
 132
 133         wantString = "{err: wrong message}"
 134         if blockMsg.String() != wantString {
 135                 t.Errorf("block msg test err. got:%s want:%s", blockMsg.String(), wantString)
 136         }
 137 }
 138
 139 func TestBlockSignatureMsg(t *testing.T) {
 140         msg := &BlockSignatureMsg{
 141                 BlockHash: [32]byte{0x01},
 142                 Height:    100,
 143                 Signature: []byte{0x00},
 144                 PubKey:    [32]byte{0x01},
 145         }
 146         gotMsg := NewBlockSignatureMsg(bc.NewHash(msg.BlockHash), msg.Height, msg.Signature, msg.PubKey)
 147
 148         if !reflect.DeepEqual(gotMsg, msg) {
 149                 t.Fatalf("test block signature message err. got:%s\n want:%s", spew.Sdump(gotMsg), spew.Sdump(msg))
 150         }
 151         wantString := "{block_hash: 0100000000000000000000000000000000000000000000000000000000000000,block_height:100,signature:00,pubkey:0100000000000000000000000000000000000000000000000000000000000000}"
 152         if gotMsg.String() != wantString {
 153                 t.Fatalf("test block signature message err. got string:%s\n want string:%s", gotMsg.String(), wantString)
 154         }
 155 }