You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
206 lines
5.4 KiB
206 lines
5.4 KiB
package state
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/tendermint/abci/example/dummy"
|
|
abci "github.com/tendermint/abci/types"
|
|
crypto "github.com/tendermint/go-crypto"
|
|
"github.com/tendermint/tendermint/proxy"
|
|
"github.com/tendermint/tendermint/types"
|
|
dbm "github.com/tendermint/tmlibs/db"
|
|
"github.com/tendermint/tmlibs/log"
|
|
)
|
|
|
|
var (
|
|
privKey = crypto.GenPrivKeyEd25519FromSecret([]byte("execution_test"))
|
|
chainID = "execution_chain"
|
|
testPartSize = 65536
|
|
nTxsPerBlock = 10
|
|
)
|
|
|
|
func TestValidateBlock(t *testing.T) {
|
|
state := state()
|
|
state.SetLogger(log.TestingLogger())
|
|
|
|
// proper block must pass
|
|
block := makeBlock(state, 1)
|
|
err := state.ValidateBlock(block)
|
|
require.NoError(t, err)
|
|
|
|
// wrong chain fails
|
|
block = makeBlock(state, 1)
|
|
block.ChainID = "not-the-real-one"
|
|
err = state.ValidateBlock(block)
|
|
require.Error(t, err)
|
|
|
|
// wrong height fails
|
|
block = makeBlock(state, 1)
|
|
block.Height += 10
|
|
err = state.ValidateBlock(block)
|
|
require.Error(t, err)
|
|
|
|
// wrong total tx fails
|
|
block = makeBlock(state, 1)
|
|
block.TotalTxs += 10
|
|
err = state.ValidateBlock(block)
|
|
require.Error(t, err)
|
|
|
|
// wrong blockid fails
|
|
block = makeBlock(state, 1)
|
|
block.LastBlockID.PartsHeader.Total += 10
|
|
err = state.ValidateBlock(block)
|
|
require.Error(t, err)
|
|
|
|
// wrong app hash fails
|
|
block = makeBlock(state, 1)
|
|
block.AppHash = []byte("wrong app hash")
|
|
err = state.ValidateBlock(block)
|
|
require.Error(t, err)
|
|
|
|
// wrong consensus hash fails
|
|
block = makeBlock(state, 1)
|
|
block.ConsensusHash = []byte("wrong consensus hash")
|
|
err = state.ValidateBlock(block)
|
|
require.Error(t, err)
|
|
|
|
// wrong results hash fails
|
|
block = makeBlock(state, 1)
|
|
block.LastResultsHash = []byte("wrong results hash")
|
|
err = state.ValidateBlock(block)
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestApplyBlock(t *testing.T) {
|
|
cc := proxy.NewLocalClientCreator(dummy.NewDummyApplication())
|
|
proxyApp := proxy.NewAppConns(cc, nil)
|
|
err := proxyApp.Start()
|
|
require.Nil(t, err)
|
|
defer proxyApp.Stop()
|
|
|
|
state := state()
|
|
state.SetLogger(log.TestingLogger())
|
|
|
|
block := makeBlock(state, 1)
|
|
|
|
err = state.ApplyBlock(types.NopEventBus{}, proxyApp.Consensus(), block, block.MakePartSet(testPartSize).Header(), types.MockMempool{})
|
|
require.Nil(t, err)
|
|
|
|
// TODO check state and mempool
|
|
}
|
|
|
|
// TestBeginBlockAbsentValidators ensures we send absent validators list.
|
|
func TestBeginBlockAbsentValidators(t *testing.T) {
|
|
app := &testApp{}
|
|
cc := proxy.NewLocalClientCreator(app)
|
|
proxyApp := proxy.NewAppConns(cc, nil)
|
|
err := proxyApp.Start()
|
|
require.Nil(t, err)
|
|
defer proxyApp.Stop()
|
|
|
|
state := state()
|
|
state.SetLogger(log.TestingLogger())
|
|
|
|
// there were 2 validators
|
|
val1PrivKey := crypto.GenPrivKeyEd25519()
|
|
val2PrivKey := crypto.GenPrivKeyEd25519()
|
|
lastValidators := types.NewValidatorSet([]*types.Validator{
|
|
types.NewValidator(val1PrivKey.PubKey(), 10),
|
|
types.NewValidator(val2PrivKey.PubKey(), 5),
|
|
})
|
|
|
|
prevHash := state.LastBlockID.Hash
|
|
prevParts := types.PartSetHeader{}
|
|
prevBlockID := types.BlockID{prevHash, prevParts}
|
|
|
|
now := time.Now().UTC()
|
|
testCases := []struct {
|
|
desc string
|
|
lastCommitPrecommits []*types.Vote
|
|
expectedAbsentValidators []int32
|
|
}{
|
|
{"none absent", []*types.Vote{{ValidatorIndex: 0, Timestamp: now}, {ValidatorIndex: 1, Timestamp: now}}, []int32{}},
|
|
{"one absent", []*types.Vote{{ValidatorIndex: 0, Timestamp: now}, nil}, []int32{1}},
|
|
{"multiple absent", []*types.Vote{nil, nil}, []int32{0, 1}},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
lastCommit := &types.Commit{BlockID: prevBlockID, Precommits: tc.lastCommitPrecommits}
|
|
|
|
block, _ := state.MakeBlock(2, makeTxs(2), lastCommit)
|
|
_, err = ExecCommitBlock(proxyApp.Consensus(), block, log.TestingLogger(), lastValidators)
|
|
require.Nil(t, err, tc.desc)
|
|
|
|
// -> app must receive an index of the absent validator
|
|
assert.Equal(t, tc.expectedAbsentValidators, app.AbsentValidators, tc.desc)
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
// make some bogus txs
|
|
func makeTxs(height int64) (txs []types.Tx) {
|
|
for i := 0; i < nTxsPerBlock; i++ {
|
|
txs = append(txs, types.Tx([]byte{byte(height), byte(i)}))
|
|
}
|
|
return txs
|
|
}
|
|
|
|
func state() *State {
|
|
s, _ := MakeGenesisState(dbm.NewMemDB(), &types.GenesisDoc{
|
|
ChainID: chainID,
|
|
Validators: []types.GenesisValidator{
|
|
{privKey.PubKey(), 10000, "test"},
|
|
},
|
|
AppHash: nil,
|
|
})
|
|
return s
|
|
}
|
|
|
|
func makeBlock(state *State, height int64) *types.Block {
|
|
block, _ := state.MakeBlock(height, makeTxs(state.LastBlockHeight), new(types.Commit))
|
|
return block
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
var _ abci.Application = (*testApp)(nil)
|
|
|
|
type testApp struct {
|
|
abci.BaseApplication
|
|
|
|
AbsentValidators []int32
|
|
}
|
|
|
|
func NewDummyApplication() *testApp {
|
|
return &testApp{}
|
|
}
|
|
|
|
func (app *testApp) Info(req abci.RequestInfo) (resInfo abci.ResponseInfo) {
|
|
return abci.ResponseInfo{}
|
|
}
|
|
|
|
func (app *testApp) BeginBlock(req abci.RequestBeginBlock) abci.ResponseBeginBlock {
|
|
app.AbsentValidators = req.AbsentValidators
|
|
return abci.ResponseBeginBlock{}
|
|
}
|
|
|
|
func (app *testApp) DeliverTx(tx []byte) abci.ResponseDeliverTx {
|
|
return abci.ResponseDeliverTx{Tags: []*abci.KVPair{}}
|
|
}
|
|
|
|
func (app *testApp) CheckTx(tx []byte) abci.ResponseCheckTx {
|
|
return abci.ResponseCheckTx{}
|
|
}
|
|
|
|
func (app *testApp) Commit() abci.ResponseCommit {
|
|
return abci.ResponseCommit{}
|
|
}
|
|
|
|
func (app *testApp) Query(reqQuery abci.RequestQuery) (resQuery abci.ResponseQuery) {
|
|
return
|
|
}
|