431 lines
17 KiB
Go
431 lines
17 KiB
Go
// +build cli_test
|
|
|
|
package clitest
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/tendermint/tendermint/crypto"
|
|
cmn "github.com/tendermint/tendermint/libs/common"
|
|
|
|
"github.com/cosmos/cosmos-sdk/client/keys"
|
|
"github.com/cosmos/cosmos-sdk/cmd/gaia/app"
|
|
"github.com/cosmos/cosmos-sdk/server"
|
|
"github.com/cosmos/cosmos-sdk/tests"
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
"github.com/cosmos/cosmos-sdk/wire"
|
|
"github.com/cosmos/cosmos-sdk/x/auth"
|
|
"github.com/cosmos/cosmos-sdk/x/gov"
|
|
"github.com/cosmos/cosmos-sdk/x/stake"
|
|
)
|
|
|
|
var (
|
|
gaiadHome = ""
|
|
gaiacliHome = ""
|
|
)
|
|
|
|
func init() {
|
|
gaiadHome, gaiacliHome = getTestingHomeDirs()
|
|
}
|
|
|
|
func TestGaiaCLISend(t *testing.T) {
|
|
chainID, servAddr, port := initializeFixtures(t)
|
|
flags := fmt.Sprintf("--home=%s --node=%v --chain-id=%v", gaiacliHome, servAddr, chainID)
|
|
|
|
// start gaiad server
|
|
proc := tests.GoExecuteTWithStdout(t, fmt.Sprintf("gaiad start --home=%s --rpc.laddr=%v", gaiadHome, servAddr))
|
|
|
|
defer proc.Stop(false)
|
|
tests.WaitForTMStart(port)
|
|
tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
fooAddr, _ := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show foo --output=json --home=%s", gaiacliHome))
|
|
barAddr, _ := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show bar --output=json --home=%s", gaiacliHome))
|
|
|
|
fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags))
|
|
require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf("steak").Int64())
|
|
|
|
executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%s --from=foo", flags, barAddr), app.DefaultKeyPass)
|
|
tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", barAddr, flags))
|
|
require.Equal(t, int64(10), barAcc.GetCoins().AmountOf("steak").Int64())
|
|
fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags))
|
|
require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf("steak").Int64())
|
|
|
|
// test autosequencing
|
|
executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%s --from=foo", flags, barAddr), app.DefaultKeyPass)
|
|
tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", barAddr, flags))
|
|
require.Equal(t, int64(20), barAcc.GetCoins().AmountOf("steak").Int64())
|
|
fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags))
|
|
require.Equal(t, int64(30), fooAcc.GetCoins().AmountOf("steak").Int64())
|
|
|
|
// test memo
|
|
executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%s --from=foo --memo 'testmemo'", flags, barAddr), app.DefaultKeyPass)
|
|
tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", barAddr, flags))
|
|
require.Equal(t, int64(30), barAcc.GetCoins().AmountOf("steak").Int64())
|
|
fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags))
|
|
require.Equal(t, int64(20), fooAcc.GetCoins().AmountOf("steak").Int64())
|
|
}
|
|
|
|
func TestGaiaCLIGasAuto(t *testing.T) {
|
|
chainID, servAddr, port := initializeFixtures(t)
|
|
flags := fmt.Sprintf("--home=%s --node=%v --chain-id=%v", gaiacliHome, servAddr, chainID)
|
|
|
|
// start gaiad server
|
|
proc := tests.GoExecuteTWithStdout(t, fmt.Sprintf("gaiad start --home=%s --rpc.laddr=%v", gaiadHome, servAddr))
|
|
|
|
defer proc.Stop(false)
|
|
tests.WaitForTMStart(port)
|
|
tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
fooAddr, _ := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show foo --output=json --home=%s", gaiacliHome))
|
|
barAddr, _ := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show bar --output=json --home=%s", gaiacliHome))
|
|
|
|
fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags))
|
|
require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf("steak").Int64())
|
|
|
|
// Test failure with auto gas disabled and very little gas set by hand
|
|
success := executeWrite(t, fmt.Sprintf("gaiacli send %v --gas=10 --amount=10steak --to=%s --from=foo", flags, barAddr), app.DefaultKeyPass)
|
|
require.False(t, success)
|
|
tests.WaitForNextNBlocksTM(2, port)
|
|
// Check state didn't change
|
|
fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags))
|
|
require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf("steak").Int64())
|
|
|
|
// Enable auto gas
|
|
success = executeWrite(t, fmt.Sprintf("gaiacli send %v --gas=0 --amount=10steak --to=%s --from=foo", flags, barAddr), app.DefaultKeyPass)
|
|
require.True(t, success)
|
|
tests.WaitForNextNBlocksTM(2, port)
|
|
// Check state has changed accordingly
|
|
fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags))
|
|
require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf("steak").Int64())
|
|
}
|
|
|
|
func TestGaiaCLICreateValidator(t *testing.T) {
|
|
chainID, servAddr, port := initializeFixtures(t)
|
|
flags := fmt.Sprintf("--home=%s --node=%v --chain-id=%v", gaiacliHome, servAddr, chainID)
|
|
|
|
// start gaiad server
|
|
proc := tests.GoExecuteTWithStdout(t, fmt.Sprintf("gaiad start --home=%s --rpc.laddr=%v", gaiadHome, servAddr))
|
|
|
|
defer proc.Stop(false)
|
|
tests.WaitForTMStart(port)
|
|
tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
fooAddr, _ := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show foo --output=json --home=%s", gaiacliHome))
|
|
barAddr, barPubKey := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show bar --output=json --home=%s", gaiacliHome))
|
|
barCeshPubKey := sdk.MustBech32ifyValPub(barPubKey)
|
|
|
|
executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%s --from=foo", flags, barAddr), app.DefaultKeyPass)
|
|
tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", barAddr, flags))
|
|
require.Equal(t, int64(10), barAcc.GetCoins().AmountOf("steak").Int64())
|
|
fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags))
|
|
require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf("steak").Int64())
|
|
|
|
defaultParams := stake.DefaultParams()
|
|
initialPool := stake.InitialPool()
|
|
initialPool.BondedTokens = initialPool.BondedTokens.Add(sdk.NewDec(100)) // Delegate tx on GaiaAppGenState
|
|
initialPool = initialPool.ProcessProvisions(defaultParams) // provisions are added to the pool every hour
|
|
|
|
// create validator
|
|
cvStr := fmt.Sprintf("gaiacli stake create-validator %v", flags)
|
|
cvStr += fmt.Sprintf(" --from=%s", "bar")
|
|
cvStr += fmt.Sprintf(" --pubkey=%s", barCeshPubKey)
|
|
cvStr += fmt.Sprintf(" --amount=%v", "2steak")
|
|
cvStr += fmt.Sprintf(" --moniker=%v", "bar-vally")
|
|
|
|
initialPool.BondedTokens = initialPool.BondedTokens.Add(sdk.NewDec(1))
|
|
|
|
executeWrite(t, cvStr, app.DefaultKeyPass)
|
|
tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", barAddr, flags))
|
|
require.Equal(t, int64(8), barAcc.GetCoins().AmountOf("steak").Int64(), "%v", barAcc)
|
|
|
|
validator := executeGetValidator(t, fmt.Sprintf("gaiacli stake validator %s --output=json %v", barAddr, flags))
|
|
require.Equal(t, validator.Operator, barAddr)
|
|
require.True(sdk.DecEq(t, sdk.NewDec(2), validator.Tokens))
|
|
|
|
// unbond a single share
|
|
unbondStr := fmt.Sprintf("gaiacli stake unbond begin %v", flags)
|
|
unbondStr += fmt.Sprintf(" --from=%s", "bar")
|
|
unbondStr += fmt.Sprintf(" --validator=%s", barAddr)
|
|
unbondStr += fmt.Sprintf(" --shares-amount=%v", "1")
|
|
|
|
success := executeWrite(t, unbondStr, app.DefaultKeyPass)
|
|
require.True(t, success)
|
|
tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
/* // this won't be what we expect because we've only started unbonding, haven't completed
|
|
barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barCech, flags))
|
|
require.Equal(t, int64(9), barAcc.GetCoins().AmountOf("steak").Int64(), "%v", barAcc)
|
|
*/
|
|
validator = executeGetValidator(t, fmt.Sprintf("gaiacli stake validator %s --output=json %v", barAddr, flags))
|
|
require.Equal(t, "1.0000000000", validator.Tokens.String())
|
|
|
|
params := executeGetParams(t, fmt.Sprintf("gaiacli stake parameters --output=json %v", flags))
|
|
require.True(t, defaultParams.Equal(params))
|
|
|
|
pool := executeGetPool(t, fmt.Sprintf("gaiacli stake pool --output=json %v", flags))
|
|
require.Equal(t, initialPool.DateLastCommissionReset, pool.DateLastCommissionReset)
|
|
require.Equal(t, initialPool.PrevBondedShares, pool.PrevBondedShares)
|
|
require.Equal(t, initialPool.BondedTokens, pool.BondedTokens)
|
|
}
|
|
|
|
func TestGaiaCLISubmitProposal(t *testing.T) {
|
|
chainID, servAddr, port := initializeFixtures(t)
|
|
flags := fmt.Sprintf("--home=%s --node=%v --chain-id=%v", gaiacliHome, servAddr, chainID)
|
|
|
|
// start gaiad server
|
|
proc := tests.GoExecuteTWithStdout(t, fmt.Sprintf("gaiad start --home=%s --rpc.laddr=%v", gaiadHome, servAddr))
|
|
|
|
defer proc.Stop(false)
|
|
tests.WaitForTMStart(port)
|
|
tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
fooAddr, _ := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show foo --output=json --home=%s", gaiacliHome))
|
|
|
|
fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags))
|
|
require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf("steak").Int64())
|
|
|
|
proposalsQuery := tests.ExecuteT(t, fmt.Sprintf("gaiacli gov query-proposals %v", flags), "")
|
|
require.Equal(t, "No matching proposals found", proposalsQuery)
|
|
|
|
// submit a test proposal
|
|
spStr := fmt.Sprintf("gaiacli gov submit-proposal %v", flags)
|
|
spStr += fmt.Sprintf(" --from=%s", "foo")
|
|
spStr += fmt.Sprintf(" --deposit=%s", "5steak")
|
|
spStr += fmt.Sprintf(" --type=%s", "Text")
|
|
spStr += fmt.Sprintf(" --title=%s", "Test")
|
|
spStr += fmt.Sprintf(" --description=%s", "test")
|
|
|
|
executeWrite(t, spStr, app.DefaultKeyPass)
|
|
tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags))
|
|
require.Equal(t, int64(45), fooAcc.GetCoins().AmountOf("steak").Int64())
|
|
|
|
proposal1 := executeGetProposal(t, fmt.Sprintf("gaiacli gov query-proposal --proposal-id=1 --output=json %v", flags))
|
|
require.Equal(t, int64(1), proposal1.GetProposalID())
|
|
require.Equal(t, gov.StatusDepositPeriod, proposal1.GetStatus())
|
|
|
|
proposalsQuery = tests.ExecuteT(t, fmt.Sprintf("gaiacli gov query-proposals %v", flags), "")
|
|
require.Equal(t, " 1 - Test", proposalsQuery)
|
|
|
|
depositStr := fmt.Sprintf("gaiacli gov deposit %v", flags)
|
|
depositStr += fmt.Sprintf(" --from=%s", "foo")
|
|
depositStr += fmt.Sprintf(" --deposit=%s", "10steak")
|
|
depositStr += fmt.Sprintf(" --proposal-id=%s", "1")
|
|
|
|
executeWrite(t, depositStr, app.DefaultKeyPass)
|
|
tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags))
|
|
require.Equal(t, int64(35), fooAcc.GetCoins().AmountOf("steak").Int64())
|
|
proposal1 = executeGetProposal(t, fmt.Sprintf("gaiacli gov query-proposal --proposal-id=1 --output=json %v", flags))
|
|
require.Equal(t, int64(1), proposal1.GetProposalID())
|
|
require.Equal(t, gov.StatusVotingPeriod, proposal1.GetStatus())
|
|
|
|
voteStr := fmt.Sprintf("gaiacli gov vote %v", flags)
|
|
voteStr += fmt.Sprintf(" --from=%s", "foo")
|
|
voteStr += fmt.Sprintf(" --proposal-id=%s", "1")
|
|
voteStr += fmt.Sprintf(" --option=%s", "Yes")
|
|
|
|
executeWrite(t, voteStr, app.DefaultKeyPass)
|
|
tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
vote := executeGetVote(t, fmt.Sprintf("gaiacli gov query-vote --proposal-id=1 --voter=%s --output=json %v", fooAddr, flags))
|
|
require.Equal(t, int64(1), vote.ProposalID)
|
|
require.Equal(t, gov.OptionYes, vote.Option)
|
|
|
|
votes := executeGetVotes(t, fmt.Sprintf("gaiacli gov query-votes --proposal-id=1 --output=json %v", flags))
|
|
require.Len(t, votes, 1)
|
|
require.Equal(t, int64(1), votes[0].ProposalID)
|
|
require.Equal(t, gov.OptionYes, votes[0].Option)
|
|
|
|
proposalsQuery = tests.ExecuteT(t, fmt.Sprintf("gaiacli gov query-proposals --status=DepositPeriod %v", flags), "")
|
|
require.Equal(t, "No matching proposals found", proposalsQuery)
|
|
|
|
proposalsQuery = tests.ExecuteT(t, fmt.Sprintf("gaiacli gov query-proposals --status=VotingPeriod %v", flags), "")
|
|
require.Equal(t, " 1 - Test", proposalsQuery)
|
|
|
|
// submit a second test proposal
|
|
spStr = fmt.Sprintf("gaiacli gov submit-proposal %v", flags)
|
|
spStr += fmt.Sprintf(" --from=%s", "foo")
|
|
spStr += fmt.Sprintf(" --deposit=%s", "5steak")
|
|
spStr += fmt.Sprintf(" --type=%s", "Text")
|
|
spStr += fmt.Sprintf(" --title=%s", "Apples")
|
|
spStr += fmt.Sprintf(" --description=%s", "test")
|
|
|
|
executeWrite(t, spStr, app.DefaultKeyPass)
|
|
tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
proposalsQuery = tests.ExecuteT(t, fmt.Sprintf("gaiacli gov query-proposals --latest=1 %v", flags), "")
|
|
require.Equal(t, " 2 - Apples", proposalsQuery)
|
|
}
|
|
|
|
//___________________________________________________________________________________
|
|
// helper methods
|
|
|
|
func getTestingHomeDirs() (string, string) {
|
|
tmpDir := os.TempDir()
|
|
gaiadHome := fmt.Sprintf("%s%s.test_gaiad", tmpDir, string(os.PathSeparator))
|
|
gaiacliHome := fmt.Sprintf("%s%s.test_gaiacli", tmpDir, string(os.PathSeparator))
|
|
return gaiadHome, gaiacliHome
|
|
}
|
|
|
|
func initializeFixtures(t *testing.T) (chainID, servAddr, port string) {
|
|
tests.ExecuteT(t, fmt.Sprintf("gaiad --home=%s unsafe-reset-all", gaiadHome), "")
|
|
executeWrite(t, fmt.Sprintf("gaiacli keys delete --home=%s foo", gaiacliHome), app.DefaultKeyPass)
|
|
executeWrite(t, fmt.Sprintf("gaiacli keys delete --home=%s bar", gaiacliHome), app.DefaultKeyPass)
|
|
|
|
chainID = executeInit(t, fmt.Sprintf("gaiad init -o --name=foo --home=%s --home-client=%s", gaiadHome, gaiacliHome))
|
|
executeWrite(t, fmt.Sprintf("gaiacli keys add --home=%s bar", gaiacliHome), app.DefaultKeyPass)
|
|
|
|
// get a free port, also setup some common flags
|
|
servAddr, port, err := server.FreeTCPAddr()
|
|
require.NoError(t, err)
|
|
return
|
|
}
|
|
|
|
//___________________________________________________________________________________
|
|
// executors
|
|
|
|
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)
|
|
|
|
for _, write := range writes {
|
|
_, err := proc.StdinPipe.Write([]byte(write + "\n"))
|
|
require.NoError(t, err)
|
|
}
|
|
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:", cmn.Green(string(stdout)))
|
|
}
|
|
if len(stderr) > 0 {
|
|
t.Log("Stderr:", cmn.Red(string(stderr)))
|
|
}
|
|
|
|
proc.Wait()
|
|
return proc.ExitState.Success(), string(stdout), string(stderr)
|
|
}
|
|
|
|
func executeInit(t *testing.T, cmdStr string) (chainID string) {
|
|
out := tests.ExecuteT(t, cmdStr, app.DefaultKeyPass)
|
|
|
|
var initRes map[string]json.RawMessage
|
|
err := json.Unmarshal([]byte(out), &initRes)
|
|
require.NoError(t, err)
|
|
|
|
err = json.Unmarshal(initRes["chain_id"], &chainID)
|
|
require.NoError(t, err)
|
|
|
|
return
|
|
}
|
|
|
|
func executeGetAddrPK(t *testing.T, cmdStr string) (sdk.AccAddress, crypto.PubKey) {
|
|
out := tests.ExecuteT(t, cmdStr, "")
|
|
var ko keys.KeyOutput
|
|
keys.UnmarshalJSON([]byte(out), &ko)
|
|
|
|
pk, err := sdk.GetAccPubKeyBech32(ko.PubKey)
|
|
require.NoError(t, err)
|
|
|
|
return ko.Address, pk
|
|
}
|
|
|
|
func executeGetAccount(t *testing.T, cmdStr string) auth.BaseAccount {
|
|
out := tests.ExecuteT(t, cmdStr, "")
|
|
var initRes map[string]json.RawMessage
|
|
err := json.Unmarshal([]byte(out), &initRes)
|
|
require.NoError(t, err, "out %v, err %v", out, err)
|
|
value := initRes["value"]
|
|
var acc auth.BaseAccount
|
|
cdc := wire.NewCodec()
|
|
wire.RegisterCrypto(cdc)
|
|
err = cdc.UnmarshalJSON(value, &acc)
|
|
require.NoError(t, err, "value %v, err %v", string(value), err)
|
|
return acc
|
|
}
|
|
|
|
//___________________________________________________________________________________
|
|
// stake
|
|
|
|
func executeGetValidator(t *testing.T, cmdStr string) stake.Validator {
|
|
out := tests.ExecuteT(t, cmdStr, "")
|
|
var validator stake.Validator
|
|
cdc := app.MakeCodec()
|
|
err := cdc.UnmarshalJSON([]byte(out), &validator)
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
|
return validator
|
|
}
|
|
|
|
func executeGetPool(t *testing.T, cmdStr string) stake.Pool {
|
|
out := tests.ExecuteT(t, cmdStr, "")
|
|
var pool stake.Pool
|
|
cdc := app.MakeCodec()
|
|
err := cdc.UnmarshalJSON([]byte(out), &pool)
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
|
return pool
|
|
}
|
|
|
|
func executeGetParams(t *testing.T, cmdStr string) stake.Params {
|
|
out := tests.ExecuteT(t, cmdStr, "")
|
|
var params stake.Params
|
|
cdc := app.MakeCodec()
|
|
err := cdc.UnmarshalJSON([]byte(out), ¶ms)
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
|
return params
|
|
}
|
|
|
|
//___________________________________________________________________________________
|
|
// gov
|
|
|
|
func executeGetProposal(t *testing.T, cmdStr string) gov.Proposal {
|
|
out := tests.ExecuteT(t, cmdStr, "")
|
|
var proposal gov.Proposal
|
|
cdc := app.MakeCodec()
|
|
err := cdc.UnmarshalJSON([]byte(out), &proposal)
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
|
return proposal
|
|
}
|
|
|
|
func executeGetVote(t *testing.T, cmdStr string) gov.Vote {
|
|
out := tests.ExecuteT(t, cmdStr, "")
|
|
var vote gov.Vote
|
|
cdc := app.MakeCodec()
|
|
err := cdc.UnmarshalJSON([]byte(out), &vote)
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
|
return vote
|
|
}
|
|
|
|
func executeGetVotes(t *testing.T, cmdStr string) []gov.Vote {
|
|
out := tests.ExecuteT(t, cmdStr, "")
|
|
var votes []gov.Vote
|
|
cdc := app.MakeCodec()
|
|
err := cdc.UnmarshalJSON([]byte(out), &votes)
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
|
return votes
|
|
}
|