Merge branch 'master' into jonathan/5684-prune-syncable

.github/CODEOWNERS

@@ -1,4 +1,4 @@
 # CODEOWNERS: https://help.github.com/articles/about-codeowners/
 
 # Primary repo maintainers
-*       @alexanderbez @jackzampolin @alessio @fedekunze 
+*       @alexanderbez @alessio @fedekunze @nylira @hschoenburg

simapp/test_helpers.go

@@ -1,6 +1,10 @@
 package simapp
 
 import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"strconv"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -77,15 +81,56 @@ func SetupWithGenesisAccounts(genAccs []authexported.GenesisAccount, balances ..
 	return app
 }
 
-// AddTestAddrs constructs and returns accNum amount of accounts with an
-// initial balance of accAmt
-func AddTestAddrs(app *SimApp, ctx sdk.Context, accNum int, accAmt sdk.Int) []sdk.AccAddress {
+type GenerateAccountStrategy func(int) []sdk.AccAddress
+
+// createRandomAccounts is a strategy used by addTestAddrs() in order to generated addresses in random order.
+func createRandomAccounts(accNum int) []sdk.AccAddress {
 	testAddrs := make([]sdk.AccAddress, accNum)
 	for i := 0; i < accNum; i++ {
 		pk := ed25519.GenPrivKey().PubKey()
 		testAddrs[i] = sdk.AccAddress(pk.Address())
 	}
 
+	return testAddrs
+}
+
+// createIncrementalAccounts is a strategy used by addTestAddrs() in order to generated addresses in ascending order.
+func createIncrementalAccounts(accNum int) []sdk.AccAddress {
+	var addresses []sdk.AccAddress
+	var buffer bytes.Buffer
+
+	// start at 100 so we can make up to 999 test addresses with valid test addresses
+	for i := 100; i < (accNum + 100); i++ {
+		numString := strconv.Itoa(i)
+		buffer.WriteString("A58856F0FD53BF058B4909A21AEC019107BA6") //base address string
+
+		buffer.WriteString(numString) //adding on final two digits to make addresses unique
+		res, _ := sdk.AccAddressFromHex(buffer.String())
+		bech := res.String()
+		addr, _ := TestAddr(buffer.String(), bech)
+
+		addresses = append(addresses, addr)
+		buffer.Reset()
+	}
+
+	return addresses
+}
+
+// AddTestAddrs constructs and returns accNum amount of accounts with an
+// initial balance of accAmt in random order
+func AddTestAddrs(app *SimApp, ctx sdk.Context, accNum int, accAmt sdk.Int) []sdk.AccAddress {
+	return addTestAddrs(app, ctx, accNum, accAmt, createRandomAccounts)
+}
+
+// AddTestAddrs constructs and returns accNum amount of accounts with an
+// initial balance of accAmt in random order
+func AddTestAddrsIncremental(app *SimApp, ctx sdk.Context, accNum int, accAmt sdk.Int) []sdk.AccAddress {
+	return addTestAddrs(app, ctx, accNum, accAmt, createIncrementalAccounts)
+}
+
+func addTestAddrs(app *SimApp, ctx sdk.Context, accNum int, accAmt sdk.Int, strategy GenerateAccountStrategy) []sdk.AccAddress {
+	testAddrs := strategy(accNum)
+
 	initCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), accAmt))
 	totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), accAmt.MulRaw(int64(len(testAddrs)))))
 	prevSupply := app.SupplyKeeper.GetSupply(ctx)
@@ -104,6 +149,38 @@ func AddTestAddrs(app *SimApp, ctx sdk.Context, accNum int, accAmt sdk.Int) []sd
 	return testAddrs
 }
 
+// ConvertAddrsToValAddrs converts the provided addresses to ValAddress.
+func ConvertAddrsToValAddrs(addrs []sdk.AccAddress) []sdk.ValAddress {
+	valAddrs := make([]sdk.ValAddress, len(addrs))
+
+	for i, addr := range addrs {
+		valAddrs[i] = sdk.ValAddress(addr)
+	}
+
+	return valAddrs
+}
+
+func TestAddr(addr string, bech string) (sdk.AccAddress, error) {
+	res, err := sdk.AccAddressFromHex(addr)
+	if err != nil {
+		return nil, err
+	}
+	bechexpected := res.String()
+	if bech != bechexpected {
+		return nil, fmt.Errorf("bech encoding doesn't match reference")
+	}
+
+	bechres, err := sdk.AccAddressFromBech32(bech)
+	if err != nil {
+		return nil, err
+	}
+	if !bytes.Equal(bechres, res) {
+		return nil, err
+	}
+
+	return res, nil
+}
+
 // CheckBalance checks the balance of an account.
 func CheckBalance(t *testing.T, app *SimApp, addr sdk.AccAddress, balances sdk.Coins) {
 	ctxCheck := app.BaseApp.NewContext(true, abci.Header{})
@@ -187,3 +264,31 @@ func incrementAllSequenceNumbers(initSeqNums []uint64) {
 		initSeqNums[i]++
 	}
 }
+
+// CreateTestPubKeys returns a total of numPubKeys public keys in ascending order.
+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, NewPubKeyFromHex(buffer.String()))
+		buffer.Reset()
+	}
+
+	return publicKeys
+}
+
+// NewPubKeyFromHex returns a PubKey from a hex string.
+func NewPubKeyFromHex(pk string) (res crypto.PubKey) {
+	pkBytes, err := hex.DecodeString(pk)
+	if err != nil {
+		panic(err)
+	}
+	var pkEd ed25519.PubKeyEd25519
+	copy(pkEd[:], pkBytes)
+	return pkEd
+}

version/command.go

@@ -2,7 +2,6 @@ package version
 
 import (
 	"encoding/json"
-	"fmt"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -21,29 +20,31 @@ func init() {
 var Cmd = &cobra.Command{
 	Use:   "version",
 	Short: "Print the app version",
-	RunE: func(_ *cobra.Command, _ []string) error {
-		verInfo := NewInfo()
+	RunE:  runVersionCmd,
+}
 
-		if !viper.GetBool(flagLong) {
-			fmt.Println(verInfo.Version)
-			return nil
-		}
+func runVersionCmd(cmd *cobra.Command, args []string) error {
+	verInfo := NewInfo()
 
-		var bz []byte
-		var err error
+	if !viper.GetBool(flagLong) {
+		cmd.Println(verInfo.Version)
+		return nil
+	}
 
-		switch viper.GetString(cli.OutputFlag) {
-		case "json":
-			bz, err = json.Marshal(verInfo)
-		default:
-			bz, err = yaml.Marshal(&verInfo)
-		}
+	var bz []byte
+	var err error
 
-		if err != nil {
-			return err
-		}
+	switch viper.GetString(cli.OutputFlag) {
+	case "json":
+		bz, err = json.Marshal(verInfo)
+	default:
+		bz, err = yaml.Marshal(&verInfo)
+	}
 
-		_, err = fmt.Println(string(bz))
+	if err != nil {
 		return err
-	},
+	}
+
+	cmd.Println(string(bz))
+	return nil
 }

version/version_test.go

@@ -0,0 +1,60 @@
+package version
+
+import (
+	"encoding/json"
+	"fmt"
+	"runtime"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/tendermint/tendermint/libs/cli"
+
+	"github.com/cosmos/cosmos-sdk/tests"
+)
+
+func TestNewInfo(t *testing.T) {
+	info := NewInfo()
+	want := fmt.Sprintf(`: 
+git commit: 
+build tags: 
+%s`, fmt.Sprintf("go version %s %s/%s", runtime.Version(), runtime.GOOS, runtime.GOARCH))
+	require.Equal(t, want, info.String())
+}
+
+func TestInfo_String(t *testing.T) {
+	info := Info{
+		Name:       "testapp",
+		ServerName: "testappd",
+		ClientName: "testappcli",
+		Version:    "1.0.0",
+		GitCommit:  "1b78457135a4104bc3af97f20654d49e2ea87454",
+		BuildTags:  "netgo,ledger",
+		GoVersion:  "go version go1.14 linux/amd64",
+	}
+	want := fmt.Sprintf(`testapp: 1.0.0
+git commit: 1b78457135a4104bc3af97f20654d49e2ea87454
+build tags: netgo,ledger
+go version go1.14 linux/amd64`)
+	require.Equal(t, want, info.String())
+}
+
+func Test_runVersionCmd(t *testing.T) {
+	require.NotNil(t, Cmd)
+	_, mockOut, _ := tests.ApplyMockIO(Cmd)
+
+	viper.Set(cli.OutputFlag, "")
+	viper.Set(flagLong, false)
+	require.NoError(t, runVersionCmd(Cmd, nil))
+	assert.Equal(t, "\n", mockOut.String())
+	mockOut.Reset()
+
+	viper.Set(cli.OutputFlag, "json")
+	viper.Set(flagLong, true)
+	info := NewInfo()
+	stringInfo, err := json.Marshal(info)
+	require.NoError(t, err)
+	require.NoError(t, runVersionCmd(Cmd, nil))
+	assert.Equal(t, string(stringInfo)+"\n", mockOut.String())
+}

x/staking/common_test.go

@@ -1,12 +1,16 @@
 package staking_test
 
 import (
+	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/secp256k1"
 
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/simapp"
+	cdc "github.com/cosmos/cosmos-sdk/simapp/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/staking"
+	"github.com/cosmos/cosmos-sdk/x/staking/keeper"
 	"github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
@@ -16,16 +20,10 @@ var (
 	addr1 = sdk.AccAddress(priv1.PubKey().Address())
 	priv2 = secp256k1.GenPrivKey()
 	addr2 = sdk.AccAddress(priv2.PubKey().Address())
-	addr3 = sdk.AccAddress(secp256k1.GenPrivKey().PubKey().Address())
-	priv4 = secp256k1.GenPrivKey()
-	addr4 = sdk.AccAddress(priv4.PubKey().Address())
-	coins = sdk.Coins{sdk.NewCoin("foocoin", sdk.NewInt(10))}
-	fee   = auth.NewStdFee(
-		100000,
-		sdk.Coins{sdk.NewCoin("foocoin", sdk.NewInt(0))},
-	)
 
 	commissionRates = staking.NewCommissionRates(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec())
+
+	PKs = simapp.CreateTestPubKeys(500)
 )
 
 func NewTestMsgCreateValidator(address sdk.ValAddress, pubKey crypto.PubKey, amt sdk.Int) staking.MsgCreateValidator {
@@ -38,3 +36,31 @@ func NewTestMsgDelegate(delAddr sdk.AccAddress, valAddr sdk.ValAddress, amt sdk.
 	amount := sdk.NewCoin(sdk.DefaultBondDenom, amt)
 	return staking.NewMsgDelegate(delAddr, valAddr, amount)
 }
+
+// getBaseSimappWithCustomKeeper Returns a simapp with custom StakingKeeper
+// to avoid messing with the hooks.
+func getBaseSimappWithCustomKeeper() (*codec.Codec, *simapp.SimApp, sdk.Context) {
+	app := simapp.Setup(false)
+	ctx := app.BaseApp.NewContext(false, abci.Header{})
+
+	appCodec := cdc.NewAppCodec(codec.New())
+
+	app.StakingKeeper = keeper.NewKeeper(
+		appCodec,
+		app.GetKey(staking.StoreKey),
+		app.BankKeeper,
+		app.SupplyKeeper,
+		app.GetSubspace(staking.ModuleName),
+	)
+	app.StakingKeeper.SetParams(ctx, types.DefaultParams())
+
+	return codec.New(), app, ctx
+}
+
+// generateAddresses generates numAddrs of normal AccAddrs and ValAddrs
+func generateAddresses(app *simapp.SimApp, ctx sdk.Context, numAddrs int, accAmount int64) ([]sdk.AccAddress, []sdk.ValAddress) {
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, numAddrs, sdk.NewInt(accAmount))
+	addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
+
+	return addrDels, addrVals
+}