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