certusone
/
cosmos-sdk
mirror of https://github.com/certusone/cosmos-sdk.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Get counter app working, with cli tests

This commit is contained in:
Ethan Frey 2017-07-04 14:04:18 +02:00
parent 6d56891a0f
commit 49ebe59804
8 changed files with 199 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -25,7 +25,7 @@ test_unit:
test_cli: tests/cli/shunit2
# sudo apt-get install jq
@./tests/cli/basictx.sh
# @./tests/cli/counter.sh
@./tests/cli/counter.sh
@./tests/cli/restart.sh
# @./tests/cli/ibc.sh

5
docs/guide/counter/cmd/counter/main.go
View File

@ -7,10 +7,8 @@ import (
"github.com/tendermint/tmlibs/cli"
"github.com/tendermint/basecoin/app"
"github.com/tendermint/basecoin/cmd/basecoin/commands"
"github.com/tendermint/basecoin/docs/guide/counter/plugins/counter"
"github.com/tendermint/basecoin/types"
)
func main() {
@ -20,7 +18,7 @@ func main() {
}
// TODO: register the counter here
commands.Handler = app.DefaultHandler()
commands.Handler = counter.NewCounterHandler()
RootCmd.AddCommand(
commands.InitCmd,
@ -29,7 +27,6 @@ func main() {
commands.VersionCmd,
)
commands.RegisterStartPlugin("counter", func() types.Plugin { return counter.New() })
cmd := cli.PrepareMainCmd(RootCmd, "CT", os.ExpandEnv("$HOME/.counter"))
cmd.Execute()
}

72
docs/guide/counter/cmd/countercli/commands/counter.go
View File

@ -4,11 +4,12 @@ import (
"github.com/spf13/cobra"
"github.com/spf13/viper"
wire "github.com/tendermint/go-wire"
"github.com/tendermint/basecoin"
"github.com/tendermint/light-client/commands"
txcmd "github.com/tendermint/light-client/commands/txs"
bcmd "github.com/tendermint/basecoin/cmd/basecli/commands"
"github.com/tendermint/basecoin/docs/guide/counter/plugins/counter"
"github.com/tendermint/basecoin/txs"
btypes "github.com/tendermint/basecoin/types"
)
@ -20,64 +21,59 @@ var CounterTxCmd = &cobra.Command{
Long: `Add a vote to the counter.
You must pass --valid for it to count and the countfee will be added to the counter.`,
RunE: counterTxCmd,
RunE: doCounterTx,
}
const (
flagCountFee = "countfee"
flagValid = "valid"
FlagCountFee = "countfee"
FlagValid = "valid"
FlagSequence = "sequence" // FIXME: currently not supported...
)
func init() {
fs := CounterTxCmd.Flags()
bcmd.AddAppTxFlags(fs)
fs.String(flagCountFee, "", "Coins to send in the format <amt><coin>,<amt><coin>...")
fs.Bool(flagValid, false, "Is count valid?")
fs.String(FlagCountFee, "", "Coins to send in the format <amt><coin>,<amt><coin>...")
fs.Bool(FlagValid, false, "Is count valid?")
fs.Int(FlagSequence, -1, "Sequence number for this transaction")
}
func counterTxCmd(cmd *cobra.Command, args []string) error {
// Note: we don't support loading apptx from json currently, so skip that
// Read the app-specific flags
name, data, err := getAppData()
// TODO: doCounterTx is very similar to the sendtx one,
// maybe we can pull out some common patterns?
func doCounterTx(cmd *cobra.Command, args []string) error {
// load data from json or flags
var tx basecoin.Tx
found, err := txcmd.LoadJSON(&tx)
if err != nil {
return err
}
if !found {
tx, err = readCounterTxFlags()
}
if err != nil {
return err
}
// Read the standard app-tx flags
gas, fee, txInput, err := bcmd.ReadAppTxFlags()
if err != nil {
return err
}
// TODO: make this more flexible for middleware
// add the chain info
tx = txs.NewChain(commands.GetChainID(), tx)
stx := txs.NewSig(tx)
// Create AppTx and broadcast
tx := &btypes.AppTx{
Gas: gas,
Fee: fee,
Name: name,
Input: txInput,
Data: data,
}
res, err := bcmd.BroadcastAppTx(tx)
// Sign if needed and post. This it the work-horse
bres, err := txcmd.SignAndPostTx(stx)
if err != nil {
return err
}
// Output result
return txcmd.OutputTx(res)
return txcmd.OutputTx(bres)
}
func getAppData() (name string, data []byte, err error) {
countFee, err := btypes.ParseCoins(viper.GetString(flagCountFee))
func readCounterTxFlags() (tx basecoin.Tx, err error) {
feeCoins, err := btypes.ParseCoins(viper.GetString(FlagCountFee))
if err != nil {
return
}
ctx := counter.CounterTx{
Valid: viper.GetBool(flagValid),
Fee: countFee,
return tx, err
}
name = counter.New().Name()
data = wire.BinaryBytes(ctx)
return
tx = counter.NewCounterTx(viper.GetBool(FlagValid), feeCoins)
return tx, nil
}

4
docs/guide/counter/cmd/countercli/commands/query.go
View File

@ -16,9 +16,9 @@ var CounterQueryCmd = &cobra.Command{
}
func counterQueryCmd(cmd *cobra.Command, args []string) error {
key := counter.New().StateKey()
key := counter.StateKey()
var cp counter.CounterPluginState
var cp counter.CounterState
proof, err := proofcmd.GetAndParseAppProof(key, &cp)
if err != nil {
return err

23
docs/guide/counter/plugins/counter/counter.go
View File

@ -9,6 +9,7 @@ import (
"github.com/tendermint/basecoin"
"github.com/tendermint/basecoin/errors"
"github.com/tendermint/basecoin/modules/coin"
"github.com/tendermint/basecoin/stack"
"github.com/tendermint/basecoin/types"
)
@ -78,6 +79,17 @@ func ErrDecoding() error {
// CounterHandler
//--------------------------------------------------------------------------------
func NewCounterHandler() basecoin.Handler {
// use the default stack
coin := coin.NewHandler()
counter := CounterHandler{}
dispatcher := stack.NewDispatcher(
stack.WrapHandler(coin),
stack.WrapHandler(counter),
)
return stack.NewDefault().Use(dispatcher)
}
type CounterHandler struct {
basecoin.NopOption
}
@ -107,6 +119,7 @@ func (h CounterHandler) DeliverTx(ctx basecoin.Context, store types.KVStore, tx
}
// TODO: handle coin movement.... ugh, need sequence to do this, right?
// like, actually decrement the other account
// update the counter
state, err := LoadState(store)
@ -135,16 +148,16 @@ func checkTx(ctx basecoin.Context, tx basecoin.Tx) (ctr CounterTx, err error) {
// CounterStore
//--------------------------------------------------------------------------------
type CounterPluginState struct {
Counter int
TotalFees types.Coins
type CounterState struct {
Counter int `json:"counter"`
TotalFees types.Coins `json:"total_fees"`
}
func StateKey() []byte {
return []byte(NameCounter + "/state")
}
func LoadState(store types.KVStore) (state CounterPluginState, err error) {
func LoadState(store types.KVStore) (state CounterState, err error) {
bytes := store.Get(StateKey())
if len(bytes) > 0 {
err = wire.ReadBinaryBytes(bytes, &state)
@ -155,7 +168,7 @@ func LoadState(store types.KVStore) (state CounterPluginState, err error) {
return state, nil
}
func StoreState(store types.KVStore, state CounterPluginState) error {
func StoreState(store types.KVStore, state CounterState) error {
bytes := wire.BinaryBytes(state)
store.Set(StateKey(), bytes)
return nil

15
docs/guide/counter/plugins/counter/counter_test.go
View File

@ -7,10 +7,7 @@ import (
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
abci "github.com/tendermint/abci/types"
"github.com/tendermint/basecoin"
"github.com/tendermint/basecoin/app"
"github.com/tendermint/basecoin/modules/coin"
"github.com/tendermint/basecoin/stack"
"github.com/tendermint/basecoin/txs"
"github.com/tendermint/basecoin/types"
"github.com/tendermint/go-wire"
@ -18,18 +15,6 @@ import (
"github.com/tendermint/tmlibs/log"
)
// TODO: actually handle the counter here...
func NewCounterHandler() basecoin.Handler {
// use the default stack
coin := coin.NewHandler()
counter := CounterHandler{}
dispatcher := stack.NewDispatcher(
stack.WrapHandler(coin),
stack.WrapHandler(counter),
)
return stack.NewDefault().Use(dispatcher)
}
func TestCounterPlugin(t *testing.T) {
assert := assert.New(t)

13
tests/cli/counter.sh
View File

@ -55,21 +55,22 @@ test02GetCounter() {
checkCounter() {
# make sure sender goes down
ACCT=$(${CLIENT_EXE} query counter)
assertTrue "count is set" $?
assertEquals "proper count" "$1" $(echo $ACCT | jq .data.Counter)
assertEquals "proper money" "$2" $(echo $ACCT | jq .data.TotalFees[0].amount)
if assertTrue "count is set" $?; then
assertEquals "proper count" "$1" $(echo $ACCT | jq .data.counter)
assertEquals "proper money" "$2" $(echo $ACCT | jq .data.total_fees[0].amount)
fi
}
test03AddCount() {
SENDER=$(getAddr $RICH)
assertFalse "bad password" "echo hi | ${CLIENT_EXE} tx counter --amount=1000mycoin --sequence=2 --name=${RICH} 2>/dev/null"
assertFalse "bad password" "echo hi | ${CLIENT_EXE} tx counter --countfee=100mycoin --sequence=2 --name=${RICH} 2>/dev/null"
TX=$(echo qwertyuiop | ${CLIENT_EXE} tx counter --amount=10mycoin --sequence=2 --name=${RICH} --valid --countfee=5mycoin)
TX=$(echo qwertyuiop | ${CLIENT_EXE} tx counter --countfee=10mycoin --sequence=2 --name=${RICH} --valid)
txSucceeded $? "$TX" "counter"
HASH=$(echo $TX | jq .hash | tr -d \")
TX_HEIGHT=$(echo $TX | jq .height)
checkCounter "1" "5"
checkCounter "1" "10"
# FIXME: cannot load apptx properly.
# Look at the stack trace

270
tests/tmsp/tmsp_test.go
View File

@ -1,157 +1,159 @@
package tmsp_test
import (
"encoding/json"
"testing"
// TODO: replace with benchmarker
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/tendermint/basecoin/app"
"github.com/tendermint/basecoin/types"
wire "github.com/tendermint/go-wire"
eyescli "github.com/tendermint/merkleeyes/client"
cmn "github.com/tendermint/tmlibs/common"
"github.com/tendermint/tmlibs/log"
)
// import (
// "encoding/json"
// "testing"
func TestSendTx(t *testing.T) {
eyesCli := eyescli.NewLocalClient("", 0)
chainID := "test_chain_id"
bcApp := app.NewBasecoin(eyesCli, log.TestingLogger().With("module", "app"))
bcApp.SetOption("base/chain_id", chainID)
// t.Log(bcApp.Info())
// "github.com/stretchr/testify/assert"
// "github.com/stretchr/testify/require"
// "github.com/tendermint/basecoin/app"
// "github.com/tendermint/basecoin/types"
// wire "github.com/tendermint/go-wire"
// eyescli "github.com/tendermint/merkleeyes/client"
// cmn "github.com/tendermint/tmlibs/common"
// "github.com/tendermint/tmlibs/log"
// )
test1PrivAcc := types.PrivAccountFromSecret("test1")
test2PrivAcc := types.PrivAccountFromSecret("test2")
// func TestSendTx(t *testing.T) {
// eyesCli := eyescli.NewLocalClient("", 0)
// chainID := "test_chain_id"
// bcApp := app.NewBasecoin(eyesCli, log.TestingLogger().With("module", "app"))
// bcApp.SetOption("base/chain_id", chainID)
// // t.Log(bcApp.Info())
// Seed Basecoin with account
test1Acc := test1PrivAcc.Account
test1Acc.Balance = types.Coins{{"", 1000}}
accOpt, err := json.Marshal(test1Acc)
require.Nil(t, err)
bcApp.SetOption("base/account", string(accOpt))
// test1PrivAcc := types.PrivAccountFromSecret("test1")
// test2PrivAcc := types.PrivAccountFromSecret("test2")
// Construct a SendTx signature
tx := &types.SendTx{
Gas: 0,
Fee: types.Coin{"", 0},
Inputs: []types.TxInput{
types.NewTxInput(test1PrivAcc.Account.PubKey, types.Coins{{"", 1}}, 1),
},
Outputs: []types.TxOutput{
types.TxOutput{
Address: test2PrivAcc.Account.PubKey.Address(),
Coins: types.Coins{{"", 1}},
},
},
}
// // Seed Basecoin with account
// test1Acc := test1PrivAcc.Account
// test1Acc.Balance = types.Coins{{"", 1000}}
// accOpt, err := json.Marshal(test1Acc)
// require.Nil(t, err)
// bcApp.SetOption("base/account", string(accOpt))
// Sign request
signBytes := tx.SignBytes(chainID)
// t.Log("Sign bytes: %X\n", signBytes)
sig := test1PrivAcc.Sign(signBytes)
tx.Inputs[0].Signature = sig
// t.Log("Signed TX bytes: %X\n", wire.BinaryBytes(types.TxS{tx}))
// // Construct a SendTx signature
// tx := &types.SendTx{
// Gas: 0,
// Fee: types.Coin{"", 0},
// Inputs: []types.TxInput{
// types.NewTxInput(test1PrivAcc.Account.PubKey, types.Coins{{"", 1}}, 1),
// },
// Outputs: []types.TxOutput{
// types.TxOutput{
// Address: test2PrivAcc.Account.PubKey.Address(),
// Coins: types.Coins{{"", 1}},
// },
// },
// }
// Write request
txBytes := wire.BinaryBytes(types.TxS{tx})
res := bcApp.DeliverTx(txBytes)
// t.Log(res)
assert.True(t, res.IsOK(), "Failed: %v", res.Error())
}
// // Sign request
// signBytes := tx.SignBytes(chainID)
// // t.Log("Sign bytes: %X\n", signBytes)
// sig := test1PrivAcc.Sign(signBytes)
// tx.Inputs[0].Signature = sig
// // t.Log("Signed TX bytes: %X\n", wire.BinaryBytes(types.TxS{tx}))
func TestSequence(t *testing.T) {
eyesCli := eyescli.NewLocalClient("", 0)
chainID := "test_chain_id"
bcApp := app.NewBasecoin(eyesCli, log.TestingLogger().With("module", "app"))
bcApp.SetOption("base/chain_id", chainID)
// t.Log(bcApp.Info())
// // Write request
// txBytes := wire.BinaryBytes(types.TxS{tx})
// res := bcApp.DeliverTx(txBytes)
// // t.Log(res)
// assert.True(t, res.IsOK(), "Failed: %v", res.Error())
// }
// Get the test account
test1PrivAcc := types.PrivAccountFromSecret("test1")
test1Acc := test1PrivAcc.Account
test1Acc.Balance = types.Coins{{"", 1 << 53}}
accOpt, err := json.Marshal(test1Acc)
require.Nil(t, err)
bcApp.SetOption("base/account", string(accOpt))
// func TestSequence(t *testing.T) {
// eyesCli := eyescli.NewLocalClient("", 0)
// chainID := "test_chain_id"
// bcApp := app.NewBasecoin(eyesCli, log.TestingLogger().With("module", "app"))
// bcApp.SetOption("base/chain_id", chainID)
// // t.Log(bcApp.Info())
sequence := int(1)
// Make a bunch of PrivAccounts
privAccounts := types.RandAccounts(1000, 1000000, 0)
privAccountSequences := make(map[string]int)
// Send coins to each account
// // Get the test account
// test1PrivAcc := types.PrivAccountFromSecret("test1")
// test1Acc := test1PrivAcc.Account
// test1Acc.Balance = types.Coins{{"", 1 << 53}}
// accOpt, err := json.Marshal(test1Acc)
// require.Nil(t, err)
// bcApp.SetOption("base/account", string(accOpt))
for i := 0; i < len(privAccounts); i++ {
privAccount := privAccounts[i]
// sequence := int(1)
// // Make a bunch of PrivAccounts
// privAccounts := types.RandAccounts(1000, 1000000, 0)
// privAccountSequences := make(map[string]int)
// // Send coins to each account
tx := &types.SendTx{
Gas: 2,
Fee: types.Coin{"", 2},
Inputs: []types.TxInput{
types.NewTxInput(test1Acc.PubKey, types.Coins{{"", 1000002}}, sequence),
},
Outputs: []types.TxOutput{
types.TxOutput{
Address: privAccount.Account.PubKey.Address(),
Coins: types.Coins{{"", 1000000}},
},
},
}
sequence += 1
// for i := 0; i < len(privAccounts); i++ {
// privAccount := privAccounts[i]
// Sign request
signBytes := tx.SignBytes(chainID)
sig := test1PrivAcc.Sign(signBytes)
tx.Inputs[0].Signature = sig
// t.Log("ADDR: %X -> %X\n", tx.Inputs[0].Address, tx.Outputs[0].Address)
// tx := &types.SendTx{
// Gas: 2,
// Fee: types.Coin{"", 2},
// Inputs: []types.TxInput{
// types.NewTxInput(test1Acc.PubKey, types.Coins{{"", 1000002}}, sequence),
// },
// Outputs: []types.TxOutput{
// types.TxOutput{
// Address: privAccount.Account.PubKey.Address(),
// Coins: types.Coins{{"", 1000000}},
// },
// },
// }
// sequence += 1
// Write request
txBytes := wire.BinaryBytes(struct{ types.Tx }{tx})
res := bcApp.DeliverTx(txBytes)
assert.True(t, res.IsOK(), "DeliverTx error: %v", res.Error())
}
// // Sign request
// signBytes := tx.SignBytes(chainID)
// sig := test1PrivAcc.Sign(signBytes)
// tx.Inputs[0].Signature = sig
// // t.Log("ADDR: %X -> %X\n", tx.Inputs[0].Address, tx.Outputs[0].Address)
res := bcApp.Commit()
assert.True(t, res.IsOK(), "Failed Commit: %v", res.Error())
// // Write request
// txBytes := wire.BinaryBytes(struct{ types.Tx }{tx})
// res := bcApp.DeliverTx(txBytes)
// assert.True(t, res.IsOK(), "DeliverTx error: %v", res.Error())
// }
t.Log("-------------------- RANDOM SENDS --------------------")
// res := bcApp.Commit()
// assert.True(t, res.IsOK(), "Failed Commit: %v", res.Error())
// Now send coins between these accounts
for i := 0; i < 10000; i++ {
randA := cmn.RandInt() % len(privAccounts)
randB := cmn.RandInt() % len(privAccounts)
if randA == randB {
continue
}
// t.Log("-------------------- RANDOM SENDS --------------------")
privAccountA := privAccounts[randA]
privAccountASequence := privAccountSequences[privAccountA.Account.PubKey.KeyString()]
privAccountSequences[privAccountA.Account.PubKey.KeyString()] = privAccountASequence + 1
privAccountB := privAccounts[randB]
// // Now send coins between these accounts
// for i := 0; i < 10000; i++ {
// randA := cmn.RandInt() % len(privAccounts)
// randB := cmn.RandInt() % len(privAccounts)
// if randA == randB {
// continue
// }
tx := &types.SendTx{
Gas: 2,
Fee: types.Coin{"", 2},
Inputs: []types.TxInput{
types.NewTxInput(privAccountA.PubKey, types.Coins{{"", 3}}, privAccountASequence+1),
},
Outputs: []types.TxOutput{
types.TxOutput{
Address: privAccountB.PubKey.Address(),
Coins: types.Coins{{"", 1}},
},
},
}
// privAccountA := privAccounts[randA]
// privAccountASequence := privAccountSequences[privAccountA.Account.PubKey.KeyString()]
// privAccountSequences[privAccountA.Account.PubKey.KeyString()] = privAccountASequence + 1
// privAccountB := privAccounts[randB]
// Sign request
signBytes := tx.SignBytes(chainID)
sig := privAccountA.Sign(signBytes)
tx.Inputs[0].Signature = sig
// t.Log("ADDR: %X -> %X\n", tx.Inputs[0].Address, tx.Outputs[0].Address)
// tx := &types.SendTx{
// Gas: 2,
// Fee: types.Coin{"", 2},
// Inputs: []types.TxInput{
// types.NewTxInput(privAccountA.PubKey, types.Coins{{"", 3}}, privAccountASequence+1),
// },
// Outputs: []types.TxOutput{
// types.TxOutput{
// Address: privAccountB.PubKey.Address(),
// Coins: types.Coins{{"", 1}},
// },
// },
// }
// Write request
txBytes := wire.BinaryBytes(struct{ types.Tx }{tx})
res := bcApp.DeliverTx(txBytes)
assert.True(t, res.IsOK(), "DeliverTx error: %v", res.Error())
}
}
// // Sign request
// signBytes := tx.SignBytes(chainID)
// sig := privAccountA.Sign(signBytes)
// tx.Inputs[0].Signature = sig
// // t.Log("ADDR: %X -> %X\n", tx.Inputs[0].Address, tx.Outputs[0].Address)
// // Write request
// txBytes := wire.BinaryBytes(struct{ types.Tx }{tx})
// res := bcApp.DeliverTx(txBytes)
// assert.True(t, res.IsOK(), "DeliverTx error: %v", res.Error())
// }
// }