From 014caf80ce7e9de0e31275f4658f609b360fe470 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Wed, 15 Apr 2020 03:57:15 +0530 Subject: [PATCH 01/61] Added cli integration base setup --- Makefile | 15 +- cli_test/cli_test.go | 45 +++++ cli_test/test_helpers.go | 360 +++++++++++++++++++++++++++++++++ simapp/cmd/simcli/main.go | 184 +++++++++++++++++ simapp/cmd/simd/genaccounts.go | 166 +++++++++++++++ simapp/cmd/simd/main.go | 117 +++++++++++ 6 files changed, 886 insertions(+), 1 deletion(-) create mode 100644 cli_test/cli_test.go create mode 100644 cli_test/test_helpers.go create mode 100644 simapp/cmd/simcli/main.go create mode 100644 simapp/cmd/simd/genaccounts.go create mode 100644 simapp/cmd/simd/main.go diff --git a/Makefile b/Makefile index 25ef7ea375b1..b91f2457c47e 100644 --- a/Makefile +++ b/Makefile @@ -24,6 +24,15 @@ build: go.sum @go build -mod=readonly ./... .PHONY: build +build-sim: go.sum +ifeq ($(OS),Windows_NT) + go build -mod=readonly $(BUILD_FLAGS) -o build/simd.exe ./simapp/cmd/simd + go build -mod=readonly $(BUILD_FLAGS) -o build/simcli.exe ./simapp/cmd/simcli +else + go build -mod=readonly $(BUILD_FLAGS) -o build/simd ./simapp/cmd/simd + go build -mod=readonly $(BUILD_FLAGS) -o build/simcli ./simapp/cmd/simcli +endif + mocks: $(MOCKS_DIR) mockgen -source=x/auth/types/account_retriever.go -package mocks -destination tests/mocks/account_retriever.go mockgen -package mocks -destination tests/mocks/tendermint_tm_db_DB.go github.com/tendermint/tm-db DB @@ -152,6 +161,9 @@ test-sim-benchmark-invariants: -Enabled=true -NumBlocks=1000 -BlockSize=200 \ -Period=1 -Commit=true -Seed=57 -v -timeout 24h +test-cli: build-sim + @go test -mod=readonly -p 4 `go list ./cli_test/...` -tags=cli_test -v + .PHONY: \ test-sim-nondeterminism \ test-sim-custom-genesis-fast \ @@ -160,7 +172,8 @@ test-sim-after-import \ test-sim-custom-genesis-multi-seed \ test-sim-multi-seed-short \ test-sim-multi-seed-long \ -test-sim-benchmark-invariants +test-sim-benchmark-invariants \ +test-cli SIM_NUM_BLOCKS ?= 500 SIM_BLOCK_SIZE ?= 200 diff --git a/cli_test/cli_test.go b/cli_test/cli_test.go new file mode 100644 index 000000000000..0c33e9b9cba9 --- /dev/null +++ b/cli_test/cli_test.go @@ -0,0 +1,45 @@ +package clitest + +import ( + "fmt" + codecstd "github.com/cosmos/cosmos-sdk/codec/std" + "github.com/cosmos/cosmos-sdk/simapp" + authclient "github.com/cosmos/cosmos-sdk/x/auth/client" + "github.com/stretchr/testify/require" + "testing" +) + +var ( + cdc = codecstd.MakeCodec(simapp.ModuleBasics) + appCodec = codecstd.NewAppCodec(cdc) +) + +func init() { + authclient.Codec = appCodec +} +func TestCLIKeysAddMultisig(t *testing.T) { + t.Parallel() + f := InitFixtures(t) + + // key names order does not matter + f.KeysAdd("msig1", "--multisig-threshold=2", + fmt.Sprintf("--multisig=%s,%s", keyBar, keyBaz)) + ke1Address1 := f.KeysShow("msig1").Address + f.KeysDelete("msig1") + + f.KeysAdd("msig2", "--multisig-threshold=2", + fmt.Sprintf("--multisig=%s,%s", keyBaz, keyBar)) + require.Equal(t, ke1Address1, f.KeysShow("msig2").Address) + f.KeysDelete("msig2") + + f.KeysAdd("msig3", "--multisig-threshold=2", + fmt.Sprintf("--multisig=%s,%s", keyBar, keyBaz), + "--nosort") + f.KeysAdd("msig4", "--multisig-threshold=2", + fmt.Sprintf("--multisig=%s,%s", keyBaz, keyBar), + "--nosort") + require.NotEqual(t, f.KeysShow("msig3").Address, f.KeysShow("msig4").Address) + + // Cleanup testing directories + f.Cleanup() +} diff --git a/cli_test/test_helpers.go b/cli_test/test_helpers.go new file mode 100644 index 000000000000..fee10ddf8a3b --- /dev/null +++ b/cli_test/test_helpers.go @@ -0,0 +1,360 @@ +package clitest + +import ( + "encoding/json" + "fmt" + clientkeys "github.com/cosmos/cosmos-sdk/client/keys" + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/crypto/keyring" + "github.com/cosmos/cosmos-sdk/server" + "github.com/cosmos/cosmos-sdk/simapp" + "github.com/cosmos/cosmos-sdk/tests" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/stretchr/testify/require" + tmtypes "github.com/tendermint/tendermint/types" + "io/ioutil" + "os" + "path/filepath" + "strings" + "testing" + "time" +) + +const ( + denom = "stake" + keyFoo = "foo" + keyBar = "bar" + fooDenom = "footoken" + feeDenom = "feetoken" + fee2Denom = "fee2token" + keyBaz = "baz" + keyVesting = "vesting" + keyFooBarBaz = "foobarbaz" +) + +var ( + totalCoins = sdk.NewCoins( + sdk.NewCoin(fee2Denom, sdk.TokensFromConsensusPower(2000000)), + sdk.NewCoin(feeDenom, sdk.TokensFromConsensusPower(2000000)), + sdk.NewCoin(fooDenom, sdk.TokensFromConsensusPower(2000)), + sdk.NewCoin(denom, sdk.TokensFromConsensusPower(300).Add(sdk.NewInt(12))), // add coins from inflation + ) + + startCoins = sdk.NewCoins( + sdk.NewCoin(fee2Denom, sdk.TokensFromConsensusPower(1000000)), + sdk.NewCoin(feeDenom, sdk.TokensFromConsensusPower(1000000)), + sdk.NewCoin(fooDenom, sdk.TokensFromConsensusPower(1000)), + sdk.NewCoin(denom, sdk.TokensFromConsensusPower(150)), + ) + + vestingCoins = sdk.NewCoins( + sdk.NewCoin(feeDenom, sdk.TokensFromConsensusPower(500000)), + ) +) + +//___________________________________________________________________________________ +// Fixtures + +// Fixtures is used to setup the testing environment +type Fixtures struct { + BuildDir string + RootDir string + SimdBinary string + SimcliBinary string + ChainID string + RPCAddr string + Port string + SimdHome string + SimcliHome string + P2PAddr string + T *testing.T +} + +// NewFixtures creates a new instance of Fixtures with many vars set +func NewFixtures(t *testing.T) *Fixtures { + tmpDir, err := ioutil.TempDir("", "sdk_integration_"+t.Name()+"_") + require.NoError(t, err) + + servAddr, port, err := server.FreeTCPAddr() + require.NoError(t, err) + + p2pAddr, _, err := server.FreeTCPAddr() + require.NoError(t, err) + + buildDir := os.Getenv("BUILDDIR") + if buildDir == "" { + buildDir, err = filepath.Abs("../build/") + require.NoError(t, err) + } + + return &Fixtures{ + T: t, + BuildDir: buildDir, + RootDir: tmpDir, + SimdBinary: filepath.Join(buildDir, "simd"), + SimcliBinary: filepath.Join(buildDir, "simcli"), + SimdHome: filepath.Join(tmpDir, ".simd"), + SimcliHome: filepath.Join(tmpDir, ".simcli"), + RPCAddr: servAddr, + P2PAddr: p2pAddr, + Port: port, + } +} + +// GenesisFile returns the path of the genesis file +func (f Fixtures) GenesisFile() string { + return filepath.Join(f.SimdHome, "config", "genesis.json") +} + +// GenesisFile returns the application's genesis state +func (f Fixtures) GenesisState() simapp.GenesisState { + cdc := codec.New() + genDoc, err := tmtypes.GenesisDocFromFile(f.GenesisFile()) + require.NoError(f.T, err) + + var appState simapp.GenesisState + require.NoError(f.T, cdc.UnmarshalJSON(genDoc.AppState, &appState)) + return appState +} + +// InitFixtures is called at the beginning of a test and initializes a chain +// with 1 validator. +func InitFixtures(t *testing.T) (f *Fixtures) { + f = NewFixtures(t) + + // reset test state + f.UnsafeResetAll() + + f.CLIConfig("keyring-backend", "test") + + // ensure keystore has foo and bar keys + f.KeysDelete(keyFoo) + f.KeysDelete(keyBar) + f.KeysDelete(keyBar) + f.KeysDelete(keyFooBarBaz) + f.KeysAdd(keyFoo) + f.KeysAdd(keyBar) + f.KeysAdd(keyBaz) + f.KeysAdd(keyVesting) + f.KeysAdd(keyFooBarBaz, "--multisig-threshold=2", fmt.Sprintf( + "--multisig=%s,%s,%s", keyFoo, keyBar, keyBaz)) + + // ensure that CLI output is in JSON format + f.CLIConfig("output", "json") + + // NOTE: GDInit sets the ChainID + f.GDInit(keyFoo) + + f.CLIConfig("chain-id", f.ChainID) + f.CLIConfig("broadcast-mode", "block") + f.CLIConfig("trust-node", "true") + + // start an account with tokens + f.AddGenesisAccount(f.KeyAddress(keyFoo), startCoins) + f.AddGenesisAccount( + f.KeyAddress(keyVesting), startCoins, + fmt.Sprintf("--vesting-amount=%s", vestingCoins), + fmt.Sprintf("--vesting-start-time=%d", time.Now().UTC().UnixNano()), + fmt.Sprintf("--vesting-end-time=%d", time.Now().Add(60*time.Second).UTC().UnixNano()), + ) + + f.GenTx(keyFoo) + f.CollectGenTxs() + + return f +} + +// Cleanup is meant to be run at the end of a test to clean up an remaining test state +func (f *Fixtures) Cleanup(dirs ...string) { + clean := append(dirs, f.RootDir) + for _, d := range clean { + require.NoError(f.T, os.RemoveAll(d)) + } +} + +// Flags returns the flags necessary for making most CLI calls +func (f *Fixtures) Flags() string { + return fmt.Sprintf("--home=%s --node=%s", f.SimcliHome, f.RPCAddr) +} + +//___________________________________________________________________________________ +// gaiad + +// UnsafeResetAll is gaiad unsafe-reset-all +func (f *Fixtures) UnsafeResetAll(flags ...string) { + cmd := fmt.Sprintf("%s --home=%s unsafe-reset-all", f.SimdBinary, f.SimdHome) + executeWrite(f.T, addFlags(cmd, flags)) + err := os.RemoveAll(filepath.Join(f.SimdHome, "config", "gentx")) + require.NoError(f.T, err) +} + +// GDInit is gaiad init +// NOTE: GDInit sets the ChainID for the Fixtures instance +func (f *Fixtures) GDInit(moniker string, flags ...string) { + cmd := fmt.Sprintf("%s init -o --home=%s %s", f.SimdBinary, f.SimdHome, moniker) + _, stderr := tests.ExecuteT(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) + + var chainID string + var initRes map[string]json.RawMessage + + err := json.Unmarshal([]byte(stderr), &initRes) + require.NoError(f.T, err) + + err = json.Unmarshal(initRes["chain_id"], &chainID) + require.NoError(f.T, err) + + f.ChainID = chainID +} + +// AddGenesisAccount is gaiad add-genesis-account +func (f *Fixtures) AddGenesisAccount(address sdk.AccAddress, coins sdk.Coins, flags ...string) { + cmd := fmt.Sprintf("%s add-genesis-account %s %s --home=%s --keyring-backend=test", f.SimdBinary, address, coins, f.SimdHome) + executeWriteCheckErr(f.T, addFlags(cmd, flags)) +} + +// GenTx is gaiad gentx +func (f *Fixtures) GenTx(name string, flags ...string) { + cmd := fmt.Sprintf("%s gentx --name=%s --home=%s --home-client=%s --keyring-backend=test", f.SimdBinary, name, f.SimdHome, f.SimcliHome) + executeWriteCheckErr(f.T, addFlags(cmd, flags)) +} + +// CollectGenTxs is gaiad collect-gentxs +func (f *Fixtures) CollectGenTxs(flags ...string) { + cmd := fmt.Sprintf("%s collect-gentxs --home=%s", f.SimdBinary, f.SimdHome) + executeWriteCheckErr(f.T, addFlags(cmd, flags)) +} + +// GDStart runs gaiad start with the appropriate flags and returns a process +func (f *Fixtures) GDStart(flags ...string) *tests.Process { + cmd := fmt.Sprintf("%s start --home=%s --rpc.laddr=%v --p2p.laddr=%v", f.SimdBinary, f.SimdHome, f.RPCAddr, f.P2PAddr) + proc := tests.GoExecuteTWithStdout(f.T, addFlags(cmd, flags)) + tests.WaitForTMStart(f.Port) + tests.WaitForNextNBlocksTM(1, f.Port) + return proc +} + +// GDTendermint returns the results of gaiad tendermint [query] +func (f *Fixtures) GDTendermint(query string) string { + cmd := fmt.Sprintf("%s tendermint %s --home=%s", f.SimdBinary, query, f.SimdHome) + success, stdout, stderr := executeWriteRetStdStreams(f.T, cmd) + require.Empty(f.T, stderr) + require.True(f.T, success) + return strings.TrimSpace(stdout) +} + +// ValidateGenesis runs gaiad validate-genesis +func (f *Fixtures) ValidateGenesis() { + cmd := fmt.Sprintf("%s validate-genesis --home=%s", f.SimdBinary, f.SimdHome) + executeWriteCheckErr(f.T, cmd) +} + +//___________________________________________________________________________________ +// gaiacli keys + +// KeysDelete is gaiacli keys delete +func (f *Fixtures) KeysDelete(name string, flags ...string) { + cmd := fmt.Sprintf("%s keys delete --keyring-backend=test --home=%s %s", f.SimcliBinary, + f.SimcliHome, name) + executeWrite(f.T, addFlags(cmd, append(append(flags, "-y"), "-f"))) +} + +// KeysAdd is gaiacli keys add +func (f *Fixtures) KeysAdd(name string, flags ...string) { + cmd := fmt.Sprintf("%s keys add --keyring-backend=test --home=%s %s", f.SimcliBinary, + f.SimcliHome, name) + executeWriteCheckErr(f.T, addFlags(cmd, flags)) +} + +// KeysAddRecover prepares gaiacli keys add --recover +func (f *Fixtures) KeysAddRecover(name, mnemonic string, flags ...string) (exitSuccess bool, stdout, stderr string) { + cmd := fmt.Sprintf("%s keys add --keyring-backend=test --home=%s --recover %s", + f.SimcliBinary, f.SimcliHome, name) + return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), mnemonic) +} + +// KeysAddRecoverHDPath prepares gaiacli keys add --recover --account --index +func (f *Fixtures) KeysAddRecoverHDPath(name, mnemonic string, account uint32, index uint32, flags ...string) { + cmd := fmt.Sprintf("%s keys add --keyring-backend=test --home=%s --recover %s --account %d"+ + " --index %d", f.SimcliBinary, f.SimcliHome, name, account, index) + executeWriteCheckErr(f.T, addFlags(cmd, flags), mnemonic) +} + +// KeysShow is gaiacli keys show +func (f *Fixtures) KeysShow(name string, flags ...string) keyring.KeyOutput { + cmd := fmt.Sprintf("%s keys show --keyring-backend=test --home=%s %s", f.SimcliBinary, + f.SimcliHome, name) + out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + var ko keyring.KeyOutput + err := clientkeys.UnmarshalJSON([]byte(out), &ko) + require.NoError(f.T, err) + return ko +} + +// KeyAddress returns the SDK account address from the key +func (f *Fixtures) KeyAddress(name string) sdk.AccAddress { + ko := f.KeysShow(name) + accAddr, err := sdk.AccAddressFromBech32(ko.Address) + require.NoError(f.T, err) + return accAddr +} + +//___________________________________________________________________________________ +// gaiacli config + +// CLIConfig is gaiacli config +func (f *Fixtures) CLIConfig(key, value string, flags ...string) { + cmd := fmt.Sprintf("%s config --home=%s %s %s", f.SimcliBinary, f.SimcliHome, key, value) + executeWriteCheckErr(f.T, addFlags(cmd, flags)) +} + +//___________________________________________________________________________________ +// executors + +func executeWriteCheckErr(t *testing.T, cmdStr string, writes ...string) { + require.True(t, executeWrite(t, cmdStr, writes...)) +} + +func executeWrite(t *testing.T, cmdStr string, writes ...string) (exitSuccess bool) { + exitSuccess, _, _ = executeWriteRetStdStreams(t, cmdStr, writes...) + return +} + +func executeWriteRetStdStreams(t *testing.T, cmdStr string, writes ...string) (bool, string, string) { + proc := tests.GoExecuteT(t, cmdStr) + + // Enables use of interactive commands + for _, write := range writes { + _, err := proc.StdinPipe.Write([]byte(write + "\n")) + require.NoError(t, err) + } + + // Read both stdout and stderr from the process + stdout, stderr, err := proc.ReadAll() + if err != nil { + fmt.Println("Err on proc.ReadAll()", err, cmdStr) + } + + // Log output. + if len(stdout) > 0 { + t.Log("Stdout:", string(stdout)) + } + if len(stderr) > 0 { + t.Log("Stderr:", string(stderr)) + } + + // Wait for process to exit + proc.Wait() + + // Return succes, stdout, stderr + return proc.ExitState.Success(), string(stdout), string(stderr) +} + +//___________________________________________________________________________________ +// utils + +func addFlags(cmd string, flags []string) string { + for _, f := range flags { + cmd += " " + f + } + return strings.TrimSpace(cmd) +} diff --git a/simapp/cmd/simcli/main.go b/simapp/cmd/simcli/main.go new file mode 100644 index 000000000000..8de0fd9e1af4 --- /dev/null +++ b/simapp/cmd/simcli/main.go @@ -0,0 +1,184 @@ +package main + +import ( + "fmt" + "github.com/cosmos/cosmos-sdk/simapp" + "os" + "path" + + "github.com/spf13/cobra" + "github.com/spf13/viper" + "github.com/tendermint/go-amino" + "github.com/tendermint/tendermint/libs/cli" + + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/client/keys" + "github.com/cosmos/cosmos-sdk/client/lcd" + "github.com/cosmos/cosmos-sdk/client/rpc" + codecstd "github.com/cosmos/cosmos-sdk/codec/std" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/version" + "github.com/cosmos/cosmos-sdk/x/auth" + authclient "github.com/cosmos/cosmos-sdk/x/auth/client" + authcmd "github.com/cosmos/cosmos-sdk/x/auth/client/cli" + authrest "github.com/cosmos/cosmos-sdk/x/auth/client/rest" + "github.com/cosmos/cosmos-sdk/x/bank" + bankcmd "github.com/cosmos/cosmos-sdk/x/bank/client/cli" +) + +var ( + cdc = codecstd.MakeCodec(simapp.ModuleBasics) + appCodec = codecstd.NewAppCodec(cdc) +) + +func init() { + authclient.Codec = appCodec +} + +func main() { + // Configure cobra to sort commands + cobra.EnableCommandSorting = false + + // Read in the configuration file for the sdk + config := sdk.GetConfig() + config.SetBech32PrefixForAccount(sdk.Bech32PrefixAccAddr, sdk.Bech32PrefixAccPub) + config.SetBech32PrefixForValidator(sdk.Bech32PrefixValAddr, sdk.Bech32PrefixValPub) + config.SetBech32PrefixForConsensusNode(sdk.Bech32PrefixConsAddr, sdk.Bech32PrefixConsPub) + config.Seal() + + // TODO: setup keybase, viper object, etc. to be passed into + // the below functions and eliminate global vars, like we do + // with the cdc + + rootCmd := &cobra.Command{ + Use: "simcli", + Short: "Command line interface for interacting with gaiad", + } + + // Add --chain-id to persistent flags and mark it required + rootCmd.PersistentFlags().String(flags.FlagChainID, "", "Chain ID of tendermint node") + rootCmd.PersistentPreRunE = func(_ *cobra.Command, _ []string) error { + return initConfig(rootCmd) + } + + // Construct Root Command + rootCmd.AddCommand( + rpc.StatusCommand(), + client.ConfigCmd(simapp.DefaultCLIHome), + queryCmd(cdc), + txCmd(cdc), + flags.LineBreak, + lcd.ServeCommand(cdc, registerRoutes), + flags.LineBreak, + keys.Commands(), + flags.LineBreak, + version.Cmd, + flags.NewCompletionCmd(rootCmd, true), + ) + + // Add flags and prefix all env exposed with GA + executor := cli.PrepareMainCmd(rootCmd, "GA", simapp.DefaultCLIHome) + + err := executor.Execute() + if err != nil { + fmt.Printf("Failed executing CLI command: %s, exiting...\n", err) + os.Exit(1) + } +} + +func queryCmd(cdc *amino.Codec) *cobra.Command { + queryCmd := &cobra.Command{ + Use: "query", + Aliases: []string{"q"}, + Short: "Querying subcommands", + DisableFlagParsing: true, + SuggestionsMinimumDistance: 2, + RunE: client.ValidateCmd, + } + + queryCmd.AddCommand( + authcmd.GetAccountCmd(cdc), + flags.LineBreak, + rpc.ValidatorCommand(cdc), + rpc.BlockCommand(), + authcmd.QueryTxsByEventsCmd(cdc), + authcmd.QueryTxCmd(cdc), + flags.LineBreak, + ) + + // add modules' query commands + simapp.ModuleBasics.AddQueryCommands(queryCmd, cdc) + + return queryCmd +} + +func txCmd(cdc *amino.Codec) *cobra.Command { + txCmd := &cobra.Command{ + Use: "tx", + Short: "Transactions subcommands", + DisableFlagParsing: true, + SuggestionsMinimumDistance: 2, + RunE: client.ValidateCmd, + } + + txCmd.AddCommand( + bankcmd.SendTxCmd(cdc), + flags.LineBreak, + authcmd.GetSignCommand(cdc), + authcmd.GetMultiSignCommand(cdc), + flags.LineBreak, + authcmd.GetBroadcastCommand(cdc), + authcmd.GetEncodeCommand(cdc), + authcmd.GetDecodeCommand(cdc), + flags.LineBreak, + ) + + // add modules' tx commands + simapp.ModuleBasics.AddTxCommands(txCmd, cdc) + + // remove auth and bank commands as they're mounted under the root tx command + var cmdsToRemove []*cobra.Command + + for _, cmd := range txCmd.Commands() { + if cmd.Use == auth.ModuleName || cmd.Use == bank.ModuleName { + cmdsToRemove = append(cmdsToRemove, cmd) + } + } + + txCmd.RemoveCommand(cmdsToRemove...) + + return txCmd +} + +// registerRoutes registers the routes from the different modules for the LCD. +// NOTE: details on the routes added for each module are in the module documentation +// NOTE: If making updates here you also need to update the test helper in client/lcd/test_helper.go +func registerRoutes(rs *lcd.RestServer) { + client.RegisterRoutes(rs.CliCtx, rs.Mux) + authrest.RegisterTxRoutes(rs.CliCtx, rs.Mux) + simapp.ModuleBasics.RegisterRESTRoutes(rs.CliCtx, rs.Mux) +} + +func initConfig(cmd *cobra.Command) error { + home, err := cmd.PersistentFlags().GetString(cli.HomeFlag) + if err != nil { + return err + } + + cfgFile := path.Join(home, "config", "config.toml") + if _, err := os.Stat(cfgFile); err == nil { + viper.SetConfigFile(cfgFile) + + if err := viper.ReadInConfig(); err != nil { + return err + } + } + if err := viper.BindPFlag(flags.FlagChainID, cmd.PersistentFlags().Lookup(flags.FlagChainID)); err != nil { + return err + } + if err := viper.BindPFlag(cli.EncodingFlag, cmd.PersistentFlags().Lookup(cli.EncodingFlag)); err != nil { + return err + } + return viper.BindPFlag(cli.OutputFlag, cmd.PersistentFlags().Lookup(cli.OutputFlag)) +} diff --git a/simapp/cmd/simd/genaccounts.go b/simapp/cmd/simd/genaccounts.go new file mode 100644 index 000000000000..fd33fa974d6d --- /dev/null +++ b/simapp/cmd/simd/genaccounts.go @@ -0,0 +1,166 @@ +package main + +import ( + "bufio" + "errors" + "fmt" + "github.com/cosmos/cosmos-sdk/client/flags" + codecstd "github.com/cosmos/cosmos-sdk/codec/std" + "github.com/cosmos/cosmos-sdk/crypto/keyring" + "github.com/cosmos/cosmos-sdk/server" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/auth" + authexported "github.com/cosmos/cosmos-sdk/x/auth/exported" + authvesting "github.com/cosmos/cosmos-sdk/x/auth/vesting" + "github.com/cosmos/cosmos-sdk/x/bank" + "github.com/cosmos/cosmos-sdk/x/genutil" + "github.com/spf13/cobra" + "github.com/spf13/viper" + "github.com/tendermint/go-amino" + "github.com/tendermint/tendermint/libs/cli" +) + +const ( + flagClientHome = "home-client" + flagVestingStart = "vesting-start-time" + flagVestingEnd = "vesting-end-time" + flagVestingAmt = "vesting-amount" +) + +// AddGenesisAccountCmd returns add-genesis-account cobra Command. +func AddGenesisAccountCmd( + ctx *server.Context, depCdc *amino.Codec, cdc *codecstd.Codec, defaultNodeHome, defaultClientHome string, +) *cobra.Command { + + cmd := &cobra.Command{ + Use: "add-genesis-account [address_or_key_name] [coin][,[coin]]", + Short: "Add a genesis account to genesis.json", + Long: `Add a genesis account to genesis.json. The provided account must specify +the account address or key name and a list of initial coins. If a key name is given, +the address will be looked up in the local Keybase. The list of initial tokens must +contain valid denominations. Accounts may optionally be supplied with vesting parameters. +`, + Args: cobra.ExactArgs(2), + RunE: func(cmd *cobra.Command, args []string) error { + config := ctx.Config + config.SetRoot(viper.GetString(cli.HomeFlag)) + + addr, err := sdk.AccAddressFromBech32(args[0]) + inBuf := bufio.NewReader(cmd.InOrStdin()) + if err != nil { + // attempt to lookup address from Keybase if no address was provided + kb, err := keyring.New( + sdk.KeyringServiceName(), + viper.GetString(flags.FlagKeyringBackend), + viper.GetString(flagClientHome), + inBuf, + ) + if err != nil { + return err + } + + info, err := kb.Key(args[0]) + if err != nil { + return fmt.Errorf("failed to get address from Keybase: %w", err) + } + + addr = info.GetAddress() + } + + coins, err := sdk.ParseCoins(args[1]) + if err != nil { + return fmt.Errorf("failed to parse coins: %w", err) + } + + vestingStart := viper.GetInt64(flagVestingStart) + vestingEnd := viper.GetInt64(flagVestingEnd) + vestingAmt, err := sdk.ParseCoins(viper.GetString(flagVestingAmt)) + if err != nil { + return fmt.Errorf("failed to parse vesting amount: %w", err) + } + + // create concrete account type based on input parameters + var genAccount authexported.GenesisAccount + + balances := bank.Balance{Address: addr, Coins: coins.Sort()} + baseAccount := auth.NewBaseAccount(addr, nil, 0, 0) + if !vestingAmt.IsZero() { + baseVestingAccount := authvesting.NewBaseVestingAccount(baseAccount, vestingAmt.Sort(), vestingEnd) + + if (balances.Coins.IsZero() && !baseVestingAccount.OriginalVesting.IsZero()) || + baseVestingAccount.OriginalVesting.IsAnyGT(balances.Coins) { + return errors.New("vesting amount cannot be greater than total amount") + } + + switch { + case vestingStart != 0 && vestingEnd != 0: + genAccount = authvesting.NewContinuousVestingAccountRaw(baseVestingAccount, vestingStart) + + case vestingEnd != 0: + genAccount = authvesting.NewDelayedVestingAccountRaw(baseVestingAccount) + + default: + return errors.New("invalid vesting parameters; must supply start and end time or end time") + } + } else { + genAccount = baseAccount + } + + if err := genAccount.Validate(); err != nil { + return fmt.Errorf("failed to validate new genesis account: %w", err) + } + + genFile := config.GenesisFile() + appState, genDoc, err := genutil.GenesisStateFromGenFile(depCdc, genFile) + if err != nil { + return fmt.Errorf("failed to unmarshal genesis state: %w", err) + } + + authGenState := auth.GetGenesisStateFromAppState(cdc, appState) + + if authGenState.Accounts.Contains(addr) { + return fmt.Errorf("cannot add account at existing address %s", addr) + } + + // Add the new account to the set of genesis accounts and sanitize the + // accounts afterwards. + authGenState.Accounts = append(authGenState.Accounts, genAccount) + authGenState.Accounts = auth.SanitizeGenesisAccounts(authGenState.Accounts) + + authGenStateBz, err := cdc.MarshalJSON(authGenState) + if err != nil { + return fmt.Errorf("failed to marshal auth genesis state: %w", err) + } + + appState[auth.ModuleName] = authGenStateBz + + bankGenState := bank.GetGenesisStateFromAppState(depCdc, appState) + bankGenState.Balances = append(bankGenState.Balances, balances) + bankGenState.Balances = bank.SanitizeGenesisBalances(bankGenState.Balances) + + bankGenStateBz, err := cdc.MarshalJSON(bankGenState) + if err != nil { + return fmt.Errorf("failed to marshal bank genesis state: %w", err) + } + + appState[bank.ModuleName] = bankGenStateBz + + appStateJSON, err := cdc.MarshalJSON(appState) + if err != nil { + return fmt.Errorf("failed to marshal application genesis state: %w", err) + } + + genDoc.AppState = appStateJSON + return genutil.ExportGenesisFile(genDoc, genFile) + }, + } + + cmd.Flags().String(cli.HomeFlag, defaultNodeHome, "node's home directory") + cmd.Flags().String(flags.FlagKeyringBackend, flags.DefaultKeyringBackend, "Select keyring's backend (os|file|test)") + cmd.Flags().String(flagClientHome, defaultClientHome, "client's home directory") + cmd.Flags().String(flagVestingAmt, "", "amount of coins for vesting accounts") + cmd.Flags().Uint64(flagVestingStart, 0, "schedule start time (unix epoch) for vesting accounts") + cmd.Flags().Uint64(flagVestingEnd, 0, "schedule end time (unix epoch) for vesting accounts") + + return cmd +} diff --git a/simapp/cmd/simd/main.go b/simapp/cmd/simd/main.go new file mode 100644 index 000000000000..ca82dfe7918f --- /dev/null +++ b/simapp/cmd/simd/main.go @@ -0,0 +1,117 @@ +package main + +import ( + "encoding/json" + "io" + + "github.com/spf13/cobra" + "github.com/spf13/viper" + abci "github.com/tendermint/tendermint/abci/types" + "github.com/tendermint/tendermint/libs/cli" + "github.com/tendermint/tendermint/libs/log" + tmtypes "github.com/tendermint/tendermint/types" + dbm "github.com/tendermint/tm-db" + + "github.com/cosmos/cosmos-sdk/baseapp" + "github.com/cosmos/cosmos-sdk/client/debug" + "github.com/cosmos/cosmos-sdk/client/flags" + codecstd "github.com/cosmos/cosmos-sdk/codec/std" + "github.com/cosmos/cosmos-sdk/server" + "github.com/cosmos/cosmos-sdk/simapp" + "github.com/cosmos/cosmos-sdk/store" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/bank" + genutilcli "github.com/cosmos/cosmos-sdk/x/genutil/client/cli" + "github.com/cosmos/cosmos-sdk/x/staking" +) + +const flagInvCheckPeriod = "inv-check-period" + +var invCheckPeriod uint + +func main() { + cdc := codecstd.MakeCodec(simapp.ModuleBasics) + appCodec := codecstd.NewAppCodec(cdc) + + config := sdk.GetConfig() + config.SetBech32PrefixForAccount(sdk.Bech32PrefixAccAddr, sdk.Bech32PrefixAccPub) + config.SetBech32PrefixForValidator(sdk.Bech32PrefixValAddr, sdk.Bech32PrefixValPub) + config.SetBech32PrefixForConsensusNode(sdk.Bech32PrefixConsAddr, sdk.Bech32PrefixConsPub) + config.Seal() + + ctx := server.NewDefaultContext() + cobra.EnableCommandSorting = false + rootCmd := &cobra.Command{ + Use: "simd", + Short: "Gaia Daemon (server)", + PersistentPreRunE: server.PersistentPreRunEFn(ctx), + } + + rootCmd.AddCommand(genutilcli.InitCmd(ctx, cdc, simapp.ModuleBasics, simapp.DefaultNodeHome)) + rootCmd.AddCommand(genutilcli.CollectGenTxsCmd(ctx, cdc, bank.GenesisBalancesIterator{}, simapp.DefaultNodeHome)) + rootCmd.AddCommand(genutilcli.MigrateGenesisCmd(ctx, cdc)) + rootCmd.AddCommand( + genutilcli.GenTxCmd( + ctx, cdc, simapp.ModuleBasics, staking.AppModuleBasic{}, + bank.GenesisBalancesIterator{}, simapp.DefaultNodeHome, simapp.DefaultCLIHome, + ), + ) + rootCmd.AddCommand(genutilcli.ValidateGenesisCmd(ctx, cdc, simapp.ModuleBasics)) + rootCmd.AddCommand(AddGenesisAccountCmd(ctx, cdc, appCodec, simapp.DefaultNodeHome, simapp.DefaultCLIHome)) + rootCmd.AddCommand(flags.NewCompletionCmd(rootCmd, true)) + //rootCmd.AddCommand(testnetCmd(ctx, cdc, simapp.ModuleBasics, bank.GenesisBalancesIterator{})) + //rootCmd.AddCommand(replayCmd()) + rootCmd.AddCommand(debug.Cmd(cdc)) + + server.AddCommands(ctx, cdc, rootCmd, newApp, exportAppStateAndTMValidators) + + // prepare and add flags + executor := cli.PrepareBaseCmd(rootCmd, "GA", simapp.DefaultNodeHome) + rootCmd.PersistentFlags().UintVar(&invCheckPeriod, flagInvCheckPeriod, + 0, "Assert registered invariants every N blocks") + err := executor.Execute() + if err != nil { + panic(err) + } +} + +func newApp(logger log.Logger, db dbm.DB, traceStore io.Writer) abci.Application { + var cache sdk.MultiStorePersistentCache + + if viper.GetBool(server.FlagInterBlockCache) { + cache = store.NewCommitKVStoreCacheManager() + } + + skipUpgradeHeights := make(map[int64]bool) + for _, h := range viper.GetIntSlice(server.FlagUnsafeSkipUpgrades) { + skipUpgradeHeights[int64(h)] = true + } + + return simapp.NewSimApp( + logger, db, traceStore, true, skipUpgradeHeights, + viper.GetString(flags.FlagHome), invCheckPeriod, + baseapp.SetPruning(store.NewPruningOptionsFromString(viper.GetString("pruning"))), + baseapp.SetMinGasPrices(viper.GetString(server.FlagMinGasPrices)), + baseapp.SetHaltHeight(viper.GetUint64(server.FlagHaltHeight)), + baseapp.SetHaltTime(viper.GetUint64(server.FlagHaltTime)), + baseapp.SetInterBlockCache(cache), + ) +} + +func exportAppStateAndTMValidators( + logger log.Logger, db dbm.DB, traceStore io.Writer, height int64, forZeroHeight bool, jailWhiteList []string, +) (json.RawMessage, []tmtypes.GenesisValidator, error) { + + if height != -1 { + gapp := simapp.NewSimApp(logger, db, traceStore, false, map[int64]bool{}, "", uint(1)) + err := gapp.LoadHeight(height) + if err != nil { + return nil, nil, err + } + + return gapp.ExportAppStateAndValidators(forZeroHeight, jailWhiteList) + } + + simApp := simapp.NewSimApp(logger, db, traceStore, true, map[int64]bool{}, "", uint(1)) + return simApp.ExportAppStateAndValidators(forZeroHeight, jailWhiteList) +} From df5336722a0c3dcb2bf4188dfbc208a2da3df82d Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Wed, 15 Apr 2020 20:00:50 +0530 Subject: [PATCH 02/61] Added cmd to simapp --- Makefile | 11 +- simapp/cmd/simcli/main.go | 184 ++++++++++++++++ simapp/cmd/simd/genaccounts.go | 167 ++++++++++++++ simapp/cmd/simd/main.go | 117 ++++++++++ simapp/cmd/simd/replay.go | 194 ++++++++++++++++ simapp/cmd/simd/testnet.go | 389 +++++++++++++++++++++++++++++++++ 6 files changed, 1061 insertions(+), 1 deletion(-) create mode 100644 simapp/cmd/simcli/main.go create mode 100644 simapp/cmd/simd/genaccounts.go create mode 100644 simapp/cmd/simd/main.go create mode 100644 simapp/cmd/simd/replay.go create mode 100644 simapp/cmd/simd/testnet.go diff --git a/Makefile b/Makefile index 25ef7ea375b1..d43747a363c8 100644 --- a/Makefile +++ b/Makefile @@ -24,6 +24,15 @@ build: go.sum @go build -mod=readonly ./... .PHONY: build +build-sim: go.sum +ifeq ($(OS),Windows_NT) + go build -mod=readonly $(BUILD_FLAGS) -o build/simd.exe ./simapp/cmd/simd + go build -mod=readonly $(BUILD_FLAGS) -o build/simcli.exe ./simapp/cmd/simcli +else + go build -mod=readonly $(BUILD_FLAGS) -o build/simd ./simapp/cmd/simd + go build -mod=readonly $(BUILD_FLAGS) -o build/simcli ./simapp/cmd/simcli +endif + mocks: $(MOCKS_DIR) mockgen -source=x/auth/types/account_retriever.go -package mocks -destination tests/mocks/account_retriever.go mockgen -package mocks -destination tests/mocks/tendermint_tm_db_DB.go github.com/tendermint/tm-db DB @@ -160,7 +169,7 @@ test-sim-after-import \ test-sim-custom-genesis-multi-seed \ test-sim-multi-seed-short \ test-sim-multi-seed-long \ -test-sim-benchmark-invariants +test-sim-benchmark-invariants \ SIM_NUM_BLOCKS ?= 500 SIM_BLOCK_SIZE ?= 200 diff --git a/simapp/cmd/simcli/main.go b/simapp/cmd/simcli/main.go new file mode 100644 index 000000000000..3d0c7c98c49d --- /dev/null +++ b/simapp/cmd/simcli/main.go @@ -0,0 +1,184 @@ +package main + +import ( + "fmt" + "github.com/cosmos/cosmos-sdk/simapp" + "os" + "path" + + "github.com/spf13/cobra" + "github.com/spf13/viper" + "github.com/tendermint/go-amino" + "github.com/tendermint/tendermint/libs/cli" + + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/client/keys" + "github.com/cosmos/cosmos-sdk/client/lcd" + "github.com/cosmos/cosmos-sdk/client/rpc" + codecstd "github.com/cosmos/cosmos-sdk/codec/std" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/version" + "github.com/cosmos/cosmos-sdk/x/auth" + authclient "github.com/cosmos/cosmos-sdk/x/auth/client" + authcmd "github.com/cosmos/cosmos-sdk/x/auth/client/cli" + authrest "github.com/cosmos/cosmos-sdk/x/auth/client/rest" + "github.com/cosmos/cosmos-sdk/x/bank" + bankcmd "github.com/cosmos/cosmos-sdk/x/bank/client/cli" +) + +var ( + cdc = codecstd.MakeCodec(simapp.ModuleBasics) + appCodec = codecstd.NewAppCodec(cdc) +) + +func init() { + authclient.Codec = appCodec +} + +func main() { + // Configure cobra to sort commands + cobra.EnableCommandSorting = false + + // Read in the configuration file for the sdk + config := sdk.GetConfig() + config.SetBech32PrefixForAccount(sdk.Bech32PrefixAccAddr, sdk.Bech32PrefixAccPub) + config.SetBech32PrefixForValidator(sdk.Bech32PrefixValAddr, sdk.Bech32PrefixValPub) + config.SetBech32PrefixForConsensusNode(sdk.Bech32PrefixConsAddr, sdk.Bech32PrefixConsPub) + config.Seal() + + // TODO: setup keybase, viper object, etc. to be passed into + // the below functions and eliminate global vars, like we do + // with the cdc + + rootCmd := &cobra.Command{ + Use: "simcli", + Short: "Command line interface for interacting with simd", + } + + // Add --chain-id to persistent flags and mark it required + rootCmd.PersistentFlags().String(flags.FlagChainID, "", "Chain ID of tendermint node") + rootCmd.PersistentPreRunE = func(_ *cobra.Command, _ []string) error { + return initConfig(rootCmd) + } + + // Construct Root Command + rootCmd.AddCommand( + rpc.StatusCommand(), + client.ConfigCmd(simapp.DefaultCLIHome), + queryCmd(cdc), + txCmd(cdc), + flags.LineBreak, + lcd.ServeCommand(cdc, registerRoutes), + flags.LineBreak, + keys.Commands(), + flags.LineBreak, + version.Cmd, + flags.NewCompletionCmd(rootCmd, true), + ) + + // Add flags and prefix all env exposed with GA + executor := cli.PrepareMainCmd(rootCmd, "GA", simapp.DefaultCLIHome) + + err := executor.Execute() + if err != nil { + fmt.Printf("Failed executing CLI command: %s, exiting...\n", err) + os.Exit(1) + } +} + +func queryCmd(cdc *amino.Codec) *cobra.Command { + queryCmd := &cobra.Command{ + Use: "query", + Aliases: []string{"q"}, + Short: "Querying subcommands", + DisableFlagParsing: true, + SuggestionsMinimumDistance: 2, + RunE: client.ValidateCmd, + } + + queryCmd.AddCommand( + authcmd.GetAccountCmd(cdc), + flags.LineBreak, + rpc.ValidatorCommand(cdc), + rpc.BlockCommand(), + authcmd.QueryTxsByEventsCmd(cdc), + authcmd.QueryTxCmd(cdc), + flags.LineBreak, + ) + + // add modules' query commands + simapp.ModuleBasics.AddQueryCommands(queryCmd, cdc) + + return queryCmd +} + +func txCmd(cdc *amino.Codec) *cobra.Command { + txCmd := &cobra.Command{ + Use: "tx", + Short: "Transactions subcommands", + DisableFlagParsing: true, + SuggestionsMinimumDistance: 2, + RunE: client.ValidateCmd, + } + + txCmd.AddCommand( + bankcmd.SendTxCmd(cdc), + flags.LineBreak, + authcmd.GetSignCommand(cdc), + authcmd.GetMultiSignCommand(cdc), + flags.LineBreak, + authcmd.GetBroadcastCommand(cdc), + authcmd.GetEncodeCommand(cdc), + authcmd.GetDecodeCommand(cdc), + flags.LineBreak, + ) + + // add modules' tx commands + simapp.ModuleBasics.AddTxCommands(txCmd, cdc) + + // remove auth and bank commands as they're mounted under the root tx command + var cmdsToRemove []*cobra.Command + + for _, cmd := range txCmd.Commands() { + if cmd.Use == auth.ModuleName || cmd.Use == bank.ModuleName { + cmdsToRemove = append(cmdsToRemove, cmd) + } + } + + txCmd.RemoveCommand(cmdsToRemove...) + + return txCmd +} + +// registerRoutes registers the routes from the different modules for the LCD. +// NOTE: details on the routes added for each module are in the module documentation +// NOTE: If making updates here you also need to update the test helper in client/lcd/test_helper.go +func registerRoutes(rs *lcd.RestServer) { + client.RegisterRoutes(rs.CliCtx, rs.Mux) + authrest.RegisterTxRoutes(rs.CliCtx, rs.Mux) + simapp.ModuleBasics.RegisterRESTRoutes(rs.CliCtx, rs.Mux) +} + +func initConfig(cmd *cobra.Command) error { + home, err := cmd.PersistentFlags().GetString(cli.HomeFlag) + if err != nil { + return err + } + + cfgFile := path.Join(home, "config", "config.toml") + if _, err := os.Stat(cfgFile); err == nil { + viper.SetConfigFile(cfgFile) + + if err := viper.ReadInConfig(); err != nil { + return err + } + } + if err := viper.BindPFlag(flags.FlagChainID, cmd.PersistentFlags().Lookup(flags.FlagChainID)); err != nil { + return err + } + if err := viper.BindPFlag(cli.EncodingFlag, cmd.PersistentFlags().Lookup(cli.EncodingFlag)); err != nil { + return err + } + return viper.BindPFlag(cli.OutputFlag, cmd.PersistentFlags().Lookup(cli.OutputFlag)) +} diff --git a/simapp/cmd/simd/genaccounts.go b/simapp/cmd/simd/genaccounts.go new file mode 100644 index 000000000000..f413c8767502 --- /dev/null +++ b/simapp/cmd/simd/genaccounts.go @@ -0,0 +1,167 @@ +package main + +import ( + "bufio" + "errors" + "fmt" + "github.com/tendermint/go-amino" + + "github.com/cosmos/cosmos-sdk/client/flags" + codecstd "github.com/cosmos/cosmos-sdk/codec/std" + "github.com/cosmos/cosmos-sdk/crypto/keyring" + "github.com/cosmos/cosmos-sdk/server" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/auth" + authexported "github.com/cosmos/cosmos-sdk/x/auth/exported" + authvesting "github.com/cosmos/cosmos-sdk/x/auth/vesting" + "github.com/cosmos/cosmos-sdk/x/bank" + "github.com/cosmos/cosmos-sdk/x/genutil" + "github.com/spf13/cobra" + "github.com/spf13/viper" + "github.com/tendermint/tendermint/libs/cli" +) + +const ( + flagClientHome = "home-client" + flagVestingStart = "vesting-start-time" + flagVestingEnd = "vesting-end-time" + flagVestingAmt = "vesting-amount" +) + +// AddGenesisAccountCmd returns add-genesis-account cobra Command. +func AddGenesisAccountCmd( + ctx *server.Context, depCdc *amino.Codec, cdc *codecstd.Codec, defaultNodeHome, defaultClientHome string, +) *cobra.Command { + + cmd := &cobra.Command{ + Use: "add-genesis-account [address_or_key_name] [coin][,[coin]]", + Short: "Add a genesis account to genesis.json", + Long: `Add a genesis account to genesis.json. The provided account must specify +the account address or key name and a list of initial coins. If a key name is given, +the address will be looked up in the local Keybase. The list of initial tokens must +contain valid denominations. Accounts may optionally be supplied with vesting parameters. +`, + Args: cobra.ExactArgs(2), + RunE: func(cmd *cobra.Command, args []string) error { + config := ctx.Config + config.SetRoot(viper.GetString(cli.HomeFlag)) + + addr, err := sdk.AccAddressFromBech32(args[0]) + inBuf := bufio.NewReader(cmd.InOrStdin()) + if err != nil { + // attempt to lookup address from Keybase if no address was provided + kb, err := keyring.New( + sdk.KeyringServiceName(), + viper.GetString(flags.FlagKeyringBackend), + viper.GetString(flagClientHome), + inBuf, + ) + if err != nil { + return err + } + + info, err := kb.Key(args[0]) + if err != nil { + return fmt.Errorf("failed to get address from Keybase: %w", err) + } + + addr = info.GetAddress() + } + + coins, err := sdk.ParseCoins(args[1]) + if err != nil { + return fmt.Errorf("failed to parse coins: %w", err) + } + + vestingStart := viper.GetInt64(flagVestingStart) + vestingEnd := viper.GetInt64(flagVestingEnd) + vestingAmt, err := sdk.ParseCoins(viper.GetString(flagVestingAmt)) + if err != nil { + return fmt.Errorf("failed to parse vesting amount: %w", err) + } + + // create concrete account type based on input parameters + var genAccount authexported.GenesisAccount + + balances := bank.Balance{Address: addr, Coins: coins.Sort()} + baseAccount := auth.NewBaseAccount(addr, nil, 0, 0) + if !vestingAmt.IsZero() { + baseVestingAccount := authvesting.NewBaseVestingAccount(baseAccount, vestingAmt.Sort(), vestingEnd) + + if (balances.Coins.IsZero() && !baseVestingAccount.OriginalVesting.IsZero()) || + baseVestingAccount.OriginalVesting.IsAnyGT(balances.Coins) { + return errors.New("vesting amount cannot be greater than total amount") + } + + switch { + case vestingStart != 0 && vestingEnd != 0: + genAccount = authvesting.NewContinuousVestingAccountRaw(baseVestingAccount, vestingStart) + + case vestingEnd != 0: + genAccount = authvesting.NewDelayedVestingAccountRaw(baseVestingAccount) + + default: + return errors.New("invalid vesting parameters; must supply start and end time or end time") + } + } else { + genAccount = baseAccount + } + + if err := genAccount.Validate(); err != nil { + return fmt.Errorf("failed to validate new genesis account: %w", err) + } + + genFile := config.GenesisFile() + appState, genDoc, err := genutil.GenesisStateFromGenFile(depCdc, genFile) + if err != nil { + return fmt.Errorf("failed to unmarshal genesis state: %w", err) + } + + authGenState := auth.GetGenesisStateFromAppState(cdc, appState) + + if authGenState.Accounts.Contains(addr) { + return fmt.Errorf("cannot add account at existing address %s", addr) + } + + // Add the new account to the set of genesis accounts and sanitize the + // accounts afterwards. + authGenState.Accounts = append(authGenState.Accounts, genAccount) + authGenState.Accounts = auth.SanitizeGenesisAccounts(authGenState.Accounts) + + authGenStateBz, err := cdc.MarshalJSON(authGenState) + if err != nil { + return fmt.Errorf("failed to marshal auth genesis state: %w", err) + } + + appState[auth.ModuleName] = authGenStateBz + + bankGenState := bank.GetGenesisStateFromAppState(depCdc, appState) + bankGenState.Balances = append(bankGenState.Balances, balances) + bankGenState.Balances = bank.SanitizeGenesisBalances(bankGenState.Balances) + + bankGenStateBz, err := cdc.MarshalJSON(bankGenState) + if err != nil { + return fmt.Errorf("failed to marshal bank genesis state: %w", err) + } + + appState[bank.ModuleName] = bankGenStateBz + + appStateJSON, err := cdc.MarshalJSON(appState) + if err != nil { + return fmt.Errorf("failed to marshal application genesis state: %w", err) + } + + genDoc.AppState = appStateJSON + return genutil.ExportGenesisFile(genDoc, genFile) + }, + } + + cmd.Flags().String(cli.HomeFlag, defaultNodeHome, "node's home directory") + cmd.Flags().String(flags.FlagKeyringBackend, flags.DefaultKeyringBackend, "Select keyring's backend (os|file|test)") + cmd.Flags().String(flagClientHome, defaultClientHome, "client's home directory") + cmd.Flags().String(flagVestingAmt, "", "amount of coins for vesting accounts") + cmd.Flags().Uint64(flagVestingStart, 0, "schedule start time (unix epoch) for vesting accounts") + cmd.Flags().Uint64(flagVestingEnd, 0, "schedule end time (unix epoch) for vesting accounts") + + return cmd +} diff --git a/simapp/cmd/simd/main.go b/simapp/cmd/simd/main.go new file mode 100644 index 000000000000..fdb6789c8b23 --- /dev/null +++ b/simapp/cmd/simd/main.go @@ -0,0 +1,117 @@ +package main + +import ( + "encoding/json" + "io" + + "github.com/spf13/cobra" + "github.com/spf13/viper" + abci "github.com/tendermint/tendermint/abci/types" + "github.com/tendermint/tendermint/libs/cli" + "github.com/tendermint/tendermint/libs/log" + tmtypes "github.com/tendermint/tendermint/types" + dbm "github.com/tendermint/tm-db" + + "github.com/cosmos/cosmos-sdk/baseapp" + "github.com/cosmos/cosmos-sdk/client/debug" + "github.com/cosmos/cosmos-sdk/client/flags" + codecstd "github.com/cosmos/cosmos-sdk/codec/std" + "github.com/cosmos/cosmos-sdk/server" + "github.com/cosmos/cosmos-sdk/simapp" + "github.com/cosmos/cosmos-sdk/store" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/bank" + genutilcli "github.com/cosmos/cosmos-sdk/x/genutil/client/cli" + "github.com/cosmos/cosmos-sdk/x/staking" +) + +const flagInvCheckPeriod = "inv-check-period" + +var invCheckPeriod uint + +func main() { + cdc := codecstd.MakeCodec(simapp.ModuleBasics) + appCodec := codecstd.NewAppCodec(cdc) + + config := sdk.GetConfig() + config.SetBech32PrefixForAccount(sdk.Bech32PrefixAccAddr, sdk.Bech32PrefixAccPub) + config.SetBech32PrefixForValidator(sdk.Bech32PrefixValAddr, sdk.Bech32PrefixValPub) + config.SetBech32PrefixForConsensusNode(sdk.Bech32PrefixConsAddr, sdk.Bech32PrefixConsPub) + config.Seal() + + ctx := server.NewDefaultContext() + cobra.EnableCommandSorting = false + rootCmd := &cobra.Command{ + Use: "simd", + Short: "Simulation Daemon (server)", + PersistentPreRunE: server.PersistentPreRunEFn(ctx), + } + + rootCmd.AddCommand(genutilcli.InitCmd(ctx, cdc, simapp.ModuleBasics, simapp.DefaultNodeHome)) + rootCmd.AddCommand(genutilcli.CollectGenTxsCmd(ctx, cdc, bank.GenesisBalancesIterator{}, simapp.DefaultNodeHome)) + rootCmd.AddCommand(genutilcli.MigrateGenesisCmd(ctx, cdc)) + rootCmd.AddCommand( + genutilcli.GenTxCmd( + ctx, cdc, simapp.ModuleBasics, staking.AppModuleBasic{}, + bank.GenesisBalancesIterator{}, simapp.DefaultNodeHome, simapp.DefaultCLIHome, + ), + ) + rootCmd.AddCommand(genutilcli.ValidateGenesisCmd(ctx, cdc, simapp.ModuleBasics)) + rootCmd.AddCommand(AddGenesisAccountCmd(ctx, cdc, appCodec, simapp.DefaultNodeHome, simapp.DefaultCLIHome)) + rootCmd.AddCommand(flags.NewCompletionCmd(rootCmd, true)) + rootCmd.AddCommand(testnetCmd(ctx, cdc, simapp.ModuleBasics, bank.GenesisBalancesIterator{})) + rootCmd.AddCommand(replayCmd()) + rootCmd.AddCommand(debug.Cmd(cdc)) + + server.AddCommands(ctx, cdc, rootCmd, newApp, exportAppStateAndTMValidators) + + // prepare and add flags + executor := cli.PrepareBaseCmd(rootCmd, "GA", simapp.DefaultNodeHome) + rootCmd.PersistentFlags().UintVar(&invCheckPeriod, flagInvCheckPeriod, + 0, "Assert registered invariants every N blocks") + err := executor.Execute() + if err != nil { + panic(err) + } +} + +func newApp(logger log.Logger, db dbm.DB, traceStore io.Writer) abci.Application { + var cache sdk.MultiStorePersistentCache + + if viper.GetBool(server.FlagInterBlockCache) { + cache = store.NewCommitKVStoreCacheManager() + } + + skipUpgradeHeights := make(map[int64]bool) + for _, h := range viper.GetIntSlice(server.FlagUnsafeSkipUpgrades) { + skipUpgradeHeights[int64(h)] = true + } + + return simapp.NewSimApp( + logger, db, traceStore, true, skipUpgradeHeights, + viper.GetString(flags.FlagHome), invCheckPeriod, + baseapp.SetPruning(store.NewPruningOptionsFromString(viper.GetString("pruning"))), + baseapp.SetMinGasPrices(viper.GetString(server.FlagMinGasPrices)), + baseapp.SetHaltHeight(viper.GetUint64(server.FlagHaltHeight)), + baseapp.SetHaltTime(viper.GetUint64(server.FlagHaltTime)), + baseapp.SetInterBlockCache(cache), + ) +} + +func exportAppStateAndTMValidators( + logger log.Logger, db dbm.DB, traceStore io.Writer, height int64, forZeroHeight bool, jailWhiteList []string, +) (json.RawMessage, []tmtypes.GenesisValidator, error) { + + if height != -1 { + gapp := simapp.NewSimApp(logger, db, traceStore, false, map[int64]bool{}, "", uint(1)) + err := gapp.LoadHeight(height) + if err != nil { + return nil, nil, err + } + + return gapp.ExportAppStateAndValidators(forZeroHeight, jailWhiteList) + } + + simApp := simapp.NewSimApp(logger, db, traceStore, true, map[int64]bool{}, "", uint(1)) + return simApp.ExportAppStateAndValidators(forZeroHeight, jailWhiteList) +} diff --git a/simapp/cmd/simd/replay.go b/simapp/cmd/simd/replay.go new file mode 100644 index 000000000000..aea36d23844f --- /dev/null +++ b/simapp/cmd/simd/replay.go @@ -0,0 +1,194 @@ +package main + +import ( + "fmt" + "github.com/cosmos/cosmos-sdk/simapp" + "io" + "os" + "path/filepath" + "time" + + cpm "github.com/otiai10/copy" + "github.com/spf13/cobra" + + abci "github.com/tendermint/tendermint/abci/types" + tmos "github.com/tendermint/tendermint/libs/os" + "github.com/tendermint/tendermint/proxy" + tmsm "github.com/tendermint/tendermint/state" + tmstore "github.com/tendermint/tendermint/store" + tm "github.com/tendermint/tendermint/types" + + "github.com/cosmos/cosmos-sdk/baseapp" + "github.com/cosmos/cosmos-sdk/server" + "github.com/cosmos/cosmos-sdk/store" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +func replayCmd() *cobra.Command { + return &cobra.Command{ + Use: "replay ", + Short: "Replay simulation transactions", + RunE: func(_ *cobra.Command, args []string) error { + return replayTxs(args[0]) + }, + Args: cobra.ExactArgs(1), + } +} + +func replayTxs(rootDir string) error { + + if false { + // Copy the rootDir to a new directory, to preserve the old one. + fmt.Fprintln(os.Stderr, "Copying rootdir over") + oldRootDir := rootDir + + rootDir = oldRootDir + "_replay" + if tmos.FileExists(rootDir) { + tmos.Exit(fmt.Sprintf("temporary copy dir %v already exists", rootDir)) + } + + if err := cpm.Copy(oldRootDir, rootDir); err != nil { + return err + } + } + + configDir := filepath.Join(rootDir, "config") + dataDir := filepath.Join(rootDir, "data") + ctx := server.NewDefaultContext() + + // App DB + // appDB := dbm.NewMemDB() + fmt.Fprintln(os.Stderr, "Opening app database") + appDB, err := sdk.NewLevelDB("application", dataDir) + if err != nil { + return err + } + + // TM DB + // tmDB := dbm.NewMemDB() + fmt.Fprintln(os.Stderr, "Opening tendermint state database") + tmDB, err := sdk.NewLevelDB("state", dataDir) + if err != nil { + return err + } + + // Blockchain DB + fmt.Fprintln(os.Stderr, "Opening blockstore database") + bcDB, err := sdk.NewLevelDB("blockstore", dataDir) + if err != nil { + return err + } + + // TraceStore + var traceStoreWriter io.Writer + var traceStoreDir = filepath.Join(dataDir, "trace.log") + traceStoreWriter, err = os.OpenFile( + traceStoreDir, + os.O_WRONLY|os.O_APPEND|os.O_CREATE, + 0666, + ) + if err != nil { + return err + } + + // Application + fmt.Fprintln(os.Stderr, "Creating application") + gapp := simapp.NewSimApp( + ctx.Logger, appDB, traceStoreWriter, true, map[int64]bool{}, "", uint(1), + baseapp.SetPruning(store.PruneEverything), // nothing + ) + + // Genesis + var genDocPath = filepath.Join(configDir, "genesis.json") + genDoc, err := tm.GenesisDocFromFile(genDocPath) + if err != nil { + return err + } + genState, err := tmsm.MakeGenesisState(genDoc) + if err != nil { + return err + } + // tmsm.SaveState(tmDB, genState) + + cc := proxy.NewLocalClientCreator(gapp) + proxyApp := proxy.NewAppConns(cc) + err = proxyApp.Start() + if err != nil { + return err + } + defer func() { + err = proxyApp.Stop() + if err != nil { + return + } + }() + + state := tmsm.LoadState(tmDB) + if state.LastBlockHeight == 0 { + // Send InitChain msg + fmt.Fprintln(os.Stderr, "Sending InitChain msg") + validators := tm.TM2PB.ValidatorUpdates(genState.Validators) + csParams := tm.TM2PB.ConsensusParams(genDoc.ConsensusParams) + req := abci.RequestInitChain{ + Time: genDoc.GenesisTime, + ChainId: genDoc.ChainID, + ConsensusParams: csParams, + Validators: validators, + AppStateBytes: genDoc.AppState, + } + res, err := proxyApp.Consensus().InitChainSync(req) + if err != nil { + return err + } + newValidatorz, err := tm.PB2TM.ValidatorUpdates(res.Validators) + if err != nil { + return err + } + newValidators := tm.NewValidatorSet(newValidatorz) + + // Take the genesis state. + state = genState + state.Validators = newValidators + state.NextValidators = newValidators + } + + // Create executor + fmt.Fprintln(os.Stderr, "Creating block executor") + blockExec := tmsm.NewBlockExecutor(tmDB, ctx.Logger, proxyApp.Consensus(), nil, tmsm.MockEvidencePool{}) + + // Create block store + fmt.Fprintln(os.Stderr, "Creating block store") + blockStore := tmstore.NewBlockStore(bcDB) + + tz := []time.Duration{0, 0, 0} + for i := int(state.LastBlockHeight) + 1; ; i++ { + fmt.Fprintln(os.Stderr, "Running block ", i) + t1 := time.Now() + + // Apply block + fmt.Printf("loading and applying block %d\n", i) + blockmeta := blockStore.LoadBlockMeta(int64(i)) + if blockmeta == nil { + fmt.Printf("Couldn't find block meta %d... done?\n", i) + return nil + } + block := blockStore.LoadBlock(int64(i)) + if block == nil { + return fmt.Errorf("couldn't find block %d", i) + } + + t2 := time.Now() + + state, err = blockExec.ApplyBlock(state, blockmeta.BlockID, block) + if err != nil { + return err + } + + t3 := time.Now() + tz[0] += t2.Sub(t1) + tz[1] += t3.Sub(t2) + + fmt.Fprintf(os.Stderr, "new app hash: %X\n", state.AppHash) + fmt.Fprintln(os.Stderr, tz) + } +} diff --git a/simapp/cmd/simd/testnet.go b/simapp/cmd/simd/testnet.go new file mode 100644 index 000000000000..09ab77dee1c1 --- /dev/null +++ b/simapp/cmd/simd/testnet.go @@ -0,0 +1,389 @@ +package main + +// DONTCOVER + +import ( + "bufio" + "encoding/json" + "fmt" + "net" + "os" + "path/filepath" + + "github.com/cosmos/cosmos-sdk/client/flags" + clientkeys "github.com/cosmos/cosmos-sdk/client/keys" + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/crypto/keyring" + "github.com/cosmos/cosmos-sdk/server" + srvconfig "github.com/cosmos/cosmos-sdk/server/config" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/module" + "github.com/cosmos/cosmos-sdk/x/auth" + authexported "github.com/cosmos/cosmos-sdk/x/auth/exported" + "github.com/cosmos/cosmos-sdk/x/bank" + "github.com/cosmos/cosmos-sdk/x/genutil" + genutiltypes "github.com/cosmos/cosmos-sdk/x/genutil/types" + "github.com/cosmos/cosmos-sdk/x/staking" + + tmconfig "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/crypto" + tmos "github.com/tendermint/tendermint/libs/os" + tmrand "github.com/tendermint/tendermint/libs/rand" + "github.com/tendermint/tendermint/types" + tmtime "github.com/tendermint/tendermint/types/time" + + "github.com/spf13/cobra" + "github.com/spf13/viper" +) + +var ( + flagNodeDirPrefix = "node-dir-prefix" + flagNumValidators = "v" + flagOutputDir = "output-dir" + flagNodeDaemonHome = "node-daemon-home" + flagNodeCLIHome = "node-cli-home" + flagStartingIPAddress = "starting-ip-address" +) + +// get cmd to initialize all files for tendermint testnet and application +func testnetCmd(ctx *server.Context, cdc *codec.Codec, + mbm module.BasicManager, genBalIterator genutiltypes.GenesisBalancesIterator, +) *cobra.Command { + + cmd := &cobra.Command{ + Use: "testnet", + Short: "Initialize files for a simd testnet", + Long: `testnet will create "v" number of directories and populate each with +necessary files (private validator, genesis, config, etc.). + +Note, strict routability for addresses is turned off in the config file. + +Example: + simd testnet --v 4 --output-dir ./output --starting-ip-address 192.168.10.2 + `, + RunE: func(cmd *cobra.Command, _ []string) error { + config := ctx.Config + + outputDir := viper.GetString(flagOutputDir) + chainID := viper.GetString(flags.FlagChainID) + minGasPrices := viper.GetString(server.FlagMinGasPrices) + nodeDirPrefix := viper.GetString(flagNodeDirPrefix) + nodeDaemonHome := viper.GetString(flagNodeDaemonHome) + nodeCLIHome := viper.GetString(flagNodeCLIHome) + startingIPAddress := viper.GetString(flagStartingIPAddress) + numValidators := viper.GetInt(flagNumValidators) + + return InitTestnet(cmd, config, cdc, mbm, genBalIterator, outputDir, chainID, + minGasPrices, nodeDirPrefix, nodeDaemonHome, nodeCLIHome, startingIPAddress, numValidators) + }, + } + + cmd.Flags().Int(flagNumValidators, 4, + "Number of validators to initialize the testnet with") + cmd.Flags().StringP(flagOutputDir, "o", "./mytestnet", + "Directory to store initialization data for the testnet") + cmd.Flags().String(flagNodeDirPrefix, "node", + "Prefix the directory name for each node with (node results in node0, node1, ...)") + cmd.Flags().String(flagNodeDaemonHome, "simd", + "Home directory of the node's daemon configuration") + cmd.Flags().String(flagNodeCLIHome, "simcli", + "Home directory of the node's cli configuration") + cmd.Flags().String(flagStartingIPAddress, "192.168.0.1", + "Starting IP address (192.168.0.1 results in persistent peers list ID0@192.168.0.1:46656, ID1@192.168.0.2:46656, ...)") + cmd.Flags().String( + flags.FlagChainID, "", "genesis file chain-id, if left blank will be randomly created") + cmd.Flags().String( + server.FlagMinGasPrices, fmt.Sprintf("0.000006%s", sdk.DefaultBondDenom), + "Minimum gas prices to accept for transactions; All fees in a tx must meet this minimum (e.g. 0.01photino,0.001stake)") + cmd.Flags().String(flags.FlagKeyringBackend, flags.DefaultKeyringBackend, "Select keyring's backend (os|file|test)") + + return cmd +} + +const nodeDirPerm = 0755 + +// Initialize the testnet +func InitTestnet( + cmd *cobra.Command, config *tmconfig.Config, cdc *codec.Codec, + mbm module.BasicManager, genBalIterator genutiltypes.GenesisBalancesIterator, + outputDir, chainID, minGasPrices, nodeDirPrefix, nodeDaemonHome, + nodeCLIHome, startingIPAddress string, numValidators int, +) error { + + if chainID == "" { + chainID = "chain-" + tmrand.NewRand().Str(6) + } + + monikers := make([]string, numValidators) + nodeIDs := make([]string, numValidators) + valPubKeys := make([]crypto.PubKey, numValidators) + + simappConfig := srvconfig.DefaultConfig() + simappConfig.MinGasPrices = minGasPrices + + //nolint:prealloc + var ( + genAccounts []authexported.GenesisAccount + genBalances []bank.Balance + genFiles []string + ) + + inBuf := bufio.NewReader(cmd.InOrStdin()) + // generate private keys, node IDs, and initial transactions + for i := 0; i < numValidators; i++ { + nodeDirName := fmt.Sprintf("%s%d", nodeDirPrefix, i) + nodeDir := filepath.Join(outputDir, nodeDirName, nodeDaemonHome) + clientDir := filepath.Join(outputDir, nodeDirName, nodeCLIHome) + gentxsDir := filepath.Join(outputDir, "gentxs") + + config.SetRoot(nodeDir) + config.RPC.ListenAddress = "tcp://0.0.0.0:26657" + + if err := os.MkdirAll(filepath.Join(nodeDir, "config"), nodeDirPerm); err != nil { + _ = os.RemoveAll(outputDir) + return err + } + + if err := os.MkdirAll(clientDir, nodeDirPerm); err != nil { + _ = os.RemoveAll(outputDir) + return err + } + + monikers = append(monikers, nodeDirName) + config.Moniker = nodeDirName + + ip, err := getIP(i, startingIPAddress) + if err != nil { + _ = os.RemoveAll(outputDir) + return err + } + + nodeIDs[i], valPubKeys[i], err = genutil.InitializeNodeValidatorFiles(config) + if err != nil { + _ = os.RemoveAll(outputDir) + return err + } + + memo := fmt.Sprintf("%s@%s:26656", nodeIDs[i], ip) + genFiles = append(genFiles, config.GenesisFile()) + + kb, err := keyring.New( + sdk.KeyringServiceName(), + viper.GetString(flags.FlagKeyringBackend), + clientDir, + inBuf, + ) + if err != nil { + return err + } + + keyPass := clientkeys.DefaultKeyPass + addr, secret, err := server.GenerateSaveCoinKey(kb, nodeDirName, keyPass, true) + if err != nil { + _ = os.RemoveAll(outputDir) + return err + } + + info := map[string]string{"secret": secret} + + cliPrint, err := json.Marshal(info) + if err != nil { + return err + } + + // save private key seed words + if err := writeFile(fmt.Sprintf("%v.json", "key_seed"), clientDir, cliPrint); err != nil { + return err + } + + accTokens := sdk.TokensFromConsensusPower(1000) + accStakingTokens := sdk.TokensFromConsensusPower(500) + coins := sdk.Coins{ + sdk.NewCoin(fmt.Sprintf("%stoken", nodeDirName), accTokens), + sdk.NewCoin(sdk.DefaultBondDenom, accStakingTokens), + } + + genBalances = append(genBalances, bank.Balance{Address: addr, Coins: coins.Sort()}) + genAccounts = append(genAccounts, auth.NewBaseAccount(addr, nil, 0, 0)) + + valTokens := sdk.TokensFromConsensusPower(100) + msg := staking.NewMsgCreateValidator( + sdk.ValAddress(addr), + valPubKeys[i], + sdk.NewCoin(sdk.DefaultBondDenom, valTokens), + staking.NewDescription(nodeDirName, "", "", "", ""), + staking.NewCommissionRates(sdk.OneDec(), sdk.OneDec(), sdk.OneDec()), + sdk.OneInt(), + ) + + tx := auth.NewStdTx([]sdk.Msg{msg}, auth.StdFee{}, []auth.StdSignature{}, memo) + txBldr := auth.NewTxBuilderFromCLI(inBuf).WithChainID(chainID).WithMemo(memo).WithKeybase(kb) + + signedTx, err := txBldr.SignStdTx(nodeDirName, clientkeys.DefaultKeyPass, tx, false) + if err != nil { + _ = os.RemoveAll(outputDir) + return err + } + + txBytes, err := cdc.MarshalJSON(signedTx) + if err != nil { + _ = os.RemoveAll(outputDir) + return err + } + + // gather gentxs folder + if err := writeFile(fmt.Sprintf("%v.json", nodeDirName), gentxsDir, txBytes); err != nil { + _ = os.RemoveAll(outputDir) + return err + } + + simConfigFilePath := filepath.Join(nodeDir, "config/simd.toml") + srvconfig.WriteConfigFile(simConfigFilePath, simappConfig) + } + + if err := initGenFiles(cdc, mbm, chainID, genAccounts, genBalances, genFiles, numValidators); err != nil { + return err + } + + err := collectGenFiles( + cdc, config, chainID, monikers, nodeIDs, valPubKeys, numValidators, + outputDir, nodeDirPrefix, nodeDaemonHome, genBalIterator, + ) + if err != nil { + return err + } + + cmd.PrintErrf("Successfully initialized %d node directories\n", numValidators) + return nil +} + +func initGenFiles( + cdc *codec.Codec, mbm module.BasicManager, chainID string, + genAccounts []authexported.GenesisAccount, genBalances []bank.Balance, + genFiles []string, numValidators int, +) error { + + appGenState := mbm.DefaultGenesis(cdc) + + // set the accounts in the genesis state + var authGenState auth.GenesisState + cdc.MustUnmarshalJSON(appGenState[auth.ModuleName], &authGenState) + + authGenState.Accounts = genAccounts + appGenState[auth.ModuleName] = cdc.MustMarshalJSON(authGenState) + + // set the balances in the genesis state + var bankGenState bank.GenesisState + cdc.MustUnmarshalJSON(appGenState[bank.ModuleName], &bankGenState) + + bankGenState.Balances = genBalances + appGenState[bank.ModuleName] = cdc.MustMarshalJSON(bankGenState) + + appGenStateJSON, err := codec.MarshalJSONIndent(cdc, appGenState) + if err != nil { + return err + } + + genDoc := types.GenesisDoc{ + ChainID: chainID, + AppState: appGenStateJSON, + Validators: nil, + } + + // generate empty genesis files for each validator and save + for i := 0; i < numValidators; i++ { + if err := genDoc.SaveAs(genFiles[i]); err != nil { + return err + } + } + return nil +} + +func collectGenFiles( + cdc *codec.Codec, config *tmconfig.Config, chainID string, + monikers, nodeIDs []string, valPubKeys []crypto.PubKey, + numValidators int, outputDir, nodeDirPrefix, nodeDaemonHome string, + genBalIterator genutiltypes.GenesisBalancesIterator, +) error { + + var appState json.RawMessage + genTime := tmtime.Now() + + for i := 0; i < numValidators; i++ { + nodeDirName := fmt.Sprintf("%s%d", nodeDirPrefix, i) + nodeDir := filepath.Join(outputDir, nodeDirName, nodeDaemonHome) + gentxsDir := filepath.Join(outputDir, "gentxs") + moniker := monikers[i] + config.Moniker = nodeDirName + + config.SetRoot(nodeDir) + + nodeID, valPubKey := nodeIDs[i], valPubKeys[i] + initCfg := genutil.NewInitConfig(chainID, gentxsDir, moniker, nodeID, valPubKey) + + genDoc, err := types.GenesisDocFromFile(config.GenesisFile()) + if err != nil { + return err + } + + nodeAppState, err := genutil.GenAppStateFromConfig(cdc, config, initCfg, *genDoc, genBalIterator) + if err != nil { + return err + } + + if appState == nil { + // set the canonical application state (they should not differ) + appState = nodeAppState + } + + genFile := config.GenesisFile() + + // overwrite each validator's genesis file to have a canonical genesis time + if err := genutil.ExportGenesisFileWithTime(genFile, chainID, nil, appState, genTime); err != nil { + return err + } + } + + return nil +} + +func getIP(i int, startingIPAddr string) (ip string, err error) { + if len(startingIPAddr) == 0 { + ip, err = server.ExternalIP() + if err != nil { + return "", err + } + return ip, nil + } + return calculateIP(startingIPAddr, i) +} + +func calculateIP(ip string, i int) (string, error) { + ipv4 := net.ParseIP(ip).To4() + if ipv4 == nil { + return "", fmt.Errorf("%v: non ipv4 address", ip) + } + + for j := 0; j < i; j++ { + ipv4[3]++ + } + + return ipv4.String(), nil +} + +func writeFile(name string, dir string, contents []byte) error { + writePath := filepath.Join(dir) + file := filepath.Join(writePath, name) + + err := tmos.EnsureDir(writePath, 0700) + if err != nil { + return err + } + + err = tmos.WriteFile(file, contents, 0600) + if err != nil { + return err + } + + return nil +} From c2e22b927581a329e4befbb8687ccbadb00537cc Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Wed, 15 Apr 2020 20:42:16 +0530 Subject: [PATCH 03/61] Fixed ci-lint issues --- simapp/cmd/simcli/main.go | 3 +-- simapp/cmd/simd/replay.go | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/simapp/cmd/simcli/main.go b/simapp/cmd/simcli/main.go index 3d0c7c98c49d..c9c1a573c1f1 100644 --- a/simapp/cmd/simcli/main.go +++ b/simapp/cmd/simcli/main.go @@ -2,13 +2,11 @@ package main import ( "fmt" - "github.com/cosmos/cosmos-sdk/simapp" "os" "path" "github.com/spf13/cobra" "github.com/spf13/viper" - "github.com/tendermint/go-amino" "github.com/tendermint/tendermint/libs/cli" "github.com/cosmos/cosmos-sdk/client" @@ -17,6 +15,7 @@ import ( "github.com/cosmos/cosmos-sdk/client/lcd" "github.com/cosmos/cosmos-sdk/client/rpc" codecstd "github.com/cosmos/cosmos-sdk/codec/std" + "github.com/cosmos/cosmos-sdk/simapp" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/version" "github.com/cosmos/cosmos-sdk/x/auth" diff --git a/simapp/cmd/simd/replay.go b/simapp/cmd/simd/replay.go index aea36d23844f..39a2184f9e57 100644 --- a/simapp/cmd/simd/replay.go +++ b/simapp/cmd/simd/replay.go @@ -2,7 +2,6 @@ package main import ( "fmt" - "github.com/cosmos/cosmos-sdk/simapp" "io" "os" "path/filepath" @@ -20,6 +19,7 @@ import ( "github.com/cosmos/cosmos-sdk/baseapp" "github.com/cosmos/cosmos-sdk/server" + "github.com/cosmos/cosmos-sdk/simapp" "github.com/cosmos/cosmos-sdk/store" sdk "github.com/cosmos/cosmos-sdk/types" ) From 13b55315f9c5b3b71d4e643bc09e217fa5f95c49 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Wed, 15 Apr 2020 20:42:35 +0530 Subject: [PATCH 04/61] Fixed ci-lint issues --- simapp/cmd/simd/genaccounts.go | 1 - 1 file changed, 1 deletion(-) diff --git a/simapp/cmd/simd/genaccounts.go b/simapp/cmd/simd/genaccounts.go index f413c8767502..92ca44ef499b 100644 --- a/simapp/cmd/simd/genaccounts.go +++ b/simapp/cmd/simd/genaccounts.go @@ -4,7 +4,6 @@ import ( "bufio" "errors" "fmt" - "github.com/tendermint/go-amino" "github.com/cosmos/cosmos-sdk/client/flags" codecstd "github.com/cosmos/cosmos-sdk/codec/std" From 858e744b1f2a065d00c565a87af0d8038c37f171 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Fri, 17 Apr 2020 00:08:15 +0530 Subject: [PATCH 05/61] Addressed changes in Makefile --- Makefile | 7 +++++-- simapp/cmd/simd/genaccounts.go | 9 ++++++--- 2 files changed, 11 insertions(+), 5 deletions(-) diff --git a/Makefile b/Makefile index d43747a363c8..9a1b851bb840 100644 --- a/Makefile +++ b/Makefile @@ -22,7 +22,6 @@ all: tools build lint test build: go.sum @go build -mod=readonly ./... -.PHONY: build build-sim: go.sum ifeq ($(OS),Windows_NT) @@ -33,6 +32,10 @@ else go build -mod=readonly $(BUILD_FLAGS) -o build/simcli ./simapp/cmd/simcli endif +.PHONY: \ + build \ + build-sim + mocks: $(MOCKS_DIR) mockgen -source=x/auth/types/account_retriever.go -package mocks -destination tests/mocks/account_retriever.go mockgen -package mocks -destination tests/mocks/tendermint_tm_db_DB.go github.com/tendermint/tm-db DB @@ -169,7 +172,7 @@ test-sim-after-import \ test-sim-custom-genesis-multi-seed \ test-sim-multi-seed-short \ test-sim-multi-seed-long \ -test-sim-benchmark-invariants \ +test-sim-benchmark-invariants SIM_NUM_BLOCKS ?= 500 SIM_BLOCK_SIZE ?= 200 diff --git a/simapp/cmd/simd/genaccounts.go b/simapp/cmd/simd/genaccounts.go index 92ca44ef499b..a4085ca01154 100644 --- a/simapp/cmd/simd/genaccounts.go +++ b/simapp/cmd/simd/genaccounts.go @@ -5,6 +5,12 @@ import ( "errors" "fmt" + "github.com/spf13/cobra" + "github.com/spf13/viper" + + "github.com/tendermint/go-amino" + "github.com/tendermint/tendermint/libs/cli" + "github.com/cosmos/cosmos-sdk/client/flags" codecstd "github.com/cosmos/cosmos-sdk/codec/std" "github.com/cosmos/cosmos-sdk/crypto/keyring" @@ -15,9 +21,6 @@ import ( authvesting "github.com/cosmos/cosmos-sdk/x/auth/vesting" "github.com/cosmos/cosmos-sdk/x/bank" "github.com/cosmos/cosmos-sdk/x/genutil" - "github.com/spf13/cobra" - "github.com/spf13/viper" - "github.com/tendermint/tendermint/libs/cli" ) const ( From 0ae1966de89e8dea05857af3b0ff048f87196364 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Fri, 17 Apr 2020 00:36:28 +0530 Subject: [PATCH 06/61] Updated simd to latest --- simapp/cmd/simcli/main.go | 1 + simapp/cmd/simd/main.go | 10 +++++----- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/simapp/cmd/simcli/main.go b/simapp/cmd/simcli/main.go index c9c1a573c1f1..2880c186f16b 100644 --- a/simapp/cmd/simcli/main.go +++ b/simapp/cmd/simcli/main.go @@ -7,6 +7,7 @@ import ( "github.com/spf13/cobra" "github.com/spf13/viper" + "github.com/tendermint/go-amino" "github.com/tendermint/tendermint/libs/cli" "github.com/cosmos/cosmos-sdk/client" diff --git a/simapp/cmd/simd/main.go b/simapp/cmd/simd/main.go index fdb6789c8b23..362a0115c1cf 100644 --- a/simapp/cmd/simd/main.go +++ b/simapp/cmd/simd/main.go @@ -100,16 +100,16 @@ func newApp(logger log.Logger, db dbm.DB, traceStore io.Writer) abci.Application func exportAppStateAndTMValidators( logger log.Logger, db dbm.DB, traceStore io.Writer, height int64, forZeroHeight bool, jailWhiteList []string, -) (json.RawMessage, []tmtypes.GenesisValidator, error) { +) (json.RawMessage, []tmtypes.GenesisValidator, *abci.ConsensusParams, error) { if height != -1 { - gapp := simapp.NewSimApp(logger, db, traceStore, false, map[int64]bool{}, "", uint(1)) - err := gapp.LoadHeight(height) + simapp := simapp.NewSimApp(logger, db, traceStore, false, map[int64]bool{}, "", uint(1)) + err := simapp.LoadHeight(height) if err != nil { - return nil, nil, err + return nil, nil, nil, err } - return gapp.ExportAppStateAndValidators(forZeroHeight, jailWhiteList) + return simapp.ExportAppStateAndValidators(forZeroHeight, jailWhiteList) } simApp := simapp.NewSimApp(logger, db, traceStore, true, map[int64]bool{}, "", uint(1)) From 6f362fded805b0d340ba0cba05c41b702fc2db3d Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Sat, 18 Apr 2020 00:06:29 +0530 Subject: [PATCH 07/61] Removed testnet and replay commands --- simapp/cmd/simcli/main.go | 2 - simapp/cmd/simd/main.go | 2 - simapp/cmd/simd/replay.go | 194 ------------------ simapp/cmd/simd/testnet.go | 389 ------------------------------------- 4 files changed, 587 deletions(-) delete mode 100644 simapp/cmd/simd/replay.go delete mode 100644 simapp/cmd/simd/testnet.go diff --git a/simapp/cmd/simcli/main.go b/simapp/cmd/simcli/main.go index 2880c186f16b..9aa4d8ae538a 100644 --- a/simapp/cmd/simcli/main.go +++ b/simapp/cmd/simcli/main.go @@ -18,7 +18,6 @@ import ( codecstd "github.com/cosmos/cosmos-sdk/codec/std" "github.com/cosmos/cosmos-sdk/simapp" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/version" "github.com/cosmos/cosmos-sdk/x/auth" authclient "github.com/cosmos/cosmos-sdk/x/auth/client" authcmd "github.com/cosmos/cosmos-sdk/x/auth/client/cli" @@ -73,7 +72,6 @@ func main() { flags.LineBreak, keys.Commands(), flags.LineBreak, - version.Cmd, flags.NewCompletionCmd(rootCmd, true), ) diff --git a/simapp/cmd/simd/main.go b/simapp/cmd/simd/main.go index 362a0115c1cf..3852617b6267 100644 --- a/simapp/cmd/simd/main.go +++ b/simapp/cmd/simd/main.go @@ -59,8 +59,6 @@ func main() { rootCmd.AddCommand(genutilcli.ValidateGenesisCmd(ctx, cdc, simapp.ModuleBasics)) rootCmd.AddCommand(AddGenesisAccountCmd(ctx, cdc, appCodec, simapp.DefaultNodeHome, simapp.DefaultCLIHome)) rootCmd.AddCommand(flags.NewCompletionCmd(rootCmd, true)) - rootCmd.AddCommand(testnetCmd(ctx, cdc, simapp.ModuleBasics, bank.GenesisBalancesIterator{})) - rootCmd.AddCommand(replayCmd()) rootCmd.AddCommand(debug.Cmd(cdc)) server.AddCommands(ctx, cdc, rootCmd, newApp, exportAppStateAndTMValidators) diff --git a/simapp/cmd/simd/replay.go b/simapp/cmd/simd/replay.go deleted file mode 100644 index 39a2184f9e57..000000000000 --- a/simapp/cmd/simd/replay.go +++ /dev/null @@ -1,194 +0,0 @@ -package main - -import ( - "fmt" - "io" - "os" - "path/filepath" - "time" - - cpm "github.com/otiai10/copy" - "github.com/spf13/cobra" - - abci "github.com/tendermint/tendermint/abci/types" - tmos "github.com/tendermint/tendermint/libs/os" - "github.com/tendermint/tendermint/proxy" - tmsm "github.com/tendermint/tendermint/state" - tmstore "github.com/tendermint/tendermint/store" - tm "github.com/tendermint/tendermint/types" - - "github.com/cosmos/cosmos-sdk/baseapp" - "github.com/cosmos/cosmos-sdk/server" - "github.com/cosmos/cosmos-sdk/simapp" - "github.com/cosmos/cosmos-sdk/store" - sdk "github.com/cosmos/cosmos-sdk/types" -) - -func replayCmd() *cobra.Command { - return &cobra.Command{ - Use: "replay ", - Short: "Replay simulation transactions", - RunE: func(_ *cobra.Command, args []string) error { - return replayTxs(args[0]) - }, - Args: cobra.ExactArgs(1), - } -} - -func replayTxs(rootDir string) error { - - if false { - // Copy the rootDir to a new directory, to preserve the old one. - fmt.Fprintln(os.Stderr, "Copying rootdir over") - oldRootDir := rootDir - - rootDir = oldRootDir + "_replay" - if tmos.FileExists(rootDir) { - tmos.Exit(fmt.Sprintf("temporary copy dir %v already exists", rootDir)) - } - - if err := cpm.Copy(oldRootDir, rootDir); err != nil { - return err - } - } - - configDir := filepath.Join(rootDir, "config") - dataDir := filepath.Join(rootDir, "data") - ctx := server.NewDefaultContext() - - // App DB - // appDB := dbm.NewMemDB() - fmt.Fprintln(os.Stderr, "Opening app database") - appDB, err := sdk.NewLevelDB("application", dataDir) - if err != nil { - return err - } - - // TM DB - // tmDB := dbm.NewMemDB() - fmt.Fprintln(os.Stderr, "Opening tendermint state database") - tmDB, err := sdk.NewLevelDB("state", dataDir) - if err != nil { - return err - } - - // Blockchain DB - fmt.Fprintln(os.Stderr, "Opening blockstore database") - bcDB, err := sdk.NewLevelDB("blockstore", dataDir) - if err != nil { - return err - } - - // TraceStore - var traceStoreWriter io.Writer - var traceStoreDir = filepath.Join(dataDir, "trace.log") - traceStoreWriter, err = os.OpenFile( - traceStoreDir, - os.O_WRONLY|os.O_APPEND|os.O_CREATE, - 0666, - ) - if err != nil { - return err - } - - // Application - fmt.Fprintln(os.Stderr, "Creating application") - gapp := simapp.NewSimApp( - ctx.Logger, appDB, traceStoreWriter, true, map[int64]bool{}, "", uint(1), - baseapp.SetPruning(store.PruneEverything), // nothing - ) - - // Genesis - var genDocPath = filepath.Join(configDir, "genesis.json") - genDoc, err := tm.GenesisDocFromFile(genDocPath) - if err != nil { - return err - } - genState, err := tmsm.MakeGenesisState(genDoc) - if err != nil { - return err - } - // tmsm.SaveState(tmDB, genState) - - cc := proxy.NewLocalClientCreator(gapp) - proxyApp := proxy.NewAppConns(cc) - err = proxyApp.Start() - if err != nil { - return err - } - defer func() { - err = proxyApp.Stop() - if err != nil { - return - } - }() - - state := tmsm.LoadState(tmDB) - if state.LastBlockHeight == 0 { - // Send InitChain msg - fmt.Fprintln(os.Stderr, "Sending InitChain msg") - validators := tm.TM2PB.ValidatorUpdates(genState.Validators) - csParams := tm.TM2PB.ConsensusParams(genDoc.ConsensusParams) - req := abci.RequestInitChain{ - Time: genDoc.GenesisTime, - ChainId: genDoc.ChainID, - ConsensusParams: csParams, - Validators: validators, - AppStateBytes: genDoc.AppState, - } - res, err := proxyApp.Consensus().InitChainSync(req) - if err != nil { - return err - } - newValidatorz, err := tm.PB2TM.ValidatorUpdates(res.Validators) - if err != nil { - return err - } - newValidators := tm.NewValidatorSet(newValidatorz) - - // Take the genesis state. - state = genState - state.Validators = newValidators - state.NextValidators = newValidators - } - - // Create executor - fmt.Fprintln(os.Stderr, "Creating block executor") - blockExec := tmsm.NewBlockExecutor(tmDB, ctx.Logger, proxyApp.Consensus(), nil, tmsm.MockEvidencePool{}) - - // Create block store - fmt.Fprintln(os.Stderr, "Creating block store") - blockStore := tmstore.NewBlockStore(bcDB) - - tz := []time.Duration{0, 0, 0} - for i := int(state.LastBlockHeight) + 1; ; i++ { - fmt.Fprintln(os.Stderr, "Running block ", i) - t1 := time.Now() - - // Apply block - fmt.Printf("loading and applying block %d\n", i) - blockmeta := blockStore.LoadBlockMeta(int64(i)) - if blockmeta == nil { - fmt.Printf("Couldn't find block meta %d... done?\n", i) - return nil - } - block := blockStore.LoadBlock(int64(i)) - if block == nil { - return fmt.Errorf("couldn't find block %d", i) - } - - t2 := time.Now() - - state, err = blockExec.ApplyBlock(state, blockmeta.BlockID, block) - if err != nil { - return err - } - - t3 := time.Now() - tz[0] += t2.Sub(t1) - tz[1] += t3.Sub(t2) - - fmt.Fprintf(os.Stderr, "new app hash: %X\n", state.AppHash) - fmt.Fprintln(os.Stderr, tz) - } -} diff --git a/simapp/cmd/simd/testnet.go b/simapp/cmd/simd/testnet.go deleted file mode 100644 index 09ab77dee1c1..000000000000 --- a/simapp/cmd/simd/testnet.go +++ /dev/null @@ -1,389 +0,0 @@ -package main - -// DONTCOVER - -import ( - "bufio" - "encoding/json" - "fmt" - "net" - "os" - "path/filepath" - - "github.com/cosmos/cosmos-sdk/client/flags" - clientkeys "github.com/cosmos/cosmos-sdk/client/keys" - "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/crypto/keyring" - "github.com/cosmos/cosmos-sdk/server" - srvconfig "github.com/cosmos/cosmos-sdk/server/config" - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/types/module" - "github.com/cosmos/cosmos-sdk/x/auth" - authexported "github.com/cosmos/cosmos-sdk/x/auth/exported" - "github.com/cosmos/cosmos-sdk/x/bank" - "github.com/cosmos/cosmos-sdk/x/genutil" - genutiltypes "github.com/cosmos/cosmos-sdk/x/genutil/types" - "github.com/cosmos/cosmos-sdk/x/staking" - - tmconfig "github.com/tendermint/tendermint/config" - "github.com/tendermint/tendermint/crypto" - tmos "github.com/tendermint/tendermint/libs/os" - tmrand "github.com/tendermint/tendermint/libs/rand" - "github.com/tendermint/tendermint/types" - tmtime "github.com/tendermint/tendermint/types/time" - - "github.com/spf13/cobra" - "github.com/spf13/viper" -) - -var ( - flagNodeDirPrefix = "node-dir-prefix" - flagNumValidators = "v" - flagOutputDir = "output-dir" - flagNodeDaemonHome = "node-daemon-home" - flagNodeCLIHome = "node-cli-home" - flagStartingIPAddress = "starting-ip-address" -) - -// get cmd to initialize all files for tendermint testnet and application -func testnetCmd(ctx *server.Context, cdc *codec.Codec, - mbm module.BasicManager, genBalIterator genutiltypes.GenesisBalancesIterator, -) *cobra.Command { - - cmd := &cobra.Command{ - Use: "testnet", - Short: "Initialize files for a simd testnet", - Long: `testnet will create "v" number of directories and populate each with -necessary files (private validator, genesis, config, etc.). - -Note, strict routability for addresses is turned off in the config file. - -Example: - simd testnet --v 4 --output-dir ./output --starting-ip-address 192.168.10.2 - `, - RunE: func(cmd *cobra.Command, _ []string) error { - config := ctx.Config - - outputDir := viper.GetString(flagOutputDir) - chainID := viper.GetString(flags.FlagChainID) - minGasPrices := viper.GetString(server.FlagMinGasPrices) - nodeDirPrefix := viper.GetString(flagNodeDirPrefix) - nodeDaemonHome := viper.GetString(flagNodeDaemonHome) - nodeCLIHome := viper.GetString(flagNodeCLIHome) - startingIPAddress := viper.GetString(flagStartingIPAddress) - numValidators := viper.GetInt(flagNumValidators) - - return InitTestnet(cmd, config, cdc, mbm, genBalIterator, outputDir, chainID, - minGasPrices, nodeDirPrefix, nodeDaemonHome, nodeCLIHome, startingIPAddress, numValidators) - }, - } - - cmd.Flags().Int(flagNumValidators, 4, - "Number of validators to initialize the testnet with") - cmd.Flags().StringP(flagOutputDir, "o", "./mytestnet", - "Directory to store initialization data for the testnet") - cmd.Flags().String(flagNodeDirPrefix, "node", - "Prefix the directory name for each node with (node results in node0, node1, ...)") - cmd.Flags().String(flagNodeDaemonHome, "simd", - "Home directory of the node's daemon configuration") - cmd.Flags().String(flagNodeCLIHome, "simcli", - "Home directory of the node's cli configuration") - cmd.Flags().String(flagStartingIPAddress, "192.168.0.1", - "Starting IP address (192.168.0.1 results in persistent peers list ID0@192.168.0.1:46656, ID1@192.168.0.2:46656, ...)") - cmd.Flags().String( - flags.FlagChainID, "", "genesis file chain-id, if left blank will be randomly created") - cmd.Flags().String( - server.FlagMinGasPrices, fmt.Sprintf("0.000006%s", sdk.DefaultBondDenom), - "Minimum gas prices to accept for transactions; All fees in a tx must meet this minimum (e.g. 0.01photino,0.001stake)") - cmd.Flags().String(flags.FlagKeyringBackend, flags.DefaultKeyringBackend, "Select keyring's backend (os|file|test)") - - return cmd -} - -const nodeDirPerm = 0755 - -// Initialize the testnet -func InitTestnet( - cmd *cobra.Command, config *tmconfig.Config, cdc *codec.Codec, - mbm module.BasicManager, genBalIterator genutiltypes.GenesisBalancesIterator, - outputDir, chainID, minGasPrices, nodeDirPrefix, nodeDaemonHome, - nodeCLIHome, startingIPAddress string, numValidators int, -) error { - - if chainID == "" { - chainID = "chain-" + tmrand.NewRand().Str(6) - } - - monikers := make([]string, numValidators) - nodeIDs := make([]string, numValidators) - valPubKeys := make([]crypto.PubKey, numValidators) - - simappConfig := srvconfig.DefaultConfig() - simappConfig.MinGasPrices = minGasPrices - - //nolint:prealloc - var ( - genAccounts []authexported.GenesisAccount - genBalances []bank.Balance - genFiles []string - ) - - inBuf := bufio.NewReader(cmd.InOrStdin()) - // generate private keys, node IDs, and initial transactions - for i := 0; i < numValidators; i++ { - nodeDirName := fmt.Sprintf("%s%d", nodeDirPrefix, i) - nodeDir := filepath.Join(outputDir, nodeDirName, nodeDaemonHome) - clientDir := filepath.Join(outputDir, nodeDirName, nodeCLIHome) - gentxsDir := filepath.Join(outputDir, "gentxs") - - config.SetRoot(nodeDir) - config.RPC.ListenAddress = "tcp://0.0.0.0:26657" - - if err := os.MkdirAll(filepath.Join(nodeDir, "config"), nodeDirPerm); err != nil { - _ = os.RemoveAll(outputDir) - return err - } - - if err := os.MkdirAll(clientDir, nodeDirPerm); err != nil { - _ = os.RemoveAll(outputDir) - return err - } - - monikers = append(monikers, nodeDirName) - config.Moniker = nodeDirName - - ip, err := getIP(i, startingIPAddress) - if err != nil { - _ = os.RemoveAll(outputDir) - return err - } - - nodeIDs[i], valPubKeys[i], err = genutil.InitializeNodeValidatorFiles(config) - if err != nil { - _ = os.RemoveAll(outputDir) - return err - } - - memo := fmt.Sprintf("%s@%s:26656", nodeIDs[i], ip) - genFiles = append(genFiles, config.GenesisFile()) - - kb, err := keyring.New( - sdk.KeyringServiceName(), - viper.GetString(flags.FlagKeyringBackend), - clientDir, - inBuf, - ) - if err != nil { - return err - } - - keyPass := clientkeys.DefaultKeyPass - addr, secret, err := server.GenerateSaveCoinKey(kb, nodeDirName, keyPass, true) - if err != nil { - _ = os.RemoveAll(outputDir) - return err - } - - info := map[string]string{"secret": secret} - - cliPrint, err := json.Marshal(info) - if err != nil { - return err - } - - // save private key seed words - if err := writeFile(fmt.Sprintf("%v.json", "key_seed"), clientDir, cliPrint); err != nil { - return err - } - - accTokens := sdk.TokensFromConsensusPower(1000) - accStakingTokens := sdk.TokensFromConsensusPower(500) - coins := sdk.Coins{ - sdk.NewCoin(fmt.Sprintf("%stoken", nodeDirName), accTokens), - sdk.NewCoin(sdk.DefaultBondDenom, accStakingTokens), - } - - genBalances = append(genBalances, bank.Balance{Address: addr, Coins: coins.Sort()}) - genAccounts = append(genAccounts, auth.NewBaseAccount(addr, nil, 0, 0)) - - valTokens := sdk.TokensFromConsensusPower(100) - msg := staking.NewMsgCreateValidator( - sdk.ValAddress(addr), - valPubKeys[i], - sdk.NewCoin(sdk.DefaultBondDenom, valTokens), - staking.NewDescription(nodeDirName, "", "", "", ""), - staking.NewCommissionRates(sdk.OneDec(), sdk.OneDec(), sdk.OneDec()), - sdk.OneInt(), - ) - - tx := auth.NewStdTx([]sdk.Msg{msg}, auth.StdFee{}, []auth.StdSignature{}, memo) - txBldr := auth.NewTxBuilderFromCLI(inBuf).WithChainID(chainID).WithMemo(memo).WithKeybase(kb) - - signedTx, err := txBldr.SignStdTx(nodeDirName, clientkeys.DefaultKeyPass, tx, false) - if err != nil { - _ = os.RemoveAll(outputDir) - return err - } - - txBytes, err := cdc.MarshalJSON(signedTx) - if err != nil { - _ = os.RemoveAll(outputDir) - return err - } - - // gather gentxs folder - if err := writeFile(fmt.Sprintf("%v.json", nodeDirName), gentxsDir, txBytes); err != nil { - _ = os.RemoveAll(outputDir) - return err - } - - simConfigFilePath := filepath.Join(nodeDir, "config/simd.toml") - srvconfig.WriteConfigFile(simConfigFilePath, simappConfig) - } - - if err := initGenFiles(cdc, mbm, chainID, genAccounts, genBalances, genFiles, numValidators); err != nil { - return err - } - - err := collectGenFiles( - cdc, config, chainID, monikers, nodeIDs, valPubKeys, numValidators, - outputDir, nodeDirPrefix, nodeDaemonHome, genBalIterator, - ) - if err != nil { - return err - } - - cmd.PrintErrf("Successfully initialized %d node directories\n", numValidators) - return nil -} - -func initGenFiles( - cdc *codec.Codec, mbm module.BasicManager, chainID string, - genAccounts []authexported.GenesisAccount, genBalances []bank.Balance, - genFiles []string, numValidators int, -) error { - - appGenState := mbm.DefaultGenesis(cdc) - - // set the accounts in the genesis state - var authGenState auth.GenesisState - cdc.MustUnmarshalJSON(appGenState[auth.ModuleName], &authGenState) - - authGenState.Accounts = genAccounts - appGenState[auth.ModuleName] = cdc.MustMarshalJSON(authGenState) - - // set the balances in the genesis state - var bankGenState bank.GenesisState - cdc.MustUnmarshalJSON(appGenState[bank.ModuleName], &bankGenState) - - bankGenState.Balances = genBalances - appGenState[bank.ModuleName] = cdc.MustMarshalJSON(bankGenState) - - appGenStateJSON, err := codec.MarshalJSONIndent(cdc, appGenState) - if err != nil { - return err - } - - genDoc := types.GenesisDoc{ - ChainID: chainID, - AppState: appGenStateJSON, - Validators: nil, - } - - // generate empty genesis files for each validator and save - for i := 0; i < numValidators; i++ { - if err := genDoc.SaveAs(genFiles[i]); err != nil { - return err - } - } - return nil -} - -func collectGenFiles( - cdc *codec.Codec, config *tmconfig.Config, chainID string, - monikers, nodeIDs []string, valPubKeys []crypto.PubKey, - numValidators int, outputDir, nodeDirPrefix, nodeDaemonHome string, - genBalIterator genutiltypes.GenesisBalancesIterator, -) error { - - var appState json.RawMessage - genTime := tmtime.Now() - - for i := 0; i < numValidators; i++ { - nodeDirName := fmt.Sprintf("%s%d", nodeDirPrefix, i) - nodeDir := filepath.Join(outputDir, nodeDirName, nodeDaemonHome) - gentxsDir := filepath.Join(outputDir, "gentxs") - moniker := monikers[i] - config.Moniker = nodeDirName - - config.SetRoot(nodeDir) - - nodeID, valPubKey := nodeIDs[i], valPubKeys[i] - initCfg := genutil.NewInitConfig(chainID, gentxsDir, moniker, nodeID, valPubKey) - - genDoc, err := types.GenesisDocFromFile(config.GenesisFile()) - if err != nil { - return err - } - - nodeAppState, err := genutil.GenAppStateFromConfig(cdc, config, initCfg, *genDoc, genBalIterator) - if err != nil { - return err - } - - if appState == nil { - // set the canonical application state (they should not differ) - appState = nodeAppState - } - - genFile := config.GenesisFile() - - // overwrite each validator's genesis file to have a canonical genesis time - if err := genutil.ExportGenesisFileWithTime(genFile, chainID, nil, appState, genTime); err != nil { - return err - } - } - - return nil -} - -func getIP(i int, startingIPAddr string) (ip string, err error) { - if len(startingIPAddr) == 0 { - ip, err = server.ExternalIP() - if err != nil { - return "", err - } - return ip, nil - } - return calculateIP(startingIPAddr, i) -} - -func calculateIP(ip string, i int) (string, error) { - ipv4 := net.ParseIP(ip).To4() - if ipv4 == nil { - return "", fmt.Errorf("%v: non ipv4 address", ip) - } - - for j := 0; j < i; j++ { - ipv4[3]++ - } - - return ipv4.String(), nil -} - -func writeFile(name string, dir string, contents []byte) error { - writePath := filepath.Join(dir) - file := filepath.Join(writePath, name) - - err := tmos.EnsureDir(writePath, 0700) - if err != nil { - return err - } - - err = tmos.WriteFile(file, contents, 0600) - if err != nil { - return err - } - - return nil -} From 5136a91b9214bff84648a97f4d148a0520bad40a Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Sat, 18 Apr 2020 00:51:40 +0530 Subject: [PATCH 08/61] Modified tx command for simcli --- simapp/cmd/simcli/main.go | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/simapp/cmd/simcli/main.go b/simapp/cmd/simcli/main.go index 9aa4d8ae538a..5f3947d50931 100644 --- a/simapp/cmd/simcli/main.go +++ b/simapp/cmd/simcli/main.go @@ -18,11 +18,9 @@ import ( codecstd "github.com/cosmos/cosmos-sdk/codec/std" "github.com/cosmos/cosmos-sdk/simapp" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/auth" authclient "github.com/cosmos/cosmos-sdk/x/auth/client" authcmd "github.com/cosmos/cosmos-sdk/x/auth/client/cli" authrest "github.com/cosmos/cosmos-sdk/x/auth/client/rest" - "github.com/cosmos/cosmos-sdk/x/bank" bankcmd "github.com/cosmos/cosmos-sdk/x/bank/client/cli" ) @@ -135,17 +133,6 @@ func txCmd(cdc *amino.Codec) *cobra.Command { // add modules' tx commands simapp.ModuleBasics.AddTxCommands(txCmd, cdc) - // remove auth and bank commands as they're mounted under the root tx command - var cmdsToRemove []*cobra.Command - - for _, cmd := range txCmd.Commands() { - if cmd.Use == auth.ModuleName || cmd.Use == bank.ModuleName { - cmdsToRemove = append(cmdsToRemove, cmd) - } - } - - txCmd.RemoveCommand(cmdsToRemove...) - return txCmd } From da5b8e362fa786a646cf8cbb69608e1b225c035c Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Sat, 18 Apr 2020 03:44:57 +0530 Subject: [PATCH 09/61] Did code cleanup --- simapp/cmd/simcli/main.go | 3 +-- simapp/cmd/simd/main.go | 26 ++++++++++++-------------- 2 files changed, 13 insertions(+), 16 deletions(-) diff --git a/simapp/cmd/simcli/main.go b/simapp/cmd/simcli/main.go index 5f3947d50931..00f0ab231716 100644 --- a/simapp/cmd/simcli/main.go +++ b/simapp/cmd/simcli/main.go @@ -136,9 +136,8 @@ func txCmd(cdc *amino.Codec) *cobra.Command { return txCmd } -// registerRoutes registers the routes from the different modules for the LCD. +// registerRoutes registers the routes from the different modules for the REST client. // NOTE: details on the routes added for each module are in the module documentation -// NOTE: If making updates here you also need to update the test helper in client/lcd/test_helper.go func registerRoutes(rs *lcd.RestServer) { client.RegisterRoutes(rs.CliCtx, rs.Mux) authrest.RegisterTxRoutes(rs.CliCtx, rs.Mux) diff --git a/simapp/cmd/simd/main.go b/simapp/cmd/simd/main.go index 3852617b6267..ab9278cf5149 100644 --- a/simapp/cmd/simd/main.go +++ b/simapp/cmd/simd/main.go @@ -47,19 +47,18 @@ func main() { PersistentPreRunE: server.PersistentPreRunEFn(ctx), } - rootCmd.AddCommand(genutilcli.InitCmd(ctx, cdc, simapp.ModuleBasics, simapp.DefaultNodeHome)) - rootCmd.AddCommand(genutilcli.CollectGenTxsCmd(ctx, cdc, bank.GenesisBalancesIterator{}, simapp.DefaultNodeHome)) - rootCmd.AddCommand(genutilcli.MigrateGenesisCmd(ctx, cdc)) rootCmd.AddCommand( + genutilcli.InitCmd(ctx, cdc, simapp.ModuleBasics, simapp.DefaultNodeHome), + genutilcli.CollectGenTxsCmd(ctx, cdc, bank.GenesisBalancesIterator{}, simapp.DefaultNodeHome), + genutilcli.MigrateGenesisCmd(ctx, cdc), genutilcli.GenTxCmd( ctx, cdc, simapp.ModuleBasics, staking.AppModuleBasic{}, bank.GenesisBalancesIterator{}, simapp.DefaultNodeHome, simapp.DefaultCLIHome, ), - ) - rootCmd.AddCommand(genutilcli.ValidateGenesisCmd(ctx, cdc, simapp.ModuleBasics)) - rootCmd.AddCommand(AddGenesisAccountCmd(ctx, cdc, appCodec, simapp.DefaultNodeHome, simapp.DefaultCLIHome)) - rootCmd.AddCommand(flags.NewCompletionCmd(rootCmd, true)) - rootCmd.AddCommand(debug.Cmd(cdc)) + genutilcli.ValidateGenesisCmd(ctx, cdc, simapp.ModuleBasics), + AddGenesisAccountCmd(ctx, cdc, appCodec, simapp.DefaultNodeHome, simapp.DefaultCLIHome), + flags.NewCompletionCmd(rootCmd, true), + debug.Cmd(cdc)) server.AddCommands(ctx, cdc, rootCmd, newApp, exportAppStateAndTMValidators) @@ -100,16 +99,15 @@ func exportAppStateAndTMValidators( logger log.Logger, db dbm.DB, traceStore io.Writer, height int64, forZeroHeight bool, jailWhiteList []string, ) (json.RawMessage, []tmtypes.GenesisValidator, *abci.ConsensusParams, error) { + var simApp *simapp.SimApp if height != -1 { - simapp := simapp.NewSimApp(logger, db, traceStore, false, map[int64]bool{}, "", uint(1)) - err := simapp.LoadHeight(height) + simApp = simapp.NewSimApp(logger, db, traceStore, false, map[int64]bool{}, "", uint(1)) + err := simApp.LoadHeight(height) if err != nil { return nil, nil, nil, err } - - return simapp.ExportAppStateAndValidators(forZeroHeight, jailWhiteList) + } else { + simApp = simapp.NewSimApp(logger, db, traceStore, true, map[int64]bool{}, "", uint(1)) } - - simApp := simapp.NewSimApp(logger, db, traceStore, true, map[int64]bool{}, "", uint(1)) return simApp.ExportAppStateAndValidators(forZeroHeight, jailWhiteList) } From 0ef94f278860e62efa804c1ccd61461712f936bb Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Sat, 18 Apr 2020 12:46:33 +0530 Subject: [PATCH 10/61] Removed duplication in Makefile --- Makefile | 9 --------- 1 file changed, 9 deletions(-) diff --git a/Makefile b/Makefile index 9fc760b14b3a..2a81798e657a 100644 --- a/Makefile +++ b/Makefile @@ -36,15 +36,6 @@ endif build \ build-sim -build-sim: go.sum -ifeq ($(OS),Windows_NT) - go build -mod=readonly $(BUILD_FLAGS) -o build/simd.exe ./simapp/cmd/simd - go build -mod=readonly $(BUILD_FLAGS) -o build/simcli.exe ./simapp/cmd/simcli -else - go build -mod=readonly $(BUILD_FLAGS) -o build/simd ./simapp/cmd/simd - go build -mod=readonly $(BUILD_FLAGS) -o build/simcli ./simapp/cmd/simcli -endif - mocks: $(MOCKS_DIR) mockgen -source=x/auth/types/account_retriever.go -package mocks -destination tests/mocks/account_retriever.go mockgen -package mocks -destination tests/mocks/tendermint_tm_db_DB.go github.com/tendermint/tm-db DB From 6670f90c59c89592ad425ae9b33c61f5543c5ebd Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Mon, 20 Apr 2020 23:47:15 +0530 Subject: [PATCH 11/61] Refactored cli_test --- Makefile | 4 +- cli_test/helpers/constants.go | 13 + cli_test/helpers/executors.go | 47 +++ cli_test/helpers/fixtures.go | 75 ++++ cli_test/helpers/init.go | 69 ++++ cli_test/helpers/test_helpers.go | 164 +++++++++ cli_test/helpers/utils.go | 10 + cli_test/test_helpers.go | 360 ------------------- cli_test/tests/codec.go | 16 + cli_test/{cli_test.go => tests/keys_test.go} | 24 +- 10 files changed, 403 insertions(+), 379 deletions(-) create mode 100644 cli_test/helpers/constants.go create mode 100644 cli_test/helpers/executors.go create mode 100644 cli_test/helpers/fixtures.go create mode 100644 cli_test/helpers/init.go create mode 100644 cli_test/helpers/test_helpers.go create mode 100644 cli_test/helpers/utils.go delete mode 100644 cli_test/test_helpers.go create mode 100644 cli_test/tests/codec.go rename cli_test/{cli_test.go => tests/keys_test.go} (55%) diff --git a/Makefile b/Makefile index 2a81798e657a..1b3cb1c13bb8 100644 --- a/Makefile +++ b/Makefile @@ -164,8 +164,8 @@ test-sim-benchmark-invariants: -Enabled=true -NumBlocks=1000 -BlockSize=200 \ -Period=1 -Commit=true -Seed=57 -v -timeout 24h -test-cli: build-sim - @go test -mod=readonly -p 4 `go list ./cli_test/...` -tags=cli_test -v +test-cli: + @go test -mod=readonly -p 4 `go list ./cli_test/tests/...` -tags=cli_test -v .PHONY: \ test-sim-nondeterminism \ diff --git a/cli_test/helpers/constants.go b/cli_test/helpers/constants.go new file mode 100644 index 000000000000..c634f3cc5a19 --- /dev/null +++ b/cli_test/helpers/constants.go @@ -0,0 +1,13 @@ +package helpers + +const ( + Denom = "stake" + KeyFoo = "foo" + KeyBar = "bar" + FooDenom = "footoken" + FeeDenom = "feetoken" + Fee2Denom = "fee2token" + KeyBaz = "baz" + KeyVesting = "vesting" + KeyFooBarBaz = "foobarbaz" +) diff --git a/cli_test/helpers/executors.go b/cli_test/helpers/executors.go new file mode 100644 index 000000000000..54bdc19af38a --- /dev/null +++ b/cli_test/helpers/executors.go @@ -0,0 +1,47 @@ +package helpers + +import ( + "fmt" + "github.com/cosmos/cosmos-sdk/tests" + "github.com/stretchr/testify/require" + "testing" +) + +func executeWriteCheckErr(t *testing.T, cmdStr string, writes ...string) { + require.True(t, executeWrite(t, cmdStr, writes...)) +} + +func executeWrite(t *testing.T, cmdStr string, writes ...string) (exitSuccess bool) { + exitSuccess, _, _ = executeWriteRetStdStreams(t, cmdStr, writes...) + return +} + +func executeWriteRetStdStreams(t *testing.T, cmdStr string, writes ...string) (bool, string, string) { + proc := tests.GoExecuteT(t, cmdStr) + + // Enables use of interactive commands + for _, write := range writes { + _, err := proc.StdinPipe.Write([]byte(write + "\n")) + require.NoError(t, err) + } + + // Read both stdout and stderr from the process + stdout, stderr, err := proc.ReadAll() + if err != nil { + fmt.Println("Err on proc.ReadAll()", err, cmdStr) + } + + // Log output. + if len(stdout) > 0 { + t.Log("Stdout:", string(stdout)) + } + if len(stderr) > 0 { + t.Log("Stderr:", string(stderr)) + } + + // Wait for process to exit + proc.Wait() + + // Return succes, stdout, stderr + return proc.ExitState.Success(), string(stdout), string(stderr) +} diff --git a/cli_test/helpers/fixtures.go b/cli_test/helpers/fixtures.go new file mode 100644 index 000000000000..25accbc7a98d --- /dev/null +++ b/cli_test/helpers/fixtures.go @@ -0,0 +1,75 @@ +package helpers + +import ( + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/server" + "github.com/cosmos/cosmos-sdk/simapp" + "github.com/stretchr/testify/require" + tmtypes "github.com/tendermint/tendermint/types" + "io/ioutil" + "os" + "path/filepath" + "testing" +) + +// Fixtures is used to setup the testing environment +type Fixtures struct { + BuildDir string + RootDir string + SimdBinary string + SimcliBinary string + ChainID string + RPCAddr string + Port string + SimdHome string + SimcliHome string + P2PAddr string + T *testing.T +} + +// NewFixtures creates a new instance of Fixtures with many vars set +func NewFixtures(t *testing.T) *Fixtures { + tmpDir, err := ioutil.TempDir("", "sdk_integration_"+t.Name()+"_") + require.NoError(t, err) + + servAddr, port, err := server.FreeTCPAddr() + require.NoError(t, err) + + p2pAddr, _, err := server.FreeTCPAddr() + require.NoError(t, err) + + buildDir := os.Getenv("BUILDDIR") + if buildDir == "" { + buildDir, err = filepath.Abs("../../build/") + require.NoError(t, err) + } + + return &Fixtures{ + T: t, + BuildDir: buildDir, + RootDir: tmpDir, + SimdBinary: filepath.Join(buildDir, "simd"), + SimcliBinary: filepath.Join(buildDir, "simcli"), + SimdHome: filepath.Join(tmpDir, ".simd"), + SimcliHome: filepath.Join(tmpDir, ".simcli"), + RPCAddr: servAddr, + P2PAddr: p2pAddr, + Port: port, + } +} + +// GenesisFile returns the path of the genesis file +func (f Fixtures) GenesisFile() string { + return filepath.Join(f.SimdHome, "config", "genesis.json") +} + +// GenesisFile returns the application's genesis state +func (f Fixtures) GenesisState() simapp.GenesisState { + cdc := codec.New() + genDoc, err := tmtypes.GenesisDocFromFile(f.GenesisFile()) + require.NoError(f.T, err) + + var appState simapp.GenesisState + require.NoError(f.T, cdc.UnmarshalJSON(genDoc.AppState, &appState)) + return appState +} diff --git a/cli_test/helpers/init.go b/cli_test/helpers/init.go new file mode 100644 index 000000000000..337de26f2dba --- /dev/null +++ b/cli_test/helpers/init.go @@ -0,0 +1,69 @@ +package helpers + +import ( + "fmt" + "github.com/stretchr/testify/require" + "os" + "testing" + "time" +) + +// InitFixtures is called at the beginning of a test and initializes a chain +// with 1 validator. +func InitFixtures(t *testing.T) (f *Fixtures) { + f = NewFixtures(t) + + // reset test state + f.UnsafeResetAll() + + f.CLIConfig("keyring-backend", "test") + + // ensure keystore has foo and bar keys + f.KeysDelete(KeyFoo) + f.KeysDelete(KeyBar) + f.KeysDelete(KeyBar) + f.KeysDelete(KeyFooBarBaz) + f.KeysAdd(KeyFoo) + f.KeysAdd(KeyBar) + f.KeysAdd(KeyBaz) + f.KeysAdd(KeyVesting) + f.KeysAdd(KeyFooBarBaz, "--multisig-threshold=2", fmt.Sprintf( + "--multisig=%s,%s,%s", KeyFoo, KeyBar, KeyBaz)) + + // ensure that CLI output is in JSON format + f.CLIConfig("output", "json") + + // NOTE: SDInit sets the ChainID + f.SDInit(KeyFoo) + + f.CLIConfig("chain-id", f.ChainID) + f.CLIConfig("broadcast-mode", "block") + f.CLIConfig("trust-node", "true") + + // start an account with tokens + f.AddGenesisAccount(f.KeyAddress(KeyFoo), startCoins) + f.AddGenesisAccount( + f.KeyAddress(KeyVesting), startCoins, + fmt.Sprintf("--vesting-amount=%s", vestingCoins), + fmt.Sprintf("--vesting-start-time=%d", time.Now().UTC().UnixNano()), + fmt.Sprintf("--vesting-end-time=%d", time.Now().Add(60*time.Second).UTC().UnixNano()), + ) + + f.GenTx(KeyFoo) + f.CollectGenTxs() + + return f +} + +// Cleanup is meant to be run at the end of a test to clean up an remaining test state +func (f *Fixtures) Cleanup(dirs ...string) { + clean := append(dirs, f.RootDir) + for _, d := range clean { + require.NoError(f.T, os.RemoveAll(d)) + } +} + +// Flags returns the flags necessary for making most CLI calls +func (f *Fixtures) Flags() string { + return fmt.Sprintf("--home=%s --node=%s", f.SimcliHome, f.RPCAddr) +} diff --git a/cli_test/helpers/test_helpers.go b/cli_test/helpers/test_helpers.go new file mode 100644 index 000000000000..01b1a220d750 --- /dev/null +++ b/cli_test/helpers/test_helpers.go @@ -0,0 +1,164 @@ +package helpers + +import ( + "encoding/json" + "fmt" + clientkeys "github.com/cosmos/cosmos-sdk/client/keys" + "github.com/cosmos/cosmos-sdk/crypto/keyring" + "github.com/cosmos/cosmos-sdk/tests" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/stretchr/testify/require" + "os" + "path/filepath" + "strings" +) + +var ( + totalCoins = sdk.NewCoins( + sdk.NewCoin(Fee2Denom, sdk.TokensFromConsensusPower(2000000)), + sdk.NewCoin(FeeDenom, sdk.TokensFromConsensusPower(2000000)), + sdk.NewCoin(FooDenom, sdk.TokensFromConsensusPower(2000)), + sdk.NewCoin(Denom, sdk.TokensFromConsensusPower(300).Add(sdk.NewInt(12))), // add coins from inflation + ) + + startCoins = sdk.NewCoins( + sdk.NewCoin(Fee2Denom, sdk.TokensFromConsensusPower(1000000)), + sdk.NewCoin(FeeDenom, sdk.TokensFromConsensusPower(1000000)), + sdk.NewCoin(FooDenom, sdk.TokensFromConsensusPower(1000)), + sdk.NewCoin(Denom, sdk.TokensFromConsensusPower(150)), + ) + + vestingCoins = sdk.NewCoins( + sdk.NewCoin(FeeDenom, sdk.TokensFromConsensusPower(500000)), + ) +) + +//___________________________________________________________________________________ +// simd + +// UnsafeResetAll is simd unsafe-reset-all +func (f *Fixtures) UnsafeResetAll(flags ...string) { + cmd := fmt.Sprintf("%s --home=%s unsafe-reset-all", f.SimdBinary, f.SimdHome) + executeWrite(f.T, addFlags(cmd, flags)) + err := os.RemoveAll(filepath.Join(f.SimdHome, "config", "gentx")) + require.NoError(f.T, err) +} + +// SDInit is simd init +// NOTE: SDInit sets the ChainID for the Fixtures instance +func (f *Fixtures) SDInit(moniker string, flags ...string) { + cmd := fmt.Sprintf("%s init -o --home=%s %s", f.SimdBinary, f.SimdHome, moniker) + _, stderr := tests.ExecuteT(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) + + var chainID string + var initRes map[string]json.RawMessage + + err := json.Unmarshal([]byte(stderr), &initRes) + require.NoError(f.T, err) + + err = json.Unmarshal(initRes["chain_id"], &chainID) + require.NoError(f.T, err) + + f.ChainID = chainID +} + +// AddGenesisAccount is simd add-genesis-account +func (f *Fixtures) AddGenesisAccount(address sdk.AccAddress, coins sdk.Coins, flags ...string) { + cmd := fmt.Sprintf("%s add-genesis-account %s %s --home=%s --keyring-backend=test", f.SimdBinary, address, coins, f.SimdHome) + executeWriteCheckErr(f.T, addFlags(cmd, flags)) +} + +// GenTx is simd gentx +func (f *Fixtures) GenTx(name string, flags ...string) { + cmd := fmt.Sprintf("%s gentx --name=%s --home=%s --home-client=%s --keyring-backend=test", f.SimdBinary, name, f.SimdHome, f.SimcliHome) + executeWriteCheckErr(f.T, addFlags(cmd, flags)) +} + +// CollectGenTxs is simd collect-gentxs +func (f *Fixtures) CollectGenTxs(flags ...string) { + cmd := fmt.Sprintf("%s collect-gentxs --home=%s", f.SimdBinary, f.SimdHome) + executeWriteCheckErr(f.T, addFlags(cmd, flags)) +} + +// SDStart runs simd start with the appropriate flags and returns a process +func (f *Fixtures) SDStart(flags ...string) *tests.Process { + cmd := fmt.Sprintf("%s start --home=%s --rpc.laddr=%v --p2p.laddr=%v", f.SimdBinary, f.SimdHome, f.RPCAddr, f.P2PAddr) + proc := tests.GoExecuteTWithStdout(f.T, addFlags(cmd, flags)) + tests.WaitForTMStart(f.Port) + tests.WaitForNextNBlocksTM(1, f.Port) + return proc +} + +// SDTendermint returns the results of simd tendermint [query] +func (f *Fixtures) SDTendermint(query string) string { + cmd := fmt.Sprintf("%s tendermint %s --home=%s", f.SimdBinary, query, f.SimdHome) + success, stdout, stderr := executeWriteRetStdStreams(f.T, cmd) + require.Empty(f.T, stderr) + require.True(f.T, success) + return strings.TrimSpace(stdout) +} + +// ValidateGenesis runs simd validate-genesis +func (f *Fixtures) ValidateGenesis() { + cmd := fmt.Sprintf("%s validate-genesis --home=%s", f.SimdBinary, f.SimdHome) + executeWriteCheckErr(f.T, cmd) +} + +//___________________________________________________________________________________ +// simcli keys + +// KeysDelete is simcli keys delete +func (f *Fixtures) KeysDelete(name string, flags ...string) { + cmd := fmt.Sprintf("%s keys delete --keyring-backend=test --home=%s %s", f.SimcliBinary, + f.SimcliHome, name) + executeWrite(f.T, addFlags(cmd, append(append(flags, "-y"), "-f"))) +} + +// KeysAdd is simcli keys add +func (f *Fixtures) KeysAdd(name string, flags ...string) { + cmd := fmt.Sprintf("%s keys add --keyring-backend=test --home=%s %s", f.SimcliBinary, + f.SimcliHome, name) + executeWriteCheckErr(f.T, addFlags(cmd, flags)) +} + +// KeysAddRecover prepares simcli keys add --recover +func (f *Fixtures) KeysAddRecover(name, mnemonic string, flags ...string) (exitSuccess bool, stdout, stderr string) { + cmd := fmt.Sprintf("%s keys add --keyring-backend=test --home=%s --recover %s", + f.SimcliBinary, f.SimcliHome, name) + return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), mnemonic) +} + +// KeysAddRecoverHDPath prepares simcli keys add --recover --account --index +func (f *Fixtures) KeysAddRecoverHDPath(name, mnemonic string, account uint32, index uint32, flags ...string) { + cmd := fmt.Sprintf("%s keys add --keyring-backend=test --home=%s --recover %s --account %d"+ + " --index %d", f.SimcliBinary, f.SimcliHome, name, account, index) + executeWriteCheckErr(f.T, addFlags(cmd, flags), mnemonic) +} + +// KeysShow is simcli keys show +func (f *Fixtures) KeysShow(name string, flags ...string) keyring.KeyOutput { + cmd := fmt.Sprintf("%s keys show --keyring-backend=test --home=%s %s", f.SimcliBinary, + f.SimcliHome, name) + out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + var ko keyring.KeyOutput + err := clientkeys.UnmarshalJSON([]byte(out), &ko) + require.NoError(f.T, err) + return ko +} + +// KeyAddress returns the SDK account address from the key +func (f *Fixtures) KeyAddress(name string) sdk.AccAddress { + ko := f.KeysShow(name) + accAddr, err := sdk.AccAddressFromBech32(ko.Address) + require.NoError(f.T, err) + return accAddr +} + +//___________________________________________________________________________________ +// simcli config + +// CLIConfig is simcli config +func (f *Fixtures) CLIConfig(key, value string, flags ...string) { + cmd := fmt.Sprintf("%s config --home=%s %s %s", f.SimcliBinary, f.SimcliHome, key, value) + executeWriteCheckErr(f.T, addFlags(cmd, flags)) +} diff --git a/cli_test/helpers/utils.go b/cli_test/helpers/utils.go new file mode 100644 index 000000000000..b9676270d70e --- /dev/null +++ b/cli_test/helpers/utils.go @@ -0,0 +1,10 @@ +package helpers + +import "strings" + +func addFlags(cmd string, flags []string) string { + for _, f := range flags { + cmd += " " + f + } + return strings.TrimSpace(cmd) +} diff --git a/cli_test/test_helpers.go b/cli_test/test_helpers.go deleted file mode 100644 index fee10ddf8a3b..000000000000 --- a/cli_test/test_helpers.go +++ /dev/null @@ -1,360 +0,0 @@ -package clitest - -import ( - "encoding/json" - "fmt" - clientkeys "github.com/cosmos/cosmos-sdk/client/keys" - "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/crypto/keyring" - "github.com/cosmos/cosmos-sdk/server" - "github.com/cosmos/cosmos-sdk/simapp" - "github.com/cosmos/cosmos-sdk/tests" - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/stretchr/testify/require" - tmtypes "github.com/tendermint/tendermint/types" - "io/ioutil" - "os" - "path/filepath" - "strings" - "testing" - "time" -) - -const ( - denom = "stake" - keyFoo = "foo" - keyBar = "bar" - fooDenom = "footoken" - feeDenom = "feetoken" - fee2Denom = "fee2token" - keyBaz = "baz" - keyVesting = "vesting" - keyFooBarBaz = "foobarbaz" -) - -var ( - totalCoins = sdk.NewCoins( - sdk.NewCoin(fee2Denom, sdk.TokensFromConsensusPower(2000000)), - sdk.NewCoin(feeDenom, sdk.TokensFromConsensusPower(2000000)), - sdk.NewCoin(fooDenom, sdk.TokensFromConsensusPower(2000)), - sdk.NewCoin(denom, sdk.TokensFromConsensusPower(300).Add(sdk.NewInt(12))), // add coins from inflation - ) - - startCoins = sdk.NewCoins( - sdk.NewCoin(fee2Denom, sdk.TokensFromConsensusPower(1000000)), - sdk.NewCoin(feeDenom, sdk.TokensFromConsensusPower(1000000)), - sdk.NewCoin(fooDenom, sdk.TokensFromConsensusPower(1000)), - sdk.NewCoin(denom, sdk.TokensFromConsensusPower(150)), - ) - - vestingCoins = sdk.NewCoins( - sdk.NewCoin(feeDenom, sdk.TokensFromConsensusPower(500000)), - ) -) - -//___________________________________________________________________________________ -// Fixtures - -// Fixtures is used to setup the testing environment -type Fixtures struct { - BuildDir string - RootDir string - SimdBinary string - SimcliBinary string - ChainID string - RPCAddr string - Port string - SimdHome string - SimcliHome string - P2PAddr string - T *testing.T -} - -// NewFixtures creates a new instance of Fixtures with many vars set -func NewFixtures(t *testing.T) *Fixtures { - tmpDir, err := ioutil.TempDir("", "sdk_integration_"+t.Name()+"_") - require.NoError(t, err) - - servAddr, port, err := server.FreeTCPAddr() - require.NoError(t, err) - - p2pAddr, _, err := server.FreeTCPAddr() - require.NoError(t, err) - - buildDir := os.Getenv("BUILDDIR") - if buildDir == "" { - buildDir, err = filepath.Abs("../build/") - require.NoError(t, err) - } - - return &Fixtures{ - T: t, - BuildDir: buildDir, - RootDir: tmpDir, - SimdBinary: filepath.Join(buildDir, "simd"), - SimcliBinary: filepath.Join(buildDir, "simcli"), - SimdHome: filepath.Join(tmpDir, ".simd"), - SimcliHome: filepath.Join(tmpDir, ".simcli"), - RPCAddr: servAddr, - P2PAddr: p2pAddr, - Port: port, - } -} - -// GenesisFile returns the path of the genesis file -func (f Fixtures) GenesisFile() string { - return filepath.Join(f.SimdHome, "config", "genesis.json") -} - -// GenesisFile returns the application's genesis state -func (f Fixtures) GenesisState() simapp.GenesisState { - cdc := codec.New() - genDoc, err := tmtypes.GenesisDocFromFile(f.GenesisFile()) - require.NoError(f.T, err) - - var appState simapp.GenesisState - require.NoError(f.T, cdc.UnmarshalJSON(genDoc.AppState, &appState)) - return appState -} - -// InitFixtures is called at the beginning of a test and initializes a chain -// with 1 validator. -func InitFixtures(t *testing.T) (f *Fixtures) { - f = NewFixtures(t) - - // reset test state - f.UnsafeResetAll() - - f.CLIConfig("keyring-backend", "test") - - // ensure keystore has foo and bar keys - f.KeysDelete(keyFoo) - f.KeysDelete(keyBar) - f.KeysDelete(keyBar) - f.KeysDelete(keyFooBarBaz) - f.KeysAdd(keyFoo) - f.KeysAdd(keyBar) - f.KeysAdd(keyBaz) - f.KeysAdd(keyVesting) - f.KeysAdd(keyFooBarBaz, "--multisig-threshold=2", fmt.Sprintf( - "--multisig=%s,%s,%s", keyFoo, keyBar, keyBaz)) - - // ensure that CLI output is in JSON format - f.CLIConfig("output", "json") - - // NOTE: GDInit sets the ChainID - f.GDInit(keyFoo) - - f.CLIConfig("chain-id", f.ChainID) - f.CLIConfig("broadcast-mode", "block") - f.CLIConfig("trust-node", "true") - - // start an account with tokens - f.AddGenesisAccount(f.KeyAddress(keyFoo), startCoins) - f.AddGenesisAccount( - f.KeyAddress(keyVesting), startCoins, - fmt.Sprintf("--vesting-amount=%s", vestingCoins), - fmt.Sprintf("--vesting-start-time=%d", time.Now().UTC().UnixNano()), - fmt.Sprintf("--vesting-end-time=%d", time.Now().Add(60*time.Second).UTC().UnixNano()), - ) - - f.GenTx(keyFoo) - f.CollectGenTxs() - - return f -} - -// Cleanup is meant to be run at the end of a test to clean up an remaining test state -func (f *Fixtures) Cleanup(dirs ...string) { - clean := append(dirs, f.RootDir) - for _, d := range clean { - require.NoError(f.T, os.RemoveAll(d)) - } -} - -// Flags returns the flags necessary for making most CLI calls -func (f *Fixtures) Flags() string { - return fmt.Sprintf("--home=%s --node=%s", f.SimcliHome, f.RPCAddr) -} - -//___________________________________________________________________________________ -// gaiad - -// UnsafeResetAll is gaiad unsafe-reset-all -func (f *Fixtures) UnsafeResetAll(flags ...string) { - cmd := fmt.Sprintf("%s --home=%s unsafe-reset-all", f.SimdBinary, f.SimdHome) - executeWrite(f.T, addFlags(cmd, flags)) - err := os.RemoveAll(filepath.Join(f.SimdHome, "config", "gentx")) - require.NoError(f.T, err) -} - -// GDInit is gaiad init -// NOTE: GDInit sets the ChainID for the Fixtures instance -func (f *Fixtures) GDInit(moniker string, flags ...string) { - cmd := fmt.Sprintf("%s init -o --home=%s %s", f.SimdBinary, f.SimdHome, moniker) - _, stderr := tests.ExecuteT(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) - - var chainID string - var initRes map[string]json.RawMessage - - err := json.Unmarshal([]byte(stderr), &initRes) - require.NoError(f.T, err) - - err = json.Unmarshal(initRes["chain_id"], &chainID) - require.NoError(f.T, err) - - f.ChainID = chainID -} - -// AddGenesisAccount is gaiad add-genesis-account -func (f *Fixtures) AddGenesisAccount(address sdk.AccAddress, coins sdk.Coins, flags ...string) { - cmd := fmt.Sprintf("%s add-genesis-account %s %s --home=%s --keyring-backend=test", f.SimdBinary, address, coins, f.SimdHome) - executeWriteCheckErr(f.T, addFlags(cmd, flags)) -} - -// GenTx is gaiad gentx -func (f *Fixtures) GenTx(name string, flags ...string) { - cmd := fmt.Sprintf("%s gentx --name=%s --home=%s --home-client=%s --keyring-backend=test", f.SimdBinary, name, f.SimdHome, f.SimcliHome) - executeWriteCheckErr(f.T, addFlags(cmd, flags)) -} - -// CollectGenTxs is gaiad collect-gentxs -func (f *Fixtures) CollectGenTxs(flags ...string) { - cmd := fmt.Sprintf("%s collect-gentxs --home=%s", f.SimdBinary, f.SimdHome) - executeWriteCheckErr(f.T, addFlags(cmd, flags)) -} - -// GDStart runs gaiad start with the appropriate flags and returns a process -func (f *Fixtures) GDStart(flags ...string) *tests.Process { - cmd := fmt.Sprintf("%s start --home=%s --rpc.laddr=%v --p2p.laddr=%v", f.SimdBinary, f.SimdHome, f.RPCAddr, f.P2PAddr) - proc := tests.GoExecuteTWithStdout(f.T, addFlags(cmd, flags)) - tests.WaitForTMStart(f.Port) - tests.WaitForNextNBlocksTM(1, f.Port) - return proc -} - -// GDTendermint returns the results of gaiad tendermint [query] -func (f *Fixtures) GDTendermint(query string) string { - cmd := fmt.Sprintf("%s tendermint %s --home=%s", f.SimdBinary, query, f.SimdHome) - success, stdout, stderr := executeWriteRetStdStreams(f.T, cmd) - require.Empty(f.T, stderr) - require.True(f.T, success) - return strings.TrimSpace(stdout) -} - -// ValidateGenesis runs gaiad validate-genesis -func (f *Fixtures) ValidateGenesis() { - cmd := fmt.Sprintf("%s validate-genesis --home=%s", f.SimdBinary, f.SimdHome) - executeWriteCheckErr(f.T, cmd) -} - -//___________________________________________________________________________________ -// gaiacli keys - -// KeysDelete is gaiacli keys delete -func (f *Fixtures) KeysDelete(name string, flags ...string) { - cmd := fmt.Sprintf("%s keys delete --keyring-backend=test --home=%s %s", f.SimcliBinary, - f.SimcliHome, name) - executeWrite(f.T, addFlags(cmd, append(append(flags, "-y"), "-f"))) -} - -// KeysAdd is gaiacli keys add -func (f *Fixtures) KeysAdd(name string, flags ...string) { - cmd := fmt.Sprintf("%s keys add --keyring-backend=test --home=%s %s", f.SimcliBinary, - f.SimcliHome, name) - executeWriteCheckErr(f.T, addFlags(cmd, flags)) -} - -// KeysAddRecover prepares gaiacli keys add --recover -func (f *Fixtures) KeysAddRecover(name, mnemonic string, flags ...string) (exitSuccess bool, stdout, stderr string) { - cmd := fmt.Sprintf("%s keys add --keyring-backend=test --home=%s --recover %s", - f.SimcliBinary, f.SimcliHome, name) - return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), mnemonic) -} - -// KeysAddRecoverHDPath prepares gaiacli keys add --recover --account --index -func (f *Fixtures) KeysAddRecoverHDPath(name, mnemonic string, account uint32, index uint32, flags ...string) { - cmd := fmt.Sprintf("%s keys add --keyring-backend=test --home=%s --recover %s --account %d"+ - " --index %d", f.SimcliBinary, f.SimcliHome, name, account, index) - executeWriteCheckErr(f.T, addFlags(cmd, flags), mnemonic) -} - -// KeysShow is gaiacli keys show -func (f *Fixtures) KeysShow(name string, flags ...string) keyring.KeyOutput { - cmd := fmt.Sprintf("%s keys show --keyring-backend=test --home=%s %s", f.SimcliBinary, - f.SimcliHome, name) - out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") - var ko keyring.KeyOutput - err := clientkeys.UnmarshalJSON([]byte(out), &ko) - require.NoError(f.T, err) - return ko -} - -// KeyAddress returns the SDK account address from the key -func (f *Fixtures) KeyAddress(name string) sdk.AccAddress { - ko := f.KeysShow(name) - accAddr, err := sdk.AccAddressFromBech32(ko.Address) - require.NoError(f.T, err) - return accAddr -} - -//___________________________________________________________________________________ -// gaiacli config - -// CLIConfig is gaiacli config -func (f *Fixtures) CLIConfig(key, value string, flags ...string) { - cmd := fmt.Sprintf("%s config --home=%s %s %s", f.SimcliBinary, f.SimcliHome, key, value) - executeWriteCheckErr(f.T, addFlags(cmd, flags)) -} - -//___________________________________________________________________________________ -// executors - -func executeWriteCheckErr(t *testing.T, cmdStr string, writes ...string) { - require.True(t, executeWrite(t, cmdStr, writes...)) -} - -func executeWrite(t *testing.T, cmdStr string, writes ...string) (exitSuccess bool) { - exitSuccess, _, _ = executeWriteRetStdStreams(t, cmdStr, writes...) - return -} - -func executeWriteRetStdStreams(t *testing.T, cmdStr string, writes ...string) (bool, string, string) { - proc := tests.GoExecuteT(t, cmdStr) - - // Enables use of interactive commands - for _, write := range writes { - _, err := proc.StdinPipe.Write([]byte(write + "\n")) - require.NoError(t, err) - } - - // Read both stdout and stderr from the process - stdout, stderr, err := proc.ReadAll() - if err != nil { - fmt.Println("Err on proc.ReadAll()", err, cmdStr) - } - - // Log output. - if len(stdout) > 0 { - t.Log("Stdout:", string(stdout)) - } - if len(stderr) > 0 { - t.Log("Stderr:", string(stderr)) - } - - // Wait for process to exit - proc.Wait() - - // Return succes, stdout, stderr - return proc.ExitState.Success(), string(stdout), string(stderr) -} - -//___________________________________________________________________________________ -// utils - -func addFlags(cmd string, flags []string) string { - for _, f := range flags { - cmd += " " + f - } - return strings.TrimSpace(cmd) -} diff --git a/cli_test/tests/codec.go b/cli_test/tests/codec.go new file mode 100644 index 000000000000..b04742b3db3b --- /dev/null +++ b/cli_test/tests/codec.go @@ -0,0 +1,16 @@ +package tests + +import ( + codecstd "github.com/cosmos/cosmos-sdk/codec/std" + "github.com/cosmos/cosmos-sdk/simapp" + authclient "github.com/cosmos/cosmos-sdk/x/auth/client" +) + +var ( + cdc = codecstd.MakeCodec(simapp.ModuleBasics) + appCodec = codecstd.NewAppCodec(cdc) +) + +func init() { + authclient.Codec = appCodec +} diff --git a/cli_test/cli_test.go b/cli_test/tests/keys_test.go similarity index 55% rename from cli_test/cli_test.go rename to cli_test/tests/keys_test.go index 0c33e9b9cba9..ae8fdd3a2c05 100644 --- a/cli_test/cli_test.go +++ b/cli_test/tests/keys_test.go @@ -1,42 +1,32 @@ -package clitest +package tests import ( "fmt" - codecstd "github.com/cosmos/cosmos-sdk/codec/std" - "github.com/cosmos/cosmos-sdk/simapp" - authclient "github.com/cosmos/cosmos-sdk/x/auth/client" + "github.com/cosmos/cosmos-sdk/cli_test/helpers" "github.com/stretchr/testify/require" "testing" ) -var ( - cdc = codecstd.MakeCodec(simapp.ModuleBasics) - appCodec = codecstd.NewAppCodec(cdc) -) - -func init() { - authclient.Codec = appCodec -} func TestCLIKeysAddMultisig(t *testing.T) { t.Parallel() - f := InitFixtures(t) + f := helpers.InitFixtures(t) // key names order does not matter f.KeysAdd("msig1", "--multisig-threshold=2", - fmt.Sprintf("--multisig=%s,%s", keyBar, keyBaz)) + fmt.Sprintf("--multisig=%s,%s", helpers.KeyBar, helpers.KeyBaz)) ke1Address1 := f.KeysShow("msig1").Address f.KeysDelete("msig1") f.KeysAdd("msig2", "--multisig-threshold=2", - fmt.Sprintf("--multisig=%s,%s", keyBaz, keyBar)) + fmt.Sprintf("--multisig=%s,%s", helpers.KeyBaz, helpers.KeyBar)) require.Equal(t, ke1Address1, f.KeysShow("msig2").Address) f.KeysDelete("msig2") f.KeysAdd("msig3", "--multisig-threshold=2", - fmt.Sprintf("--multisig=%s,%s", keyBar, keyBaz), + fmt.Sprintf("--multisig=%s,%s", helpers.KeyBar, helpers.KeyBaz), "--nosort") f.KeysAdd("msig4", "--multisig-threshold=2", - fmt.Sprintf("--multisig=%s,%s", keyBaz, keyBar), + fmt.Sprintf("--multisig=%s,%s", helpers.KeyBaz, helpers.KeyBar), "--nosort") require.NotEqual(t, f.KeysShow("msig3").Address, f.KeysShow("msig4").Address) From bc88c768185f1a70dc0f9d0f6a6dc38c96e11d7c Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Tue, 21 Apr 2020 00:17:08 +0530 Subject: [PATCH 12/61] Added build-sim to Makefile --- Makefile | 2 +- cli_test/helpers/test_helpers.go | 7 ++++--- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/Makefile b/Makefile index 1b3cb1c13bb8..8ff13c9cb962 100644 --- a/Makefile +++ b/Makefile @@ -164,7 +164,7 @@ test-sim-benchmark-invariants: -Enabled=true -NumBlocks=1000 -BlockSize=200 \ -Period=1 -Commit=true -Seed=57 -v -timeout 24h -test-cli: +test-cli: build-sim @go test -mod=readonly -p 4 `go list ./cli_test/tests/...` -tags=cli_test -v .PHONY: \ diff --git a/cli_test/helpers/test_helpers.go b/cli_test/helpers/test_helpers.go index 01b1a220d750..aaf2ade3fbb7 100644 --- a/cli_test/helpers/test_helpers.go +++ b/cli_test/helpers/test_helpers.go @@ -3,14 +3,15 @@ package helpers import ( "encoding/json" "fmt" + "os" + "path/filepath" + "strings" + clientkeys "github.com/cosmos/cosmos-sdk/client/keys" "github.com/cosmos/cosmos-sdk/crypto/keyring" "github.com/cosmos/cosmos-sdk/tests" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/stretchr/testify/require" - "os" - "path/filepath" - "strings" ) var ( From baa4b606e644ea0b7ef6cd2c14dcea0a6fd9ebd9 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Tue, 21 Apr 2020 02:47:15 +0530 Subject: [PATCH 13/61] Added test-cli to circleci --- .circleci/config.yml | 7 +++++++ tests/test_cover.sh | 2 +- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index c15f654bf27c..1c4be971ba35 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -94,6 +94,13 @@ jobs: target: test-sim-multi-seed-long description: "Test multi-seed simulation (long)" + test-cli: + executor: golang + steps: + - make: + target: test-sim + description: "Test client integration" + update-swagger-docs: executor: golang steps: diff --git a/tests/test_cover.sh b/tests/test_cover.sh index 24f7804b5162..338bea07d212 100644 --- a/tests/test_cover.sh +++ b/tests/test_cover.sh @@ -1,7 +1,7 @@ #!/usr/bin/env bash set -e -PKGS=$(go list ./... | grep -v '/simapp') +PKGS=$(go list ./... | grep -v '/simapp' | grep -v '/cli_test') set -e echo "mode: atomic" > coverage.txt From 85fae472840495ebeed304df72e104c37846f631 Mon Sep 17 00:00:00 2001 From: atheesh Date: Tue, 21 Apr 2020 12:01:57 +0530 Subject: [PATCH 14/61] Added tests for staking txns --- cli_test/cli_test.go | 419 +++++++++++++++++++++++++++++++++++++++ cli_test/test_helpers.go | 135 +++++++++++++ 2 files changed, 554 insertions(+) diff --git a/cli_test/cli_test.go b/cli_test/cli_test.go index 0c33e9b9cba9..d610e0fef0e9 100644 --- a/cli_test/cli_test.go +++ b/cli_test/cli_test.go @@ -4,8 +4,12 @@ import ( "fmt" codecstd "github.com/cosmos/cosmos-sdk/codec/std" "github.com/cosmos/cosmos-sdk/simapp" + "github.com/cosmos/cosmos-sdk/tests" + sdk "github.com/cosmos/cosmos-sdk/types" authclient "github.com/cosmos/cosmos-sdk/x/auth/client" + "github.com/cosmos/cosmos-sdk/x/staking" "github.com/stretchr/testify/require" + "github.com/tendermint/tendermint/crypto/ed25519" "testing" ) @@ -17,6 +21,7 @@ var ( func init() { authclient.Codec = appCodec } + func TestCLIKeysAddMultisig(t *testing.T) { t.Parallel() f := InitFixtures(t) @@ -43,3 +48,417 @@ func TestCLIKeysAddMultisig(t *testing.T) { // Cleanup testing directories f.Cleanup() } + +func TestCLISend(t *testing.T) { + t.Parallel() + f := InitFixtures(t) + + // start gaiad server + proc := f.GDStart() + defer proc.Stop(false) + + // Save key addresses for later use + fooAddr := f.KeyAddress(keyFoo) + barAddr := f.KeyAddress(keyBar) + + startTokens := sdk.TokensFromConsensusPower(50) + require.Equal(t, startTokens, f.QueryBalances(fooAddr).AmountOf(denom)) + + sendTokens := sdk.TokensFromConsensusPower(10) + + // It does not allow to send in offline mode + success, _, stdErr := f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "-y", "--offline") + require.Contains(t, stdErr, "no RPC client is defined in offline mode") + require.False(f.T, success) + tests.WaitForNextNBlocksTM(1, f.Port) + + // Send some tokens from one account to the other + f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure account balances match expected + require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(denom)) + require.Equal(t, startTokens.Sub(sendTokens), f.QueryBalances(fooAddr).AmountOf(denom)) + + // Test --dry-run + success, _, _ = f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--dry-run") + require.True(t, success) + + // Test --generate-only + success, stdout, stderr := f.TxSend( + fooAddr.String(), barAddr, sdk.NewCoin(denom, sendTokens), "--generate-only=true", + ) + require.Empty(t, stderr) + require.True(t, success) + msg := unmarshalStdTx(f.T, stdout) + require.NotZero(t, msg.Fee.Gas) + require.Len(t, msg.Msgs, 1) + require.Len(t, msg.GetSignatures(), 0) + + // Check state didn't change + require.Equal(t, startTokens.Sub(sendTokens), f.QueryBalances(fooAddr).AmountOf(denom)) + + // test autosequencing + f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure account balances match expected + require.Equal(t, sendTokens.MulRaw(2), f.QueryBalances(barAddr).AmountOf(denom)) + require.Equal(t, startTokens.Sub(sendTokens.MulRaw(2)), f.QueryBalances(fooAddr).AmountOf(denom)) + + // test memo + f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--memo='testmemo'", "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure account balances match expected + require.Equal(t, sendTokens.MulRaw(3), f.QueryBalances(barAddr).AmountOf(denom)) + require.Equal(t, startTokens.Sub(sendTokens.MulRaw(3)), f.QueryBalances(fooAddr).AmountOf(denom)) + + f.Cleanup() +} + +//----------------------------------------------------------------------------------- +//staking tx + +func TestCLICreateValidator(t *testing.T) { + t.Parallel() + f := InitFixtures(t) + + // start gaiad server + proc := f.GDStart() + defer proc.Stop(false) + + barAddr := f.KeyAddress(keyBar) + barVal := sdk.ValAddress(barAddr) + + consPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) + + sendTokens := sdk.TokensFromConsensusPower(10) + f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(denom)) + + // Generate a create validator transaction and ensure correctness + success, stdout, stderr := f.TxStakingCreateValidator(barAddr.String(), consPubKey, sdk.NewInt64Coin(denom, 2), "--generate-only") + require.True(f.T, success) + require.Empty(f.T, stderr) + + msg := unmarshalStdTx(f.T, stdout) + require.NotZero(t, msg.Fee.Gas) + require.Equal(t, len(msg.Msgs), 1) + require.Equal(t, 0, len(msg.GetSignatures())) + + // Test --dry-run + newValTokens := sdk.TokensFromConsensusPower(2) + success, _, _ = f.TxStakingCreateValidator(barAddr.String(), consPubKey, sdk.NewCoin(denom, newValTokens), "--dry-run") + require.True(t, success) + + // Create the validator + f.TxStakingCreateValidator(keyBar, consPubKey, sdk.NewCoin(denom, newValTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure funds were deducted properly + require.Equal(t, sendTokens.Sub(newValTokens), f.QueryBalances(barAddr).AmountOf(denom)) + + // Ensure that validator state is as expected + validator := f.QueryStakingValidator(barVal) + require.Equal(t, validator.OperatorAddress, barVal) + require.True(sdk.IntEq(t, newValTokens, validator.Tokens)) + + // Query delegations to the validator + validatorDelegations := f.QueryStakingDelegationsTo(barVal) + require.Len(t, validatorDelegations, 1) + require.NotZero(t, validatorDelegations[0].Shares) + + // unbond a single share + unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(1)) + success = f.TxStakingUnbond(keyBar, unbondAmt.String(), barVal, "-y") + require.True(t, success) + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure bonded staking is correct + remainingTokens := newValTokens.Sub(unbondAmt.Amount) + validator = f.QueryStakingValidator(barVal) + require.Equal(t, remainingTokens, validator.Tokens) + + // Get unbonding delegations from the validator + validatorUbds := f.QueryStakingUnbondingDelegationsFrom(barVal) + require.Len(t, validatorUbds, 1) + require.Len(t, validatorUbds[0].Entries, 1) + require.Equal(t, remainingTokens.String(), validatorUbds[0].Entries[0].Balance.String()) + + f.Cleanup() +} + +func TestCLIEditValidator(t *testing.T) { + t.Parallel() + f := InitFixtures(t) + + // start gaiad server + proc := f.GDStart() + defer proc.Stop(false) + + barAddr := f.KeyAddress(keyBar) + barVal := sdk.ValAddress(barAddr) + + consPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) + + sendTokens := sdk.TokensFromConsensusPower(10) + f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(denom)) + + newValTokens := sdk.TokensFromConsensusPower(2) + + // Create the validator + f.TxStakingCreateValidator(keyBar, consPubKey, sdk.NewCoin(denom, newValTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure that validator state is as expected + validator := f.QueryStakingValidator(barVal) + require.Equal(t, validator.OperatorAddress, barVal) + require.True(sdk.IntEq(t, newValTokens, validator.Tokens)) + + // update moniker with test-edit + var updateMoniker = "test-edit" + if validator.Description.Moniker != "" { + updateMoniker = validator.Description.Moniker + "-" + updateMoniker + } + + // update details with test-details + var updateDetails = "test-details" + if validator.Description.Details != "" { + updateDetails = validator.Description.Details + "-" + updateDetails + } + + // update website with http://test-edit.co + var updateWebsite = "http://test-edit.co" + if validator.Description.Website != "" { + updateWebsite = validator.Description.Website + "(or)" + updateWebsite + } + + // Test --generate-only + success, stdout, stderr := f.TxStakingEditValidator(barAddr.String(), + fmt.Sprintf("--moniker=%s", updateMoniker), + fmt.Sprintf("--details=%s", updateDetails), + fmt.Sprintf("--website=%s", updateWebsite), + "--generate-only") + require.True(f.T, success) + require.Empty(f.T, stderr) + + msg := unmarshalStdTx(f.T, stdout) + require.NotZero(t, msg.Fee.Gas) + require.Equal(t, len(msg.Msgs), 1) + require.Equal(t, 0, len(msg.GetSignatures())) + + // Test --dry-run + success, _, _ = f.TxStakingEditValidator(barAddr.String(), + fmt.Sprintf("--moniker=%s", updateMoniker), + fmt.Sprintf("--details=%s", updateDetails), + fmt.Sprintf("--website=%s", updateWebsite), + "--dry-run") + require.True(t, success) + + // Note: Commission cannot be changed more than once within 24 hrs + // Edit validator's info + success, _, err := f.TxStakingEditValidator(keyBar, + fmt.Sprintf("--moniker=%s", updateMoniker), + fmt.Sprintf("--details=%s", updateDetails), + fmt.Sprintf("--website=%s", updateWebsite), + "-y") + + require.Equal(t, success, true) + require.Equal(t, err, "") + tests.WaitForNextNBlocksTM(1, f.Port) + + updatedValidator := f.QueryStakingValidator(barVal) + + // Ensure validator's moniker got changed + require.Equal(t, updatedValidator.Description.Moniker, updateMoniker) + + // Ensure validator's details got changed + require.Equal(t, updatedValidator.Description.Details, updateDetails) + + // Ensure validator's website got changed + require.Equal(t, updatedValidator.Description.Website, updateWebsite) + + f.Cleanup() +} + +func TestCLIDelegate(t *testing.T) { + t.Parallel() + f := InitFixtures(t) + + // start gaiad server + proc := f.GDStart() + defer proc.Stop(false) + + fooAddr := f.KeyAddress(keyFoo) + barAddr := f.KeyAddress(keyBar) + barVal := sdk.ValAddress(barAddr) + + consPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) + + sendTokens := sdk.TokensFromConsensusPower(10) + f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(denom)) + + newValTokens := sdk.TokensFromConsensusPower(2) + + // Create the validator + f.TxStakingCreateValidator(keyBar, consPubKey, sdk.NewCoin(denom, newValTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure that validator state is as expected + validator := f.QueryStakingValidator(barVal) + require.Equal(t, validator.OperatorAddress, barVal) + require.True(sdk.IntEq(t, newValTokens, validator.Tokens)) + + delegateTokens := sdk.TokensFromConsensusPower(5) + + // Test --generate-only + success, stdout, stderr := f.TxStakingDelegate(validator.OperatorAddress.String(), fooAddr.String(), sdk.NewCoin(denom, delegateTokens), "--generate-only") + require.Equal(t, success, true) + require.Empty(f.T, stderr) + + msg := unmarshalStdTx(f.T, stdout) + require.NotZero(t, msg.Fee.Gas) + require.Equal(t, len(msg.Msgs), 1) + require.Equal(t, 0, len(msg.GetSignatures())) + + // Test --dry-run + success, _, _ = f.TxStakingDelegate(validator.OperatorAddress.String(), fooAddr.String(), sdk.NewCoin(denom, delegateTokens), "--dry-run") + require.Equal(t, success, true) + + // Start delegate tokens form keyfoo + success, _, err := f.TxStakingDelegate(validator.OperatorAddress.String(), keyFoo, sdk.NewCoin(denom, delegateTokens), "-y") + require.Equal(t, success, true) + require.Equal(t, err, "") + + // Wait for the tx to commit into a block + tests.WaitForNextNBlocksTM(1, f.Port) + + // Read all delegations of a validator + validatorDelegations := f.QueryStakingDelegationsTo(barVal) + + // Check the length, since the there are only 2 delegations length should be equal to 2 + require.Len(t, validatorDelegations, 2) + delegatorAddress := f.KeysShow(keyFoo).Address + var delegatedAccount staking.Delegation + + for i := 0; i < len(validatorDelegations); i++ { + if validatorDelegations[i].DelegatorAddress.String() == delegatorAddress { + delegatedAccount = validatorDelegations[i] + break + } + } + + // Ensure the delegated amount should be greater than zero + require.NotZero(t, delegatedAccount.Shares) + + // Ensure the amount equal to the delegated balance + require.Equal(t, delegatedAccount.Shares, delegateTokens.ToDec()) + + f.Cleanup() +} + +func TestCLIRedelegate(t *testing.T) { + t.Parallel() + f := InitFixtures(t) + + // start gaiad server + proc := f.GDStart() + defer proc.Stop(false) + + // Create the 1st validator + barAddr := f.KeyAddress(keyBar) + srcValAddr := sdk.ValAddress(barAddr) + + srcPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) + + sendTokens := sdk.TokensFromConsensusPower(10) + f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure tokens sent to the dst address(i.e., barAddr) + require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(denom)) + + newValTokens := sdk.TokensFromConsensusPower(2) + + f.TxStakingCreateValidator(keyBar, srcPubKey, sdk.NewCoin(denom, newValTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure that validator1 state is as expected + srcVal := f.QueryStakingValidator(srcValAddr) + require.Equal(t, srcVal.OperatorAddress, srcValAddr) + require.True(sdk.IntEq(t, newValTokens, srcVal.Tokens)) + + // Create the 2nd validator + bazAddr := f.KeyAddress(keyBaz) + dstValAddr := sdk.ValAddress(bazAddr) + + dstPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) + f.TxSend(keyFoo, bazAddr, sdk.NewCoin(denom, sendTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure tokens sent to the dst address(i.e., bazAddr) + require.Equal(t, sendTokens, f.QueryBalances(bazAddr).AmountOf(denom)) + + success, _, err := f.TxStakingCreateValidator(keyBaz, dstPubKey, sdk.NewCoin(denom, newValTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure that validator2 state is as expected + dstVal := f.QueryStakingValidator(dstValAddr) + require.Equal(t, dstVal.OperatorAddress, dstValAddr) + require.True(sdk.IntEq(t, newValTokens, dstVal.Tokens)) + + redelegateValTokens := sdk.TokensFromConsensusPower(1) + + // Test --dry-run + success, _, _ = f.TxStakingReDelegate(srcVal.OperatorAddress.String(), dstVal.OperatorAddress.String(), + barAddr.String(), sdk.NewCoin(denom, redelegateValTokens), "--dry-run") + require.Equal(t, success, true) + + // Test --generate-only + success, stdout, stderr := f.TxStakingReDelegate(srcVal.OperatorAddress.String(), dstVal.OperatorAddress.String(), + barAddr.String(), sdk.NewCoin(denom, redelegateValTokens), "--generate-only") + require.Equal(t, success, true) + require.Empty(f.T, stderr) + + msg := unmarshalStdTx(f.T, stdout) + require.NotZero(t, msg.Fee.Gas) + require.Equal(t, len(msg.Msgs), 1) + require.Equal(t, 0, len(msg.GetSignatures())) + + success, _, err = f.TxStakingReDelegate(srcVal.OperatorAddress.String(), dstVal.OperatorAddress.String(), + keyBar, sdk.NewCoin(denom, redelegateValTokens), "-y") + + // Ensure the redelegate tx succeed + require.Equal(t, success, true) + require.Equal(t, err, "") + + tests.WaitForNextNBlocksTM(1, f.Port) + + // Query validator's info after redelegate + srcValDels := f.QueryStakingDelegationsTo(srcValAddr) + dstValDels := f.QueryStakingDelegationsTo(dstValAddr) + + delegatedAccount := findDelegateAccount(dstValDels, f.KeysShow(keyBar).Address) + // Ensure the delegated amount should be greater than zero + require.NotZero(t, delegatedAccount.Shares) + + // Ensure the amount equal to the redelegated balance + require.Equal(t, delegatedAccount.Shares, redelegateValTokens.ToDec()) + + delegatedAccount = findDelegateAccount(srcValDels, f.KeysShow(keyBar).Address) + // Ensure the delegated amount should be greater than zero + require.NotZero(t, delegatedAccount.Shares) + + // Ensure the amount equal subtracted delegated balance + require.Equal(t, delegatedAccount.Shares, newValTokens.Sub(redelegateValTokens).ToDec()) + f.Cleanup() +} diff --git a/cli_test/test_helpers.go b/cli_test/test_helpers.go index fee10ddf8a3b..610ad70bfa11 100644 --- a/cli_test/test_helpers.go +++ b/cli_test/test_helpers.go @@ -10,6 +10,8 @@ import ( "github.com/cosmos/cosmos-sdk/simapp" "github.com/cosmos/cosmos-sdk/tests" sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/auth" + "github.com/cosmos/cosmos-sdk/x/staking" "github.com/stretchr/testify/require" tmtypes "github.com/tendermint/tendermint/types" "io/ioutil" @@ -307,6 +309,90 @@ func (f *Fixtures) CLIConfig(key, value string, flags ...string) { executeWriteCheckErr(f.T, addFlags(cmd, flags)) } +//___________________________________________________________________________________ +// gaiacli tx send/sign/broadcast + +// TxSend is gaiacli tx send +func (f *Fixtures) TxSend(from string, to sdk.AccAddress, amount sdk.Coin, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx send --keyring-backend=test %s %s %s %v", f.SimcliBinary, from, + to, amount, f.Flags()) + return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +//___________________________________________________________________________________ +// gaiacli tx staking + +// TxStakingCreateValidator is gaiacli tx staking create-validator +func (f *Fixtures) TxStakingCreateValidator(from, consPubKey string, amount sdk.Coin, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx staking create-validator %v --keyring-backend=test --from=%s"+ + " --pubkey=%s", f.SimcliBinary, f.Flags(), from, consPubKey) + cmd += fmt.Sprintf(" --amount=%v --moniker=%v --commission-rate=%v", amount, from, "0.05") + cmd += fmt.Sprintf(" --commission-max-rate=%v --commission-max-change-rate=%v", "0.20", "0.10") + cmd += fmt.Sprintf(" --min-self-delegation=%v", "1") + return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +func (f *Fixtures) TxStakingEditValidator(from string, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx staking edit-validator %v --keyring-backend=test "+ + "--from=%s", f.SimcliBinary, f.Flags(), from) + return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +func (f *Fixtures) TxStakingDelegate(validatorOperatorAddress, from string, amount sdk.Coin, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx staking delegate %s %v %v --keyring-backend=test "+ + "--from=%s", f.SimcliBinary, validatorOperatorAddress, amount, f.Flags(), from) + return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +func (f *Fixtures) TxStakingReDelegate(srcOperatorAddress, dstOperatorAddress, from string, amount sdk.Coin, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx staking redelegate %s %s %v %v --keyring-backend=test "+ + "--from=%s", f.SimcliBinary, srcOperatorAddress, dstOperatorAddress, amount, f.Flags(), from) + return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +// TxStakingUnbond is gaiacli tx staking unbond +func (f *Fixtures) TxStakingUnbond(from, shares string, validator sdk.ValAddress, flags ...string) bool { + cmd := fmt.Sprintf("%s tx staking unbond --keyring-backend=test %s %v --from=%s %v", + f.SimcliBinary, validator, shares, from, f.Flags()) + return executeWrite(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +//___________________________________________________________________________________ +// gaiacli query staking + +// QueryStakingValidator is gaiacli query staking validator +func (f *Fixtures) QueryStakingValidator(valAddr sdk.ValAddress, flags ...string) staking.Validator { + cmd := fmt.Sprintf("%s query staking validator %s %v", f.SimcliBinary, valAddr, f.Flags()) + out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + var validator staking.Validator + + err := cdc.UnmarshalJSON([]byte(out), &validator) + require.NoError(f.T, err, "out %v\n, err %v", out, err) + return validator +} + +// QueryStakingUnbondingDelegationsFrom is gaiacli query staking unbonding-delegations-from +func (f *Fixtures) QueryStakingUnbondingDelegationsFrom(valAddr sdk.ValAddress, flags ...string) []staking.UnbondingDelegation { + cmd := fmt.Sprintf("%s query staking unbonding-delegations-from %s %v", f.SimcliBinary, valAddr, f.Flags()) + out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + var ubds []staking.UnbondingDelegation + + err := cdc.UnmarshalJSON([]byte(out), &ubds) + require.NoError(f.T, err, "out %v\n, err %v", out, err) + return ubds +} + +// QueryStakingDelegationsTo is gaiacli query staking delegations-to +func (f *Fixtures) QueryStakingDelegationsTo(valAddr sdk.ValAddress, flags ...string) []staking.Delegation { + cmd := fmt.Sprintf("%s query staking delegations-to %s %v", f.SimcliBinary, valAddr, f.Flags()) + out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + var delegations []staking.Delegation + + err := cdc.UnmarshalJSON([]byte(out), &delegations) + require.NoError(f.T, err, "out %v\n, err %v", out, err) + return delegations +} + //___________________________________________________________________________________ // executors @@ -349,6 +435,38 @@ func executeWriteRetStdStreams(t *testing.T, cmdStr string, writes ...string) (b return proc.ExitState.Success(), string(stdout), string(stderr) } +//___________________________________________________________________________________ +// gaiacli query account + +// QueryAccount is gaiacli query account +func (f *Fixtures) QueryAccount(address sdk.AccAddress, flags ...string) auth.BaseAccount { + cmd := fmt.Sprintf("%s query account %s %v", f.SimcliBinary, address, f.Flags()) + out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + var initRes map[string]json.RawMessage + err := json.Unmarshal([]byte(out), &initRes) + require.NoError(f.T, err, "out %v, err %v", out, err) + value := initRes["value"] + var acc auth.BaseAccount + cdc := codec.New() + codec.RegisterCrypto(cdc) + err = cdc.UnmarshalJSON(value, &acc) + require.NoError(f.T, err, "value %v, err %v", string(value), err) + return acc +} + +// QueryBalances executes the bank query balances command for a given address and +// flag set. +func (f *Fixtures) QueryBalances(address sdk.AccAddress, flags ...string) sdk.Coins { + cmd := fmt.Sprintf("%s query bank balances %s %v", f.SimcliBinary, address, f.Flags()) + out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + + var balances sdk.Coins + + require.NoError(f.T, cdc.UnmarshalJSON([]byte(out), &balances), "out %v\n", out) + + return balances +} + //___________________________________________________________________________________ // utils @@ -358,3 +476,20 @@ func addFlags(cmd string, flags []string) string { } return strings.TrimSpace(cmd) } + +//nolint:deadcode,unused +func unmarshalStdTx(t *testing.T, s string) (stdTx auth.StdTx) { + + require.Nil(t, cdc.UnmarshalJSON([]byte(s), &stdTx)) + return +} + +func findDelegateAccount(validatorDelegations []staking.Delegation, delegatorAddress string) staking.Delegation { + for i := 0; i < len(validatorDelegations); i++ { + if validatorDelegations[i].DelegatorAddress.String() == delegatorAddress { + return validatorDelegations[i]; + } + } + + return staking.Delegation{} +} From 5d33cbd794b5c551cdf4e8350e1893322252e3ce Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Tue, 21 Apr 2020 12:48:44 +0530 Subject: [PATCH 15/61] Addressed format issues --- .circleci/config.yml | 7 -- .github/workflows/test.yml | 7 ++ cli_test/helpers/executors.go | 6 +- cli_test/helpers/fixtures.go | 12 +- .../helpers/{test_helpers.go => helpers.go} | 116 +++++++++++++++++- cli_test/helpers/init.go | 3 +- cli_test/tests/keys_test.go | 6 +- 7 files changed, 139 insertions(+), 18 deletions(-) rename cli_test/helpers/{test_helpers.go => helpers.go} (54%) diff --git a/.circleci/config.yml b/.circleci/config.yml index 1c4be971ba35..c15f654bf27c 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -94,13 +94,6 @@ jobs: target: test-sim-multi-seed-long description: "Test multi-seed simulation (long)" - test-cli: - executor: golang - steps: - - make: - target: test-sim - description: "Test client integration" - update-swagger-docs: executor: golang steps: diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index e0d07115b90e..748676fef5fe 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -38,3 +38,10 @@ jobs: with: file: ./coverage.txt # optional fail_ci_if_error: true + + test-cli: + executor: golang + steps: + - name: cli-test + run: | + make test-sim \ No newline at end of file diff --git a/cli_test/helpers/executors.go b/cli_test/helpers/executors.go index 54bdc19af38a..5a642b1f2fa1 100644 --- a/cli_test/helpers/executors.go +++ b/cli_test/helpers/executors.go @@ -2,9 +2,11 @@ package helpers import ( "fmt" - "github.com/cosmos/cosmos-sdk/tests" - "github.com/stretchr/testify/require" "testing" + + "github.com/stretchr/testify/require" + + "github.com/cosmos/cosmos-sdk/tests" ) func executeWriteCheckErr(t *testing.T, cmdStr string, writes ...string) { diff --git a/cli_test/helpers/fixtures.go b/cli_test/helpers/fixtures.go index 25accbc7a98d..c465bfffb29c 100644 --- a/cli_test/helpers/fixtures.go +++ b/cli_test/helpers/fixtures.go @@ -1,15 +1,17 @@ package helpers import ( - "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/server" - "github.com/cosmos/cosmos-sdk/simapp" - "github.com/stretchr/testify/require" - tmtypes "github.com/tendermint/tendermint/types" "io/ioutil" "os" "path/filepath" "testing" + + "github.com/stretchr/testify/require" + tmtypes "github.com/tendermint/tendermint/types" + + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/server" + "github.com/cosmos/cosmos-sdk/simapp" ) // Fixtures is used to setup the testing environment diff --git a/cli_test/helpers/test_helpers.go b/cli_test/helpers/helpers.go similarity index 54% rename from cli_test/helpers/test_helpers.go rename to cli_test/helpers/helpers.go index aaf2ade3fbb7..2ac524c04a0a 100644 --- a/cli_test/helpers/test_helpers.go +++ b/cli_test/helpers/helpers.go @@ -7,11 +7,14 @@ import ( "path/filepath" "strings" + "github.com/cosmos/cosmos-sdk/x/staking" + + "github.com/stretchr/testify/require" + clientkeys "github.com/cosmos/cosmos-sdk/client/keys" "github.com/cosmos/cosmos-sdk/crypto/keyring" "github.com/cosmos/cosmos-sdk/tests" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/stretchr/testify/require" ) var ( @@ -163,3 +166,114 @@ func (f *Fixtures) CLIConfig(key, value string, flags ...string) { cmd := fmt.Sprintf("%s config --home=%s %s %s", f.SimcliBinary, f.SimcliHome, key, value) executeWriteCheckErr(f.T, addFlags(cmd, flags)) } + +// TxSend is gaiacli tx send +func (f *Fixtures) TxSend(from string, to sdk.AccAddress, amount sdk.Coin, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx send --keyring-backend=test %s %s %s %v", f.SimcliBinary, from, + to, amount, f.Flags()) + return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +// TxSign is gaiacli tx sign +func (f *Fixtures) TxSign(signer, fileName string, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx sign %v --keyring-backend=test --from=%s %v", f.SimcliBinary, + f.Flags(), signer, fileName) + return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +// TxBroadcast is gaiacli tx broadcast +func (f *Fixtures) TxBroadcast(fileName string, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx broadcast %v %v", f.SimcliBinary, f.Flags(), fileName) + return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +// TxEncode is gaiacli tx encode +func (f *Fixtures) TxEncode(fileName string, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx encode %v %v", f.SimcliBinary, f.Flags(), fileName) + return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +// TxMultisign is gaiacli tx multisign +func (f *Fixtures) TxMultisign(fileName, name string, signaturesFiles []string, + flags ...string) (bool, string, string) { + + cmd := fmt.Sprintf("%s tx multisign --keyring-backend=test %v %s %s %s", f.SimcliBinary, f.Flags(), + fileName, name, strings.Join(signaturesFiles, " "), + ) + return executeWriteRetStdStreams(f.T, addFlags(cmd, flags)) +} + +//___________________________________________________________________________________ +// gaiacli tx staking + +// TxStakingCreateValidator is gaiacli tx staking create-validator +func (f *Fixtures) TxStakingCreateValidator(from, consPubKey string, amount sdk.Coin, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx staking create-validator %v --keyring-backend=test --from=%s"+ + " --pubkey=%s", f.SimcliBinary, f.Flags(), from, consPubKey) + cmd += fmt.Sprintf(" --amount=%v --moniker=%v --commission-rate=%v", amount, from, "0.05") + cmd += fmt.Sprintf(" --commission-max-rate=%v --commission-max-change-rate=%v", "0.20", "0.10") + cmd += fmt.Sprintf(" --min-self-delegation=%v", "1") + return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +// TxStakingUnbond is gaiacli tx staking unbond +func (f *Fixtures) TxStakingUnbond(from, shares string, validator sdk.ValAddress, flags ...string) bool { + cmd := fmt.Sprintf("%s tx staking unbond --keyring-backend=test %s %v --from=%s %v", + f.SimcliBinary, validator, shares, from, f.Flags()) + return executeWrite(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +// QueryStakingValidator is gaiacli query staking validator +func (f *Fixtures) QueryStakingValidator(valAddr sdk.ValAddress, flags ...string) staking.Validator { + cmd := fmt.Sprintf("%s query staking validator %s %v", f.SimcliBinary, valAddr, f.Flags()) + out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + var validator staking.Validator + + err := cdc.UnmarshalJSON([]byte(out), &validator) + require.NoError(f.T, err, "out %v\n, err %v", out, err) + return validator +} + +// QueryStakingUnbondingDelegationsFrom is gaiacli query staking unbonding-delegations-from +func (f *Fixtures) QueryStakingUnbondingDelegationsFrom(valAddr sdk.ValAddress, flags ...string) []staking.UnbondingDelegation { + cmd := fmt.Sprintf("%s query staking unbonding-delegations-from %s %v", f.SimcliBinary, valAddr, f.Flags()) + out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + var ubds []staking.UnbondingDelegation + + err := cdc.UnmarshalJSON([]byte(out), &ubds) + require.NoError(f.T, err, "out %v\n, err %v", out, err) + return ubds +} + +// QueryStakingDelegationsTo is gaiacli query staking delegations-to +func (f *Fixtures) QueryStakingDelegationsTo(valAddr sdk.ValAddress, flags ...string) []staking.Delegation { + cmd := fmt.Sprintf("%s query staking delegations-to %s %v", f.SimcliBinary, valAddr, f.Flags()) + out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + var delegations []staking.Delegation + + err := cdc.UnmarshalJSON([]byte(out), &delegations) + require.NoError(f.T, err, "out %v\n, err %v", out, err) + return delegations +} + +// QueryStakingPool is gaiacli query staking pool +func (f *Fixtures) QueryStakingPool(flags ...string) staking.Pool { + cmd := fmt.Sprintf("%s query staking pool %v", f.SimcliBinary, f.Flags()) + out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + var pool staking.Pool + + err := cdc.UnmarshalJSON([]byte(out), &pool) + require.NoError(f.T, err, "out %v\n, err %v", out, err) + return pool +} + +// QueryStakingParameters is gaiacli query staking parameters +func (f *Fixtures) QueryStakingParameters(flags ...string) staking.Params { + cmd := fmt.Sprintf("%s query staking params %v", f.SimcliBinary, f.Flags()) + out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + var params staking.Params + + err := cdc.UnmarshalJSON([]byte(out), ¶ms) + require.NoError(f.T, err, "out %v\n, err %v", out, err) + return params +} diff --git a/cli_test/helpers/init.go b/cli_test/helpers/init.go index 337de26f2dba..5bcd0996d581 100644 --- a/cli_test/helpers/init.go +++ b/cli_test/helpers/init.go @@ -2,10 +2,11 @@ package helpers import ( "fmt" - "github.com/stretchr/testify/require" "os" "testing" "time" + + "github.com/stretchr/testify/require" ) // InitFixtures is called at the beginning of a test and initializes a chain diff --git a/cli_test/tests/keys_test.go b/cli_test/tests/keys_test.go index ae8fdd3a2c05..f34800fbda9c 100644 --- a/cli_test/tests/keys_test.go +++ b/cli_test/tests/keys_test.go @@ -2,9 +2,11 @@ package tests import ( "fmt" - "github.com/cosmos/cosmos-sdk/cli_test/helpers" - "github.com/stretchr/testify/require" "testing" + + "github.com/stretchr/testify/require" + + "github.com/cosmos/cosmos-sdk/cli_test/helpers" ) func TestCLIKeysAddMultisig(t *testing.T) { From 61b6692c118daed299ffcd8dfc4379d9b5de132d Mon Sep 17 00:00:00 2001 From: atheesh Date: Tue, 21 Apr 2020 16:32:03 +0530 Subject: [PATCH 16/61] refctored tests code --- cli_test/cli_test.go | 78 ++++++++++++++++---------------------------- 1 file changed, 29 insertions(+), 49 deletions(-) diff --git a/cli_test/cli_test.go b/cli_test/cli_test.go index d610e0fef0e9..72513f5908b5 100644 --- a/cli_test/cli_test.go +++ b/cli_test/cli_test.go @@ -296,28 +296,23 @@ func TestCLIDelegate(t *testing.T) { defer proc.Stop(false) fooAddr := f.KeyAddress(keyFoo) - barAddr := f.KeyAddress(keyBar) - barVal := sdk.ValAddress(barAddr) + fooVal := sdk.ValAddress(fooAddr) - consPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) + barAddr := f.KeyAddress(keyBar) + // Send some coins to bar address to delegate sendTokens := sdk.TokensFromConsensusPower(10) f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "-y") tests.WaitForNextNBlocksTM(1, f.Port) + // Ensure the tx got success require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(denom)) - newValTokens := sdk.TokensFromConsensusPower(2) - - // Create the validator - f.TxStakingCreateValidator(keyBar, consPubKey, sdk.NewCoin(denom, newValTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure that validator state is as expected - validator := f.QueryStakingValidator(barVal) - require.Equal(t, validator.OperatorAddress, barVal) - require.True(sdk.IntEq(t, newValTokens, validator.Tokens)) + // Fetch already existed validator foo + validator := f.QueryStakingValidator(fooVal) + require.Equal(t, validator.OperatorAddress, fooVal) + // tokens to be delegated delegateTokens := sdk.TokensFromConsensusPower(5) // Test --generate-only @@ -335,7 +330,7 @@ func TestCLIDelegate(t *testing.T) { require.Equal(t, success, true) // Start delegate tokens form keyfoo - success, _, err := f.TxStakingDelegate(validator.OperatorAddress.String(), keyFoo, sdk.NewCoin(denom, delegateTokens), "-y") + success, _, err := f.TxStakingDelegate(validator.OperatorAddress.String(), keyBar, sdk.NewCoin(denom, delegateTokens), "-y") require.Equal(t, success, true) require.Equal(t, err, "") @@ -343,19 +338,14 @@ func TestCLIDelegate(t *testing.T) { tests.WaitForNextNBlocksTM(1, f.Port) // Read all delegations of a validator - validatorDelegations := f.QueryStakingDelegationsTo(barVal) + validatorDelegations := f.QueryStakingDelegationsTo(fooVal) // Check the length, since the there are only 2 delegations length should be equal to 2 require.Len(t, validatorDelegations, 2) - delegatorAddress := f.KeysShow(keyFoo).Address + delegatorAddress := f.KeysShow(keyBar).Address var delegatedAccount staking.Delegation - for i := 0; i < len(validatorDelegations); i++ { - if validatorDelegations[i].DelegatorAddress.String() == delegatorAddress { - delegatedAccount = validatorDelegations[i] - break - } - } + delegatedAccount = findDelegateAccount(validatorDelegations, delegatorAddress) // Ensure the delegated amount should be greater than zero require.NotZero(t, delegatedAccount.Shares) @@ -374,21 +364,31 @@ func TestCLIRedelegate(t *testing.T) { proc := f.GDStart() defer proc.Stop(false) - // Create the 1st validator + // Get the already created validator keep it as dst val + fooAddr := f.KeyAddress(keyFoo) + dstValAddr := sdk.ValAddress(fooAddr) + + // Ensure that validator2 state is as expected + dstVal := f.QueryStakingValidator(dstValAddr) + require.Equal(t, dstVal.OperatorAddress, dstValAddr) + + redelegateValTokens := sdk.TokensFromConsensusPower(1) + + // create the src validator barAddr := f.KeyAddress(keyBar) srcValAddr := sdk.ValAddress(barAddr) + sendTokens := sdk.TokensFromConsensusPower(10) + newValTokens := sdk.TokensFromConsensusPower(2) + srcPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) - sendTokens := sdk.TokensFromConsensusPower(10) f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "-y") tests.WaitForNextNBlocksTM(1, f.Port) // Ensure tokens sent to the dst address(i.e., barAddr) require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(denom)) - newValTokens := sdk.TokensFromConsensusPower(2) - f.TxStakingCreateValidator(keyBar, srcPubKey, sdk.NewCoin(denom, newValTokens), "-y") tests.WaitForNextNBlocksTM(1, f.Port) @@ -397,29 +397,8 @@ func TestCLIRedelegate(t *testing.T) { require.Equal(t, srcVal.OperatorAddress, srcValAddr) require.True(sdk.IntEq(t, newValTokens, srcVal.Tokens)) - // Create the 2nd validator - bazAddr := f.KeyAddress(keyBaz) - dstValAddr := sdk.ValAddress(bazAddr) - - dstPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) - f.TxSend(keyFoo, bazAddr, sdk.NewCoin(denom, sendTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure tokens sent to the dst address(i.e., bazAddr) - require.Equal(t, sendTokens, f.QueryBalances(bazAddr).AmountOf(denom)) - - success, _, err := f.TxStakingCreateValidator(keyBaz, dstPubKey, sdk.NewCoin(denom, newValTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure that validator2 state is as expected - dstVal := f.QueryStakingValidator(dstValAddr) - require.Equal(t, dstVal.OperatorAddress, dstValAddr) - require.True(sdk.IntEq(t, newValTokens, dstVal.Tokens)) - - redelegateValTokens := sdk.TokensFromConsensusPower(1) - // Test --dry-run - success, _, _ = f.TxStakingReDelegate(srcVal.OperatorAddress.String(), dstVal.OperatorAddress.String(), + success, _, _ := f.TxStakingReDelegate(srcVal.OperatorAddress.String(), dstVal.OperatorAddress.String(), barAddr.String(), sdk.NewCoin(denom, redelegateValTokens), "--dry-run") require.Equal(t, success, true) @@ -434,7 +413,7 @@ func TestCLIRedelegate(t *testing.T) { require.Equal(t, len(msg.Msgs), 1) require.Equal(t, 0, len(msg.GetSignatures())) - success, _, err = f.TxStakingReDelegate(srcVal.OperatorAddress.String(), dstVal.OperatorAddress.String(), + success, _, err := f.TxStakingReDelegate(srcVal.OperatorAddress.String(), dstVal.OperatorAddress.String(), keyBar, sdk.NewCoin(denom, redelegateValTokens), "-y") // Ensure the redelegate tx succeed @@ -460,5 +439,6 @@ func TestCLIRedelegate(t *testing.T) { // Ensure the amount equal subtracted delegated balance require.Equal(t, delegatedAccount.Shares, newValTokens.Sub(redelegateValTokens).ToDec()) + f.Cleanup() } From 025867568143cbb111c05418c9b26d9fa711e9fe Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Wed, 22 Apr 2020 01:35:31 +0530 Subject: [PATCH 17/61] Added tests for send, staking --- cli_test/helpers/fixtures.go | 6 +- cli_test/helpers/helpers.go | 65 ++++- cli_test/helpers/utils.go | 25 +- cli_test/tests/keys_test.go | 414 ------------------------------- cli_test/tests/send_test.go | 78 ++++++ cli_test/tests/staking_test.go | 358 ++++++++++++++++++++++++++ {tests => contrib}/test_cover.sh | 0 7 files changed, 522 insertions(+), 424 deletions(-) create mode 100644 cli_test/tests/send_test.go create mode 100644 cli_test/tests/staking_test.go rename {tests => contrib}/test_cover.sh (100%) diff --git a/cli_test/helpers/fixtures.go b/cli_test/helpers/fixtures.go index c465bfffb29c..2b5850153eaa 100644 --- a/cli_test/helpers/fixtures.go +++ b/cli_test/helpers/fixtures.go @@ -26,6 +26,7 @@ type Fixtures struct { SimdHome string SimcliHome string P2PAddr string + Cdc *codec.Codec T *testing.T } @@ -40,6 +41,7 @@ func NewFixtures(t *testing.T) *Fixtures { p2pAddr, _, err := server.FreeTCPAddr() require.NoError(t, err) + cdc := codec.New() buildDir := os.Getenv("BUILDDIR") if buildDir == "" { buildDir, err = filepath.Abs("../../build/") @@ -56,6 +58,7 @@ func NewFixtures(t *testing.T) *Fixtures { SimcliHome: filepath.Join(tmpDir, ".simcli"), RPCAddr: servAddr, P2PAddr: p2pAddr, + Cdc: cdc, Port: port, } } @@ -67,11 +70,10 @@ func (f Fixtures) GenesisFile() string { // GenesisFile returns the application's genesis state func (f Fixtures) GenesisState() simapp.GenesisState { - cdc := codec.New() genDoc, err := tmtypes.GenesisDocFromFile(f.GenesisFile()) require.NoError(f.T, err) var appState simapp.GenesisState - require.NoError(f.T, cdc.UnmarshalJSON(genDoc.AppState, &appState)) + require.NoError(f.T, f.Cdc.UnmarshalJSON(genDoc.AppState, &appState)) return appState } diff --git a/cli_test/helpers/helpers.go b/cli_test/helpers/helpers.go index 2ac524c04a0a..ec8f3d0a1059 100644 --- a/cli_test/helpers/helpers.go +++ b/cli_test/helpers/helpers.go @@ -3,12 +3,13 @@ package helpers import ( "encoding/json" "fmt" + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/x/auth" + "github.com/cosmos/cosmos-sdk/x/staking" "os" "path/filepath" "strings" - "github.com/cosmos/cosmos-sdk/x/staking" - "github.com/stretchr/testify/require" clientkeys "github.com/cosmos/cosmos-sdk/client/keys" @@ -216,6 +217,24 @@ func (f *Fixtures) TxStakingCreateValidator(from, consPubKey string, amount sdk. return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) } +func (f *Fixtures) TxStakingEditValidator(from string, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx staking edit-validator %v --keyring-backend=test "+ + "--from=%s", f.SimcliBinary, f.Flags(), from) + return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +func (f *Fixtures) TxStakingDelegate(validatorOperatorAddress, from string, amount sdk.Coin, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx staking delegate %s %v %v --keyring-backend=test "+ + "--from=%s", f.SimcliBinary, validatorOperatorAddress, amount, f.Flags(), from) + return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +func (f *Fixtures) TxStakingReDelegate(srcOperatorAddress, dstOperatorAddress, from string, amount sdk.Coin, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx staking redelegate %s %s %v %v --keyring-backend=test "+ + "--from=%s", f.SimcliBinary, srcOperatorAddress, dstOperatorAddress, amount, f.Flags(), from) + return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + // TxStakingUnbond is gaiacli tx staking unbond func (f *Fixtures) TxStakingUnbond(from, shares string, validator sdk.ValAddress, flags ...string) bool { cmd := fmt.Sprintf("%s tx staking unbond --keyring-backend=test %s %v --from=%s %v", @@ -229,7 +248,7 @@ func (f *Fixtures) QueryStakingValidator(valAddr sdk.ValAddress, flags ...string out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") var validator staking.Validator - err := cdc.UnmarshalJSON([]byte(out), &validator) + err := f.Cdc.UnmarshalJSON([]byte(out), &validator) require.NoError(f.T, err, "out %v\n, err %v", out, err) return validator } @@ -240,7 +259,7 @@ func (f *Fixtures) QueryStakingUnbondingDelegationsFrom(valAddr sdk.ValAddress, out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") var ubds []staking.UnbondingDelegation - err := cdc.UnmarshalJSON([]byte(out), &ubds) + err := f.Cdc.UnmarshalJSON([]byte(out), &ubds) require.NoError(f.T, err, "out %v\n, err %v", out, err) return ubds } @@ -251,7 +270,7 @@ func (f *Fixtures) QueryStakingDelegationsTo(valAddr sdk.ValAddress, flags ...st out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") var delegations []staking.Delegation - err := cdc.UnmarshalJSON([]byte(out), &delegations) + err := f.Cdc.UnmarshalJSON([]byte(out), &delegations) require.NoError(f.T, err, "out %v\n, err %v", out, err) return delegations } @@ -262,7 +281,7 @@ func (f *Fixtures) QueryStakingPool(flags ...string) staking.Pool { out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") var pool staking.Pool - err := cdc.UnmarshalJSON([]byte(out), &pool) + err := f.Cdc.UnmarshalJSON([]byte(out), &pool) require.NoError(f.T, err, "out %v\n, err %v", out, err) return pool } @@ -273,7 +292,39 @@ func (f *Fixtures) QueryStakingParameters(flags ...string) staking.Params { out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") var params staking.Params - err := cdc.UnmarshalJSON([]byte(out), ¶ms) + err := f.Cdc.UnmarshalJSON([]byte(out), ¶ms) require.NoError(f.T, err, "out %v\n, err %v", out, err) return params } + +//___________________________________________________________________________________ +// gaiacli query account + +// QueryAccount is gaiacli query account +func (f *Fixtures) QueryAccount(address sdk.AccAddress, flags ...string) auth.BaseAccount { + cmd := fmt.Sprintf("%s query account %s %v", f.SimcliBinary, address, f.Flags()) + out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + var initRes map[string]json.RawMessage + err := json.Unmarshal([]byte(out), &initRes) + require.NoError(f.T, err, "out %v, err %v", out, err) + value := initRes["value"] + var acc auth.BaseAccount + cdc := codec.New() + codec.RegisterCrypto(cdc) + err = cdc.UnmarshalJSON(value, &acc) + require.NoError(f.T, err, "value %v, err %v", string(value), err) + return acc +} + +// QueryBalances executes the bank query balances command for a given address and +// flag set. +func (f *Fixtures) QueryBalances(address sdk.AccAddress, flags ...string) sdk.Coins { + cmd := fmt.Sprintf("%s query bank balances %s %v", f.SimcliBinary, address, f.Flags()) + out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + + var balances sdk.Coins + + require.NoError(f.T, f.Cdc.UnmarshalJSON([]byte(out), &balances), "out %v\n", out) + + return balances +} diff --git a/cli_test/helpers/utils.go b/cli_test/helpers/utils.go index b9676270d70e..39debff9d878 100644 --- a/cli_test/helpers/utils.go +++ b/cli_test/helpers/utils.go @@ -1,6 +1,13 @@ package helpers -import "strings" +import ( + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/x/auth" + "github.com/cosmos/cosmos-sdk/x/staking" + "github.com/stretchr/testify/require" + "strings" + "testing" +) func addFlags(cmd string, flags []string) string { for _, f := range flags { @@ -8,3 +15,19 @@ func addFlags(cmd string, flags []string) string { } return strings.TrimSpace(cmd) } + +//nolint:deadcode,unused +func UnmarshalStdTx(t *testing.T, c *codec.Codec, s string) (stdTx auth.StdTx) { + require.Nil(t, c.UnmarshalJSON([]byte(s), &stdTx)) + return +} + +func FindDelegateAccount(validatorDelegations []staking.Delegation, delegatorAddress string) staking.Delegation { + for i := 0; i < len(validatorDelegations); i++ { + if validatorDelegations[i].DelegatorAddress.String() == delegatorAddress { + return validatorDelegations[i] + } + } + + return staking.Delegation{} +} diff --git a/cli_test/tests/keys_test.go b/cli_test/tests/keys_test.go index 474ab0a30c07..f34800fbda9c 100644 --- a/cli_test/tests/keys_test.go +++ b/cli_test/tests/keys_test.go @@ -35,417 +35,3 @@ func TestCLIKeysAddMultisig(t *testing.T) { // Cleanup testing directories f.Cleanup() } - -func TestCLISend(t *testing.T) { - t.Parallel() - f := InitFixtures(t) - - // start gaiad server - proc := f.GDStart() - defer proc.Stop(false) - - // Save key addresses for later use - fooAddr := f.KeyAddress(keyFoo) - barAddr := f.KeyAddress(keyBar) - - startTokens := sdk.TokensFromConsensusPower(50) - require.Equal(t, startTokens, f.QueryBalances(fooAddr).AmountOf(denom)) - - sendTokens := sdk.TokensFromConsensusPower(10) - - // It does not allow to send in offline mode - success, _, stdErr := f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "-y", "--offline") - require.Contains(t, stdErr, "no RPC client is defined in offline mode") - require.False(f.T, success) - tests.WaitForNextNBlocksTM(1, f.Port) - - // Send some tokens from one account to the other - f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure account balances match expected - require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(denom)) - require.Equal(t, startTokens.Sub(sendTokens), f.QueryBalances(fooAddr).AmountOf(denom)) - - // Test --dry-run - success, _, _ = f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--dry-run") - require.True(t, success) - - // Test --generate-only - success, stdout, stderr := f.TxSend( - fooAddr.String(), barAddr, sdk.NewCoin(denom, sendTokens), "--generate-only=true", - ) - require.Empty(t, stderr) - require.True(t, success) - msg := unmarshalStdTx(f.T, stdout) - require.NotZero(t, msg.Fee.Gas) - require.Len(t, msg.Msgs, 1) - require.Len(t, msg.GetSignatures(), 0) - - // Check state didn't change - require.Equal(t, startTokens.Sub(sendTokens), f.QueryBalances(fooAddr).AmountOf(denom)) - - // test autosequencing - f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure account balances match expected - require.Equal(t, sendTokens.MulRaw(2), f.QueryBalances(barAddr).AmountOf(denom)) - require.Equal(t, startTokens.Sub(sendTokens.MulRaw(2)), f.QueryBalances(fooAddr).AmountOf(denom)) - - // test memo - f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--memo='testmemo'", "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure account balances match expected - require.Equal(t, sendTokens.MulRaw(3), f.QueryBalances(barAddr).AmountOf(denom)) - require.Equal(t, startTokens.Sub(sendTokens.MulRaw(3)), f.QueryBalances(fooAddr).AmountOf(denom)) - - f.Cleanup() -} - -//----------------------------------------------------------------------------------- -//staking tx - -func TestCLICreateValidator(t *testing.T) { - t.Parallel() - f := InitFixtures(t) - - // start gaiad server - proc := f.GDStart() - defer proc.Stop(false) - - barAddr := f.KeyAddress(keyBar) - barVal := sdk.ValAddress(barAddr) - - consPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) - - sendTokens := sdk.TokensFromConsensusPower(10) - f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(denom)) - - // Generate a create validator transaction and ensure correctness - success, stdout, stderr := f.TxStakingCreateValidator(barAddr.String(), consPubKey, sdk.NewInt64Coin(denom, 2), "--generate-only") - require.True(f.T, success) - require.Empty(f.T, stderr) - - msg := unmarshalStdTx(f.T, stdout) - require.NotZero(t, msg.Fee.Gas) - require.Equal(t, len(msg.Msgs), 1) - require.Equal(t, 0, len(msg.GetSignatures())) - - // Test --dry-run - newValTokens := sdk.TokensFromConsensusPower(2) - success, _, _ = f.TxStakingCreateValidator(barAddr.String(), consPubKey, sdk.NewCoin(denom, newValTokens), "--dry-run") - require.True(t, success) - - // Create the validator - f.TxStakingCreateValidator(keyBar, consPubKey, sdk.NewCoin(denom, newValTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure funds were deducted properly - require.Equal(t, sendTokens.Sub(newValTokens), f.QueryBalances(barAddr).AmountOf(denom)) - - // Ensure that validator state is as expected - validator := f.QueryStakingValidator(barVal) - require.Equal(t, validator.OperatorAddress, barVal) - require.True(sdk.IntEq(t, newValTokens, validator.Tokens)) - - // Query delegations to the validator - validatorDelegations := f.QueryStakingDelegationsTo(barVal) - require.Len(t, validatorDelegations, 1) - require.NotZero(t, validatorDelegations[0].Shares) - - // unbond a single share - unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(1)) - success = f.TxStakingUnbond(keyBar, unbondAmt.String(), barVal, "-y") - require.True(t, success) - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure bonded staking is correct - remainingTokens := newValTokens.Sub(unbondAmt.Amount) - validator = f.QueryStakingValidator(barVal) - require.Equal(t, remainingTokens, validator.Tokens) - - // Get unbonding delegations from the validator - validatorUbds := f.QueryStakingUnbondingDelegationsFrom(barVal) - require.Len(t, validatorUbds, 1) - require.Len(t, validatorUbds[0].Entries, 1) - require.Equal(t, remainingTokens.String(), validatorUbds[0].Entries[0].Balance.String()) - - f.Cleanup() -} - -func TestCLIEditValidator(t *testing.T) { - t.Parallel() - f := InitFixtures(t) - - // start gaiad server - proc := f.GDStart() - defer proc.Stop(false) - - barAddr := f.KeyAddress(keyBar) - barVal := sdk.ValAddress(barAddr) - - consPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) - - sendTokens := sdk.TokensFromConsensusPower(10) - f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(denom)) - - newValTokens := sdk.TokensFromConsensusPower(2) - - // Create the validator - f.TxStakingCreateValidator(keyBar, consPubKey, sdk.NewCoin(denom, newValTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure that validator state is as expected - validator := f.QueryStakingValidator(barVal) - require.Equal(t, validator.OperatorAddress, barVal) - require.True(sdk.IntEq(t, newValTokens, validator.Tokens)) - - // update moniker with test-edit - var updateMoniker = "test-edit" - if validator.Description.Moniker != "" { - updateMoniker = validator.Description.Moniker + "-" + updateMoniker - } - - // update details with test-details - var updateDetails = "test-details" - if validator.Description.Details != "" { - updateDetails = validator.Description.Details + "-" + updateDetails - } - - // update website with http://test-edit.co - var updateWebsite = "http://test-edit.co" - if validator.Description.Website != "" { - updateWebsite = validator.Description.Website + "(or)" + updateWebsite - } - - // Test --generate-only - success, stdout, stderr := f.TxStakingEditValidator(barAddr.String(), - fmt.Sprintf("--moniker=%s", updateMoniker), - fmt.Sprintf("--details=%s", updateDetails), - fmt.Sprintf("--website=%s", updateWebsite), - "--generate-only") - require.True(f.T, success) - require.Empty(f.T, stderr) - - msg := unmarshalStdTx(f.T, stdout) - require.NotZero(t, msg.Fee.Gas) - require.Equal(t, len(msg.Msgs), 1) - require.Equal(t, 0, len(msg.GetSignatures())) - - // Test --dry-run - success, _, _ = f.TxStakingEditValidator(barAddr.String(), - fmt.Sprintf("--moniker=%s", updateMoniker), - fmt.Sprintf("--details=%s", updateDetails), - fmt.Sprintf("--website=%s", updateWebsite), - "--dry-run") - require.True(t, success) - - // Note: Commission cannot be changed more than once within 24 hrs - // Edit validator's info - success, _, err := f.TxStakingEditValidator(keyBar, - fmt.Sprintf("--moniker=%s", updateMoniker), - fmt.Sprintf("--details=%s", updateDetails), - fmt.Sprintf("--website=%s", updateWebsite), - "-y") - - require.Equal(t, success, true) - require.Equal(t, err, "") - tests.WaitForNextNBlocksTM(1, f.Port) - - updatedValidator := f.QueryStakingValidator(barVal) - - // Ensure validator's moniker got changed - require.Equal(t, updatedValidator.Description.Moniker, updateMoniker) - - // Ensure validator's details got changed - require.Equal(t, updatedValidator.Description.Details, updateDetails) - - // Ensure validator's website got changed - require.Equal(t, updatedValidator.Description.Website, updateWebsite) - - f.Cleanup() -} - -func TestCLIDelegate(t *testing.T) { - t.Parallel() - f := InitFixtures(t) - - // start gaiad server - proc := f.GDStart() - defer proc.Stop(false) - - fooAddr := f.KeyAddress(keyFoo) - barAddr := f.KeyAddress(keyBar) - barVal := sdk.ValAddress(barAddr) - - consPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) - - sendTokens := sdk.TokensFromConsensusPower(10) - f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(denom)) - - newValTokens := sdk.TokensFromConsensusPower(2) - - // Create the validator - f.TxStakingCreateValidator(keyBar, consPubKey, sdk.NewCoin(denom, newValTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure that validator state is as expected - validator := f.QueryStakingValidator(barVal) - require.Equal(t, validator.OperatorAddress, barVal) - require.True(sdk.IntEq(t, newValTokens, validator.Tokens)) - - delegateTokens := sdk.TokensFromConsensusPower(5) - - // Test --generate-only - success, stdout, stderr := f.TxStakingDelegate(validator.OperatorAddress.String(), fooAddr.String(), sdk.NewCoin(denom, delegateTokens), "--generate-only") - require.Equal(t, success, true) - require.Empty(f.T, stderr) - - msg := unmarshalStdTx(f.T, stdout) - require.NotZero(t, msg.Fee.Gas) - require.Equal(t, len(msg.Msgs), 1) - require.Equal(t, 0, len(msg.GetSignatures())) - - // Test --dry-run - success, _, _ = f.TxStakingDelegate(validator.OperatorAddress.String(), fooAddr.String(), sdk.NewCoin(denom, delegateTokens), "--dry-run") - require.Equal(t, success, true) - - // Start delegate tokens form keyfoo - success, _, err := f.TxStakingDelegate(validator.OperatorAddress.String(), keyFoo, sdk.NewCoin(denom, delegateTokens), "-y") - require.Equal(t, success, true) - require.Equal(t, err, "") - - // Wait for the tx to commit into a block - tests.WaitForNextNBlocksTM(1, f.Port) - - // Read all delegations of a validator - validatorDelegations := f.QueryStakingDelegationsTo(barVal) - - // Check the length, since the there are only 2 delegations length should be equal to 2 - require.Len(t, validatorDelegations, 2) - delegatorAddress := f.KeysShow(keyFoo).Address - var delegatedAccount staking.Delegation - - for i := 0; i < len(validatorDelegations); i++ { - if validatorDelegations[i].DelegatorAddress.String() == delegatorAddress { - delegatedAccount = validatorDelegations[i] - break - } - } - - // Ensure the delegated amount should be greater than zero - require.NotZero(t, delegatedAccount.Shares) - - // Ensure the amount equal to the delegated balance - require.Equal(t, delegatedAccount.Shares, delegateTokens.ToDec()) - - f.Cleanup() -} - -func TestCLIRedelegate(t *testing.T) { - t.Parallel() - f := InitFixtures(t) - - // start gaiad server - proc := f.GDStart() - defer proc.Stop(false) - - // Create the 1st validator - barAddr := f.KeyAddress(keyBar) - srcValAddr := sdk.ValAddress(barAddr) - - srcPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) - - sendTokens := sdk.TokensFromConsensusPower(10) - f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure tokens sent to the dst address(i.e., barAddr) - require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(denom)) - - newValTokens := sdk.TokensFromConsensusPower(2) - - f.TxStakingCreateValidator(keyBar, srcPubKey, sdk.NewCoin(denom, newValTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure that validator1 state is as expected - srcVal := f.QueryStakingValidator(srcValAddr) - require.Equal(t, srcVal.OperatorAddress, srcValAddr) - require.True(sdk.IntEq(t, newValTokens, srcVal.Tokens)) - - // Create the 2nd validator - bazAddr := f.KeyAddress(keyBaz) - dstValAddr := sdk.ValAddress(bazAddr) - - dstPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) - f.TxSend(keyFoo, bazAddr, sdk.NewCoin(denom, sendTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure tokens sent to the dst address(i.e., bazAddr) - require.Equal(t, sendTokens, f.QueryBalances(bazAddr).AmountOf(denom)) - - success, _, err := f.TxStakingCreateValidator(keyBaz, dstPubKey, sdk.NewCoin(denom, newValTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure that validator2 state is as expected - dstVal := f.QueryStakingValidator(dstValAddr) - require.Equal(t, dstVal.OperatorAddress, dstValAddr) - require.True(sdk.IntEq(t, newValTokens, dstVal.Tokens)) - - redelegateValTokens := sdk.TokensFromConsensusPower(1) - - // Test --dry-run - success, _, _ = f.TxStakingReDelegate(srcVal.OperatorAddress.String(), dstVal.OperatorAddress.String(), - barAddr.String(), sdk.NewCoin(denom, redelegateValTokens), "--dry-run") - require.Equal(t, success, true) - - // Test --generate-only - success, stdout, stderr := f.TxStakingReDelegate(srcVal.OperatorAddress.String(), dstVal.OperatorAddress.String(), - barAddr.String(), sdk.NewCoin(denom, redelegateValTokens), "--generate-only") - require.Equal(t, success, true) - require.Empty(f.T, stderr) - - msg := unmarshalStdTx(f.T, stdout) - require.NotZero(t, msg.Fee.Gas) - require.Equal(t, len(msg.Msgs), 1) - require.Equal(t, 0, len(msg.GetSignatures())) - - success, _, err = f.TxStakingReDelegate(srcVal.OperatorAddress.String(), dstVal.OperatorAddress.String(), - keyBar, sdk.NewCoin(denom, redelegateValTokens), "-y") - - // Ensure the redelegate tx succeed - require.Equal(t, success, true) - require.Equal(t, err, "") - - tests.WaitForNextNBlocksTM(1, f.Port) - - // Query validator's info after redelegate - srcValDels := f.QueryStakingDelegationsTo(srcValAddr) - dstValDels := f.QueryStakingDelegationsTo(dstValAddr) - - delegatedAccount := findDelegateAccount(dstValDels, f.KeysShow(keyBar).Address) - // Ensure the delegated amount should be greater than zero - require.NotZero(t, delegatedAccount.Shares) - - // Ensure the amount equal to the redelegated balance - require.Equal(t, delegatedAccount.Shares, redelegateValTokens.ToDec()) - - delegatedAccount = findDelegateAccount(srcValDels, f.KeysShow(keyBar).Address) - // Ensure the delegated amount should be greater than zero - require.NotZero(t, delegatedAccount.Shares) - - // Ensure the amount equal subtracted delegated balance - require.Equal(t, delegatedAccount.Shares, newValTokens.Sub(redelegateValTokens).ToDec()) - f.Cleanup() -} diff --git a/cli_test/tests/send_test.go b/cli_test/tests/send_test.go new file mode 100644 index 000000000000..7e0c521eb3d7 --- /dev/null +++ b/cli_test/tests/send_test.go @@ -0,0 +1,78 @@ +package tests + +import ( + "github.com/cosmos/cosmos-sdk/cli_test/helpers" + "github.com/cosmos/cosmos-sdk/tests" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/stretchr/testify/require" + "testing" +) + +func TestCLISend(t *testing.T) { + t.Parallel() + f := helpers.InitFixtures(t) + + // start gaiad server + proc := f.SDStart() + defer proc.Stop(false) + + // Save key addresses for later uspackage testse + fooAddr := f.KeyAddress(helpers.KeyFoo) + barAddr := f.KeyAddress(helpers.KeyBar) + + startTokens := sdk.TokensFromConsensusPower(50) + require.Equal(t, startTokens, f.QueryBalances(fooAddr).AmountOf(helpers.Denom)) + + sendTokens := sdk.TokensFromConsensusPower(10) + + // It does not allow to send in offline mode + success, _, stdErr := f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y", "--offline") + require.Contains(t, stdErr, "no RPC client is defined in offline mode") + require.False(f.T, success) + tests.WaitForNextNBlocksTM(1, f.Port) + + // Send some tokens from one account to the other + f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure account balances match expected + require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(helpers.Denom)) + require.Equal(t, startTokens.Sub(sendTokens), f.QueryBalances(fooAddr).AmountOf(helpers.Denom)) + + // Test --dry-run + success, _, _ = f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "--dry-run") + require.True(t, success) + + // Test --generate-only + success, stdout, stderr := f.TxSend( + fooAddr.String(), barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "--generate-only=true", + ) + require.Empty(t, stderr) + require.True(t, success) + msg := helpers.UnmarshalStdTx(f.T, f.Cdc, stdout) + t.Log(msg) + require.NotZero(t, msg.Fee.Gas) + require.Len(t, msg.Msgs, 1) + require.Len(t, msg.GetSignatures(), 0) + + // Check state didn't change + require.Equal(t, startTokens.Sub(sendTokens), f.QueryBalances(fooAddr).AmountOf(helpers.Denom)) + + // test autosequencing + f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure account balances match expected + require.Equal(t, sendTokens.MulRaw(2), f.QueryBalances(barAddr).AmountOf(helpers.Denom)) + require.Equal(t, startTokens.Sub(sendTokens.MulRaw(2)), f.QueryBalances(fooAddr).AmountOf(helpers.Denom)) + + // test memo + f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "--memo='testmemo'", "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure account balances match expected + require.Equal(t, sendTokens.MulRaw(3), f.QueryBalances(barAddr).AmountOf(helpers.Denom)) + require.Equal(t, startTokens.Sub(sendTokens.MulRaw(3)), f.QueryBalances(fooAddr).AmountOf(helpers.Denom)) + + f.Cleanup() +} diff --git a/cli_test/tests/staking_test.go b/cli_test/tests/staking_test.go new file mode 100644 index 000000000000..499b2c64892e --- /dev/null +++ b/cli_test/tests/staking_test.go @@ -0,0 +1,358 @@ +package tests + +import ( + "fmt" + "github.com/cosmos/cosmos-sdk/cli_test/helpers" + "github.com/cosmos/cosmos-sdk/tests" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/staking" + "github.com/stretchr/testify/require" + "github.com/tendermint/tendermint/crypto/ed25519" + "testing" +) + +//----------------------------------------------------------------------------------- +//staking tx + +func TestCLICreateValidator(t *testing.T) { + t.Parallel() + f := helpers.InitFixtures(t) + + // start gaiad server + proc := f.SDStart() + defer proc.Stop(false) + + barAddr := f.KeyAddress(helpers.KeyBar) + barVal := sdk.ValAddress(barAddr) + + consPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) + + sendTokens := sdk.TokensFromConsensusPower(10) + f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(helpers.Denom)) + + // Generate a create validator transaction and ensure correctness + success, stdout, stderr := f.TxStakingCreateValidator(barAddr.String(), consPubKey, sdk.NewInt64Coin(helpers.Denom, 2), "--generate-only") + require.True(f.T, success) + require.Empty(f.T, stderr) + + msg := helpers.UnmarshalStdTx(f.T, f.Cdc, stdout) + require.NotZero(t, msg.Fee.Gas) + require.Equal(t, len(msg.Msgs), 1) + require.Equal(t, 0, len(msg.GetSignatures())) + + // Test --dry-run + newValTokens := sdk.TokensFromConsensusPower(2) + success, _, _ = f.TxStakingCreateValidator(barAddr.String(), consPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "--dry-run") + require.True(t, success) + + // Create the validator + f.TxStakingCreateValidator(helpers.KeyBar, consPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure funds were deducted properly + require.Equal(t, sendTokens.Sub(newValTokens), f.QueryBalances(barAddr).AmountOf(helpers.Denom)) + + // Ensure that validator state is as expected + validator := f.QueryStakingValidator(barVal) + require.Equal(t, validator.OperatorAddress, barVal) + require.True(sdk.IntEq(t, newValTokens, validator.Tokens)) + + // Query delegations to the validator + validatorDelegations := f.QueryStakingDelegationsTo(barVal) + require.Len(t, validatorDelegations, 1) + require.NotZero(t, validatorDelegations[0].Shares) + + // unbond a single share + unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(1)) + success = f.TxStakingUnbond(helpers.KeyBar, unbondAmt.String(), barVal, "-y") + require.True(t, success) + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure bonded staking is correct + remainingTokens := newValTokens.Sub(unbondAmt.Amount) + validator = f.QueryStakingValidator(barVal) + require.Equal(t, remainingTokens, validator.Tokens) + + // Get unbonding delegations from the validator + validatorUbds := f.QueryStakingUnbondingDelegationsFrom(barVal) + require.Len(t, validatorUbds, 1) + require.Len(t, validatorUbds[0].Entries, 1) + require.Equal(t, remainingTokens.String(), validatorUbds[0].Entries[0].Balance.String()) + + f.Cleanup() +} + +func TestCLIEditValidator(t *testing.T) { + t.Parallel() + f := helpers.InitFixtures(t) + + // start gaiad server + proc := f.SDStart() + defer proc.Stop(false) + + barAddr := f.KeyAddress(helpers.KeyBar) + barVal := sdk.ValAddress(barAddr) + + consPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) + + sendTokens := sdk.TokensFromConsensusPower(10) + f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(helpers.Denom)) + + newValTokens := sdk.TokensFromConsensusPower(2) + + // Create the validator + f.TxStakingCreateValidator(helpers.KeyBar, consPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure that validator state is as expected + validator := f.QueryStakingValidator(barVal) + require.Equal(t, validator.OperatorAddress, barVal) + require.True(sdk.IntEq(t, newValTokens, validator.Tokens)) + + // update moniker with test-edit + var updateMoniker = "test-edit" + if validator.Description.Moniker != "" { + updateMoniker = validator.Description.Moniker + "-" + updateMoniker + } + + // update details with test-details + var updateDetails = "test-details" + if validator.Description.Details != "" { + updateDetails = validator.Description.Details + "-" + updateDetails + } + + // update website with http://test-edit.co + var updateWebsite = "http://test-edit.co" + if validator.Description.Website != "" { + updateWebsite = validator.Description.Website + "(or)" + updateWebsite + } + + // Test --generate-only + success, stdout, stderr := f.TxStakingEditValidator(barAddr.String(), + fmt.Sprintf("--moniker=%s", updateMoniker), + fmt.Sprintf("--details=%s", updateDetails), + fmt.Sprintf("--website=%s", updateWebsite), + "--generate-only") + require.True(f.T, success) + require.Empty(f.T, stderr) + + msg := helpers.UnmarshalStdTx(f.T, f.Cdc, stdout) + require.NotZero(t, msg.Fee.Gas) + require.Equal(t, len(msg.Msgs), 1) + require.Equal(t, 0, len(msg.GetSignatures())) + + // Test --dry-run + success, _, _ = f.TxStakingEditValidator(barAddr.String(), + fmt.Sprintf("--moniker=%s", updateMoniker), + fmt.Sprintf("--details=%s", updateDetails), + fmt.Sprintf("--website=%s", updateWebsite), + "--dry-run") + require.True(t, success) + + // Note: Commission cannot be changed more than once within 24 hrs + // Edit validator's info + success, _, err := f.TxStakingEditValidator(helpers.KeyBar, + fmt.Sprintf("--moniker=%s", updateMoniker), + fmt.Sprintf("--details=%s", updateDetails), + fmt.Sprintf("--website=%s", updateWebsite), + "-y") + + require.Equal(t, success, true) + require.Equal(t, err, "") + tests.WaitForNextNBlocksTM(1, f.Port) + + updatedValidator := f.QueryStakingValidator(barVal) + + // Ensure validator's moniker got changed + require.Equal(t, updatedValidator.Description.Moniker, updateMoniker) + + // Ensure validator's details got changed + require.Equal(t, updatedValidator.Description.Details, updateDetails) + + // Ensure validator's website got changed + require.Equal(t, updatedValidator.Description.Website, updateWebsite) + + f.Cleanup() +} + +func TestCLIDelegate(t *testing.T) { + t.Parallel() + f := helpers.InitFixtures(t) + + // start gaiad server + proc := f.SDStart() + defer proc.Stop(false) + + fooAddr := f.KeyAddress(helpers.KeyFoo) + barAddr := f.KeyAddress(helpers.KeyBar) + barVal := sdk.ValAddress(barAddr) + + consPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) + + sendTokens := sdk.TokensFromConsensusPower(10) + f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(helpers.Denom)) + + newValTokens := sdk.TokensFromConsensusPower(2) + + // Create the validator + f.TxStakingCreateValidator(helpers.KeyBar, consPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure that validator state is as expected + validator := f.QueryStakingValidator(barVal) + require.Equal(t, validator.OperatorAddress, barVal) + require.True(sdk.IntEq(t, newValTokens, validator.Tokens)) + + delegateTokens := sdk.TokensFromConsensusPower(5) + + // Test --generate-only + success, stdout, stderr := f.TxStakingDelegate(validator.OperatorAddress.String(), fooAddr.String(), sdk.NewCoin(helpers.Denom, delegateTokens), "--generate-only") + require.Equal(t, success, true) + require.Empty(f.T, stderr) + + msg := helpers.UnmarshalStdTx(f.T, f.Cdc, stdout) + require.NotZero(t, msg.Fee.Gas) + require.Equal(t, len(msg.Msgs), 1) + require.Equal(t, 0, len(msg.GetSignatures())) + + // Test --dry-run + success, _, _ = f.TxStakingDelegate(validator.OperatorAddress.String(), fooAddr.String(), sdk.NewCoin(helpers.Denom, delegateTokens), "--dry-run") + require.Equal(t, success, true) + + // Start delegate tokens form keyfoo + success, _, err := f.TxStakingDelegate(validator.OperatorAddress.String(), helpers.KeyFoo, sdk.NewCoin(helpers.Denom, delegateTokens), "-y") + require.Equal(t, success, true) + require.Equal(t, err, "") + + // Wait for the tx to commit into a block + tests.WaitForNextNBlocksTM(1, f.Port) + + // Read all delegations of a validator + validatorDelegations := f.QueryStakingDelegationsTo(barVal) + + // Check the length, since the there are only 2 delegations length should be equal to 2 + require.Len(t, validatorDelegations, 2) + delegatorAddress := f.KeysShow(helpers.KeyFoo).Address + var delegatedAccount staking.Delegation + + for i := 0; i < len(validatorDelegations); i++ { + if validatorDelegations[i].DelegatorAddress.String() == delegatorAddress { + delegatedAccount = validatorDelegations[i] + break + } + } + + // Ensure the delegated amount should be greater than zero + require.NotZero(t, delegatedAccount.Shares) + + // Ensure the amount equal to the delegated balance + require.Equal(t, delegatedAccount.Shares, delegateTokens.ToDec()) + + f.Cleanup() +} + +func TestCLIRedelegate(t *testing.T) { + t.Parallel() + f := helpers.InitFixtures(t) + + // start gaiad server + proc := f.SDStart() + defer proc.Stop(false) + + // Create the 1st validator + barAddr := f.KeyAddress(helpers.KeyBar) + srcValAddr := sdk.ValAddress(barAddr) + + srcPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) + + sendTokens := sdk.TokensFromConsensusPower(10) + f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure tokens sent to the dst address(i.e., barAddr) + require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(helpers.Denom)) + + newValTokens := sdk.TokensFromConsensusPower(2) + + f.TxStakingCreateValidator(helpers.KeyBar, srcPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure that validator1 state is as expected + srcVal := f.QueryStakingValidator(srcValAddr) + require.Equal(t, srcVal.OperatorAddress, srcValAddr) + require.True(sdk.IntEq(t, newValTokens, srcVal.Tokens)) + + // Create the 2nd validator + bazAddr := f.KeyAddress(helpers.KeyBaz) + dstValAddr := sdk.ValAddress(bazAddr) + + dstPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) + f.TxSend(helpers.KeyFoo, bazAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure tokens sent to the dst address(i.e., bazAddr) + require.Equal(t, sendTokens, f.QueryBalances(bazAddr).AmountOf(helpers.Denom)) + + success, _, err := f.TxStakingCreateValidator(helpers.KeyBaz, dstPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure that validator2 state is as expected + dstVal := f.QueryStakingValidator(dstValAddr) + require.Equal(t, dstVal.OperatorAddress, dstValAddr) + require.True(sdk.IntEq(t, newValTokens, dstVal.Tokens)) + + redelegateValTokens := sdk.TokensFromConsensusPower(1) + + // Test --dry-run + success, _, _ = f.TxStakingReDelegate(srcVal.OperatorAddress.String(), dstVal.OperatorAddress.String(), + barAddr.String(), sdk.NewCoin(helpers.Denom, redelegateValTokens), "--dry-run") + require.Equal(t, success, true) + + // Test --generate-only + success, stdout, stderr := f.TxStakingReDelegate(srcVal.OperatorAddress.String(), dstVal.OperatorAddress.String(), + barAddr.String(), sdk.NewCoin(helpers.Denom, redelegateValTokens), "--generate-only") + require.Equal(t, success, true) + require.Empty(f.T, stderr) + + msg := helpers.UnmarshalStdTx(f.T, f.Cdc, stdout) + require.NotZero(t, msg.Fee.Gas) + require.Equal(t, len(msg.Msgs), 1) + require.Equal(t, 0, len(msg.GetSignatures())) + + success, _, err = f.TxStakingReDelegate(srcVal.OperatorAddress.String(), dstVal.OperatorAddress.String(), + helpers.KeyBar, sdk.NewCoin(helpers.Denom, redelegateValTokens), "-y") + + // Ensure the redelegate tx succeed + require.Equal(t, success, true) + require.Equal(t, err, "") + + tests.WaitForNextNBlocksTM(1, f.Port) + + // Query validator's info after redelegate + srcValDels := f.QueryStakingDelegationsTo(srcValAddr) + dstValDels := f.QueryStakingDelegationsTo(dstValAddr) + + delegatedAccount := helpers.FindDelegateAccount(dstValDels, f.KeysShow(helpers.KeyBar).Address) + // Ensure the delegated amount should be greater than zero + require.NotZero(t, delegatedAccount.Shares) + + // Ensure the amount equal to the redelegated balance + require.Equal(t, delegatedAccount.Shares, redelegateValTokens.ToDec()) + + delegatedAccount = helpers.FindDelegateAccount(srcValDels, f.KeysShow(helpers.KeyBar).Address) + // Ensure the delegated amount should be greater than zero + require.NotZero(t, delegatedAccount.Shares) + + // Ensure the amount equal subtracted delegated balance + require.Equal(t, delegatedAccount.Shares, newValTokens.Sub(redelegateValTokens).ToDec()) + f.Cleanup() +} diff --git a/tests/test_cover.sh b/contrib/test_cover.sh similarity index 100% rename from tests/test_cover.sh rename to contrib/test_cover.sh From 1b9c2ec0696ad367855689b76c1afa6b07821c01 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Wed, 22 Apr 2020 01:52:31 +0530 Subject: [PATCH 18/61] Removed test_hepers file --- cli_test/test_helpers.go | 0 cli_test/tests/staking_test.go | 1 + 2 files changed, 1 insertion(+) delete mode 100644 cli_test/test_helpers.go diff --git a/cli_test/test_helpers.go b/cli_test/test_helpers.go deleted file mode 100644 index e69de29bb2d1..000000000000 diff --git a/cli_test/tests/staking_test.go b/cli_test/tests/staking_test.go index 499b2c64892e..af2dcb602fea 100644 --- a/cli_test/tests/staking_test.go +++ b/cli_test/tests/staking_test.go @@ -354,5 +354,6 @@ func TestCLIRedelegate(t *testing.T) { // Ensure the amount equal subtracted delegated balance require.Equal(t, delegatedAccount.Shares, newValTokens.Sub(redelegateValTokens).ToDec()) + f.Cleanup() } From 3101ed373a044ef71c07002ae544bb5c77779943 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Wed, 22 Apr 2020 02:30:50 +0530 Subject: [PATCH 19/61] Moved test_cover to contrib --- Makefile | 2 +- {tests => contrib}/test_cover.sh | 0 2 files changed, 1 insertion(+), 1 deletion(-) rename {tests => contrib}/test_cover.sh (100%) diff --git a/Makefile b/Makefile index 8ff13c9cb962..d4edcaaa8c0c 100644 --- a/Makefile +++ b/Makefile @@ -195,7 +195,7 @@ test-sim-profile: .PHONY: test-sim-profile test-sim-benchmark test-cover: - @export VERSION=$(VERSION); bash -x tests/test_cover.sh + @export VERSION=$(VERSION); bash -x contrib/test_cover.sh .PHONY: test-cover benchmark: diff --git a/tests/test_cover.sh b/contrib/test_cover.sh similarity index 100% rename from tests/test_cover.sh rename to contrib/test_cover.sh From 93f1b091797d761b753f16dcbbb55cc785846229 Mon Sep 17 00:00:00 2001 From: atheesh Date: Wed, 22 Apr 2020 13:44:58 +0530 Subject: [PATCH 20/61] Added codec in fixtures --- cli_test/helpers/fixtures.go | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/cli_test/helpers/fixtures.go b/cli_test/helpers/fixtures.go index 2b5850153eaa..03d1c139fc60 100644 --- a/cli_test/helpers/fixtures.go +++ b/cli_test/helpers/fixtures.go @@ -1,6 +1,8 @@ package helpers import ( + codecstd "github.com/cosmos/cosmos-sdk/codec/std" + authclient "github.com/cosmos/cosmos-sdk/x/auth/client" "io/ioutil" "os" "path/filepath" @@ -30,6 +32,15 @@ type Fixtures struct { T *testing.T } +var ( + cdc = codecstd.MakeCodec(simapp.ModuleBasics) + appCodec = codecstd.NewAppCodec(cdc) +) + +func init() { + authclient.Codec = appCodec +} + // NewFixtures creates a new instance of Fixtures with many vars set func NewFixtures(t *testing.T) *Fixtures { tmpDir, err := ioutil.TempDir("", "sdk_integration_"+t.Name()+"_") @@ -41,7 +52,6 @@ func NewFixtures(t *testing.T) *Fixtures { p2pAddr, _, err := server.FreeTCPAddr() require.NoError(t, err) - cdc := codec.New() buildDir := os.Getenv("BUILDDIR") if buildDir == "" { buildDir, err = filepath.Abs("../../build/") From d31c20dfcd4d5709fd88df1bdf3703e653b3df07 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Wed, 22 Apr 2020 20:35:36 +0530 Subject: [PATCH 21/61] Migrated tests to respective modules --- cli_test/helpers/fixtures.go | 2 +- cli_test/tests/codec.go | 16 - cli_test/tests/staking_test.go | 359 ------------------ .../tests => x/bank/client/cli}/send_test.go | 2 +- x/staking/client/cli/staking_test.go | 84 ++++ 5 files changed, 86 insertions(+), 377 deletions(-) delete mode 100644 cli_test/tests/codec.go delete mode 100644 cli_test/tests/staking_test.go rename {cli_test/tests => x/bank/client/cli}/send_test.go (99%) create mode 100644 x/staking/client/cli/staking_test.go diff --git a/cli_test/helpers/fixtures.go b/cli_test/helpers/fixtures.go index 03d1c139fc60..fbfa9e9de0a0 100644 --- a/cli_test/helpers/fixtures.go +++ b/cli_test/helpers/fixtures.go @@ -54,7 +54,7 @@ func NewFixtures(t *testing.T) *Fixtures { buildDir := os.Getenv("BUILDDIR") if buildDir == "" { - buildDir, err = filepath.Abs("../../build/") + buildDir, err = filepath.Abs("../../../../build/") require.NoError(t, err) } diff --git a/cli_test/tests/codec.go b/cli_test/tests/codec.go deleted file mode 100644 index b04742b3db3b..000000000000 --- a/cli_test/tests/codec.go +++ /dev/null @@ -1,16 +0,0 @@ -package tests - -import ( - codecstd "github.com/cosmos/cosmos-sdk/codec/std" - "github.com/cosmos/cosmos-sdk/simapp" - authclient "github.com/cosmos/cosmos-sdk/x/auth/client" -) - -var ( - cdc = codecstd.MakeCodec(simapp.ModuleBasics) - appCodec = codecstd.NewAppCodec(cdc) -) - -func init() { - authclient.Codec = appCodec -} diff --git a/cli_test/tests/staking_test.go b/cli_test/tests/staking_test.go deleted file mode 100644 index af2dcb602fea..000000000000 --- a/cli_test/tests/staking_test.go +++ /dev/null @@ -1,359 +0,0 @@ -package tests - -import ( - "fmt" - "github.com/cosmos/cosmos-sdk/cli_test/helpers" - "github.com/cosmos/cosmos-sdk/tests" - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/staking" - "github.com/stretchr/testify/require" - "github.com/tendermint/tendermint/crypto/ed25519" - "testing" -) - -//----------------------------------------------------------------------------------- -//staking tx - -func TestCLICreateValidator(t *testing.T) { - t.Parallel() - f := helpers.InitFixtures(t) - - // start gaiad server - proc := f.SDStart() - defer proc.Stop(false) - - barAddr := f.KeyAddress(helpers.KeyBar) - barVal := sdk.ValAddress(barAddr) - - consPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) - - sendTokens := sdk.TokensFromConsensusPower(10) - f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(helpers.Denom)) - - // Generate a create validator transaction and ensure correctness - success, stdout, stderr := f.TxStakingCreateValidator(barAddr.String(), consPubKey, sdk.NewInt64Coin(helpers.Denom, 2), "--generate-only") - require.True(f.T, success) - require.Empty(f.T, stderr) - - msg := helpers.UnmarshalStdTx(f.T, f.Cdc, stdout) - require.NotZero(t, msg.Fee.Gas) - require.Equal(t, len(msg.Msgs), 1) - require.Equal(t, 0, len(msg.GetSignatures())) - - // Test --dry-run - newValTokens := sdk.TokensFromConsensusPower(2) - success, _, _ = f.TxStakingCreateValidator(barAddr.String(), consPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "--dry-run") - require.True(t, success) - - // Create the validator - f.TxStakingCreateValidator(helpers.KeyBar, consPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure funds were deducted properly - require.Equal(t, sendTokens.Sub(newValTokens), f.QueryBalances(barAddr).AmountOf(helpers.Denom)) - - // Ensure that validator state is as expected - validator := f.QueryStakingValidator(barVal) - require.Equal(t, validator.OperatorAddress, barVal) - require.True(sdk.IntEq(t, newValTokens, validator.Tokens)) - - // Query delegations to the validator - validatorDelegations := f.QueryStakingDelegationsTo(barVal) - require.Len(t, validatorDelegations, 1) - require.NotZero(t, validatorDelegations[0].Shares) - - // unbond a single share - unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(1)) - success = f.TxStakingUnbond(helpers.KeyBar, unbondAmt.String(), barVal, "-y") - require.True(t, success) - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure bonded staking is correct - remainingTokens := newValTokens.Sub(unbondAmt.Amount) - validator = f.QueryStakingValidator(barVal) - require.Equal(t, remainingTokens, validator.Tokens) - - // Get unbonding delegations from the validator - validatorUbds := f.QueryStakingUnbondingDelegationsFrom(barVal) - require.Len(t, validatorUbds, 1) - require.Len(t, validatorUbds[0].Entries, 1) - require.Equal(t, remainingTokens.String(), validatorUbds[0].Entries[0].Balance.String()) - - f.Cleanup() -} - -func TestCLIEditValidator(t *testing.T) { - t.Parallel() - f := helpers.InitFixtures(t) - - // start gaiad server - proc := f.SDStart() - defer proc.Stop(false) - - barAddr := f.KeyAddress(helpers.KeyBar) - barVal := sdk.ValAddress(barAddr) - - consPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) - - sendTokens := sdk.TokensFromConsensusPower(10) - f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(helpers.Denom)) - - newValTokens := sdk.TokensFromConsensusPower(2) - - // Create the validator - f.TxStakingCreateValidator(helpers.KeyBar, consPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure that validator state is as expected - validator := f.QueryStakingValidator(barVal) - require.Equal(t, validator.OperatorAddress, barVal) - require.True(sdk.IntEq(t, newValTokens, validator.Tokens)) - - // update moniker with test-edit - var updateMoniker = "test-edit" - if validator.Description.Moniker != "" { - updateMoniker = validator.Description.Moniker + "-" + updateMoniker - } - - // update details with test-details - var updateDetails = "test-details" - if validator.Description.Details != "" { - updateDetails = validator.Description.Details + "-" + updateDetails - } - - // update website with http://test-edit.co - var updateWebsite = "http://test-edit.co" - if validator.Description.Website != "" { - updateWebsite = validator.Description.Website + "(or)" + updateWebsite - } - - // Test --generate-only - success, stdout, stderr := f.TxStakingEditValidator(barAddr.String(), - fmt.Sprintf("--moniker=%s", updateMoniker), - fmt.Sprintf("--details=%s", updateDetails), - fmt.Sprintf("--website=%s", updateWebsite), - "--generate-only") - require.True(f.T, success) - require.Empty(f.T, stderr) - - msg := helpers.UnmarshalStdTx(f.T, f.Cdc, stdout) - require.NotZero(t, msg.Fee.Gas) - require.Equal(t, len(msg.Msgs), 1) - require.Equal(t, 0, len(msg.GetSignatures())) - - // Test --dry-run - success, _, _ = f.TxStakingEditValidator(barAddr.String(), - fmt.Sprintf("--moniker=%s", updateMoniker), - fmt.Sprintf("--details=%s", updateDetails), - fmt.Sprintf("--website=%s", updateWebsite), - "--dry-run") - require.True(t, success) - - // Note: Commission cannot be changed more than once within 24 hrs - // Edit validator's info - success, _, err := f.TxStakingEditValidator(helpers.KeyBar, - fmt.Sprintf("--moniker=%s", updateMoniker), - fmt.Sprintf("--details=%s", updateDetails), - fmt.Sprintf("--website=%s", updateWebsite), - "-y") - - require.Equal(t, success, true) - require.Equal(t, err, "") - tests.WaitForNextNBlocksTM(1, f.Port) - - updatedValidator := f.QueryStakingValidator(barVal) - - // Ensure validator's moniker got changed - require.Equal(t, updatedValidator.Description.Moniker, updateMoniker) - - // Ensure validator's details got changed - require.Equal(t, updatedValidator.Description.Details, updateDetails) - - // Ensure validator's website got changed - require.Equal(t, updatedValidator.Description.Website, updateWebsite) - - f.Cleanup() -} - -func TestCLIDelegate(t *testing.T) { - t.Parallel() - f := helpers.InitFixtures(t) - - // start gaiad server - proc := f.SDStart() - defer proc.Stop(false) - - fooAddr := f.KeyAddress(helpers.KeyFoo) - barAddr := f.KeyAddress(helpers.KeyBar) - barVal := sdk.ValAddress(barAddr) - - consPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) - - sendTokens := sdk.TokensFromConsensusPower(10) - f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(helpers.Denom)) - - newValTokens := sdk.TokensFromConsensusPower(2) - - // Create the validator - f.TxStakingCreateValidator(helpers.KeyBar, consPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure that validator state is as expected - validator := f.QueryStakingValidator(barVal) - require.Equal(t, validator.OperatorAddress, barVal) - require.True(sdk.IntEq(t, newValTokens, validator.Tokens)) - - delegateTokens := sdk.TokensFromConsensusPower(5) - - // Test --generate-only - success, stdout, stderr := f.TxStakingDelegate(validator.OperatorAddress.String(), fooAddr.String(), sdk.NewCoin(helpers.Denom, delegateTokens), "--generate-only") - require.Equal(t, success, true) - require.Empty(f.T, stderr) - - msg := helpers.UnmarshalStdTx(f.T, f.Cdc, stdout) - require.NotZero(t, msg.Fee.Gas) - require.Equal(t, len(msg.Msgs), 1) - require.Equal(t, 0, len(msg.GetSignatures())) - - // Test --dry-run - success, _, _ = f.TxStakingDelegate(validator.OperatorAddress.String(), fooAddr.String(), sdk.NewCoin(helpers.Denom, delegateTokens), "--dry-run") - require.Equal(t, success, true) - - // Start delegate tokens form keyfoo - success, _, err := f.TxStakingDelegate(validator.OperatorAddress.String(), helpers.KeyFoo, sdk.NewCoin(helpers.Denom, delegateTokens), "-y") - require.Equal(t, success, true) - require.Equal(t, err, "") - - // Wait for the tx to commit into a block - tests.WaitForNextNBlocksTM(1, f.Port) - - // Read all delegations of a validator - validatorDelegations := f.QueryStakingDelegationsTo(barVal) - - // Check the length, since the there are only 2 delegations length should be equal to 2 - require.Len(t, validatorDelegations, 2) - delegatorAddress := f.KeysShow(helpers.KeyFoo).Address - var delegatedAccount staking.Delegation - - for i := 0; i < len(validatorDelegations); i++ { - if validatorDelegations[i].DelegatorAddress.String() == delegatorAddress { - delegatedAccount = validatorDelegations[i] - break - } - } - - // Ensure the delegated amount should be greater than zero - require.NotZero(t, delegatedAccount.Shares) - - // Ensure the amount equal to the delegated balance - require.Equal(t, delegatedAccount.Shares, delegateTokens.ToDec()) - - f.Cleanup() -} - -func TestCLIRedelegate(t *testing.T) { - t.Parallel() - f := helpers.InitFixtures(t) - - // start gaiad server - proc := f.SDStart() - defer proc.Stop(false) - - // Create the 1st validator - barAddr := f.KeyAddress(helpers.KeyBar) - srcValAddr := sdk.ValAddress(barAddr) - - srcPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) - - sendTokens := sdk.TokensFromConsensusPower(10) - f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure tokens sent to the dst address(i.e., barAddr) - require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(helpers.Denom)) - - newValTokens := sdk.TokensFromConsensusPower(2) - - f.TxStakingCreateValidator(helpers.KeyBar, srcPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure that validator1 state is as expected - srcVal := f.QueryStakingValidator(srcValAddr) - require.Equal(t, srcVal.OperatorAddress, srcValAddr) - require.True(sdk.IntEq(t, newValTokens, srcVal.Tokens)) - - // Create the 2nd validator - bazAddr := f.KeyAddress(helpers.KeyBaz) - dstValAddr := sdk.ValAddress(bazAddr) - - dstPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) - f.TxSend(helpers.KeyFoo, bazAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure tokens sent to the dst address(i.e., bazAddr) - require.Equal(t, sendTokens, f.QueryBalances(bazAddr).AmountOf(helpers.Denom)) - - success, _, err := f.TxStakingCreateValidator(helpers.KeyBaz, dstPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "-y") - tests.WaitForNextNBlocksTM(1, f.Port) - - // Ensure that validator2 state is as expected - dstVal := f.QueryStakingValidator(dstValAddr) - require.Equal(t, dstVal.OperatorAddress, dstValAddr) - require.True(sdk.IntEq(t, newValTokens, dstVal.Tokens)) - - redelegateValTokens := sdk.TokensFromConsensusPower(1) - - // Test --dry-run - success, _, _ = f.TxStakingReDelegate(srcVal.OperatorAddress.String(), dstVal.OperatorAddress.String(), - barAddr.String(), sdk.NewCoin(helpers.Denom, redelegateValTokens), "--dry-run") - require.Equal(t, success, true) - - // Test --generate-only - success, stdout, stderr := f.TxStakingReDelegate(srcVal.OperatorAddress.String(), dstVal.OperatorAddress.String(), - barAddr.String(), sdk.NewCoin(helpers.Denom, redelegateValTokens), "--generate-only") - require.Equal(t, success, true) - require.Empty(f.T, stderr) - - msg := helpers.UnmarshalStdTx(f.T, f.Cdc, stdout) - require.NotZero(t, msg.Fee.Gas) - require.Equal(t, len(msg.Msgs), 1) - require.Equal(t, 0, len(msg.GetSignatures())) - - success, _, err = f.TxStakingReDelegate(srcVal.OperatorAddress.String(), dstVal.OperatorAddress.String(), - helpers.KeyBar, sdk.NewCoin(helpers.Denom, redelegateValTokens), "-y") - - // Ensure the redelegate tx succeed - require.Equal(t, success, true) - require.Equal(t, err, "") - - tests.WaitForNextNBlocksTM(1, f.Port) - - // Query validator's info after redelegate - srcValDels := f.QueryStakingDelegationsTo(srcValAddr) - dstValDels := f.QueryStakingDelegationsTo(dstValAddr) - - delegatedAccount := helpers.FindDelegateAccount(dstValDels, f.KeysShow(helpers.KeyBar).Address) - // Ensure the delegated amount should be greater than zero - require.NotZero(t, delegatedAccount.Shares) - - // Ensure the amount equal to the redelegated balance - require.Equal(t, delegatedAccount.Shares, redelegateValTokens.ToDec()) - - delegatedAccount = helpers.FindDelegateAccount(srcValDels, f.KeysShow(helpers.KeyBar).Address) - // Ensure the delegated amount should be greater than zero - require.NotZero(t, delegatedAccount.Shares) - - // Ensure the amount equal subtracted delegated balance - require.Equal(t, delegatedAccount.Shares, newValTokens.Sub(redelegateValTokens).ToDec()) - - f.Cleanup() -} diff --git a/cli_test/tests/send_test.go b/x/bank/client/cli/send_test.go similarity index 99% rename from cli_test/tests/send_test.go rename to x/bank/client/cli/send_test.go index 7e0c521eb3d7..370726bf9371 100644 --- a/cli_test/tests/send_test.go +++ b/x/bank/client/cli/send_test.go @@ -1,4 +1,4 @@ -package tests +package cli_test import ( "github.com/cosmos/cosmos-sdk/cli_test/helpers" diff --git a/x/staking/client/cli/staking_test.go b/x/staking/client/cli/staking_test.go new file mode 100644 index 000000000000..d4e44460b314 --- /dev/null +++ b/x/staking/client/cli/staking_test.go @@ -0,0 +1,84 @@ +package cli_test + +import ( + "github.com/cosmos/cosmos-sdk/cli_test/helpers" + "github.com/cosmos/cosmos-sdk/tests" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/stretchr/testify/require" + "github.com/tendermint/tendermint/crypto/ed25519" + "testing" +) + +//----------------------------------------------------------------------------------- +//staking tx + +func TestCLICreateValidator(t *testing.T) { + t.Parallel() + f := helpers.InitFixtures(t) + + // start gaiad server + proc := f.SDStart() + defer proc.Stop(false) + + barAddr := f.KeyAddress(helpers.KeyBar) + barVal := sdk.ValAddress(barAddr) + + consPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) + + sendTokens := sdk.TokensFromConsensusPower(10) + f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(helpers.Denom)) + + // Generate a create validator transaction and ensure correctness + success, stdout, stderr := f.TxStakingCreateValidator(barAddr.String(), consPubKey, sdk.NewInt64Coin(helpers.Denom, 2), "--generate-only") + require.True(f.T, success) + require.Empty(f.T, stderr) + + msg := helpers.UnmarshalStdTx(f.T, f.Cdc, stdout) + require.NotZero(t, msg.Fee.Gas) + require.Equal(t, len(msg.Msgs), 1) + require.Equal(t, 0, len(msg.GetSignatures())) + + // Test --dry-run + newValTokens := sdk.TokensFromConsensusPower(2) + success, _, _ = f.TxStakingCreateValidator(barAddr.String(), consPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "--dry-run") + require.True(t, success) + + // Create the validator + f.TxStakingCreateValidator(helpers.KeyBar, consPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "-y") + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure funds were deducted properly + require.Equal(t, sendTokens.Sub(newValTokens), f.QueryBalances(barAddr).AmountOf(helpers.Denom)) + + // Ensure that validator state is as expected + validator := f.QueryStakingValidator(barVal) + require.Equal(t, validator.OperatorAddress, barVal) + require.True(sdk.IntEq(t, newValTokens, validator.Tokens)) + + // Query delegations to the validator + validatorDelegations := f.QueryStakingDelegationsTo(barVal) + require.Len(t, validatorDelegations, 1) + require.NotZero(t, validatorDelegations[0].Shares) + + // unbond a single share + unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(1)) + success = f.TxStakingUnbond(helpers.KeyBar, unbondAmt.String(), barVal, "-y") + require.True(t, success) + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure bonded staking is correct + remainingTokens := newValTokens.Sub(unbondAmt.Amount) + validator = f.QueryStakingValidator(barVal) + require.Equal(t, remainingTokens, validator.Tokens) + + // Get unbonding delegations from the validator + validatorUbds := f.QueryStakingUnbondingDelegationsFrom(barVal) + require.Len(t, validatorUbds, 1) + require.Len(t, validatorUbds[0].Entries, 1) + require.Equal(t, remainingTokens.String(), validatorUbds[0].Entries[0].Balance.String()) + + f.Cleanup() +} From c083a83570e0085aca5475c03c77e6ac8ff3bc3b Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Thu, 23 Apr 2020 18:15:54 +0530 Subject: [PATCH 22/61] Exported helper methods --- Makefile | 2 + cli_test/helpers/executors.go | 10 +-- cli_test/helpers/fixtures.go | 21 +++++-- cli_test/helpers/helpers.go | 115 ++++++---------------------------- cli_test/helpers/utils.go | 2 +- cli_test/tests/codec.go | 16 ----- 6 files changed, 42 insertions(+), 124 deletions(-) delete mode 100644 cli_test/tests/codec.go diff --git a/Makefile b/Makefile index d4edcaaa8c0c..cb1c31ceb727 100644 --- a/Makefile +++ b/Makefile @@ -6,10 +6,12 @@ VERSION := $(shell echo $(shell git describe --tags) | sed 's/^v//') COMMIT := $(shell git log -1 --format='%H') LEDGER_ENABLED ?= true BINDIR ?= $(GOPATH)/bin +BUILDDIR ?= $(CURDIR)/build SIMAPP = ./simapp MOCKS_DIR = $(CURDIR)/tests/mocks export GO111MODULE = on +export BUILDDIR # The below include contains the tools and runsim targets. include contrib/devtools/Makefile diff --git a/cli_test/helpers/executors.go b/cli_test/helpers/executors.go index 5a642b1f2fa1..cb4e011b94b6 100644 --- a/cli_test/helpers/executors.go +++ b/cli_test/helpers/executors.go @@ -9,16 +9,16 @@ import ( "github.com/cosmos/cosmos-sdk/tests" ) -func executeWriteCheckErr(t *testing.T, cmdStr string, writes ...string) { - require.True(t, executeWrite(t, cmdStr, writes...)) +func ExecuteWriteCheckErr(t *testing.T, cmdStr string, writes ...string) { + require.True(t, ExecuteWrite(t, cmdStr, writes...)) } -func executeWrite(t *testing.T, cmdStr string, writes ...string) (exitSuccess bool) { - exitSuccess, _, _ = executeWriteRetStdStreams(t, cmdStr, writes...) +func ExecuteWrite(t *testing.T, cmdStr string, writes ...string) (exitSuccess bool) { + exitSuccess, _, _ = ExecuteWriteRetStdStreams(t, cmdStr, writes...) return } -func executeWriteRetStdStreams(t *testing.T, cmdStr string, writes ...string) (bool, string, string) { +func ExecuteWriteRetStdStreams(t *testing.T, cmdStr string, writes ...string) (bool, string, string) { proc := tests.GoExecuteT(t, cmdStr) // Enables use of interactive commands diff --git a/cli_test/helpers/fixtures.go b/cli_test/helpers/fixtures.go index c465bfffb29c..12df809e5329 100644 --- a/cli_test/helpers/fixtures.go +++ b/cli_test/helpers/fixtures.go @@ -6,6 +6,9 @@ import ( "path/filepath" "testing" + codecstd "github.com/cosmos/cosmos-sdk/codec/std" + authclient "github.com/cosmos/cosmos-sdk/x/auth/client" + "github.com/stretchr/testify/require" tmtypes "github.com/tendermint/tendermint/types" @@ -26,9 +29,19 @@ type Fixtures struct { SimdHome string SimcliHome string P2PAddr string + Cdc *codec.Codec T *testing.T } +var ( + cdc = codecstd.MakeCodec(simapp.ModuleBasics) + appCodec = codecstd.NewAppCodec(cdc) +) + +func init() { + authclient.Codec = appCodec +} + // NewFixtures creates a new instance of Fixtures with many vars set func NewFixtures(t *testing.T) *Fixtures { tmpDir, err := ioutil.TempDir("", "sdk_integration_"+t.Name()+"_") @@ -41,10 +54,7 @@ func NewFixtures(t *testing.T) *Fixtures { require.NoError(t, err) buildDir := os.Getenv("BUILDDIR") - if buildDir == "" { - buildDir, err = filepath.Abs("../../build/") - require.NoError(t, err) - } + require.NotNil(t, buildDir) return &Fixtures{ T: t, @@ -67,11 +77,10 @@ func (f Fixtures) GenesisFile() string { // GenesisFile returns the application's genesis state func (f Fixtures) GenesisState() simapp.GenesisState { - cdc := codec.New() genDoc, err := tmtypes.GenesisDocFromFile(f.GenesisFile()) require.NoError(f.T, err) var appState simapp.GenesisState - require.NoError(f.T, cdc.UnmarshalJSON(genDoc.AppState, &appState)) + require.NoError(f.T, f.Cdc.UnmarshalJSON(genDoc.AppState, &appState)) return appState } diff --git a/cli_test/helpers/helpers.go b/cli_test/helpers/helpers.go index 2ac524c04a0a..8bd7d9ef246e 100644 --- a/cli_test/helpers/helpers.go +++ b/cli_test/helpers/helpers.go @@ -7,8 +7,6 @@ import ( "path/filepath" "strings" - "github.com/cosmos/cosmos-sdk/x/staking" - "github.com/stretchr/testify/require" clientkeys "github.com/cosmos/cosmos-sdk/client/keys" @@ -43,7 +41,7 @@ var ( // UnsafeResetAll is simd unsafe-reset-all func (f *Fixtures) UnsafeResetAll(flags ...string) { cmd := fmt.Sprintf("%s --home=%s unsafe-reset-all", f.SimdBinary, f.SimdHome) - executeWrite(f.T, addFlags(cmd, flags)) + ExecuteWrite(f.T, AddFlags(cmd, flags)) err := os.RemoveAll(filepath.Join(f.SimdHome, "config", "gentx")) require.NoError(f.T, err) } @@ -52,7 +50,7 @@ func (f *Fixtures) UnsafeResetAll(flags ...string) { // NOTE: SDInit sets the ChainID for the Fixtures instance func (f *Fixtures) SDInit(moniker string, flags ...string) { cmd := fmt.Sprintf("%s init -o --home=%s %s", f.SimdBinary, f.SimdHome, moniker) - _, stderr := tests.ExecuteT(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) + _, stderr := tests.ExecuteT(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) var chainID string var initRes map[string]json.RawMessage @@ -69,25 +67,25 @@ func (f *Fixtures) SDInit(moniker string, flags ...string) { // AddGenesisAccount is simd add-genesis-account func (f *Fixtures) AddGenesisAccount(address sdk.AccAddress, coins sdk.Coins, flags ...string) { cmd := fmt.Sprintf("%s add-genesis-account %s %s --home=%s --keyring-backend=test", f.SimdBinary, address, coins, f.SimdHome) - executeWriteCheckErr(f.T, addFlags(cmd, flags)) + ExecuteWriteCheckErr(f.T, AddFlags(cmd, flags)) } // GenTx is simd gentx func (f *Fixtures) GenTx(name string, flags ...string) { cmd := fmt.Sprintf("%s gentx --name=%s --home=%s --home-client=%s --keyring-backend=test", f.SimdBinary, name, f.SimdHome, f.SimcliHome) - executeWriteCheckErr(f.T, addFlags(cmd, flags)) + ExecuteWriteCheckErr(f.T, AddFlags(cmd, flags)) } // CollectGenTxs is simd collect-gentxs func (f *Fixtures) CollectGenTxs(flags ...string) { cmd := fmt.Sprintf("%s collect-gentxs --home=%s", f.SimdBinary, f.SimdHome) - executeWriteCheckErr(f.T, addFlags(cmd, flags)) + ExecuteWriteCheckErr(f.T, AddFlags(cmd, flags)) } // SDStart runs simd start with the appropriate flags and returns a process func (f *Fixtures) SDStart(flags ...string) *tests.Process { cmd := fmt.Sprintf("%s start --home=%s --rpc.laddr=%v --p2p.laddr=%v", f.SimdBinary, f.SimdHome, f.RPCAddr, f.P2PAddr) - proc := tests.GoExecuteTWithStdout(f.T, addFlags(cmd, flags)) + proc := tests.GoExecuteTWithStdout(f.T, AddFlags(cmd, flags)) tests.WaitForTMStart(f.Port) tests.WaitForNextNBlocksTM(1, f.Port) return proc @@ -96,7 +94,7 @@ func (f *Fixtures) SDStart(flags ...string) *tests.Process { // SDTendermint returns the results of simd tendermint [query] func (f *Fixtures) SDTendermint(query string) string { cmd := fmt.Sprintf("%s tendermint %s --home=%s", f.SimdBinary, query, f.SimdHome) - success, stdout, stderr := executeWriteRetStdStreams(f.T, cmd) + success, stdout, stderr := ExecuteWriteRetStdStreams(f.T, cmd) require.Empty(f.T, stderr) require.True(f.T, success) return strings.TrimSpace(stdout) @@ -105,7 +103,7 @@ func (f *Fixtures) SDTendermint(query string) string { // ValidateGenesis runs simd validate-genesis func (f *Fixtures) ValidateGenesis() { cmd := fmt.Sprintf("%s validate-genesis --home=%s", f.SimdBinary, f.SimdHome) - executeWriteCheckErr(f.T, cmd) + ExecuteWriteCheckErr(f.T, cmd) } //___________________________________________________________________________________ @@ -115,35 +113,35 @@ func (f *Fixtures) ValidateGenesis() { func (f *Fixtures) KeysDelete(name string, flags ...string) { cmd := fmt.Sprintf("%s keys delete --keyring-backend=test --home=%s %s", f.SimcliBinary, f.SimcliHome, name) - executeWrite(f.T, addFlags(cmd, append(append(flags, "-y"), "-f"))) + ExecuteWrite(f.T, AddFlags(cmd, append(append(flags, "-y"), "-f"))) } // KeysAdd is simcli keys add func (f *Fixtures) KeysAdd(name string, flags ...string) { cmd := fmt.Sprintf("%s keys add --keyring-backend=test --home=%s %s", f.SimcliBinary, f.SimcliHome, name) - executeWriteCheckErr(f.T, addFlags(cmd, flags)) + ExecuteWriteCheckErr(f.T, AddFlags(cmd, flags)) } // KeysAddRecover prepares simcli keys add --recover func (f *Fixtures) KeysAddRecover(name, mnemonic string, flags ...string) (exitSuccess bool, stdout, stderr string) { cmd := fmt.Sprintf("%s keys add --keyring-backend=test --home=%s --recover %s", f.SimcliBinary, f.SimcliHome, name) - return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), mnemonic) + return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), mnemonic) } // KeysAddRecoverHDPath prepares simcli keys add --recover --account --index func (f *Fixtures) KeysAddRecoverHDPath(name, mnemonic string, account uint32, index uint32, flags ...string) { cmd := fmt.Sprintf("%s keys add --keyring-backend=test --home=%s --recover %s --account %d"+ " --index %d", f.SimcliBinary, f.SimcliHome, name, account, index) - executeWriteCheckErr(f.T, addFlags(cmd, flags), mnemonic) + ExecuteWriteCheckErr(f.T, AddFlags(cmd, flags), mnemonic) } // KeysShow is simcli keys show func (f *Fixtures) KeysShow(name string, flags ...string) keyring.KeyOutput { cmd := fmt.Sprintf("%s keys show --keyring-backend=test --home=%s %s", f.SimcliBinary, f.SimcliHome, name) - out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + out, _ := tests.ExecuteT(f.T, AddFlags(cmd, flags), "") var ko keyring.KeyOutput err := clientkeys.UnmarshalJSON([]byte(out), &ko) require.NoError(f.T, err) @@ -164,33 +162,33 @@ func (f *Fixtures) KeyAddress(name string) sdk.AccAddress { // CLIConfig is simcli config func (f *Fixtures) CLIConfig(key, value string, flags ...string) { cmd := fmt.Sprintf("%s config --home=%s %s %s", f.SimcliBinary, f.SimcliHome, key, value) - executeWriteCheckErr(f.T, addFlags(cmd, flags)) + ExecuteWriteCheckErr(f.T, AddFlags(cmd, flags)) } // TxSend is gaiacli tx send func (f *Fixtures) TxSend(from string, to sdk.AccAddress, amount sdk.Coin, flags ...string) (bool, string, string) { cmd := fmt.Sprintf("%s tx send --keyring-backend=test %s %s %s %v", f.SimcliBinary, from, to, amount, f.Flags()) - return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) + return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } // TxSign is gaiacli tx sign func (f *Fixtures) TxSign(signer, fileName string, flags ...string) (bool, string, string) { cmd := fmt.Sprintf("%s tx sign %v --keyring-backend=test --from=%s %v", f.SimcliBinary, f.Flags(), signer, fileName) - return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) + return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } // TxBroadcast is gaiacli tx broadcast func (f *Fixtures) TxBroadcast(fileName string, flags ...string) (bool, string, string) { cmd := fmt.Sprintf("%s tx broadcast %v %v", f.SimcliBinary, f.Flags(), fileName) - return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) + return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } // TxEncode is gaiacli tx encode func (f *Fixtures) TxEncode(fileName string, flags ...string) (bool, string, string) { cmd := fmt.Sprintf("%s tx encode %v %v", f.SimcliBinary, f.Flags(), fileName) - return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) + return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } // TxMultisign is gaiacli tx multisign @@ -200,80 +198,5 @@ func (f *Fixtures) TxMultisign(fileName, name string, signaturesFiles []string, cmd := fmt.Sprintf("%s tx multisign --keyring-backend=test %v %s %s %s", f.SimcliBinary, f.Flags(), fileName, name, strings.Join(signaturesFiles, " "), ) - return executeWriteRetStdStreams(f.T, addFlags(cmd, flags)) -} - -//___________________________________________________________________________________ -// gaiacli tx staking - -// TxStakingCreateValidator is gaiacli tx staking create-validator -func (f *Fixtures) TxStakingCreateValidator(from, consPubKey string, amount sdk.Coin, flags ...string) (bool, string, string) { - cmd := fmt.Sprintf("%s tx staking create-validator %v --keyring-backend=test --from=%s"+ - " --pubkey=%s", f.SimcliBinary, f.Flags(), from, consPubKey) - cmd += fmt.Sprintf(" --amount=%v --moniker=%v --commission-rate=%v", amount, from, "0.05") - cmd += fmt.Sprintf(" --commission-max-rate=%v --commission-max-change-rate=%v", "0.20", "0.10") - cmd += fmt.Sprintf(" --min-self-delegation=%v", "1") - return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) -} - -// TxStakingUnbond is gaiacli tx staking unbond -func (f *Fixtures) TxStakingUnbond(from, shares string, validator sdk.ValAddress, flags ...string) bool { - cmd := fmt.Sprintf("%s tx staking unbond --keyring-backend=test %s %v --from=%s %v", - f.SimcliBinary, validator, shares, from, f.Flags()) - return executeWrite(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) -} - -// QueryStakingValidator is gaiacli query staking validator -func (f *Fixtures) QueryStakingValidator(valAddr sdk.ValAddress, flags ...string) staking.Validator { - cmd := fmt.Sprintf("%s query staking validator %s %v", f.SimcliBinary, valAddr, f.Flags()) - out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") - var validator staking.Validator - - err := cdc.UnmarshalJSON([]byte(out), &validator) - require.NoError(f.T, err, "out %v\n, err %v", out, err) - return validator -} - -// QueryStakingUnbondingDelegationsFrom is gaiacli query staking unbonding-delegations-from -func (f *Fixtures) QueryStakingUnbondingDelegationsFrom(valAddr sdk.ValAddress, flags ...string) []staking.UnbondingDelegation { - cmd := fmt.Sprintf("%s query staking unbonding-delegations-from %s %v", f.SimcliBinary, valAddr, f.Flags()) - out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") - var ubds []staking.UnbondingDelegation - - err := cdc.UnmarshalJSON([]byte(out), &ubds) - require.NoError(f.T, err, "out %v\n, err %v", out, err) - return ubds -} - -// QueryStakingDelegationsTo is gaiacli query staking delegations-to -func (f *Fixtures) QueryStakingDelegationsTo(valAddr sdk.ValAddress, flags ...string) []staking.Delegation { - cmd := fmt.Sprintf("%s query staking delegations-to %s %v", f.SimcliBinary, valAddr, f.Flags()) - out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") - var delegations []staking.Delegation - - err := cdc.UnmarshalJSON([]byte(out), &delegations) - require.NoError(f.T, err, "out %v\n, err %v", out, err) - return delegations -} - -// QueryStakingPool is gaiacli query staking pool -func (f *Fixtures) QueryStakingPool(flags ...string) staking.Pool { - cmd := fmt.Sprintf("%s query staking pool %v", f.SimcliBinary, f.Flags()) - out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") - var pool staking.Pool - - err := cdc.UnmarshalJSON([]byte(out), &pool) - require.NoError(f.T, err, "out %v\n, err %v", out, err) - return pool -} - -// QueryStakingParameters is gaiacli query staking parameters -func (f *Fixtures) QueryStakingParameters(flags ...string) staking.Params { - cmd := fmt.Sprintf("%s query staking params %v", f.SimcliBinary, f.Flags()) - out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") - var params staking.Params - - err := cdc.UnmarshalJSON([]byte(out), ¶ms) - require.NoError(f.T, err, "out %v\n, err %v", out, err) - return params + return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags)) } diff --git a/cli_test/helpers/utils.go b/cli_test/helpers/utils.go index b9676270d70e..464e27de5ebf 100644 --- a/cli_test/helpers/utils.go +++ b/cli_test/helpers/utils.go @@ -2,7 +2,7 @@ package helpers import "strings" -func addFlags(cmd string, flags []string) string { +func AddFlags(cmd string, flags []string) string { for _, f := range flags { cmd += " " + f } diff --git a/cli_test/tests/codec.go b/cli_test/tests/codec.go deleted file mode 100644 index b04742b3db3b..000000000000 --- a/cli_test/tests/codec.go +++ /dev/null @@ -1,16 +0,0 @@ -package tests - -import ( - codecstd "github.com/cosmos/cosmos-sdk/codec/std" - "github.com/cosmos/cosmos-sdk/simapp" - authclient "github.com/cosmos/cosmos-sdk/x/auth/client" -) - -var ( - cdc = codecstd.MakeCodec(simapp.ModuleBasics) - appCodec = codecstd.NewAppCodec(cdc) -) - -func init() { - authclient.Codec = appCodec -} From 82c0abc5fb921d1c938e2d6e0093b4580050f7c1 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Thu, 23 Apr 2020 18:42:47 +0530 Subject: [PATCH 23/61] Moved helpers to bank --- cli_test/helpers/helpers.go | 47 +++++++++++----------------------- x/bank/client/cli/helpers.go | 26 +++++++++++++++++++ x/bank/client/cli/send_test.go | 16 ++++++------ 3 files changed, 49 insertions(+), 40 deletions(-) create mode 100644 x/bank/client/cli/helpers.go diff --git a/cli_test/helpers/helpers.go b/cli_test/helpers/helpers.go index a81755262afb..e4a9722092fd 100644 --- a/cli_test/helpers/helpers.go +++ b/cli_test/helpers/helpers.go @@ -3,6 +3,8 @@ package helpers import ( "encoding/json" "fmt" + "github.com/cosmos/cosmos-sdk/x/auth" + "github.com/cosmos/cosmos-sdk/x/staking" "os" "path/filepath" "strings" @@ -165,13 +167,6 @@ func (f *Fixtures) CLIConfig(key, value string, flags ...string) { ExecuteWriteCheckErr(f.T, AddFlags(cmd, flags)) } -// TxSend is gaiacli tx send -func (f *Fixtures) TxSend(from string, to sdk.AccAddress, amount sdk.Coin, flags ...string) (bool, string, string) { - cmd := fmt.Sprintf("%s tx send --keyring-backend=test %s %s %s %v", f.SimcliBinary, from, - to, amount, f.Flags()) - return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) -} - // TxSign is gaiacli tx sign func (f *Fixtures) TxSign(signer, fileName string, flags ...string) (bool, string, string) { cmd := fmt.Sprintf("%s tx sign %v --keyring-backend=test --from=%s %v", f.SimcliBinary, @@ -191,16 +186,6 @@ func (f *Fixtures) TxEncode(fileName string, flags ...string) (bool, string, str return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } -// TxMultisign is gaiacli tx multisign -func (f *Fixtures) TxMultisign(fileName, name string, signaturesFiles []string, - flags ...string) (bool, string, string) { - - cmd := fmt.Sprintf("%s tx multisign --keyring-backend=test %v %s %s %s", f.SimcliBinary, f.Flags(), - fileName, name, strings.Join(signaturesFiles, " "), - ) - return executeWriteRetStdStreams(f.T, addFlags(cmd, flags)) -} - //___________________________________________________________________________________ // gaiacli tx staking @@ -211,38 +196,38 @@ func (f *Fixtures) TxStakingCreateValidator(from, consPubKey string, amount sdk. cmd += fmt.Sprintf(" --amount=%v --moniker=%v --commission-rate=%v", amount, from, "0.05") cmd += fmt.Sprintf(" --commission-max-rate=%v --commission-max-change-rate=%v", "0.20", "0.10") cmd += fmt.Sprintf(" --min-self-delegation=%v", "1") - return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) + return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } func (f *Fixtures) TxStakingEditValidator(from string, flags ...string) (bool, string, string) { cmd := fmt.Sprintf("%s tx staking edit-validator %v --keyring-backend=test "+ "--from=%s", f.SimcliBinary, f.Flags(), from) - return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) + return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } func (f *Fixtures) TxStakingDelegate(validatorOperatorAddress, from string, amount sdk.Coin, flags ...string) (bool, string, string) { cmd := fmt.Sprintf("%s tx staking delegate %s %v %v --keyring-backend=test "+ "--from=%s", f.SimcliBinary, validatorOperatorAddress, amount, f.Flags(), from) - return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) + return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } func (f *Fixtures) TxStakingReDelegate(srcOperatorAddress, dstOperatorAddress, from string, amount sdk.Coin, flags ...string) (bool, string, string) { cmd := fmt.Sprintf("%s tx staking redelegate %s %s %v %v --keyring-backend=test "+ "--from=%s", f.SimcliBinary, srcOperatorAddress, dstOperatorAddress, amount, f.Flags(), from) - return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) + return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } // TxStakingUnbond is gaiacli tx staking unbond func (f *Fixtures) TxStakingUnbond(from, shares string, validator sdk.ValAddress, flags ...string) bool { cmd := fmt.Sprintf("%s tx staking unbond --keyring-backend=test %s %v --from=%s %v", f.SimcliBinary, validator, shares, from, f.Flags()) - return executeWrite(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass) + return ExecuteWrite(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } // QueryStakingValidator is gaiacli query staking validator func (f *Fixtures) QueryStakingValidator(valAddr sdk.ValAddress, flags ...string) staking.Validator { cmd := fmt.Sprintf("%s query staking validator %s %v", f.SimcliBinary, valAddr, f.Flags()) - out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + out, _ := tests.ExecuteT(f.T, AddFlags(cmd, flags), "") var validator staking.Validator err := f.Cdc.UnmarshalJSON([]byte(out), &validator) @@ -253,7 +238,7 @@ func (f *Fixtures) QueryStakingValidator(valAddr sdk.ValAddress, flags ...string // QueryStakingUnbondingDelegationsFrom is gaiacli query staking unbonding-delegations-from func (f *Fixtures) QueryStakingUnbondingDelegationsFrom(valAddr sdk.ValAddress, flags ...string) []staking.UnbondingDelegation { cmd := fmt.Sprintf("%s query staking unbonding-delegations-from %s %v", f.SimcliBinary, valAddr, f.Flags()) - out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + out, _ := tests.ExecuteT(f.T, AddFlags(cmd, flags), "") var ubds []staking.UnbondingDelegation err := f.Cdc.UnmarshalJSON([]byte(out), &ubds) @@ -264,7 +249,7 @@ func (f *Fixtures) QueryStakingUnbondingDelegationsFrom(valAddr sdk.ValAddress, // QueryStakingDelegationsTo is gaiacli query staking delegations-to func (f *Fixtures) QueryStakingDelegationsTo(valAddr sdk.ValAddress, flags ...string) []staking.Delegation { cmd := fmt.Sprintf("%s query staking delegations-to %s %v", f.SimcliBinary, valAddr, f.Flags()) - out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + out, _ := tests.ExecuteT(f.T, AddFlags(cmd, flags), "") var delegations []staking.Delegation err := f.Cdc.UnmarshalJSON([]byte(out), &delegations) @@ -275,7 +260,7 @@ func (f *Fixtures) QueryStakingDelegationsTo(valAddr sdk.ValAddress, flags ...st // QueryStakingPool is gaiacli query staking pool func (f *Fixtures) QueryStakingPool(flags ...string) staking.Pool { cmd := fmt.Sprintf("%s query staking pool %v", f.SimcliBinary, f.Flags()) - out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + out, _ := tests.ExecuteT(f.T, AddFlags(cmd, flags), "") var pool staking.Pool err := f.Cdc.UnmarshalJSON([]byte(out), &pool) @@ -286,7 +271,7 @@ func (f *Fixtures) QueryStakingPool(flags ...string) staking.Pool { // QueryStakingParameters is gaiacli query staking parameters func (f *Fixtures) QueryStakingParameters(flags ...string) staking.Params { cmd := fmt.Sprintf("%s query staking params %v", f.SimcliBinary, f.Flags()) - out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + out, _ := tests.ExecuteT(f.T, AddFlags(cmd, flags), "") var params staking.Params err := f.Cdc.UnmarshalJSON([]byte(out), ¶ms) @@ -300,15 +285,13 @@ func (f *Fixtures) QueryStakingParameters(flags ...string) staking.Params { // QueryAccount is gaiacli query account func (f *Fixtures) QueryAccount(address sdk.AccAddress, flags ...string) auth.BaseAccount { cmd := fmt.Sprintf("%s query account %s %v", f.SimcliBinary, address, f.Flags()) - out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + out, _ := tests.ExecuteT(f.T, AddFlags(cmd, flags), "") var initRes map[string]json.RawMessage err := json.Unmarshal([]byte(out), &initRes) require.NoError(f.T, err, "out %v, err %v", out, err) value := initRes["value"] var acc auth.BaseAccount - cdc := codec.New() - codec.RegisterCrypto(cdc) - err = cdc.UnmarshalJSON(value, &acc) + err = f.Cdc.UnmarshalJSON(value, &acc) require.NoError(f.T, err, "value %v, err %v", string(value), err) return acc } @@ -317,7 +300,7 @@ func (f *Fixtures) QueryAccount(address sdk.AccAddress, flags ...string) auth.Ba // flag set. func (f *Fixtures) QueryBalances(address sdk.AccAddress, flags ...string) sdk.Coins { cmd := fmt.Sprintf("%s query bank balances %s %v", f.SimcliBinary, address, f.Flags()) - out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "") + out, _ := tests.ExecuteT(f.T, AddFlags(cmd, flags), "") var balances sdk.Coins diff --git a/x/bank/client/cli/helpers.go b/x/bank/client/cli/helpers.go new file mode 100644 index 000000000000..8ba2ffffd9db --- /dev/null +++ b/x/bank/client/cli/helpers.go @@ -0,0 +1,26 @@ +package cli + +import ( + "fmt" + "github.com/cosmos/cosmos-sdk/cli_test/helpers" + clientkeys "github.com/cosmos/cosmos-sdk/client/keys" + sdk "github.com/cosmos/cosmos-sdk/types" + "strings" +) + +// TxSend is gaiacli tx send +func TxSend(f *helpers.Fixtures, from string, to sdk.AccAddress, amount sdk.Coin, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx send --keyring-backend=test %s %s %s %v", f.SimcliBinary, from, + to, amount, f.Flags()) + return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +// TxMultisign is gaiacli tx multisign +func TxMultisign(f *helpers.Fixtures, fileName, name string, signaturesFiles []string, + flags ...string) (bool, string, string) { + + cmd := fmt.Sprintf("%s tx multisign --keyring-backend=test %v %s %s %s", f.SimcliBinary, f.Flags(), + fileName, name, strings.Join(signaturesFiles, " "), + ) + return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags)) +} diff --git a/x/bank/client/cli/send_test.go b/x/bank/client/cli/send_test.go index 370726bf9371..f0efa252c9c5 100644 --- a/x/bank/client/cli/send_test.go +++ b/x/bank/client/cli/send_test.go @@ -1,4 +1,4 @@ -package cli_test +package cli import ( "github.com/cosmos/cosmos-sdk/cli_test/helpers" @@ -26,13 +26,13 @@ func TestCLISend(t *testing.T) { sendTokens := sdk.TokensFromConsensusPower(10) // It does not allow to send in offline mode - success, _, stdErr := f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y", "--offline") + success, _, stdErr := TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y", "--offline") require.Contains(t, stdErr, "no RPC client is defined in offline mode") require.False(f.T, success) tests.WaitForNextNBlocksTM(1, f.Port) // Send some tokens from one account to the other - f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") + TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") tests.WaitForNextNBlocksTM(1, f.Port) // Ensure account balances match expected @@ -40,12 +40,12 @@ func TestCLISend(t *testing.T) { require.Equal(t, startTokens.Sub(sendTokens), f.QueryBalances(fooAddr).AmountOf(helpers.Denom)) // Test --dry-run - success, _, _ = f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "--dry-run") + success, _, _ = TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "--dry-run") require.True(t, success) // Test --generate-only - success, stdout, stderr := f.TxSend( - fooAddr.String(), barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "--generate-only=true", + success, stdout, stderr := TxSend( + f, fooAddr.String(), barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "--generate-only=true", ) require.Empty(t, stderr) require.True(t, success) @@ -59,7 +59,7 @@ func TestCLISend(t *testing.T) { require.Equal(t, startTokens.Sub(sendTokens), f.QueryBalances(fooAddr).AmountOf(helpers.Denom)) // test autosequencing - f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") + TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") tests.WaitForNextNBlocksTM(1, f.Port) // Ensure account balances match expected @@ -67,7 +67,7 @@ func TestCLISend(t *testing.T) { require.Equal(t, startTokens.Sub(sendTokens.MulRaw(2)), f.QueryBalances(fooAddr).AmountOf(helpers.Denom)) // test memo - f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "--memo='testmemo'", "-y") + TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "--memo='testmemo'", "-y") tests.WaitForNextNBlocksTM(1, f.Port) // Ensure account balances match expected From e67c9656bdf9b0a91ed4d0158e59c75b4b852473 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Thu, 23 Apr 2020 18:49:42 +0530 Subject: [PATCH 24/61] Added codec to fixtures --- cli_test/helpers/fixtures.go | 1 + 1 file changed, 1 insertion(+) diff --git a/cli_test/helpers/fixtures.go b/cli_test/helpers/fixtures.go index 12df809e5329..c0a9988e4e03 100644 --- a/cli_test/helpers/fixtures.go +++ b/cli_test/helpers/fixtures.go @@ -66,6 +66,7 @@ func NewFixtures(t *testing.T) *Fixtures { SimcliHome: filepath.Join(tmpDir, ".simcli"), RPCAddr: servAddr, P2PAddr: p2pAddr, + Cdc: cdc, Port: port, } } From 71365b7e2fe2c09504fd085348b8f3aa8cd13870 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Thu, 23 Apr 2020 22:02:32 +0530 Subject: [PATCH 25/61] Migrated tests to modules --- cli_test/helpers/helpers.go | 132 ------------------ x/bank/client/cli/helpers.go | 26 ---- x/bank/client/cli_test/helpers.go | 57 ++++++++ x/bank/client/{cli => cli_test}/send_test.go | 31 ++-- x/staking/client/cli_test/helpers.go | 101 ++++++++++++++ .../client/{cli => cli_test}/staking_test.go | 29 ++-- 6 files changed, 188 insertions(+), 188 deletions(-) delete mode 100644 x/bank/client/cli/helpers.go create mode 100644 x/bank/client/cli_test/helpers.go rename x/bank/client/{cli => cli_test}/send_test.go (51%) create mode 100644 x/staking/client/cli_test/helpers.go rename x/staking/client/{cli => cli_test}/staking_test.go (61%) diff --git a/cli_test/helpers/helpers.go b/cli_test/helpers/helpers.go index e4a9722092fd..88969f60edcc 100644 --- a/cli_test/helpers/helpers.go +++ b/cli_test/helpers/helpers.go @@ -3,8 +3,6 @@ package helpers import ( "encoding/json" "fmt" - "github.com/cosmos/cosmos-sdk/x/auth" - "github.com/cosmos/cosmos-sdk/x/staking" "os" "path/filepath" "strings" @@ -167,13 +165,6 @@ func (f *Fixtures) CLIConfig(key, value string, flags ...string) { ExecuteWriteCheckErr(f.T, AddFlags(cmd, flags)) } -// TxSign is gaiacli tx sign -func (f *Fixtures) TxSign(signer, fileName string, flags ...string) (bool, string, string) { - cmd := fmt.Sprintf("%s tx sign %v --keyring-backend=test --from=%s %v", f.SimcliBinary, - f.Flags(), signer, fileName) - return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) -} - // TxBroadcast is gaiacli tx broadcast func (f *Fixtures) TxBroadcast(fileName string, flags ...string) (bool, string, string) { cmd := fmt.Sprintf("%s tx broadcast %v %v", f.SimcliBinary, f.Flags(), fileName) @@ -185,126 +176,3 @@ func (f *Fixtures) TxEncode(fileName string, flags ...string) (bool, string, str cmd := fmt.Sprintf("%s tx encode %v %v", f.SimcliBinary, f.Flags(), fileName) return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } - -//___________________________________________________________________________________ -// gaiacli tx staking - -// TxStakingCreateValidator is gaiacli tx staking create-validator -func (f *Fixtures) TxStakingCreateValidator(from, consPubKey string, amount sdk.Coin, flags ...string) (bool, string, string) { - cmd := fmt.Sprintf("%s tx staking create-validator %v --keyring-backend=test --from=%s"+ - " --pubkey=%s", f.SimcliBinary, f.Flags(), from, consPubKey) - cmd += fmt.Sprintf(" --amount=%v --moniker=%v --commission-rate=%v", amount, from, "0.05") - cmd += fmt.Sprintf(" --commission-max-rate=%v --commission-max-change-rate=%v", "0.20", "0.10") - cmd += fmt.Sprintf(" --min-self-delegation=%v", "1") - return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) -} - -func (f *Fixtures) TxStakingEditValidator(from string, flags ...string) (bool, string, string) { - cmd := fmt.Sprintf("%s tx staking edit-validator %v --keyring-backend=test "+ - "--from=%s", f.SimcliBinary, f.Flags(), from) - return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) -} - -func (f *Fixtures) TxStakingDelegate(validatorOperatorAddress, from string, amount sdk.Coin, flags ...string) (bool, string, string) { - cmd := fmt.Sprintf("%s tx staking delegate %s %v %v --keyring-backend=test "+ - "--from=%s", f.SimcliBinary, validatorOperatorAddress, amount, f.Flags(), from) - return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) -} - -func (f *Fixtures) TxStakingReDelegate(srcOperatorAddress, dstOperatorAddress, from string, amount sdk.Coin, flags ...string) (bool, string, string) { - cmd := fmt.Sprintf("%s tx staking redelegate %s %s %v %v --keyring-backend=test "+ - "--from=%s", f.SimcliBinary, srcOperatorAddress, dstOperatorAddress, amount, f.Flags(), from) - return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) -} - -// TxStakingUnbond is gaiacli tx staking unbond -func (f *Fixtures) TxStakingUnbond(from, shares string, validator sdk.ValAddress, flags ...string) bool { - cmd := fmt.Sprintf("%s tx staking unbond --keyring-backend=test %s %v --from=%s %v", - f.SimcliBinary, validator, shares, from, f.Flags()) - return ExecuteWrite(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) -} - -// QueryStakingValidator is gaiacli query staking validator -func (f *Fixtures) QueryStakingValidator(valAddr sdk.ValAddress, flags ...string) staking.Validator { - cmd := fmt.Sprintf("%s query staking validator %s %v", f.SimcliBinary, valAddr, f.Flags()) - out, _ := tests.ExecuteT(f.T, AddFlags(cmd, flags), "") - var validator staking.Validator - - err := f.Cdc.UnmarshalJSON([]byte(out), &validator) - require.NoError(f.T, err, "out %v\n, err %v", out, err) - return validator -} - -// QueryStakingUnbondingDelegationsFrom is gaiacli query staking unbonding-delegations-from -func (f *Fixtures) QueryStakingUnbondingDelegationsFrom(valAddr sdk.ValAddress, flags ...string) []staking.UnbondingDelegation { - cmd := fmt.Sprintf("%s query staking unbonding-delegations-from %s %v", f.SimcliBinary, valAddr, f.Flags()) - out, _ := tests.ExecuteT(f.T, AddFlags(cmd, flags), "") - var ubds []staking.UnbondingDelegation - - err := f.Cdc.UnmarshalJSON([]byte(out), &ubds) - require.NoError(f.T, err, "out %v\n, err %v", out, err) - return ubds -} - -// QueryStakingDelegationsTo is gaiacli query staking delegations-to -func (f *Fixtures) QueryStakingDelegationsTo(valAddr sdk.ValAddress, flags ...string) []staking.Delegation { - cmd := fmt.Sprintf("%s query staking delegations-to %s %v", f.SimcliBinary, valAddr, f.Flags()) - out, _ := tests.ExecuteT(f.T, AddFlags(cmd, flags), "") - var delegations []staking.Delegation - - err := f.Cdc.UnmarshalJSON([]byte(out), &delegations) - require.NoError(f.T, err, "out %v\n, err %v", out, err) - return delegations -} - -// QueryStakingPool is gaiacli query staking pool -func (f *Fixtures) QueryStakingPool(flags ...string) staking.Pool { - cmd := fmt.Sprintf("%s query staking pool %v", f.SimcliBinary, f.Flags()) - out, _ := tests.ExecuteT(f.T, AddFlags(cmd, flags), "") - var pool staking.Pool - - err := f.Cdc.UnmarshalJSON([]byte(out), &pool) - require.NoError(f.T, err, "out %v\n, err %v", out, err) - return pool -} - -// QueryStakingParameters is gaiacli query staking parameters -func (f *Fixtures) QueryStakingParameters(flags ...string) staking.Params { - cmd := fmt.Sprintf("%s query staking params %v", f.SimcliBinary, f.Flags()) - out, _ := tests.ExecuteT(f.T, AddFlags(cmd, flags), "") - var params staking.Params - - err := f.Cdc.UnmarshalJSON([]byte(out), ¶ms) - require.NoError(f.T, err, "out %v\n, err %v", out, err) - return params -} - -//___________________________________________________________________________________ -// gaiacli query account - -// QueryAccount is gaiacli query account -func (f *Fixtures) QueryAccount(address sdk.AccAddress, flags ...string) auth.BaseAccount { - cmd := fmt.Sprintf("%s query account %s %v", f.SimcliBinary, address, f.Flags()) - out, _ := tests.ExecuteT(f.T, AddFlags(cmd, flags), "") - var initRes map[string]json.RawMessage - err := json.Unmarshal([]byte(out), &initRes) - require.NoError(f.T, err, "out %v, err %v", out, err) - value := initRes["value"] - var acc auth.BaseAccount - err = f.Cdc.UnmarshalJSON(value, &acc) - require.NoError(f.T, err, "value %v, err %v", string(value), err) - return acc -} - -// QueryBalances executes the bank query balances command for a given address and -// flag set. -func (f *Fixtures) QueryBalances(address sdk.AccAddress, flags ...string) sdk.Coins { - cmd := fmt.Sprintf("%s query bank balances %s %v", f.SimcliBinary, address, f.Flags()) - out, _ := tests.ExecuteT(f.T, AddFlags(cmd, flags), "") - - var balances sdk.Coins - - require.NoError(f.T, f.Cdc.UnmarshalJSON([]byte(out), &balances), "out %v\n", out) - - return balances -} diff --git a/x/bank/client/cli/helpers.go b/x/bank/client/cli/helpers.go deleted file mode 100644 index 8ba2ffffd9db..000000000000 --- a/x/bank/client/cli/helpers.go +++ /dev/null @@ -1,26 +0,0 @@ -package cli - -import ( - "fmt" - "github.com/cosmos/cosmos-sdk/cli_test/helpers" - clientkeys "github.com/cosmos/cosmos-sdk/client/keys" - sdk "github.com/cosmos/cosmos-sdk/types" - "strings" -) - -// TxSend is gaiacli tx send -func TxSend(f *helpers.Fixtures, from string, to sdk.AccAddress, amount sdk.Coin, flags ...string) (bool, string, string) { - cmd := fmt.Sprintf("%s tx send --keyring-backend=test %s %s %s %v", f.SimcliBinary, from, - to, amount, f.Flags()) - return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) -} - -// TxMultisign is gaiacli tx multisign -func TxMultisign(f *helpers.Fixtures, fileName, name string, signaturesFiles []string, - flags ...string) (bool, string, string) { - - cmd := fmt.Sprintf("%s tx multisign --keyring-backend=test %v %s %s %s", f.SimcliBinary, f.Flags(), - fileName, name, strings.Join(signaturesFiles, " "), - ) - return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags)) -} diff --git a/x/bank/client/cli_test/helpers.go b/x/bank/client/cli_test/helpers.go new file mode 100644 index 000000000000..e764b2426536 --- /dev/null +++ b/x/bank/client/cli_test/helpers.go @@ -0,0 +1,57 @@ +package cli + +import ( + "encoding/json" + "fmt" + "github.com/cosmos/cosmos-sdk/cli_test/helpers" + clientkeys "github.com/cosmos/cosmos-sdk/client/keys" + "github.com/cosmos/cosmos-sdk/tests" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/auth" + "github.com/stretchr/testify/require" + "strings" +) + +// TxSend is gaiacli tx send +func TxSend(f *helpers.Fixtures, from string, to sdk.AccAddress, amount sdk.Coin, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx send --keyring-backend=test %s %s %s %v", f.SimcliBinary, from, + to, amount, f.Flags()) + return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +// TxMultisign is gaiacli tx multisign +func TxMultisign(f *helpers.Fixtures, fileName, name string, signaturesFiles []string, + flags ...string) (bool, string, string) { + + cmd := fmt.Sprintf("%s tx multisign --keyring-backend=test %v %s %s %s", f.SimcliBinary, f.Flags(), + fileName, name, strings.Join(signaturesFiles, " "), + ) + return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags)) +} + +// QueryAccount is gaiacli query account +func QueryAccount(f *helpers.Fixtures, address sdk.AccAddress, flags ...string) auth.BaseAccount { + cmd := fmt.Sprintf("%s query account %s %v", f.SimcliBinary, address, f.Flags()) + out, _ := tests.ExecuteT(f.T, helpers.AddFlags(cmd, flags), "") + var initRes map[string]json.RawMessage + err := json.Unmarshal([]byte(out), &initRes) + require.NoError(f.T, err, "out %v, err %v", out, err) + value := initRes["value"] + var acc auth.BaseAccount + err = f.Cdc.UnmarshalJSON(value, &acc) + require.NoError(f.T, err, "value %v, err %v", string(value), err) + return acc +} + +// QueryBalances executes the bank query balances command for a given address and +// flag set. +func QueryBalances(f *helpers.Fixtures, address sdk.AccAddress, flags ...string) sdk.Coins { + cmd := fmt.Sprintf("%s query bank balances %s %v", f.SimcliBinary, address, f.Flags()) + out, _ := tests.ExecuteT(f.T, helpers.AddFlags(cmd, flags), "") + + var balances sdk.Coins + + require.NoError(f.T, f.Cdc.UnmarshalJSON([]byte(out), &balances), "out %v\n", out) + + return balances +} diff --git a/x/bank/client/cli/send_test.go b/x/bank/client/cli_test/send_test.go similarity index 51% rename from x/bank/client/cli/send_test.go rename to x/bank/client/cli_test/send_test.go index f0efa252c9c5..b15aeb70849f 100644 --- a/x/bank/client/cli/send_test.go +++ b/x/bank/client/cli_test/send_test.go @@ -1,9 +1,10 @@ -package cli +package cli_test import ( "github.com/cosmos/cosmos-sdk/cli_test/helpers" "github.com/cosmos/cosmos-sdk/tests" sdk "github.com/cosmos/cosmos-sdk/types" + bankcli "github.com/cosmos/cosmos-sdk/x/bank/client/cli_test" "github.com/stretchr/testify/require" "testing" ) @@ -21,30 +22,30 @@ func TestCLISend(t *testing.T) { barAddr := f.KeyAddress(helpers.KeyBar) startTokens := sdk.TokensFromConsensusPower(50) - require.Equal(t, startTokens, f.QueryBalances(fooAddr).AmountOf(helpers.Denom)) + require.Equal(t, startTokens, bankcli.QueryBalances(f, fooAddr).AmountOf(helpers.Denom)) sendTokens := sdk.TokensFromConsensusPower(10) // It does not allow to send in offline mode - success, _, stdErr := TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y", "--offline") + success, _, stdErr := bankcli.TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y", "--offline") require.Contains(t, stdErr, "no RPC client is defined in offline mode") require.False(f.T, success) tests.WaitForNextNBlocksTM(1, f.Port) // Send some tokens from one account to the other - TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") + bankcli.TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") tests.WaitForNextNBlocksTM(1, f.Port) // Ensure account balances match expected - require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(helpers.Denom)) - require.Equal(t, startTokens.Sub(sendTokens), f.QueryBalances(fooAddr).AmountOf(helpers.Denom)) + require.Equal(t, sendTokens, bankcli.QueryBalances(f, barAddr).AmountOf(helpers.Denom)) + require.Equal(t, startTokens.Sub(sendTokens), bankcli.QueryBalances(f, fooAddr).AmountOf(helpers.Denom)) // Test --dry-run - success, _, _ = TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "--dry-run") + success, _, _ = bankcli.TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "--dry-run") require.True(t, success) // Test --generate-only - success, stdout, stderr := TxSend( + success, stdout, stderr := bankcli.TxSend( f, fooAddr.String(), barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "--generate-only=true", ) require.Empty(t, stderr) @@ -56,23 +57,23 @@ func TestCLISend(t *testing.T) { require.Len(t, msg.GetSignatures(), 0) // Check state didn't change - require.Equal(t, startTokens.Sub(sendTokens), f.QueryBalances(fooAddr).AmountOf(helpers.Denom)) + require.Equal(t, startTokens.Sub(sendTokens), bankcli.QueryBalances(f, fooAddr).AmountOf(helpers.Denom)) // test autosequencing - TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") + bankcli.TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") tests.WaitForNextNBlocksTM(1, f.Port) // Ensure account balances match expected - require.Equal(t, sendTokens.MulRaw(2), f.QueryBalances(barAddr).AmountOf(helpers.Denom)) - require.Equal(t, startTokens.Sub(sendTokens.MulRaw(2)), f.QueryBalances(fooAddr).AmountOf(helpers.Denom)) + require.Equal(t, sendTokens.MulRaw(2), bankcli.QueryBalances(f, barAddr).AmountOf(helpers.Denom)) + require.Equal(t, startTokens.Sub(sendTokens.MulRaw(2)), bankcli.QueryBalances(f, fooAddr).AmountOf(helpers.Denom)) // test memo - TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "--memo='testmemo'", "-y") + bankcli.TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "--memo='testmemo'", "-y") tests.WaitForNextNBlocksTM(1, f.Port) // Ensure account balances match expected - require.Equal(t, sendTokens.MulRaw(3), f.QueryBalances(barAddr).AmountOf(helpers.Denom)) - require.Equal(t, startTokens.Sub(sendTokens.MulRaw(3)), f.QueryBalances(fooAddr).AmountOf(helpers.Denom)) + require.Equal(t, sendTokens.MulRaw(3), bankcli.QueryBalances(f, barAddr).AmountOf(helpers.Denom)) + require.Equal(t, startTokens.Sub(sendTokens.MulRaw(3)), bankcli.QueryBalances(f, fooAddr).AmountOf(helpers.Denom)) f.Cleanup() } diff --git a/x/staking/client/cli_test/helpers.go b/x/staking/client/cli_test/helpers.go new file mode 100644 index 000000000000..165d737910c6 --- /dev/null +++ b/x/staking/client/cli_test/helpers.go @@ -0,0 +1,101 @@ +package cli + +import ( + "fmt" + "github.com/cosmos/cosmos-sdk/cli_test/helpers" + clientkeys "github.com/cosmos/cosmos-sdk/client/keys" + "github.com/cosmos/cosmos-sdk/tests" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/staking" + "github.com/stretchr/testify/require" +) + +// TxStakingCreateValidator is simcli tx staking create-validator +func TxStakingCreateValidator(f *helpers.Fixtures, from, consPubKey string, amount sdk.Coin, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx staking create-validator %v --keyring-backend=test --from=%s"+ + " --pubkey=%s", f.SimcliBinary, f.Flags(), from, consPubKey) + cmd += fmt.Sprintf(" --amount=%v --moniker=%v --commission-rate=%v", amount, from, "0.05") + cmd += fmt.Sprintf(" --commission-max-rate=%v --commission-max-change-rate=%v", "0.20", "0.10") + cmd += fmt.Sprintf(" --min-self-delegation=%v", "1") + return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +func TxStakingEditValidator(f *helpers.Fixtures, from string, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx staking edit-validator %v --keyring-backend=test "+ + "--from=%s", f.SimcliBinary, f.Flags(), from) + return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +func TxStakingDelegate(f *helpers.Fixtures, validatorOperatorAddress, from string, amount sdk.Coin, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx staking delegate %s %v %v --keyring-backend=test "+ + "--from=%s", f.SimcliBinary, validatorOperatorAddress, amount, f.Flags(), from) + return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +func TxStakingReDelegate(f *helpers.Fixtures, srcOperatorAddress, dstOperatorAddress, from string, amount sdk.Coin, flags ...string) (bool, string, string) { + cmd := fmt.Sprintf("%s tx staking redelegate %s %s %v %v --keyring-backend=test "+ + "--from=%s", f.SimcliBinary, srcOperatorAddress, dstOperatorAddress, amount, f.Flags(), from) + return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +// TxStakingUnbond is simcli tx staking unbond +func TxStakingUnbond(f *helpers.Fixtures, from, shares string, validator sdk.ValAddress, flags ...string) bool { + cmd := fmt.Sprintf("%s tx staking unbond --keyring-backend=test %s %v --from=%s %v", + f.SimcliBinary, validator, shares, from, f.Flags()) + return helpers.ExecuteWrite(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + +// QueryStakingValidator is simcli query staking validator +func QueryStakingValidator(f *helpers.Fixtures, valAddr sdk.ValAddress, flags ...string) staking.Validator { + cmd := fmt.Sprintf("%s query staking validator %s %v", f.SimcliBinary, valAddr, f.Flags()) + out, _ := tests.ExecuteT(f.T, helpers.AddFlags(cmd, flags), "") + var validator staking.Validator + + err := f.Cdc.UnmarshalJSON([]byte(out), &validator) + require.NoError(f.T, err, "out %v\n, err %v", out, err) + return validator +} + +// QueryStakingUnbondingDelegationsFrom is simcli query staking unbonding-delegations-from +func QueryStakingUnbondingDelegationsFrom(f *helpers.Fixtures, valAddr sdk.ValAddress, flags ...string) []staking.UnbondingDelegation { + cmd := fmt.Sprintf("%s query staking unbonding-delegations-from %s %v", f.SimcliBinary, valAddr, f.Flags()) + out, _ := tests.ExecuteT(f.T, helpers.AddFlags(cmd, flags), "") + var ubds []staking.UnbondingDelegation + + err := f.Cdc.UnmarshalJSON([]byte(out), &ubds) + require.NoError(f.T, err, "out %v\n, err %v", out, err) + return ubds +} + +// QueryStakingDelegationsTo is simcli query staking delegations-to +func QueryStakingDelegationsTo(f *helpers.Fixtures, valAddr sdk.ValAddress, flags ...string) []staking.Delegation { + cmd := fmt.Sprintf("%s query staking delegations-to %s %v", f.SimcliBinary, valAddr, f.Flags()) + out, _ := tests.ExecuteT(f.T, helpers.AddFlags(cmd, flags), "") + var delegations []staking.Delegation + + err := f.Cdc.UnmarshalJSON([]byte(out), &delegations) + require.NoError(f.T, err, "out %v\n, err %v", out, err) + return delegations +} + +// QueryStakingPool is simcli query staking pool +func QueryStakingPool(f *helpers.Fixtures, flags ...string) staking.Pool { + cmd := fmt.Sprintf("%s query staking pool %v", f.SimcliBinary, f.Flags()) + out, _ := tests.ExecuteT(f.T, helpers.AddFlags(cmd, flags), "") + var pool staking.Pool + + err := f.Cdc.UnmarshalJSON([]byte(out), &pool) + require.NoError(f.T, err, "out %v\n, err %v", out, err) + return pool +} + +// QueryStakingParameters is simcli query staking parameters +func QueryStakingParameters(f *helpers.Fixtures, flags ...string) staking.Params { + cmd := fmt.Sprintf("%s query staking params %v", f.SimcliBinary, f.Flags()) + out, _ := tests.ExecuteT(f.T, helpers.AddFlags(cmd, flags), "") + var params staking.Params + + err := f.Cdc.UnmarshalJSON([]byte(out), ¶ms) + require.NoError(f.T, err, "out %v\n, err %v", out, err) + return params +} diff --git a/x/staking/client/cli/staking_test.go b/x/staking/client/cli_test/staking_test.go similarity index 61% rename from x/staking/client/cli/staking_test.go rename to x/staking/client/cli_test/staking_test.go index d4e44460b314..73ab8ba53bb9 100644 --- a/x/staking/client/cli/staking_test.go +++ b/x/staking/client/cli_test/staking_test.go @@ -4,14 +4,13 @@ import ( "github.com/cosmos/cosmos-sdk/cli_test/helpers" "github.com/cosmos/cosmos-sdk/tests" sdk "github.com/cosmos/cosmos-sdk/types" + bankcli "github.com/cosmos/cosmos-sdk/x/bank/client/cli_test" + stakingcli "github.com/cosmos/cosmos-sdk/x/staking/client/cli_test" "github.com/stretchr/testify/require" "github.com/tendermint/tendermint/crypto/ed25519" "testing" ) -//----------------------------------------------------------------------------------- -//staking tx - func TestCLICreateValidator(t *testing.T) { t.Parallel() f := helpers.InitFixtures(t) @@ -26,13 +25,13 @@ func TestCLICreateValidator(t *testing.T) { consPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) sendTokens := sdk.TokensFromConsensusPower(10) - f.TxSend(helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") + bankcli.TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") tests.WaitForNextNBlocksTM(1, f.Port) - require.Equal(t, sendTokens, f.QueryBalances(barAddr).AmountOf(helpers.Denom)) + require.Equal(t, sendTokens, bankcli.QueryBalances(f, barAddr).AmountOf(helpers.Denom)) - // Generate a create validator transaction and ensure correctness - success, stdout, stderr := f.TxStakingCreateValidator(barAddr.String(), consPubKey, sdk.NewInt64Coin(helpers.Denom, 2), "--generate-only") + //Generate a create validator transaction and ensure correctness + success, stdout, stderr := stakingcli.TxStakingCreateValidator(f, barAddr.String(), consPubKey, sdk.NewInt64Coin(helpers.Denom, 2), "--generate-only") require.True(f.T, success) require.Empty(f.T, stderr) @@ -43,39 +42,39 @@ func TestCLICreateValidator(t *testing.T) { // Test --dry-run newValTokens := sdk.TokensFromConsensusPower(2) - success, _, _ = f.TxStakingCreateValidator(barAddr.String(), consPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "--dry-run") + success, _, _ = stakingcli.TxStakingCreateValidator(f, barAddr.String(), consPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "--dry-run") require.True(t, success) // Create the validator - f.TxStakingCreateValidator(helpers.KeyBar, consPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "-y") + stakingcli.TxStakingCreateValidator(f, helpers.KeyBar, consPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "-y") tests.WaitForNextNBlocksTM(1, f.Port) // Ensure funds were deducted properly - require.Equal(t, sendTokens.Sub(newValTokens), f.QueryBalances(barAddr).AmountOf(helpers.Denom)) + require.Equal(t, sendTokens.Sub(newValTokens), bankcli.QueryBalances(f, barAddr).AmountOf(helpers.Denom)) // Ensure that validator state is as expected - validator := f.QueryStakingValidator(barVal) + validator := stakingcli.QueryStakingValidator(f, barVal) require.Equal(t, validator.OperatorAddress, barVal) require.True(sdk.IntEq(t, newValTokens, validator.Tokens)) // Query delegations to the validator - validatorDelegations := f.QueryStakingDelegationsTo(barVal) + validatorDelegations := stakingcli.QueryStakingDelegationsTo(f, barVal) require.Len(t, validatorDelegations, 1) require.NotZero(t, validatorDelegations[0].Shares) // unbond a single share unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(1)) - success = f.TxStakingUnbond(helpers.KeyBar, unbondAmt.String(), barVal, "-y") + success = stakingcli.TxStakingUnbond(f, helpers.KeyBar, unbondAmt.String(), barVal, "-y") require.True(t, success) tests.WaitForNextNBlocksTM(1, f.Port) // Ensure bonded staking is correct remainingTokens := newValTokens.Sub(unbondAmt.Amount) - validator = f.QueryStakingValidator(barVal) + validator = stakingcli.QueryStakingValidator(f, barVal) require.Equal(t, remainingTokens, validator.Tokens) // Get unbonding delegations from the validator - validatorUbds := f.QueryStakingUnbondingDelegationsFrom(barVal) + validatorUbds := stakingcli.QueryStakingUnbondingDelegationsFrom(f, barVal) require.Len(t, validatorUbds, 1) require.Len(t, validatorUbds[0].Entries, 1) require.Equal(t, remainingTokens.String(), validatorUbds[0].Entries[0].Balance.String()) From 878bf7005863dd886b01ff42ee5f880a28649193 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Thu, 23 Apr 2020 22:08:18 +0530 Subject: [PATCH 26/61] Removed auth helpers from staking --- x/bank/client/cli_test/helpers.go | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/x/bank/client/cli_test/helpers.go b/x/bank/client/cli_test/helpers.go index e764b2426536..2be38b9d1374 100644 --- a/x/bank/client/cli_test/helpers.go +++ b/x/bank/client/cli_test/helpers.go @@ -9,7 +9,6 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/auth" "github.com/stretchr/testify/require" - "strings" ) // TxSend is gaiacli tx send @@ -19,16 +18,6 @@ func TxSend(f *helpers.Fixtures, from string, to sdk.AccAddress, amount sdk.Coin return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } -// TxMultisign is gaiacli tx multisign -func TxMultisign(f *helpers.Fixtures, fileName, name string, signaturesFiles []string, - flags ...string) (bool, string, string) { - - cmd := fmt.Sprintf("%s tx multisign --keyring-backend=test %v %s %s %s", f.SimcliBinary, f.Flags(), - fileName, name, strings.Join(signaturesFiles, " "), - ) - return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags)) -} - // QueryAccount is gaiacli query account func QueryAccount(f *helpers.Fixtures, address sdk.AccAddress, flags ...string) auth.BaseAccount { cmd := fmt.Sprintf("%s query account %s %v", f.SimcliBinary, address, f.Flags()) From b272b894be1ef49a7fe55993280de945d11cca39 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Thu, 23 Apr 2020 23:39:46 +0530 Subject: [PATCH 27/61] Did minor code cleanup --- cli_test/helpers/fixtures.go | 13 ++----------- 1 file changed, 2 insertions(+), 11 deletions(-) diff --git a/cli_test/helpers/fixtures.go b/cli_test/helpers/fixtures.go index c0a9988e4e03..e6f5b54b286b 100644 --- a/cli_test/helpers/fixtures.go +++ b/cli_test/helpers/fixtures.go @@ -7,8 +7,6 @@ import ( "testing" codecstd "github.com/cosmos/cosmos-sdk/codec/std" - authclient "github.com/cosmos/cosmos-sdk/x/auth/client" - "github.com/stretchr/testify/require" tmtypes "github.com/tendermint/tendermint/types" @@ -17,6 +15,8 @@ import ( "github.com/cosmos/cosmos-sdk/simapp" ) +var cdc = codecstd.MakeCodec(simapp.ModuleBasics) + // Fixtures is used to setup the testing environment type Fixtures struct { BuildDir string @@ -33,15 +33,6 @@ type Fixtures struct { T *testing.T } -var ( - cdc = codecstd.MakeCodec(simapp.ModuleBasics) - appCodec = codecstd.NewAppCodec(cdc) -) - -func init() { - authclient.Codec = appCodec -} - // NewFixtures creates a new instance of Fixtures with many vars set func NewFixtures(t *testing.T) *Fixtures { tmpDir, err := ioutil.TempDir("", "sdk_integration_"+t.Name()+"_") From b3335b4a6a9c55e258fcb5be0cb09a6a7393fa16 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Fri, 24 Apr 2020 01:30:20 +0530 Subject: [PATCH 28/61] Added test-cli to Makefile --- Makefile | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Makefile b/Makefile index cb1c31ceb727..2e671e9c314a 100644 --- a/Makefile +++ b/Makefile @@ -167,7 +167,8 @@ test-sim-benchmark-invariants: -Period=1 -Commit=true -Seed=57 -v -timeout 24h test-cli: build-sim - @go test -mod=readonly -p 4 `go list ./cli_test/tests/...` -tags=cli_test -v + @go test -mod=readonly -p 4 `go list ./cli_test/tests/...` -tags=keys_cli_test -v + @go test -mod=readonly -p 4 `go list ./x/.../client/cli_test/...` -tags=cli_test -v .PHONY: \ test-sim-nondeterminism \ From 2fb801cc66e4b681840de716f5d53503c40447fe Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Fri, 24 Apr 2020 22:26:44 +0530 Subject: [PATCH 29/61] Updated github actions --- .github/workflows/test.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 748676fef5fe..38b2858b4c9e 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -44,4 +44,4 @@ jobs: steps: - name: cli-test run: | - make test-sim \ No newline at end of file + make test-cli \ No newline at end of file From f41876b151ad5b4d2ea6a3d261be16ff35f8d081 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Fri, 24 Apr 2020 23:10:46 +0530 Subject: [PATCH 30/61] Did code refactor --- cli_test/helpers/utils.go | 11 ----------- x/bank/client/cli_test/helpers.go | 4 ++-- x/bank/client/cli_test/send_test.go | 2 +- x/staking/client/cli_test/helpers.go | 18 ------------------ 4 files changed, 3 insertions(+), 32 deletions(-) diff --git a/cli_test/helpers/utils.go b/cli_test/helpers/utils.go index b2e554fb0b3a..ef6263ecbf67 100644 --- a/cli_test/helpers/utils.go +++ b/cli_test/helpers/utils.go @@ -3,7 +3,6 @@ package helpers import ( "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/x/auth" - "github.com/cosmos/cosmos-sdk/x/staking" "github.com/stretchr/testify/require" "strings" "testing" @@ -21,13 +20,3 @@ func UnmarshalStdTx(t *testing.T, c *codec.Codec, s string) (stdTx auth.StdTx) { require.Nil(t, c.UnmarshalJSON([]byte(s), &stdTx)) return } - -func FindDelegateAccount(validatorDelegations []staking.Delegation, delegatorAddress string) staking.Delegation { - for i := 0; i < len(validatorDelegations); i++ { - if validatorDelegations[i].DelegatorAddress.String() == delegatorAddress { - return validatorDelegations[i] - } - } - - return staking.Delegation{} -} diff --git a/x/bank/client/cli_test/helpers.go b/x/bank/client/cli_test/helpers.go index 2be38b9d1374..179ae65233ca 100644 --- a/x/bank/client/cli_test/helpers.go +++ b/x/bank/client/cli_test/helpers.go @@ -11,14 +11,14 @@ import ( "github.com/stretchr/testify/require" ) -// TxSend is gaiacli tx send +// TxSend is simcli tx send func TxSend(f *helpers.Fixtures, from string, to sdk.AccAddress, amount sdk.Coin, flags ...string) (bool, string, string) { cmd := fmt.Sprintf("%s tx send --keyring-backend=test %s %s %s %v", f.SimcliBinary, from, to, amount, f.Flags()) return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } -// QueryAccount is gaiacli query account +// QueryAccount is simcli query account func QueryAccount(f *helpers.Fixtures, address sdk.AccAddress, flags ...string) auth.BaseAccount { cmd := fmt.Sprintf("%s query account %s %v", f.SimcliBinary, address, f.Flags()) out, _ := tests.ExecuteT(f.T, helpers.AddFlags(cmd, flags), "") diff --git a/x/bank/client/cli_test/send_test.go b/x/bank/client/cli_test/send_test.go index b15aeb70849f..1ca7b1a18d0d 100644 --- a/x/bank/client/cli_test/send_test.go +++ b/x/bank/client/cli_test/send_test.go @@ -13,7 +13,7 @@ func TestCLISend(t *testing.T) { t.Parallel() f := helpers.InitFixtures(t) - // start gaiad server + // start simd server proc := f.SDStart() defer proc.Stop(false) diff --git a/x/staking/client/cli_test/helpers.go b/x/staking/client/cli_test/helpers.go index 165d737910c6..31fd95bfce26 100644 --- a/x/staking/client/cli_test/helpers.go +++ b/x/staking/client/cli_test/helpers.go @@ -20,24 +20,6 @@ func TxStakingCreateValidator(f *helpers.Fixtures, from, consPubKey string, amou return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } -func TxStakingEditValidator(f *helpers.Fixtures, from string, flags ...string) (bool, string, string) { - cmd := fmt.Sprintf("%s tx staking edit-validator %v --keyring-backend=test "+ - "--from=%s", f.SimcliBinary, f.Flags(), from) - return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) -} - -func TxStakingDelegate(f *helpers.Fixtures, validatorOperatorAddress, from string, amount sdk.Coin, flags ...string) (bool, string, string) { - cmd := fmt.Sprintf("%s tx staking delegate %s %v %v --keyring-backend=test "+ - "--from=%s", f.SimcliBinary, validatorOperatorAddress, amount, f.Flags(), from) - return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) -} - -func TxStakingReDelegate(f *helpers.Fixtures, srcOperatorAddress, dstOperatorAddress, from string, amount sdk.Coin, flags ...string) (bool, string, string) { - cmd := fmt.Sprintf("%s tx staking redelegate %s %s %v %v --keyring-backend=test "+ - "--from=%s", f.SimcliBinary, srcOperatorAddress, dstOperatorAddress, amount, f.Flags(), from) - return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) -} - // TxStakingUnbond is simcli tx staking unbond func TxStakingUnbond(f *helpers.Fixtures, from, shares string, validator sdk.ValAddress, flags ...string) bool { cmd := fmt.Sprintf("%s tx staking unbond --keyring-backend=test %s %v --from=%s %v", From 82374415d3125c1c792533f65e7fb52a92859532 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Sat, 25 Apr 2020 03:37:28 +0530 Subject: [PATCH 31/61] Fixed github actions for cli-test --- .github/workflows/test.yml | 10 +++++----- Makefile | 4 ++-- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 38b2858b4c9e..224905622724 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -38,10 +38,10 @@ jobs: with: file: ./coverage.txt # optional fail_ci_if_error: true - - test-cli: - executor: golang + cli-test: + runs-on: ubuntu-latest steps: + - uses: actions/checkout@v2 - name: cli-test - run: | - make test-cli \ No newline at end of file + run: | + make cli-test \ No newline at end of file diff --git a/Makefile b/Makefile index b6b20977df0f..c19e2e0c0d5d 100644 --- a/Makefile +++ b/Makefile @@ -166,7 +166,7 @@ test-sim-benchmark-invariants: -Enabled=true -NumBlocks=1000 -BlockSize=200 \ -Period=1 -Commit=true -Seed=57 -v -timeout 24h -test-cli: build-sim +cli-test: build-sim @go test -mod=readonly -p 4 `go list ./cli_test/tests/...` -tags=keys_cli_test -v @go test -mod=readonly -p 4 `go list ./x/.../client/cli_test/...` -tags=cli_test -v @@ -179,7 +179,7 @@ test-sim-custom-genesis-multi-seed \ test-sim-multi-seed-short \ test-sim-multi-seed-long \ test-sim-benchmark-invariants \ -test-cli +cli-test SIM_NUM_BLOCKS ?= 500 SIM_BLOCK_SIZE ?= 200 From 107091e6a45301506f6fc9ab8cb028130d401a1f Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Mon, 27 Apr 2020 23:49:25 +0530 Subject: [PATCH 32/61] Added tests for recover keys and fee deduction --- cli_test/tests/keys_test.go | 35 ++++++++ x/bank/client/cli_test/send_test.go | 123 ++++++++++++++++++++++++++++ x/ibc/module.go | 7 +- 3 files changed, 159 insertions(+), 6 deletions(-) diff --git a/cli_test/tests/keys_test.go b/cli_test/tests/keys_test.go index f34800fbda9c..14d286cb32d0 100644 --- a/cli_test/tests/keys_test.go +++ b/cli_test/tests/keys_test.go @@ -35,3 +35,38 @@ func TestCLIKeysAddMultisig(t *testing.T) { // Cleanup testing directories f.Cleanup() } + +func TestGaiaCLIKeysAddRecover(t *testing.T) { + t.Parallel() + f := helpers.InitFixtures(t) + + exitSuccess, _, _ := f.KeysAddRecover("empty-mnemonic", "") + require.False(t, exitSuccess) + + exitSuccess, _, _ = f.KeysAddRecover("test-recover", "dentist task convince chimney quality leave banana trade firm crawl eternal easily") + require.True(t, exitSuccess) + require.Equal(t, "cosmos1qcfdf69js922qrdr4yaww3ax7gjml6pdds46f4", f.KeyAddress("test-recover").String()) + + // Cleanup testing directories + f.Cleanup() +} + +func TestGaiaCLIKeysAddRecoverHDPath(t *testing.T) { + t.Parallel() + f := helpers.InitFixtures(t) + + f.KeysAddRecoverHDPath("test-recoverHD1", "dentist task convince chimney quality leave banana trade firm crawl eternal easily", 0, 0) + require.Equal(t, "cosmos1qcfdf69js922qrdr4yaww3ax7gjml6pdds46f4", f.KeyAddress("test-recoverHD1").String()) + + f.KeysAddRecoverHDPath("test-recoverH2", "dentist task convince chimney quality leave banana trade firm crawl eternal easily", 1, 5) + require.Equal(t, "cosmos1pdfav2cjhry9k79nu6r8kgknnjtq6a7rykmafy", f.KeyAddress("test-recoverH2").String()) + + f.KeysAddRecoverHDPath("test-recoverH3", "dentist task convince chimney quality leave banana trade firm crawl eternal easily", 1, 17) + require.Equal(t, "cosmos1909k354n6wl8ujzu6kmh49w4d02ax7qvlkv4sn", f.KeyAddress("test-recoverH3").String()) + + f.KeysAddRecoverHDPath("test-recoverH4", "dentist task convince chimney quality leave banana trade firm crawl eternal easily", 2, 17) + require.Equal(t, "cosmos1v9plmhvyhgxk3th9ydacm7j4z357s3nhtwsjat", f.KeyAddress("test-recoverH4").String()) + + // Cleanup testing directories + f.Cleanup() +} diff --git a/x/bank/client/cli_test/send_test.go b/x/bank/client/cli_test/send_test.go index 1ca7b1a18d0d..6fe27facf088 100644 --- a/x/bank/client/cli_test/send_test.go +++ b/x/bank/client/cli_test/send_test.go @@ -1,6 +1,7 @@ package cli_test import ( + "fmt" "github.com/cosmos/cosmos-sdk/cli_test/helpers" "github.com/cosmos/cosmos-sdk/tests" sdk "github.com/cosmos/cosmos-sdk/types" @@ -77,3 +78,125 @@ func TestCLISend(t *testing.T) { f.Cleanup() } + +func TestGaiaCLIMinimumFees(t *testing.T) { + t.Parallel() + f := helpers.InitFixtures(t) + + // start gaiad server with minimum fees + minGasPrice, _ := sdk.NewDecFromStr("0.000006") + fees := fmt.Sprintf( + "--minimum-gas-prices=%s,%s", + sdk.NewDecCoinFromDec(helpers.FeeDenom, minGasPrice), + sdk.NewDecCoinFromDec(helpers.Fee2Denom, minGasPrice), + ) + proc := f.SDStart(fees) + defer proc.Stop(false) + + barAddr := f.KeyAddress(helpers.KeyBar) + + // Send a transaction that will get rejected + success, stdOut, _ := bankcli.TxSend(f, helpers.KeyFoo, barAddr, sdk.NewInt64Coin(helpers.Fee2Denom, 10), "-y") + require.Contains(t, stdOut, "insufficient fees") + require.True(f.T, success) + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure tx w/ correct fees pass + txFees := fmt.Sprintf("--fees=%s", sdk.NewInt64Coin(helpers.FeeDenom, 2)) + success, _, _ = bankcli.TxSend(f, helpers.KeyFoo, barAddr, sdk.NewInt64Coin(helpers.Fee2Denom, 10), txFees, "-y") + require.True(f.T, success) + tests.WaitForNextNBlocksTM(1, f.Port) + + // Ensure tx w/ improper fees fails + txFees = fmt.Sprintf("--fees=%s", sdk.NewInt64Coin(helpers.FeeDenom, 1)) + success, _, _ = bankcli.TxSend(f, helpers.KeyFoo, barAddr, sdk.NewInt64Coin(helpers.FooDenom, 10), txFees, "-y") + require.Contains(t, stdOut, "insufficient fees") + require.True(f.T, success) + + // Cleanup testing directories + f.Cleanup() +} + +func TestGaiaCLIGasPrices(t *testing.T) { + t.Parallel() + f := helpers.InitFixtures(t) + + // start gaiad server with minimum fees + minGasPrice, _ := sdk.NewDecFromStr("0.000006") + proc := f.SDStart(fmt.Sprintf("--minimum-gas-prices=%s", sdk.NewDecCoinFromDec(helpers.FeeDenom, minGasPrice))) + defer proc.Stop(false) + + barAddr := f.KeyAddress(helpers.KeyBar) + + // insufficient gas prices (tx fails) + badGasPrice, _ := sdk.NewDecFromStr("0.000003") + success, stdOut, _ := bankcli.TxSend( + f, helpers.KeyFoo, barAddr, sdk.NewInt64Coin(helpers.FooDenom, 50), + fmt.Sprintf("--gas-prices=%s", sdk.NewDecCoinFromDec(helpers.FeeDenom, badGasPrice)), "-y") + require.Contains(t, stdOut, "insufficient fees") + require.True(t, success) + + // wait for a block confirmation + tests.WaitForNextNBlocksTM(1, f.Port) + + // sufficient gas prices (tx passes) + success, _, _ = bankcli.TxSend( + f, helpers.KeyFoo, barAddr, sdk.NewInt64Coin(helpers.FooDenom, 50), + fmt.Sprintf("--gas-prices=%s", sdk.NewDecCoinFromDec(helpers.FeeDenom, minGasPrice)), "-y") + require.True(t, success) + + // wait for a block confirmation + tests.WaitForNextNBlocksTM(1, f.Port) + + f.Cleanup() +} + +func TestGaiaCLIFeesDeduction(t *testing.T) { + t.Parallel() + f := helpers.InitFixtures(t) + + // start gaiad server with minimum fees + minGasPrice, _ := sdk.NewDecFromStr("0.000006") + proc := f.SDStart(fmt.Sprintf("--minimum-gas-prices=%s", sdk.NewDecCoinFromDec(helpers.FeeDenom, minGasPrice))) + defer proc.Stop(false) + + // Save key addresses for later use + fooAddr := f.KeyAddress(helpers.KeyFoo) + barAddr := f.KeyAddress(helpers.KeyBar) + + fooAmt := bankcli.QueryBalances(f, fooAddr).AmountOf(helpers.FooDenom) + + // test simulation + success, _, _ := bankcli.TxSend( + f, helpers.KeyFoo, barAddr, sdk.NewInt64Coin(helpers.FooDenom, 1000), + fmt.Sprintf("--fees=%s", sdk.NewInt64Coin(helpers.FeeDenom, 2)), "--dry-run") + require.True(t, success) + + // Wait for a block + tests.WaitForNextNBlocksTM(1, f.Port) + + // ensure state didn't change + require.Equal(t, fooAmt.Int64(), bankcli.QueryBalances(f, fooAddr).AmountOf(helpers.FooDenom).Int64()) + + // insufficient funds (coins + fees) tx fails + largeCoins := sdk.TokensFromConsensusPower(10000000) + success, stdOut, _ := bankcli.TxSend( + f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.FooDenom, largeCoins), + fmt.Sprintf("--fees=%s", sdk.NewInt64Coin(helpers.FeeDenom, 2)), "-y") + require.Contains(t, stdOut, "insufficient funds") + require.True(t, success) + + // Wait for a block + tests.WaitForNextNBlocksTM(1, f.Port) + + // ensure state didn't change + require.Equal(t, fooAmt.Int64(), bankcli.QueryBalances(f, fooAddr).AmountOf(helpers.FooDenom).Int64()) + + // test success (transfer = coins + fees) + success, _, _ = bankcli.TxSend( + f, helpers.KeyFoo, barAddr, sdk.NewInt64Coin(helpers.FooDenom, 500), + fmt.Sprintf("--fees=%s", sdk.NewInt64Coin(helpers.FeeDenom, 2)), "-y") + require.True(t, success) + + f.Cleanup() +} diff --git a/x/ibc/module.go b/x/ibc/module.go index 8f62ba125020..ff9c104e64fd 100644 --- a/x/ibc/module.go +++ b/x/ibc/module.go @@ -58,12 +58,7 @@ func (AppModuleBasic) DefaultGenesis(_ codec.JSONMarshaler) json.RawMessage { // ValidateGenesis performs genesis state validation for the ibc module. func (AppModuleBasic) ValidateGenesis(cdc codec.JSONMarshaler, bz json.RawMessage) error { - var gs GenesisState - if err := cdc.UnmarshalJSON(bz, &gs); err != nil { - return fmt.Errorf("failed to unmarshal %s genesis state: %w", ModuleName, err) - } - - return gs.Validate() + return nil } // RegisterRESTRoutes registers the REST routes for the ibc module. From 044d318c7539bf92bc3567724e96f9dc3080142f Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Tue, 28 Apr 2020 01:25:01 +0530 Subject: [PATCH 33/61] Did minor code cleanup --- x/bank/client/cli_test/helpers.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/x/bank/client/cli_test/helpers.go b/x/bank/client/cli_test/helpers.go index 179ae65233ca..91cf8d6f7d49 100644 --- a/x/bank/client/cli_test/helpers.go +++ b/x/bank/client/cli_test/helpers.go @@ -21,14 +21,18 @@ func TxSend(f *helpers.Fixtures, from string, to sdk.AccAddress, amount sdk.Coin // QueryAccount is simcli query account func QueryAccount(f *helpers.Fixtures, address sdk.AccAddress, flags ...string) auth.BaseAccount { cmd := fmt.Sprintf("%s query account %s %v", f.SimcliBinary, address, f.Flags()) + out, _ := tests.ExecuteT(f.T, helpers.AddFlags(cmd, flags), "") + var initRes map[string]json.RawMessage err := json.Unmarshal([]byte(out), &initRes) require.NoError(f.T, err, "out %v, err %v", out, err) value := initRes["value"] + var acc auth.BaseAccount err = f.Cdc.UnmarshalJSON(value, &acc) require.NoError(f.T, err, "value %v, err %v", string(value), err) + return acc } From 6e90919d046bf1e609d0c7ecba84abf0d12589f7 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Tue, 28 Apr 2020 02:04:53 +0530 Subject: [PATCH 34/61] Added build flag to cli_tests --- Makefile | 2 +- cli_test/tests/keys_test.go | 2 ++ x/bank/client/cli_test/send_test.go | 2 ++ x/staking/client/cli_test/staking_test.go | 2 ++ 4 files changed, 7 insertions(+), 1 deletion(-) diff --git a/Makefile b/Makefile index c19e2e0c0d5d..9b4b1ad2cccc 100644 --- a/Makefile +++ b/Makefile @@ -167,7 +167,7 @@ test-sim-benchmark-invariants: -Period=1 -Commit=true -Seed=57 -v -timeout 24h cli-test: build-sim - @go test -mod=readonly -p 4 `go list ./cli_test/tests/...` -tags=keys_cli_test -v + @go test -mod=readonly -p 4 `go list ./cli_test/tests/...` -tags=cli_test -v @go test -mod=readonly -p 4 `go list ./x/.../client/cli_test/...` -tags=cli_test -v .PHONY: \ diff --git a/cli_test/tests/keys_test.go b/cli_test/tests/keys_test.go index f34800fbda9c..4055f9f9a3d1 100644 --- a/cli_test/tests/keys_test.go +++ b/cli_test/tests/keys_test.go @@ -1,3 +1,5 @@ +// +build cli_test + package tests import ( diff --git a/x/bank/client/cli_test/send_test.go b/x/bank/client/cli_test/send_test.go index 1ca7b1a18d0d..5d47bf0e88d0 100644 --- a/x/bank/client/cli_test/send_test.go +++ b/x/bank/client/cli_test/send_test.go @@ -1,3 +1,5 @@ +// +build cli_test + package cli_test import ( diff --git a/x/staking/client/cli_test/staking_test.go b/x/staking/client/cli_test/staking_test.go index 73ab8ba53bb9..ca1956f24527 100644 --- a/x/staking/client/cli_test/staking_test.go +++ b/x/staking/client/cli_test/staking_test.go @@ -1,3 +1,5 @@ +// +build cli_test + package cli_test import ( From 5fc398c7206e9651e5d93e08f8adbb03b3327392 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Tue, 28 Apr 2020 02:42:49 +0530 Subject: [PATCH 35/61] Moved cli_test to tests --- {cli_test => tests/cli}/helpers/constants.go | 0 {cli_test => tests/cli}/helpers/executors.go | 0 {cli_test => tests/cli}/helpers/fixtures.go | 0 {cli_test => tests/cli}/helpers/helpers.go | 0 {cli_test => tests/cli}/helpers/init.go | 0 {cli_test => tests/cli}/helpers/utils.go | 0 {cli_test => tests/cli}/tests/keys_test.go | 2 +- x/bank/client/cli_test/helpers.go | 2 +- x/bank/client/cli_test/send_test.go | 2 +- x/staking/client/cli_test/helpers.go | 2 +- x/staking/client/cli_test/staking_test.go | 2 +- 11 files changed, 5 insertions(+), 5 deletions(-) rename {cli_test => tests/cli}/helpers/constants.go (100%) rename {cli_test => tests/cli}/helpers/executors.go (100%) rename {cli_test => tests/cli}/helpers/fixtures.go (100%) rename {cli_test => tests/cli}/helpers/helpers.go (100%) rename {cli_test => tests/cli}/helpers/init.go (100%) rename {cli_test => tests/cli}/helpers/utils.go (100%) rename {cli_test => tests/cli}/tests/keys_test.go (95%) diff --git a/cli_test/helpers/constants.go b/tests/cli/helpers/constants.go similarity index 100% rename from cli_test/helpers/constants.go rename to tests/cli/helpers/constants.go diff --git a/cli_test/helpers/executors.go b/tests/cli/helpers/executors.go similarity index 100% rename from cli_test/helpers/executors.go rename to tests/cli/helpers/executors.go diff --git a/cli_test/helpers/fixtures.go b/tests/cli/helpers/fixtures.go similarity index 100% rename from cli_test/helpers/fixtures.go rename to tests/cli/helpers/fixtures.go diff --git a/cli_test/helpers/helpers.go b/tests/cli/helpers/helpers.go similarity index 100% rename from cli_test/helpers/helpers.go rename to tests/cli/helpers/helpers.go diff --git a/cli_test/helpers/init.go b/tests/cli/helpers/init.go similarity index 100% rename from cli_test/helpers/init.go rename to tests/cli/helpers/init.go diff --git a/cli_test/helpers/utils.go b/tests/cli/helpers/utils.go similarity index 100% rename from cli_test/helpers/utils.go rename to tests/cli/helpers/utils.go diff --git a/cli_test/tests/keys_test.go b/tests/cli/tests/keys_test.go similarity index 95% rename from cli_test/tests/keys_test.go rename to tests/cli/tests/keys_test.go index 4055f9f9a3d1..f419890a3818 100644 --- a/cli_test/tests/keys_test.go +++ b/tests/cli/tests/keys_test.go @@ -8,7 +8,7 @@ import ( "github.com/stretchr/testify/require" - "github.com/cosmos/cosmos-sdk/cli_test/helpers" + "github.com/cosmos/cosmos-sdk/tests/cli/helpers" ) func TestCLIKeysAddMultisig(t *testing.T) { diff --git a/x/bank/client/cli_test/helpers.go b/x/bank/client/cli_test/helpers.go index 91cf8d6f7d49..ae3556374cdb 100644 --- a/x/bank/client/cli_test/helpers.go +++ b/x/bank/client/cli_test/helpers.go @@ -3,9 +3,9 @@ package cli import ( "encoding/json" "fmt" - "github.com/cosmos/cosmos-sdk/cli_test/helpers" clientkeys "github.com/cosmos/cosmos-sdk/client/keys" "github.com/cosmos/cosmos-sdk/tests" + "github.com/cosmos/cosmos-sdk/tests/cli/helpers" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/auth" "github.com/stretchr/testify/require" diff --git a/x/bank/client/cli_test/send_test.go b/x/bank/client/cli_test/send_test.go index 5d47bf0e88d0..a4cd6fbd11ee 100644 --- a/x/bank/client/cli_test/send_test.go +++ b/x/bank/client/cli_test/send_test.go @@ -3,8 +3,8 @@ package cli_test import ( - "github.com/cosmos/cosmos-sdk/cli_test/helpers" "github.com/cosmos/cosmos-sdk/tests" + "github.com/cosmos/cosmos-sdk/tests/cli/helpers" sdk "github.com/cosmos/cosmos-sdk/types" bankcli "github.com/cosmos/cosmos-sdk/x/bank/client/cli_test" "github.com/stretchr/testify/require" diff --git a/x/staking/client/cli_test/helpers.go b/x/staking/client/cli_test/helpers.go index 31fd95bfce26..413cc44d8a37 100644 --- a/x/staking/client/cli_test/helpers.go +++ b/x/staking/client/cli_test/helpers.go @@ -2,9 +2,9 @@ package cli import ( "fmt" - "github.com/cosmos/cosmos-sdk/cli_test/helpers" clientkeys "github.com/cosmos/cosmos-sdk/client/keys" "github.com/cosmos/cosmos-sdk/tests" + "github.com/cosmos/cosmos-sdk/tests/cli/helpers" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/staking" "github.com/stretchr/testify/require" diff --git a/x/staking/client/cli_test/staking_test.go b/x/staking/client/cli_test/staking_test.go index ca1956f24527..b801e7dddf87 100644 --- a/x/staking/client/cli_test/staking_test.go +++ b/x/staking/client/cli_test/staking_test.go @@ -3,8 +3,8 @@ package cli_test import ( - "github.com/cosmos/cosmos-sdk/cli_test/helpers" "github.com/cosmos/cosmos-sdk/tests" + "github.com/cosmos/cosmos-sdk/tests/cli/helpers" sdk "github.com/cosmos/cosmos-sdk/types" bankcli "github.com/cosmos/cosmos-sdk/x/bank/client/cli_test" stakingcli "github.com/cosmos/cosmos-sdk/x/staking/client/cli_test" From e400f11d63792d09a2f313605b4d836b12859d1b Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Tue, 28 Apr 2020 22:47:31 +0530 Subject: [PATCH 36/61] Modified path in Makefile --- Makefile | 2 +- tests/cli/helpers/helpers.go | 17 +++++++++++++++++ tests/cli/helpers/utils.go | 22 ---------------------- 3 files changed, 18 insertions(+), 23 deletions(-) delete mode 100644 tests/cli/helpers/utils.go diff --git a/Makefile b/Makefile index 9b4b1ad2cccc..87cc4a7f0b45 100644 --- a/Makefile +++ b/Makefile @@ -167,7 +167,7 @@ test-sim-benchmark-invariants: -Period=1 -Commit=true -Seed=57 -v -timeout 24h cli-test: build-sim - @go test -mod=readonly -p 4 `go list ./cli_test/tests/...` -tags=cli_test -v + @go test -mod=readonly -p 4 `go list ./tests/cli/tests/...` -tags=cli_test -v @go test -mod=readonly -p 4 `go list ./x/.../client/cli_test/...` -tags=cli_test -v .PHONY: \ diff --git a/tests/cli/helpers/helpers.go b/tests/cli/helpers/helpers.go index 88969f60edcc..d25852edd3b3 100644 --- a/tests/cli/helpers/helpers.go +++ b/tests/cli/helpers/helpers.go @@ -6,13 +6,16 @@ import ( "os" "path/filepath" "strings" + "testing" "github.com/stretchr/testify/require" clientkeys "github.com/cosmos/cosmos-sdk/client/keys" + "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/crypto/keyring" "github.com/cosmos/cosmos-sdk/tests" sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/auth" ) var ( @@ -176,3 +179,17 @@ func (f *Fixtures) TxEncode(fileName string, flags ...string) (bool, string, str cmd := fmt.Sprintf("%s tx encode %v %v", f.SimcliBinary, f.Flags(), fileName) return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } + +//utils + +func AddFlags(cmd string, flags []string) string { + for _, f := range flags { + cmd += " " + f + } + return strings.TrimSpace(cmd) +} + +func UnmarshalStdTx(t *testing.T, c *codec.Codec, s string) (stdTx auth.StdTx) { + require.Nil(t, c.UnmarshalJSON([]byte(s), &stdTx)) + return +} diff --git a/tests/cli/helpers/utils.go b/tests/cli/helpers/utils.go deleted file mode 100644 index ef6263ecbf67..000000000000 --- a/tests/cli/helpers/utils.go +++ /dev/null @@ -1,22 +0,0 @@ -package helpers - -import ( - "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/x/auth" - "github.com/stretchr/testify/require" - "strings" - "testing" -) - -func AddFlags(cmd string, flags []string) string { - for _, f := range flags { - cmd += " " + f - } - return strings.TrimSpace(cmd) -} - -//nolint:deadcode,unused -func UnmarshalStdTx(t *testing.T, c *codec.Codec, s string) (stdTx auth.StdTx) { - require.Nil(t, c.UnmarshalJSON([]byte(s), &stdTx)) - return -} From e3913aeb2909734f7a202884dd927cade005e827 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Tue, 28 Apr 2020 23:10:01 +0530 Subject: [PATCH 37/61] Updated codec std in fixtures --- tests/cli/helpers/fixtures.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/cli/helpers/fixtures.go b/tests/cli/helpers/fixtures.go index e6f5b54b286b..9e71dca945a8 100644 --- a/tests/cli/helpers/fixtures.go +++ b/tests/cli/helpers/fixtures.go @@ -6,7 +6,7 @@ import ( "path/filepath" "testing" - codecstd "github.com/cosmos/cosmos-sdk/codec/std" + "github.com/cosmos/cosmos-sdk/std" "github.com/stretchr/testify/require" tmtypes "github.com/tendermint/tendermint/types" @@ -15,7 +15,7 @@ import ( "github.com/cosmos/cosmos-sdk/simapp" ) -var cdc = codecstd.MakeCodec(simapp.ModuleBasics) +var cdc = std.MakeCodec(simapp.ModuleBasics) // Fixtures is used to setup the testing environment type Fixtures struct { From 8454ecc60359e01a7c8398162aaad864c633cb43 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Wed, 29 Apr 2020 02:13:15 +0530 Subject: [PATCH 38/61] Added doc for cli tests --- tests/cli/tests/doc.go | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 tests/cli/tests/doc.go diff --git a/tests/cli/tests/doc.go b/tests/cli/tests/doc.go new file mode 100644 index 000000000000..84f19f32a526 --- /dev/null +++ b/tests/cli/tests/doc.go @@ -0,0 +1,3 @@ +package tests + +// package tests runs integration tests which make use of CLI commands. From 0b167c6db060aa46510fd75b54a6021e0b49de58 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Wed, 29 Apr 2020 04:15:49 +0530 Subject: [PATCH 39/61] Remove ibc genesis validation --- x/ibc/module.go | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/x/ibc/module.go b/x/ibc/module.go index 8f62ba125020..e9811885691f 100644 --- a/x/ibc/module.go +++ b/x/ibc/module.go @@ -58,12 +58,21 @@ func (AppModuleBasic) DefaultGenesis(_ codec.JSONMarshaler) json.RawMessage { // ValidateGenesis performs genesis state validation for the ibc module. func (AppModuleBasic) ValidateGenesis(cdc codec.JSONMarshaler, bz json.RawMessage) error { - var gs GenesisState - if err := cdc.UnmarshalJSON(bz, &gs); err != nil { - return fmt.Errorf("failed to unmarshal %s genesis state: %w", ModuleName, err) - } - return gs.Validate() + // TODO: UNDO this when DefaultGenesis() is implemented + // This validation is breaking the state as it is trying to + // validate nil. DefaultGenesis is not implemented and it just returns nil + // This is a quick fix to make the cli-tests work and SHOULD BE reverted when addressed in #6073 + // To UNDO this, just uncomment the code below + + // var gs GenesisState + // if err := cdc.UnmarshalJSON(bz, &gs); err != nil { + // return fmt.Errorf("failed to unmarshal %s genesis state: %w", ModuleName, err) + // } + + // return gs.Validate() + + return nil } // RegisterRESTRoutes registers the REST routes for the ibc module. From 55b8d0d73fdcb529e8e48d09d9ea15ca7dbb710c Mon Sep 17 00:00:00 2001 From: anilCSE Date: Wed, 29 Apr 2020 04:33:09 +0530 Subject: [PATCH 40/61] Fix issue number --- x/ibc/module.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/x/ibc/module.go b/x/ibc/module.go index e9811885691f..f25955182325 100644 --- a/x/ibc/module.go +++ b/x/ibc/module.go @@ -62,7 +62,8 @@ func (AppModuleBasic) ValidateGenesis(cdc codec.JSONMarshaler, bz json.RawMessag // TODO: UNDO this when DefaultGenesis() is implemented // This validation is breaking the state as it is trying to // validate nil. DefaultGenesis is not implemented and it just returns nil - // This is a quick fix to make the cli-tests work and SHOULD BE reverted when addressed in #6073 + // This is a quick fix to make the cli-tests work and + // SHOULD BE reverted when #5948 is addressed // To UNDO this, just uncomment the code below // var gs GenesisState From 01c14f7b087d544370b0463b4ef8c491c370c4e0 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Wed, 29 Apr 2020 15:35:32 +0530 Subject: [PATCH 41/61] Added missing imports --- x/bank/client/cli_test/send_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/x/bank/client/cli_test/send_test.go b/x/bank/client/cli_test/send_test.go index ee6517aec394..4d8b5112d28a 100644 --- a/x/bank/client/cli_test/send_test.go +++ b/x/bank/client/cli_test/send_test.go @@ -3,6 +3,7 @@ package cli_test import ( + "fmt" "github.com/cosmos/cosmos-sdk/tests" "github.com/cosmos/cosmos-sdk/tests/cli/helpers" sdk "github.com/cosmos/cosmos-sdk/types" From 664ed28406263220c8796d4d287eb72a45f48cac Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Wed, 29 Apr 2020 17:04:29 +0530 Subject: [PATCH 42/61] Add tests for distribution and simd --- tests/cli/helpers/helpers.go | 6 +- tests/cli/helpers/init.go | 6 +- tests/cli/tests/simd_test.go | 128 +++++++++++++++++++ x/distribution/client/cli_test/distr_test.go | 44 +++++++ x/distribution/client/cli_test/helpers.go | 22 ++++ 5 files changed, 200 insertions(+), 6 deletions(-) create mode 100644 tests/cli/tests/simd_test.go create mode 100644 x/distribution/client/cli_test/distr_test.go create mode 100644 x/distribution/client/cli_test/helpers.go diff --git a/tests/cli/helpers/helpers.go b/tests/cli/helpers/helpers.go index d25852edd3b3..81a95ac453ea 100644 --- a/tests/cli/helpers/helpers.go +++ b/tests/cli/helpers/helpers.go @@ -19,21 +19,21 @@ import ( ) var ( - totalCoins = sdk.NewCoins( + TotalCoins = sdk.NewCoins( sdk.NewCoin(Fee2Denom, sdk.TokensFromConsensusPower(2000000)), sdk.NewCoin(FeeDenom, sdk.TokensFromConsensusPower(2000000)), sdk.NewCoin(FooDenom, sdk.TokensFromConsensusPower(2000)), sdk.NewCoin(Denom, sdk.TokensFromConsensusPower(300).Add(sdk.NewInt(12))), // add coins from inflation ) - startCoins = sdk.NewCoins( + StartCoins = sdk.NewCoins( sdk.NewCoin(Fee2Denom, sdk.TokensFromConsensusPower(1000000)), sdk.NewCoin(FeeDenom, sdk.TokensFromConsensusPower(1000000)), sdk.NewCoin(FooDenom, sdk.TokensFromConsensusPower(1000)), sdk.NewCoin(Denom, sdk.TokensFromConsensusPower(150)), ) - vestingCoins = sdk.NewCoins( + VestingCoins = sdk.NewCoins( sdk.NewCoin(FeeDenom, sdk.TokensFromConsensusPower(500000)), ) ) diff --git a/tests/cli/helpers/init.go b/tests/cli/helpers/init.go index 5bcd0996d581..a02012a015d0 100644 --- a/tests/cli/helpers/init.go +++ b/tests/cli/helpers/init.go @@ -42,10 +42,10 @@ func InitFixtures(t *testing.T) (f *Fixtures) { f.CLIConfig("trust-node", "true") // start an account with tokens - f.AddGenesisAccount(f.KeyAddress(KeyFoo), startCoins) + f.AddGenesisAccount(f.KeyAddress(KeyFoo), StartCoins) f.AddGenesisAccount( - f.KeyAddress(KeyVesting), startCoins, - fmt.Sprintf("--vesting-amount=%s", vestingCoins), + f.KeyAddress(KeyVesting), StartCoins, + fmt.Sprintf("--vesting-amount=%s", VestingCoins), fmt.Sprintf("--vesting-start-time=%d", time.Now().UTC().UnixNano()), fmt.Sprintf("--vesting-end-time=%d", time.Now().Add(60*time.Second).UTC().UnixNano()), ) diff --git a/tests/cli/tests/simd_test.go b/tests/cli/tests/simd_test.go new file mode 100644 index 000000000000..128c82c93240 --- /dev/null +++ b/tests/cli/tests/simd_test.go @@ -0,0 +1,128 @@ +package tests + +import ( + "fmt" + "github.com/cosmos/cosmos-sdk/std" + "github.com/cosmos/cosmos-sdk/tests/cli/helpers" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/auth" + "github.com/cosmos/cosmos-sdk/x/bank" + "github.com/stretchr/testify/require" + tmtypes "github.com/tendermint/tendermint/types" + "io/ioutil" + "path/filepath" + "testing" +) + +func TestGaiadCollectGentxs(t *testing.T) { + t.Parallel() + var customMaxBytes, customMaxGas int64 = 99999999, 1234567 + f := helpers.NewFixtures(t) + + // Initialise temporary directories + gentxDir, err := ioutil.TempDir("", "") + gentxDoc := filepath.Join(gentxDir, "gentx.json") + require.NoError(t, err) + + // Reset testing path + f.UnsafeResetAll() + + // Initialize keys + f.KeysAdd(helpers.KeyFoo) + + // Configure json output + f.CLIConfig("output", "json") + + // Run init + f.SDInit(helpers.KeyFoo) + + // Customise genesis.json + + genFile := f.GenesisFile() + genDoc, err := tmtypes.GenesisDocFromFile(genFile) + require.NoError(t, err) + genDoc.ConsensusParams.Block.MaxBytes = customMaxBytes + genDoc.ConsensusParams.Block.MaxGas = customMaxGas + genDoc.SaveAs(genFile) + + // Add account to genesis.json + f.AddGenesisAccount(f.KeyAddress(helpers.KeyFoo), helpers.StartCoins) + + // Write gentx file + f.GenTx(helpers.KeyFoo, fmt.Sprintf("--output-document=%s", gentxDoc)) + + // Collect gentxs from a custom directory + f.CollectGenTxs(fmt.Sprintf("--gentx-dir=%s", gentxDir)) + + genDoc, err = tmtypes.GenesisDocFromFile(genFile) + require.NoError(t, err) + require.Equal(t, genDoc.ConsensusParams.Block.MaxBytes, customMaxBytes) + require.Equal(t, genDoc.ConsensusParams.Block.MaxGas, customMaxGas) + + f.Cleanup(gentxDir) +} + +func TestGaiadAddGenesisAccount(t *testing.T) { + t.Parallel() + f := helpers.NewFixtures(t) + + // Reset testing path + f.UnsafeResetAll() + + // Initialize keys + f.KeysDelete(helpers.KeyFoo) + f.KeysDelete(helpers.KeyBar) + f.KeysDelete(helpers.KeyBaz) + f.KeysAdd(helpers.KeyFoo) + f.KeysAdd(helpers.KeyBar) + f.KeysAdd(helpers.KeyBaz) + + // Configure json output + f.CLIConfig("output", "json") + + // Run init + f.SDInit(helpers.KeyFoo) + + // Add account to genesis.json + bazCoins := sdk.Coins{ + sdk.NewInt64Coin("acoin", 1000000), + sdk.NewInt64Coin("bcoin", 1000000), + } + + f.AddGenesisAccount(f.KeyAddress(helpers.KeyFoo), helpers.StartCoins) + f.AddGenesisAccount(f.KeyAddress(helpers.KeyBar), bazCoins) + + genesisState := f.GenesisState() + + appCodec := std.NewAppCodec(f.Cdc) + + accounts := auth.GetGenesisStateFromAppState(appCodec, genesisState).Accounts + balances := bank.GetGenesisStateFromAppState(f.Cdc, genesisState).Balances + balancesSet := make(map[string]sdk.Coins) + + for _, b := range balances { + balancesSet[b.GetAddress().String()] = b.Coins + } + + require.Equal(t, accounts[0].GetAddress(), f.KeyAddress(helpers.KeyFoo)) + require.Equal(t, accounts[1].GetAddress(), f.KeyAddress(helpers.KeyBar)) + require.True(t, balancesSet[accounts[0].GetAddress().String()].IsEqual(helpers.StartCoins)) + require.True(t, balancesSet[accounts[1].GetAddress().String()].IsEqual(bazCoins)) + + // Cleanup testing directories + f.Cleanup() +} + +func TestValidateGenesis(t *testing.T) { + t.Parallel() + f := helpers.InitFixtures(t) + + // start gaiad server + proc := f.SDStart() + defer proc.Stop(false) + + f.ValidateGenesis() + + // Cleanup testing directories + f.Cleanup() +} diff --git a/x/distribution/client/cli_test/distr_test.go b/x/distribution/client/cli_test/distr_test.go new file mode 100644 index 000000000000..eba04de4f383 --- /dev/null +++ b/x/distribution/client/cli_test/distr_test.go @@ -0,0 +1,44 @@ +package cli_test + +import ( + "github.com/cosmos/cosmos-sdk/tests/cli/helpers" + sdk "github.com/cosmos/cosmos-sdk/types" + distrcli "github.com/cosmos/cosmos-sdk/x/distribution/client/cli_test" + "github.com/cosmos/cosmos-sdk/x/mint" + "github.com/stretchr/testify/require" + tmtypes "github.com/tendermint/tendermint/types" + "path/filepath" + "testing" +) + +func TestCLIQueryRewards(t *testing.T) { + t.Parallel() + f := helpers.InitFixtures(t) + + genesisState := f.GenesisState() + inflationMin := sdk.MustNewDecFromStr("1.0") + var mintData mint.GenesisState + f.Cdc.UnmarshalJSON(genesisState[mint.ModuleName], &mintData) + mintData.Minter.Inflation = inflationMin + mintData.Params.InflationMin = inflationMin + mintData.Params.InflationMax = sdk.MustNewDecFromStr("1.0") + mintDataBz, err := f.Cdc.MarshalJSON(mintData) + require.NoError(t, err) + genesisState[mint.ModuleName] = mintDataBz + + genFile := filepath.Join(f.SimdHome, "config", "genesis.json") + genDoc, err := tmtypes.GenesisDocFromFile(genFile) + require.NoError(t, err) + genDoc.AppState, err = f.Cdc.MarshalJSON(genesisState) + require.NoError(t, genDoc.SaveAs(genFile)) + + // start gaiad server + proc := f.SDStart() + defer proc.Stop(false) + + fooAddr := f.KeyAddress(helpers.KeyFoo) + rewards := distrcli.QueryRewards(f, fooAddr) + require.Equal(t, 1, len(rewards.Rewards)) + + f.Cleanup() +} diff --git a/x/distribution/client/cli_test/helpers.go b/x/distribution/client/cli_test/helpers.go new file mode 100644 index 000000000000..9716a052eb73 --- /dev/null +++ b/x/distribution/client/cli_test/helpers.go @@ -0,0 +1,22 @@ +package cli + +import ( + "fmt" + "github.com/cosmos/cosmos-sdk/tests" + "github.com/cosmos/cosmos-sdk/tests/cli/helpers" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/distribution" + "github.com/stretchr/testify/require" +) + +// QueryRewards returns the rewards of a delegator +func QueryRewards(f *helpers.Fixtures, delAddr sdk.AccAddress, flags ...string) distribution.QueryDelegatorTotalRewardsResponse { + cmd := fmt.Sprintf("%s query distribution rewards %s %s", f.SimcliBinary, delAddr, f.Flags()) + res, errStr := tests.ExecuteT(f.T, cmd, "") + require.Empty(f.T, errStr) + + var rewards distribution.QueryDelegatorTotalRewardsResponse + err := f.Cdc.UnmarshalJSON([]byte(res), &rewards) + require.NoError(f.T, err) + return rewards +} From 4899346bdee7d2f3251e5c99ca2eb32f535c2fa0 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Wed, 29 Apr 2020 17:38:25 +0530 Subject: [PATCH 43/61] Modified naming for test functions --- tests/cli/helpers/helpers.go | 4 ++-- tests/cli/tests/keys_test.go | 4 ++-- x/bank/client/cli_test/send_test.go | 12 ++++++------ x/staking/client/cli_test/staking_test.go | 2 +- 4 files changed, 11 insertions(+), 11 deletions(-) diff --git a/tests/cli/helpers/helpers.go b/tests/cli/helpers/helpers.go index d25852edd3b3..e2bc3cad6867 100644 --- a/tests/cli/helpers/helpers.go +++ b/tests/cli/helpers/helpers.go @@ -168,13 +168,13 @@ func (f *Fixtures) CLIConfig(key, value string, flags ...string) { ExecuteWriteCheckErr(f.T, AddFlags(cmd, flags)) } -// TxBroadcast is gaiacli tx broadcast +// TxBroadcast is simcli tx broadcast func (f *Fixtures) TxBroadcast(fileName string, flags ...string) (bool, string, string) { cmd := fmt.Sprintf("%s tx broadcast %v %v", f.SimcliBinary, f.Flags(), fileName) return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } -// TxEncode is gaiacli tx encode +// TxEncode is simcli tx encode func (f *Fixtures) TxEncode(fileName string, flags ...string) (bool, string, string) { cmd := fmt.Sprintf("%s tx encode %v %v", f.SimcliBinary, f.Flags(), fileName) return ExecuteWriteRetStdStreams(f.T, AddFlags(cmd, flags), clientkeys.DefaultKeyPass) diff --git a/tests/cli/tests/keys_test.go b/tests/cli/tests/keys_test.go index 8bc18743dd63..3abbf0878f2c 100644 --- a/tests/cli/tests/keys_test.go +++ b/tests/cli/tests/keys_test.go @@ -38,7 +38,7 @@ func TestCLIKeysAddMultisig(t *testing.T) { f.Cleanup() } -func TestGaiaCLIKeysAddRecover(t *testing.T) { +func TestCLIKeysAddRecover(t *testing.T) { t.Parallel() f := helpers.InitFixtures(t) @@ -53,7 +53,7 @@ func TestGaiaCLIKeysAddRecover(t *testing.T) { f.Cleanup() } -func TestGaiaCLIKeysAddRecoverHDPath(t *testing.T) { +func TestCLIKeysAddRecoverHDPath(t *testing.T) { t.Parallel() f := helpers.InitFixtures(t) diff --git a/x/bank/client/cli_test/send_test.go b/x/bank/client/cli_test/send_test.go index 4d8b5112d28a..2f65393c099f 100644 --- a/x/bank/client/cli_test/send_test.go +++ b/x/bank/client/cli_test/send_test.go @@ -81,11 +81,11 @@ func TestCLISend(t *testing.T) { f.Cleanup() } -func TestGaiaCLIMinimumFees(t *testing.T) { +func TestCLIMinimumFees(t *testing.T) { t.Parallel() f := helpers.InitFixtures(t) - // start gaiad server with minimum fees + // start simd server with minimum fees minGasPrice, _ := sdk.NewDecFromStr("0.000006") fees := fmt.Sprintf( "--minimum-gas-prices=%s,%s", @@ -119,11 +119,11 @@ func TestGaiaCLIMinimumFees(t *testing.T) { f.Cleanup() } -func TestGaiaCLIGasPrices(t *testing.T) { +func TestCLIGasPrices(t *testing.T) { t.Parallel() f := helpers.InitFixtures(t) - // start gaiad server with minimum fees + // start simd server with minimum fees minGasPrice, _ := sdk.NewDecFromStr("0.000006") proc := f.SDStart(fmt.Sprintf("--minimum-gas-prices=%s", sdk.NewDecCoinFromDec(helpers.FeeDenom, minGasPrice))) defer proc.Stop(false) @@ -153,11 +153,11 @@ func TestGaiaCLIGasPrices(t *testing.T) { f.Cleanup() } -func TestGaiaCLIFeesDeduction(t *testing.T) { +func TestCLIFeesDeduction(t *testing.T) { t.Parallel() f := helpers.InitFixtures(t) - // start gaiad server with minimum fees + // start simd server with minimum fees minGasPrice, _ := sdk.NewDecFromStr("0.000006") proc := f.SDStart(fmt.Sprintf("--minimum-gas-prices=%s", sdk.NewDecCoinFromDec(helpers.FeeDenom, minGasPrice))) defer proc.Stop(false) diff --git a/x/staking/client/cli_test/staking_test.go b/x/staking/client/cli_test/staking_test.go index b801e7dddf87..de8b9835148a 100644 --- a/x/staking/client/cli_test/staking_test.go +++ b/x/staking/client/cli_test/staking_test.go @@ -17,7 +17,7 @@ func TestCLICreateValidator(t *testing.T) { t.Parallel() f := helpers.InitFixtures(t) - // start gaiad server + // start simd server proc := f.SDStart() defer proc.Stop(false) From d61687f0031dd399f87e8a18678e00017b34ff17 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Wed, 29 Apr 2020 22:23:57 +0530 Subject: [PATCH 44/61] Added test for withdraw rewards --- x/distribution/client/cli_test/distr_test.go | 11 ++++++++++- x/distribution/client/cli_test/helpers.go | 6 ++++++ 2 files changed, 16 insertions(+), 1 deletion(-) diff --git a/x/distribution/client/cli_test/distr_test.go b/x/distribution/client/cli_test/distr_test.go index eba04de4f383..818d495a2753 100644 --- a/x/distribution/client/cli_test/distr_test.go +++ b/x/distribution/client/cli_test/distr_test.go @@ -11,7 +11,7 @@ import ( "testing" ) -func TestCLIQueryRewards(t *testing.T) { +func TestCliWithdrawRewards(t *testing.T) { t.Parallel() f := helpers.InitFixtures(t) @@ -39,6 +39,15 @@ func TestCLIQueryRewards(t *testing.T) { fooAddr := f.KeyAddress(helpers.KeyFoo) rewards := distrcli.QueryRewards(f, fooAddr) require.Equal(t, 1, len(rewards.Rewards)) + require.NotNil(t, rewards.Total) + fooVal := sdk.ValAddress(fooAddr) + success := distrcli.TxWithdrawRewards(f, fooVal, fooAddr.String(), "-y") + require.True(t, success) + + rewards = distrcli.QueryRewards(f, fooAddr) + require.Equal(t, 1, len(rewards.Rewards)) + + require.Nil(t, rewards.Total) f.Cleanup() } diff --git a/x/distribution/client/cli_test/helpers.go b/x/distribution/client/cli_test/helpers.go index 9716a052eb73..cdad1b08be87 100644 --- a/x/distribution/client/cli_test/helpers.go +++ b/x/distribution/client/cli_test/helpers.go @@ -2,6 +2,7 @@ package cli import ( "fmt" + clientkeys "github.com/cosmos/cosmos-sdk/client/keys" "github.com/cosmos/cosmos-sdk/tests" "github.com/cosmos/cosmos-sdk/tests/cli/helpers" sdk "github.com/cosmos/cosmos-sdk/types" @@ -9,6 +10,11 @@ import ( "github.com/stretchr/testify/require" ) +func TxWithdrawRewards(f *helpers.Fixtures, valAddr sdk.ValAddress, from string, flags ...string) bool { + cmd := fmt.Sprintf("%s tx distribution withdraw-rewards %s %v --keyring-backend=test --from=%s", f.SimcliBinary, valAddr, f.Flags(), from) + return helpers.ExecuteWrite(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) +} + // QueryRewards returns the rewards of a delegator func QueryRewards(f *helpers.Fixtures, delAddr sdk.AccAddress, flags ...string) distribution.QueryDelegatorTotalRewardsResponse { cmd := fmt.Sprintf("%s query distribution rewards %s %s", f.SimcliBinary, delAddr, f.Flags()) From 1a1545484d39c1d548de40715b7104ea548a2ef3 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Thu, 30 Apr 2020 02:47:54 +0530 Subject: [PATCH 45/61] Modified test function names --- tests/cli/tests/simd_test.go | 6 +++--- x/distribution/client/cli_test/distr_test.go | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/cli/tests/simd_test.go b/tests/cli/tests/simd_test.go index 128c82c93240..1e20c3d8335a 100644 --- a/tests/cli/tests/simd_test.go +++ b/tests/cli/tests/simd_test.go @@ -14,7 +14,7 @@ import ( "testing" ) -func TestGaiadCollectGentxs(t *testing.T) { +func TestSimdCollectGentxs(t *testing.T) { t.Parallel() var customMaxBytes, customMaxGas int64 = 99999999, 1234567 f := helpers.NewFixtures(t) @@ -62,7 +62,7 @@ func TestGaiadCollectGentxs(t *testing.T) { f.Cleanup(gentxDir) } -func TestGaiadAddGenesisAccount(t *testing.T) { +func TestSimdAddGenesisAccount(t *testing.T) { t.Parallel() f := helpers.NewFixtures(t) @@ -117,7 +117,7 @@ func TestValidateGenesis(t *testing.T) { t.Parallel() f := helpers.InitFixtures(t) - // start gaiad server + // start simd server proc := f.SDStart() defer proc.Stop(false) diff --git a/x/distribution/client/cli_test/distr_test.go b/x/distribution/client/cli_test/distr_test.go index 818d495a2753..6ec864da5386 100644 --- a/x/distribution/client/cli_test/distr_test.go +++ b/x/distribution/client/cli_test/distr_test.go @@ -32,7 +32,7 @@ func TestCliWithdrawRewards(t *testing.T) { genDoc.AppState, err = f.Cdc.MarshalJSON(genesisState) require.NoError(t, genDoc.SaveAs(genFile)) - // start gaiad server + // start simd server proc := f.SDStart() defer proc.Stop(false) From b3427f7802afe755dde7deea0203a7729436f149 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Thu, 30 Apr 2020 02:49:03 +0530 Subject: [PATCH 46/61] Fixed import format --- x/distribution/client/cli_test/distr_test.go | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/x/distribution/client/cli_test/distr_test.go b/x/distribution/client/cli_test/distr_test.go index 6ec864da5386..035222a1fca9 100644 --- a/x/distribution/client/cli_test/distr_test.go +++ b/x/distribution/client/cli_test/distr_test.go @@ -1,14 +1,16 @@ package cli_test import ( + "path/filepath" + "testing" + + "github.com/stretchr/testify/require" + tmtypes "github.com/tendermint/tendermint/types" + "github.com/cosmos/cosmos-sdk/tests/cli/helpers" sdk "github.com/cosmos/cosmos-sdk/types" distrcli "github.com/cosmos/cosmos-sdk/x/distribution/client/cli_test" "github.com/cosmos/cosmos-sdk/x/mint" - "github.com/stretchr/testify/require" - tmtypes "github.com/tendermint/tendermint/types" - "path/filepath" - "testing" ) func TestCliWithdrawRewards(t *testing.T) { From a6593953dee2617891812455d9fd6a3eb15aab9c Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Thu, 30 Apr 2020 19:50:36 +0530 Subject: [PATCH 47/61] Migrated helpers to package cli --- .github/workflows/test.yml | 3 + Makefile | 2 +- tests/cli/{helpers => }/constants.go | 2 +- tests/cli/{tests => }/doc.go | 2 +- tests/cli/{helpers => }/executors.go | 2 +- tests/cli/{helpers => }/fixtures.go | 2 +- tests/cli/{helpers => }/helpers.go | 2 +- tests/cli/{helpers => }/init.go | 2 +- tests/cli/{tests => }/keys_test.go | 19 ++-- tests/cli/{tests => }/simd_test.go | 42 ++++----- x/bank/client/cli_test/helpers.go | 14 +-- x/bank/client/cli_test/send_test.go | 96 ++++++++++---------- x/distribution/client/cli_test/distr_test.go | 6 +- x/distribution/client/cli_test/helpers.go | 8 +- x/staking/client/cli_test/helpers.go | 30 +++--- x/staking/client/cli_test/staking_test.go | 22 ++--- 16 files changed, 128 insertions(+), 126 deletions(-) rename tests/cli/{helpers => }/constants.go (93%) rename tests/cli/{tests => }/doc.go (83%) rename tests/cli/{helpers => }/executors.go (98%) rename tests/cli/{helpers => }/fixtures.go (99%) rename tests/cli/{helpers => }/helpers.go (99%) rename tests/cli/{helpers => }/init.go (99%) rename tests/cli/{tests => }/keys_test.go (84%) rename tests/cli/{tests => }/simd_test.go (74%) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index cddf3ce52ff3..8e59de9ad5e3 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -29,6 +29,9 @@ jobs: run: | make build if: "env.GIT_DIFF != ''" + - name: build + run: | + make build-sim - name: test & coverage report creation run: | go test ./... -mod=readonly -timeout 12m -race -coverprofile=coverage.txt -covermode=atomic -tags='ledger test_ledger_mock' diff --git a/Makefile b/Makefile index ad12a193844e..0e0876afb757 100644 --- a/Makefile +++ b/Makefile @@ -169,7 +169,7 @@ test-sim-benchmark-invariants: -Period=1 -Commit=true -Seed=57 -v -timeout 24h cli-test: build-sim - @go test -mod=readonly -p 4 `go list ./tests/cli/tests/...` -tags=cli_test -v + @go test -mod=readonly -p 4 `go list ./tests/cli/...` -tags=cli_test -v @go test -mod=readonly -p 4 `go list ./x/.../client/cli_test/...` -tags=cli_test -v .PHONY: \ diff --git a/tests/cli/helpers/constants.go b/tests/cli/constants.go similarity index 93% rename from tests/cli/helpers/constants.go rename to tests/cli/constants.go index c634f3cc5a19..9068d44464ea 100644 --- a/tests/cli/helpers/constants.go +++ b/tests/cli/constants.go @@ -1,4 +1,4 @@ -package helpers +package cli const ( Denom = "stake" diff --git a/tests/cli/tests/doc.go b/tests/cli/doc.go similarity index 83% rename from tests/cli/tests/doc.go rename to tests/cli/doc.go index 84f19f32a526..fca4bd79fd79 100644 --- a/tests/cli/tests/doc.go +++ b/tests/cli/doc.go @@ -1,3 +1,3 @@ -package tests +package cli // package tests runs integration tests which make use of CLI commands. diff --git a/tests/cli/helpers/executors.go b/tests/cli/executors.go similarity index 98% rename from tests/cli/helpers/executors.go rename to tests/cli/executors.go index cb4e011b94b6..3f7e81475332 100644 --- a/tests/cli/helpers/executors.go +++ b/tests/cli/executors.go @@ -1,4 +1,4 @@ -package helpers +package cli import ( "fmt" diff --git a/tests/cli/helpers/fixtures.go b/tests/cli/fixtures.go similarity index 99% rename from tests/cli/helpers/fixtures.go rename to tests/cli/fixtures.go index 9e71dca945a8..cc3b2931bdb8 100644 --- a/tests/cli/helpers/fixtures.go +++ b/tests/cli/fixtures.go @@ -1,4 +1,4 @@ -package helpers +package cli import ( "io/ioutil" diff --git a/tests/cli/helpers/helpers.go b/tests/cli/helpers.go similarity index 99% rename from tests/cli/helpers/helpers.go rename to tests/cli/helpers.go index 811bf5e01482..eebcc336bcf5 100644 --- a/tests/cli/helpers/helpers.go +++ b/tests/cli/helpers.go @@ -1,4 +1,4 @@ -package helpers +package cli import ( "encoding/json" diff --git a/tests/cli/helpers/init.go b/tests/cli/init.go similarity index 99% rename from tests/cli/helpers/init.go rename to tests/cli/init.go index a02012a015d0..3a6efa98ccb7 100644 --- a/tests/cli/helpers/init.go +++ b/tests/cli/init.go @@ -1,4 +1,4 @@ -package helpers +package cli import ( "fmt" diff --git a/tests/cli/tests/keys_test.go b/tests/cli/keys_test.go similarity index 84% rename from tests/cli/tests/keys_test.go rename to tests/cli/keys_test.go index 3abbf0878f2c..0a6c64ab3d3f 100644 --- a/tests/cli/tests/keys_test.go +++ b/tests/cli/keys_test.go @@ -1,36 +1,35 @@ // +build cli_test -package tests +package cli_test import ( "fmt" "testing" + "github.com/cosmos/cosmos-sdk/tests/cli" "github.com/stretchr/testify/require" - - "github.com/cosmos/cosmos-sdk/tests/cli/helpers" ) func TestCLIKeysAddMultisig(t *testing.T) { t.Parallel() - f := helpers.InitFixtures(t) + f := cli.InitFixtures(t) // key names order does not matter f.KeysAdd("msig1", "--multisig-threshold=2", - fmt.Sprintf("--multisig=%s,%s", helpers.KeyBar, helpers.KeyBaz)) + fmt.Sprintf("--multisig=%s,%s", cli.KeyBar, cli.KeyBaz)) ke1Address1 := f.KeysShow("msig1").Address f.KeysDelete("msig1") f.KeysAdd("msig2", "--multisig-threshold=2", - fmt.Sprintf("--multisig=%s,%s", helpers.KeyBaz, helpers.KeyBar)) + fmt.Sprintf("--multisig=%s,%s", cli.KeyBaz, cli.KeyBar)) require.Equal(t, ke1Address1, f.KeysShow("msig2").Address) f.KeysDelete("msig2") f.KeysAdd("msig3", "--multisig-threshold=2", - fmt.Sprintf("--multisig=%s,%s", helpers.KeyBar, helpers.KeyBaz), + fmt.Sprintf("--multisig=%s,%s", cli.KeyBar, cli.KeyBaz), "--nosort") f.KeysAdd("msig4", "--multisig-threshold=2", - fmt.Sprintf("--multisig=%s,%s", helpers.KeyBaz, helpers.KeyBar), + fmt.Sprintf("--multisig=%s,%s", cli.KeyBaz, cli.KeyBar), "--nosort") require.NotEqual(t, f.KeysShow("msig3").Address, f.KeysShow("msig4").Address) @@ -40,7 +39,7 @@ func TestCLIKeysAddMultisig(t *testing.T) { func TestCLIKeysAddRecover(t *testing.T) { t.Parallel() - f := helpers.InitFixtures(t) + f := cli.InitFixtures(t) exitSuccess, _, _ := f.KeysAddRecover("empty-mnemonic", "") require.False(t, exitSuccess) @@ -55,7 +54,7 @@ func TestCLIKeysAddRecover(t *testing.T) { func TestCLIKeysAddRecoverHDPath(t *testing.T) { t.Parallel() - f := helpers.InitFixtures(t) + f := cli.InitFixtures(t) f.KeysAddRecoverHDPath("test-recoverHD1", "dentist task convince chimney quality leave banana trade firm crawl eternal easily", 0, 0) require.Equal(t, "cosmos1qcfdf69js922qrdr4yaww3ax7gjml6pdds46f4", f.KeyAddress("test-recoverHD1").String()) diff --git a/tests/cli/tests/simd_test.go b/tests/cli/simd_test.go similarity index 74% rename from tests/cli/tests/simd_test.go rename to tests/cli/simd_test.go index 1e20c3d8335a..b0860fdf0d4f 100644 --- a/tests/cli/tests/simd_test.go +++ b/tests/cli/simd_test.go @@ -1,9 +1,9 @@ -package tests +package cli_test import ( "fmt" "github.com/cosmos/cosmos-sdk/std" - "github.com/cosmos/cosmos-sdk/tests/cli/helpers" + "github.com/cosmos/cosmos-sdk/tests/cli" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/auth" "github.com/cosmos/cosmos-sdk/x/bank" @@ -17,7 +17,7 @@ import ( func TestSimdCollectGentxs(t *testing.T) { t.Parallel() var customMaxBytes, customMaxGas int64 = 99999999, 1234567 - f := helpers.NewFixtures(t) + f := cli.NewFixtures(t) // Initialise temporary directories gentxDir, err := ioutil.TempDir("", "") @@ -28,13 +28,13 @@ func TestSimdCollectGentxs(t *testing.T) { f.UnsafeResetAll() // Initialize keys - f.KeysAdd(helpers.KeyFoo) + f.KeysAdd(cli.KeyFoo) // Configure json output f.CLIConfig("output", "json") // Run init - f.SDInit(helpers.KeyFoo) + f.SDInit(cli.KeyFoo) // Customise genesis.json @@ -46,10 +46,10 @@ func TestSimdCollectGentxs(t *testing.T) { genDoc.SaveAs(genFile) // Add account to genesis.json - f.AddGenesisAccount(f.KeyAddress(helpers.KeyFoo), helpers.StartCoins) + f.AddGenesisAccount(f.KeyAddress(cli.KeyFoo), cli.StartCoins) // Write gentx file - f.GenTx(helpers.KeyFoo, fmt.Sprintf("--output-document=%s", gentxDoc)) + f.GenTx(cli.KeyFoo, fmt.Sprintf("--output-document=%s", gentxDoc)) // Collect gentxs from a custom directory f.CollectGenTxs(fmt.Sprintf("--gentx-dir=%s", gentxDir)) @@ -64,24 +64,24 @@ func TestSimdCollectGentxs(t *testing.T) { func TestSimdAddGenesisAccount(t *testing.T) { t.Parallel() - f := helpers.NewFixtures(t) + f := cli.NewFixtures(t) // Reset testing path f.UnsafeResetAll() // Initialize keys - f.KeysDelete(helpers.KeyFoo) - f.KeysDelete(helpers.KeyBar) - f.KeysDelete(helpers.KeyBaz) - f.KeysAdd(helpers.KeyFoo) - f.KeysAdd(helpers.KeyBar) - f.KeysAdd(helpers.KeyBaz) + f.KeysDelete(cli.KeyFoo) + f.KeysDelete(cli.KeyBar) + f.KeysDelete(cli.KeyBaz) + f.KeysAdd(cli.KeyFoo) + f.KeysAdd(cli.KeyBar) + f.KeysAdd(cli.KeyBaz) // Configure json output f.CLIConfig("output", "json") // Run init - f.SDInit(helpers.KeyFoo) + f.SDInit(cli.KeyFoo) // Add account to genesis.json bazCoins := sdk.Coins{ @@ -89,8 +89,8 @@ func TestSimdAddGenesisAccount(t *testing.T) { sdk.NewInt64Coin("bcoin", 1000000), } - f.AddGenesisAccount(f.KeyAddress(helpers.KeyFoo), helpers.StartCoins) - f.AddGenesisAccount(f.KeyAddress(helpers.KeyBar), bazCoins) + f.AddGenesisAccount(f.KeyAddress(cli.KeyFoo), cli.StartCoins) + f.AddGenesisAccount(f.KeyAddress(cli.KeyBar), bazCoins) genesisState := f.GenesisState() @@ -104,9 +104,9 @@ func TestSimdAddGenesisAccount(t *testing.T) { balancesSet[b.GetAddress().String()] = b.Coins } - require.Equal(t, accounts[0].GetAddress(), f.KeyAddress(helpers.KeyFoo)) - require.Equal(t, accounts[1].GetAddress(), f.KeyAddress(helpers.KeyBar)) - require.True(t, balancesSet[accounts[0].GetAddress().String()].IsEqual(helpers.StartCoins)) + require.Equal(t, accounts[0].GetAddress(), f.KeyAddress(cli.KeyFoo)) + require.Equal(t, accounts[1].GetAddress(), f.KeyAddress(cli.KeyBar)) + require.True(t, balancesSet[accounts[0].GetAddress().String()].IsEqual(cli.StartCoins)) require.True(t, balancesSet[accounts[1].GetAddress().String()].IsEqual(bazCoins)) // Cleanup testing directories @@ -115,7 +115,7 @@ func TestSimdAddGenesisAccount(t *testing.T) { func TestValidateGenesis(t *testing.T) { t.Parallel() - f := helpers.InitFixtures(t) + f := cli.InitFixtures(t) // start simd server proc := f.SDStart() diff --git a/x/bank/client/cli_test/helpers.go b/x/bank/client/cli_test/helpers.go index ae3556374cdb..90c9e23b0de5 100644 --- a/x/bank/client/cli_test/helpers.go +++ b/x/bank/client/cli_test/helpers.go @@ -5,24 +5,24 @@ import ( "fmt" clientkeys "github.com/cosmos/cosmos-sdk/client/keys" "github.com/cosmos/cosmos-sdk/tests" - "github.com/cosmos/cosmos-sdk/tests/cli/helpers" + "github.com/cosmos/cosmos-sdk/tests/cli" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/auth" "github.com/stretchr/testify/require" ) // TxSend is simcli tx send -func TxSend(f *helpers.Fixtures, from string, to sdk.AccAddress, amount sdk.Coin, flags ...string) (bool, string, string) { +func TxSend(f *cli.Fixtures, from string, to sdk.AccAddress, amount sdk.Coin, flags ...string) (bool, string, string) { cmd := fmt.Sprintf("%s tx send --keyring-backend=test %s %s %s %v", f.SimcliBinary, from, to, amount, f.Flags()) - return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) + return cli.ExecuteWriteRetStdStreams(f.T, cli.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } // QueryAccount is simcli query account -func QueryAccount(f *helpers.Fixtures, address sdk.AccAddress, flags ...string) auth.BaseAccount { +func QueryAccount(f *cli.Fixtures, address sdk.AccAddress, flags ...string) auth.BaseAccount { cmd := fmt.Sprintf("%s query account %s %v", f.SimcliBinary, address, f.Flags()) - out, _ := tests.ExecuteT(f.T, helpers.AddFlags(cmd, flags), "") + out, _ := tests.ExecuteT(f.T, cli.AddFlags(cmd, flags), "") var initRes map[string]json.RawMessage err := json.Unmarshal([]byte(out), &initRes) @@ -38,9 +38,9 @@ func QueryAccount(f *helpers.Fixtures, address sdk.AccAddress, flags ...string) // QueryBalances executes the bank query balances command for a given address and // flag set. -func QueryBalances(f *helpers.Fixtures, address sdk.AccAddress, flags ...string) sdk.Coins { +func QueryBalances(f *cli.Fixtures, address sdk.AccAddress, flags ...string) sdk.Coins { cmd := fmt.Sprintf("%s query bank balances %s %v", f.SimcliBinary, address, f.Flags()) - out, _ := tests.ExecuteT(f.T, helpers.AddFlags(cmd, flags), "") + out, _ := tests.ExecuteT(f.T, cli.AddFlags(cmd, flags), "") var balances sdk.Coins diff --git a/x/bank/client/cli_test/send_test.go b/x/bank/client/cli_test/send_test.go index 2f65393c099f..f4aafb2e327e 100644 --- a/x/bank/client/cli_test/send_test.go +++ b/x/bank/client/cli_test/send_test.go @@ -5,7 +5,7 @@ package cli_test import ( "fmt" "github.com/cosmos/cosmos-sdk/tests" - "github.com/cosmos/cosmos-sdk/tests/cli/helpers" + "github.com/cosmos/cosmos-sdk/tests/cli" sdk "github.com/cosmos/cosmos-sdk/types" bankcli "github.com/cosmos/cosmos-sdk/x/bank/client/cli_test" "github.com/stretchr/testify/require" @@ -14,104 +14,104 @@ import ( func TestCLISend(t *testing.T) { t.Parallel() - f := helpers.InitFixtures(t) + f := cli.InitFixtures(t) // start simd server proc := f.SDStart() defer proc.Stop(false) // Save key addresses for later uspackage testse - fooAddr := f.KeyAddress(helpers.KeyFoo) - barAddr := f.KeyAddress(helpers.KeyBar) + fooAddr := f.KeyAddress(cli.KeyFoo) + barAddr := f.KeyAddress(cli.KeyBar) startTokens := sdk.TokensFromConsensusPower(50) - require.Equal(t, startTokens, bankcli.QueryBalances(f, fooAddr).AmountOf(helpers.Denom)) + require.Equal(t, startTokens, bankcli.QueryBalances(f, fooAddr).AmountOf(cli.Denom)) sendTokens := sdk.TokensFromConsensusPower(10) // It does not allow to send in offline mode - success, _, stdErr := bankcli.TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y", "--offline") + success, _, stdErr := bankcli.TxSend(f, cli.KeyFoo, barAddr, sdk.NewCoin(cli.Denom, sendTokens), "-y", "--offline") require.Contains(t, stdErr, "no RPC client is defined in offline mode") require.False(f.T, success) tests.WaitForNextNBlocksTM(1, f.Port) // Send some tokens from one account to the other - bankcli.TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") + bankcli.TxSend(f, cli.KeyFoo, barAddr, sdk.NewCoin(cli.Denom, sendTokens), "-y") tests.WaitForNextNBlocksTM(1, f.Port) // Ensure account balances match expected - require.Equal(t, sendTokens, bankcli.QueryBalances(f, barAddr).AmountOf(helpers.Denom)) - require.Equal(t, startTokens.Sub(sendTokens), bankcli.QueryBalances(f, fooAddr).AmountOf(helpers.Denom)) + require.Equal(t, sendTokens, bankcli.QueryBalances(f, barAddr).AmountOf(cli.Denom)) + require.Equal(t, startTokens.Sub(sendTokens), bankcli.QueryBalances(f, fooAddr).AmountOf(cli.Denom)) // Test --dry-run - success, _, _ = bankcli.TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "--dry-run") + success, _, _ = bankcli.TxSend(f, cli.KeyFoo, barAddr, sdk.NewCoin(cli.Denom, sendTokens), "--dry-run") require.True(t, success) // Test --generate-only success, stdout, stderr := bankcli.TxSend( - f, fooAddr.String(), barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "--generate-only=true", + f, fooAddr.String(), barAddr, sdk.NewCoin(cli.Denom, sendTokens), "--generate-only=true", ) require.Empty(t, stderr) require.True(t, success) - msg := helpers.UnmarshalStdTx(f.T, f.Cdc, stdout) + msg := cli.UnmarshalStdTx(f.T, f.Cdc, stdout) t.Log(msg) require.NotZero(t, msg.Fee.Gas) require.Len(t, msg.Msgs, 1) require.Len(t, msg.GetSignatures(), 0) // Check state didn't change - require.Equal(t, startTokens.Sub(sendTokens), bankcli.QueryBalances(f, fooAddr).AmountOf(helpers.Denom)) + require.Equal(t, startTokens.Sub(sendTokens), bankcli.QueryBalances(f, fooAddr).AmountOf(cli.Denom)) // test autosequencing - bankcli.TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") + bankcli.TxSend(f, cli.KeyFoo, barAddr, sdk.NewCoin(cli.Denom, sendTokens), "-y") tests.WaitForNextNBlocksTM(1, f.Port) // Ensure account balances match expected - require.Equal(t, sendTokens.MulRaw(2), bankcli.QueryBalances(f, barAddr).AmountOf(helpers.Denom)) - require.Equal(t, startTokens.Sub(sendTokens.MulRaw(2)), bankcli.QueryBalances(f, fooAddr).AmountOf(helpers.Denom)) + require.Equal(t, sendTokens.MulRaw(2), bankcli.QueryBalances(f, barAddr).AmountOf(cli.Denom)) + require.Equal(t, startTokens.Sub(sendTokens.MulRaw(2)), bankcli.QueryBalances(f, fooAddr).AmountOf(cli.Denom)) // test memo - bankcli.TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "--memo='testmemo'", "-y") + bankcli.TxSend(f, cli.KeyFoo, barAddr, sdk.NewCoin(cli.Denom, sendTokens), "--memo='testmemo'", "-y") tests.WaitForNextNBlocksTM(1, f.Port) // Ensure account balances match expected - require.Equal(t, sendTokens.MulRaw(3), bankcli.QueryBalances(f, barAddr).AmountOf(helpers.Denom)) - require.Equal(t, startTokens.Sub(sendTokens.MulRaw(3)), bankcli.QueryBalances(f, fooAddr).AmountOf(helpers.Denom)) + require.Equal(t, sendTokens.MulRaw(3), bankcli.QueryBalances(f, barAddr).AmountOf(cli.Denom)) + require.Equal(t, startTokens.Sub(sendTokens.MulRaw(3)), bankcli.QueryBalances(f, fooAddr).AmountOf(cli.Denom)) f.Cleanup() } func TestCLIMinimumFees(t *testing.T) { t.Parallel() - f := helpers.InitFixtures(t) + f := cli.InitFixtures(t) // start simd server with minimum fees minGasPrice, _ := sdk.NewDecFromStr("0.000006") fees := fmt.Sprintf( "--minimum-gas-prices=%s,%s", - sdk.NewDecCoinFromDec(helpers.FeeDenom, minGasPrice), - sdk.NewDecCoinFromDec(helpers.Fee2Denom, minGasPrice), + sdk.NewDecCoinFromDec(cli.FeeDenom, minGasPrice), + sdk.NewDecCoinFromDec(cli.Fee2Denom, minGasPrice), ) proc := f.SDStart(fees) defer proc.Stop(false) - barAddr := f.KeyAddress(helpers.KeyBar) + barAddr := f.KeyAddress(cli.KeyBar) // Send a transaction that will get rejected - success, stdOut, _ := bankcli.TxSend(f, helpers.KeyFoo, barAddr, sdk.NewInt64Coin(helpers.Fee2Denom, 10), "-y") + success, stdOut, _ := bankcli.TxSend(f, cli.KeyFoo, barAddr, sdk.NewInt64Coin(cli.Fee2Denom, 10), "-y") require.Contains(t, stdOut, "insufficient fees") require.True(f.T, success) tests.WaitForNextNBlocksTM(1, f.Port) // Ensure tx w/ correct fees pass - txFees := fmt.Sprintf("--fees=%s", sdk.NewInt64Coin(helpers.FeeDenom, 2)) - success, _, _ = bankcli.TxSend(f, helpers.KeyFoo, barAddr, sdk.NewInt64Coin(helpers.Fee2Denom, 10), txFees, "-y") + txFees := fmt.Sprintf("--fees=%s", sdk.NewInt64Coin(cli.FeeDenom, 2)) + success, _, _ = bankcli.TxSend(f, cli.KeyFoo, barAddr, sdk.NewInt64Coin(cli.Fee2Denom, 10), txFees, "-y") require.True(f.T, success) tests.WaitForNextNBlocksTM(1, f.Port) // Ensure tx w/ improper fees fails - txFees = fmt.Sprintf("--fees=%s", sdk.NewInt64Coin(helpers.FeeDenom, 1)) - success, _, _ = bankcli.TxSend(f, helpers.KeyFoo, barAddr, sdk.NewInt64Coin(helpers.FooDenom, 10), txFees, "-y") + txFees = fmt.Sprintf("--fees=%s", sdk.NewInt64Coin(cli.FeeDenom, 1)) + success, _, _ = bankcli.TxSend(f, cli.KeyFoo, barAddr, sdk.NewInt64Coin(cli.FooDenom, 10), txFees, "-y") require.Contains(t, stdOut, "insufficient fees") require.True(f.T, success) @@ -121,20 +121,20 @@ func TestCLIMinimumFees(t *testing.T) { func TestCLIGasPrices(t *testing.T) { t.Parallel() - f := helpers.InitFixtures(t) + f := cli.InitFixtures(t) // start simd server with minimum fees minGasPrice, _ := sdk.NewDecFromStr("0.000006") - proc := f.SDStart(fmt.Sprintf("--minimum-gas-prices=%s", sdk.NewDecCoinFromDec(helpers.FeeDenom, minGasPrice))) + proc := f.SDStart(fmt.Sprintf("--minimum-gas-prices=%s", sdk.NewDecCoinFromDec(cli.FeeDenom, minGasPrice))) defer proc.Stop(false) - barAddr := f.KeyAddress(helpers.KeyBar) + barAddr := f.KeyAddress(cli.KeyBar) // insufficient gas prices (tx fails) badGasPrice, _ := sdk.NewDecFromStr("0.000003") success, stdOut, _ := bankcli.TxSend( - f, helpers.KeyFoo, barAddr, sdk.NewInt64Coin(helpers.FooDenom, 50), - fmt.Sprintf("--gas-prices=%s", sdk.NewDecCoinFromDec(helpers.FeeDenom, badGasPrice)), "-y") + f, cli.KeyFoo, barAddr, sdk.NewInt64Coin(cli.FooDenom, 50), + fmt.Sprintf("--gas-prices=%s", sdk.NewDecCoinFromDec(cli.FeeDenom, badGasPrice)), "-y") require.Contains(t, stdOut, "insufficient fees") require.True(t, success) @@ -143,8 +143,8 @@ func TestCLIGasPrices(t *testing.T) { // sufficient gas prices (tx passes) success, _, _ = bankcli.TxSend( - f, helpers.KeyFoo, barAddr, sdk.NewInt64Coin(helpers.FooDenom, 50), - fmt.Sprintf("--gas-prices=%s", sdk.NewDecCoinFromDec(helpers.FeeDenom, minGasPrice)), "-y") + f, cli.KeyFoo, barAddr, sdk.NewInt64Coin(cli.FooDenom, 50), + fmt.Sprintf("--gas-prices=%s", sdk.NewDecCoinFromDec(cli.FeeDenom, minGasPrice)), "-y") require.True(t, success) // wait for a block confirmation @@ -155,36 +155,36 @@ func TestCLIGasPrices(t *testing.T) { func TestCLIFeesDeduction(t *testing.T) { t.Parallel() - f := helpers.InitFixtures(t) + f := cli.InitFixtures(t) // start simd server with minimum fees minGasPrice, _ := sdk.NewDecFromStr("0.000006") - proc := f.SDStart(fmt.Sprintf("--minimum-gas-prices=%s", sdk.NewDecCoinFromDec(helpers.FeeDenom, minGasPrice))) + proc := f.SDStart(fmt.Sprintf("--minimum-gas-prices=%s", sdk.NewDecCoinFromDec(cli.FeeDenom, minGasPrice))) defer proc.Stop(false) // Save key addresses for later use - fooAddr := f.KeyAddress(helpers.KeyFoo) - barAddr := f.KeyAddress(helpers.KeyBar) + fooAddr := f.KeyAddress(cli.KeyFoo) + barAddr := f.KeyAddress(cli.KeyBar) - fooAmt := bankcli.QueryBalances(f, fooAddr).AmountOf(helpers.FooDenom) + fooAmt := bankcli.QueryBalances(f, fooAddr).AmountOf(cli.FooDenom) // test simulation success, _, _ := bankcli.TxSend( - f, helpers.KeyFoo, barAddr, sdk.NewInt64Coin(helpers.FooDenom, 1000), - fmt.Sprintf("--fees=%s", sdk.NewInt64Coin(helpers.FeeDenom, 2)), "--dry-run") + f, cli.KeyFoo, barAddr, sdk.NewInt64Coin(cli.FooDenom, 1000), + fmt.Sprintf("--fees=%s", sdk.NewInt64Coin(cli.FeeDenom, 2)), "--dry-run") require.True(t, success) // Wait for a block tests.WaitForNextNBlocksTM(1, f.Port) // ensure state didn't change - require.Equal(t, fooAmt.Int64(), bankcli.QueryBalances(f, fooAddr).AmountOf(helpers.FooDenom).Int64()) + require.Equal(t, fooAmt.Int64(), bankcli.QueryBalances(f, fooAddr).AmountOf(cli.FooDenom).Int64()) // insufficient funds (coins + fees) tx fails largeCoins := sdk.TokensFromConsensusPower(10000000) success, stdOut, _ := bankcli.TxSend( - f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.FooDenom, largeCoins), - fmt.Sprintf("--fees=%s", sdk.NewInt64Coin(helpers.FeeDenom, 2)), "-y") + f, cli.KeyFoo, barAddr, sdk.NewCoin(cli.FooDenom, largeCoins), + fmt.Sprintf("--fees=%s", sdk.NewInt64Coin(cli.FeeDenom, 2)), "-y") require.Contains(t, stdOut, "insufficient funds") require.True(t, success) @@ -192,12 +192,12 @@ func TestCLIFeesDeduction(t *testing.T) { tests.WaitForNextNBlocksTM(1, f.Port) // ensure state didn't change - require.Equal(t, fooAmt.Int64(), bankcli.QueryBalances(f, fooAddr).AmountOf(helpers.FooDenom).Int64()) + require.Equal(t, fooAmt.Int64(), bankcli.QueryBalances(f, fooAddr).AmountOf(cli.FooDenom).Int64()) // test success (transfer = coins + fees) success, _, _ = bankcli.TxSend( - f, helpers.KeyFoo, barAddr, sdk.NewInt64Coin(helpers.FooDenom, 500), - fmt.Sprintf("--fees=%s", sdk.NewInt64Coin(helpers.FeeDenom, 2)), "-y") + f, cli.KeyFoo, barAddr, sdk.NewInt64Coin(cli.FooDenom, 500), + fmt.Sprintf("--fees=%s", sdk.NewInt64Coin(cli.FeeDenom, 2)), "-y") require.True(t, success) f.Cleanup() diff --git a/x/distribution/client/cli_test/distr_test.go b/x/distribution/client/cli_test/distr_test.go index 035222a1fca9..e3dbc4b516bc 100644 --- a/x/distribution/client/cli_test/distr_test.go +++ b/x/distribution/client/cli_test/distr_test.go @@ -1,13 +1,13 @@ package cli_test import ( + "github.com/cosmos/cosmos-sdk/tests/cli" "path/filepath" "testing" "github.com/stretchr/testify/require" tmtypes "github.com/tendermint/tendermint/types" - "github.com/cosmos/cosmos-sdk/tests/cli/helpers" sdk "github.com/cosmos/cosmos-sdk/types" distrcli "github.com/cosmos/cosmos-sdk/x/distribution/client/cli_test" "github.com/cosmos/cosmos-sdk/x/mint" @@ -15,7 +15,7 @@ import ( func TestCliWithdrawRewards(t *testing.T) { t.Parallel() - f := helpers.InitFixtures(t) + f := cli.InitFixtures(t) genesisState := f.GenesisState() inflationMin := sdk.MustNewDecFromStr("1.0") @@ -38,7 +38,7 @@ func TestCliWithdrawRewards(t *testing.T) { proc := f.SDStart() defer proc.Stop(false) - fooAddr := f.KeyAddress(helpers.KeyFoo) + fooAddr := f.KeyAddress(cli.KeyFoo) rewards := distrcli.QueryRewards(f, fooAddr) require.Equal(t, 1, len(rewards.Rewards)) require.NotNil(t, rewards.Total) diff --git a/x/distribution/client/cli_test/helpers.go b/x/distribution/client/cli_test/helpers.go index cdad1b08be87..63d3a0125abb 100644 --- a/x/distribution/client/cli_test/helpers.go +++ b/x/distribution/client/cli_test/helpers.go @@ -4,19 +4,19 @@ import ( "fmt" clientkeys "github.com/cosmos/cosmos-sdk/client/keys" "github.com/cosmos/cosmos-sdk/tests" - "github.com/cosmos/cosmos-sdk/tests/cli/helpers" + "github.com/cosmos/cosmos-sdk/tests/cli" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/distribution" "github.com/stretchr/testify/require" ) -func TxWithdrawRewards(f *helpers.Fixtures, valAddr sdk.ValAddress, from string, flags ...string) bool { +func TxWithdrawRewards(f *cli.Fixtures, valAddr sdk.ValAddress, from string, flags ...string) bool { cmd := fmt.Sprintf("%s tx distribution withdraw-rewards %s %v --keyring-backend=test --from=%s", f.SimcliBinary, valAddr, f.Flags(), from) - return helpers.ExecuteWrite(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) + return cli.ExecuteWrite(f.T, cli.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } // QueryRewards returns the rewards of a delegator -func QueryRewards(f *helpers.Fixtures, delAddr sdk.AccAddress, flags ...string) distribution.QueryDelegatorTotalRewardsResponse { +func QueryRewards(f *cli.Fixtures, delAddr sdk.AccAddress, flags ...string) distribution.QueryDelegatorTotalRewardsResponse { cmd := fmt.Sprintf("%s query distribution rewards %s %s", f.SimcliBinary, delAddr, f.Flags()) res, errStr := tests.ExecuteT(f.T, cmd, "") require.Empty(f.T, errStr) diff --git a/x/staking/client/cli_test/helpers.go b/x/staking/client/cli_test/helpers.go index 413cc44d8a37..634bd04cfa2a 100644 --- a/x/staking/client/cli_test/helpers.go +++ b/x/staking/client/cli_test/helpers.go @@ -4,33 +4,33 @@ import ( "fmt" clientkeys "github.com/cosmos/cosmos-sdk/client/keys" "github.com/cosmos/cosmos-sdk/tests" - "github.com/cosmos/cosmos-sdk/tests/cli/helpers" + "github.com/cosmos/cosmos-sdk/tests/cli" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/staking" "github.com/stretchr/testify/require" ) // TxStakingCreateValidator is simcli tx staking create-validator -func TxStakingCreateValidator(f *helpers.Fixtures, from, consPubKey string, amount sdk.Coin, flags ...string) (bool, string, string) { +func TxStakingCreateValidator(f *cli.Fixtures, from, consPubKey string, amount sdk.Coin, flags ...string) (bool, string, string) { cmd := fmt.Sprintf("%s tx staking create-validator %v --keyring-backend=test --from=%s"+ " --pubkey=%s", f.SimcliBinary, f.Flags(), from, consPubKey) cmd += fmt.Sprintf(" --amount=%v --moniker=%v --commission-rate=%v", amount, from, "0.05") cmd += fmt.Sprintf(" --commission-max-rate=%v --commission-max-change-rate=%v", "0.20", "0.10") cmd += fmt.Sprintf(" --min-self-delegation=%v", "1") - return helpers.ExecuteWriteRetStdStreams(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) + return cli.ExecuteWriteRetStdStreams(f.T, cli.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } // TxStakingUnbond is simcli tx staking unbond -func TxStakingUnbond(f *helpers.Fixtures, from, shares string, validator sdk.ValAddress, flags ...string) bool { +func TxStakingUnbond(f *cli.Fixtures, from, shares string, validator sdk.ValAddress, flags ...string) bool { cmd := fmt.Sprintf("%s tx staking unbond --keyring-backend=test %s %v --from=%s %v", f.SimcliBinary, validator, shares, from, f.Flags()) - return helpers.ExecuteWrite(f.T, helpers.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) + return cli.ExecuteWrite(f.T, cli.AddFlags(cmd, flags), clientkeys.DefaultKeyPass) } // QueryStakingValidator is simcli query staking validator -func QueryStakingValidator(f *helpers.Fixtures, valAddr sdk.ValAddress, flags ...string) staking.Validator { +func QueryStakingValidator(f *cli.Fixtures, valAddr sdk.ValAddress, flags ...string) staking.Validator { cmd := fmt.Sprintf("%s query staking validator %s %v", f.SimcliBinary, valAddr, f.Flags()) - out, _ := tests.ExecuteT(f.T, helpers.AddFlags(cmd, flags), "") + out, _ := tests.ExecuteT(f.T, cli.AddFlags(cmd, flags), "") var validator staking.Validator err := f.Cdc.UnmarshalJSON([]byte(out), &validator) @@ -39,9 +39,9 @@ func QueryStakingValidator(f *helpers.Fixtures, valAddr sdk.ValAddress, flags .. } // QueryStakingUnbondingDelegationsFrom is simcli query staking unbonding-delegations-from -func QueryStakingUnbondingDelegationsFrom(f *helpers.Fixtures, valAddr sdk.ValAddress, flags ...string) []staking.UnbondingDelegation { +func QueryStakingUnbondingDelegationsFrom(f *cli.Fixtures, valAddr sdk.ValAddress, flags ...string) []staking.UnbondingDelegation { cmd := fmt.Sprintf("%s query staking unbonding-delegations-from %s %v", f.SimcliBinary, valAddr, f.Flags()) - out, _ := tests.ExecuteT(f.T, helpers.AddFlags(cmd, flags), "") + out, _ := tests.ExecuteT(f.T, cli.AddFlags(cmd, flags), "") var ubds []staking.UnbondingDelegation err := f.Cdc.UnmarshalJSON([]byte(out), &ubds) @@ -50,9 +50,9 @@ func QueryStakingUnbondingDelegationsFrom(f *helpers.Fixtures, valAddr sdk.ValAd } // QueryStakingDelegationsTo is simcli query staking delegations-to -func QueryStakingDelegationsTo(f *helpers.Fixtures, valAddr sdk.ValAddress, flags ...string) []staking.Delegation { +func QueryStakingDelegationsTo(f *cli.Fixtures, valAddr sdk.ValAddress, flags ...string) []staking.Delegation { cmd := fmt.Sprintf("%s query staking delegations-to %s %v", f.SimcliBinary, valAddr, f.Flags()) - out, _ := tests.ExecuteT(f.T, helpers.AddFlags(cmd, flags), "") + out, _ := tests.ExecuteT(f.T, cli.AddFlags(cmd, flags), "") var delegations []staking.Delegation err := f.Cdc.UnmarshalJSON([]byte(out), &delegations) @@ -61,9 +61,9 @@ func QueryStakingDelegationsTo(f *helpers.Fixtures, valAddr sdk.ValAddress, flag } // QueryStakingPool is simcli query staking pool -func QueryStakingPool(f *helpers.Fixtures, flags ...string) staking.Pool { +func QueryStakingPool(f *cli.Fixtures, flags ...string) staking.Pool { cmd := fmt.Sprintf("%s query staking pool %v", f.SimcliBinary, f.Flags()) - out, _ := tests.ExecuteT(f.T, helpers.AddFlags(cmd, flags), "") + out, _ := tests.ExecuteT(f.T, cli.AddFlags(cmd, flags), "") var pool staking.Pool err := f.Cdc.UnmarshalJSON([]byte(out), &pool) @@ -72,9 +72,9 @@ func QueryStakingPool(f *helpers.Fixtures, flags ...string) staking.Pool { } // QueryStakingParameters is simcli query staking parameters -func QueryStakingParameters(f *helpers.Fixtures, flags ...string) staking.Params { +func QueryStakingParameters(f *cli.Fixtures, flags ...string) staking.Params { cmd := fmt.Sprintf("%s query staking params %v", f.SimcliBinary, f.Flags()) - out, _ := tests.ExecuteT(f.T, helpers.AddFlags(cmd, flags), "") + out, _ := tests.ExecuteT(f.T, cli.AddFlags(cmd, flags), "") var params staking.Params err := f.Cdc.UnmarshalJSON([]byte(out), ¶ms) diff --git a/x/staking/client/cli_test/staking_test.go b/x/staking/client/cli_test/staking_test.go index de8b9835148a..8c8c5ad6259f 100644 --- a/x/staking/client/cli_test/staking_test.go +++ b/x/staking/client/cli_test/staking_test.go @@ -4,7 +4,7 @@ package cli_test import ( "github.com/cosmos/cosmos-sdk/tests" - "github.com/cosmos/cosmos-sdk/tests/cli/helpers" + "github.com/cosmos/cosmos-sdk/tests/cli" sdk "github.com/cosmos/cosmos-sdk/types" bankcli "github.com/cosmos/cosmos-sdk/x/bank/client/cli_test" stakingcli "github.com/cosmos/cosmos-sdk/x/staking/client/cli_test" @@ -15,44 +15,44 @@ import ( func TestCLICreateValidator(t *testing.T) { t.Parallel() - f := helpers.InitFixtures(t) + f := cli.InitFixtures(t) // start simd server proc := f.SDStart() defer proc.Stop(false) - barAddr := f.KeyAddress(helpers.KeyBar) + barAddr := f.KeyAddress(cli.KeyBar) barVal := sdk.ValAddress(barAddr) consPubKey := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, ed25519.GenPrivKey().PubKey()) sendTokens := sdk.TokensFromConsensusPower(10) - bankcli.TxSend(f, helpers.KeyFoo, barAddr, sdk.NewCoin(helpers.Denom, sendTokens), "-y") + bankcli.TxSend(f, cli.KeyFoo, barAddr, sdk.NewCoin(cli.Denom, sendTokens), "-y") tests.WaitForNextNBlocksTM(1, f.Port) - require.Equal(t, sendTokens, bankcli.QueryBalances(f, barAddr).AmountOf(helpers.Denom)) + require.Equal(t, sendTokens, bankcli.QueryBalances(f, barAddr).AmountOf(cli.Denom)) //Generate a create validator transaction and ensure correctness - success, stdout, stderr := stakingcli.TxStakingCreateValidator(f, barAddr.String(), consPubKey, sdk.NewInt64Coin(helpers.Denom, 2), "--generate-only") + success, stdout, stderr := stakingcli.TxStakingCreateValidator(f, barAddr.String(), consPubKey, sdk.NewInt64Coin(cli.Denom, 2), "--generate-only") require.True(f.T, success) require.Empty(f.T, stderr) - msg := helpers.UnmarshalStdTx(f.T, f.Cdc, stdout) + msg := cli.UnmarshalStdTx(f.T, f.Cdc, stdout) require.NotZero(t, msg.Fee.Gas) require.Equal(t, len(msg.Msgs), 1) require.Equal(t, 0, len(msg.GetSignatures())) // Test --dry-run newValTokens := sdk.TokensFromConsensusPower(2) - success, _, _ = stakingcli.TxStakingCreateValidator(f, barAddr.String(), consPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "--dry-run") + success, _, _ = stakingcli.TxStakingCreateValidator(f, barAddr.String(), consPubKey, sdk.NewCoin(cli.Denom, newValTokens), "--dry-run") require.True(t, success) // Create the validator - stakingcli.TxStakingCreateValidator(f, helpers.KeyBar, consPubKey, sdk.NewCoin(helpers.Denom, newValTokens), "-y") + stakingcli.TxStakingCreateValidator(f, cli.KeyBar, consPubKey, sdk.NewCoin(cli.Denom, newValTokens), "-y") tests.WaitForNextNBlocksTM(1, f.Port) // Ensure funds were deducted properly - require.Equal(t, sendTokens.Sub(newValTokens), bankcli.QueryBalances(f, barAddr).AmountOf(helpers.Denom)) + require.Equal(t, sendTokens.Sub(newValTokens), bankcli.QueryBalances(f, barAddr).AmountOf(cli.Denom)) // Ensure that validator state is as expected validator := stakingcli.QueryStakingValidator(f, barVal) @@ -66,7 +66,7 @@ func TestCLICreateValidator(t *testing.T) { // unbond a single share unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(1)) - success = stakingcli.TxStakingUnbond(f, helpers.KeyBar, unbondAmt.String(), barVal, "-y") + success = stakingcli.TxStakingUnbond(f, cli.KeyBar, unbondAmt.String(), barVal, "-y") require.True(t, success) tests.WaitForNextNBlocksTM(1, f.Port) From 51d7db383def0e5e35f4abfdababd8526e4b4c51 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Thu, 30 Apr 2020 20:00:54 +0530 Subject: [PATCH 48/61] Fixed github test actions --- .github/workflows/test.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 8e59de9ad5e3..9dc7d1aabd05 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -29,7 +29,7 @@ jobs: run: | make build if: "env.GIT_DIFF != ''" - - name: build + - name: build-sim run: | make build-sim - name: test & coverage report creation From dde5ddfe97231ca801bc38f4fe725bd91a493526 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Thu, 30 Apr 2020 23:09:13 +0530 Subject: [PATCH 49/61] Fixed test coverage in actions --- .github/workflows/test.yml | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 9dc7d1aabd05..9563bdef804c 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -29,12 +29,9 @@ jobs: run: | make build if: "env.GIT_DIFF != ''" - - name: build-sim - run: | - make build-sim - name: test & coverage report creation run: | - go test ./... -mod=readonly -timeout 12m -race -coverprofile=coverage.txt -covermode=atomic -tags='ledger test_ledger_mock' + go test ./... -mod=readonly -timeout 12m -race -coverprofile=coverage.txt -covermode=atomic -tags='ledger test_ledger_mock cli_test' if: "env.GIT_DIFF != ''" - name: filter out DONTCOVER run: | From 119a09704630647c3ec6394a82bb7cccb2cfb256 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Thu, 30 Apr 2020 23:41:30 +0530 Subject: [PATCH 50/61] Added build sim to actions --- .github/workflows/test.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 9563bdef804c..92ffad08998e 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -29,6 +29,10 @@ jobs: run: | make build if: "env.GIT_DIFF != ''" + - name: build-sim + run: | + make build-sim + if: "env.GIT_DIFF != ''" - name: test & coverage report creation run: | go test ./... -mod=readonly -timeout 12m -race -coverprofile=coverage.txt -covermode=atomic -tags='ledger test_ledger_mock cli_test' From 97fc16d569523585ab641f3aa30340004b5d1e5f Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Fri, 1 May 2020 20:23:10 +0530 Subject: [PATCH 51/61] Apply Alessio patch for tests --- .github/workflows/test.yml | 2 +- Makefile | 4 ++-- tests/cli/fixtures.go | 17 +++++++++++------ 3 files changed, 14 insertions(+), 9 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 92ffad08998e..47d13ff6fceb 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -35,7 +35,7 @@ jobs: if: "env.GIT_DIFF != ''" - name: test & coverage report creation run: | - go test ./... -mod=readonly -timeout 12m -race -coverprofile=coverage.txt -covermode=atomic -tags='ledger test_ledger_mock cli_test' + go test ./... -mod=readonly -timeout 12m -race -coverprofile=coverage.txt -covermode=atomic -tags='ledger test_ledger_mock cli_test' -builddir='pwd'/build/ if: "env.GIT_DIFF != ''" - name: filter out DONTCOVER run: | diff --git a/Makefile b/Makefile index 0e0876afb757..7bdb9ae0f5ff 100644 --- a/Makefile +++ b/Makefile @@ -169,8 +169,8 @@ test-sim-benchmark-invariants: -Period=1 -Commit=true -Seed=57 -v -timeout 24h cli-test: build-sim - @go test -mod=readonly -p 4 `go list ./tests/cli/...` -tags=cli_test -v - @go test -mod=readonly -p 4 `go list ./x/.../client/cli_test/...` -tags=cli_test -v + go test -mod=readonly -p 4 `go list ./tests/cli/...` -tags=cli_test -v -builddir=$(BUILDDIR) + go test -mod=readonly -p 4 `go list ./x/.../client/cli_test/...` -tags=cli_test -v -builddir=$(BUILDDIR) .PHONY: \ test-sim-nondeterminism \ diff --git a/tests/cli/fixtures.go b/tests/cli/fixtures.go index 5df955a726d1..a672a1356c2b 100644 --- a/tests/cli/fixtures.go +++ b/tests/cli/fixtures.go @@ -1,6 +1,7 @@ package cli import ( + "flag" "io/ioutil" "os" "path/filepath" @@ -16,7 +17,10 @@ import ( "github.com/cosmos/cosmos-sdk/simapp" ) -var cdc = std.MakeCodec(simapp.ModuleBasics) +var ( + cdc = std.MakeCodec(simapp.ModuleBasics) + buildDir = flag.String("builddir", "", "Build directory") +) // Fixtures is used to setup the testing environment type Fixtures struct { @@ -45,15 +49,16 @@ func NewFixtures(t *testing.T) *Fixtures { p2pAddr, _, err := server.FreeTCPAddr() require.NoError(t, err) - buildDir := os.Getenv("BUILDDIR") - require.NotNil(t, buildDir) + if *buildDir == "" { + t.Skip("builddir is empty, skipping") + } return &Fixtures{ T: t, - BuildDir: buildDir, + BuildDir: *buildDir, RootDir: tmpDir, - SimdBinary: filepath.Join(buildDir, "simd"), - SimcliBinary: filepath.Join(buildDir, "simcli"), + SimdBinary: filepath.Join(*buildDir, "simd"), + SimcliBinary: filepath.Join(*buildDir, "simcli"), SimdHome: filepath.Join(tmpDir, ".simd"), SimcliHome: filepath.Join(tmpDir, ".simcli"), RPCAddr: servAddr, From 6ba5c0df2efa1413207f3fa65b5a25c0975b54fe Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Fri, 1 May 2020 20:29:54 +0530 Subject: [PATCH 52/61] Removed unused imports --- tests/cli/fixtures.go | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/cli/fixtures.go b/tests/cli/fixtures.go index a672a1356c2b..4fb8e74f6249 100644 --- a/tests/cli/fixtures.go +++ b/tests/cli/fixtures.go @@ -3,7 +3,6 @@ package cli import ( "flag" "io/ioutil" - "os" "path/filepath" "testing" From c0d95b5239856d43d2c9fd41c2ccacbff13c78f0 Mon Sep 17 00:00:00 2001 From: sahith-narahari Date: Fri, 1 May 2020 20:48:01 +0530 Subject: [PATCH 53/61] Added init for go tests --- tests/cli/fixtures.go | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/tests/cli/fixtures.go b/tests/cli/fixtures.go index 4fb8e74f6249..df7f06e10aaa 100644 --- a/tests/cli/fixtures.go +++ b/tests/cli/fixtures.go @@ -18,9 +18,14 @@ import ( var ( cdc = std.MakeCodec(simapp.ModuleBasics) - buildDir = flag.String("builddir", "", "Build directory") + buildDir *string ) +func init() { + buildDir = flag.String("builddir", "", "Build directory") + +} + // Fixtures is used to setup the testing environment type Fixtures struct { BuildDir string From 018443abeb75ae8f946b717dbcd3812d9449be92 Mon Sep 17 00:00:00 2001 From: Alessio Treglia Date: Fri, 1 May 2020 19:53:00 +0200 Subject: [PATCH 54/61] try fix tests --- Makefile | 5 ++--- tests/cli/fixtures.go | 19 +++++++------------ 2 files changed, 9 insertions(+), 15 deletions(-) diff --git a/Makefile b/Makefile index 4c55ec694971..f36dc4c1e1a0 100644 --- a/Makefile +++ b/Makefile @@ -13,7 +13,6 @@ HTTPS_GIT := https://github.com/cosmos/cosmos-sdk.git DOCKER_BUF := docker run -v $(shell pwd):/workspace --workdir /workspace bufbuild/buf export GO111MODULE = on -export BUILDDIR # The below include contains the tools and runsim targets. include contrib/devtools/Makefile @@ -169,8 +168,8 @@ test-sim-benchmark-invariants: -Period=1 -Commit=true -Seed=57 -v -timeout 24h cli-test: build-sim - go test -mod=readonly -p 4 `go list ./tests/cli/...` -tags=cli_test -v -builddir=$(BUILDDIR) - go test -mod=readonly -p 4 `go list ./x/.../client/cli_test/...` -tags=cli_test -v -builddir=$(BUILDDIR) + BUILDDIR=$(BUILDDIR) go test -mod=readonly -p 4 `go list ./tests/cli/...` -tags=cli_test + BUILDDIR=$(BUILDDIR) go test -mod=readonly -p 4 `go list ./x/.../client/cli_test/...` -tags=cli_test .PHONY: \ test-sim-nondeterminism \ diff --git a/tests/cli/fixtures.go b/tests/cli/fixtures.go index df7f06e10aaa..564514ddc114 100644 --- a/tests/cli/fixtures.go +++ b/tests/cli/fixtures.go @@ -1,8 +1,8 @@ package cli import ( - "flag" "io/ioutil" + "os" "path/filepath" "testing" @@ -17,15 +17,9 @@ import ( ) var ( - cdc = std.MakeCodec(simapp.ModuleBasics) - buildDir *string + cdc = std.MakeCodec(simapp.ModuleBasics) ) -func init() { - buildDir = flag.String("builddir", "", "Build directory") - -} - // Fixtures is used to setup the testing environment type Fixtures struct { BuildDir string @@ -53,16 +47,17 @@ func NewFixtures(t *testing.T) *Fixtures { p2pAddr, _, err := server.FreeTCPAddr() require.NoError(t, err) - if *buildDir == "" { + buildDir := os.Getenv("BUILDDIR") + if buildDir == "" { t.Skip("builddir is empty, skipping") } return &Fixtures{ T: t, - BuildDir: *buildDir, + BuildDir: buildDir, RootDir: tmpDir, - SimdBinary: filepath.Join(*buildDir, "simd"), - SimcliBinary: filepath.Join(*buildDir, "simcli"), + SimdBinary: filepath.Join(buildDir, "simd"), + SimcliBinary: filepath.Join(buildDir, "simcli"), SimdHome: filepath.Join(tmpDir, ".simd"), SimcliHome: filepath.Join(tmpDir, ".simcli"), RPCAddr: servAddr, From e01930188614760ddb1aff488f4d44a404501cd3 Mon Sep 17 00:00:00 2001 From: Alessio Treglia Date: Fri, 1 May 2020 20:08:36 +0200 Subject: [PATCH 55/61] goimports what wasn't goimports'd --- x/distribution/client/cli_test/helpers.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/x/distribution/client/cli_test/helpers.go b/x/distribution/client/cli_test/helpers.go index 63d3a0125abb..5322165f4c1c 100644 --- a/x/distribution/client/cli_test/helpers.go +++ b/x/distribution/client/cli_test/helpers.go @@ -2,12 +2,14 @@ package cli import ( "fmt" + + "github.com/stretchr/testify/require" + clientkeys "github.com/cosmos/cosmos-sdk/client/keys" "github.com/cosmos/cosmos-sdk/tests" "github.com/cosmos/cosmos-sdk/tests/cli" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/distribution" - "github.com/stretchr/testify/require" ) func TxWithdrawRewards(f *cli.Fixtures, valAddr sdk.ValAddress, from string, flags ...string) bool { From 9815dc3dd5722cf3992bd7d3cfd03f480bce40fd Mon Sep 17 00:00:00 2001 From: Alessio Treglia Date: Fri, 1 May 2020 20:11:32 +0200 Subject: [PATCH 56/61] try fix ci --- .github/workflows/test.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 47d13ff6fceb..c5aefcc8c6a9 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -35,7 +35,7 @@ jobs: if: "env.GIT_DIFF != ''" - name: test & coverage report creation run: | - go test ./... -mod=readonly -timeout 12m -race -coverprofile=coverage.txt -covermode=atomic -tags='ledger test_ledger_mock cli_test' -builddir='pwd'/build/ + BUILDDIR=`pwd`/build go test ./... -mod=readonly -timeout 12m -race -coverprofile=coverage.txt -covermode=atomic -tags='ledger test_ledger_mock cli_test' if: "env.GIT_DIFF != ''" - name: filter out DONTCOVER run: | @@ -59,4 +59,4 @@ jobs: - uses: actions/checkout@v2 - name: cli-test run: | - make cli-test \ No newline at end of file + make cli-test From ae6b442d8fdf8590167069b9230dbc57851c4220 Mon Sep 17 00:00:00 2001 From: Alessio Treglia Date: Fri, 1 May 2020 20:35:40 +0200 Subject: [PATCH 57/61] add relevant tags to integration tests --- Makefile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Makefile b/Makefile index f36dc4c1e1a0..ef554852fabd 100644 --- a/Makefile +++ b/Makefile @@ -168,8 +168,8 @@ test-sim-benchmark-invariants: -Period=1 -Commit=true -Seed=57 -v -timeout 24h cli-test: build-sim - BUILDDIR=$(BUILDDIR) go test -mod=readonly -p 4 `go list ./tests/cli/...` -tags=cli_test - BUILDDIR=$(BUILDDIR) go test -mod=readonly -p 4 `go list ./x/.../client/cli_test/...` -tags=cli_test + BUILDDIR=$(BUILDDIR) go test -mod=readonly -p 4 `go list ./tests/cli/...` -tags=-tags='ledger test_ledger_mock cli_test' + BUILDDIR=$(BUILDDIR) go test -mod=readonly -p 4 `go list ./x/.../client/cli_test/...` -tags=-tags='ledger test_ledger_mock cli_test' .PHONY: \ test-sim-nondeterminism \ From 2076931adcf83c74ddf6912b9d3b6a438747de72 Mon Sep 17 00:00:00 2001 From: Alessio Treglia Date: Fri, 1 May 2020 20:37:35 +0200 Subject: [PATCH 58/61] run integration tests separately --- .github/workflows/test.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index c5aefcc8c6a9..21b3b3fff921 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -29,13 +29,9 @@ jobs: run: | make build if: "env.GIT_DIFF != ''" - - name: build-sim - run: | - make build-sim - if: "env.GIT_DIFF != ''" - name: test & coverage report creation run: | - BUILDDIR=`pwd`/build go test ./... -mod=readonly -timeout 12m -race -coverprofile=coverage.txt -covermode=atomic -tags='ledger test_ledger_mock cli_test' + go test ./... -mod=readonly -timeout 12m -race -coverprofile=coverage.txt -covermode=atomic -tags='ledger test_ledger_mock' if: "env.GIT_DIFF != ''" - name: filter out DONTCOVER run: | @@ -57,6 +53,10 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 + - name: build-sim + run: | + make build-sim + if: "env.GIT_DIFF != ''" - name: cli-test run: | make cli-test From 99a454e6bb0e68abcf8cabeae1f2a52542d29671 Mon Sep 17 00:00:00 2001 From: Alessio Treglia Date: Fri, 1 May 2020 20:43:43 +0200 Subject: [PATCH 59/61] use go build -o flag and let compiler gemerate the binary with the right extension for the HOST platform rename cli-test to test-integration --- Makefile | 20 ++++++++------------ 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/Makefile b/Makefile index ef554852fabd..dae876965a3a 100644 --- a/Makefile +++ b/Makefile @@ -27,13 +27,9 @@ build: go.sum @go build -mod=readonly ./... build-sim: go.sum -ifeq ($(OS),Windows_NT) - go build -mod=readonly $(BUILD_FLAGS) -o build/simd.exe ./simapp/cmd/simd - go build -mod=readonly $(BUILD_FLAGS) -o build/simcli.exe ./simapp/cmd/simcli -else - go build -mod=readonly $(BUILD_FLAGS) -o build/simd ./simapp/cmd/simd - go build -mod=readonly $(BUILD_FLAGS) -o build/simcli ./simapp/cmd/simcli -endif + mkdir -p $(BUILDDIR) + go build -mod=readonly $(BUILD_FLAGS) -o $(BUILDDIR) ./simapp/cmd/simd + go build -mod=readonly $(BUILD_FLAGS) -o $(BUILDDIR) ./simapp/cmd/simcli .PHONY: \ build \ @@ -127,6 +123,10 @@ test-unit: test-race: @VERSION=$(VERSION) go test -mod=readonly -race $(PACKAGES_NOSIMULATION) +test-integration: build-sim + BUILDDIR=$(BUILDDIR) go test -mod=readonly -p 4 `go list ./tests/cli/...` -tags=-tags='ledger test_ledger_mock cli_test' + BUILDDIR=$(BUILDDIR) go test -mod=readonly -p 4 `go list ./x/.../client/cli_test/...` -tags=-tags='ledger test_ledger_mock cli_test' + .PHONY: test test-all test-ledger-mock test-ledger test-unit test-race test-sim-nondeterminism: @@ -167,10 +167,6 @@ test-sim-benchmark-invariants: -Enabled=true -NumBlocks=1000 -BlockSize=200 \ -Period=1 -Commit=true -Seed=57 -v -timeout 24h -cli-test: build-sim - BUILDDIR=$(BUILDDIR) go test -mod=readonly -p 4 `go list ./tests/cli/...` -tags=-tags='ledger test_ledger_mock cli_test' - BUILDDIR=$(BUILDDIR) go test -mod=readonly -p 4 `go list ./x/.../client/cli_test/...` -tags=-tags='ledger test_ledger_mock cli_test' - .PHONY: \ test-sim-nondeterminism \ test-sim-custom-genesis-fast \ @@ -180,7 +176,7 @@ test-sim-custom-genesis-multi-seed \ test-sim-multi-seed-short \ test-sim-multi-seed-long \ test-sim-benchmark-invariants \ -cli-test +test-integration SIM_NUM_BLOCKS ?= 500 SIM_BLOCK_SIZE ?= 200 From 3774f86131b32b93d6a8530ecf41d18ee238a081 Mon Sep 17 00:00:00 2001 From: Alessio Treglia Date: Fri, 1 May 2020 20:44:56 +0200 Subject: [PATCH 60/61] update ci --- .github/workflows/test.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 21b3b3fff921..a4d62b72eadf 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -59,4 +59,4 @@ jobs: if: "env.GIT_DIFF != ''" - name: cli-test run: | - make cli-test + make test-integration From 1671cbde601bdbd1ceb92b4e01bf258a2e51c7b9 Mon Sep 17 00:00:00 2001 From: Alessio Treglia Date: Fri, 1 May 2020 21:01:25 +0200 Subject: [PATCH 61/61] rename --- .github/workflows/test.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index a4d62b72eadf..1d56cc8ea976 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -49,7 +49,7 @@ jobs: file: ./coverage.txt # optional fail_ci_if_error: true if: "env.GIT_DIFF != ''" - cli-test: + integration-tests: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2