github.com/ImPedro29/bor@v0.2.7/consensus/bor/snapshot_test.go (about)

     1  package bor
     2  
     3  import (
     4  	"math/rand"
     5  	"sort"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  
    11  	"github.com/ethereum/go-ethereum/common"
    12  )
    13  
    14  const (
    15  	numVals = 100
    16  )
    17  
    18  func TestGetSignerSuccessionNumber_ProposerIsSigner(t *testing.T) {
    19  	validators := buildRandomValidatorSet(numVals)
    20  	validatorSet := NewValidatorSet(validators)
    21  	snap := Snapshot{
    22  		ValidatorSet: validatorSet,
    23  	}
    24  
    25  	// proposer is signer
    26  	signer := validatorSet.Proposer.Address
    27  	successionNumber, err := snap.GetSignerSuccessionNumber(signer)
    28  	if err != nil {
    29  		t.Fatalf("%s", err)
    30  	}
    31  	assert.Equal(t, 0, successionNumber)
    32  }
    33  
    34  func TestGetSignerSuccessionNumber_SignerIndexIsLarger(t *testing.T) {
    35  	validators := buildRandomValidatorSet(numVals)
    36  
    37  	// sort validators by address, which is what NewValidatorSet also does
    38  	sort.Sort(ValidatorsByAddress(validators))
    39  	proposerIndex := 32
    40  	signerIndex := 56
    41  	// give highest ProposerPriority to a particular val, so that they become the proposer
    42  	validators[proposerIndex].VotingPower = 200
    43  	snap := Snapshot{
    44  		ValidatorSet: NewValidatorSet(validators),
    45  	}
    46  
    47  	// choose a signer at an index greater than proposer index
    48  	signer := snap.ValidatorSet.Validators[signerIndex].Address
    49  	successionNumber, err := snap.GetSignerSuccessionNumber(signer)
    50  	if err != nil {
    51  		t.Fatalf("%s", err)
    52  	}
    53  	assert.Equal(t, signerIndex-proposerIndex, successionNumber)
    54  }
    55  
    56  func TestGetSignerSuccessionNumber_SignerIndexIsSmaller(t *testing.T) {
    57  	validators := buildRandomValidatorSet(numVals)
    58  	proposerIndex := 98
    59  	signerIndex := 11
    60  	// give highest ProposerPriority to a particular val, so that they become the proposer
    61  	validators[proposerIndex].VotingPower = 200
    62  	snap := Snapshot{
    63  		ValidatorSet: NewValidatorSet(validators),
    64  	}
    65  
    66  	// choose a signer at an index greater than proposer index
    67  	signer := snap.ValidatorSet.Validators[signerIndex].Address
    68  	successionNumber, err := snap.GetSignerSuccessionNumber(signer)
    69  	if err != nil {
    70  		t.Fatalf("%s", err)
    71  	}
    72  	assert.Equal(t, signerIndex+numVals-proposerIndex, successionNumber)
    73  }
    74  
    75  func TestGetSignerSuccessionNumber_ProposerNotFound(t *testing.T) {
    76  	validators := buildRandomValidatorSet(numVals)
    77  	snap := Snapshot{
    78  		ValidatorSet: NewValidatorSet(validators),
    79  	}
    80  	dummyProposerAddress := randomAddress()
    81  	snap.ValidatorSet.Proposer = &Validator{Address: dummyProposerAddress}
    82  	// choose any signer
    83  	signer := snap.ValidatorSet.Validators[3].Address
    84  	_, err := snap.GetSignerSuccessionNumber(signer)
    85  	assert.NotNil(t, err)
    86  	e, ok := err.(*UnauthorizedProposerError)
    87  	assert.True(t, ok)
    88  	assert.Equal(t, dummyProposerAddress.Bytes(), e.Proposer)
    89  }
    90  
    91  func TestGetSignerSuccessionNumber_SignerNotFound(t *testing.T) {
    92  	validators := buildRandomValidatorSet(numVals)
    93  	snap := Snapshot{
    94  		ValidatorSet: NewValidatorSet(validators),
    95  	}
    96  	dummySignerAddress := randomAddress()
    97  	_, err := snap.GetSignerSuccessionNumber(dummySignerAddress)
    98  	assert.NotNil(t, err)
    99  	e, ok := err.(*UnauthorizedSignerError)
   100  	assert.True(t, ok)
   101  	assert.Equal(t, dummySignerAddress.Bytes(), e.Signer)
   102  }
   103  
   104  func buildRandomValidatorSet(numVals int) []*Validator {
   105  	rand.Seed(time.Now().Unix())
   106  	validators := make([]*Validator, numVals)
   107  	for i := 0; i < numVals; i++ {
   108  		validators[i] = &Validator{
   109  			Address: randomAddress(),
   110  			// cannot process validators with voting power 0, hence +1
   111  			VotingPower: int64(rand.Intn(99) + 1),
   112  		}
   113  	}
   114  
   115  	// sort validators by address, which is what NewValidatorSet also does
   116  	sort.Sort(ValidatorsByAddress(validators))
   117  	return validators
   118  }
   119  
   120  func randomAddress() common.Address {
   121  	bytes := make([]byte, 32)
   122  	rand.Read(bytes)
   123  	return common.BytesToAddress(bytes)
   124  }