github.com/okex/exchain@v1.8.0/libs/tendermint/types/params_test.go (about)

     1  package types
     2  
     3  import (
     4  	"bytes"
     5  	"sort"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  
    11  	abci "github.com/okex/exchain/libs/tendermint/abci/types"
    12  )
    13  
    14  var (
    15  	valEd25519   = []string{ABCIPubKeyTypeEd25519}
    16  	valSecp256k1 = []string{ABCIPubKeyTypeSecp256k1}
    17  )
    18  
    19  func TestConsensusParamsValidation(t *testing.T) {
    20  	testCases := []struct {
    21  		params ConsensusParams
    22  		valid  bool
    23  	}{
    24  		// test block params
    25  		0: {makeParams(1, 0, 10, 1, valEd25519), true},
    26  		1: {makeParams(0, 0, 10, 1, valEd25519), false},
    27  		2: {makeParams(47*1024*1024, 0, 10, 1, valEd25519), true},
    28  		3: {makeParams(10, 0, 10, 1, valEd25519), true},
    29  		4: {makeParams(100*1024*1024, 0, 10, 1, valEd25519), true},
    30  		5: {makeParams(101*1024*1024, 0, 10, 1, valEd25519), false},
    31  		6: {makeParams(1024*1024*1024, 0, 10, 1, valEd25519), false},
    32  		7: {makeParams(1024*1024*1024, 0, 10, -1, valEd25519), false},
    33  		8: {makeParams(1, 0, -10, 1, valEd25519), false},
    34  		// test evidence params
    35  		9:  {makeParams(1, 0, 10, 0, valEd25519), false},
    36  		10: {makeParams(1, 0, 10, -1, valEd25519), false},
    37  		// test no pubkey type provided
    38  		11: {makeParams(1, 0, 10, 1, []string{}), false},
    39  		// test invalid pubkey type provided
    40  		12: {makeParams(1, 0, 10, 1, []string{"potatoes make good pubkeys"}), false},
    41  	}
    42  	for i, tc := range testCases {
    43  		if tc.valid {
    44  			assert.NoErrorf(t, tc.params.Validate(), "expected no error for valid params (#%d)", i)
    45  		} else {
    46  			assert.Errorf(t, tc.params.Validate(), "expected error for non valid params (#%d)", i)
    47  		}
    48  	}
    49  }
    50  
    51  func makeParams(
    52  	blockBytes, blockGas int64,
    53  	blockTimeIotaMs int64,
    54  	evidenceAge int64,
    55  	pubkeyTypes []string,
    56  ) ConsensusParams {
    57  	return ConsensusParams{
    58  		Block: BlockParams{
    59  			MaxBytes:   blockBytes,
    60  			MaxGas:     blockGas,
    61  			TimeIotaMs: blockTimeIotaMs,
    62  		},
    63  		Evidence: EvidenceParams{
    64  			MaxAgeNumBlocks: evidenceAge,
    65  			MaxAgeDuration:  time.Duration(evidenceAge),
    66  		},
    67  		Validator: ValidatorParams{
    68  			PubKeyTypes: pubkeyTypes,
    69  		},
    70  	}
    71  }
    72  
    73  func TestConsensusParamsHash(t *testing.T) {
    74  	params := []ConsensusParams{
    75  		makeParams(4, 2, 10, 3, valEd25519),
    76  		makeParams(1, 4, 10, 3, valEd25519),
    77  		makeParams(1, 2, 10, 4, valEd25519),
    78  		makeParams(2, 5, 10, 7, valEd25519),
    79  		makeParams(1, 7, 10, 6, valEd25519),
    80  		makeParams(9, 5, 10, 4, valEd25519),
    81  		makeParams(7, 8, 10, 9, valEd25519),
    82  		makeParams(4, 6, 10, 5, valEd25519),
    83  	}
    84  
    85  	hashes := make([][]byte, len(params))
    86  	for i := range params {
    87  		hashes[i] = params[i].Hash()
    88  	}
    89  
    90  	// make sure there are no duplicates...
    91  	// sort, then check in order for matches
    92  	sort.Slice(hashes, func(i, j int) bool {
    93  		return bytes.Compare(hashes[i], hashes[j]) < 0
    94  	})
    95  	for i := 0; i < len(hashes)-1; i++ {
    96  		assert.NotEqual(t, hashes[i], hashes[i+1])
    97  	}
    98  }
    99  
   100  func TestConsensusParamsUpdate(t *testing.T) {
   101  	testCases := []struct {
   102  		params        ConsensusParams
   103  		updates       *abci.ConsensusParams
   104  		updatedParams ConsensusParams
   105  	}{
   106  		// empty updates
   107  		{
   108  			makeParams(1, 2, 10, 3, valEd25519),
   109  			&abci.ConsensusParams{},
   110  			makeParams(1, 2, 10, 3, valEd25519),
   111  		},
   112  		// fine updates
   113  		{
   114  			makeParams(1, 2, 10, 3, valEd25519),
   115  			&abci.ConsensusParams{
   116  				Block: &abci.BlockParams{
   117  					MaxBytes: 100,
   118  					MaxGas:   200,
   119  				},
   120  				Evidence: &abci.EvidenceParams{
   121  					MaxAgeNumBlocks: 300,
   122  					MaxAgeDuration:  time.Duration(300),
   123  				},
   124  				Validator: &abci.ValidatorParams{
   125  					PubKeyTypes: valSecp256k1,
   126  				},
   127  			},
   128  			makeParams(100, 200, 10, 300, valSecp256k1),
   129  		},
   130  	}
   131  	for _, tc := range testCases {
   132  		assert.Equal(t, tc.updatedParams, tc.params.Update(tc.updates))
   133  	}
   134  }