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

Merge pull request #612 from cosmos/rigel/cool-tests 

Basecoin cool fix / upgrade tests
This commit is contained in:
Ethan Buchman 2018-03-13 13:46:19 +01:00 committed by GitHub
parent d4c13b093c 8f03b181c7
commit ee0b396bad
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 161 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
examples/basecoin/.gitignore vendored
View File

@ -1,12 +0,0 @@
*.swp
*.swo
vendor
build
app/data
### Vagrant ###
.vagrant/
*.box
*.log
vagrant

8
examples/basecoin/app/app.go
View File

@ -81,14 +81,14 @@ func MakeCodec() *wire.Codec {
const msgTypeSend = 0x1
const msgTypeIssue = 0x2
const msgTypeWhatCool = 0x3
const msgTypeSetWhatCool = 0x4
const msgTypeQuiz = 0x3
const msgTypeSetTrend = 0x4
var _ = oldwire.RegisterInterface(
struct{ sdk.Msg }{},
oldwire.ConcreteType{bank.SendMsg{}, msgTypeSend},
oldwire.ConcreteType{bank.IssueMsg{}, msgTypeIssue},
oldwire.ConcreteType{cool.WhatCoolMsg{}, msgTypeWhatCool},
oldwire.ConcreteType{cool.SetWhatCoolMsg{}, msgTypeSetWhatCool},
oldwire.ConcreteType{cool.QuizMsg{}, msgTypeQuiz},
oldwire.ConcreteType{cool.SetTrendMsg{}, msgTypeSetTrend},
)
const accTypeApp = 0x1

153
examples/basecoin/app/app_test.go
View File

@ -23,6 +23,8 @@ import (
// Construct some global addrs and txs for tests.
var (
chainID = "" // TODO
priv1 = crypto.GenPrivKeyEd25519()
addr1 = priv1.PubKey().Address()
addr2 = crypto.GenPrivKeyEd25519().PubKey().Address()
@ -33,19 +35,29 @@ var (
Outputs: []bank.Output{bank.NewOutput(addr2, coins)},
}
whatCoolMsg1 = cool.WhatCoolMsg{
Sender: addr1,
CoolerThanCool: "icecold",
quizMsg1 = cool.QuizMsg{
Sender: addr1,
CoolAnswer: "icecold",
}
whatCoolMsg2 = cool.WhatCoolMsg{
Sender: addr1,
CoolerThanCool: "icecold",
quizMsg2 = cool.QuizMsg{
Sender: addr1,
CoolAnswer: "badvibesonly",
}
setWhatCoolMsg = cool.SetWhatCoolMsg{
Sender: addr1,
WhatCool: "goodbye",
setTrendMsg1 = cool.SetTrendMsg{
Sender: addr1,
Cool: "icecold",
}
setTrendMsg2 = cool.SetTrendMsg{
Sender: addr1,
Cool: "badvibesonly",
}
setTrendMsg3 = cool.SetTrendMsg{
Sender: addr1,
Cool: "warmandkind",
}
)
@ -64,11 +76,10 @@ func TestMsgs(t *testing.T) {
msg sdk.Msg
}{
{sendMsg},
{whatCoolMsg1},
{setWhatCoolMsg},
{quizMsg1},
{setTrendMsg1},
}
chainID := ""
sequences := []int64{0}
for i, m := range msgs {
sig := priv1.Sign(sdk.StdSignBytes(chainID, sequences, m.msg))
@ -168,7 +179,6 @@ func TestSendMsgWithAccounts(t *testing.T) {
assert.Equal(t, acc1, res1)
// Sign the tx
chainID := "" // TODO: InitChain should get the ChainID
sequences := []int64{0}
sig := priv1.Sign(sdk.StdSignBytes(chainID, sequences, sendMsg))
tx := sdk.NewStdTx(sendMsg, []sdk.StdSignature{{
@ -209,56 +219,83 @@ func TestSendMsgWithAccounts(t *testing.T) {
assert.Equal(t, sdk.CodeOK, res.Code, res.Log)
}
//func TestWhatCoolMsg(t *testing.T) {
//bapp := newBasecoinApp()
func TestQuizMsg(t *testing.T) {
bapp := newBasecoinApp()
//// Construct genesis state
//// Construct some genesis bytes to reflect basecoin/types/AppAccount
//// Give 77 foocoin to the first key
//coins, err := sdk.ParseCoins("1icecold")
//require.Nil(t, err)
//baseAcc := auth.BaseAccount{
//Address: addr1,
//Coins: coins,
//}
//acc1 := &types.AppAccount{baseAcc, "foobart"}
// Construct genesis state
// Construct some genesis bytes to reflect basecoin/types/AppAccount
coins := sdk.Coins{}
baseAcc := auth.BaseAccount{
Address: addr1,
Coins: coins,
}
acc1 := &types.AppAccount{baseAcc, "foobart"}
//// Construct genesis state
//genesisState := types.GenesisState{
//Accounts: []*types.GenesisAccount{
//types.NewGenesisAccount(acc1),
//},
//}
//stateBytes, err := json.MarshalIndent(genesisState, "", "\t")
//require.Nil(t, err)
// Construct genesis state
genesisState := types.GenesisState{
Accounts: []*types.GenesisAccount{
types.NewGenesisAccount(acc1),
},
}
stateBytes, err := json.MarshalIndent(genesisState, "", "\t")
require.Nil(t, err)
//// Initialize the chain (nil)
//vals := []abci.Validator{}
//bapp.InitChain(abci.RequestInitChain{vals, stateBytes})
//bapp.Commit()
// Initialize the chain (nil)
vals := []abci.Validator{}
bapp.InitChain(abci.RequestInitChain{vals, stateBytes})
bapp.Commit()
//// A checkTx context (true)
//ctxCheck := bapp.BaseApp.NewContext(true, abci.Header{})
//res1 := bapp.accountMapper.GetAccount(ctxCheck, addr1)
//assert.Equal(t, acc1, res1)
// A checkTx context (true)
ctxCheck := bapp.BaseApp.NewContext(true, abci.Header{})
res1 := bapp.accountMapper.GetAccount(ctxCheck, addr1)
assert.Equal(t, acc1, res1)
//// Sign the tx
//tx := sdk.NewStdTx(whatCoolMsg1, []sdk.StdSignature{{
//PubKey: priv1.PubKey(),
//Signature: priv1.Sign(whatCoolMsg1.GetSignBytes()),
//}})
// Set the trend, submit a really cool quiz and check for reward
SignCheckDeliver(t, bapp, setTrendMsg1, 0, true)
SignCheckDeliver(t, bapp, quizMsg1, 1, true)
CheckBalance(t, bapp, "69icecold")
SignCheckDeliver(t, bapp, quizMsg2, 2, true) // result without reward
CheckBalance(t, bapp, "69icecold")
SignCheckDeliver(t, bapp, quizMsg1, 3, true)
CheckBalance(t, bapp, "138icecold")
SignCheckDeliver(t, bapp, setTrendMsg2, 4, true) // reset the trend
SignCheckDeliver(t, bapp, quizMsg1, 5, true) // the same answer will nolonger do!
CheckBalance(t, bapp, "138icecold")
SignCheckDeliver(t, bapp, quizMsg2, 6, true) // earlier answer now relavent again
CheckBalance(t, bapp, "69badvibesonly,138icecold")
SignCheckDeliver(t, bapp, setTrendMsg3, 7, false) // expect to fail to set the trend to something which is not cool
//// Run a Check
//res := bapp.Check(tx)
//assert.Equal(t, sdk.CodeOK, res.Code, res.Log)
}
//// Simulate a Block
//bapp.BeginBlock(abci.RequestBeginBlock{})
//res = bapp.Deliver(tx)
//assert.Equal(t, sdk.CodeOK, res.Code, res.Log)
func SignCheckDeliver(t *testing.T, bapp *BasecoinApp, msg sdk.Msg, seq int64, expPass bool) {
//// Check balances
//ctxDeliver := bapp.BaseApp.NewContext(false, abci.Header{})
//res2 := bapp.accountMapper.GetAccount(ctxDeliver, addr1)
//assert.Equal(t, "70icecold", fmt.Sprintf("%v", res2.GetCoins()))
//}
// Sign the tx
tx := sdk.NewStdTx(msg, []sdk.StdSignature{{
PubKey: priv1.PubKey(),
Signature: priv1.Sign(sdk.StdSignBytes(chainID, []int64{seq}, msg)),
Sequence: seq,
}})
// Run a Check
res := bapp.Check(tx)
if expPass {
require.Equal(t, sdk.CodeOK, res.Code, res.Log)
} else {
require.NotEqual(t, sdk.CodeOK, res.Code, res.Log)
}
// Simulate a Block
bapp.BeginBlock(abci.RequestBeginBlock{})
res = bapp.Deliver(tx)
if expPass {
require.Equal(t, sdk.CodeOK, res.Code, res.Log)
} else {
require.NotEqual(t, sdk.CodeOK, res.Code, res.Log)
}
}
func CheckBalance(t *testing.T, bapp *BasecoinApp, balExpected string) {
ctxDeliver := bapp.BaseApp.NewContext(false, abci.Header{})
res2 := bapp.accountMapper.GetAccount(ctxDeliver, addr1)
assert.Equal(t, balExpected, fmt.Sprintf("%v", res2.GetCoins()))
}

4
examples/basecoin/cmd/basecli/main.go
View File

@ -58,11 +58,11 @@ func main() {
)...)
basecliCmd.AddCommand(
client.PostCommands(
coolcmd.WhatCoolTxCmd(cdc),
coolcmd.QuizTxCmd(cdc),
)...)
basecliCmd.AddCommand(
client.PostCommands(
coolcmd.SetWhatCoolTxCmd(cdc),
coolcmd.SetTrendTxCmd(cdc),
)...)
// add proxy, version and key info

16
examples/basecoin/x/cool/commands/cooltx.go → examples/basecoin/x/cool/commands/tx.go
View File

@ -12,10 +12,10 @@ import (
"github.com/cosmos/cosmos-sdk/examples/basecoin/x/cool"
)
// what cool transaction
func WhatCoolTxCmd(cdc *wire.Codec) *cobra.Command {
// take the coolness quiz transaction
func QuizTxCmd(cdc *wire.Codec) *cobra.Command {
return &cobra.Command{
Use: "whatcool [answer]",
Use: "cool [answer]",
Short: "What's cooler than being cool?",
RunE: func(cmd *cobra.Command, args []string) error {
if len(args) != 1 || len(args[0]) == 0 {
@ -29,7 +29,7 @@ func WhatCoolTxCmd(cdc *wire.Codec) *cobra.Command {
}
// create the message
msg := cool.NewWhatCoolMsg(from, args[0])
msg := cool.NewQuizMsg(from, args[0])
// build and sign the transaction, then broadcast to Tendermint
res, err := builder.SignBuildBroadcast(msg, cdc)
@ -43,10 +43,10 @@ func WhatCoolTxCmd(cdc *wire.Codec) *cobra.Command {
}
}
// set what cool transaction
func SetWhatCoolTxCmd(cdc *wire.Codec) *cobra.Command {
// set a new cool trend transaction
func SetTrendTxCmd(cdc *wire.Codec) *cobra.Command {
return &cobra.Command{
Use: "setwhatcool [answer]",
Use: "setcool [answer]",
Short: "You're so cool, tell us what is cool!",
RunE: func(cmd *cobra.Command, args []string) error {
if len(args) != 1 || len(args[0]) == 0 {
@ -60,7 +60,7 @@ func SetWhatCoolTxCmd(cdc *wire.Codec) *cobra.Command {
}
// create the message
msg := cool.NewSetWhatCoolMsg(from, args[0])
msg := cool.NewSetTrendMsg(from, args[0])
// build and sign the transaction, then broadcast to Tendermint
res, err := builder.SignBuildBroadcast(msg, cdc)

25
examples/basecoin/x/cool/handler.go
View File

@ -22,10 +22,10 @@ import (
func NewHandler(ck bank.CoinKeeper, cm Mapper) sdk.Handler {
return func(ctx sdk.Context, msg sdk.Msg) sdk.Result {
switch msg := msg.(type) {
case SetWhatCoolMsg:
return handleSetWhatCoolMsg(ctx, cm, msg)
case WhatCoolMsg:
return handleWhatCoolMsg(ctx, ck, cm, msg)
case SetTrendMsg:
return handleSetTrendMsg(ctx, cm, msg)
case QuizMsg:
return handleQuizMsg(ctx, ck, cm, msg)
default:
errMsg := fmt.Sprintf("Unrecognized cool Msg type: %v", reflect.TypeOf(msg).Name())
return sdk.ErrUnknownRequest(errMsg).Result()
@ -33,20 +33,19 @@ func NewHandler(ck bank.CoinKeeper, cm Mapper) sdk.Handler {
}
}
// Handle WhatCoolMsg This is the engine of your module
func handleSetWhatCoolMsg(ctx sdk.Context, cm Mapper, msg SetWhatCoolMsg) sdk.Result {
cm.SetWhatCool(ctx, msg.WhatCool)
// Handle QuizMsg This is the engine of your module
func handleSetTrendMsg(ctx sdk.Context, cm Mapper, msg SetTrendMsg) sdk.Result {
cm.SetTrend(ctx, msg.Cool)
return sdk.Result{}
}
// Handle WhatCoolMsg This is the engine of your module
func handleWhatCoolMsg(ctx sdk.Context, ck bank.CoinKeeper, cm Mapper, msg WhatCoolMsg) sdk.Result {
// Handle QuizMsg This is the engine of your module
func handleQuizMsg(ctx sdk.Context, ck bank.CoinKeeper, cm Mapper, msg QuizMsg) sdk.Result {
whatsCool := cm.GetWhatCool(ctx)
currentTrend := cm.GetTrend(ctx)
if msg.CoolerThanCool == whatsCool {
bonusCoins := sdk.Coins{{whatsCool, 69}}
if msg.CoolAnswer == currentTrend {
bonusCoins := sdk.Coins{{currentTrend, 69}}
_, err := ck.AddCoins(ctx, msg.Sender, bonusCoins)
if err != nil {
return err.Result()

12
examples/basecoin/x/cool/mapper.go
View File

@ -13,18 +13,18 @@ func NewMapper(key sdk.StoreKey) Mapper {
return Mapper{key}
}
// Key to knowing whats cool
var whatCoolKey = []byte("WhatsCoolKey")
// Key to knowing the trend on the streets!
var trendKey = []byte("TrendKey")
// Implements sdk.AccountMapper.
func (am Mapper) GetWhatCool(ctx sdk.Context) string {
func (am Mapper) GetTrend(ctx sdk.Context) string {
store := ctx.KVStore(am.key)
bz := store.Get(whatCoolKey)
bz := store.Get(trendKey)
return string(bz)
}
// Implements sdk.AccountMapper.
func (am Mapper) SetWhatCool(ctx sdk.Context, whatscool string) {
func (am Mapper) SetTrend(ctx sdk.Context, newTrend string) {
store := ctx.KVStore(am.key)
store.Set(whatCoolKey, []byte(whatscool))
store.Set(trendKey, []byte(newTrend))
}

68
examples/basecoin/x/cool/types.go
View File

@ -10,46 +10,46 @@ import (
// A really cool msg type, these fields are can be entirely arbitrary and
// custom to your message
type SetWhatCoolMsg struct {
Sender sdk.Address
WhatCool string
type SetTrendMsg struct {
Sender sdk.Address
Cool string
}
// New cool message
func NewSetWhatCoolMsg(sender sdk.Address, whatcool string) SetWhatCoolMsg {
return SetWhatCoolMsg{
Sender: sender,
WhatCool: whatcool,
func NewSetTrendMsg(sender sdk.Address, cool string) SetTrendMsg {
return SetTrendMsg{
Sender: sender,
Cool: cool,
}
}
// enforce the msg type at compile time
var _ sdk.Msg = SetWhatCoolMsg{}
var _ sdk.Msg = SetTrendMsg{}
// nolint
func (msg SetWhatCoolMsg) Type() string { return "cool" }
func (msg SetWhatCoolMsg) Get(key interface{}) (value interface{}) { return nil }
func (msg SetWhatCoolMsg) GetSigners() []sdk.Address { return []sdk.Address{msg.Sender} }
func (msg SetWhatCoolMsg) String() string {
return fmt.Sprintf("SetWhatCoolMsg{Sender: %v, WhatCool: %v}", msg.Sender, msg.WhatCool)
func (msg SetTrendMsg) Type() string { return "cool" }
func (msg SetTrendMsg) Get(key interface{}) (value interface{}) { return nil }
func (msg SetTrendMsg) GetSigners() []sdk.Address { return []sdk.Address{msg.Sender} }
func (msg SetTrendMsg) String() string {
return fmt.Sprintf("SetTrendMsg{Sender: %v, Cool: %v}", msg.Sender, msg.Cool)
}
// Validate Basic is used to quickly disqualify obviously invalid messages quickly
func (msg SetWhatCoolMsg) ValidateBasic() sdk.Error {
func (msg SetTrendMsg) ValidateBasic() sdk.Error {
if len(msg.Sender) == 0 {
return sdk.ErrUnrecognizedAddress(msg.Sender).Trace("")
}
if strings.Contains(msg.WhatCool, "hot") {
if strings.Contains(msg.Cool, "hot") {
return sdk.ErrUnauthorized("").Trace("hot is not cool")
}
if strings.Contains(msg.WhatCool, "warm") {
if strings.Contains(msg.Cool, "warm") {
return sdk.ErrUnauthorized("").Trace("warm is not very cool")
}
return nil
}
// Get the bytes for the message signer to sign on
func (msg SetWhatCoolMsg) GetSignBytes() []byte {
func (msg SetTrendMsg) GetSignBytes() []byte {
b, err := json.Marshal(msg)
if err != nil {
panic(err)
@ -59,34 +59,34 @@ func (msg SetWhatCoolMsg) GetSignBytes() []byte {
//_______________________________________________________________________
// A really cool msg type, these fields are can be entirely arbitrary and
// custom to your message
type WhatCoolMsg struct {
Sender sdk.Address
CoolerThanCool string
// A message type to quiz how cool you are. these fields are can be entirely
// arbitrary and custom to your message
type QuizMsg struct {
Sender sdk.Address
CoolAnswer string
}
// New cool message
func NewWhatCoolMsg(sender sdk.Address, coolerthancool string) WhatCoolMsg {
return WhatCoolMsg{
Sender: sender,
CoolerThanCool: coolerthancool,
func NewQuizMsg(sender sdk.Address, coolerthancool string) QuizMsg {
return QuizMsg{
Sender: sender,
CoolAnswer: coolerthancool,
}
}
// enforce the msg type at compile time
var _ sdk.Msg = WhatCoolMsg{}
var _ sdk.Msg = QuizMsg{}
// nolint
func (msg WhatCoolMsg) Type() string { return "cool" }
func (msg WhatCoolMsg) Get(key interface{}) (value interface{}) { return nil }
func (msg WhatCoolMsg) GetSigners() []sdk.Address { return []sdk.Address{msg.Sender} }
func (msg WhatCoolMsg) String() string {
return fmt.Sprintf("WhatCoolMsg{Sender: %v, CoolerThanCool: %v}", msg.Sender, msg.CoolerThanCool)
func (msg QuizMsg) Type() string { return "cool" }
func (msg QuizMsg) Get(key interface{}) (value interface{}) { return nil }
func (msg QuizMsg) GetSigners() []sdk.Address { return []sdk.Address{msg.Sender} }
func (msg QuizMsg) String() string {
return fmt.Sprintf("QuizMsg{Sender: %v, CoolAnswer: %v}", msg.Sender, msg.CoolAnswer)
}
// Validate Basic is used to quickly disqualify obviously invalid messages quickly
func (msg WhatCoolMsg) ValidateBasic() sdk.Error {
func (msg QuizMsg) ValidateBasic() sdk.Error {
if len(msg.Sender) == 0 {
return sdk.ErrUnrecognizedAddress(msg.Sender).Trace("")
}
@ -94,7 +94,7 @@ func (msg WhatCoolMsg) ValidateBasic() sdk.Error {
}
// Get the bytes for the message signer to sign on
func (msg WhatCoolMsg) GetSignBytes() []byte {
func (msg QuizMsg) GetSignBytes() []byte {
b, err := json.Marshal(msg)
if err != nil {
panic(err)