smeb_y/0g-chain
1
0
Fork 0
mirror of https://github.com/0glabs/0g-chain.git synced 2024-12-25 15:55:18 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

rename

Browse Source
This commit is contained in:
Federico Kunze 2020-04-28 10:10:02 -04:00
parent 1cd1b1e259
commit e33898cc1a
No known key found for this signature in database
GPG Key ID: 655F93A970080A30
2 changed files with 142 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
cli_test/cli_test.go
View File

@ -99,7 +99,7 @@ func TestKavaCLIMinimumFees(t *testing.T) {
t.Parallel()
f := InitFixtures(t)
// start kavad server with minimum fees
// start kvd server with minimum fees
minGasPrice, _ := sdk.NewDecFromStr("0.000006")
fees := fmt.Sprintf(
"--minimum-gas-prices=%s,%s",
@ -137,7 +137,7 @@ func TestKavaCLIGasPrices(t *testing.T) {
t.Parallel()
f := InitFixtures(t)
// start kavad server with minimum fees
// start kvd server with minimum fees
minGasPrice, _ := sdk.NewDecFromStr("0.000006")
proc := f.GDStart(fmt.Sprintf("--minimum-gas-prices=%s", sdk.NewDecCoinFromDec(feeDenom, minGasPrice)))
defer proc.Stop(false)
@ -171,7 +171,7 @@ func TestKavaCLIFeesDeduction(t *testing.T) {
t.Parallel()
f := InitFixtures(t)
// start kavad server with minimum fees
// start kvd server with minimum fees
minGasPrice, _ := sdk.NewDecFromStr("0.000006")
proc := f.GDStart(fmt.Sprintf("--minimum-gas-prices=%s", sdk.NewDecCoinFromDec(feeDenom, minGasPrice)))
defer proc.Stop(false)
@ -224,7 +224,7 @@ func TestKavaCLISend(t *testing.T) {
t.Parallel()
f := InitFixtures(t)
// start kavad server
// start kvd server
proc := f.GDStart()
defer proc.Stop(false)
@ -294,7 +294,7 @@ func TestKavaCLIConfirmTx(t *testing.T) {
t.Parallel()
f := InitFixtures(t)
// start kavad server
// start kvd server
proc := f.GDStart()
defer proc.Stop(false)
@ -330,7 +330,7 @@ func TestKavaCLIGasAuto(t *testing.T) {
t.Parallel()
f := InitFixtures(t)
// start kavad server
// start kvd server
proc := f.GDStart()
defer proc.Stop(false)
@ -390,7 +390,7 @@ func TestKavaCLICreateValidator(t *testing.T) {
t.Parallel()
f := InitFixtures(t)
// start kavad server
// start kvd server
proc := f.GDStart()
defer proc.Stop(false)
@ -477,13 +477,13 @@ func TestKavaCLIQueryRewards(t *testing.T) {
require.NoError(t, err)
genesisState[mint.ModuleName] = mintDataBz
genFile := filepath.Join(f.KavadHome, "config", "genesis.json")
genFile := filepath.Join(f.KvdHome, "config", "genesis.json")
genDoc, err := tmtypes.GenesisDocFromFile(genFile)
require.NoError(t, err)
genDoc.AppState, err = cdc.MarshalJSON(genesisState)
require.NoError(t, genDoc.SaveAs(genFile))
// start kavad server
// start kvd server
proc := f.GDStart()
defer proc.Stop(false)
@ -498,7 +498,7 @@ func TestKavaCLIQuerySupply(t *testing.T) {
t.Parallel()
f := InitFixtures(t)
// start kavad server
// start kvd server
proc := f.GDStart()
defer proc.Stop(false)
@ -515,7 +515,7 @@ func TestKavaCLISubmitProposal(t *testing.T) {
t.Parallel()
f := InitFixtures(t)
// start kavad server
// start kvd server
proc := f.GDStart()
defer proc.Stop(false)
@ -736,7 +736,7 @@ func TestKavaCLISubmitCommunityPoolSpendProposal(t *testing.T) {
require.NoError(t, err)
genesisState[mint.ModuleName] = mintDataBz
genFile := filepath.Join(f.KavadHome, "config", "genesis.json")
genFile := filepath.Join(f.KvdHome, "config", "genesis.json")
genDoc, err := tmtypes.GenesisDocFromFile(genFile)
require.NoError(t, err)
genDoc.AppState, err = cdc.MarshalJSON(genesisState)
@ -807,7 +807,7 @@ func TestKavaCLIQueryTxPagination(t *testing.T) {
t.Parallel()
f := InitFixtures(t)
// start kavad server
// start kvd server
proc := f.GDStart()
defer proc.Stop(false)
@ -857,7 +857,7 @@ func TestKavaCLIValidateSignatures(t *testing.T) {
t.Parallel()
f := InitFixtures(t)
// start kavad server
// start kvd server
proc := f.GDStart()
defer proc.Stop(false)
@ -907,7 +907,7 @@ func TestKavaCLISendGenerateSignAndBroadcast(t *testing.T) {
t.Parallel()
f := InitFixtures(t)
// start kavad server
// start kvd server
proc := f.GDStart()
defer proc.Stop(false)
@ -991,7 +991,7 @@ func TestKavaCLIMultisignInsufficientCosigners(t *testing.T) {
t.Parallel()
f := InitFixtures(t)
// start kavad server with minimum fees
// start kvd server with minimum fees
proc := f.GDStart()
defer proc.Stop(false)
@ -1044,7 +1044,7 @@ func TestKavaCLIEncode(t *testing.T) {
t.Parallel()
f := InitFixtures(t)
// start kavad server
// start kvd server
proc := f.GDStart()
defer proc.Stop(false)
@ -1082,7 +1082,7 @@ func TestKavaCLIMultisignSortSignatures(t *testing.T) {
t.Parallel()
f := InitFixtures(t)
// start kavad server with minimum fees
// start kvd server with minimum fees
proc := f.GDStart()
defer proc.Stop(false)
@ -1147,7 +1147,7 @@ func TestKavaCLIMultisign(t *testing.T) {
t.Parallel()
f := InitFixtures(t)
// start kavad server with minimum fees
// start kvd server with minimum fees
proc := f.GDStart()
defer proc.Stop(false)
@ -1223,7 +1223,7 @@ func TestKavaCLIConfig(t *testing.T) {
f.CLIConfig("trace", "false")
f.CLIConfig("indent", "true")
config, err := ioutil.ReadFile(path.Join(f.KavacliHome, "config", "config.toml"))
config, err := ioutil.ReadFile(path.Join(f.KvcliHome, "config", "config.toml"))
require.NoError(t, err)
expectedConfig := fmt.Sprintf(`broadcast-mode = "block"
chain-id = "%s"
@ -1335,7 +1335,7 @@ func TestSlashingGetParams(t *testing.T) {
t.Parallel()
f := InitFixtures(t)
// start kavad server
// start kvd server
proc := f.GDStart()
defer proc.Stop(false)
@ -1355,7 +1355,7 @@ func TestValidateGenesis(t *testing.T) {
t.Parallel()
f := InitFixtures(t)
// start kavad server
// start kvd server
proc := f.GDStart()
defer proc.Stop(false)

212
cli_test/test_helpers.go
View File

@ -76,13 +76,13 @@ func init() {
type Fixtures struct {
BuildDir string
RootDir string
KavadBinary string
KavacliBinary string
KvdBinary string
KvcliBinary string
ChainID string
RPCAddr string
Port string
KavadHome string
KavacliHome string
KvdHome string
KvcliHome string
P2PAddr string
T *testing.T
@ -112,10 +112,10 @@ func NewFixtures(t *testing.T) *Fixtures {
T: t,
BuildDir: buildDir,
RootDir: tmpDir,
KavadBinary: filepath.Join(buildDir, "kvd"),
KavacliBinary: filepath.Join(buildDir, "kvcli"),
KavadHome: filepath.Join(tmpDir, ".kvd"),
KavacliHome: filepath.Join(tmpDir, ".kvcli"),
KvdBinary: filepath.Join(buildDir, "kvd"),
KvcliBinary: filepath.Join(buildDir, "kvcli"),
KvdHome: filepath.Join(tmpDir, ".kvd"),
KvcliHome: filepath.Join(tmpDir, ".kvcli"),
RPCAddr: servAddr,
P2PAddr: p2pAddr,
Port: port,
@ -125,7 +125,7 @@ func NewFixtures(t *testing.T) *Fixtures {
// GenesisFile returns the path of the genesis file
func (f Fixtures) GenesisFile() string {
return filepath.Join(f.KavadHome, "config", "genesis.json")
return filepath.Join(f.KvdHome, "config", "genesis.json")
}
// GenesisState returns the application's genesis state
@ -194,7 +194,7 @@ func (f *Fixtures) Cleanup(dirs ...string) {
// Flags returns the flags necessary for making most CLI calls
func (f *Fixtures) Flags() string {
return fmt.Sprintf("--home=%s --node=%s", f.KavacliHome, f.RPCAddr)
return fmt.Sprintf("--home=%s --node=%s", f.KvcliHome, f.RPCAddr)
}
//___________________________________________________________________________________
@ -202,16 +202,16 @@ func (f *Fixtures) Flags() string {
// UnsafeResetAll is kavad unsafe-reset-all
func (f *Fixtures) UnsafeResetAll(flags ...string) {
cmd := fmt.Sprintf("%s --home=%s unsafe-reset-all", f.KavadBinary, f.KavadHome)
cmd := fmt.Sprintf("%s --home=%s unsafe-reset-all", f.KvdBinary, f.KvdHome)
executeWrite(f.T, addFlags(cmd, flags))
err := os.RemoveAll(filepath.Join(f.KavadHome, "config", "gentx"))
err := os.RemoveAll(filepath.Join(f.KvdHome, "config", "gentx"))
require.NoError(f.T, err)
}
// GDInit is kavad 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.KavadBinary, f.KavadHome, moniker)
cmd := fmt.Sprintf("%s init -o --home=%s %s", f.KvdBinary, f.KvdHome, moniker)
_, stderr := tests.ExecuteT(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass)
var chainID string
@ -228,25 +228,25 @@ func (f *Fixtures) GDInit(moniker string, flags ...string) {
// AddGenesisAccount is kavad 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.KavadBinary, address, coins, f.KavadHome)
cmd := fmt.Sprintf("%s add-genesis-account %s %s --home=%s --keyring-backend=test", f.KvdBinary, address, coins, f.KvdHome)
executeWriteCheckErr(f.T, addFlags(cmd, flags))
}
// GenTx is kavad 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.KavadBinary, name, f.KavadHome, f.KavacliHome)
cmd := fmt.Sprintf("%s gentx --name=%s --home=%s --home-client=%s --keyring-backend=test", f.KvdBinary, name, f.KvdHome, f.KvcliHome)
executeWriteCheckErr(f.T, addFlags(cmd, flags))
}
// CollectGenTxs is kavad collect-gentxs
func (f *Fixtures) CollectGenTxs(flags ...string) {
cmd := fmt.Sprintf("%s collect-gentxs --home=%s", f.KavadBinary, f.KavadHome)
cmd := fmt.Sprintf("%s collect-gentxs --home=%s", f.KvdBinary, f.KvdHome)
executeWriteCheckErr(f.T, addFlags(cmd, flags))
}
// GDStart runs kavad 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.KavadBinary, f.KavadHome, f.RPCAddr, f.P2PAddr)
cmd := fmt.Sprintf("%s start --home=%s --rpc.laddr=%v --p2p.laddr=%v", f.KvdBinary, f.KvdHome, f.RPCAddr, f.P2PAddr)
proc := tests.GoExecuteTWithStdout(f.T, addFlags(cmd, flags))
tests.WaitForTMStart(f.Port)
tests.WaitForNextNBlocksTM(1, f.Port)
@ -255,7 +255,7 @@ func (f *Fixtures) GDStart(flags ...string) *tests.Process {
// GDTendermint returns the results of kavad tendermint [query]
func (f *Fixtures) GDTendermint(query string) string {
cmd := fmt.Sprintf("%s tendermint %s --home=%s", f.KavadBinary, query, f.KavadHome)
cmd := fmt.Sprintf("%s tendermint %s --home=%s", f.KvdBinary, query, f.KvdHome)
success, stdout, stderr := executeWriteRetStdStreams(f.T, cmd)
require.Empty(f.T, stderr)
require.True(f.T, success)
@ -264,45 +264,45 @@ func (f *Fixtures) GDTendermint(query string) string {
// ValidateGenesis runs kavad validate-genesis
func (f *Fixtures) ValidateGenesis() {
cmd := fmt.Sprintf("%s validate-genesis --home=%s", f.KavadBinary, f.KavadHome)
cmd := fmt.Sprintf("%s validate-genesis --home=%s", f.KvdBinary, f.KvdHome)
executeWriteCheckErr(f.T, cmd)
}
//___________________________________________________________________________________
// kavacli keys
// kvcli keys
// KeysDelete is kavacli keys delete
// KeysDelete is kvcli keys delete
func (f *Fixtures) KeysDelete(name string, flags ...string) {
cmd := fmt.Sprintf("%s keys delete --keyring-backend=test --home=%s %s", f.KavacliBinary,
f.KavacliHome, name)
cmd := fmt.Sprintf("%s keys delete --keyring-backend=test --home=%s %s", f.KvcliBinary,
f.KvcliHome, name)
executeWrite(f.T, addFlags(cmd, append(append(flags, "-y"), "-f")))
}
// KeysAdd is kavacli keys add
// KeysAdd is kvcli keys add
func (f *Fixtures) KeysAdd(name string, flags ...string) {
cmd := fmt.Sprintf("%s keys add --keyring-backend=test --home=%s %s", f.KavacliBinary,
f.KavacliHome, name)
cmd := fmt.Sprintf("%s keys add --keyring-backend=test --home=%s %s", f.KvcliBinary,
f.KvcliHome, name)
executeWriteCheckErr(f.T, addFlags(cmd, flags))
}
// KeysAddRecover prepares kavacli keys add --recover
// KeysAddRecover prepares kvcli 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.KavacliBinary, f.KavacliHome, name)
f.KvcliBinary, f.KvcliHome, name)
return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), mnemonic)
}
// KeysAddRecoverHDPath prepares kavacli keys add --recover --account --index
// KeysAddRecoverHDPath prepares kvcli 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.KavacliBinary, f.KavacliHome, name, account, index)
" --index %d", f.KvcliBinary, f.KvcliHome, name, account, index)
executeWriteCheckErr(f.T, addFlags(cmd, flags), mnemonic)
}
// KeysShow is kavacli keys show
// KeysShow is kvcli keys show
func (f *Fixtures) KeysShow(name string, flags ...string) keys.KeyOutput {
cmd := fmt.Sprintf("%s keys show --keyring-backend=test --home=%s %s", f.KavacliBinary,
f.KavacliHome, name)
cmd := fmt.Sprintf("%s keys show --keyring-backend=test --home=%s %s", f.KvcliBinary,
f.KvcliHome, name)
out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
var ko keys.KeyOutput
err := clientkeys.UnmarshalJSON([]byte(out), &ko)
@ -319,101 +319,101 @@ func (f *Fixtures) KeyAddress(name string) sdk.AccAddress {
}
//___________________________________________________________________________________
// kavacli config
// kvcli config
// CLIConfig is kavacli config
// CLIConfig is kvcli config
func (f *Fixtures) CLIConfig(key, value string, flags ...string) {
cmd := fmt.Sprintf("%s config --home=%s %s %s", f.KavacliBinary, f.KavacliHome, key, value)
cmd := fmt.Sprintf("%s config --home=%s %s %s", f.KvcliBinary, f.KvcliHome, key, value)
executeWriteCheckErr(f.T, addFlags(cmd, flags))
}
//___________________________________________________________________________________
// kavacli tx send/sign/broadcast
// kvcli tx send/sign/broadcast
// Status is kavacli status
// Status is kvcli status
func (f *Fixtures) Status(flags ...string) (bool, string, string) {
cmd := fmt.Sprintf("%s status %s", f.KavacliBinary, f.Flags())
cmd := fmt.Sprintf("%s status %s", f.KvcliBinary, f.Flags())
return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass)
}
// TxSend is kavacli tx send
// TxSend is kvcli 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.KavacliBinary, from,
cmd := fmt.Sprintf("%s tx send --keyring-backend=test %s %s %s %v", f.KvcliBinary, from,
to, amount, f.Flags())
return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass)
}
// TxSign is kavacli tx sign
// TxSign is kvcli 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.KavacliBinary,
cmd := fmt.Sprintf("%s tx sign %v --keyring-backend=test --from=%s %v", f.KvcliBinary,
f.Flags(), signer, fileName)
return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass)
}
// TxBroadcast is kavacli tx broadcast
// TxBroadcast is kvcli tx broadcast
func (f *Fixtures) TxBroadcast(fileName string, flags ...string) (bool, string, string) {
cmd := fmt.Sprintf("%s tx broadcast %v %v", f.KavacliBinary, f.Flags(), fileName)
cmd := fmt.Sprintf("%s tx broadcast %v %v", f.KvcliBinary, f.Flags(), fileName)
return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass)
}
// TxEncode is kavacli tx encode
// TxEncode is kvcli tx encode
func (f *Fixtures) TxEncode(fileName string, flags ...string) (bool, string, string) {
cmd := fmt.Sprintf("%s tx encode %v %v", f.KavacliBinary, f.Flags(), fileName)
cmd := fmt.Sprintf("%s tx encode %v %v", f.KvcliBinary, f.Flags(), fileName)
return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass)
}
// TxMultisign is kavacli tx multisign
// TxMultisign is kvcli 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.KavacliBinary, f.Flags(),
cmd := fmt.Sprintf("%s tx multisign --keyring-backend=test %v %s %s %s", f.KvcliBinary, f.Flags(),
fileName, name, strings.Join(signaturesFiles, " "),
)
return executeWriteRetStdStreams(f.T, addFlags(cmd, flags))
}
//___________________________________________________________________________________
// kavacli tx staking
// kvcli tx staking
// TxStakingCreateValidator is kavacli tx staking create-validator
// TxStakingCreateValidator is kvcli 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.KavacliBinary, f.Flags(), from, consPubKey)
" --pubkey=%s", f.KvcliBinary, 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 kavacli tx staking unbond
// TxStakingUnbond is kvcli 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.KavacliBinary, validator, shares, from, f.Flags())
f.KvcliBinary, validator, shares, from, f.Flags())
return executeWrite(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass)
}
//___________________________________________________________________________________
// kavacli tx gov
// kvcli tx gov
// TxGovSubmitProposal is kavacli tx gov submit-proposal
// TxGovSubmitProposal is kvcli tx gov submit-proposal
func (f *Fixtures) TxGovSubmitProposal(from, typ, title, description string, deposit sdk.Coin, flags ...string) (bool, string, string) {
cmd := fmt.Sprintf("%s tx gov submit-proposal %v --keyring-backend=test --from=%s --type=%s",
f.KavacliBinary, f.Flags(), from, typ)
f.KvcliBinary, f.Flags(), from, typ)
cmd += fmt.Sprintf(" --title=%s --description=%s --deposit=%s", title, description, deposit)
return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass)
}
// TxGovDeposit is kavacli tx gov deposit
// TxGovDeposit is kvcli tx gov deposit
func (f *Fixtures) TxGovDeposit(proposalID int, from string, amount sdk.Coin, flags ...string) (bool, string, string) {
cmd := fmt.Sprintf("%s tx gov deposit %d %s --keyring-backend=test --from=%s %v",
f.KavacliBinary, proposalID, amount, from, f.Flags())
f.KvcliBinary, proposalID, amount, from, f.Flags())
return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass)
}
// TxGovVote is kavacli tx gov vote
// TxGovVote is kvcli tx gov vote
func (f *Fixtures) TxGovVote(proposalID int, option gov.VoteOption, from string, flags ...string) (bool, string, string) {
cmd := fmt.Sprintf("%s tx gov vote %d %s --keyring-backend=test --from=%s %v",
f.KavacliBinary, proposalID, option, from, f.Flags())
f.KvcliBinary, proposalID, option, from, f.Flags())
return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass)
}
@ -425,7 +425,7 @@ func (f *Fixtures) TxGovSubmitParamChangeProposal(
cmd := fmt.Sprintf(
"%s tx gov submit-proposal param-change %s --keyring-backend=test --from=%s %v",
f.KavacliBinary, proposalPath, from, f.Flags(),
f.KvcliBinary, proposalPath, from, f.Flags(),
)
return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass)
@ -439,18 +439,18 @@ func (f *Fixtures) TxGovSubmitCommunityPoolSpendProposal(
cmd := fmt.Sprintf(
"%s tx gov submit-proposal community-pool-spend %s --keyring-backend=test --from=%s %v",
f.KavacliBinary, proposalPath, from, f.Flags(),
f.KvcliBinary, proposalPath, from, f.Flags(),
)
return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), clientkeys.DefaultKeyPass)
}
//___________________________________________________________________________________
// kavacli query account
// kvcli query account
// QueryAccount is kavacli query account
// QueryAccount is kvcli query account
func (f *Fixtures) QueryAccount(address sdk.AccAddress, flags ...string) auth.BaseAccount {
cmd := fmt.Sprintf("%s query account %s %v", f.KavacliBinary, address, f.Flags())
cmd := fmt.Sprintf("%s query account %s %v", f.KvcliBinary, address, f.Flags())
out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
var initRes map[string]json.RawMessage
err := json.Unmarshal([]byte(out), &initRes)
@ -465,11 +465,11 @@ func (f *Fixtures) QueryAccount(address sdk.AccAddress, flags ...string) auth.Ba
}
//___________________________________________________________________________________
// kavacli query txs
// kvcli query txs
// QueryTxs is kavacli query txs
// QueryTxs is kvcli query txs
func (f *Fixtures) QueryTxs(page, limit int, events ...string) *sdk.SearchTxsResult {
cmd := fmt.Sprintf("%s query txs --page=%d --limit=%d --events='%s' %v", f.KavacliBinary, page, limit, queryEvents(events), f.Flags())
cmd := fmt.Sprintf("%s query txs --page=%d --limit=%d --events='%s' %v", f.KvcliBinary, page, limit, queryEvents(events), f.Flags())
out, _ := tests.ExecuteT(f.T, cmd, "")
var result sdk.SearchTxsResult
@ -480,17 +480,17 @@ func (f *Fixtures) QueryTxs(page, limit int, events ...string) *sdk.SearchTxsRes
// QueryTxsInvalid query txs with wrong parameters and compare expected error
func (f *Fixtures) QueryTxsInvalid(expectedErr error, page, limit int, events ...string) {
cmd := fmt.Sprintf("%s query txs --page=%d --limit=%d --events='%s' %v", f.KavacliBinary, page, limit, queryEvents(events), f.Flags())
cmd := fmt.Sprintf("%s query txs --page=%d --limit=%d --events='%s' %v", f.KvcliBinary, page, limit, queryEvents(events), f.Flags())
_, err := tests.ExecuteT(f.T, cmd, "")
require.EqualError(f.T, expectedErr, err)
}
//___________________________________________________________________________________
// kavacli query staking
// kvcli query staking
// QueryStakingValidator is kavacli query staking validator
// QueryStakingValidator is kvcli query staking validator
func (f *Fixtures) QueryStakingValidator(valAddr sdk.ValAddress, flags ...string) staking.Validator {
cmd := fmt.Sprintf("%s query staking validator %s %v", f.KavacliBinary, valAddr, f.Flags())
cmd := fmt.Sprintf("%s query staking validator %s %v", f.KvcliBinary, valAddr, f.Flags())
out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
var validator staking.Validator
@ -499,9 +499,9 @@ func (f *Fixtures) QueryStakingValidator(valAddr sdk.ValAddress, flags ...string
return validator
}
// QueryStakingUnbondingDelegationsFrom is kavacli query staking unbonding-delegations-from
// QueryStakingUnbondingDelegationsFrom is kvcli 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.KavacliBinary, valAddr, f.Flags())
cmd := fmt.Sprintf("%s query staking unbonding-delegations-from %s %v", f.KvcliBinary, valAddr, f.Flags())
out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
var ubds []staking.UnbondingDelegation
@ -510,9 +510,9 @@ func (f *Fixtures) QueryStakingUnbondingDelegationsFrom(valAddr sdk.ValAddress,
return ubds
}
// QueryStakingDelegationsTo is kavacli query staking delegations-to
// QueryStakingDelegationsTo is kvcli 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.KavacliBinary, valAddr, f.Flags())
cmd := fmt.Sprintf("%s query staking delegations-to %s %v", f.KvcliBinary, valAddr, f.Flags())
out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
var delegations []staking.Delegation
@ -521,9 +521,9 @@ func (f *Fixtures) QueryStakingDelegationsTo(valAddr sdk.ValAddress, flags ...st
return delegations
}
// QueryStakingPool is kavacli query staking pool
// QueryStakingPool is kvcli query staking pool
func (f *Fixtures) QueryStakingPool(flags ...string) staking.Pool {
cmd := fmt.Sprintf("%s query staking pool %v", f.KavacliBinary, f.Flags())
cmd := fmt.Sprintf("%s query staking pool %v", f.KvcliBinary, f.Flags())
out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
var pool staking.Pool
@ -532,9 +532,9 @@ func (f *Fixtures) QueryStakingPool(flags ...string) staking.Pool {
return pool
}
// QueryStakingParameters is kavacli query staking parameters
// QueryStakingParameters is kvcli query staking parameters
func (f *Fixtures) QueryStakingParameters(flags ...string) staking.Params {
cmd := fmt.Sprintf("%s query staking params %v", f.KavacliBinary, f.Flags())
cmd := fmt.Sprintf("%s query staking params %v", f.KvcliBinary, f.Flags())
out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
var params staking.Params
@ -544,11 +544,11 @@ func (f *Fixtures) QueryStakingParameters(flags ...string) staking.Params {
}
//___________________________________________________________________________________
// kavacli query gov
// kvcli query gov
// QueryGovParamDeposit is kavacli query gov param deposit
// QueryGovParamDeposit is kvcli query gov param deposit
func (f *Fixtures) QueryGovParamDeposit() gov.DepositParams {
cmd := fmt.Sprintf("%s query gov param deposit %s", f.KavacliBinary, f.Flags())
cmd := fmt.Sprintf("%s query gov param deposit %s", f.KvcliBinary, f.Flags())
out, _ := tests.ExecuteT(f.T, cmd, "")
var depositParam gov.DepositParams
@ -557,9 +557,9 @@ func (f *Fixtures) QueryGovParamDeposit() gov.DepositParams {
return depositParam
}
// QueryGovParamVoting is kavacli query gov param voting
// QueryGovParamVoting is kvcli query gov param voting
func (f *Fixtures) QueryGovParamVoting() gov.VotingParams {
cmd := fmt.Sprintf("%s query gov param voting %s", f.KavacliBinary, f.Flags())
cmd := fmt.Sprintf("%s query gov param voting %s", f.KvcliBinary, f.Flags())
out, _ := tests.ExecuteT(f.T, cmd, "")
var votingParam gov.VotingParams
@ -568,9 +568,9 @@ func (f *Fixtures) QueryGovParamVoting() gov.VotingParams {
return votingParam
}
// QueryGovParamTallying is kavacli query gov param tallying
// QueryGovParamTallying is kvcli query gov param tallying
func (f *Fixtures) QueryGovParamTallying() gov.TallyParams {
cmd := fmt.Sprintf("%s query gov param tallying %s", f.KavacliBinary, f.Flags())
cmd := fmt.Sprintf("%s query gov param tallying %s", f.KvcliBinary, f.Flags())
out, _ := tests.ExecuteT(f.T, cmd, "")
var tallyingParam gov.TallyParams
@ -579,9 +579,9 @@ func (f *Fixtures) QueryGovParamTallying() gov.TallyParams {
return tallyingParam
}
// QueryGovProposals is kavacli query gov proposals
// QueryGovProposals is kvcli query gov proposals
func (f *Fixtures) QueryGovProposals(flags ...string) gov.Proposals {
cmd := fmt.Sprintf("%s query gov proposals %v", f.KavacliBinary, f.Flags())
cmd := fmt.Sprintf("%s query gov proposals %v", f.KvcliBinary, f.Flags())
stdout, stderr := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
if strings.Contains(stderr, "no matching proposals found") {
return gov.Proposals{}
@ -594,9 +594,9 @@ func (f *Fixtures) QueryGovProposals(flags ...string) gov.Proposals {
return out
}
// QueryGovProposal is kavacli query gov proposal
// QueryGovProposal is kvcli query gov proposal
func (f *Fixtures) QueryGovProposal(proposalID int, flags ...string) gov.Proposal {
cmd := fmt.Sprintf("%s query gov proposal %d %v", f.KavacliBinary, proposalID, f.Flags())
cmd := fmt.Sprintf("%s query gov proposal %d %v", f.KvcliBinary, proposalID, f.Flags())
out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
var proposal gov.Proposal
@ -605,9 +605,9 @@ func (f *Fixtures) QueryGovProposal(proposalID int, flags ...string) gov.Proposa
return proposal
}
// QueryGovVote is kavacli query gov vote
// QueryGovVote is kvcli query gov vote
func (f *Fixtures) QueryGovVote(proposalID int, voter sdk.AccAddress, flags ...string) gov.Vote {
cmd := fmt.Sprintf("%s query gov vote %d %s %v", f.KavacliBinary, proposalID, voter, f.Flags())
cmd := fmt.Sprintf("%s query gov vote %d %s %v", f.KvcliBinary, proposalID, voter, f.Flags())
out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
var vote gov.Vote
@ -616,9 +616,9 @@ func (f *Fixtures) QueryGovVote(proposalID int, voter sdk.AccAddress, flags ...s
return vote
}
// QueryGovVotes is kavacli query gov votes
// QueryGovVotes is kvcli query gov votes
func (f *Fixtures) QueryGovVotes(proposalID int, flags ...string) []gov.Vote {
cmd := fmt.Sprintf("%s query gov votes %d %v", f.KavacliBinary, proposalID, f.Flags())
cmd := fmt.Sprintf("%s query gov votes %d %v", f.KvcliBinary, proposalID, f.Flags())
out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
var votes []gov.Vote
@ -627,9 +627,9 @@ func (f *Fixtures) QueryGovVotes(proposalID int, flags ...string) []gov.Vote {
return votes
}
// QueryGovDeposit is kavacli query gov deposit
// QueryGovDeposit is kvcli query gov deposit
func (f *Fixtures) QueryGovDeposit(proposalID int, depositor sdk.AccAddress, flags ...string) gov.Deposit {
cmd := fmt.Sprintf("%s query gov deposit %d %s %v", f.KavacliBinary, proposalID, depositor, f.Flags())
cmd := fmt.Sprintf("%s query gov deposit %d %s %v", f.KvcliBinary, proposalID, depositor, f.Flags())
out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
var deposit gov.Deposit
@ -638,9 +638,9 @@ func (f *Fixtures) QueryGovDeposit(proposalID int, depositor sdk.AccAddress, fla
return deposit
}
// QueryGovDeposits is kavacli query gov deposits
// QueryGovDeposits is kvcli query gov deposits
func (f *Fixtures) QueryGovDeposits(propsalID int, flags ...string) []gov.Deposit {
cmd := fmt.Sprintf("%s query gov deposits %d %v", f.KavacliBinary, propsalID, f.Flags())
cmd := fmt.Sprintf("%s query gov deposits %d %v", f.KvcliBinary, propsalID, f.Flags())
out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
var deposits []gov.Deposit
@ -654,7 +654,7 @@ func (f *Fixtures) QueryGovDeposits(propsalID int, flags ...string) []gov.Deposi
// QuerySigningInfo returns the signing info for a validator
func (f *Fixtures) QuerySigningInfo(val string) slashing.ValidatorSigningInfo {
cmd := fmt.Sprintf("%s query slashing signing-info %s %s", f.KavacliBinary, val, f.Flags())
cmd := fmt.Sprintf("%s query slashing signing-info %s %s", f.KvcliBinary, val, f.Flags())
res, errStr := tests.ExecuteT(f.T, cmd, "")
require.Empty(f.T, errStr)
@ -664,9 +664,9 @@ func (f *Fixtures) QuerySigningInfo(val string) slashing.ValidatorSigningInfo {
return sinfo
}
// QuerySlashingParams is kavacli query slashing params
// QuerySlashingParams is kvcli query slashing params
func (f *Fixtures) QuerySlashingParams() slashing.Params {
cmd := fmt.Sprintf("%s query slashing params %s", f.KavacliBinary, f.Flags())
cmd := fmt.Sprintf("%s query slashing params %s", f.KvcliBinary, f.Flags())
res, errStr := tests.ExecuteT(f.T, cmd, "")
require.Empty(f.T, errStr)
@ -681,7 +681,7 @@ func (f *Fixtures) QuerySlashingParams() slashing.Params {
// QueryRewards returns the rewards of a delegator
func (f *Fixtures) QueryRewards(delAddr sdk.AccAddress, flags ...string) distribution.QueryDelegatorTotalRewardsResponse {
cmd := fmt.Sprintf("%s query distribution rewards %s %s", f.KavacliBinary, delAddr, f.Flags())
cmd := fmt.Sprintf("%s query distribution rewards %s %s", f.KvcliBinary, delAddr, f.Flags())
res, errStr := tests.ExecuteT(f.T, cmd, "")
require.Empty(f.T, errStr)
@ -696,7 +696,7 @@ func (f *Fixtures) QueryRewards(delAddr sdk.AccAddress, flags ...string) distrib
// QueryTotalSupply returns the total supply of coins
func (f *Fixtures) QueryTotalSupply(flags ...string) (totalSupply sdk.Coins) {
cmd := fmt.Sprintf("%s query bank total %s", f.KavacliBinary, f.Flags())
cmd := fmt.Sprintf("%s query supply total %s", f.KvcliBinary, f.Flags())
res, errStr := tests.ExecuteT(f.T, cmd, "")
require.Empty(f.T, errStr)
@ -707,7 +707,7 @@ func (f *Fixtures) QueryTotalSupply(flags ...string) (totalSupply sdk.Coins) {
// QueryTotalSupplyOf returns the total supply of a given coin denom
func (f *Fixtures) QueryTotalSupplyOf(denom string, flags ...string) sdk.Int {
cmd := fmt.Sprintf("%s query bank total %s %s", f.KavacliBinary, denom, f.Flags())
cmd := fmt.Sprintf("%s query supply total %s %s", f.KvcliBinary, denom, f.Flags())
res, errStr := tests.ExecuteT(f.T, cmd, "")
require.Empty(f.T, errStr)