2018-07-25 13:47:00 -07:00
|
|
|
// +build cli_test
|
|
|
|
|
2018-04-18 11:06:49 -07:00
|
|
|
package clitest
|
2018-04-13 13:08:06 -07:00
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
|
|
|
"fmt"
|
2018-09-07 03:59:16 -07:00
|
|
|
"io/ioutil"
|
2018-07-03 23:25:31 -07:00
|
|
|
"os"
|
2018-11-04 20:26:46 -08:00
|
|
|
"path/filepath"
|
2018-10-03 08:48:23 -07:00
|
|
|
"testing"
|
2018-04-13 13:08:06 -07:00
|
|
|
|
2018-11-06 23:33:18 -08:00
|
|
|
"github.com/tendermint/tendermint/types"
|
|
|
|
|
2018-04-13 13:08:06 -07:00
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
|
2018-07-02 21:33:53 -07:00
|
|
|
"github.com/tendermint/tendermint/crypto"
|
|
|
|
cmn "github.com/tendermint/tendermint/libs/common"
|
|
|
|
|
2018-04-14 13:52:58 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/client/keys"
|
2018-11-20 05:13:05 -08:00
|
|
|
"github.com/cosmos/cosmos-sdk/client/tx"
|
2018-04-16 16:49:00 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/cmd/gaia/app"
|
2018-09-13 11:17:32 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/codec"
|
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-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-11-12 10:54:18 -08:00
|
|
|
stakeTypes "github.com/cosmos/cosmos-sdk/x/stake/types"
|
2018-04-13 13:08:06 -07:00
|
|
|
)
|
|
|
|
|
2018-11-26 06:55:42 -08:00
|
|
|
// import (
|
|
|
|
// "encoding/json"
|
|
|
|
// "fmt"
|
|
|
|
// "io/ioutil"
|
|
|
|
// "os"
|
|
|
|
// "path"
|
|
|
|
// "path/filepath"
|
|
|
|
// "testing"
|
|
|
|
//
|
|
|
|
// "github.com/tendermint/tendermint/types"
|
|
|
|
//
|
|
|
|
// "github.com/stretchr/testify/require"
|
|
|
|
//
|
|
|
|
// abci "github.com/tendermint/tendermint/abci/types"
|
|
|
|
// "github.com/tendermint/tendermint/crypto"
|
|
|
|
// cmn "github.com/tendermint/tendermint/libs/common"
|
|
|
|
//
|
|
|
|
// "github.com/cosmos/cosmos-sdk/client"
|
|
|
|
// "github.com/cosmos/cosmos-sdk/client/keys"
|
|
|
|
// "github.com/cosmos/cosmos-sdk/client/tx"
|
|
|
|
// "github.com/cosmos/cosmos-sdk/cmd/gaia/app"
|
|
|
|
// "github.com/cosmos/cosmos-sdk/codec"
|
|
|
|
// "github.com/cosmos/cosmos-sdk/server"
|
|
|
|
// "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/gov"
|
|
|
|
// "github.com/cosmos/cosmos-sdk/x/stake"
|
|
|
|
// stakeTypes "github.com/cosmos/cosmos-sdk/x/stake/types"
|
|
|
|
// )
|
|
|
|
|
2018-07-03 23:25:31 -07:00
|
|
|
var (
|
|
|
|
gaiadHome = ""
|
|
|
|
gaiacliHome = ""
|
|
|
|
)
|
2018-04-16 16:17:09 -07:00
|
|
|
|
2018-07-03 23:25:31 -07:00
|
|
|
func init() {
|
|
|
|
gaiadHome, gaiacliHome = getTestingHomeDirs()
|
|
|
|
}
|
2018-04-16 16:17:09 -07:00
|
|
|
|
2018-11-26 06:55:42 -08:00
|
|
|
// func TestGaiaCLIMinimumFees(t *testing.T) {
|
|
|
|
// chainID, servAddr, port := initializeFixtures(t)
|
|
|
|
// flags := fmt.Sprintf("--home=%s --node=%v --chain-id=%v", gaiacliHome, servAddr, chainID)
|
|
|
|
//
|
|
|
|
// // start gaiad server with minimum fees
|
|
|
|
// proc := tests.GoExecuteTWithStdout(t, fmt.Sprintf("gaiad start --home=%s --rpc.laddr=%v --minimum_fees=2feeToken", 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 query account %s %v", fooAddr, flags))
|
|
|
|
// require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
|
|
|
//
|
|
|
|
// success := executeWrite(t, fmt.Sprintf(
|
|
|
|
// "gaiacli tx send %v --amount=10%s --to=%s --from=foo", flags, stakeTypes.DefaultBondDenom, barAddr), app.DefaultKeyPass)
|
|
|
|
// require.False(t, success)
|
|
|
|
// tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
//
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// func TestGaiaCLIFeesDeduction(t *testing.T) {
|
|
|
|
// chainID, servAddr, port := initializeFixtures(t)
|
|
|
|
// flags := fmt.Sprintf("--home=%s --node=%v --chain-id=%v", gaiacliHome, servAddr, chainID)
|
|
|
|
//
|
|
|
|
// // start gaiad server with minimum fees
|
|
|
|
// proc := tests.GoExecuteTWithStdout(t, fmt.Sprintf("gaiad start --home=%s --rpc.laddr=%v --minimum_fees=1fooToken", 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 query account %s %v", fooAddr, flags))
|
|
|
|
// require.Equal(t, int64(1000), fooAcc.GetCoins().AmountOf("fooToken").Int64())
|
|
|
|
//
|
|
|
|
// // test simulation
|
|
|
|
// success := executeWrite(t, fmt.Sprintf(
|
|
|
|
// "gaiacli tx send %v --amount=1000fooToken --to=%s --from=foo --fee=1fooToken --dry-run", flags, barAddr), app.DefaultKeyPass)
|
|
|
|
// require.True(t, success)
|
|
|
|
// tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
// // ensure state didn't change
|
|
|
|
// fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", fooAddr, flags))
|
|
|
|
// require.Equal(t, int64(1000), fooAcc.GetCoins().AmountOf("fooToken").Int64())
|
|
|
|
//
|
|
|
|
// // insufficient funds (coins + fees)
|
|
|
|
// success = executeWrite(t, fmt.Sprintf(
|
|
|
|
// "gaiacli tx send %v --amount=1000fooToken --to=%s --from=foo --fee=1fooToken", flags, barAddr), app.DefaultKeyPass)
|
|
|
|
// require.False(t, success)
|
|
|
|
// tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
// // ensure state didn't change
|
|
|
|
// fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", fooAddr, flags))
|
|
|
|
// require.Equal(t, int64(1000), fooAcc.GetCoins().AmountOf("fooToken").Int64())
|
|
|
|
//
|
|
|
|
// // test success (transfer = coins + fees)
|
|
|
|
// success = executeWrite(t, fmt.Sprintf(
|
|
|
|
// "gaiacli tx send %v --fee=300fooToken --amount=500fooToken --to=%s --from=foo", flags, barAddr), app.DefaultKeyPass)
|
|
|
|
// require.True(t, success)
|
|
|
|
// tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// 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 query account %s %v", fooAddr, flags))
|
|
|
|
// require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
|
|
|
//
|
|
|
|
// executeWrite(t, fmt.Sprintf("gaiacli tx send %v --amount=10%s --to=%s --from=foo", flags, stakeTypes.DefaultBondDenom, barAddr), app.DefaultKeyPass)
|
|
|
|
// tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
//
|
|
|
|
// barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", barAddr, flags))
|
|
|
|
// require.Equal(t, int64(10), barAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
|
|
|
// fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", fooAddr, flags))
|
|
|
|
// require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
|
|
|
//
|
|
|
|
// // Test --dry-run
|
|
|
|
// success := executeWrite(t, fmt.Sprintf("gaiacli tx send %v --amount=10%s --to=%s --from=foo --dry-run", flags, stakeTypes.DefaultBondDenom, barAddr), app.DefaultKeyPass)
|
|
|
|
// require.True(t, success)
|
|
|
|
// // Check state didn't change
|
|
|
|
// fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", fooAddr, flags))
|
|
|
|
// require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
|
|
|
//
|
|
|
|
// // test autosequencing
|
|
|
|
// executeWrite(t, fmt.Sprintf("gaiacli tx send %v --amount=10%s --to=%s --from=foo", flags, stakeTypes.DefaultBondDenom, barAddr), app.DefaultKeyPass)
|
|
|
|
// tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
//
|
|
|
|
// barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", barAddr, flags))
|
|
|
|
// require.Equal(t, int64(20), barAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
|
|
|
// fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", fooAddr, flags))
|
|
|
|
// require.Equal(t, int64(30), fooAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
|
|
|
//
|
|
|
|
// // test memo
|
|
|
|
// executeWrite(t, fmt.Sprintf("gaiacli tx send %v --amount=10%s --to=%s --from=foo --memo 'testmemo'", flags, stakeTypes.DefaultBondDenom, barAddr), app.DefaultKeyPass)
|
|
|
|
// tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
//
|
|
|
|
// barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", barAddr, flags))
|
|
|
|
// require.Equal(t, int64(30), barAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
|
|
|
// fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", fooAddr, flags))
|
|
|
|
// require.Equal(t, int64(20), fooAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).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 query account %s %v", fooAddr, flags))
|
|
|
|
// require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
|
|
|
//
|
|
|
|
// // Test failure with auto gas disabled and very little gas set by hand
|
|
|
|
// success := executeWrite(t, fmt.Sprintf("gaiacli tx send %v --gas=10 --amount=10%s --to=%s --from=foo", flags, stakeTypes.DefaultBondDenom, barAddr), app.DefaultKeyPass)
|
|
|
|
// require.False(t, success)
|
|
|
|
// tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
// // Check state didn't change
|
|
|
|
// fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", fooAddr, flags))
|
|
|
|
// require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
|
|
|
//
|
|
|
|
// // Test failure with negative gas
|
|
|
|
// success = executeWrite(t, fmt.Sprintf("gaiacli tx send %v --gas=-100 --amount=10%s --to=%s --from=foo", flags, stakeTypes.DefaultBondDenom, barAddr), app.DefaultKeyPass)
|
|
|
|
// require.False(t, success)
|
|
|
|
//
|
|
|
|
// // Test failure with 0 gas
|
|
|
|
// success = executeWrite(t, fmt.Sprintf("gaiacli tx send %v --gas=0 --amount=10%s --to=%s --from=foo", flags, stakeTypes.DefaultBondDenom, barAddr), app.DefaultKeyPass)
|
|
|
|
// require.False(t, success)
|
|
|
|
//
|
|
|
|
// // Enable auto gas
|
|
|
|
// success, stdout, _ := executeWriteRetStdStreams(t, fmt.Sprintf("gaiacli tx send %v --json --gas=simulate --amount=10%s --to=%s --from=foo", flags, stakeTypes.DefaultBondDenom, barAddr), app.DefaultKeyPass)
|
|
|
|
// require.True(t, success)
|
|
|
|
// // check that gas wanted == gas used
|
|
|
|
// cdc := app.MakeCodec()
|
|
|
|
// jsonOutput := struct {
|
|
|
|
// Height int64
|
|
|
|
// TxHash string
|
|
|
|
// Response abci.ResponseDeliverTx
|
|
|
|
// }{}
|
|
|
|
// require.Nil(t, cdc.UnmarshalJSON([]byte(stdout), &jsonOutput))
|
|
|
|
// require.Equal(t, jsonOutput.Response.GasWanted, jsonOutput.Response.GasUsed)
|
|
|
|
// tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
// // Check state has changed accordingly
|
|
|
|
// fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", fooAddr, flags))
|
|
|
|
// require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// func TestGaiaCLICreateValidator(t *testing.T) {
|
|
|
|
// chainID, servAddr, port := initializeFixtures(t)
|
|
|
|
// flags := fmt.Sprintf("--home=%s --chain-id=%v --node=%s", gaiacliHome, chainID, servAddr)
|
|
|
|
//
|
|
|
|
// // 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.MustBech32ifyConsPub(barPubKey)
|
|
|
|
//
|
|
|
|
// executeWrite(t, fmt.Sprintf("gaiacli tx send %v --amount=10%s --to=%s --from=foo", flags, stakeTypes.DefaultBondDenom, barAddr), app.DefaultKeyPass)
|
|
|
|
// tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
//
|
|
|
|
// barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", barAddr, flags))
|
|
|
|
// require.Equal(t, int64(10), barAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
|
|
|
// fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", fooAddr, flags))
|
|
|
|
// require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
|
|
|
//
|
|
|
|
// defaultParams := stake.DefaultParams()
|
|
|
|
// initialPool := stake.InitialPool()
|
|
|
|
// initialPool.BondedTokens = initialPool.BondedTokens.Add(sdk.NewDec(100)) // Delegate tx on GaiaAppGenState
|
|
|
|
//
|
|
|
|
// // create validator
|
|
|
|
// cvStr := fmt.Sprintf("gaiacli tx stake create-validator %v", flags)
|
|
|
|
// cvStr += fmt.Sprintf(" --from=%s", "bar")
|
|
|
|
// cvStr += fmt.Sprintf(" --pubkey=%s", barCeshPubKey)
|
|
|
|
// cvStr += fmt.Sprintf(" --amount=%v", fmt.Sprintf("2%s", stakeTypes.DefaultBondDenom))
|
|
|
|
// cvStr += fmt.Sprintf(" --moniker=%v", "bar-vally")
|
|
|
|
// cvStr += fmt.Sprintf(" --commission-rate=%v", "0.05")
|
|
|
|
// cvStr += fmt.Sprintf(" --commission-max-rate=%v", "0.20")
|
|
|
|
// cvStr += fmt.Sprintf(" --commission-max-change-rate=%v", "0.10")
|
|
|
|
//
|
|
|
|
// initialPool.BondedTokens = initialPool.BondedTokens.Add(sdk.NewDec(1))
|
|
|
|
//
|
|
|
|
// // Test --generate-only
|
|
|
|
// success, stdout, stderr := executeWriteRetStdStreams(t, cvStr+" --generate-only", app.DefaultKeyPass)
|
|
|
|
// require.True(t, success)
|
|
|
|
// require.True(t, success)
|
|
|
|
// require.Empty(t, stderr)
|
|
|
|
// msg := unmarshalStdTx(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 = executeWrite(t, cvStr+" --dry-run", app.DefaultKeyPass)
|
|
|
|
// require.True(t, success)
|
|
|
|
//
|
|
|
|
// executeWrite(t, cvStr, app.DefaultKeyPass)
|
|
|
|
// tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
//
|
|
|
|
// barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", barAddr, flags))
|
|
|
|
// require.Equal(t, int64(8), barAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64(), "%v", barAcc)
|
|
|
|
//
|
|
|
|
// validator := executeGetValidator(t, fmt.Sprintf("gaiacli query stake validator %s --output=json %v", sdk.ValAddress(barAddr), flags))
|
|
|
|
// require.Equal(t, validator.OperatorAddr, sdk.ValAddress(barAddr))
|
|
|
|
// require.True(sdk.DecEq(t, sdk.NewDec(2), validator.Tokens))
|
|
|
|
//
|
|
|
|
// validatorDelegations := executeGetValidatorDelegations(t, fmt.Sprintf("gaiacli query stake delegations-to %s --output=json %v", sdk.ValAddress(barAddr), flags))
|
|
|
|
// require.Len(t, validatorDelegations, 1)
|
|
|
|
// require.NotZero(t, validatorDelegations[0].Shares)
|
|
|
|
//
|
|
|
|
// // unbond a single share
|
|
|
|
// unbondStr := fmt.Sprintf("gaiacli tx stake unbond begin %v", flags)
|
|
|
|
// unbondStr += fmt.Sprintf(" --from=%s", "bar")
|
|
|
|
// unbondStr += fmt.Sprintf(" --validator=%s", sdk.ValAddress(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 query account %v %v", barCech, flags))
|
|
|
|
// require.Equal(t, int64(9), barAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64(), "%v", barAcc)
|
|
|
|
// */
|
|
|
|
// validator = executeGetValidator(t, fmt.Sprintf("gaiacli query stake validator %s --output=json %v", sdk.ValAddress(barAddr), flags))
|
|
|
|
// require.Equal(t, "1.0000000000", validator.Tokens.String())
|
|
|
|
//
|
|
|
|
// validatorUbds := executeGetValidatorUnbondingDelegations(t,
|
|
|
|
// fmt.Sprintf("gaiacli query stake unbonding-delegations-from %s --output=json %v",
|
|
|
|
// sdk.ValAddress(barAddr), flags))
|
|
|
|
// require.Len(t, validatorUbds, 1)
|
|
|
|
// require.Equal(t, "1", validatorUbds[0].Balance.Amount.String())
|
|
|
|
//
|
|
|
|
// params := executeGetParams(t, fmt.Sprintf("gaiacli query stake parameters --output=json %v", flags))
|
|
|
|
// require.True(t, defaultParams.Equal(params))
|
|
|
|
//
|
|
|
|
// pool := executeGetPool(t, fmt.Sprintf("gaiacli query stake pool --output=json %v", flags))
|
|
|
|
// require.Equal(t, initialPool.BondedTokens, pool.BondedTokens)
|
|
|
|
// }
|
2018-04-13 13:08:06 -07:00
|
|
|
|
2018-06-21 17:19:14 -07:00
|
|
|
func TestGaiaCLISubmitProposal(t *testing.T) {
|
2018-08-22 04:38:55 -07:00
|
|
|
chainID, servAddr, port := initializeFixtures(t)
|
2018-07-05 09:08:43 -07:00
|
|
|
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))
|
|
|
|
|
2018-06-21 17:19:14 -07:00
|
|
|
defer proc.Stop(false)
|
2018-07-02 21:33:53 -07:00
|
|
|
tests.WaitForTMStart(port)
|
2018-07-12 13:03:18 -07:00
|
|
|
tests.WaitForNextNBlocksTM(2, port)
|
2018-06-21 17:19:14 -07:00
|
|
|
|
2018-11-13 15:45:37 -08:00
|
|
|
executeGetDepositParam(t, fmt.Sprintf("gaiacli query gov param deposit %v", flags))
|
|
|
|
executeGetVotingParam(t, fmt.Sprintf("gaiacli query gov param voting %v", flags))
|
|
|
|
executeGetTallyingParam(t, fmt.Sprintf("gaiacli query gov param tallying %v", flags))
|
|
|
|
|
2018-07-03 23:25:31 -07:00
|
|
|
fooAddr, _ := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show foo --output=json --home=%s", gaiacliHome))
|
2018-06-21 17:19:14 -07:00
|
|
|
|
2018-09-26 07:00:49 -07:00
|
|
|
fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", fooAddr, flags))
|
2018-11-12 10:54:18 -08:00
|
|
|
require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
2018-06-21 17:19:14 -07:00
|
|
|
|
2018-11-07 16:42:34 -08:00
|
|
|
proposalsQuery, _ := tests.ExecuteT(t, fmt.Sprintf("gaiacli query gov proposals %v", flags), "")
|
2018-07-30 16:48:00 -07:00
|
|
|
require.Equal(t, "No matching proposals found", proposalsQuery)
|
|
|
|
|
|
|
|
// submit a test proposal
|
2018-11-07 16:42:34 -08:00
|
|
|
spStr := fmt.Sprintf("gaiacli tx gov submit-proposal %v", flags)
|
2018-07-18 23:53:12 -07:00
|
|
|
spStr += fmt.Sprintf(" --from=%s", "foo")
|
2018-11-12 10:54:18 -08:00
|
|
|
spStr += fmt.Sprintf(" --deposit=%s", fmt.Sprintf("5%s", stakeTypes.DefaultBondDenom))
|
2018-07-18 23:53:12 -07:00
|
|
|
spStr += fmt.Sprintf(" --type=%s", "Text")
|
|
|
|
spStr += fmt.Sprintf(" --title=%s", "Test")
|
|
|
|
spStr += fmt.Sprintf(" --description=%s", "test")
|
|
|
|
|
2018-09-02 11:20:14 -07:00
|
|
|
// Test generate only
|
|
|
|
success, stdout, stderr := executeWriteRetStdStreams(t, spStr+" --generate-only", app.DefaultKeyPass)
|
|
|
|
require.True(t, success)
|
|
|
|
require.True(t, success)
|
|
|
|
require.Empty(t, stderr)
|
|
|
|
msg := unmarshalStdTx(t, stdout)
|
|
|
|
require.NotZero(t, msg.Fee.Gas)
|
|
|
|
require.Equal(t, len(msg.Msgs), 1)
|
2018-09-04 05:57:40 -07:00
|
|
|
require.Equal(t, 0, len(msg.GetSignatures()))
|
2018-09-02 11:20:14 -07:00
|
|
|
|
2018-08-31 10:04:11 -07:00
|
|
|
// Test --dry-run
|
2018-09-02 11:20:14 -07:00
|
|
|
success = executeWrite(t, spStr+" --dry-run", app.DefaultKeyPass)
|
2018-08-31 10:04:11 -07:00
|
|
|
require.True(t, success)
|
|
|
|
|
2018-08-01 12:15:37 -07:00
|
|
|
executeWrite(t, spStr, app.DefaultKeyPass)
|
2018-07-12 13:03:18 -07:00
|
|
|
tests.WaitForNextNBlocksTM(2, port)
|
2018-06-21 17:19:14 -07:00
|
|
|
|
2018-11-26 06:55:42 -08:00
|
|
|
txs := executeGetTxs(t, fmt.Sprintf("gaiacli query txs --tag='action=submit-proposal&proposer=%s' %v", fooAddr, flags))
|
|
|
|
require.Len(t, txs, 1)
|
2018-11-20 05:13:05 -08:00
|
|
|
|
2018-09-26 07:00:49 -07:00
|
|
|
fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", fooAddr, flags))
|
2018-11-12 10:54:18 -08:00
|
|
|
require.Equal(t, int64(45), fooAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
2018-06-21 17:19:14 -07:00
|
|
|
|
2018-11-07 16:42:34 -08:00
|
|
|
proposal1 := executeGetProposal(t, fmt.Sprintf("gaiacli query gov proposal --proposal-id=1 --output=json %v", flags))
|
2018-11-06 23:33:18 -08:00
|
|
|
require.Equal(t, uint64(1), proposal1.GetProposalID())
|
2018-07-10 17:59:07 -07:00
|
|
|
require.Equal(t, gov.StatusDepositPeriod, proposal1.GetStatus())
|
2018-06-21 17:19:14 -07:00
|
|
|
|
2018-11-07 16:42:34 -08:00
|
|
|
proposalsQuery, _ = tests.ExecuteT(t, fmt.Sprintf("gaiacli query gov proposals %v", flags), "")
|
2018-07-30 16:48:00 -07:00
|
|
|
require.Equal(t, " 1 - Test", proposalsQuery)
|
|
|
|
|
2018-10-23 07:28:10 -07:00
|
|
|
deposit := executeGetDeposit(t,
|
2018-11-21 15:53:33 -08:00
|
|
|
fmt.Sprintf("gaiacli query gov deposit --proposal-id=1 --depositor=%s --output=json %v",
|
2018-10-23 10:49:34 -07:00
|
|
|
fooAddr, flags))
|
2018-11-12 10:54:18 -08:00
|
|
|
require.Equal(t, int64(5), deposit.Amount.AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
2018-10-23 07:28:10 -07:00
|
|
|
|
2018-11-07 16:42:34 -08:00
|
|
|
depositStr := fmt.Sprintf("gaiacli tx gov deposit %v", flags)
|
2018-07-18 23:53:12 -07:00
|
|
|
depositStr += fmt.Sprintf(" --from=%s", "foo")
|
2018-11-12 10:54:18 -08:00
|
|
|
depositStr += fmt.Sprintf(" --deposit=%s", fmt.Sprintf("10%s", stakeTypes.DefaultBondDenom))
|
2018-07-19 12:37:57 -07:00
|
|
|
depositStr += fmt.Sprintf(" --proposal-id=%s", "1")
|
2018-07-18 23:53:12 -07:00
|
|
|
|
2018-09-02 11:20:14 -07:00
|
|
|
// Test generate only
|
|
|
|
success, stdout, stderr = executeWriteRetStdStreams(t, depositStr+" --generate-only", app.DefaultKeyPass)
|
|
|
|
require.True(t, success)
|
|
|
|
require.True(t, success)
|
|
|
|
require.Empty(t, stderr)
|
|
|
|
msg = unmarshalStdTx(t, stdout)
|
|
|
|
require.NotZero(t, msg.Fee.Gas)
|
|
|
|
require.Equal(t, len(msg.Msgs), 1)
|
2018-09-04 05:57:40 -07:00
|
|
|
require.Equal(t, 0, len(msg.GetSignatures()))
|
2018-09-02 11:20:14 -07:00
|
|
|
|
2018-08-01 12:15:37 -07:00
|
|
|
executeWrite(t, depositStr, app.DefaultKeyPass)
|
2018-07-12 13:03:18 -07:00
|
|
|
tests.WaitForNextNBlocksTM(2, port)
|
2018-06-21 17:19:14 -07:00
|
|
|
|
2018-10-23 07:07:28 -07:00
|
|
|
// test query deposit
|
|
|
|
deposits := executeGetDeposits(t,
|
2018-11-07 16:42:34 -08:00
|
|
|
fmt.Sprintf("gaiacli query gov deposits --proposal-id=1 --output=json %v", flags))
|
2018-10-23 07:28:10 -07:00
|
|
|
require.Len(t, deposits, 1)
|
2018-11-12 10:54:18 -08:00
|
|
|
require.Equal(t, int64(15), deposits[0].Amount.AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
2018-10-23 07:07:28 -07:00
|
|
|
|
2018-10-23 07:28:10 -07:00
|
|
|
deposit = executeGetDeposit(t,
|
2018-11-21 15:53:33 -08:00
|
|
|
fmt.Sprintf("gaiacli query gov deposit --proposal-id=1 --depositor=%s --output=json %v",
|
2018-10-23 10:49:34 -07:00
|
|
|
fooAddr, flags))
|
2018-11-12 10:54:18 -08:00
|
|
|
require.Equal(t, int64(15), deposit.Amount.AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
2018-10-23 07:07:28 -07:00
|
|
|
|
2018-09-26 07:00:49 -07:00
|
|
|
fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", fooAddr, flags))
|
2018-11-12 11:10:52 -08:00
|
|
|
|
2018-11-12 10:54:18 -08:00
|
|
|
require.Equal(t, int64(35), fooAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
2018-11-07 16:42:34 -08:00
|
|
|
proposal1 = executeGetProposal(t, fmt.Sprintf("gaiacli query gov proposal --proposal-id=1 --output=json %v", flags))
|
2018-11-06 23:33:18 -08:00
|
|
|
require.Equal(t, uint64(1), proposal1.GetProposalID())
|
2018-07-10 17:59:07 -07:00
|
|
|
require.Equal(t, gov.StatusVotingPeriod, proposal1.GetStatus())
|
2018-06-21 17:19:14 -07:00
|
|
|
|
2018-11-07 16:42:34 -08:00
|
|
|
voteStr := fmt.Sprintf("gaiacli tx gov vote %v", flags)
|
2018-07-18 23:53:12 -07:00
|
|
|
voteStr += fmt.Sprintf(" --from=%s", "foo")
|
2018-07-19 12:37:57 -07:00
|
|
|
voteStr += fmt.Sprintf(" --proposal-id=%s", "1")
|
2018-07-18 23:53:12 -07:00
|
|
|
voteStr += fmt.Sprintf(" --option=%s", "Yes")
|
|
|
|
|
2018-09-02 11:20:14 -07:00
|
|
|
// Test generate only
|
|
|
|
success, stdout, stderr = executeWriteRetStdStreams(t, voteStr+" --generate-only", app.DefaultKeyPass)
|
|
|
|
require.True(t, success)
|
|
|
|
require.True(t, success)
|
|
|
|
require.Empty(t, stderr)
|
|
|
|
msg = unmarshalStdTx(t, stdout)
|
|
|
|
require.NotZero(t, msg.Fee.Gas)
|
|
|
|
require.Equal(t, len(msg.Msgs), 1)
|
2018-09-04 05:57:40 -07:00
|
|
|
require.Equal(t, 0, len(msg.GetSignatures()))
|
2018-09-02 11:20:14 -07:00
|
|
|
|
2018-08-01 12:15:37 -07:00
|
|
|
executeWrite(t, voteStr, app.DefaultKeyPass)
|
2018-07-12 13:03:18 -07:00
|
|
|
tests.WaitForNextNBlocksTM(2, port)
|
2018-06-21 17:19:14 -07:00
|
|
|
|
2018-11-07 16:42:34 -08:00
|
|
|
vote := executeGetVote(t, fmt.Sprintf("gaiacli query gov vote --proposal-id=1 --voter=%s --output=json %v", fooAddr, flags))
|
2018-11-06 23:33:18 -08:00
|
|
|
require.Equal(t, uint64(1), vote.ProposalID)
|
2018-07-10 17:59:07 -07:00
|
|
|
require.Equal(t, gov.OptionYes, vote.Option)
|
2018-07-19 17:02:46 -07:00
|
|
|
|
2018-11-07 16:42:34 -08:00
|
|
|
votes := executeGetVotes(t, fmt.Sprintf("gaiacli query gov votes --proposal-id=1 --output=json %v", flags))
|
2018-07-19 17:02:46 -07:00
|
|
|
require.Len(t, votes, 1)
|
2018-11-06 23:33:18 -08:00
|
|
|
require.Equal(t, uint64(1), votes[0].ProposalID)
|
2018-07-19 17:02:46 -07:00
|
|
|
require.Equal(t, gov.OptionYes, votes[0].Option)
|
2018-07-30 16:48:00 -07:00
|
|
|
|
2018-11-07 16:42:34 -08:00
|
|
|
proposalsQuery, _ = tests.ExecuteT(t, fmt.Sprintf("gaiacli query gov proposals --status=DepositPeriod %v", flags), "")
|
2018-07-30 16:48:00 -07:00
|
|
|
require.Equal(t, "No matching proposals found", proposalsQuery)
|
|
|
|
|
2018-11-07 16:42:34 -08:00
|
|
|
proposalsQuery, _ = tests.ExecuteT(t, fmt.Sprintf("gaiacli query gov proposals --status=VotingPeriod %v", flags), "")
|
2018-07-30 16:48:00 -07:00
|
|
|
require.Equal(t, " 1 - Test", proposalsQuery)
|
|
|
|
|
|
|
|
// submit a second test proposal
|
2018-11-07 16:42:34 -08:00
|
|
|
spStr = fmt.Sprintf("gaiacli tx gov submit-proposal %v", flags)
|
2018-07-30 16:48:00 -07:00
|
|
|
spStr += fmt.Sprintf(" --from=%s", "foo")
|
2018-11-12 10:54:18 -08:00
|
|
|
spStr += fmt.Sprintf(" --deposit=%s", fmt.Sprintf("5%s", stakeTypes.DefaultBondDenom))
|
2018-07-30 16:48:00 -07:00
|
|
|
spStr += fmt.Sprintf(" --type=%s", "Text")
|
|
|
|
spStr += fmt.Sprintf(" --title=%s", "Apples")
|
|
|
|
spStr += fmt.Sprintf(" --description=%s", "test")
|
|
|
|
|
2018-08-01 12:15:37 -07:00
|
|
|
executeWrite(t, spStr, app.DefaultKeyPass)
|
2018-07-30 16:48:00 -07:00
|
|
|
tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
|
2018-11-07 16:42:34 -08:00
|
|
|
proposalsQuery, _ = tests.ExecuteT(t, fmt.Sprintf("gaiacli query gov proposals --limit=1 %v", flags), "")
|
2018-07-30 16:48:00 -07:00
|
|
|
require.Equal(t, " 2 - Apples", proposalsQuery)
|
2018-06-21 17:19:14 -07:00
|
|
|
}
|
|
|
|
|
2018-11-26 06:55:42 -08:00
|
|
|
// func TestGaiaCLISendGenerateSignAndBroadcast(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))
|
|
|
|
//
|
|
|
|
// // Test generate sendTx with default gas
|
|
|
|
// success, stdout, stderr := executeWriteRetStdStreams(t, fmt.Sprintf(
|
|
|
|
// "gaiacli tx send %v --amount=10%s --to=%s --from=foo --generate-only",
|
|
|
|
// flags, stakeTypes.DefaultBondDenom, barAddr), []string{}...)
|
|
|
|
// require.True(t, success)
|
|
|
|
// require.Empty(t, stderr)
|
|
|
|
// msg := unmarshalStdTx(t, stdout)
|
|
|
|
// require.Equal(t, msg.Fee.Gas, uint64(client.DefaultGasLimit))
|
|
|
|
// require.Equal(t, len(msg.Msgs), 1)
|
|
|
|
// require.Equal(t, 0, len(msg.GetSignatures()))
|
|
|
|
//
|
|
|
|
// // Test generate sendTx with --gas=$amount
|
|
|
|
// success, stdout, stderr = executeWriteRetStdStreams(t, fmt.Sprintf(
|
|
|
|
// "gaiacli tx send %v --amount=10%s --to=%s --from=foo --gas=100 --generate-only",
|
|
|
|
// flags, stakeTypes.DefaultBondDenom, barAddr), []string{}...)
|
|
|
|
// require.True(t, success)
|
|
|
|
// require.Empty(t, stderr)
|
|
|
|
// msg = unmarshalStdTx(t, stdout)
|
|
|
|
// require.Equal(t, msg.Fee.Gas, uint64(100))
|
|
|
|
// require.Equal(t, len(msg.Msgs), 1)
|
|
|
|
// require.Equal(t, 0, len(msg.GetSignatures()))
|
|
|
|
//
|
|
|
|
// // Test generate sendTx, estimate gas
|
|
|
|
// success, stdout, stderr = executeWriteRetStdStreams(t, fmt.Sprintf(
|
|
|
|
// "gaiacli tx send %v --amount=10%s --to=%s --from=foo --gas=simulate --generate-only",
|
|
|
|
// flags, stakeTypes.DefaultBondDenom, barAddr), []string{}...)
|
|
|
|
// require.True(t, success)
|
|
|
|
// require.NotEmpty(t, stderr)
|
|
|
|
// msg = unmarshalStdTx(t, stdout)
|
|
|
|
// require.True(t, msg.Fee.Gas > 0)
|
|
|
|
// require.Equal(t, len(msg.Msgs), 1)
|
|
|
|
//
|
|
|
|
// // Write the output to disk
|
|
|
|
// unsignedTxFile := writeToNewTempFile(t, stdout)
|
|
|
|
// defer os.Remove(unsignedTxFile.Name())
|
|
|
|
//
|
|
|
|
// // Test sign --validate-signatures
|
|
|
|
// success, stdout, _ = executeWriteRetStdStreams(t, fmt.Sprintf(
|
|
|
|
// "gaiacli tx sign %v --validate-signatures %v", flags, unsignedTxFile.Name()))
|
|
|
|
// require.False(t, success)
|
|
|
|
// require.Equal(t, fmt.Sprintf("Signers:\n 0: %v\n\nSignatures:\n\n", fooAddr.String()), stdout)
|
|
|
|
//
|
|
|
|
// // Test sign
|
|
|
|
// success, stdout, _ = executeWriteRetStdStreams(t, fmt.Sprintf(
|
|
|
|
// "gaiacli tx sign %v --name=foo %v", flags, unsignedTxFile.Name()), app.DefaultKeyPass)
|
|
|
|
// require.True(t, success)
|
|
|
|
// msg = unmarshalStdTx(t, stdout)
|
|
|
|
// require.Equal(t, len(msg.Msgs), 1)
|
|
|
|
// require.Equal(t, 1, len(msg.GetSignatures()))
|
|
|
|
// require.Equal(t, fooAddr.String(), msg.GetSigners()[0].String())
|
|
|
|
//
|
|
|
|
// // Write the output to disk
|
|
|
|
// signedTxFile := writeToNewTempFile(t, stdout)
|
|
|
|
// defer os.Remove(signedTxFile.Name())
|
|
|
|
//
|
|
|
|
// // Test sign --print-signatures
|
|
|
|
// success, stdout, _ = executeWriteRetStdStreams(t, fmt.Sprintf(
|
|
|
|
// "gaiacli tx sign %v --validate-signatures %v", flags, signedTxFile.Name()))
|
|
|
|
// require.True(t, success)
|
|
|
|
// require.Equal(t, fmt.Sprintf("Signers:\n 0: %v\n\nSignatures:\n 0: %v\t[OK]\n\n", fooAddr.String(),
|
|
|
|
// fooAddr.String()), stdout)
|
|
|
|
//
|
|
|
|
// // Test broadcast
|
|
|
|
// fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", fooAddr, flags))
|
|
|
|
// require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
|
|
|
//
|
|
|
|
// success, stdout, _ = executeWriteRetStdStreams(t, fmt.Sprintf(
|
|
|
|
// "gaiacli tx broadcast %v --json %v", flags, signedTxFile.Name()))
|
|
|
|
// require.True(t, success)
|
|
|
|
//
|
|
|
|
// var result struct {
|
|
|
|
// Response abci.ResponseDeliverTx
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// require.Nil(t, app.MakeCodec().UnmarshalJSON([]byte(stdout), &result))
|
|
|
|
// require.Equal(t, msg.Fee.Gas, uint64(result.Response.GasUsed))
|
|
|
|
// require.Equal(t, msg.Fee.Gas, uint64(result.Response.GasWanted))
|
|
|
|
// tests.WaitForNextNBlocksTM(2, port)
|
|
|
|
//
|
|
|
|
// barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", barAddr, flags))
|
|
|
|
// require.Equal(t, int64(10), barAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
|
|
|
//
|
|
|
|
// fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli query account %s %v", fooAddr, flags))
|
|
|
|
// require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf(stakeTypes.DefaultBondDenom).Int64())
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// func TestGaiaCLIConfig(t *testing.T) {
|
|
|
|
// require.NoError(t, os.RemoveAll(gaiacliHome))
|
|
|
|
// require.NoError(t, os.RemoveAll(gaiadHome))
|
|
|
|
// servAddr, port, err := server.FreeTCPAddr()
|
|
|
|
// require.NoError(t, err)
|
|
|
|
// node := fmt.Sprintf("%s:%s", servAddr, port)
|
|
|
|
// chainID := executeInit(t, fmt.Sprintf("gaiad init -o --moniker=foo --home=%s", gaiadHome))
|
|
|
|
// executeWrite(t, fmt.Sprintf("gaiacli --home=%s config", gaiadHome), gaiacliHome, node, "y")
|
|
|
|
// config, err := ioutil.ReadFile(path.Join(gaiacliHome, "config", "config.toml"))
|
|
|
|
// require.NoError(t, err)
|
|
|
|
// expectedConfig := fmt.Sprintf(`chain_id = "%s"
|
|
|
|
// home = "%s"
|
|
|
|
// node = "%s"
|
|
|
|
// output = "text"
|
|
|
|
// trace = false
|
|
|
|
// trust_node = true
|
|
|
|
// `, chainID, gaiacliHome, node)
|
|
|
|
// require.Equal(t, expectedConfig, string(config))
|
|
|
|
// // ensure a backup gets created
|
|
|
|
// executeWrite(t, "gaiacli config", gaiacliHome, node, "y", "y")
|
|
|
|
// configBackup, err := ioutil.ReadFile(path.Join(gaiacliHome, "config", "config.toml-old"))
|
|
|
|
// require.NoError(t, err)
|
|
|
|
// require.Equal(t, expectedConfig, string(configBackup))
|
|
|
|
//
|
|
|
|
// require.NoError(t, os.RemoveAll(gaiadHome))
|
|
|
|
// executeWrite(t, "gaiacli config", gaiacliHome, node, "y")
|
|
|
|
//
|
|
|
|
// // ensure it works without an initialized gaiad state
|
|
|
|
// expectedConfig = fmt.Sprintf(`chain_id = ""
|
|
|
|
// home = "%s"
|
|
|
|
// node = "%s"
|
|
|
|
// output = "text"
|
|
|
|
// trace = false
|
|
|
|
// trust_node = true
|
|
|
|
// `, gaiacliHome, node)
|
|
|
|
// config, err = ioutil.ReadFile(path.Join(gaiacliHome, "config", "config.toml"))
|
|
|
|
// require.NoError(t, err)
|
|
|
|
// require.Equal(t, expectedConfig, string(config))
|
|
|
|
// }
|
2018-09-25 14:36:42 -07:00
|
|
|
|
2018-07-03 23:25:31 -07:00
|
|
|
//___________________________________________________________________________________
|
|
|
|
// helper methods
|
|
|
|
|
|
|
|
func getTestingHomeDirs() (string, string) {
|
2018-07-04 13:09:59 -07:00
|
|
|
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))
|
2018-07-03 23:25:31 -07:00
|
|
|
return gaiadHome, gaiacliHome
|
|
|
|
}
|
|
|
|
|
2018-08-22 04:38:55 -07:00
|
|
|
func initializeFixtures(t *testing.T) (chainID, servAddr, port string) {
|
|
|
|
tests.ExecuteT(t, fmt.Sprintf("gaiad --home=%s unsafe-reset-all", gaiadHome), "")
|
2018-11-26 03:50:33 -08:00
|
|
|
os.RemoveAll(filepath.Join(gaiadHome, "config", "gentx"))
|
2018-08-22 04:38:55 -07:00
|
|
|
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)
|
2018-11-26 03:50:33 -08:00
|
|
|
executeWriteCheckErr(t, fmt.Sprintf("gaiacli keys add --home=%s foo", gaiacliHome), app.DefaultKeyPass)
|
|
|
|
executeWriteCheckErr(t, fmt.Sprintf("gaiacli keys add --home=%s bar", gaiacliHome), app.DefaultKeyPass)
|
2018-11-04 20:26:46 -08:00
|
|
|
fooAddr, _ := executeGetAddrPK(t, fmt.Sprintf(
|
|
|
|
"gaiacli keys show foo --output=json --home=%s", gaiacliHome))
|
|
|
|
chainID = executeInit(t, fmt.Sprintf("gaiad init -o --moniker=foo --home=%s", gaiadHome))
|
|
|
|
genFile := filepath.Join(gaiadHome, "config", "genesis.json")
|
|
|
|
genDoc := readGenesisFile(t, genFile)
|
|
|
|
var appState app.GenesisState
|
|
|
|
err := codec.Cdc.UnmarshalJSON(genDoc.AppState, &appState)
|
|
|
|
require.NoError(t, err)
|
|
|
|
appState.Accounts = []app.GenesisAccount{app.NewDefaultGenesisAccount(fooAddr)}
|
|
|
|
appStateJSON, err := codec.Cdc.MarshalJSON(appState)
|
|
|
|
require.NoError(t, err)
|
|
|
|
genDoc.AppState = appStateJSON
|
|
|
|
genDoc.SaveAs(genFile)
|
2018-11-26 03:50:33 -08:00
|
|
|
executeWriteCheckErr(t, fmt.Sprintf(
|
2018-11-04 20:26:46 -08:00
|
|
|
"gaiad gentx --name=foo --home=%s --home-client=%s", gaiadHome, gaiacliHome),
|
|
|
|
app.DefaultKeyPass)
|
2018-11-26 03:50:33 -08:00
|
|
|
executeWriteCheckErr(t, fmt.Sprintf("gaiad collect-gentxs --home=%s", gaiadHome), app.DefaultKeyPass)
|
2018-08-22 04:38:55 -07:00
|
|
|
// get a free port, also setup some common flags
|
2018-11-04 20:26:46 -08:00
|
|
|
servAddr, port, err = server.FreeTCPAddr()
|
2018-08-22 04:38:55 -07:00
|
|
|
require.NoError(t, err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-09-02 11:20:14 -07:00
|
|
|
func unmarshalStdTx(t *testing.T, s string) (stdTx auth.StdTx) {
|
|
|
|
cdc := app.MakeCodec()
|
|
|
|
require.Nil(t, cdc.UnmarshalJSON([]byte(s), &stdTx))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-09-07 03:59:16 -07:00
|
|
|
func writeToNewTempFile(t *testing.T, s string) *os.File {
|
|
|
|
fp, err := ioutil.TempFile(os.TempDir(), "cosmos_cli_test_")
|
|
|
|
require.Nil(t, err)
|
|
|
|
_, err = fp.WriteString(s)
|
|
|
|
require.Nil(t, err)
|
|
|
|
return fp
|
|
|
|
}
|
|
|
|
|
2018-11-04 20:26:46 -08:00
|
|
|
func readGenesisFile(t *testing.T, genFile string) types.GenesisDoc {
|
|
|
|
var genDoc types.GenesisDoc
|
|
|
|
fp, err := os.Open(genFile)
|
|
|
|
require.NoError(t, err)
|
|
|
|
fileContents, err := ioutil.ReadAll(fp)
|
|
|
|
require.NoError(t, err)
|
|
|
|
defer fp.Close()
|
|
|
|
err = codec.Cdc.UnmarshalJSON(fileContents, &genDoc)
|
|
|
|
require.NoError(t, err)
|
|
|
|
return genDoc
|
|
|
|
}
|
|
|
|
|
2018-05-31 12:10:12 -07:00
|
|
|
//___________________________________________________________________________________
|
|
|
|
// executors
|
|
|
|
|
2018-11-26 03:50:33 -08:00
|
|
|
func executeWriteCheckErr(t *testing.T, cmdStr string, writes ...string) {
|
|
|
|
require.True(t, executeWrite(t, cmdStr, writes...))
|
|
|
|
}
|
|
|
|
|
2018-08-22 04:38:55 -07:00
|
|
|
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) {
|
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-07-02 21:33:53 -07:00
|
|
|
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)))
|
|
|
|
}
|
|
|
|
|
2018-05-31 04:16:05 -07:00
|
|
|
proc.Wait()
|
2018-08-22 04:38:55 -07:00
|
|
|
return proc.ExitState.Success(), string(stdout), string(stderr)
|
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-10-19 11:00:27 -07:00
|
|
|
_, stderr := tests.ExecuteT(t, cmdStr, app.DefaultKeyPass)
|
2018-04-13 16:45:26 -07:00
|
|
|
|
2018-04-14 00:16:49 -07:00
|
|
|
var initRes map[string]json.RawMessage
|
2018-10-19 11:00:27 -07:00
|
|
|
err := json.Unmarshal([]byte(stderr), &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-07-06 00:06:53 -07:00
|
|
|
func executeGetAddrPK(t *testing.T, cmdStr string) (sdk.AccAddress, crypto.PubKey) {
|
2018-10-19 11:00:27 -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
|
|
|
pk, err := sdk.GetAccPubKeyBech32(ko.PubKey)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
2018-08-30 21:06:44 -07:00
|
|
|
accAddr, err := sdk.AccAddressFromBech32(ko.Address)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
return accAddr, 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-10-19 11:00:27 -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-09-13 11:17:32 -07:00
|
|
|
cdc := codec.New()
|
|
|
|
codec.RegisterCrypto(cdc)
|
2018-04-25 13:38:13 -07:00
|
|
|
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-11-20 05:13:05 -08:00
|
|
|
//___________________________________________________________________________________
|
|
|
|
// txs
|
|
|
|
|
|
|
|
func executeGetTxs(t *testing.T, cmdStr string) []tx.Info {
|
|
|
|
out, _ := tests.ExecuteT(t, cmdStr, "")
|
|
|
|
var txs []tx.Info
|
|
|
|
cdc := app.MakeCodec()
|
|
|
|
err := cdc.UnmarshalJSON([]byte(out), &txs)
|
|
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
|
|
|
return txs
|
|
|
|
}
|
|
|
|
|
2018-08-21 08:32:54 -07:00
|
|
|
//___________________________________________________________________________________
|
|
|
|
// stake
|
|
|
|
|
2018-05-31 12:10:12 -07:00
|
|
|
func executeGetValidator(t *testing.T, cmdStr string) stake.Validator {
|
2018-10-19 11:00:27 -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
|
|
|
|
2018-10-28 14:28:12 -07:00
|
|
|
func executeGetValidatorUnbondingDelegations(t *testing.T, cmdStr string) []stake.UnbondingDelegation {
|
|
|
|
out, _ := tests.ExecuteT(t, cmdStr, "")
|
|
|
|
var ubds []stake.UnbondingDelegation
|
|
|
|
cdc := app.MakeCodec()
|
|
|
|
err := cdc.UnmarshalJSON([]byte(out), &ubds)
|
|
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
|
|
|
return ubds
|
|
|
|
}
|
|
|
|
|
|
|
|
func executeGetValidatorRedelegations(t *testing.T, cmdStr string) []stake.Redelegation {
|
|
|
|
out, _ := tests.ExecuteT(t, cmdStr, "")
|
|
|
|
var reds []stake.Redelegation
|
|
|
|
cdc := app.MakeCodec()
|
|
|
|
err := cdc.UnmarshalJSON([]byte(out), &reds)
|
|
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
|
|
|
return reds
|
|
|
|
}
|
|
|
|
|
2018-10-23 01:25:53 -07:00
|
|
|
func executeGetValidatorDelegations(t *testing.T, cmdStr string) []stake.Delegation {
|
|
|
|
out, _ := tests.ExecuteT(t, cmdStr, "")
|
|
|
|
var delegations []stake.Delegation
|
|
|
|
cdc := app.MakeCodec()
|
|
|
|
err := cdc.UnmarshalJSON([]byte(out), &delegations)
|
|
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
|
|
|
return delegations
|
|
|
|
}
|
|
|
|
|
2018-08-21 08:32:54 -07:00
|
|
|
func executeGetPool(t *testing.T, cmdStr string) stake.Pool {
|
2018-10-19 11:00:27 -07:00
|
|
|
out, _ := tests.ExecuteT(t, cmdStr, "")
|
2018-08-21 08:32:54 -07:00
|
|
|
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 {
|
2018-10-19 11:00:27 -07:00
|
|
|
out, _ := tests.ExecuteT(t, cmdStr, "")
|
2018-08-21 08:32:54 -07:00
|
|
|
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
|
|
|
|
|
2018-11-13 15:45:37 -08:00
|
|
|
func executeGetDepositParam(t *testing.T, cmdStr string) gov.DepositParams {
|
|
|
|
out, _ := tests.ExecuteT(t, cmdStr, "")
|
|
|
|
var depositParam gov.DepositParams
|
|
|
|
cdc := app.MakeCodec()
|
|
|
|
err := cdc.UnmarshalJSON([]byte(out), &depositParam)
|
|
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
|
|
|
return depositParam
|
|
|
|
}
|
|
|
|
|
|
|
|
func executeGetVotingParam(t *testing.T, cmdStr string) gov.VotingParams {
|
|
|
|
out, _ := tests.ExecuteT(t, cmdStr, "")
|
|
|
|
var votingParam gov.VotingParams
|
|
|
|
cdc := app.MakeCodec()
|
|
|
|
err := cdc.UnmarshalJSON([]byte(out), &votingParam)
|
|
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
|
|
|
return votingParam
|
|
|
|
}
|
|
|
|
|
|
|
|
func executeGetTallyingParam(t *testing.T, cmdStr string) gov.TallyParams {
|
|
|
|
out, _ := tests.ExecuteT(t, cmdStr, "")
|
|
|
|
var tallyingParam gov.TallyParams
|
|
|
|
cdc := app.MakeCodec()
|
|
|
|
err := cdc.UnmarshalJSON([]byte(out), &tallyingParam)
|
|
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
|
|
|
return tallyingParam
|
|
|
|
}
|
|
|
|
|
2018-07-10 17:59:07 -07:00
|
|
|
func executeGetProposal(t *testing.T, cmdStr string) gov.Proposal {
|
2018-10-19 11:00:27 -07:00
|
|
|
out, _ := tests.ExecuteT(t, cmdStr, "")
|
2018-07-10 17:59:07 -07:00
|
|
|
var proposal gov.Proposal
|
2018-06-21 17:19:14 -07:00
|
|
|
cdc := app.MakeCodec()
|
|
|
|
err := cdc.UnmarshalJSON([]byte(out), &proposal)
|
|
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
|
|
|
return proposal
|
|
|
|
}
|
|
|
|
|
2018-07-10 17:59:07 -07:00
|
|
|
func executeGetVote(t *testing.T, cmdStr string) gov.Vote {
|
2018-10-19 11:00:27 -07:00
|
|
|
out, _ := tests.ExecuteT(t, cmdStr, "")
|
2018-07-10 17:59:07 -07:00
|
|
|
var vote gov.Vote
|
2018-06-21 17:19:14 -07:00
|
|
|
cdc := app.MakeCodec()
|
|
|
|
err := cdc.UnmarshalJSON([]byte(out), &vote)
|
|
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
|
|
|
return vote
|
|
|
|
}
|
2018-07-19 17:02:46 -07:00
|
|
|
|
|
|
|
func executeGetVotes(t *testing.T, cmdStr string) []gov.Vote {
|
2018-10-19 11:00:27 -07:00
|
|
|
out, _ := tests.ExecuteT(t, cmdStr, "")
|
2018-07-19 17:02:46 -07:00
|
|
|
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
|
|
|
|
}
|
2018-10-23 07:07:28 -07:00
|
|
|
|
|
|
|
func executeGetDeposit(t *testing.T, cmdStr string) gov.Deposit {
|
|
|
|
out, _ := tests.ExecuteT(t, cmdStr, "")
|
|
|
|
var deposit gov.Deposit
|
|
|
|
cdc := app.MakeCodec()
|
|
|
|
err := cdc.UnmarshalJSON([]byte(out), &deposit)
|
|
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
|
|
|
return deposit
|
|
|
|
}
|
|
|
|
|
|
|
|
func executeGetDeposits(t *testing.T, cmdStr string) []gov.Deposit {
|
|
|
|
out, _ := tests.ExecuteT(t, cmdStr, "")
|
|
|
|
var deposits []gov.Deposit
|
|
|
|
cdc := app.MakeCodec()
|
|
|
|
err := cdc.UnmarshalJSON([]byte(out), &deposits)
|
|
|
|
require.NoError(t, err, "out %v\n, err %v", out, err)
|
|
|
|
return deposits
|
|
|
|
}
|