2018-04-18 11:06:49 -07:00
|
|
|
package clitest
|
2018-04-13 13:08:06 -07:00
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
|
|
|
"fmt"
|
|
|
|
"testing"
|
|
|
|
|
2018-04-13 16:45:26 -07:00
|
|
|
"github.com/stretchr/testify/assert"
|
2018-04-13 13:08:06 -07:00
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
|
2018-04-14 13:52:58 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/client/keys"
|
2018-04-16 16:49:00 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/cmd/gaia/app"
|
2018-04-13 16:45:26 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/server"
|
2018-04-13 13:08:06 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/tests"
|
2018-05-26 14:21:29 -07:00
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
2018-04-25 13:38:13 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/wire"
|
2018-04-13 16:45:26 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/x/auth"
|
2018-06-21 17:19:14 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/x/gov"
|
2018-04-16 16:49:00 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/x/stake"
|
2018-06-28 17:54:47 -07:00
|
|
|
"github.com/tendermint/tendermint/crypto"
|
2018-04-13 13:08:06 -07:00
|
|
|
)
|
|
|
|
|
2018-04-16 16:49:00 -07:00
|
|
|
func TestGaiaCLISend(t *testing.T) {
|
2018-04-16 16:17:09 -07:00
|
|
|
|
2018-06-01 01:47:44 -07:00
|
|
|
tests.ExecuteT(t, "gaiad unsafe_reset_all")
|
2018-04-16 16:49:00 -07:00
|
|
|
pass := "1234567890"
|
|
|
|
executeWrite(t, "gaiacli keys delete foo", pass)
|
|
|
|
executeWrite(t, "gaiacli keys delete bar", pass)
|
2018-04-25 21:27:40 -07:00
|
|
|
chainID := executeInit(t, "gaiad init -o --name=foo")
|
|
|
|
executeWrite(t, "gaiacli keys add bar", pass)
|
2018-04-16 16:17:09 -07:00
|
|
|
|
2018-04-16 16:49:00 -07:00
|
|
|
// get a free port, also setup some common flags
|
2018-05-31 18:46:25 -07:00
|
|
|
servAddr, port, err := server.FreeTCPAddr()
|
|
|
|
require.NoError(t, err)
|
2018-04-16 16:49:00 -07:00
|
|
|
flags := fmt.Sprintf("--node=%v --chain-id=%v", servAddr, chainID)
|
2018-04-16 16:17:09 -07:00
|
|
|
|
2018-04-16 16:49:00 -07:00
|
|
|
// start gaiad server
|
2018-05-31 04:16:05 -07:00
|
|
|
proc := tests.GoExecuteT(t, fmt.Sprintf("gaiad start --rpc.laddr=%v", servAddr))
|
|
|
|
defer proc.Stop(false)
|
2018-05-31 18:46:25 -07:00
|
|
|
tests.WaitForStart(port)
|
2018-04-16 16:17:09 -07:00
|
|
|
|
2018-04-19 12:18:31 -07:00
|
|
|
fooAddr, _ := executeGetAddrPK(t, "gaiacli keys show foo --output=json")
|
2018-06-01 07:23:58 -07:00
|
|
|
fooCech, err := sdk.Bech32ifyAcc(fooAddr)
|
2018-05-31 12:10:12 -07:00
|
|
|
require.NoError(t, err)
|
2018-04-19 12:18:31 -07:00
|
|
|
barAddr, _ := executeGetAddrPK(t, "gaiacli keys show bar --output=json")
|
2018-06-01 07:23:58 -07:00
|
|
|
barCech, err := sdk.Bech32ifyAcc(barAddr)
|
2018-05-31 12:10:12 -07:00
|
|
|
require.NoError(t, err)
|
2018-04-16 16:17:09 -07:00
|
|
|
|
2018-05-31 12:10:12 -07:00
|
|
|
fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooCech, flags))
|
2018-06-15 14:16:45 -07:00
|
|
|
assert.Equal(t, int64(50), fooAcc.GetCoins().AmountOf("steak").Int64())
|
2018-04-16 16:17:09 -07:00
|
|
|
|
2018-05-31 12:10:12 -07:00
|
|
|
executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%v --name=foo", flags, barCech), pass)
|
2018-06-13 17:41:01 -07:00
|
|
|
tests.WaitForNextHeightTM(port)
|
2018-04-16 16:17:09 -07:00
|
|
|
|
2018-05-31 12:10:12 -07:00
|
|
|
barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barCech, flags))
|
2018-06-15 14:16:45 -07:00
|
|
|
assert.Equal(t, int64(10), barAcc.GetCoins().AmountOf("steak").Int64())
|
2018-05-31 12:10:12 -07:00
|
|
|
fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooCech, flags))
|
2018-06-15 14:16:45 -07:00
|
|
|
assert.Equal(t, int64(40), fooAcc.GetCoins().AmountOf("steak").Int64())
|
2018-05-03 20:43:29 -07:00
|
|
|
|
|
|
|
// test autosequencing
|
2018-05-31 12:10:12 -07:00
|
|
|
executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%v --name=foo", flags, barCech), pass)
|
2018-06-13 17:41:01 -07:00
|
|
|
tests.WaitForNextHeightTM(port)
|
2018-05-03 20:43:29 -07:00
|
|
|
|
2018-05-31 12:10:12 -07:00
|
|
|
barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barCech, flags))
|
2018-06-15 14:16:45 -07:00
|
|
|
assert.Equal(t, int64(20), barAcc.GetCoins().AmountOf("steak").Int64())
|
2018-05-31 12:10:12 -07:00
|
|
|
fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooCech, flags))
|
2018-06-15 14:16:45 -07:00
|
|
|
assert.Equal(t, int64(30), fooAcc.GetCoins().AmountOf("steak").Int64())
|
2018-06-20 12:27:36 -07:00
|
|
|
|
|
|
|
// test memo
|
|
|
|
executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%v --name=foo --memo 'testmemo'", flags, barCech), pass)
|
|
|
|
tests.WaitForNextHeightTM(port)
|
|
|
|
|
|
|
|
barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barCech, flags))
|
|
|
|
assert.Equal(t, int64(30), barAcc.GetCoins().AmountOf("steak").Int64())
|
|
|
|
fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooCech, flags))
|
|
|
|
assert.Equal(t, int64(20), fooAcc.GetCoins().AmountOf("steak").Int64())
|
2018-04-16 16:49:00 -07:00
|
|
|
}
|
2018-04-16 16:17:09 -07:00
|
|
|
|
2018-05-31 12:10:12 -07:00
|
|
|
func TestGaiaCLICreateValidator(t *testing.T) {
|
2018-04-13 13:08:06 -07:00
|
|
|
|
2018-06-01 01:47:44 -07:00
|
|
|
tests.ExecuteT(t, "gaiad unsafe_reset_all")
|
2018-04-14 00:16:49 -07:00
|
|
|
pass := "1234567890"
|
2018-04-16 13:47:28 -07:00
|
|
|
executeWrite(t, "gaiacli keys delete foo", pass)
|
2018-04-25 13:38:13 -07:00
|
|
|
executeWrite(t, "gaiacli keys delete bar", pass)
|
2018-04-25 21:27:40 -07:00
|
|
|
chainID := executeInit(t, "gaiad init -o --name=foo")
|
|
|
|
executeWrite(t, "gaiacli keys add bar", pass)
|
2018-04-13 13:08:06 -07:00
|
|
|
|
2018-04-14 00:16:49 -07:00
|
|
|
// get a free port, also setup some common flags
|
2018-05-31 18:46:25 -07:00
|
|
|
servAddr, port, err := server.FreeTCPAddr()
|
|
|
|
require.NoError(t, err)
|
2018-04-14 00:16:49 -07:00
|
|
|
flags := fmt.Sprintf("--node=%v --chain-id=%v", servAddr, chainID)
|
2018-04-13 16:45:26 -07:00
|
|
|
|
2018-04-13 13:08:06 -07:00
|
|
|
// start gaiad server
|
2018-05-31 04:16:05 -07:00
|
|
|
proc := tests.GoExecuteT(t, fmt.Sprintf("gaiad start --rpc.laddr=%v", servAddr))
|
|
|
|
defer proc.Stop(false)
|
2018-05-31 18:46:25 -07:00
|
|
|
tests.WaitForStart(port)
|
2018-04-13 13:08:06 -07:00
|
|
|
|
2018-04-25 13:12:14 -07:00
|
|
|
fooAddr, _ := executeGetAddrPK(t, "gaiacli keys show foo --output=json")
|
2018-06-01 07:23:58 -07:00
|
|
|
fooCech, err := sdk.Bech32ifyAcc(fooAddr)
|
2018-05-31 12:10:12 -07:00
|
|
|
require.NoError(t, err)
|
|
|
|
barAddr, barPubKey := executeGetAddrPK(t, "gaiacli keys show bar --output=json")
|
2018-06-01 07:23:58 -07:00
|
|
|
barCech, err := sdk.Bech32ifyAcc(barAddr)
|
2018-05-31 12:10:12 -07:00
|
|
|
require.NoError(t, err)
|
2018-06-01 07:23:58 -07:00
|
|
|
barCeshPubKey, err := sdk.Bech32ifyValPub(barPubKey)
|
2018-05-31 12:10:12 -07:00
|
|
|
require.NoError(t, err)
|
2018-05-26 14:21:29 -07:00
|
|
|
|
2018-05-31 12:10:12 -07:00
|
|
|
executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%v --name=foo", flags, barCech), pass)
|
2018-06-13 17:41:01 -07:00
|
|
|
tests.WaitForNextHeightTM(port)
|
2018-04-25 13:38:13 -07:00
|
|
|
|
2018-05-31 12:10:12 -07:00
|
|
|
barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barCech, flags))
|
2018-06-15 14:16:45 -07:00
|
|
|
assert.Equal(t, int64(10), barAcc.GetCoins().AmountOf("steak").Int64())
|
2018-05-31 12:10:12 -07:00
|
|
|
fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooCech, flags))
|
2018-06-15 14:16:45 -07:00
|
|
|
assert.Equal(t, int64(40), fooAcc.GetCoins().AmountOf("steak").Int64())
|
2018-05-31 12:10:12 -07:00
|
|
|
|
2018-05-31 12:22:46 -07:00
|
|
|
// create validator
|
2018-05-31 22:06:13 -07:00
|
|
|
cvStr := fmt.Sprintf("gaiacli stake create-validator %v", flags)
|
2018-05-31 12:10:12 -07:00
|
|
|
cvStr += fmt.Sprintf(" --name=%v", "bar")
|
2018-05-31 13:33:52 -07:00
|
|
|
cvStr += fmt.Sprintf(" --address-validator=%v", barCech)
|
2018-05-31 12:10:12 -07:00
|
|
|
cvStr += fmt.Sprintf(" --pubkey=%v", barCeshPubKey)
|
2018-05-31 15:49:18 -07:00
|
|
|
cvStr += fmt.Sprintf(" --amount=%v", "2steak")
|
2018-05-31 12:10:12 -07:00
|
|
|
cvStr += fmt.Sprintf(" --moniker=%v", "bar-vally")
|
|
|
|
|
|
|
|
executeWrite(t, cvStr, pass)
|
2018-06-13 17:41:01 -07:00
|
|
|
tests.WaitForNextHeightTM(port)
|
2018-05-31 12:10:12 -07:00
|
|
|
|
|
|
|
barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barCech, flags))
|
2018-06-15 14:16:45 -07:00
|
|
|
require.Equal(t, int64(8), barAcc.GetCoins().AmountOf("steak").Int64(), "%v", barAcc)
|
2018-05-31 12:10:12 -07:00
|
|
|
|
2018-05-31 22:06:13 -07:00
|
|
|
validator := executeGetValidator(t, fmt.Sprintf("gaiacli stake validator %v --output=json %v", barCech, flags))
|
2018-05-31 14:45:07 -07:00
|
|
|
assert.Equal(t, validator.Owner, barAddr)
|
2018-05-31 15:49:18 -07:00
|
|
|
assert.Equal(t, "2/1", validator.PoolShares.Amount.String())
|
2018-04-17 21:33:33 -07:00
|
|
|
|
|
|
|
// unbond a single share
|
2018-05-31 22:06:13 -07:00
|
|
|
unbondStr := fmt.Sprintf("gaiacli stake unbond %v", flags)
|
2018-05-31 15:49:18 -07:00
|
|
|
unbondStr += fmt.Sprintf(" --name=%v", "bar")
|
|
|
|
unbondStr += fmt.Sprintf(" --address-validator=%v", barCech)
|
|
|
|
unbondStr += fmt.Sprintf(" --address-delegator=%v", barCech)
|
|
|
|
unbondStr += fmt.Sprintf(" --shares=%v", "1")
|
|
|
|
unbondStr += fmt.Sprintf(" --sequence=%v", "1")
|
|
|
|
t.Log(fmt.Sprintf("debug unbondStr: %v\n", unbondStr))
|
|
|
|
|
|
|
|
executeWrite(t, unbondStr, pass)
|
2018-06-13 17:41:01 -07:00
|
|
|
tests.WaitForNextHeightTM(port)
|
2018-05-31 15:49:18 -07:00
|
|
|
|
|
|
|
barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barCech, flags))
|
2018-06-15 14:16:45 -07:00
|
|
|
require.Equal(t, int64(9), barAcc.GetCoins().AmountOf("steak").Int64(), "%v", barAcc)
|
2018-05-31 22:06:13 -07:00
|
|
|
validator = executeGetValidator(t, fmt.Sprintf("gaiacli stake validator %v --output=json %v", barCech, flags))
|
2018-05-31 15:49:18 -07:00
|
|
|
assert.Equal(t, "1/1", validator.PoolShares.Amount.String())
|
2018-04-14 00:16:49 -07:00
|
|
|
}
|
2018-04-13 13:08:06 -07:00
|
|
|
|
2018-06-21 17:19:14 -07:00
|
|
|
func TestGaiaCLISubmitProposal(t *testing.T) {
|
|
|
|
|
|
|
|
tests.ExecuteT(t, "gaiad unsafe_reset_all")
|
|
|
|
pass := "1234567890"
|
|
|
|
executeWrite(t, "gaiacli keys delete foo", pass)
|
|
|
|
executeWrite(t, "gaiacli keys delete bar", pass)
|
|
|
|
chainID := executeInit(t, "gaiad init -o --name=foo")
|
|
|
|
executeWrite(t, "gaiacli keys add bar", pass)
|
|
|
|
|
|
|
|
// get a free port, also setup some common flags
|
|
|
|
servAddr, port, err := server.FreeTCPAddr()
|
|
|
|
require.NoError(t, err)
|
|
|
|
flags := fmt.Sprintf("--node=%v --chain-id=%v", servAddr, chainID)
|
|
|
|
|
|
|
|
// start gaiad server
|
|
|
|
proc := tests.GoExecuteT(t, fmt.Sprintf("gaiad start --rpc.laddr=%v", servAddr))
|
|
|
|
defer proc.Stop(false)
|
|
|
|
tests.WaitForStart(port)
|
|
|
|
|
|
|
|
fooAddr, _ := executeGetAddrPK(t, "gaiacli keys show foo --output=json")
|
|
|
|
fooCech, err := sdk.Bech32ifyAcc(fooAddr)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooCech, flags))
|
|
|
|
assert.Equal(t, int64(50), fooAcc.GetCoins().AmountOf("steak").Int64())
|
|
|
|
|
|
|
|
executeWrite(t, fmt.Sprintf("gaiacli gov submitproposal %v --proposer=%v --deposit=5steak --type=Text --title=Test --description=test --name=foo", flags, fooCech), pass)
|
|
|
|
tests.WaitForNextHeightTM(port)
|
|
|
|
|
|
|
|
fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooCech, flags))
|
|
|
|
assert.Equal(t, int64(45), fooAcc.GetCoins().AmountOf("steak").Int64())
|
|
|
|
|
|
|
|
proposal1 := executeGetProposal(t, fmt.Sprintf("gaiacli gov query-proposal --proposalID=1 --output=json %v", flags))
|
|
|
|
assert.Equal(t, int64(1), proposal1.ProposalID)
|
|
|
|
assert.Equal(t, gov.StatusToString(gov.StatusDepositPeriod), proposal1.Status)
|
|
|
|
|
|
|
|
executeWrite(t, fmt.Sprintf("gaiacli gov deposit %v --depositer=%v --deposit=10steak --proposalID=1 --name=foo", flags, fooCech), pass)
|
|
|
|
tests.WaitForNextHeightTM(port)
|
|
|
|
|
|
|
|
fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooCech, flags))
|
|
|
|
assert.Equal(t, int64(35), fooAcc.GetCoins().AmountOf("steak").Int64())
|
|
|
|
proposal1 = executeGetProposal(t, fmt.Sprintf("gaiacli gov query-proposal --proposalID=1 --output=json %v", flags))
|
|
|
|
assert.Equal(t, int64(1), proposal1.ProposalID)
|
|
|
|
assert.Equal(t, gov.StatusToString(gov.StatusVotingPeriod), proposal1.Status)
|
|
|
|
|
|
|
|
executeWrite(t, fmt.Sprintf("gaiacli gov vote %v --proposalID=1 --voter=%v --option=Yes --name=foo", flags, fooCech), pass)
|
|
|
|
tests.WaitForNextHeightTM(port)
|
|
|
|
|
|
|
|
vote := executeGetVote(t, fmt.Sprintf("gaiacli gov query-vote --proposalID=1 --voter=%v --output=json %v", fooCech, flags))
|
|
|
|
assert.Equal(t, int64(1), vote.ProposalID)
|
|
|
|
assert.Equal(t, gov.VoteOptionToString(gov.OptionYes), vote.Option)
|
|
|
|
}
|
|
|
|
|
2018-05-31 12:10:12 -07:00
|
|
|
//___________________________________________________________________________________
|
|
|
|
// executors
|
|
|
|
|
2018-04-16 13:47:28 -07:00
|
|
|
func executeWrite(t *testing.T, cmdStr string, writes ...string) {
|
2018-05-31 04:16:05 -07:00
|
|
|
proc := tests.GoExecuteT(t, cmdStr)
|
2018-04-14 13:52:58 -07:00
|
|
|
|
2018-04-16 16:17:09 -07:00
|
|
|
for _, write := range writes {
|
2018-05-31 04:16:05 -07:00
|
|
|
_, err := proc.StdinPipe.Write([]byte(write + "\n"))
|
2018-04-16 16:17:09 -07:00
|
|
|
require.NoError(t, err)
|
|
|
|
}
|
2018-05-31 04:16:05 -07:00
|
|
|
proc.Wait()
|
2018-06-13 17:41:01 -07:00
|
|
|
// bz := proc.StdoutBuffer.Bytes()
|
|
|
|
// fmt.Println("EXEC WRITE", string(bz))
|
2018-04-14 00:16:49 -07:00
|
|
|
}
|
2018-04-13 13:08:06 -07:00
|
|
|
|
2018-04-25 21:27:40 -07:00
|
|
|
func executeInit(t *testing.T, cmdStr string) (chainID string) {
|
2018-04-25 13:38:13 -07:00
|
|
|
out := tests.ExecuteT(t, cmdStr)
|
2018-04-13 16:45:26 -07:00
|
|
|
|
2018-04-14 00:16:49 -07:00
|
|
|
var initRes map[string]json.RawMessage
|
2018-04-21 21:57:53 -07:00
|
|
|
err := json.Unmarshal([]byte(out), &initRes)
|
2018-04-14 10:06:54 -07:00
|
|
|
require.NoError(t, err)
|
2018-04-21 21:57:53 -07:00
|
|
|
|
2018-04-14 10:06:54 -07:00
|
|
|
err = json.Unmarshal(initRes["chain_id"], &chainID)
|
|
|
|
require.NoError(t, err)
|
2018-04-21 21:57:53 -07:00
|
|
|
|
2018-04-14 00:16:49 -07:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-05-26 14:21:29 -07:00
|
|
|
func executeGetAddrPK(t *testing.T, cmdStr string) (sdk.Address, crypto.PubKey) {
|
2018-04-25 13:38:13 -07:00
|
|
|
out := tests.ExecuteT(t, cmdStr)
|
2018-04-20 09:51:47 -07:00
|
|
|
var ko keys.KeyOutput
|
|
|
|
keys.UnmarshalJSON([]byte(out), &ko)
|
2018-05-31 12:10:12 -07:00
|
|
|
|
2018-06-05 21:53:04 -07:00
|
|
|
address, err := sdk.GetAccAddressBech32(ko.Address)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
pk, err := sdk.GetAccPubKeyBech32(ko.PubKey)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
return address, pk
|
2018-04-13 16:45:26 -07:00
|
|
|
}
|
|
|
|
|
2018-04-14 00:16:49 -07:00
|
|
|
func executeGetAccount(t *testing.T, cmdStr string) auth.BaseAccount {
|
2018-04-25 13:38:13 -07:00
|
|
|
out := tests.ExecuteT(t, cmdStr)
|
2018-04-13 16:45:26 -07:00
|
|
|
var initRes map[string]json.RawMessage
|
2018-04-14 00:16:49 -07:00
|
|
|
err := json.Unmarshal([]byte(out), &initRes)
|
|
|
|
require.NoError(t, err, "out %v, err %v", out, err)
|
2018-04-13 16:45:26 -07:00
|
|
|
value := initRes["value"]
|
|
|
|
var acc auth.BaseAccount
|
2018-04-25 13:38:13 -07:00
|
|
|
cdc := wire.NewCodec()
|
|
|
|
wire.RegisterCrypto(cdc)
|
|
|
|
err = cdc.UnmarshalJSON(value, &acc)
|
2018-04-13 16:45:26 -07:00
|
|
|
require.NoError(t, err, "value %v, err %v", string(value), err)
|
|
|
|
return acc
|
2018-04-13 13:08:06 -07:00
|
|
|
}
|
2018-04-16 16:49:00 -07:00
|
|
|
|
2018-05-31 12:10:12 -07:00
|
|
|
func executeGetValidator(t *testing.T, cmdStr string) stake.Validator {
|
2018-04-25 13:38:13 -07:00
|
|
|
out := tests.ExecuteT(t, cmdStr)
|
2018-05-31 12:10:12 -07:00
|
|
|
var validator stake.Validator
|
2018-04-16 16:49:00 -07:00
|
|
|
cdc := app.MakeCodec()
|
2018-05-31 12:10:12 -07:00
|
|
|
err := cdc.UnmarshalJSON([]byte(out), &validator)
|
2018-05-31 14:45:07 -07:00
|
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
2018-05-31 12:10:12 -07:00
|
|
|
return validator
|
2018-04-16 16:49:00 -07:00
|
|
|
}
|
2018-06-21 17:19:14 -07:00
|
|
|
|
|
|
|
func executeGetProposal(t *testing.T, cmdStr string) gov.ProposalRest {
|
|
|
|
out := tests.ExecuteT(t, cmdStr)
|
|
|
|
var proposal gov.ProposalRest
|
|
|
|
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.VoteRest {
|
|
|
|
out := tests.ExecuteT(t, cmdStr)
|
|
|
|
var vote gov.VoteRest
|
|
|
|
cdc := app.MakeCodec()
|
|
|
|
err := cdc.UnmarshalJSON([]byte(out), &vote)
|
|
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
|
|
|
return vote
|
|
|
|
}
|