|
|
|
package core
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
|
|
|
"context"
|
|
|
|
"fmt"
|
|
|
|
"math/rand"
|
|
|
|
"sync"
|
|
|
|
"testing"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
|
|
|
|
"github.com/0xPolygon/go-ibft/messages"
|
|
|
|
"github.com/0xPolygon/go-ibft/messages/proto"
|
|
|
|
)
|
|
|
|
|
|
|
|
func proposalMatches(proposal *proto.Proposal, message *proto.IbftMessage) bool {
|
|
|
|
if message == nil || message.Type != proto.MessageType_PREPREPARE {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
extractedProposal := messages.ExtractProposal(message)
|
|
|
|
if extractedProposal == nil {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
return proposal.Round == extractedProposal.Round &&
|
|
|
|
bytes.Equal(proposal.RawProposal, extractedProposal.RawProposal)
|
|
|
|
}
|
|
|
|
|
|
|
|
func prepareHashMatches(prepareHash []byte, message *proto.IbftMessage) bool {
|
|
|
|
if message == nil || message.Type != proto.MessageType_PREPARE {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
prepareData, _ := message.Payload.(*proto.IbftMessage_PrepareData)
|
|
|
|
extractedPrepareHash := prepareData.PrepareData.ProposalHash
|
|
|
|
|
|
|
|
return bytes.Equal(prepareHash, extractedPrepareHash)
|
|
|
|
}
|
|
|
|
|
|
|
|
func commitHashMatches(commitHash []byte, message *proto.IbftMessage) bool {
|
|
|
|
if message == nil || message.Type != proto.MessageType_COMMIT {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
commitData, _ := message.Payload.(*proto.IbftMessage_CommitData)
|
|
|
|
extractedCommitHash := commitData.CommitData.ProposalHash
|
|
|
|
|
|
|
|
return bytes.Equal(commitHash, extractedCommitHash)
|
|
|
|
}
|
|
|
|
|
|
|
|
func generateMessages(count uint64, messageType proto.MessageType) []*proto.IbftMessage {
|
|
|
|
messages := make([]*proto.IbftMessage, count)
|
|
|
|
|
|
|
|
for index := uint64(0); index < count; index++ {
|
|
|
|
message := &proto.IbftMessage{
|
|
|
|
View: &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 0,
|
|
|
|
},
|
|
|
|
Type: messageType,
|
|
|
|
}
|
|
|
|
|
|
|
|
switch message.Type {
|
|
|
|
case proto.MessageType_PREPREPARE:
|
|
|
|
message.Payload = &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{},
|
|
|
|
}
|
|
|
|
case proto.MessageType_PREPARE:
|
|
|
|
message.Payload = &proto.IbftMessage_PrepareData{
|
|
|
|
PrepareData: &proto.PrepareMessage{},
|
|
|
|
}
|
|
|
|
case proto.MessageType_COMMIT:
|
|
|
|
message.Payload = &proto.IbftMessage_CommitData{
|
|
|
|
CommitData: &proto.CommitMessage{},
|
|
|
|
}
|
|
|
|
case proto.MessageType_ROUND_CHANGE:
|
|
|
|
message.Payload = &proto.IbftMessage_RoundChangeData{
|
|
|
|
RoundChangeData: &proto.RoundChangeMessage{},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
messages[index] = message
|
|
|
|
}
|
|
|
|
|
|
|
|
return messages
|
|
|
|
}
|
|
|
|
|
|
|
|
func generateMessagesWithSender(count uint64, messageType proto.MessageType, sender []byte) []*proto.IbftMessage {
|
|
|
|
messages := generateMessages(count, messageType)
|
|
|
|
|
|
|
|
for _, message := range messages {
|
|
|
|
message.From = sender
|
|
|
|
}
|
|
|
|
|
|
|
|
return messages
|
|
|
|
}
|
|
|
|
|
|
|
|
func generateMessagesWithUniqueSender(count uint64, messageType proto.MessageType) []*proto.IbftMessage {
|
|
|
|
messages := generateMessages(count, messageType)
|
|
|
|
|
|
|
|
for index, message := range messages {
|
|
|
|
message.From = []byte(fmt.Sprintf("node %d", index))
|
|
|
|
}
|
|
|
|
|
|
|
|
return messages
|
|
|
|
}
|
|
|
|
|
|
|
|
func appendProposalHash(messages []*proto.IbftMessage, proposalHash []byte) {
|
|
|
|
for _, message := range messages {
|
|
|
|
switch message.Type {
|
|
|
|
case proto.MessageType_PREPREPARE:
|
|
|
|
ppData, _ := message.Payload.(*proto.IbftMessage_PreprepareData)
|
|
|
|
payload := ppData.PreprepareData
|
|
|
|
|
|
|
|
payload.ProposalHash = proposalHash
|
|
|
|
case proto.MessageType_PREPARE:
|
|
|
|
pData, _ := message.Payload.(*proto.IbftMessage_PrepareData)
|
|
|
|
payload := pData.PrepareData
|
|
|
|
|
|
|
|
payload.ProposalHash = proposalHash
|
|
|
|
default:
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func setRoundForMessages(messages []*proto.IbftMessage, round uint64) {
|
|
|
|
for _, message := range messages {
|
|
|
|
message.View.Round = round
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func generateSeals(count int) [][]byte {
|
|
|
|
seals := make([][]byte, count)
|
|
|
|
|
|
|
|
for i := 0; i < count; i++ {
|
|
|
|
seals[i] = []byte("committed seal")
|
|
|
|
}
|
|
|
|
|
|
|
|
return seals
|
|
|
|
}
|
|
|
|
|
|
|
|
func filterMessages(messages []*proto.IbftMessage, isValid func(message *proto.IbftMessage) bool) []*proto.IbftMessage {
|
|
|
|
newMessages := make([]*proto.IbftMessage, 0)
|
|
|
|
|
|
|
|
for _, message := range messages {
|
|
|
|
if isValid(message) {
|
|
|
|
newMessages = append(newMessages, message)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return newMessages
|
|
|
|
}
|
|
|
|
|
|
|
|
func generateFilledRCMessages(
|
|
|
|
quorum uint64,
|
|
|
|
proposal *proto.Proposal,
|
|
|
|
proposalHash []byte) []*proto.IbftMessage {
|
|
|
|
// Generate random RC messages
|
|
|
|
roundChangeMessages := generateMessagesWithUniqueSender(quorum, proto.MessageType_ROUND_CHANGE)
|
|
|
|
prepareMessages := generateMessages(quorum-1, proto.MessageType_PREPARE)
|
|
|
|
|
|
|
|
// Fill up the prepare message hashes
|
|
|
|
for index, message := range prepareMessages {
|
|
|
|
message.Payload = &proto.IbftMessage_PrepareData{
|
|
|
|
PrepareData: &proto.PrepareMessage{
|
|
|
|
ProposalHash: proposalHash,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
message.View = &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 1,
|
|
|
|
}
|
|
|
|
message.From = []byte(fmt.Sprintf("node %d", index+1))
|
|
|
|
}
|
|
|
|
|
|
|
|
lastPreparedCertificate := &proto.PreparedCertificate{
|
|
|
|
ProposalMessage: &proto.IbftMessage{
|
|
|
|
View: &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 1,
|
|
|
|
},
|
|
|
|
From: []byte("unique node"),
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Proposal: proposal,
|
|
|
|
ProposalHash: proposalHash,
|
|
|
|
Certificate: nil,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
PrepareMessages: prepareMessages,
|
|
|
|
}
|
|
|
|
|
|
|
|
// Fill up their certificates
|
|
|
|
for _, message := range roundChangeMessages {
|
|
|
|
message.Payload = &proto.IbftMessage_RoundChangeData{
|
|
|
|
RoundChangeData: &proto.RoundChangeMessage{
|
|
|
|
LastPreparedProposal: proposal,
|
|
|
|
LatestPreparedCertificate: lastPreparedCertificate,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
message.View = &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 1,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return roundChangeMessages
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestRunNewRound_Proposer checks that the node functions
|
|
|
|
// correctly as the proposer for a block
|
|
|
|
func TestRunNewRound_Proposer(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
t.Run(
|
|
|
|
"proposer builds fresh block",
|
|
|
|
func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
ctx, cancelFn := context.WithCancel(context.Background())
|
|
|
|
|
|
|
|
var (
|
|
|
|
newRawProposal = []byte("new block")
|
|
|
|
multicastedProposal *proto.IbftMessage = nil
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{func(message *proto.IbftMessage) {
|
|
|
|
if message != nil && message.Type == proto.MessageType_PREPREPARE {
|
|
|
|
multicastedProposal = message
|
|
|
|
}
|
|
|
|
}}
|
|
|
|
backend = mockBackend{
|
|
|
|
idFn: func() []byte { return nil },
|
|
|
|
isProposerFn: func(_ []byte, _ uint64, _ uint64) bool {
|
|
|
|
return true
|
|
|
|
},
|
|
|
|
buildProposalFn: func(_ uint64) []byte {
|
|
|
|
return newRawProposal
|
|
|
|
},
|
|
|
|
buildPrePrepareMessageFn: func(
|
|
|
|
rawProposal []byte,
|
|
|
|
certificate *proto.RoundChangeCertificate,
|
|
|
|
view *proto.View,
|
|
|
|
) *proto.IbftMessage {
|
|
|
|
return &proto.IbftMessage{
|
|
|
|
View: view,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Proposal: &proto.Proposal{
|
|
|
|
RawProposal: rawProposal,
|
|
|
|
Round: 0,
|
|
|
|
},
|
|
|
|
Certificate: certificate,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
},
|
|
|
|
}
|
|
|
|
messages = mockMessages{
|
|
|
|
subscribeFn: func(_ messages.SubscriptionDetails) *messages.Subscription {
|
|
|
|
cancelFn()
|
|
|
|
|
|
|
|
return &messages.Subscription{
|
|
|
|
ID: messages.SubscriptionID(1),
|
|
|
|
SubCh: make(chan uint64),
|
|
|
|
}
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
i.messages = messages
|
|
|
|
|
|
|
|
i.wg.Add(1)
|
|
|
|
i.startRound(ctx)
|
|
|
|
|
|
|
|
i.wg.Wait()
|
|
|
|
|
|
|
|
// Make sure the node is in prepare state
|
|
|
|
assert.Equal(t, prepare, i.state.name)
|
|
|
|
|
|
|
|
// Make sure the accepted proposal is the one proposed to other nodes
|
|
|
|
assert.Equal(t, multicastedProposal, i.state.proposalMessage)
|
|
|
|
|
|
|
|
// Make sure the accepted proposal matches what was built
|
|
|
|
assert.True(
|
|
|
|
t,
|
|
|
|
proposalMatches(&proto.Proposal{
|
|
|
|
RawProposal: newRawProposal,
|
|
|
|
Round: 0,
|
|
|
|
}, multicastedProposal,
|
|
|
|
),
|
|
|
|
)
|
|
|
|
},
|
|
|
|
)
|
|
|
|
|
|
|
|
t.Run(
|
|
|
|
"proposer builds proposal for round > 0 (create new)",
|
|
|
|
func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
quorum := uint64(4)
|
|
|
|
ctx, cancelFn := context.WithCancel(context.Background())
|
|
|
|
|
|
|
|
roundChangeMessages := generateMessages(quorum, proto.MessageType_ROUND_CHANGE)
|
|
|
|
setRoundForMessages(roundChangeMessages, 1)
|
|
|
|
|
|
|
|
var (
|
|
|
|
multicastedPreprepare *proto.IbftMessage = nil
|
|
|
|
multicastedPrepare *proto.IbftMessage = nil
|
|
|
|
notifyCh = make(chan uint64, 1)
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{func(message *proto.IbftMessage) {
|
|
|
|
switch message.Type {
|
|
|
|
case proto.MessageType_PREPREPARE:
|
|
|
|
multicastedPreprepare = message
|
|
|
|
case proto.MessageType_PREPARE:
|
|
|
|
multicastedPrepare = message
|
|
|
|
default:
|
|
|
|
}
|
|
|
|
}}
|
|
|
|
backend = mockBackend{
|
|
|
|
idFn: func() []byte { return nil },
|
|
|
|
isProposerFn: func(_ []byte, _ uint64, _ uint64) bool {
|
|
|
|
return true
|
|
|
|
},
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
buildProposalFn: func(_ uint64) []byte {
|
|
|
|
return correctRoundMessage.proposal.GetRawProposal()
|
|
|
|
},
|
|
|
|
buildPrepareMessageFn: func(_ []byte, view *proto.View) *proto.IbftMessage {
|
|
|
|
return &proto.IbftMessage{
|
|
|
|
View: view,
|
|
|
|
Type: proto.MessageType_PREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PrepareData{
|
|
|
|
PrepareData: &proto.PrepareMessage{
|
|
|
|
ProposalHash: correctRoundMessage.hash,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
},
|
|
|
|
buildPrePrepareMessageFn: func(
|
|
|
|
_ []byte,
|
|
|
|
_ *proto.RoundChangeCertificate,
|
|
|
|
view *proto.View,
|
|
|
|
) *proto.IbftMessage {
|
|
|
|
return &proto.IbftMessage{
|
|
|
|
View: view,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Proposal: correctRoundMessage.proposal,
|
|
|
|
ProposalHash: correctRoundMessage.hash,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
},
|
|
|
|
}
|
|
|
|
messages = mockMessages{
|
|
|
|
subscribeFn: func(_ messages.SubscriptionDetails) *messages.Subscription {
|
|
|
|
return &messages.Subscription{
|
|
|
|
ID: messages.SubscriptionID(1),
|
|
|
|
SubCh: notifyCh,
|
|
|
|
}
|
|
|
|
},
|
|
|
|
unsubscribeFn: func(_ messages.SubscriptionID) {
|
|
|
|
cancelFn()
|
|
|
|
},
|
|
|
|
getValidMessagesFn: func(
|
|
|
|
view *proto.View,
|
|
|
|
messageType proto.MessageType,
|
|
|
|
isValid func(message *proto.IbftMessage) bool,
|
|
|
|
) []*proto.IbftMessage {
|
|
|
|
return filterMessages(
|
|
|
|
roundChangeMessages,
|
|
|
|
isValid,
|
|
|
|
)
|
|
|
|
},
|
|
|
|
getExtendedRCCFn: func(
|
|
|
|
height uint64,
|
|
|
|
isValidMessage func(message *proto.IbftMessage) bool,
|
|
|
|
isValidRCC func(round uint64, messages []*proto.IbftMessage,
|
|
|
|
) bool) []*proto.IbftMessage {
|
|
|
|
return filterMessages(
|
|
|
|
roundChangeMessages,
|
|
|
|
isValidMessage,
|
|
|
|
)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
i.messages = messages
|
|
|
|
i.state.setView(&proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 1,
|
|
|
|
})
|
|
|
|
|
|
|
|
notifyCh <- 1
|
|
|
|
|
|
|
|
i.wg.Add(1)
|
|
|
|
i.startRound(ctx)
|
|
|
|
|
|
|
|
i.wg.Wait()
|
|
|
|
|
|
|
|
// Make sure the node changed the state to prepare
|
|
|
|
assert.Equal(t, prepare, i.state.name)
|
|
|
|
|
|
|
|
// Make sure the multicasted proposal is the accepted proposal
|
|
|
|
assert.Equal(t, multicastedPreprepare, i.state.proposalMessage)
|
|
|
|
|
|
|
|
// Make sure the correct proposal value was multicasted
|
|
|
|
assert.True(t, proposalMatches(correctRoundMessage.proposal, multicastedPreprepare))
|
|
|
|
|
|
|
|
// Make sure the prepare message was not multicasted
|
|
|
|
assert.Nil(t, multicastedPrepare)
|
|
|
|
},
|
|
|
|
)
|
|
|
|
|
|
|
|
t.Run(
|
|
|
|
"proposer builds proposal for round > 0 (resend last prepared proposal)",
|
|
|
|
func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
lastPreparedProposedProposal := &proto.Proposal{
|
|
|
|
RawProposal: []byte("dummy block"),
|
|
|
|
Round: 0,
|
|
|
|
}
|
|
|
|
|
|
|
|
quorum := uint64(4)
|
|
|
|
ctx, cancelFn := context.WithCancel(context.Background())
|
|
|
|
|
|
|
|
roundChangeMessages := generateMessagesWithUniqueSender(quorum, proto.MessageType_ROUND_CHANGE)
|
|
|
|
prepareMessages := generateMessages(quorum-1, proto.MessageType_PREPARE)
|
|
|
|
|
|
|
|
for index, message := range prepareMessages {
|
|
|
|
message.Payload = &proto.IbftMessage_PrepareData{
|
|
|
|
PrepareData: &proto.PrepareMessage{
|
|
|
|
ProposalHash: correctRoundMessage.hash,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
message.From = []byte(fmt.Sprintf("node %d", index+1))
|
|
|
|
}
|
|
|
|
|
|
|
|
setRoundForMessages(roundChangeMessages, 1)
|
|
|
|
|
|
|
|
// Make sure at least one RC message has a PC
|
|
|
|
payload, _ := roundChangeMessages[1].Payload.(*proto.IbftMessage_RoundChangeData)
|
|
|
|
rcData := payload.RoundChangeData
|
|
|
|
|
|
|
|
rcData.LastPreparedProposal = lastPreparedProposedProposal
|
|
|
|
rcData.LatestPreparedCertificate = &proto.PreparedCertificate{
|
|
|
|
ProposalMessage: &proto.IbftMessage{
|
|
|
|
View: &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 0,
|
|
|
|
},
|
|
|
|
From: []byte("unique node"),
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Proposal: lastPreparedProposedProposal,
|
|
|
|
ProposalHash: correctRoundMessage.hash,
|
|
|
|
Certificate: nil,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
PrepareMessages: prepareMessages,
|
|
|
|
}
|
|
|
|
|
|
|
|
var (
|
|
|
|
proposerID = []byte("unique node")
|
|
|
|
multicastedPreprepare *proto.IbftMessage = nil
|
|
|
|
multicastedPrepare *proto.IbftMessage = nil
|
|
|
|
proposal = []byte("proposal")
|
|
|
|
notifyCh = make(chan uint64, 1)
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{func(message *proto.IbftMessage) {
|
|
|
|
switch message.Type {
|
|
|
|
case proto.MessageType_PREPREPARE:
|
|
|
|
multicastedPreprepare = message
|
|
|
|
case proto.MessageType_PREPARE:
|
|
|
|
multicastedPrepare = message
|
|
|
|
default:
|
|
|
|
}
|
|
|
|
}}
|
|
|
|
backend = mockBackend{
|
|
|
|
idFn: func() []byte { return proposerID },
|
|
|
|
isProposerFn: func(proposer []byte, _ uint64, _ uint64) bool {
|
|
|
|
return bytes.Equal(proposerID, proposer)
|
|
|
|
},
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
buildProposalFn: func(_ uint64) []byte {
|
|
|
|
return proposal
|
|
|
|
},
|
|
|
|
buildPrepareMessageFn: func(_ []byte, view *proto.View) *proto.IbftMessage {
|
|
|
|
return &proto.IbftMessage{
|
|
|
|
View: view,
|
|
|
|
Type: proto.MessageType_PREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PrepareData{
|
|
|
|
PrepareData: &proto.PrepareMessage{
|
|
|
|
ProposalHash: correctRoundMessage.hash,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
},
|
|
|
|
buildPrePrepareMessageFn: func(
|
|
|
|
rawProposal []byte,
|
|
|
|
certificate *proto.RoundChangeCertificate,
|
|
|
|
view *proto.View,
|
|
|
|
) *proto.IbftMessage {
|
|
|
|
return &proto.IbftMessage{
|
|
|
|
View: view,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Proposal: &proto.Proposal{
|
|
|
|
RawProposal: rawProposal,
|
|
|
|
Round: 0,
|
|
|
|
},
|
|
|
|
ProposalHash: correctRoundMessage.hash,
|
|
|
|
Certificate: certificate,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
},
|
|
|
|
}
|
|
|
|
messages = mockMessages{
|
|
|
|
subscribeFn: func(_ messages.SubscriptionDetails) *messages.Subscription {
|
|
|
|
return &messages.Subscription{
|
|
|
|
ID: messages.SubscriptionID(1),
|
|
|
|
SubCh: notifyCh,
|
|
|
|
}
|
|
|
|
},
|
|
|
|
unsubscribeFn: func(_ messages.SubscriptionID) {
|
|
|
|
cancelFn()
|
|
|
|
},
|
|
|
|
getValidMessagesFn: func(
|
|
|
|
view *proto.View,
|
|
|
|
messageType proto.MessageType,
|
|
|
|
isValid func(message *proto.IbftMessage) bool,
|
|
|
|
) []*proto.IbftMessage {
|
|
|
|
return filterMessages(
|
|
|
|
roundChangeMessages,
|
|
|
|
isValid,
|
|
|
|
)
|
|
|
|
},
|
|
|
|
getExtendedRCCFn: func(
|
|
|
|
height uint64,
|
|
|
|
isValidMessage func(message *proto.IbftMessage) bool,
|
|
|
|
isValidRCC func(round uint64, messages []*proto.IbftMessage) bool,
|
|
|
|
) []*proto.IbftMessage {
|
|
|
|
return filterMessages(
|
|
|
|
roundChangeMessages,
|
|
|
|
isValidMessage,
|
|
|
|
)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
require.NoError(t, i.validatorManager.Init(0))
|
|
|
|
i.messages = messages
|
|
|
|
i.state.setView(&proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 1,
|
|
|
|
})
|
|
|
|
|
|
|
|
notifyCh <- 1
|
|
|
|
|
|
|
|
i.wg.Add(1)
|
|
|
|
i.startRound(ctx)
|
|
|
|
|
|
|
|
i.wg.Wait()
|
|
|
|
|
|
|
|
// Make sure the node changed the state to prepare
|
|
|
|
assert.Equal(t, prepare, i.state.name)
|
|
|
|
|
|
|
|
// Make sure the multicasted proposal is the accepted proposal
|
|
|
|
assert.Equal(t, multicastedPreprepare, i.state.proposalMessage)
|
|
|
|
|
|
|
|
// Make sure the correct proposal was multicasted
|
|
|
|
assert.True(t, proposalMatches(lastPreparedProposedProposal, multicastedPreprepare))
|
|
|
|
|
|
|
|
// Make sure the prepare message was not multicasted
|
|
|
|
assert.Nil(t, multicastedPrepare)
|
|
|
|
},
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestRunNewRound_Validator_Zero validates the behavior
|
|
|
|
// of a non-proposer when receiving the proposal for round 0
|
|
|
|
func TestRunNewRound_Validator_Zero(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
ctx, cancelFn := context.WithCancel(context.Background())
|
|
|
|
|
|
|
|
var (
|
|
|
|
proposer = []byte("proposer")
|
|
|
|
multicastedPrepare *proto.IbftMessage = nil
|
|
|
|
notifyCh = make(chan uint64, 1)
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{
|
|
|
|
func(message *proto.IbftMessage) {
|
|
|
|
if message != nil && message.Type == proto.MessageType_PREPARE {
|
|
|
|
multicastedPrepare = message
|
|
|
|
}
|
|
|
|
},
|
|
|
|
}
|
|
|
|
backend = mockBackend{
|
|
|
|
idFn: func() []byte {
|
|
|
|
return []byte("non proposer")
|
|
|
|
},
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(1),
|
|
|
|
buildPrepareMessageFn: func(proposal []byte, view *proto.View) *proto.IbftMessage {
|
|
|
|
return &proto.IbftMessage{
|
|
|
|
View: view,
|
|
|
|
Type: proto.MessageType_PREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PrepareData{
|
|
|
|
PrepareData: &proto.PrepareMessage{
|
|
|
|
ProposalHash: correctRoundMessage.hash,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
},
|
|
|
|
isProposerFn: func(from []byte, _, _ uint64) bool {
|
|
|
|
return bytes.Equal(from, proposer)
|
|
|
|
},
|
|
|
|
isValidProposalFn: func(_ []byte) bool {
|
|
|
|
return true
|
|
|
|
},
|
|
|
|
}
|
|
|
|
messages = mockMessages{
|
|
|
|
subscribeFn: func(_ messages.SubscriptionDetails) *messages.Subscription {
|
|
|
|
return &messages.Subscription{
|
|
|
|
ID: messages.SubscriptionID(1),
|
|
|
|
SubCh: notifyCh,
|
|
|
|
}
|
|
|
|
},
|
|
|
|
unsubscribeFn: func(_ messages.SubscriptionID) {
|
|
|
|
cancelFn()
|
|
|
|
},
|
|
|
|
getValidMessagesFn: func(
|
|
|
|
view *proto.View,
|
|
|
|
_ proto.MessageType,
|
|
|
|
isValid func(message *proto.IbftMessage) bool,
|
|
|
|
) []*proto.IbftMessage {
|
|
|
|
return filterMessages(
|
|
|
|
[]*proto.IbftMessage{
|
|
|
|
{
|
|
|
|
View: view,
|
|
|
|
From: proposer,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Proposal: correctRoundMessage.proposal,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
isValid,
|
|
|
|
)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
i.messages = messages
|
|
|
|
|
|
|
|
// Make sure the notification is sent out
|
|
|
|
notifyCh <- 0
|
|
|
|
|
|
|
|
i.wg.Add(1)
|
|
|
|
i.startRound(ctx)
|
|
|
|
|
|
|
|
i.wg.Wait()
|
|
|
|
|
|
|
|
// Make sure the node moves to prepare state
|
|
|
|
assert.Equal(t, prepare, i.state.name)
|
|
|
|
|
|
|
|
// Make sure the accepted proposal is the one that was sent out
|
|
|
|
assert.Equal(t, correctRoundMessage.proposal, i.state.getProposal())
|
|
|
|
|
|
|
|
// Make sure the correct proposal hash was multicasted
|
|
|
|
assert.True(t, prepareHashMatches(correctRoundMessage.hash, multicastedPrepare))
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestRunNewRound_Validator_NonZero validates the behavior
|
|
|
|
// of a non-proposer when receiving proposals for rounds > 0
|
|
|
|
func TestRunNewRound_Validator_NonZero(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
quorum := uint64(4)
|
|
|
|
proposer := []byte("proposer")
|
|
|
|
round := uint64(1)
|
|
|
|
|
|
|
|
roundMessage := newCorrectRoundMessage(round)
|
|
|
|
|
|
|
|
generateProposalWithNoPrevious := func() *proto.IbftMessage {
|
|
|
|
roundChangeMessages := generateMessagesWithUniqueSender(quorum, proto.MessageType_ROUND_CHANGE)
|
|
|
|
setRoundForMessages(roundChangeMessages, round)
|
|
|
|
|
|
|
|
return &proto.IbftMessage{
|
|
|
|
View: &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: round,
|
|
|
|
},
|
|
|
|
From: proposer,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Proposal: roundMessage.proposal,
|
|
|
|
ProposalHash: roundMessage.hash,
|
|
|
|
Certificate: &proto.RoundChangeCertificate{
|
|
|
|
RoundChangeMessages: roundChangeMessages,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
generateProposalWithPrevious := func() *proto.IbftMessage {
|
|
|
|
return &proto.IbftMessage{
|
|
|
|
View: &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 1,
|
|
|
|
},
|
|
|
|
From: proposer,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Proposal: roundMessage.proposal,
|
|
|
|
ProposalHash: roundMessage.hash,
|
|
|
|
Certificate: &proto.RoundChangeCertificate{
|
|
|
|
RoundChangeMessages: generateFilledRCMessages(
|
|
|
|
quorum,
|
|
|
|
roundMessage.proposal,
|
|
|
|
roundMessage.hash,
|
|
|
|
),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
testTable := []struct {
|
|
|
|
name string
|
|
|
|
proposalMessage *proto.IbftMessage
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
"validator receives valid block proposal (round > 0, new block)",
|
|
|
|
generateProposalWithNoPrevious(),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"validator receives valid block proposal (round > 0, old block)",
|
|
|
|
generateProposalWithPrevious(),
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, testCase := range testTable {
|
|
|
|
testCase := testCase
|
|
|
|
|
|
|
|
t.Run(testCase.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
ctx, cancelFn := context.WithCancel(context.Background())
|
|
|
|
defer cancelFn()
|
|
|
|
|
|
|
|
var (
|
|
|
|
multicastedPrepare *proto.IbftMessage = nil
|
|
|
|
notifyCh = make(chan uint64, 1)
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{
|
|
|
|
func(message *proto.IbftMessage) {
|
|
|
|
if message != nil && message.Type == proto.MessageType_PREPARE {
|
|
|
|
multicastedPrepare = message
|
|
|
|
}
|
|
|
|
},
|
|
|
|
}
|
|
|
|
backend = mockBackend{
|
|
|
|
idFn: func() []byte {
|
|
|
|
return []byte("non proposer")
|
|
|
|
},
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
buildPrepareMessageFn: func(proposal []byte, view *proto.View) *proto.IbftMessage {
|
|
|
|
return &proto.IbftMessage{
|
|
|
|
View: view,
|
|
|
|
Type: proto.MessageType_PREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PrepareData{
|
|
|
|
PrepareData: &proto.PrepareMessage{
|
|
|
|
ProposalHash: roundMessage.hash,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
},
|
|
|
|
isProposerFn: func(from []byte, _, _ uint64) bool {
|
|
|
|
return bytes.Equal(from, proposer)
|
|
|
|
},
|
|
|
|
isValidProposalFn: func(_ []byte) bool {
|
|
|
|
return true
|
|
|
|
},
|
|
|
|
}
|
|
|
|
messages = mockMessages{
|
|
|
|
subscribeFn: func(_ messages.SubscriptionDetails) *messages.Subscription {
|
|
|
|
return &messages.Subscription{
|
|
|
|
ID: messages.SubscriptionID(1),
|
|
|
|
SubCh: notifyCh,
|
|
|
|
}
|
|
|
|
},
|
|
|
|
unsubscribeFn: func(_ messages.SubscriptionID) {
|
|
|
|
cancelFn()
|
|
|
|
},
|
|
|
|
getValidMessagesFn: func(
|
|
|
|
view *proto.View,
|
|
|
|
_ proto.MessageType,
|
|
|
|
isValid func(message *proto.IbftMessage) bool,
|
|
|
|
) []*proto.IbftMessage {
|
|
|
|
return filterMessages(
|
|
|
|
[]*proto.IbftMessage{
|
|
|
|
testCase.proposalMessage,
|
|
|
|
},
|
|
|
|
isValid,
|
|
|
|
)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
require.NoError(t, i.validatorManager.Init(0))
|
|
|
|
i.messages = messages
|
|
|
|
i.state.setView(&proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 1,
|
|
|
|
})
|
|
|
|
|
|
|
|
// Make sure the notification is sent out
|
|
|
|
notifyCh <- 1
|
|
|
|
|
|
|
|
i.wg.Add(1)
|
|
|
|
i.startRound(ctx)
|
|
|
|
|
|
|
|
i.wg.Wait()
|
|
|
|
|
|
|
|
// Make sure the node moves to prepare state
|
|
|
|
assert.Equal(t, prepare, i.state.name)
|
|
|
|
|
|
|
|
// Make sure the accepted proposal is the one that was sent out
|
|
|
|
assert.Equal(t, roundMessage.proposal, i.state.getProposal())
|
|
|
|
|
|
|
|
// Make sure the correct proposal hash was multicasted
|
|
|
|
assert.True(t, prepareHashMatches(roundMessage.hash, multicastedPrepare))
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestRunPrepare checks that the node behaves correctly
|
|
|
|
// in prepare state
|
|
|
|
func TestRunPrepare(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
t.Run(
|
|
|
|
"validator receives quorum of PREPARE messages",
|
|
|
|
func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
ctx, cancelFn := context.WithCancel(context.Background())
|
|
|
|
|
|
|
|
var (
|
|
|
|
multicastedCommit *proto.IbftMessage = nil
|
|
|
|
notifyCh = make(chan uint64, 1)
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{func(message *proto.IbftMessage) {
|
|
|
|
if message != nil && message.Type == proto.MessageType_COMMIT {
|
|
|
|
multicastedCommit = message
|
|
|
|
}
|
|
|
|
}}
|
|
|
|
backend = mockBackend{
|
|
|
|
buildCommitMessageFn: func(_ []byte, view *proto.View) *proto.IbftMessage {
|
|
|
|
return &proto.IbftMessage{
|
|
|
|
View: view,
|
|
|
|
Type: proto.MessageType_COMMIT,
|
|
|
|
Payload: &proto.IbftMessage_CommitData{
|
|
|
|
CommitData: &proto.CommitMessage{
|
|
|
|
ProposalHash: correctRoundMessage.hash,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
},
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(1),
|
|
|
|
isValidProposalHashFn: func(_ *proto.Proposal, hash []byte) bool {
|
|
|
|
return bytes.Equal(correctRoundMessage.hash, hash)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
messages = mockMessages{
|
|
|
|
subscribeFn: func(_ messages.SubscriptionDetails) *messages.Subscription {
|
|
|
|
return &messages.Subscription{
|
|
|
|
ID: messages.SubscriptionID(1),
|
|
|
|
SubCh: notifyCh,
|
|
|
|
}
|
|
|
|
},
|
|
|
|
unsubscribeFn: func(_ messages.SubscriptionID) {
|
|
|
|
cancelFn()
|
|
|
|
},
|
|
|
|
getValidMessagesFn: func(
|
|
|
|
view *proto.View,
|
|
|
|
_ proto.MessageType,
|
|
|
|
isValid func(message *proto.IbftMessage) bool,
|
|
|
|
) []*proto.IbftMessage {
|
|
|
|
return filterMessages(
|
|
|
|
[]*proto.IbftMessage{
|
|
|
|
{
|
|
|
|
View: view,
|
|
|
|
Type: proto.MessageType_PREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PrepareData{
|
|
|
|
PrepareData: &proto.PrepareMessage{
|
|
|
|
ProposalHash: correctRoundMessage.hash,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
From: []byte("node 0"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
isValid,
|
|
|
|
)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
require.NoError(t, i.validatorManager.Init(0))
|
|
|
|
i.state.name = prepare
|
|
|
|
i.state.roundStarted = true
|
|
|
|
i.state.proposalMessage = &proto.IbftMessage{
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Proposal: correctRoundMessage.proposal,
|
|
|
|
ProposalHash: correctRoundMessage.hash,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
i.messages = &messages
|
|
|
|
|
|
|
|
// Make sure the notification is present
|
|
|
|
notifyCh <- 0
|
|
|
|
|
|
|
|
i.wg.Add(1)
|
|
|
|
i.startRound(ctx)
|
|
|
|
|
|
|
|
i.wg.Wait()
|
|
|
|
|
|
|
|
// Make sure the node moves to the commit state
|
|
|
|
assert.Equal(t, commit, i.state.name)
|
|
|
|
|
|
|
|
// Make sure the proposal didn't change
|
|
|
|
assert.Equal(t, correctRoundMessage.proposal, i.state.getProposal())
|
|
|
|
|
|
|
|
// Make sure the proper proposal hash was multicasted
|
|
|
|
assert.True(t, commitHashMatches(correctRoundMessage.hash, multicastedCommit))
|
|
|
|
},
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestRunCommit makes sure the node
|
|
|
|
// behaves correctly in the commit state
|
|
|
|
func TestRunCommit(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
t.Run(
|
|
|
|
"validator received quorum of valid commit messages",
|
|
|
|
func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
wg sync.WaitGroup
|
|
|
|
|
|
|
|
signer = []byte("node 0")
|
|
|
|
insertedProposal []byte = nil
|
|
|
|
insertedCommittedSeals []*messages.CommittedSeal = nil
|
|
|
|
committedSeals = []*messages.CommittedSeal{
|
|
|
|
{
|
|
|
|
Signer: signer,
|
|
|
|
Signature: generateSeals(1)[0],
|
|
|
|
},
|
|
|
|
}
|
|
|
|
doneReceived = false
|
|
|
|
notifyCh = make(chan uint64, 1)
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{
|
|
|
|
insertProposalFn: func(proposal *proto.Proposal, committedSeals []*messages.CommittedSeal) {
|
|
|
|
insertedProposal = proposal.RawProposal
|
|
|
|
insertedCommittedSeals = committedSeals
|
|
|
|
},
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(1),
|
|
|
|
isValidProposalHashFn: func(_ *proto.Proposal, hash []byte) bool {
|
|
|
|
return bytes.Equal(correctRoundMessage.hash, hash)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
messages = mockMessages{
|
|
|
|
subscribeFn: func(_ messages.SubscriptionDetails) *messages.Subscription {
|
|
|
|
return &messages.Subscription{
|
|
|
|
ID: messages.SubscriptionID(1),
|
|
|
|
SubCh: notifyCh,
|
|
|
|
}
|
|
|
|
},
|
|
|
|
getValidMessagesFn: func(
|
|
|
|
view *proto.View,
|
|
|
|
_ proto.MessageType,
|
|
|
|
isValid func(message *proto.IbftMessage) bool,
|
|
|
|
) []*proto.IbftMessage {
|
|
|
|
return filterMessages(
|
|
|
|
[]*proto.IbftMessage{
|
|
|
|
{
|
|
|
|
View: view,
|
|
|
|
Type: proto.MessageType_COMMIT,
|
|
|
|
Payload: &proto.IbftMessage_CommitData{
|
|
|
|
CommitData: &proto.CommitMessage{
|
|
|
|
ProposalHash: correctRoundMessage.hash,
|
|
|
|
CommittedSeal: committedSeals[0].Signature,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
From: signer,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
isValid,
|
|
|
|
)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
require.NoError(t, i.validatorManager.Init(0))
|
|
|
|
i.messages = messages
|
|
|
|
i.state.proposalMessage = &proto.IbftMessage{
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Proposal: correctRoundMessage.proposal,
|
|
|
|
ProposalHash: correctRoundMessage.hash,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
i.state.roundStarted = true
|
|
|
|
i.state.name = commit
|
|
|
|
|
|
|
|
ctx, cancelFn := context.WithCancel(context.Background())
|
|
|
|
|
|
|
|
wg.Add(1)
|
|
|
|
|
|
|
|
go func(i *IBFT) {
|
|
|
|
defer func() {
|
|
|
|
cancelFn()
|
|
|
|
wg.Done()
|
|
|
|
}()
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-i.roundDone:
|
|
|
|
doneReceived = true
|
|
|
|
case <-time.After(5 * time.Second):
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}(i)
|
|
|
|
|
|
|
|
// Make sure the notification is ready
|
|
|
|
notifyCh <- 0
|
|
|
|
|
|
|
|
i.wg.Add(1)
|
|
|
|
i.startRound(ctx)
|
|
|
|
|
|
|
|
i.wg.Wait()
|
|
|
|
i.insertBlock()
|
|
|
|
|
|
|
|
// Make sure the node changed the state to fin
|
|
|
|
require.Equal(t, fin, i.state.name)
|
|
|
|
|
|
|
|
// Make sure the inserted proposal was the one present
|
|
|
|
require.Equal(t, insertedProposal, correctRoundMessage.proposal.RawProposal)
|
|
|
|
|
|
|
|
// Make sure the inserted committed seals were correct
|
|
|
|
require.Equal(t, insertedCommittedSeals, committedSeals)
|
|
|
|
|
|
|
|
// Make sure the proper done channel was notified
|
|
|
|
wg.Wait()
|
|
|
|
require.True(t, doneReceived)
|
|
|
|
},
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestIBFT_IsAcceptableMessage makes sure invalid messages
|
|
|
|
// are properly handled
|
|
|
|
func TestIBFT_IsAcceptableMessage(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
baseView := &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 0,
|
|
|
|
}
|
|
|
|
|
|
|
|
testTable := []struct {
|
|
|
|
name string
|
|
|
|
msgView *proto.View
|
|
|
|
stateView *proto.View
|
|
|
|
invalidSender bool
|
|
|
|
acceptable bool
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "invalid sender",
|
|
|
|
msgView: nil,
|
|
|
|
stateView: baseView,
|
|
|
|
invalidSender: true,
|
|
|
|
acceptable: false,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "malformed message",
|
|
|
|
msgView: nil,
|
|
|
|
stateView: baseView,
|
|
|
|
invalidSender: false,
|
|
|
|
acceptable: false,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "higher height, same round number",
|
|
|
|
msgView: &proto.View{
|
|
|
|
Height: baseView.Height + 100,
|
|
|
|
Round: baseView.Round,
|
|
|
|
},
|
|
|
|
stateView: baseView,
|
|
|
|
invalidSender: false,
|
|
|
|
acceptable: true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "higher height, lower round number",
|
|
|
|
msgView: &proto.View{
|
|
|
|
Height: baseView.Height + 100,
|
|
|
|
Round: baseView.Round,
|
|
|
|
},
|
|
|
|
stateView: &proto.View{
|
|
|
|
Height: baseView.Height,
|
|
|
|
Round: baseView.Round + 1,
|
|
|
|
},
|
|
|
|
invalidSender: false,
|
|
|
|
acceptable: true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "same heights, higher round number",
|
|
|
|
msgView: &proto.View{
|
|
|
|
Height: baseView.Height,
|
|
|
|
Round: baseView.Round + 1,
|
|
|
|
},
|
|
|
|
stateView: baseView,
|
|
|
|
invalidSender: false,
|
|
|
|
acceptable: true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "same heights, lower round number",
|
|
|
|
msgView: &proto.View{
|
|
|
|
Height: baseView.Height,
|
|
|
|
Round: baseView.Round + 1,
|
|
|
|
},
|
|
|
|
stateView: &proto.View{
|
|
|
|
Height: baseView.Height,
|
|
|
|
Round: baseView.Round + 2,
|
|
|
|
},
|
|
|
|
invalidSender: false,
|
|
|
|
acceptable: false,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "lower height number",
|
|
|
|
msgView: baseView,
|
|
|
|
stateView: &proto.View{
|
|
|
|
Height: baseView.Height + 1,
|
|
|
|
Round: baseView.Round,
|
|
|
|
},
|
|
|
|
invalidSender: false,
|
|
|
|
acceptable: false,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, testCase := range testTable {
|
|
|
|
testCase := testCase
|
|
|
|
|
|
|
|
t.Run(testCase.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{
|
|
|
|
IsValidValidatorFn: func(message *proto.IbftMessage) bool {
|
|
|
|
return !testCase.invalidSender
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
i.state.view = testCase.stateView
|
|
|
|
|
|
|
|
message := &proto.IbftMessage{
|
|
|
|
View: testCase.msgView,
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.Equal(t, testCase.acceptable, i.isAcceptableMessage(message))
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestIBFT_StartRoundTimer makes sure that the
|
|
|
|
// round timer behaves correctly
|
|
|
|
func TestIBFT_StartRoundTimer(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
t.Run("round timer exits due to a quit signal", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
wg sync.WaitGroup
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
ctx, cancelFn := context.WithCancel(context.Background())
|
|
|
|
|
|
|
|
wg.Add(1)
|
|
|
|
i.wg.Add(1)
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
i.startRoundTimer(ctx, 0)
|
|
|
|
|
|
|
|
wg.Done()
|
|
|
|
}()
|
|
|
|
|
|
|
|
cancelFn()
|
|
|
|
|
|
|
|
wg.Wait()
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("round timer expires", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
wg sync.WaitGroup
|
|
|
|
expired = false
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
i.baseRoundTimeout = 0 * time.Second
|
|
|
|
|
|
|
|
ctx, cancelFn := context.WithCancel(context.Background())
|
|
|
|
|
|
|
|
wg.Add(1)
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
defer func() {
|
|
|
|
wg.Done()
|
|
|
|
|
|
|
|
cancelFn()
|
|
|
|
}()
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-i.roundExpired:
|
|
|
|
expired = true
|
|
|
|
case <-time.After(5 * time.Second):
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
i.wg.Add(1)
|
|
|
|
i.startRoundTimer(ctx, 0)
|
|
|
|
|
|
|
|
wg.Wait()
|
|
|
|
|
|
|
|
// Make sure the round timer expired properly
|
|
|
|
assert.True(t, expired)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestIBFT_MoveToNewRound makes sure the state is modified
|
|
|
|
// correctly during round moves
|
|
|
|
func TestIBFT_MoveToNewRound(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
t.Run("move to new round", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
expectedNewRound uint64 = 1
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
i.moveToNewRound(expectedNewRound)
|
|
|
|
|
|
|
|
// Make sure the view has changed
|
|
|
|
assert.Equal(t, expectedNewRound, i.state.getRound())
|
|
|
|
|
|
|
|
// Make sure the proposal is not present
|
|
|
|
assert.Nil(t, i.state.getProposal())
|
|
|
|
|
|
|
|
// Make sure the state is correct
|
|
|
|
assert.Equal(t, newRound, i.state.name)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestIBFT_FutureProposal checks the
|
|
|
|
// behavior when new proposal messages appear
|
|
|
|
func TestIBFT_FutureProposal(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
nodeID := []byte("node ID")
|
|
|
|
proposer := []byte("proposer")
|
|
|
|
quorum := uint64(4)
|
|
|
|
|
|
|
|
generateEmptyRCMessages := func(count uint64, round uint64) []*proto.IbftMessage {
|
|
|
|
// Generate random RC messages
|
|
|
|
roundChangeMessages := generateMessagesWithUniqueSender(count, proto.MessageType_ROUND_CHANGE)
|
|
|
|
|
|
|
|
// Fill up their certificates
|
|
|
|
for _, message := range roundChangeMessages {
|
|
|
|
message.Payload = &proto.IbftMessage_RoundChangeData{
|
|
|
|
RoundChangeData: &proto.RoundChangeMessage{
|
|
|
|
LastPreparedProposal: nil,
|
|
|
|
LatestPreparedCertificate: nil,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
message.View.Round = round
|
|
|
|
}
|
|
|
|
|
|
|
|
return roundChangeMessages
|
|
|
|
}
|
|
|
|
|
|
|
|
generateValidProposal := func(
|
|
|
|
view *proto.View,
|
|
|
|
roundChangeMessages []*proto.IbftMessage,
|
|
|
|
) *proto.IbftMessage {
|
|
|
|
roundMessage := newCorrectRoundMessage(view.Round)
|
|
|
|
|
|
|
|
return &proto.IbftMessage{
|
|
|
|
View: view,
|
|
|
|
From: proposer,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Proposal: roundMessage.proposal,
|
|
|
|
ProposalHash: roundMessage.hash,
|
|
|
|
Certificate: &proto.RoundChangeCertificate{
|
|
|
|
RoundChangeMessages: roundChangeMessages,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
generateFilledRCMessagesWithRound := func(quorum, round uint64) []*proto.IbftMessage {
|
|
|
|
messages := generateFilledRCMessages(quorum, correctRoundMessage.proposal, correctRoundMessage.hash)
|
|
|
|
setRoundForMessages(messages, round)
|
|
|
|
|
|
|
|
return messages
|
|
|
|
}
|
|
|
|
|
|
|
|
testTable := []struct {
|
|
|
|
name string
|
|
|
|
proposalView *proto.View
|
|
|
|
roundChangeMessages []*proto.IbftMessage
|
|
|
|
notifyRound uint64
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
"valid future proposal with new block",
|
|
|
|
&proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 1,
|
|
|
|
},
|
|
|
|
generateEmptyRCMessages(quorum, 1),
|
|
|
|
1,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"valid future proposal with old block",
|
|
|
|
&proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 2,
|
|
|
|
},
|
|
|
|
generateFilledRCMessagesWithRound(quorum, 2),
|
|
|
|
2,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, testCase := range testTable {
|
|
|
|
testCase := testCase
|
|
|
|
|
|
|
|
t.Run(testCase.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
ctx, cancelFn := context.WithCancel(context.Background())
|
|
|
|
validProposal := generateValidProposal(
|
|
|
|
testCase.proposalView,
|
|
|
|
testCase.roundChangeMessages,
|
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
|
|
|
wg sync.WaitGroup
|
|
|
|
receivedProposalEvent *newProposalEvent = nil
|
|
|
|
notifyCh = make(chan uint64, 1)
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
backend = mockBackend{
|
|
|
|
isProposerFn: func(id []byte, _ uint64, _ uint64) bool {
|
|
|
|
return !bytes.Equal(id, nodeID)
|
|
|
|
},
|
|
|
|
idFn: func() []byte {
|
|
|
|
return nodeID
|
|
|
|
},
|
|
|
|
isValidProposalHashFn: func(p *proto.Proposal, hash []byte) bool {
|
|
|
|
if bytes.Equal(p.RawProposal, correctRoundMessage.proposal.RawProposal) {
|
|
|
|
return bytes.Equal(hash, correctRoundMessage.hash)
|
|
|
|
}
|
|
|
|
|
|
|
|
return false
|
|
|
|
},
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
}
|
|
|
|
transport = mockTransport{}
|
|
|
|
mMessages = mockMessages{
|
|
|
|
subscribeFn: func(_ messages.SubscriptionDetails) *messages.Subscription {
|
|
|
|
return &messages.Subscription{
|
|
|
|
ID: messages.SubscriptionID(1),
|
|
|
|
SubCh: notifyCh,
|
|
|
|
}
|
|
|
|
},
|
|
|
|
getValidMessagesFn: func(
|
|
|
|
view *proto.View,
|
|
|
|
_ proto.MessageType,
|
|
|
|
isValid func(message *proto.IbftMessage) bool,
|
|
|
|
) []*proto.IbftMessage {
|
|
|
|
return filterMessages(
|
|
|
|
[]*proto.IbftMessage{
|
|
|
|
validProposal,
|
|
|
|
},
|
|
|
|
isValid,
|
|
|
|
)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
require.NoError(t, i.validatorManager.Init(0))
|
|
|
|
i.messages = mMessages
|
|
|
|
|
|
|
|
wg.Add(1)
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
defer func() {
|
|
|
|
cancelFn()
|
|
|
|
|
|
|
|
wg.Done()
|
|
|
|
}()
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-time.After(5 * time.Second):
|
|
|
|
case event := <-i.newProposal:
|
|
|
|
receivedProposalEvent = &event
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
notifyCh <- testCase.notifyRound
|
|
|
|
|
|
|
|
i.wg.Add(1)
|
|
|
|
i.watchForFutureProposal(ctx)
|
|
|
|
|
|
|
|
wg.Wait()
|
|
|
|
|
|
|
|
// Make sure the received proposal is the one that was expected
|
|
|
|
if receivedProposalEvent == nil {
|
|
|
|
t.Fatalf("no proposal event received")
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.Equal(t, testCase.notifyRound, receivedProposalEvent.round)
|
|
|
|
assert.Equal(
|
|
|
|
t,
|
|
|
|
messages.ExtractProposal(validProposal),
|
|
|
|
messages.ExtractProposal(receivedProposalEvent.proposalMessage),
|
|
|
|
)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestIBFT_ValidPC validates that prepared certificates
|
|
|
|
// are verified correctly
|
|
|
|
func TestIBFT_ValidPC(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
t.Run("no certificate", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
certificate *proto.PreparedCertificate = nil
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
assert.True(t, i.validPC(certificate, 0, 0))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("proposal and prepare messages mismatch", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
certificate := &proto.PreparedCertificate{
|
|
|
|
ProposalMessage: nil,
|
|
|
|
PrepareMessages: make([]*proto.IbftMessage, 0),
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validPC(certificate, 0, 0))
|
|
|
|
|
|
|
|
certificate = &proto.PreparedCertificate{
|
|
|
|
ProposalMessage: &proto.IbftMessage{},
|
|
|
|
PrepareMessages: nil,
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validPC(certificate, 0, 0))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("no Quorum PP + P messages", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
certificate := &proto.PreparedCertificate{
|
|
|
|
ProposalMessage: &proto.IbftMessage{},
|
|
|
|
PrepareMessages: generateMessages(quorum-2, proto.MessageType_PREPARE),
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validPC(certificate, 0, 0))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("invalid proposal message type", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
certificate := &proto.PreparedCertificate{
|
|
|
|
ProposalMessage: &proto.IbftMessage{
|
|
|
|
Type: proto.MessageType_PREPARE,
|
|
|
|
},
|
|
|
|
PrepareMessages: generateMessages(quorum-1, proto.MessageType_PREPARE),
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validPC(certificate, 0, 0))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("invalid prepare message type", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
certificate := &proto.PreparedCertificate{
|
|
|
|
ProposalMessage: &proto.IbftMessage{
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
},
|
|
|
|
PrepareMessages: generateMessages(quorum-1, proto.MessageType_PREPARE),
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure one of the messages has an invalid type
|
|
|
|
certificate.PrepareMessages[0].Type = proto.MessageType_ROUND_CHANGE
|
|
|
|
|
|
|
|
assert.False(t, i.validPC(certificate, 0, 0))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("non unique senders", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
sender = []byte("node x")
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
certificate := &proto.PreparedCertificate{
|
|
|
|
ProposalMessage: &proto.IbftMessage{
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
From: sender,
|
|
|
|
},
|
|
|
|
PrepareMessages: generateMessagesWithSender(quorum-1, proto.MessageType_PREPARE, sender),
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validPC(certificate, 0, 0))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("differing proposal hashes", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
sender = []byte("unique node")
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
proposal := generateMessagesWithSender(1, proto.MessageType_PREPREPARE, sender)[0]
|
|
|
|
|
|
|
|
certificate := &proto.PreparedCertificate{
|
|
|
|
ProposalMessage: proposal,
|
|
|
|
PrepareMessages: generateMessagesWithUniqueSender(quorum-1, proto.MessageType_PREPARE),
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure the proposal has a different hash than the prepare messages
|
|
|
|
appendProposalHash([]*proto.IbftMessage{certificate.ProposalMessage}, []byte("proposal hash 1"))
|
|
|
|
appendProposalHash(certificate.PrepareMessages, []byte("proposal hash 2"))
|
|
|
|
|
|
|
|
assert.False(t, i.validPC(certificate, 0, 0))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("rounds not lower than rLimit", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
rLimit = uint64(1)
|
|
|
|
sender = []byte("unique node")
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
proposal := generateMessagesWithSender(1, proto.MessageType_PREPREPARE, sender)[0]
|
|
|
|
|
|
|
|
certificate := &proto.PreparedCertificate{
|
|
|
|
ProposalMessage: proposal,
|
|
|
|
PrepareMessages: generateMessagesWithUniqueSender(quorum-1, proto.MessageType_PREPARE),
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure they all have the same proposal hash
|
|
|
|
allMessages := append([]*proto.IbftMessage{certificate.ProposalMessage}, certificate.PrepareMessages...)
|
|
|
|
appendProposalHash(
|
|
|
|
allMessages,
|
|
|
|
correctRoundMessage.hash,
|
|
|
|
)
|
|
|
|
|
|
|
|
setRoundForMessages(allMessages, rLimit+1)
|
|
|
|
|
|
|
|
assert.False(t, i.validPC(certificate, rLimit, 0))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("heights are not the same", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
rLimit = uint64(1)
|
|
|
|
sender = []byte("unique node")
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
isProposerFn: func(proposer []byte, _ uint64, _ uint64) bool {
|
|
|
|
return !bytes.Equal(proposer, sender)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
proposal := generateMessagesWithSender(1, proto.MessageType_PREPREPARE, sender)[0]
|
|
|
|
|
|
|
|
// Make sure the height is invalid for the proposal
|
|
|
|
proposal.View.Height = 10
|
|
|
|
|
|
|
|
certificate := &proto.PreparedCertificate{
|
|
|
|
ProposalMessage: proposal,
|
|
|
|
PrepareMessages: generateMessagesWithUniqueSender(quorum-1, proto.MessageType_PREPARE),
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure they all have the same proposal hash
|
|
|
|
allMessages := append([]*proto.IbftMessage{certificate.ProposalMessage}, certificate.PrepareMessages...)
|
|
|
|
appendProposalHash(
|
|
|
|
allMessages,
|
|
|
|
correctRoundMessage.hash,
|
|
|
|
)
|
|
|
|
|
|
|
|
setRoundForMessages(allMessages, rLimit-1)
|
|
|
|
|
|
|
|
assert.False(t, i.validPC(certificate, rLimit, 0))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("rounds are not the same", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
rLimit = uint64(2)
|
|
|
|
sender = []byte("unique node")
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
isProposerFn: func(proposer []byte, _ uint64, _ uint64) bool {
|
|
|
|
return !bytes.Equal(proposer, sender)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
proposal := generateMessagesWithSender(1, proto.MessageType_PREPREPARE, sender)[0]
|
|
|
|
|
|
|
|
certificate := &proto.PreparedCertificate{
|
|
|
|
ProposalMessage: proposal,
|
|
|
|
PrepareMessages: generateMessagesWithUniqueSender(quorum-1, proto.MessageType_PREPARE),
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure they all have the same proposal hash
|
|
|
|
allMessages := append([]*proto.IbftMessage{certificate.ProposalMessage}, certificate.PrepareMessages...)
|
|
|
|
appendProposalHash(
|
|
|
|
allMessages,
|
|
|
|
correctRoundMessage.hash,
|
|
|
|
)
|
|
|
|
|
|
|
|
setRoundForMessages(allMessages, rLimit-1)
|
|
|
|
// Make sure the round is invalid for some random message
|
|
|
|
randomIndex := rand.Intn(len(certificate.PrepareMessages))
|
|
|
|
randomPrepareMessage := certificate.PrepareMessages[randomIndex]
|
|
|
|
randomPrepareMessage.View.Round = 0
|
|
|
|
|
|
|
|
assert.False(t, i.validPC(certificate, rLimit, 0))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("proposal not from proposer", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
rLimit = uint64(1)
|
|
|
|
sender = []byte("unique node")
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
isProposerFn: func(proposer []byte, _ uint64, _ uint64) bool {
|
|
|
|
return !bytes.Equal(proposer, sender)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
proposal := generateMessagesWithSender(1, proto.MessageType_PREPREPARE, sender)[0]
|
|
|
|
|
|
|
|
certificate := &proto.PreparedCertificate{
|
|
|
|
ProposalMessage: proposal,
|
|
|
|
PrepareMessages: generateMessagesWithUniqueSender(quorum-1, proto.MessageType_PREPARE),
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure they all have the same proposal hash
|
|
|
|
allMessages := append([]*proto.IbftMessage{certificate.ProposalMessage}, certificate.PrepareMessages...)
|
|
|
|
appendProposalHash(
|
|
|
|
allMessages,
|
|
|
|
correctRoundMessage.hash,
|
|
|
|
)
|
|
|
|
|
|
|
|
setRoundForMessages(allMessages, rLimit-1)
|
|
|
|
|
|
|
|
assert.False(t, i.validPC(certificate, rLimit, 0))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("prepare is from an invalid sender", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
rLimit = uint64(1)
|
|
|
|
sender = []byte("unique node")
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
isProposerFn: func(proposer []byte, _ uint64, _ uint64) bool {
|
|
|
|
return bytes.Equal(proposer, sender)
|
|
|
|
},
|
|
|
|
IsValidValidatorFn: func(message *proto.IbftMessage) bool {
|
|
|
|
// One of the messages will be invalid
|
|
|
|
return !bytes.Equal(message.From, []byte("node 1"))
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
proposal := generateMessagesWithSender(1, proto.MessageType_PREPREPARE, sender)[0]
|
|
|
|
|
|
|
|
certificate := &proto.PreparedCertificate{
|
|
|
|
ProposalMessage: proposal,
|
|
|
|
PrepareMessages: generateMessagesWithUniqueSender(quorum-1, proto.MessageType_PREPARE),
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure they all have the same proposal hash
|
|
|
|
allMessages := append([]*proto.IbftMessage{certificate.ProposalMessage}, certificate.PrepareMessages...)
|
|
|
|
appendProposalHash(
|
|
|
|
allMessages,
|
|
|
|
correctRoundMessage.hash,
|
|
|
|
)
|
|
|
|
|
|
|
|
setRoundForMessages(allMessages, rLimit-1)
|
|
|
|
|
|
|
|
assert.False(t, i.validPC(certificate, rLimit, 0))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("proposal is from an invalid sender", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
rLimit = uint64(1)
|
|
|
|
sender = []byte("unique node")
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
isProposerFn: func(proposer []byte, _ uint64, _ uint64) bool {
|
|
|
|
return bytes.Equal(proposer, sender)
|
|
|
|
},
|
|
|
|
IsValidValidatorFn: func(message *proto.IbftMessage) bool {
|
|
|
|
// Proposer is invalid
|
|
|
|
return !bytes.Equal(message.From, sender)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
proposal := generateMessagesWithSender(1, proto.MessageType_PREPREPARE, sender)[0]
|
|
|
|
|
|
|
|
certificate := &proto.PreparedCertificate{
|
|
|
|
ProposalMessage: proposal,
|
|
|
|
PrepareMessages: generateMessagesWithUniqueSender(quorum-1, proto.MessageType_PREPARE),
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure they all have the same proposal hash
|
|
|
|
allMessages := append([]*proto.IbftMessage{certificate.ProposalMessage}, certificate.PrepareMessages...)
|
|
|
|
appendProposalHash(
|
|
|
|
allMessages,
|
|
|
|
correctRoundMessage.hash,
|
|
|
|
)
|
|
|
|
|
|
|
|
setRoundForMessages(allMessages, rLimit-1)
|
|
|
|
|
|
|
|
assert.False(t, i.validPC(certificate, rLimit, 0))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("prepare from proposer", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
rLimit = uint64(1)
|
|
|
|
sender = []byte("unique node")
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
isProposerFn: func(proposer []byte, _ uint64, _ uint64) bool {
|
|
|
|
return true
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
proposal := generateMessagesWithSender(1, proto.MessageType_PREPREPARE, sender)[0]
|
|
|
|
|
|
|
|
certificate := &proto.PreparedCertificate{
|
|
|
|
ProposalMessage: proposal,
|
|
|
|
PrepareMessages: generateMessagesWithUniqueSender(quorum-1, proto.MessageType_PREPARE),
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure they all have the same proposal hash
|
|
|
|
allMessages := append([]*proto.IbftMessage{certificate.ProposalMessage}, certificate.PrepareMessages...)
|
|
|
|
appendProposalHash(
|
|
|
|
allMessages,
|
|
|
|
correctRoundMessage.hash,
|
|
|
|
)
|
|
|
|
|
|
|
|
setRoundForMessages(allMessages, rLimit-1)
|
|
|
|
|
|
|
|
assert.False(t, i.validPC(certificate, rLimit, 0))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("completely valid PC", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
rLimit = uint64(1)
|
|
|
|
sender = []byte("unique node")
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
isProposerFn: func(proposer []byte, _ uint64, _ uint64) bool {
|
|
|
|
return bytes.Equal(proposer, sender)
|
|
|
|
},
|
|
|
|
IsValidValidatorFn: func(message *proto.IbftMessage) bool {
|
|
|
|
return true
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
require.NoError(t, i.validatorManager.Init(0))
|
|
|
|
|
|
|
|
proposal := generateMessagesWithSender(1, proto.MessageType_PREPREPARE, sender)[0]
|
|
|
|
|
|
|
|
certificate := &proto.PreparedCertificate{
|
|
|
|
ProposalMessage: proposal,
|
|
|
|
PrepareMessages: generateMessagesWithUniqueSender(quorum-1, proto.MessageType_PREPARE),
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure they all have the same proposal hash
|
|
|
|
allMessages := append([]*proto.IbftMessage{certificate.ProposalMessage}, certificate.PrepareMessages...)
|
|
|
|
appendProposalHash(
|
|
|
|
allMessages,
|
|
|
|
correctRoundMessage.hash,
|
|
|
|
)
|
|
|
|
|
|
|
|
setRoundForMessages(allMessages, rLimit-1)
|
|
|
|
|
|
|
|
assert.True(t, i.validPC(certificate, rLimit, 0))
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestIBFT_ValidateProposal(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
t.Run("proposer is not valid", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
log = mockLogger{}
|
|
|
|
backend = mockBackend{
|
|
|
|
isProposerFn: func(_ []byte, _ uint64, _ uint64) bool {
|
|
|
|
return false
|
|
|
|
},
|
|
|
|
}
|
|
|
|
transport = mockTransport{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
baseView := &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 0,
|
|
|
|
}
|
|
|
|
proposal := &proto.IbftMessage{
|
|
|
|
View: baseView,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Proposal: &proto.Proposal{
|
|
|
|
Round: baseView.Round,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validateProposal(proposal, baseView))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("block is not valid", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
log = mockLogger{}
|
|
|
|
backend = mockBackend{
|
|
|
|
isProposerFn: func(_ []byte, _ uint64, _ uint64) bool {
|
|
|
|
return true
|
|
|
|
},
|
|
|
|
isValidProposalFn: func(_ []byte) bool {
|
|
|
|
return false
|
|
|
|
},
|
|
|
|
}
|
|
|
|
transport = mockTransport{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
baseView := &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 0,
|
|
|
|
}
|
|
|
|
proposal := &proto.IbftMessage{
|
|
|
|
View: baseView,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Proposal: &proto.Proposal{
|
|
|
|
Round: 0,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validateProposal(proposal, baseView))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("proposal hash is not valid", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
log = mockLogger{}
|
|
|
|
backend = mockBackend{
|
|
|
|
isValidProposalHashFn: func(_ *proto.Proposal, _ []byte) bool {
|
|
|
|
return false
|
|
|
|
},
|
|
|
|
isProposerFn: func(_ []byte, _ uint64, _ uint64) bool {
|
|
|
|
return true
|
|
|
|
},
|
|
|
|
}
|
|
|
|
transport = mockTransport{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
baseView := &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 0,
|
|
|
|
}
|
|
|
|
proposal := &proto.IbftMessage{
|
|
|
|
View: baseView,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Proposal: &proto.Proposal{
|
|
|
|
Round: baseView.Round,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validateProposal(proposal, baseView))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("certificate is not present", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
log = mockLogger{}
|
|
|
|
backend = mockBackend{
|
|
|
|
isProposerFn: func(_ []byte, _ uint64, _ uint64) bool {
|
|
|
|
return true
|
|
|
|
},
|
|
|
|
}
|
|
|
|
transport = mockTransport{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
baseView := &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 0,
|
|
|
|
}
|
|
|
|
proposal := &proto.IbftMessage{
|
|
|
|
View: baseView,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Certificate: nil,
|
|
|
|
Proposal: &proto.Proposal{
|
|
|
|
Round: 0,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validateProposal(proposal, baseView))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("non unique senders", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
self = []byte("node id")
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{
|
|
|
|
idFn: func() []byte {
|
|
|
|
return self
|
|
|
|
},
|
|
|
|
isProposerFn: func(proposer []byte, _ uint64, _ uint64) bool {
|
|
|
|
return !bytes.Equal(proposer, self)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
baseView := &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 0,
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure all rcc are from same node
|
|
|
|
messages := generateMessages(quorum, proto.MessageType_ROUND_CHANGE)
|
|
|
|
for _, msg := range messages {
|
|
|
|
msg.From = []byte("non unique node id")
|
|
|
|
}
|
|
|
|
|
|
|
|
proposal := &proto.IbftMessage{
|
|
|
|
View: baseView,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Certificate: &proto.RoundChangeCertificate{
|
|
|
|
RoundChangeMessages: messages,
|
|
|
|
},
|
|
|
|
Proposal: &proto.Proposal{
|
|
|
|
Round: baseView.Round,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validateProposal(proposal, baseView))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("there are < quorum RC messages in the certificate", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
backend = mockBackend{
|
|
|
|
isProposerFn: func(_ []byte, _ uint64, _ uint64) bool {
|
|
|
|
return true
|
|
|
|
},
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
}
|
|
|
|
transport = mockTransport{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
baseView := &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 0,
|
|
|
|
}
|
|
|
|
proposal := &proto.IbftMessage{
|
|
|
|
View: baseView,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Certificate: &proto.RoundChangeCertificate{
|
|
|
|
RoundChangeMessages: generateMessages(quorum-1, proto.MessageType_ROUND_CHANGE),
|
|
|
|
},
|
|
|
|
Proposal: &proto.Proposal{
|
|
|
|
Round: 0,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validateProposal(proposal, baseView))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("current node should not be the proposer", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
id = []byte("node id")
|
|
|
|
uniqueNode = []byte("unique node")
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
backend = mockBackend{
|
|
|
|
idFn: func() []byte {
|
|
|
|
return id
|
|
|
|
},
|
|
|
|
isProposerFn: func(proposer []byte, _ uint64, _ uint64) bool {
|
|
|
|
if bytes.Equal(proposer, uniqueNode) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
return bytes.Equal(proposer, id)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
transport = mockTransport{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
baseView := &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 0,
|
|
|
|
}
|
|
|
|
proposal := &proto.IbftMessage{
|
|
|
|
View: baseView,
|
|
|
|
From: uniqueNode,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Certificate: &proto.RoundChangeCertificate{
|
|
|
|
RoundChangeMessages: generateMessages(quorum, proto.MessageType_ROUND_CHANGE),
|
|
|
|
},
|
|
|
|
Proposal: &proto.Proposal{
|
|
|
|
Round: 0,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validateProposal(proposal, baseView))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("sender is not the correct proposer", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
id = []byte("node id")
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
backend = mockBackend{
|
|
|
|
idFn: func() []byte {
|
|
|
|
return id
|
|
|
|
},
|
|
|
|
isProposerFn: func(proposer []byte, _ uint64, _ uint64) bool {
|
|
|
|
return bytes.Equal(proposer, id)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
transport = mockTransport{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
baseView := &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 0,
|
|
|
|
}
|
|
|
|
proposal := &proto.IbftMessage{
|
|
|
|
View: baseView,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Proposal: &proto.Proposal{
|
|
|
|
Round: baseView.Round,
|
|
|
|
},
|
|
|
|
Certificate: &proto.RoundChangeCertificate{
|
|
|
|
RoundChangeMessages: generateMessages(quorum, proto.MessageType_ROUND_CHANGE),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validateProposal(proposal, baseView))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("round is not correct", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
round = uint64(1)
|
|
|
|
id = []byte("node id")
|
|
|
|
uniqueNode = []byte("unique node")
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
backend = mockBackend{
|
|
|
|
idFn: func() []byte {
|
|
|
|
return id
|
|
|
|
},
|
|
|
|
isProposerFn: func(proposer []byte, _ uint64, _ uint64) bool {
|
|
|
|
if bytes.Equal(proposer, uniqueNode) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
return bytes.Equal(proposer, id)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
transport = mockTransport{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
baseView := &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: round,
|
|
|
|
}
|
|
|
|
proposal := &proto.IbftMessage{
|
|
|
|
View: baseView,
|
|
|
|
From: uniqueNode,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Certificate: &proto.RoundChangeCertificate{
|
|
|
|
RoundChangeMessages: generateMessages(quorum, proto.MessageType_ROUND_CHANGE),
|
|
|
|
},
|
|
|
|
Proposal: &proto.Proposal{
|
|
|
|
Round: 0,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validateProposal(proposal, baseView))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("A message in RoundChangeCertificate is not ROUND-CHANGE message", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
round = uint64(1)
|
|
|
|
id = []byte("node id")
|
|
|
|
uniqueNode = []byte("unique node")
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
backend = mockBackend{
|
|
|
|
idFn: func() []byte {
|
|
|
|
return id
|
|
|
|
},
|
|
|
|
isProposerFn: func(proposer []byte, _ uint64, _ uint64) bool {
|
|
|
|
return bytes.Equal(proposer, uniqueNode)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
transport = mockTransport{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
// 4 ROUND-CHANGE messages + 1 COMMIT message (wrong type message)
|
|
|
|
roundChangeMessages := make([]*proto.IbftMessage, 0)
|
|
|
|
|
|
|
|
for idx := 0; idx < int(quorum); idx++ {
|
|
|
|
roundChangeMessages = append(roundChangeMessages, &proto.IbftMessage{
|
|
|
|
From: []byte(fmt.Sprintf("node%d", idx)),
|
|
|
|
View: &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: round,
|
|
|
|
},
|
|
|
|
Type: proto.MessageType_ROUND_CHANGE,
|
|
|
|
Payload: &proto.IbftMessage_RoundChangeData{},
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
roundChangeMessages = append(roundChangeMessages, &proto.IbftMessage{
|
|
|
|
From: []byte(fmt.Sprintf("node%d", quorum)),
|
|
|
|
View: &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: 0,
|
|
|
|
},
|
|
|
|
Type: proto.MessageType_COMMIT,
|
|
|
|
Payload: &proto.IbftMessage_RoundChangeData{},
|
|
|
|
})
|
|
|
|
|
|
|
|
baseView := &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: round,
|
|
|
|
}
|
|
|
|
proposal := &proto.IbftMessage{
|
|
|
|
View: baseView,
|
|
|
|
From: uniqueNode,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Certificate: &proto.RoundChangeCertificate{
|
|
|
|
RoundChangeMessages: roundChangeMessages,
|
|
|
|
},
|
|
|
|
Proposal: &proto.Proposal{
|
|
|
|
Round: round,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validateProposal(proposal, baseView))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("One message in RoundChangeCertificate has wrong height", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
round = uint64(1)
|
|
|
|
id = []byte("node id")
|
|
|
|
uniqueNode = []byte("unique node")
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
backend = mockBackend{
|
|
|
|
idFn: func() []byte {
|
|
|
|
return id
|
|
|
|
},
|
|
|
|
isProposerFn: func(proposer []byte, _ uint64, _ uint64) bool {
|
|
|
|
return bytes.Equal(proposer, uniqueNode)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
transport = mockTransport{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
// 4 ROUND-CHANGE messages
|
|
|
|
roundChangeMessages := make([]*proto.IbftMessage, quorum)
|
|
|
|
|
|
|
|
for idx := range roundChangeMessages {
|
|
|
|
roundChangeMessages[idx] = &proto.IbftMessage{
|
|
|
|
From: []byte(fmt.Sprintf("node%d", idx)),
|
|
|
|
View: &proto.View{
|
|
|
|
Height: 100, // wrong height
|
|
|
|
Round: round,
|
|
|
|
},
|
|
|
|
Type: proto.MessageType_ROUND_CHANGE,
|
|
|
|
Payload: &proto.IbftMessage_RoundChangeData{},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
baseView := &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: round,
|
|
|
|
}
|
|
|
|
proposal := &proto.IbftMessage{
|
|
|
|
View: baseView,
|
|
|
|
From: uniqueNode,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Certificate: &proto.RoundChangeCertificate{
|
|
|
|
RoundChangeMessages: roundChangeMessages,
|
|
|
|
},
|
|
|
|
Proposal: &proto.Proposal{
|
|
|
|
Round: round,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validateProposal(proposal, baseView))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("One message in RoundChangeCertificate has wrong round", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
round = uint64(1)
|
|
|
|
id = []byte("node id")
|
|
|
|
uniqueNode = []byte("unique node")
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
backend = mockBackend{
|
|
|
|
idFn: func() []byte {
|
|
|
|
return id
|
|
|
|
},
|
|
|
|
isProposerFn: func(proposer []byte, _ uint64, _ uint64) bool {
|
|
|
|
return bytes.Equal(proposer, uniqueNode)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
transport = mockTransport{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
// 4 ROUND-CHANGE messages with wrong round
|
|
|
|
roundChangeMessages := make([]*proto.IbftMessage, quorum)
|
|
|
|
|
|
|
|
for idx := range roundChangeMessages {
|
|
|
|
roundChangeMessages[idx] = &proto.IbftMessage{
|
|
|
|
From: []byte(fmt.Sprintf("node%d", idx)),
|
|
|
|
View: &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: round + 1, // wrong round
|
|
|
|
},
|
|
|
|
Type: proto.MessageType_ROUND_CHANGE,
|
|
|
|
Payload: &proto.IbftMessage_RoundChangeData{},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
baseView := &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: round,
|
|
|
|
}
|
|
|
|
proposal := &proto.IbftMessage{
|
|
|
|
View: baseView,
|
|
|
|
From: uniqueNode,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Certificate: &proto.RoundChangeCertificate{
|
|
|
|
RoundChangeMessages: roundChangeMessages,
|
|
|
|
},
|
|
|
|
Proposal: &proto.Proposal{
|
|
|
|
Round: round,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validateProposal(proposal, baseView))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("One message in RoundChangeCertificate is created by non-validator", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
round = uint64(1)
|
|
|
|
id = []byte("node id")
|
|
|
|
uniqueNode = []byte("unique node")
|
|
|
|
nonValidator = []byte("non validator")
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
backend = mockBackend{
|
|
|
|
idFn: func() []byte {
|
|
|
|
return id
|
|
|
|
},
|
|
|
|
isProposerFn: func(proposer []byte, _ uint64, _ uint64) bool {
|
|
|
|
return bytes.Equal(proposer, uniqueNode)
|
|
|
|
},
|
|
|
|
IsValidValidatorFn: func(m *proto.IbftMessage) bool {
|
|
|
|
return !bytes.Equal(m.From, nonValidator)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
transport = mockTransport{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
// 4 ROUND-CHANGE messages by validators + 1 ROUND-CHANGE message by non-validator
|
|
|
|
roundChangeMessages := make([]*proto.IbftMessage, 0)
|
|
|
|
|
|
|
|
for idx := 0; idx < int(quorum); idx++ {
|
|
|
|
roundChangeMessages = append(roundChangeMessages, &proto.IbftMessage{
|
|
|
|
From: []byte(fmt.Sprintf("node%d", idx)),
|
|
|
|
View: &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: round,
|
|
|
|
},
|
|
|
|
Type: proto.MessageType_ROUND_CHANGE,
|
|
|
|
Payload: &proto.IbftMessage_RoundChangeData{},
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
roundChangeMessages = append(roundChangeMessages, &proto.IbftMessage{
|
|
|
|
From: nonValidator,
|
|
|
|
View: &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: round,
|
|
|
|
},
|
|
|
|
Type: proto.MessageType_ROUND_CHANGE,
|
|
|
|
Payload: &proto.IbftMessage_RoundChangeData{},
|
|
|
|
})
|
|
|
|
|
|
|
|
baseView := &proto.View{
|
|
|
|
Height: 0,
|
|
|
|
Round: round,
|
|
|
|
}
|
|
|
|
proposal := &proto.IbftMessage{
|
|
|
|
View: baseView,
|
|
|
|
From: uniqueNode,
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Certificate: &proto.RoundChangeCertificate{
|
|
|
|
RoundChangeMessages: roundChangeMessages,
|
|
|
|
},
|
|
|
|
Proposal: &proto.Proposal{
|
|
|
|
Round: round,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validateProposal(proposal, baseView))
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("hash of (RawProposal, maxRound) doesn't equal to the hash in proposal message", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
quorum = uint64(4)
|
|
|
|
round = uint64(2)
|
|
|
|
id = []byte("node id")
|
|
|
|
proposers = [][]byte{
|
|
|
|
[]byte("proposer 0"), // proposer for round 0
|
|
|
|
[]byte("proposer 1"), // proposer for round 1
|
|
|
|
[]byte("proposer 2"), // proposer for round 2
|
|
|
|
}
|
|
|
|
|
|
|
|
nonValidator = []byte("non validator")
|
|
|
|
rawProposal = []byte("raw proposal")
|
|
|
|
|
|
|
|
hashFn = func(rawProposal []byte, round uint64) []byte {
|
|
|
|
return []byte(fmt.Sprintf("%s_%d", rawProposal, round))
|
|
|
|
}
|
|
|
|
|
|
|
|
correctProposalHash = hashFn(rawProposal, round)
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
backend = mockBackend{
|
|
|
|
idFn: func() []byte {
|
|
|
|
return id
|
|
|
|
},
|
|
|
|
isProposerFn: func(proposer []byte, _ uint64, round uint64) bool {
|
|
|
|
return bytes.Equal(proposer, proposers[round])
|
|
|
|
},
|
|
|
|
IsValidValidatorFn: func(m *proto.IbftMessage) bool {
|
|
|
|
return !bytes.Equal(m.From, nonValidator)
|
|
|
|
},
|
|
|
|
isValidProposalHashFn: func(p *proto.Proposal, b []byte) bool {
|
|
|
|
return bytes.Equal(
|
|
|
|
b,
|
|
|
|
hashFn(p.RawProposal, p.Round),
|
|
|
|
)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
transport = mockTransport{}
|
|
|
|
|
|
|
|
views = []*proto.View{
|
|
|
|
{
|
|
|
|
Height: 0,
|
|
|
|
Round: round - 2,
|
|
|
|
},
|
|
|
|
// previous round
|
|
|
|
{
|
|
|
|
Height: 0,
|
|
|
|
Round: round - 1,
|
|
|
|
},
|
|
|
|
// current round
|
|
|
|
{
|
|
|
|
Height: 0,
|
|
|
|
Round: round,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
// previous PREPREPARE + PREPARE messages whose proposal hashes are not correct
|
|
|
|
previousProposal := &proto.IbftMessage{
|
|
|
|
View: views[0],
|
|
|
|
From: proposers[0],
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
// the hash should be (proposal, 0)
|
|
|
|
Proposal: &proto.Proposal{
|
|
|
|
Round: round - 2,
|
|
|
|
RawProposal: rawProposal,
|
|
|
|
},
|
|
|
|
// the hash is created from (proposal, 2)
|
|
|
|
ProposalHash: correctProposalHash,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
previousPrepares := make([]*proto.IbftMessage, quorum)
|
|
|
|
for idx := range previousPrepares {
|
|
|
|
previousPrepares[idx] = &proto.IbftMessage{
|
|
|
|
From: []byte(fmt.Sprintf("node%d", idx)),
|
|
|
|
View: views[0],
|
|
|
|
Type: proto.MessageType_PREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PrepareData{
|
|
|
|
PrepareData: &proto.PrepareMessage{
|
|
|
|
ProposalHash: correctProposalHash,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// ROUND-CHANGE messages for round 2
|
|
|
|
roundChangeMessages := make([]*proto.IbftMessage, quorum)
|
|
|
|
|
|
|
|
for idx := range roundChangeMessages {
|
|
|
|
roundChangeMessages[idx] = &proto.IbftMessage{
|
|
|
|
From: []byte(fmt.Sprintf("node%d", idx)),
|
|
|
|
View: views[2],
|
|
|
|
Type: proto.MessageType_ROUND_CHANGE,
|
|
|
|
Payload: &proto.IbftMessage_RoundChangeData{
|
|
|
|
RoundChangeData: &proto.RoundChangeMessage{
|
|
|
|
LatestPreparedCertificate: &proto.PreparedCertificate{
|
|
|
|
ProposalMessage: previousProposal,
|
|
|
|
PrepareMessages: previousPrepares,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// proposal with RoundChangeCertificate
|
|
|
|
proposal := &proto.IbftMessage{
|
|
|
|
View: views[2],
|
|
|
|
From: proposers[2],
|
|
|
|
Type: proto.MessageType_PREPREPARE,
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Certificate: &proto.RoundChangeCertificate{
|
|
|
|
RoundChangeMessages: roundChangeMessages,
|
|
|
|
},
|
|
|
|
ProposalHash: hashFn(rawProposal, round),
|
|
|
|
Proposal: &proto.Proposal{
|
|
|
|
Round: round,
|
|
|
|
RawProposal: rawProposal,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
assert.False(t, i.validateProposal(proposal, views[2]))
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestIBFT_WatchForFutureRCC verifies that future RCC
|
|
|
|
// are handled properly
|
|
|
|
func TestIBFT_WatchForFutureRCC(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
quorum := uint64(4)
|
|
|
|
rccRound := uint64(10)
|
|
|
|
|
|
|
|
roundChangeMessages := generateFilledRCMessages(quorum, correctRoundMessage.proposal, correctRoundMessage.hash)
|
|
|
|
setRoundForMessages(roundChangeMessages, rccRound)
|
|
|
|
|
|
|
|
var (
|
|
|
|
wg sync.WaitGroup
|
|
|
|
|
|
|
|
receivedRound = uint64(0)
|
|
|
|
notifyCh = make(chan uint64, 1)
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
backend = mockBackend{
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
isProposerFn: func(proposer []byte, _ uint64, _ uint64) bool {
|
|
|
|
return bytes.Equal(proposer, []byte("unique node"))
|
|
|
|
},
|
|
|
|
}
|
|
|
|
messages = mockMessages{
|
|
|
|
subscribeFn: func(_ messages.SubscriptionDetails) *messages.Subscription {
|
|
|
|
return &messages.Subscription{
|
|
|
|
ID: messages.SubscriptionID(1),
|
|
|
|
SubCh: notifyCh,
|
|
|
|
}
|
|
|
|
},
|
|
|
|
getValidMessagesFn: func(
|
|
|
|
view *proto.View,
|
|
|
|
messageType proto.MessageType,
|
|
|
|
isValid func(message *proto.IbftMessage) bool,
|
|
|
|
) []*proto.IbftMessage {
|
|
|
|
return filterMessages(
|
|
|
|
roundChangeMessages,
|
|
|
|
isValid,
|
|
|
|
)
|
|
|
|
},
|
|
|
|
getExtendedRCCFn: func(
|
|
|
|
height uint64,
|
|
|
|
isValidMessage func(message *proto.IbftMessage) bool,
|
|
|
|
isValidRCC func(round uint64, messages []*proto.IbftMessage) bool,
|
|
|
|
) []*proto.IbftMessage {
|
|
|
|
messages := filterMessages(
|
|
|
|
roundChangeMessages,
|
|
|
|
isValidMessage,
|
|
|
|
)
|
|
|
|
|
|
|
|
if len(messages) == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
round := messages[0].View.Round
|
|
|
|
if !isValidRCC(round, messages) {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
return messages
|
|
|
|
},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
require.NoError(t, i.validatorManager.Init(uint64(0)))
|
|
|
|
|
|
|
|
i.messages = messages
|
|
|
|
|
|
|
|
ctx, cancelFn := context.WithCancel(context.Background())
|
|
|
|
|
|
|
|
wg.Add(1)
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
defer func() {
|
|
|
|
cancelFn()
|
|
|
|
wg.Done()
|
|
|
|
}()
|
|
|
|
|
|
|
|
select {
|
|
|
|
case r := <-i.roundCertificate:
|
|
|
|
receivedRound = r
|
|
|
|
case <-time.After(5 * time.Second):
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
// Have the notification waiting
|
|
|
|
notifyCh <- rccRound
|
|
|
|
|
|
|
|
i.wg.Add(1)
|
|
|
|
i.watchForRoundChangeCertificates(ctx)
|
|
|
|
i.wg.Wait()
|
|
|
|
|
|
|
|
// Make sure the notification round was correct
|
|
|
|
wg.Wait()
|
|
|
|
assert.Equal(t, rccRound, receivedRound)
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestState_String makes sure the string representation
|
|
|
|
// of states is correct
|
|
|
|
func TestState_String(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
stringMap := map[stateType]string{
|
|
|
|
newRound: "new round",
|
|
|
|
prepare: "prepare",
|
|
|
|
commit: "commit",
|
|
|
|
fin: "fin",
|
|
|
|
}
|
|
|
|
|
|
|
|
stateTypes := []stateType{
|
|
|
|
newRound,
|
|
|
|
prepare,
|
|
|
|
commit,
|
|
|
|
fin,
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, stateT := range stateTypes {
|
|
|
|
assert.Equal(t, stringMap[stateT], stateT.String())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestIBFT_RunSequence_NewProposal verifies that the
|
|
|
|
// state changes correctly when receiving a higher proposal event
|
|
|
|
func TestIBFT_RunSequence_NewProposal(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
ctx, cancelFn := context.WithCancel(context.Background())
|
|
|
|
defer cancelFn()
|
|
|
|
|
|
|
|
var (
|
|
|
|
proposal = &proto.Proposal{}
|
|
|
|
round = uint64(10)
|
|
|
|
height = uint64(1)
|
|
|
|
quorum = uint64(4)
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
backend = mockBackend{
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
}
|
|
|
|
transport = mockTransport{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
i.newProposal = make(chan newProposalEvent, 1)
|
|
|
|
|
|
|
|
ev := newProposalEvent{
|
|
|
|
proposalMessage: &proto.IbftMessage{
|
|
|
|
Payload: &proto.IbftMessage_PreprepareData{
|
|
|
|
PreprepareData: &proto.PrePrepareMessage{
|
|
|
|
Proposal: proposal,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
round: round,
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure the event is waiting
|
|
|
|
i.newProposal <- ev
|
|
|
|
|
|
|
|
// Spawn a go-routine that's going to turn off the sequence after 1s
|
|
|
|
go func() {
|
|
|
|
defer cancelFn()
|
|
|
|
|
|
|
|
<-time.After(1 * time.Second)
|
|
|
|
}()
|
|
|
|
|
|
|
|
i.RunSequence(ctx, height)
|
|
|
|
|
|
|
|
// Make sure the correct proposal message was accepted
|
|
|
|
assert.Equal(t, ev.proposalMessage, i.state.proposalMessage)
|
|
|
|
|
|
|
|
// Make sure the correct round was moved to
|
|
|
|
assert.Equal(t, ev.round, i.state.view.Round)
|
|
|
|
assert.Equal(t, height, i.state.view.Height)
|
|
|
|
|
|
|
|
// Make sure the round has been started
|
|
|
|
assert.True(t, i.state.roundStarted)
|
|
|
|
|
|
|
|
// Make sure the state is the prepare state
|
|
|
|
assert.Equal(t, prepare, i.state.name)
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestIBFT_RunSequence_FutureRCC verifies that the
|
|
|
|
// state changes correctly when receiving a higher RCC event
|
|
|
|
func TestIBFT_RunSequence_FutureRCC(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
ctx, cancelFn := context.WithCancel(context.Background())
|
|
|
|
defer cancelFn()
|
|
|
|
|
|
|
|
var (
|
|
|
|
round = uint64(10)
|
|
|
|
height = uint64(1)
|
|
|
|
quorum = uint64(4)
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
backend = mockBackend{
|
|
|
|
getVotingPowerFn: testCommonGetVotingPowertFnForCnt(quorum),
|
|
|
|
}
|
|
|
|
transport = mockTransport{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
i.roundCertificate = make(chan uint64, 1)
|
|
|
|
|
|
|
|
// Make sure the round event is waiting
|
|
|
|
i.roundCertificate <- round
|
|
|
|
|
|
|
|
// Spawn a go-routine that's going to turn off the sequence after 1s
|
|
|
|
go func() {
|
|
|
|
defer cancelFn()
|
|
|
|
|
|
|
|
<-time.After(1 * time.Second)
|
|
|
|
}()
|
|
|
|
|
|
|
|
i.RunSequence(ctx, height)
|
|
|
|
|
|
|
|
// Make sure the proposal message is not set
|
|
|
|
assert.Nil(t, i.state.proposalMessage)
|
|
|
|
|
|
|
|
// Make sure the correct round was moved to
|
|
|
|
assert.Equal(t, round, i.state.view.Round)
|
|
|
|
assert.Equal(t, height, i.state.view.Height)
|
|
|
|
|
|
|
|
// Make sure the new round has been started
|
|
|
|
assert.True(t, i.state.roundStarted)
|
|
|
|
|
|
|
|
// Make sure the state is the new round state
|
|
|
|
assert.Equal(t, newRound, i.state.name)
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestIBFT_ExtendRoundTimer makes sure the round timeout
|
|
|
|
// is extended correctly
|
|
|
|
func TestIBFT_ExtendRoundTimer(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var (
|
|
|
|
additionalTimeout = 10 * time.Second
|
|
|
|
|
|
|
|
log = mockLogger{}
|
|
|
|
backend = mockBackend{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
)
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
|
|
|
|
i.ExtendRoundTimeout(additionalTimeout)
|
|
|
|
|
|
|
|
// Make sure the round timeout was extended
|
|
|
|
assert.Equal(t, additionalTimeout, i.additionalTimeout)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestIBFTOverrideBaseRoundTimeout(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
baseRoundTimeout := 50 * time.Second
|
|
|
|
|
|
|
|
i := NewIBFT(mockLogger{}, mockBackend{}, mockTransport{})
|
|
|
|
i.SetBaseRoundTimeout(baseRoundTimeout)
|
|
|
|
|
|
|
|
// Make sure the base round timeout is properly set
|
|
|
|
assert.Equal(t, baseRoundTimeout, i.baseRoundTimeout)
|
|
|
|
}
|
|
|
|
|
|
|
|
func Test_getRoundTimeout(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
type args struct {
|
|
|
|
baseRoundTimeout time.Duration
|
|
|
|
additionalTimeout time.Duration
|
|
|
|
round uint64
|
|
|
|
}
|
|
|
|
|
|
|
|
tests := []struct {
|
|
|
|
name string
|
|
|
|
args args
|
|
|
|
want time.Duration
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "zero round duration",
|
|
|
|
args: args{
|
|
|
|
baseRoundTimeout: time.Second,
|
|
|
|
additionalTimeout: time.Second,
|
|
|
|
round: 0,
|
|
|
|
},
|
|
|
|
want: time.Second * 2,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "first round duration",
|
|
|
|
args: args{
|
|
|
|
baseRoundTimeout: time.Second,
|
|
|
|
additionalTimeout: time.Second,
|
|
|
|
round: 1,
|
|
|
|
},
|
|
|
|
want: time.Second * 3,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "third round duration",
|
|
|
|
args: args{
|
|
|
|
baseRoundTimeout: time.Second,
|
|
|
|
round: 3,
|
|
|
|
},
|
|
|
|
want: time.Second * 8,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
tt := tt
|
|
|
|
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
got := getRoundTimeout(tt.args.baseRoundTimeout, tt.args.additionalTimeout, tt.args.round)
|
|
|
|
assert.Equalf(t, tt.want, got, "getRoundTimeout(%v, %v, %v)", tt.args.baseRoundTimeout, tt.args.additionalTimeout, tt.args.round)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestIBFT_AddMessage(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
const (
|
|
|
|
validHeight = uint64(10)
|
|
|
|
validRound = uint64(7)
|
|
|
|
validMsgType = proto.MessageType_PREPREPARE
|
|
|
|
)
|
|
|
|
|
|
|
|
var validSender = []byte("node 0")
|
|
|
|
|
|
|
|
executeTest := func(
|
|
|
|
msg *proto.IbftMessage, shouldAddMessageCalled, shouldSignalEventCalled bool, quorumSize uint64) {
|
|
|
|
var (
|
|
|
|
signalEventCalled = false
|
|
|
|
addMessageCalled = false
|
|
|
|
log = mockLogger{}
|
|
|
|
backend = mockBackend{}
|
|
|
|
transport = mockTransport{}
|
|
|
|
messages = mockMessages{}
|
|
|
|
)
|
|
|
|
|
|
|
|
backend.IsValidValidatorFn = func(m *proto.IbftMessage) bool {
|
|
|
|
return bytes.Equal(m.From, validSender)
|
|
|
|
}
|
|
|
|
|
|
|
|
backend.getVotingPowerFn = testCommonGetVotingPowertFnForCnt(quorumSize)
|
|
|
|
|
|
|
|
messages.getValidMessagesFn = func(
|
|
|
|
view *proto.View,
|
|
|
|
messageType proto.MessageType,
|
|
|
|
isValid func(message *proto.IbftMessage) bool,
|
|
|
|
) []*proto.IbftMessage {
|
|
|
|
return []*proto.IbftMessage{msg}
|
|
|
|
}
|
|
|
|
|
|
|
|
messages.addMessageFn = func(m *proto.IbftMessage) {
|
|
|
|
addMessageCalled = true
|
|
|
|
|
|
|
|
assert.Equal(t, msg, m)
|
|
|
|
}
|
|
|
|
|
|
|
|
messages.signalEventFn = func(messageType proto.MessageType, messageView *proto.View) {
|
|
|
|
signalEventCalled = true
|
|
|
|
}
|
|
|
|
|
|
|
|
i := NewIBFT(log, backend, transport)
|
|
|
|
require.NoError(t, i.validatorManager.Init(0))
|
|
|
|
i.messages = messages
|
|
|
|
i.state.view = &proto.View{Height: validHeight, Round: validRound}
|
|
|
|
|
|
|
|
i.AddMessage(msg)
|
|
|
|
|
|
|
|
assert.Equal(t, shouldAddMessageCalled, addMessageCalled)
|
|
|
|
assert.Equal(t, shouldSignalEventCalled, signalEventCalled)
|
|
|
|
}
|
|
|
|
|
|
|
|
t.Run("nil message case", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
executeTest(nil, false, false, 1)
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("!isAcceptableMessage - invalid sender", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
msg := &proto.IbftMessage{
|
|
|
|
View: &proto.View{Height: validHeight, Round: validRound},
|
|
|
|
Type: validMsgType,
|
|
|
|
}
|
|
|
|
executeTest(msg, false, false, 1)
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("!isAcceptableMessage - invalid view", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
msg := &proto.IbftMessage{
|
|
|
|
From: validSender,
|
|
|
|
Type: validMsgType,
|
|
|
|
}
|
|
|
|
executeTest(msg, false, false, 1)
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("!isAcceptableMessage - invalid height", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
msg := &proto.IbftMessage{
|
|
|
|
From: validSender,
|
|
|
|
Type: validMsgType,
|
|
|
|
View: &proto.View{Height: validHeight - 1, Round: validRound},
|
|
|
|
}
|
|
|
|
executeTest(msg, false, false, 1)
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("!isAcceptableMessage - invalid round", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
msg := &proto.IbftMessage{
|
|
|
|
From: validSender,
|
|
|
|
Type: validMsgType,
|
|
|
|
View: &proto.View{Height: validHeight, Round: validRound - 1},
|
|
|
|
}
|
|
|
|
executeTest(msg, false, false, 1)
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("correct - but quorum not reached", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
msg := &proto.IbftMessage{
|
|
|
|
From: validSender,
|
|
|
|
Type: proto.MessageType_PREPARE,
|
|
|
|
View: &proto.View{Height: validHeight, Round: validRound},
|
|
|
|
}
|
|
|
|
executeTest(msg, true, false, 2)
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("correct - quorum reached", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
msg := &proto.IbftMessage{
|
|
|
|
From: validSender,
|
|
|
|
Type: validMsgType,
|
|
|
|
View: &proto.View{Height: validHeight, Round: validRound},
|
|
|
|
}
|
|
|
|
executeTest(msg, true, true, 1)
|
|
|
|
})
|
|
|
|
}
|