test: create common functions for easily producing tm data structures (#6435)

internal/test/factory/block.go

@@ -0,0 +1,95 @@
+package factory
+
+import (
+	"github.com/tendermint/tendermint/crypto"
+	"github.com/tendermint/tendermint/crypto/tmhash"
+	"github.com/tendermint/tendermint/types"
+	"github.com/tendermint/tendermint/version"
+)
+
+const (
+	DefaultTestChainID = "test-chain"
+)
+
+func MakeVersion() version.Consensus {
+	return version.Consensus{
+		Block: version.BlockProtocol,
+		App:   1,
+	}
+}
+
+func RandomAddress() []byte {
+	return crypto.CRandBytes(crypto.AddressSize)
+}
+
+func RandomHash() []byte {
+	return crypto.CRandBytes(tmhash.Size)
+}
+
+func MakeBlockID() types.BlockID {
+	return MakeBlockIDWithHash(RandomHash())
+}
+
+func MakeBlockIDWithHash(hash []byte) types.BlockID {
+	return types.BlockID{
+		Hash: hash,
+		PartSetHeader: types.PartSetHeader{
+			Total: 100,
+			Hash:  RandomHash(),
+		},
+	}
+}
+
+// MakeHeader fills the rest of the contents of the header such that it passes
+// validate basic
+func MakeHeader(h *types.Header) (*types.Header, error) {
+	if h.Version.Block == 0 {
+		h.Version.Block = version.BlockProtocol
+	}
+	if h.Height == 0 {
+		h.Height = 1
+	}
+	if h.LastBlockID.IsZero() {
+		h.LastBlockID = MakeBlockID()
+	}
+	if h.ChainID == "" {
+		h.ChainID = DefaultTestChainID
+	}
+	if len(h.LastCommitHash) == 0 {
+		h.LastCommitHash = RandomHash()
+	}
+	if len(h.DataHash) == 0 {
+		h.DataHash = RandomHash()
+	}
+	if len(h.ValidatorsHash) == 0 {
+		h.ValidatorsHash = RandomHash()
+	}
+	if len(h.NextValidatorsHash) == 0 {
+		h.NextValidatorsHash = RandomHash()
+	}
+	if len(h.ConsensusHash) == 0 {
+		h.ConsensusHash = RandomHash()
+	}
+	if len(h.AppHash) == 0 {
+		h.AppHash = RandomHash()
+	}
+	if len(h.LastResultsHash) == 0 {
+		h.LastResultsHash = RandomHash()
+	}
+	if len(h.EvidenceHash) == 0 {
+		h.EvidenceHash = RandomHash()
+	}
+	if len(h.ProposerAddress) == 0 {
+		h.ProposerAddress = RandomAddress()
+	}
+
+	return h, h.ValidateBasic()
+}
+
+func MakeRandomHeader() *types.Header {
+	h, err := MakeHeader(&types.Header{})
+	if err != nil {
+		panic(err)
+	}
+	return h
+}

internal/test/factory/commit.go

@@ -0,0 +1,48 @@
+package factory
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+	"github.com/tendermint/tendermint/types"
+)
+
+func MakeCommit(blockID types.BlockID, height int64, round int32,
+	voteSet *types.VoteSet, validators []types.PrivValidator, now time.Time) (*types.Commit, error) {
+
+	// all sign
+	for i := 0; i < len(validators); i++ {
+		pubKey, err := validators[i].GetPubKey(context.Background())
+		if err != nil {
+			return nil, fmt.Errorf("can't get pubkey: %w", err)
+		}
+		vote := &types.Vote{
+			ValidatorAddress: pubKey.Address(),
+			ValidatorIndex:   int32(i),
+			Height:           height,
+			Round:            round,
+			Type:             tmproto.PrecommitType,
+			BlockID:          blockID,
+			Timestamp:        now,
+		}
+
+		_, err = signAddVote(validators[i], vote, voteSet)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return voteSet.MakeCommit(), nil
+}
+
+func signAddVote(privVal types.PrivValidator, vote *types.Vote, voteSet *types.VoteSet) (signed bool, err error) {
+	v := vote.ToProto()
+	err = privVal.SignVote(context.Background(), voteSet.ChainID(), v)
+	if err != nil {
+		return false, err
+	}
+	vote.Signature = v.Signature
+	return voteSet.AddVote(vote)
+}

internal/test/factory/factory_test.go

@@ -0,0 +1,14 @@
+package factory
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/tendermint/tendermint/types"
+)
+
+func TestMakeHeader(t *testing.T) {
+	_, err := MakeHeader(&types.Header{})
+	assert.NoError(t, err)
+}

internal/test/factory/genesis.go

@@ -0,0 +1,35 @@
+package factory
+
+import (
+	"sort"
+
+	cfg "github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/types"
+	tmtime "github.com/tendermint/tendermint/types/time"
+)
+
+func RandGenesisDoc(
+	config *cfg.Config,
+	numValidators int,
+	randPower bool,
+	minPower int64) (*types.GenesisDoc, []types.PrivValidator) {
+
+	validators := make([]types.GenesisValidator, numValidators)
+	privValidators := make([]types.PrivValidator, numValidators)
+	for i := 0; i < numValidators; i++ {
+		val, privVal := RandValidator(randPower, minPower)
+		validators[i] = types.GenesisValidator{
+			PubKey: val.PubKey,
+			Power:  val.VotingPower,
+		}
+		privValidators[i] = privVal
+	}
+	sort.Sort(types.PrivValidatorsByAddress(privValidators))
+
+	return &types.GenesisDoc{
+		GenesisTime:   tmtime.Now(),
+		InitialHeight: 1,
+		ChainID:       config.ChainID(),
+		Validators:    validators,
+	}, privValidators
+}

internal/test/factory/validator.go

@@ -0,0 +1,42 @@
+package factory
+
+import (
+	"context"
+	"fmt"
+	"math/rand"
+	"sort"
+
+	"github.com/tendermint/tendermint/types"
+)
+
+func RandValidator(randPower bool, minPower int64) (*types.Validator, types.PrivValidator) {
+	privVal := types.NewMockPV()
+	votePower := minPower
+	if randPower {
+		// nolint:gosec // G404: Use of weak random number generator
+		votePower += int64(rand.Uint32())
+	}
+	pubKey, err := privVal.GetPubKey(context.Background())
+	if err != nil {
+		panic(fmt.Errorf("could not retrieve pubkey %w", err))
+	}
+	val := types.NewValidator(pubKey, votePower)
+	return val, privVal
+}
+
+func RandValidatorSet(numValidators int, votingPower int64) (*types.ValidatorSet, []types.PrivValidator) {
+	var (
+		valz           = make([]*types.Validator, numValidators)
+		privValidators = make([]types.PrivValidator, numValidators)
+	)
+
+	for i := 0; i < numValidators; i++ {
+		val, privValidator := RandValidator(false, votingPower)
+		valz[i] = val
+		privValidators[i] = privValidator
+	}
+
+	sort.Sort(types.PrivValidatorsByAddress(privValidators))
+
+	return types.NewValidatorSet(valz), privValidators
+}

internal/test/factory/vote.go

@@ -0,0 +1,42 @@
+package factory
+
+import (
+	"context"
+	"time"
+
+	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+	"github.com/tendermint/tendermint/types"
+)
+
+func MakeVote(
+	val types.PrivValidator,
+	chainID string,
+	valIndex int32,
+	height int64,
+	round int32,
+	step int,
+	blockID types.BlockID,
+	time time.Time,
+) (*types.Vote, error) {
+	pubKey, err := val.GetPubKey(context.Background())
+	if err != nil {
+		return nil, err
+	}
+	v := &types.Vote{
+		ValidatorAddress: pubKey.Address(),
+		ValidatorIndex:   valIndex,
+		Height:           height,
+		Round:            round,
+		Type:             tmproto.SignedMsgType(step),
+		BlockID:          blockID,
+		Timestamp:        time,
+	}
+
+	vpb := v.ToProto()
+	err = val.SignVote(context.Background(), chainID, vpb)
+	if err != nil {
+		panic(err)
+	}
+	v.Signature = vpb.Signature
+	return v, nil
+}