Migrate Keeper staking tests to use simapp

simapp/test_helpers.go

@@ -1,6 +1,9 @@
 package simapp
 
 import (
+	"bytes"
+	"encoding/hex"
+	"strconv"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -187,3 +190,30 @@ func incrementAllSequenceNumbers(initSeqNums []uint64) {
 		initSeqNums[i]++
 	}
 }
+
+func CreateTestPubKeys(numPubKeys int) []crypto.PubKey {
+	var publicKeys []crypto.PubKey
+	var buffer bytes.Buffer
+
+	//start at 10 to avoid changing 1 to 01, 2 to 02, etc
+	for i := 100; i < (numPubKeys + 100); i++ {
+		numString := strconv.Itoa(i)
+		buffer.WriteString("0B485CFC0EECC619440448436F8FC9DF40566F2369E72400281454CB552AF") //base pubkey string
+		buffer.WriteString(numString)                                                       //adding on final two digits to make pubkeys unique
+		publicKeys = append(publicKeys, NewPubKey(buffer.String()))
+		buffer.Reset()
+	}
+
+	return publicKeys
+}
+
+func NewPubKey(pk string) (res crypto.PubKey) {
+	pkBytes, err := hex.DecodeString(pk)
+	if err != nil {
+		panic(err)
+	}
+	//res, err = crypto.PubKeyFromBytes(pkBytes)
+	var pkEd ed25519.PubKeyEd25519
+	copy(pkEd[:], pkBytes)
+	return pkEd
+}

x/staking/keeper/historical_info_test.go

@@ -1,18 +1,23 @@
-package keeper
+package keeper_test
 
 import (
 	"sort"
 	"testing"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/cosmos/cosmos-sdk/simapp"
+
 	"github.com/cosmos/cosmos-sdk/x/staking/types"
 
 	"github.com/stretchr/testify/require"
 	abci "github.com/tendermint/tendermint/abci/types"
 )
 
 func TestHistoricalInfo(t *testing.T) {
-	ctx, _, _, keeper, _ := CreateTestInput(t, false, 10)
+	app := simapp.Setup(false)
+	ctx := app.BaseApp.NewContext(false, abci.Header{})
+
 	validators := make([]types.Validator, len(addrVals))
 
 	for i, valAddr := range addrVals {
@@ -21,27 +26,28 @@ func TestHistoricalInfo(t *testing.T) {
 
 	hi := types.NewHistoricalInfo(ctx.BlockHeader(), validators)
 
-	keeper.SetHistoricalInfo(ctx, 2, hi)
+	app.StakingKeeper.SetHistoricalInfo(ctx, 2, hi)
 
-	recv, found := keeper.GetHistoricalInfo(ctx, 2)
+	recv, found := app.StakingKeeper.GetHistoricalInfo(ctx, 2)
 	require.True(t, found, "HistoricalInfo not found after set")
 	require.Equal(t, hi, recv, "HistoricalInfo not equal")
 	require.True(t, sort.IsSorted(types.Validators(recv.Valset)), "HistoricalInfo validators is not sorted")
 
-	keeper.DeleteHistoricalInfo(ctx, 2)
+	app.StakingKeeper.DeleteHistoricalInfo(ctx, 2)
 
-	recv, found = keeper.GetHistoricalInfo(ctx, 2)
+	recv, found = app.StakingKeeper.GetHistoricalInfo(ctx, 2)
 	require.False(t, found, "HistoricalInfo found after delete")
 	require.Equal(t, types.HistoricalInfo{}, recv, "HistoricalInfo is not empty")
 }
 
 func TestTrackHistoricalInfo(t *testing.T) {
-	ctx, _, _, k, _ := CreateTestInput(t, false, 10)
+	app := simapp.Setup(false)
+	ctx := app.BaseApp.NewContext(false, abci.Header{})
 
 	// set historical entries in params to 5
 	params := types.DefaultParams()
 	params.HistoricalEntries = 5
-	k.SetParams(ctx, params)
+	app.StakingKeeper.SetParams(ctx, params)
 
 	// set historical info at 5, 4 which should be pruned
 	// and check that it has been stored
@@ -59,24 +65,24 @@ func TestTrackHistoricalInfo(t *testing.T) {
 	}
 	hi4 := types.NewHistoricalInfo(h4, valSet)
 	hi5 := types.NewHistoricalInfo(h5, valSet)
-	k.SetHistoricalInfo(ctx, 4, hi4)
-	k.SetHistoricalInfo(ctx, 5, hi5)
-	recv, found := k.GetHistoricalInfo(ctx, 4)
+	app.StakingKeeper.SetHistoricalInfo(ctx, 4, hi4)
+	app.StakingKeeper.SetHistoricalInfo(ctx, 5, hi5)
+	recv, found := app.StakingKeeper.GetHistoricalInfo(ctx, 4)
 	require.True(t, found)
 	require.Equal(t, hi4, recv)
-	recv, found = k.GetHistoricalInfo(ctx, 5)
+	recv, found = app.StakingKeeper.GetHistoricalInfo(ctx, 5)
 	require.True(t, found)
 	require.Equal(t, hi5, recv)
 
 	// Set last validators in keeper
 	val1 := types.NewValidator(sdk.ValAddress(Addrs[2]), PKs[2], types.Description{})
-	k.SetValidator(ctx, val1)
-	k.SetLastValidatorPower(ctx, val1.OperatorAddress, 10)
+	app.StakingKeeper.SetValidator(ctx, val1)
+	app.StakingKeeper.SetLastValidatorPower(ctx, val1.OperatorAddress, 10)
 	val2 := types.NewValidator(sdk.ValAddress(Addrs[3]), PKs[3], types.Description{})
 	vals := []types.Validator{val1, val2}
 	sort.Sort(types.Validators(vals))
-	k.SetValidator(ctx, val2)
-	k.SetLastValidatorPower(ctx, val2.OperatorAddress, 8)
+	app.StakingKeeper.SetValidator(ctx, val2)
+	app.StakingKeeper.SetLastValidatorPower(ctx, val2.OperatorAddress, 8)
 
 	// Set Header for BeginBlock context
 	header := abci.Header{
@@ -85,22 +91,22 @@ func TestTrackHistoricalInfo(t *testing.T) {
 	}
 	ctx = ctx.WithBlockHeader(header)
 
-	k.TrackHistoricalInfo(ctx)
+	app.StakingKeeper.TrackHistoricalInfo(ctx)
 
 	// Check HistoricalInfo at height 10 is persisted
 	expected := types.HistoricalInfo{
 		Header: header,
 		Valset: vals,
 	}
-	recv, found = k.GetHistoricalInfo(ctx, 10)
+	recv, found = app.StakingKeeper.GetHistoricalInfo(ctx, 10)
 	require.True(t, found, "GetHistoricalInfo failed after BeginBlock")
 	require.Equal(t, expected, recv, "GetHistoricalInfo returned eunexpected result")
 
 	// Check HistoricalInfo at height 5, 4 is pruned
-	recv, found = k.GetHistoricalInfo(ctx, 4)
+	recv, found = app.StakingKeeper.GetHistoricalInfo(ctx, 4)
 	require.False(t, found, "GetHistoricalInfo did not prune earlier height")
 	require.Equal(t, types.HistoricalInfo{}, recv, "GetHistoricalInfo at height 4 is not empty after prune")
-	recv, found = k.GetHistoricalInfo(ctx, 5)
+	recv, found = app.StakingKeeper.GetHistoricalInfo(ctx, 5)
 	require.False(t, found, "GetHistoricalInfo did not prune first prune height")
 	require.Equal(t, types.HistoricalInfo{}, recv, "GetHistoricalInfo at height 5 is not empty after prune")
 }

x/staking/keeper/keeper_test.go

@@ -1,24 +1,28 @@
-package keeper
+package keeper_test
 
 import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
 
+	"github.com/cosmos/cosmos-sdk/simapp"
 	"github.com/cosmos/cosmos-sdk/x/staking/types"
+	abci "github.com/tendermint/tendermint/abci/types"
 )
 
 func TestParams(t *testing.T) {
-	ctx, _, _, keeper, _ := CreateTestInput(t, false, 0)
+	app := simapp.Setup(false)
+	ctx := app.BaseApp.NewContext(false, abci.Header{})
+
 	expParams := types.DefaultParams()
 
 	//check that the empty keeper loads the default
-	resParams := keeper.GetParams(ctx)
+	resParams := app.StakingKeeper.GetParams(ctx)
 	require.True(t, expParams.Equal(resParams))
 
 	//modify a params, save, and retrieve
 	expParams.MaxValidators = 777
-	keeper.SetParams(ctx, expParams)
-	resParams = keeper.GetParams(ctx)
+	app.StakingKeeper.SetParams(ctx, expParams)
+	resParams = app.StakingKeeper.GetParams(ctx)
 	require.True(t, expParams.Equal(resParams))
 }