mirror of https://github.com/poanetwork/gecko.git
1130 lines
27 KiB
Go
1130 lines
27 KiB
Go
// (c) 2019-2020, Ava Labs, Inc. All rights reserved.
|
|
// See the file LICENSE for licensing terms.
|
|
|
|
package snowman
|
|
|
|
import (
|
|
"errors"
|
|
"math/rand"
|
|
"testing"
|
|
|
|
"github.com/prometheus/client_golang/prometheus"
|
|
|
|
"github.com/ava-labs/gecko/ids"
|
|
"github.com/ava-labs/gecko/snow"
|
|
"github.com/ava-labs/gecko/snow/choices"
|
|
"github.com/ava-labs/gecko/snow/consensus/snowball"
|
|
)
|
|
|
|
var (
|
|
GenesisID = ids.Empty.Prefix(0)
|
|
Genesis = &TestBlock{
|
|
id: GenesisID,
|
|
status: choices.Accepted,
|
|
}
|
|
|
|
Tests = []func(*testing.T, Factory){
|
|
InitializeTest,
|
|
AddToTailTest,
|
|
AddToNonTailTest,
|
|
AddToUnknownTest,
|
|
IssuedPreviouslyAcceptedTest,
|
|
IssuedPreviouslyRejectedTest,
|
|
IssuedUnissuedTest,
|
|
IssuedIssuedTest,
|
|
RecordPollAcceptSingleBlockTest,
|
|
RecordPollAcceptAndRejectTest,
|
|
RecordPollWhenFinalizedTest,
|
|
RecordPollRejectTransitivelyTest,
|
|
RecordPollTransitivelyResetConfidenceTest,
|
|
RecordPollInvalidVoteTest,
|
|
RecordPollTransitiveVotingTest,
|
|
RecordPollDivergedVotingTest,
|
|
MetricsProcessingErrorTest,
|
|
MetricsAcceptedErrorTest,
|
|
MetricsRejectedErrorTest,
|
|
ErrorOnInitialRejectionTest,
|
|
ErrorOnAcceptTest,
|
|
ErrorOnRejectSiblingTest,
|
|
ErrorOnTransitiveRejectionTest,
|
|
RandomizedConsistencyTest,
|
|
}
|
|
)
|
|
|
|
// Execute all tests against a consensus implementation
|
|
func ConsensusTest(t *testing.T, factory Factory) {
|
|
for _, test := range Tests {
|
|
test(t, factory)
|
|
}
|
|
}
|
|
|
|
// Make sure that initialize sets the state correctly
|
|
func InitializeTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 3,
|
|
BetaRogue: 5,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
if p := sm.Parameters(); p != params {
|
|
t.Fatalf("Wrong returned parameters")
|
|
} else if pref := sm.Preference(); !pref.Equals(GenesisID) {
|
|
t.Fatalf("Wrong preference returned")
|
|
} else if !sm.Finalized() {
|
|
t.Fatalf("Wrong should have marked the instance as being finalized")
|
|
}
|
|
}
|
|
|
|
// Make sure that adding a block to the tail updates the preference
|
|
func AddToTailTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 3,
|
|
BetaRogue: 5,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
block := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(1),
|
|
}
|
|
|
|
// Adding to the previous preference will update the preference
|
|
if err := sm.Add(block); err != nil {
|
|
t.Fatal(err)
|
|
} else if pref := sm.Preference(); !pref.Equals(block.id) {
|
|
t.Fatalf("Wrong preference. Expected %s, got %s", block.id, pref)
|
|
}
|
|
}
|
|
|
|
// Make sure that adding a block not to the tail doesn't change the preference
|
|
func AddToNonTailTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 3,
|
|
BetaRogue: 5,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
firstBlock := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(1),
|
|
}
|
|
secondBlock := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(2),
|
|
}
|
|
|
|
// Adding to the previous preference will update the preference
|
|
if err := sm.Add(firstBlock); err != nil {
|
|
t.Fatal(err)
|
|
} else if pref := sm.Preference(); !pref.Equals(firstBlock.id) {
|
|
t.Fatalf("Wrong preference. Expected %s, got %s", firstBlock.id, pref)
|
|
}
|
|
|
|
// Adding to something other than the previous preference won't update the
|
|
// preference
|
|
if err := sm.Add(secondBlock); err != nil {
|
|
t.Fatal(err)
|
|
} else if pref := sm.Preference(); !pref.Equals(firstBlock.id) {
|
|
t.Fatalf("Wrong preference. Expected %s, got %s", firstBlock.id, pref)
|
|
}
|
|
}
|
|
|
|
// Make sure that adding a block that is detached from the rest of the tree
|
|
// rejects the block
|
|
func AddToUnknownTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 3,
|
|
BetaRogue: 5,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
block := &TestBlock{
|
|
parent: &TestBlock{id: ids.Empty.Prefix(1)},
|
|
id: ids.Empty.Prefix(2),
|
|
}
|
|
|
|
// Adding a block with an unknown parent means the parent must have already
|
|
// been rejected. Therefore the block should be immediately rejected
|
|
if err := sm.Add(block); err != nil {
|
|
t.Fatal(err)
|
|
} else if pref := sm.Preference(); !pref.Equals(GenesisID) {
|
|
t.Fatalf("Wrong preference. Expected %s, got %s", GenesisID, pref)
|
|
} else if status := block.Status(); status != choices.Rejected {
|
|
t.Fatalf("Should have rejected the block")
|
|
}
|
|
}
|
|
|
|
func IssuedPreviouslyAcceptedTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 3,
|
|
BetaRogue: 5,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
if !sm.Issued(Genesis) {
|
|
t.Fatalf("Should have marked an accepted block as having been issued")
|
|
}
|
|
}
|
|
|
|
func IssuedPreviouslyRejectedTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 3,
|
|
BetaRogue: 5,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
block := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(1),
|
|
status: choices.Rejected,
|
|
}
|
|
|
|
if !sm.Issued(block) {
|
|
t.Fatalf("Should have marked a rejected block as having been issued")
|
|
}
|
|
}
|
|
|
|
func IssuedUnissuedTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 3,
|
|
BetaRogue: 5,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
block := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(1),
|
|
status: choices.Processing,
|
|
}
|
|
|
|
if sm.Issued(block) {
|
|
t.Fatalf("Shouldn't have marked an unissued block as having been issued")
|
|
}
|
|
}
|
|
|
|
func IssuedIssuedTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 3,
|
|
BetaRogue: 5,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
block := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(1),
|
|
status: choices.Processing,
|
|
}
|
|
|
|
if err := sm.Add(block); err != nil {
|
|
t.Fatal(err)
|
|
} else if !sm.Issued(block) {
|
|
t.Fatalf("Should have marked a pending block as having been issued")
|
|
}
|
|
}
|
|
|
|
func RecordPollAcceptSingleBlockTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 2,
|
|
BetaRogue: 3,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
block := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(1),
|
|
status: choices.Processing,
|
|
}
|
|
|
|
if err := sm.Add(block); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
votes := ids.Bag{}
|
|
votes.Add(block.id)
|
|
if err := sm.RecordPoll(votes); err != nil {
|
|
t.Fatal(err)
|
|
} else if pref := sm.Preference(); !pref.Equals(block.id) {
|
|
t.Fatalf("Preference returned the wrong block")
|
|
} else if sm.Finalized() {
|
|
t.Fatalf("Snowman instance finalized too soon")
|
|
} else if status := block.Status(); status != choices.Processing {
|
|
t.Fatalf("Block's status changed unexpectedly")
|
|
} else if err := sm.RecordPoll(votes); err != nil {
|
|
t.Fatal(err)
|
|
} else if pref := sm.Preference(); !pref.Equals(block.id) {
|
|
t.Fatalf("Preference returned the wrong block")
|
|
} else if !sm.Finalized() {
|
|
t.Fatalf("Snowman instance didn't finalize")
|
|
} else if status := block.Status(); status != choices.Accepted {
|
|
t.Fatalf("Block's status should have been set to accepted")
|
|
}
|
|
}
|
|
|
|
func RecordPollAcceptAndRejectTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 1,
|
|
BetaRogue: 2,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
firstBlock := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(1),
|
|
status: choices.Processing,
|
|
}
|
|
secondBlock := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(2),
|
|
status: choices.Processing,
|
|
}
|
|
|
|
if err := sm.Add(firstBlock); err != nil {
|
|
t.Fatal(err)
|
|
} else if err := sm.Add(secondBlock); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
votes := ids.Bag{}
|
|
votes.Add(firstBlock.id)
|
|
|
|
if err := sm.RecordPoll(votes); err != nil {
|
|
t.Fatal(err)
|
|
} else if pref := sm.Preference(); !pref.Equals(firstBlock.id) {
|
|
t.Fatalf("Preference returned the wrong block")
|
|
} else if sm.Finalized() {
|
|
t.Fatalf("Snowman instance finalized too soon")
|
|
} else if status := firstBlock.Status(); status != choices.Processing {
|
|
t.Fatalf("Block's status changed unexpectedly")
|
|
} else if status := secondBlock.Status(); status != choices.Processing {
|
|
t.Fatalf("Block's status changed unexpectedly")
|
|
} else if err := sm.RecordPoll(votes); err != nil {
|
|
t.Fatal(err)
|
|
} else if pref := sm.Preference(); !pref.Equals(firstBlock.id) {
|
|
t.Fatalf("Preference returned the wrong block")
|
|
} else if !sm.Finalized() {
|
|
t.Fatalf("Snowman instance didn't finalize")
|
|
} else if status := firstBlock.Status(); status != choices.Accepted {
|
|
t.Fatalf("Block's status should have been set to accepted")
|
|
} else if status := secondBlock.Status(); status != choices.Rejected {
|
|
t.Fatalf("Block's status should have been set to rejected")
|
|
}
|
|
}
|
|
|
|
func RecordPollWhenFinalizedTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 1,
|
|
BetaRogue: 2,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
votes := ids.Bag{}
|
|
votes.Add(GenesisID)
|
|
if err := sm.RecordPoll(votes); err != nil {
|
|
t.Fatal(err)
|
|
} else if !sm.Finalized() {
|
|
t.Fatalf("Consensus should still be finalized")
|
|
} else if pref := sm.Preference(); !GenesisID.Equals(pref) {
|
|
t.Fatalf("Wrong preference listed")
|
|
}
|
|
}
|
|
|
|
func RecordPollRejectTransitivelyTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 1,
|
|
BetaRogue: 1,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
block0 := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(1),
|
|
status: choices.Processing,
|
|
}
|
|
block1 := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(2),
|
|
status: choices.Processing,
|
|
}
|
|
block2 := &TestBlock{
|
|
parent: block1,
|
|
id: ids.Empty.Prefix(3),
|
|
status: choices.Processing,
|
|
}
|
|
|
|
if err := sm.Add(block0); err != nil {
|
|
t.Fatal(err)
|
|
} else if err := sm.Add(block1); err != nil {
|
|
t.Fatal(err)
|
|
} else if err := sm.Add(block2); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Current graph structure:
|
|
// G
|
|
// / \
|
|
// 0 1
|
|
// |
|
|
// 2
|
|
// Tail = 0
|
|
|
|
votes := ids.Bag{}
|
|
votes.Add(block0.id)
|
|
if err := sm.RecordPoll(votes); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Current graph structure:
|
|
// 0
|
|
// Tail = 0
|
|
|
|
if !sm.Finalized() {
|
|
t.Fatalf("Finalized too late")
|
|
} else if pref := sm.Preference(); !block0.id.Equals(pref) {
|
|
t.Fatalf("Wrong preference listed")
|
|
} else if status := block0.Status(); status != choices.Accepted {
|
|
t.Fatalf("Wrong status returned")
|
|
} else if status := block1.Status(); status != choices.Rejected {
|
|
t.Fatalf("Wrong status returned")
|
|
} else if status := block2.Status(); status != choices.Rejected {
|
|
t.Fatalf("Wrong status returned")
|
|
}
|
|
}
|
|
|
|
func RecordPollTransitivelyResetConfidenceTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 2,
|
|
BetaRogue: 2,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
block0 := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(1),
|
|
status: choices.Processing,
|
|
}
|
|
block1 := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(2),
|
|
status: choices.Processing,
|
|
}
|
|
block2 := &TestBlock{
|
|
parent: block1,
|
|
id: ids.Empty.Prefix(3),
|
|
status: choices.Processing,
|
|
}
|
|
block3 := &TestBlock{
|
|
parent: block1,
|
|
id: ids.Empty.Prefix(4),
|
|
status: choices.Processing,
|
|
}
|
|
|
|
if err := sm.Add(block0); err != nil {
|
|
t.Fatal(err)
|
|
} else if err := sm.Add(block1); err != nil {
|
|
t.Fatal(err)
|
|
} else if err := sm.Add(block2); err != nil {
|
|
t.Fatal(err)
|
|
} else if err := sm.Add(block3); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Current graph structure:
|
|
// G
|
|
// / \
|
|
// 0 1
|
|
// / \
|
|
// 2 3
|
|
|
|
votesFor2 := ids.Bag{}
|
|
votesFor2.Add(block2.id)
|
|
if err := sm.RecordPoll(votesFor2); err != nil {
|
|
t.Fatal(err)
|
|
} else if sm.Finalized() {
|
|
t.Fatalf("Finalized too early")
|
|
} else if pref := sm.Preference(); !block2.id.Equals(pref) {
|
|
t.Fatalf("Wrong preference listed")
|
|
}
|
|
|
|
emptyVotes := ids.Bag{}
|
|
if err := sm.RecordPoll(emptyVotes); err != nil {
|
|
t.Fatal(err)
|
|
} else if sm.Finalized() {
|
|
t.Fatalf("Finalized too early")
|
|
} else if pref := sm.Preference(); !block2.id.Equals(pref) {
|
|
t.Fatalf("Wrong preference listed")
|
|
} else if err := sm.RecordPoll(votesFor2); err != nil {
|
|
t.Fatal(err)
|
|
} else if sm.Finalized() {
|
|
t.Fatalf("Finalized too early")
|
|
} else if pref := sm.Preference(); !block2.id.Equals(pref) {
|
|
t.Fatalf("Wrong preference listed")
|
|
}
|
|
|
|
votesFor3 := ids.Bag{}
|
|
votesFor3.Add(block3.id)
|
|
if err := sm.RecordPoll(votesFor3); err != nil {
|
|
t.Fatal(err)
|
|
} else if sm.Finalized() {
|
|
t.Fatalf("Finalized too early")
|
|
} else if pref := sm.Preference(); !block2.id.Equals(pref) {
|
|
t.Fatalf("Wrong preference listed")
|
|
} else if err := sm.RecordPoll(votesFor3); err != nil {
|
|
t.Fatal(err)
|
|
} else if !sm.Finalized() {
|
|
t.Fatalf("Finalized too late")
|
|
} else if pref := sm.Preference(); !block3.id.Equals(pref) {
|
|
t.Fatalf("Wrong preference listed")
|
|
} else if status := block0.Status(); status != choices.Rejected {
|
|
t.Fatalf("Wrong status returned")
|
|
} else if status := block1.Status(); status != choices.Accepted {
|
|
t.Fatalf("Wrong status returned")
|
|
} else if status := block2.Status(); status != choices.Rejected {
|
|
t.Fatalf("Wrong status returned")
|
|
} else if status := block3.Status(); status != choices.Accepted {
|
|
t.Fatalf("Wrong status returned")
|
|
}
|
|
}
|
|
|
|
func RecordPollInvalidVoteTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 2,
|
|
BetaRogue: 2,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
block := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(1),
|
|
status: choices.Processing,
|
|
}
|
|
unknownBlockID := ids.Empty.Prefix(2)
|
|
|
|
if err := sm.Add(block); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
validVotes := ids.Bag{}
|
|
validVotes.Add(block.id)
|
|
if err := sm.RecordPoll(validVotes); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
invalidVotes := ids.Bag{}
|
|
invalidVotes.Add(unknownBlockID)
|
|
if err := sm.RecordPoll(invalidVotes); err != nil {
|
|
t.Fatal(err)
|
|
} else if err := sm.RecordPoll(validVotes); err != nil {
|
|
t.Fatal(err)
|
|
} else if sm.Finalized() {
|
|
t.Fatalf("Finalized too early")
|
|
} else if pref := sm.Preference(); !block.id.Equals(pref) {
|
|
t.Fatalf("Wrong preference listed")
|
|
}
|
|
}
|
|
|
|
func RecordPollTransitiveVotingTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 3,
|
|
Alpha: 3,
|
|
BetaVirtuous: 1,
|
|
BetaRogue: 1,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
block0 := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(1),
|
|
status: choices.Processing,
|
|
}
|
|
block1 := &TestBlock{
|
|
parent: block0,
|
|
id: ids.Empty.Prefix(2),
|
|
status: choices.Processing,
|
|
}
|
|
block2 := &TestBlock{
|
|
parent: block1,
|
|
id: ids.Empty.Prefix(3),
|
|
status: choices.Processing,
|
|
}
|
|
block3 := &TestBlock{
|
|
parent: block0,
|
|
id: ids.Empty.Prefix(4),
|
|
status: choices.Processing,
|
|
}
|
|
block4 := &TestBlock{
|
|
parent: block3,
|
|
id: ids.Empty.Prefix(5),
|
|
status: choices.Processing,
|
|
}
|
|
|
|
if err := sm.Add(block0); err != nil {
|
|
t.Fatal(err)
|
|
} else if err := sm.Add(block1); err != nil {
|
|
t.Fatal(err)
|
|
} else if err := sm.Add(block2); err != nil {
|
|
t.Fatal(err)
|
|
} else if err := sm.Add(block3); err != nil {
|
|
t.Fatal(err)
|
|
} else if err := sm.Add(block4); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Current graph structure:
|
|
// G
|
|
// |
|
|
// 0
|
|
// / \
|
|
// 1 3
|
|
// | |
|
|
// 2 4
|
|
// Tail = 2
|
|
|
|
votes0_2_4 := ids.Bag{}
|
|
votes0_2_4.Add(
|
|
block0.id,
|
|
block2.id,
|
|
block4.id,
|
|
)
|
|
if err := sm.RecordPoll(votes0_2_4); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Current graph structure:
|
|
// 0
|
|
// / \
|
|
// 1 3
|
|
// | |
|
|
// 2 4
|
|
// Tail = 2
|
|
|
|
if pref := sm.Preference(); !block2.id.Equals(pref) {
|
|
t.Fatalf("Wrong preference listed")
|
|
} else if sm.Finalized() {
|
|
t.Fatalf("Finalized too early")
|
|
} else if block0.Status() != choices.Accepted {
|
|
t.Fatalf("Should have accepted")
|
|
} else if block1.Status() != choices.Processing {
|
|
t.Fatalf("Should have accepted")
|
|
} else if block2.Status() != choices.Processing {
|
|
t.Fatalf("Should have accepted")
|
|
} else if block3.Status() != choices.Processing {
|
|
t.Fatalf("Should have rejected")
|
|
} else if block4.Status() != choices.Processing {
|
|
t.Fatalf("Should have rejected")
|
|
}
|
|
|
|
dep2_2_2 := ids.Bag{}
|
|
dep2_2_2.AddCount(block2.id, 3)
|
|
if err := sm.RecordPoll(dep2_2_2); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Current graph structure:
|
|
// 2
|
|
// Tail = 2
|
|
|
|
if pref := sm.Preference(); !block2.id.Equals(pref) {
|
|
t.Fatalf("Wrong preference listed")
|
|
} else if !sm.Finalized() {
|
|
t.Fatalf("Finalized too late")
|
|
} else if block0.Status() != choices.Accepted {
|
|
t.Fatalf("Should have accepted")
|
|
} else if block1.Status() != choices.Accepted {
|
|
t.Fatalf("Should have accepted")
|
|
} else if block2.Status() != choices.Accepted {
|
|
t.Fatalf("Should have accepted")
|
|
} else if block3.Status() != choices.Rejected {
|
|
t.Fatalf("Should have rejected")
|
|
} else if block4.Status() != choices.Rejected {
|
|
t.Fatalf("Should have rejected")
|
|
}
|
|
}
|
|
|
|
func RecordPollDivergedVotingTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 1,
|
|
BetaRogue: 2,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
block0 := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.NewID([32]byte{0x0f}), // 0b1111
|
|
status: choices.Processing,
|
|
}
|
|
block1 := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.NewID([32]byte{0x08}), // 0b1000
|
|
status: choices.Processing,
|
|
}
|
|
block2 := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.NewID([32]byte{0x01}), // 0b0001
|
|
status: choices.Processing,
|
|
}
|
|
block3 := &TestBlock{
|
|
parent: block2,
|
|
id: ids.Empty.Prefix(1),
|
|
status: choices.Processing,
|
|
}
|
|
|
|
if err := sm.Add(block0); err != nil {
|
|
t.Fatal(err)
|
|
} else if err := sm.Add(block1); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
votes0 := ids.Bag{}
|
|
votes0.Add(block0.id)
|
|
if err := sm.RecordPoll(votes0); err != nil {
|
|
t.Fatal(err)
|
|
} else if err := sm.Add(block2); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// dep2 is already rejected.
|
|
|
|
if err := sm.Add(block3); err != nil {
|
|
t.Fatal(err)
|
|
} else if status := block0.Status(); status == choices.Accepted {
|
|
t.Fatalf("Shouldn't be accepted yet")
|
|
}
|
|
|
|
// Transitively increases dep2. However, dep2 shares the first bit with
|
|
// dep0. Because dep2 is already rejected, this will accept dep0.
|
|
votes3 := ids.Bag{}
|
|
votes3.Add(block3.id)
|
|
if err := sm.RecordPoll(votes3); err != nil {
|
|
t.Fatal(err)
|
|
} else if !sm.Finalized() {
|
|
t.Fatalf("Finalized too late")
|
|
} else if status := block0.Status(); status != choices.Accepted {
|
|
t.Fatalf("Should be accepted")
|
|
}
|
|
}
|
|
|
|
func MetricsProcessingErrorTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 1,
|
|
BetaRogue: 1,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
|
|
numProcessing := prometheus.NewGauge(
|
|
prometheus.GaugeOpts{
|
|
Namespace: params.Namespace,
|
|
Name: "processing",
|
|
})
|
|
|
|
if err := params.Metrics.Register(numProcessing); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
block := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(1),
|
|
status: choices.Processing,
|
|
}
|
|
|
|
if err := sm.Add(block); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
votes := ids.Bag{}
|
|
votes.Add(block.id)
|
|
if err := sm.RecordPoll(votes); err != nil {
|
|
t.Fatal(err)
|
|
} else if !sm.Finalized() {
|
|
t.Fatalf("Snowman instance didn't finalize")
|
|
}
|
|
}
|
|
|
|
func MetricsAcceptedErrorTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 1,
|
|
BetaRogue: 1,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
|
|
numAccepted := prometheus.NewGauge(
|
|
prometheus.GaugeOpts{
|
|
Namespace: params.Namespace,
|
|
Name: "accepted",
|
|
})
|
|
|
|
if err := params.Metrics.Register(numAccepted); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
block := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(1),
|
|
status: choices.Processing,
|
|
}
|
|
|
|
if err := sm.Add(block); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
votes := ids.Bag{}
|
|
votes.Add(block.id)
|
|
if err := sm.RecordPoll(votes); err != nil {
|
|
t.Fatal(err)
|
|
} else if !sm.Finalized() {
|
|
t.Fatalf("Snowman instance didn't finalize")
|
|
}
|
|
}
|
|
|
|
func MetricsRejectedErrorTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 1,
|
|
BetaRogue: 1,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
|
|
numRejected := prometheus.NewGauge(
|
|
prometheus.GaugeOpts{
|
|
Namespace: params.Namespace,
|
|
Name: "rejected",
|
|
})
|
|
|
|
if err := params.Metrics.Register(numRejected); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
block := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(1),
|
|
status: choices.Processing,
|
|
}
|
|
|
|
if err := sm.Add(block); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
votes := ids.Bag{}
|
|
votes.Add(block.id)
|
|
if err := sm.RecordPoll(votes); err != nil {
|
|
t.Fatal(err)
|
|
} else if !sm.Finalized() {
|
|
t.Fatalf("Snowman instance didn't finalize")
|
|
}
|
|
}
|
|
|
|
func ErrorOnInitialRejectionTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 1,
|
|
BetaRogue: 1,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
rejectedBlock := &TestBlock{
|
|
id: ids.Empty.Prefix(1),
|
|
status: choices.Rejected,
|
|
}
|
|
|
|
block := &TestBlock{
|
|
parent: rejectedBlock,
|
|
id: ids.Empty.Prefix(2),
|
|
status: choices.Processing,
|
|
err: errors.New(""),
|
|
}
|
|
|
|
if err := sm.Add(block); err == nil {
|
|
t.Fatalf("Should have errored on rejecting the rejectable block")
|
|
}
|
|
}
|
|
|
|
func ErrorOnAcceptTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 1,
|
|
BetaRogue: 1,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
block := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(1),
|
|
status: choices.Processing,
|
|
err: errors.New(""),
|
|
}
|
|
|
|
if err := sm.Add(block); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
votes := ids.Bag{}
|
|
votes.Add(block.id)
|
|
if err := sm.RecordPoll(votes); err == nil {
|
|
t.Fatalf("Should have errored on accepted the block")
|
|
}
|
|
}
|
|
|
|
func ErrorOnRejectSiblingTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 1,
|
|
BetaRogue: 1,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
block0 := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(1),
|
|
status: choices.Processing,
|
|
}
|
|
block1 := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(2),
|
|
status: choices.Processing,
|
|
err: errors.New(""),
|
|
}
|
|
|
|
if err := sm.Add(block0); err != nil {
|
|
t.Fatal(err)
|
|
} else if err := sm.Add(block1); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
votes := ids.Bag{}
|
|
votes.Add(block0.id)
|
|
if err := sm.RecordPoll(votes); err == nil {
|
|
t.Fatalf("Should have errored on rejecting the block's sibling")
|
|
}
|
|
}
|
|
|
|
func ErrorOnTransitiveRejectionTest(t *testing.T, factory Factory) {
|
|
sm := factory.New()
|
|
|
|
ctx := snow.DefaultContextTest()
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 1,
|
|
Alpha: 1,
|
|
BetaVirtuous: 1,
|
|
BetaRogue: 1,
|
|
ConcurrentRepolls: 1,
|
|
}
|
|
|
|
sm.Initialize(ctx, params, GenesisID)
|
|
|
|
block0 := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(1),
|
|
status: choices.Processing,
|
|
}
|
|
block1 := &TestBlock{
|
|
parent: Genesis,
|
|
id: ids.Empty.Prefix(2),
|
|
status: choices.Processing,
|
|
}
|
|
block2 := &TestBlock{
|
|
parent: block1,
|
|
id: ids.Empty.Prefix(3),
|
|
status: choices.Processing,
|
|
err: errors.New(""),
|
|
}
|
|
|
|
if err := sm.Add(block0); err != nil {
|
|
t.Fatal(err)
|
|
} else if err := sm.Add(block1); err != nil {
|
|
t.Fatal(err)
|
|
} else if err := sm.Add(block2); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
votes := ids.Bag{}
|
|
votes.Add(block0.id)
|
|
if err := sm.RecordPoll(votes); err == nil {
|
|
t.Fatalf("Should have errored on transitively rejecting the block")
|
|
}
|
|
}
|
|
|
|
func RandomizedConsistencyTest(t *testing.T, factory Factory) {
|
|
numColors := 50
|
|
numNodes := 100
|
|
params := snowball.Parameters{
|
|
Metrics: prometheus.NewRegistry(),
|
|
K: 20,
|
|
Alpha: 15,
|
|
BetaVirtuous: 20,
|
|
BetaRogue: 30,
|
|
}
|
|
seed := int64(0)
|
|
|
|
rand.Seed(seed)
|
|
|
|
n := Network{}
|
|
n.Initialize(params, numColors)
|
|
|
|
for i := 0; i < numNodes; i++ {
|
|
n.AddNode(factory.New())
|
|
}
|
|
|
|
for !n.Finalized() {
|
|
n.Round()
|
|
}
|
|
|
|
if !n.Agreement() {
|
|
t.Fatalf("Network agreed on inconsistent values")
|
|
}
|
|
}
|