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

handler tests beginning

This commit is contained in:
rigelrozanski 2018-03-29 16:49:18 +02:00
parent c1a8f2cce9
commit 4b9bd0e7ea
2 changed files with 206 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

408
x/stake/handler_test.go
View File

@ -1,248 +1,248 @@
package stake package stake
//import ( import (
//"strconv" "strconv"
//"testing" "testing"
//"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
//"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
//crypto "github.com/tendermint/go-crypto" crypto "github.com/tendermint/go-crypto"
//sdk "github.com/cosmos/cosmos-sdk/types" sdk "github.com/cosmos/cosmos-sdk/types"
//) )
////______________________________________________________________________ //______________________________________________________________________
//func newTestMsgDeclareCandidacy(address sdk.Address, pubKey crypto.PubKey, amt int64) MsgDeclareCandidacy { func newTestMsgDeclareCandidacy(address sdk.Address, pubKey crypto.PubKey, amt int64) MsgDeclareCandidacy {
//return MsgDeclareCandidacy{ return MsgDeclareCandidacy{
//Description: Description{}, Description: Description{},
//CandidateAddr: address, CandidateAddr: address,
//Bond: sdk.Coin{"fermion", amt}, Bond: sdk.Coin{"fermion", amt},
//PubKey: pubKey, PubKey: pubKey,
//} }
//} }
//func newTestMsgDelegate(amt int64, delegatorAddr, candidateAddr sdk.Address) MsgDelegate { func newTestMsgDelegate(amt int64, delegatorAddr, candidateAddr sdk.Address) MsgDelegate {
//return MsgDelegate{ return MsgDelegate{
//DelegatorAddr: delegatorAddr, DelegatorAddr: delegatorAddr,
//CandidateAddr: candidateAddr, CandidateAddr: candidateAddr,
//Bond: sdk.Coin{"fermion", amt}, Bond: sdk.Coin{"fermion", amt},
//} }
//} }
//func TestDuplicatesMsgDeclareCandidacy(t *testing.T) { func TestDuplicatesMsgDeclareCandidacy(t *testing.T) {
//ctxDeliver, _, keeper := createTestInput(t, addrs[0], false, 1000) ctxDeliver, _, keeper := createTestInput(t, addrs[0], false, 1000)
//ctxCheck, _, keeper := createTestInput(t, addrs[0], true, 1000) ctxCheck, _, _ := createTestInput(t, addrs[0], true, 1000)
//msgDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], 10) msgDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], 10)
//got := deliverer.declareCandidacy(msgDeclareCandidacy) got := keeper.declareCandidacy(ctxDeliver, msgDeclareCandidacy)
//assert.NoError(t, got, "expected no error on runMsgDeclareCandidacy") assert.NoError(t, got, "expected no error on runMsgDeclareCandidacy")
//// one sender can bond to two different addresses // one sender can bond to two different addresses
//msgDeclareCandidacy.Address = addrs[1] msgDeclareCandidacy.Address = addrs[1]
//err := checker.declareCandidacy(msgDeclareCandidacy) err := checker.declareCandidacy(msgDeclareCandidacy)
//assert.Nil(t, err, "didn't expected error on checkTx") assert.Nil(t, err, "didn't expected error on checkTx")
//// two addrs cant bond to the same pubkey // two addrs cant bond to the same pubkey
//checker.sender = addrs[1] checker.sender = addrs[1]
//msgDeclareCandidacy.Address = addrs[0] msgDeclareCandidacy.Address = addrs[0]
//err = checker.declareCandidacy(msgDeclareCandidacy) err = checker.declareCandidacy(msgDeclareCandidacy)
//assert.NotNil(t, err, "expected error on checkTx") assert.NotNil(t, err, "expected error on checkTx")
//} }
//func TestIncrementsMsgDelegate(t *testing.T) { func TestIncrementsMsgDelegate(t *testing.T) {
//_, _, mapper, deliverer := createTestInput(t, addrs[0], false, 1000) _, _, mapper, deliverer := createTestInput(t, addrs[0], false, 1000)
//// first declare candidacy // first declare candidacy
//bondAmount := int64(10) bondAmount := int64(10)
//msgDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], bondAmount) msgDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], bondAmount)
//got := deliverer.declareCandidacy(msgDeclareCandidacy) got := deliverer.declareCandidacy(msgDeclareCandidacy)
//assert.NoError(t, got, "expected declare candidacy msg to be ok, got %v", got) assert.NoError(t, got, "expected declare candidacy msg to be ok, got %v", got)
//expectedBond := bondAmount // 1 since we send 1 at the start of loop, expectedBond := bondAmount // 1 since we send 1 at the start of loop,
//// just send the same msgbond multiple times // just send the same msgbond multiple times
//msgDelegate := newTestMsgDelegate(bondAmount, addrs[0]) msgDelegate := newTestMsgDelegate(bondAmount, addrs[0])
//for i := 0; i < 5; i++ { for i := 0; i < 5; i++ {
//got := deliverer.delegate(msgDelegate) got := deliverer.delegate(msgDelegate)
//assert.NoError(t, got, "expected msg %d to be ok, got %v", i, got) assert.NoError(t, got, "expected msg %d to be ok, got %v", i, got)
////Check that the accounts and the bond account have the appropriate values //Check that the accounts and the bond account have the appropriate values
//candidates := mapper.GetCandidates() candidates := mapper.GetCandidates()
//expectedBond += bondAmount expectedBond += bondAmount
////expectedSender := initSender - expectedBond //expectedSender := initSender - expectedBond
//gotBonded := candidates[0].Liabilities.Evaluate() gotBonded := candidates[0].Liabilities.Evaluate()
////gotSender := accStore[string(deliverer.sender)] //XXX use StoreMapper //gotSender := accStore[string(deliverer.sender)] //XXX use StoreMapper
//assert.Equal(t, expectedBond, gotBonded, "i: %v, %v, %v", i, expectedBond, gotBonded) assert.Equal(t, expectedBond, gotBonded, "i: %v, %v, %v", i, expectedBond, gotBonded)
////assert.Equal(t, expectedSender, gotSender, "i: %v, %v, %v", i, expectedSender, gotSender) // XXX fix //assert.Equal(t, expectedSender, gotSender, "i: %v, %v, %v", i, expectedSender, gotSender) // XXX fix
//} }
//} }
//func TestIncrementsMsgUnbond(t *testing.T) { func TestIncrementsMsgUnbond(t *testing.T) {
//_, _, mapper, deliverer := createTestInput(t, addrs[0], false, 0) _, _, mapper, deliverer := createTestInput(t, addrs[0], false, 0)
//// set initial bond // set initial bond
//initBond := int64(1000) initBond := int64(1000)
////accStore[string(deliverer.sender)] = initBond //XXX use StoreMapper //accStore[string(deliverer.sender)] = initBond //XXX use StoreMapper
//got := deliverer.declareCandidacy(newTestMsgDeclareCandidacy(addrs[0], pks[0], initBond)) got := deliverer.declareCandidacy(newTestMsgDeclareCandidacy(addrs[0], pks[0], initBond))
//assert.NoError(t, got, "expected initial bond msg to be ok, got %v", got) assert.NoError(t, got, "expected initial bond msg to be ok, got %v", got)
//// just send the same msgunbond multiple times // just send the same msgunbond multiple times
//// XXX use decimals here // XXX use decimals here
//unbondShares, unbondSharesStr := int64(10), "10" unbondShares, unbondSharesStr := int64(10), "10"
//msgUndelegate := NewMsgUnbond(addrs[0], unbondSharesStr) msgUndelegate := NewMsgUnbond(addrs[0], unbondSharesStr)
//nUnbonds := 5 nUnbonds := 5
//for i := 0; i < nUnbonds; i++ { for i := 0; i < nUnbonds; i++ {
//got := deliverer.unbond(msgUndelegate) got := deliverer.unbond(msgUndelegate)
//assert.NoError(t, got, "expected msg %d to be ok, got %v", i, got) assert.NoError(t, got, "expected msg %d to be ok, got %v", i, got)
////Check that the accounts and the bond account have the appropriate values //Check that the accounts and the bond account have the appropriate values
//candidates := mapper.GetCandidates() candidates := mapper.GetCandidates()
//expectedBond := initBond - int64(i+1)*unbondShares // +1 since we send 1 at the start of loop expectedBond := initBond - int64(i+1)*unbondShares // +1 since we send 1 at the start of loop
////expectedSender := initSender + (initBond - expectedBond) //expectedSender := initSender + (initBond - expectedBond)
//gotBonded := candidates[0].Liabilities.Evaluate() gotBonded := candidates[0].Liabilities.Evaluate()
////gotSender := accStore[string(deliverer.sender)] // XXX use storemapper //gotSender := accStore[string(deliverer.sender)] // XXX use storemapper
//assert.Equal(t, expectedBond, gotBonded, "%v, %v", expectedBond, gotBonded) assert.Equal(t, expectedBond, gotBonded, "%v, %v", expectedBond, gotBonded)
////assert.Equal(t, expectedSender, gotSender, "%v, %v", expectedSender, gotSender) //XXX fix //assert.Equal(t, expectedSender, gotSender, "%v, %v", expectedSender, gotSender) //XXX fix
//} }
//// these are more than we have bonded now // these are more than we have bonded now
//errorCases := []int64{ errorCases := []int64{
////1<<64 - 1, // more than int64 //1<<64 - 1, // more than int64
////1<<63 + 1, // more than int64 //1<<63 + 1, // more than int64
//1<<63 - 1, 1<<63 - 1,
//1 << 31, 1 << 31,
//initBond, initBond,
//} }
//for _, c := range errorCases { for _, c := range errorCases {
//unbondShares := strconv.Itoa(int(c)) unbondShares := strconv.Itoa(int(c))
//msgUndelegate := NewMsgUnbond(addrs[0], unbondShares) msgUndelegate := NewMsgUnbond(addrs[0], unbondShares)
//got = deliverer.unbond(msgUndelegate) got = deliverer.unbond(msgUndelegate)
//assert.Error(t, got, "expected unbond msg to fail") assert.Error(t, got, "expected unbond msg to fail")
//} }
//leftBonded := initBond - unbondShares*int64(nUnbonds) leftBonded := initBond - unbondShares*int64(nUnbonds)
//// should be unable to unbond one more than we have // should be unable to unbond one more than we have
//msgUndelegate = NewMsgUnbond(addrs[0], strconv.Itoa(int(leftBonded)+1)) msgUndelegate = NewMsgUnbond(addrs[0], strconv.Itoa(int(leftBonded)+1))
//got = deliverer.unbond(msgUndelegate) got = deliverer.unbond(msgUndelegate)
//assert.Error(t, got, "expected unbond msg to fail") assert.Error(t, got, "expected unbond msg to fail")
//// should be able to unbond just what we have // should be able to unbond just what we have
//msgUndelegate = NewMsgUnbond(addrs[0], strconv.Itoa(int(leftBonded))) msgUndelegate = NewMsgUnbond(addrs[0], strconv.Itoa(int(leftBonded)))
//got = deliverer.unbond(msgUndelegate) got = deliverer.unbond(msgUndelegate)
//assert.NoError(t, got, "expected unbond msg to pass") assert.NoError(t, got, "expected unbond msg to pass")
//} }
//func TestMultipleMsgDeclareCandidacy(t *testing.T) { func TestMultipleMsgDeclareCandidacy(t *testing.T) {
//initSender := int64(1000) initSender := int64(1000)
//ctx, accStore, mapper, deliverer := createTestInput(t, addrs[0], false, initSender) ctx, accStore, mapper, deliverer := createTestInput(t, addrs[0], false, initSender)
//addrs := []sdk.Address{addrs[0], addrs[1], addrs[2]} addrs := []sdk.Address{addrs[0], addrs[1], addrs[2]}
//// bond them all // bond them all
//for i, addr := range addrs { for i, addr := range addrs {
//msgDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[i], pks[i], 10) msgDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[i], pks[i], 10)
//deliverer.sender = addr deliverer.sender = addr
//got := deliverer.declareCandidacy(msgDeclareCandidacy) got := deliverer.declareCandidacy(msgDeclareCandidacy)
//assert.NoError(t, got, "expected msg %d to be ok, got %v", i, got) assert.NoError(t, got, "expected msg %d to be ok, got %v", i, got)
////Check that the account is bonded //Check that the account is bonded
//candidates := mapper.GetCandidates() candidates := mapper.GetCandidates()
//require.Equal(t, i, len(candidates)) require.Equal(t, i, len(candidates))
//val := candidates[i] val := candidates[i]
//balanceExpd := initSender - 10 balanceExpd := initSender - 10
//balanceGot := accStore.GetAccount(ctx, val.Address).GetCoins() balanceGot := accStore.GetAccount(ctx, val.Address).GetCoins()
//assert.Equal(t, i+1, len(candidates), "expected %d candidates got %d, candidates: %v", i+1, len(candidates), candidates) assert.Equal(t, i+1, len(candidates), "expected %d candidates got %d, candidates: %v", i+1, len(candidates), candidates)
//assert.Equal(t, 10, int(val.Liabilities.Evaluate()), "expected %d shares, got %d", 10, val.Liabilities) assert.Equal(t, 10, int(val.Liabilities.Evaluate()), "expected %d shares, got %d", 10, val.Liabilities)
//assert.Equal(t, balanceExpd, balanceGot, "expected account to have %d, got %d", balanceExpd, balanceGot) assert.Equal(t, balanceExpd, balanceGot, "expected account to have %d, got %d", balanceExpd, balanceGot)
//} }
//// unbond them all // unbond them all
//for i, addr := range addrs { for i, addr := range addrs {
//candidatePre := mapper.GetCandidate(addrs[i]) candidatePre := mapper.GetCandidate(addrs[i])
//msgUndelegate := NewMsgUnbond(addrs[i], "10") msgUndelegate := NewMsgUnbond(addrs[i], "10")
//deliverer.sender = addr deliverer.sender = addr
//got := deliverer.unbond(msgUndelegate) got := deliverer.unbond(msgUndelegate)
//assert.NoError(t, got, "expected msg %d to be ok, got %v", i, got) assert.NoError(t, got, "expected msg %d to be ok, got %v", i, got)
////Check that the account is unbonded //Check that the account is unbonded
//candidates := mapper.GetCandidates() candidates := mapper.GetCandidates()
//assert.Equal(t, len(addrs)-(i+1), len(candidates), "expected %d candidates got %d", len(addrs)-(i+1), len(candidates)) assert.Equal(t, len(addrs)-(i+1), len(candidates), "expected %d candidates got %d", len(addrs)-(i+1), len(candidates))
//candidatePost := mapper.GetCandidate(addrs[i]) candidatePost := mapper.GetCandidate(addrs[i])
//balanceExpd := initSender balanceExpd := initSender
//balanceGot := accStore.GetAccount(ctx, candidatePre.Address).GetCoins() balanceGot := accStore.GetAccount(ctx, candidatePre.Address).GetCoins()
//assert.Nil(t, candidatePost, "expected nil candidate retrieve, got %d", 0, candidatePost) assert.Nil(t, candidatePost, "expected nil candidate retrieve, got %d", 0, candidatePost)
//assert.Equal(t, balanceExpd, balanceGot, "expected account to have %d, got %d", balanceExpd, balanceGot) assert.Equal(t, balanceExpd, balanceGot, "expected account to have %d, got %d", balanceExpd, balanceGot)
//} }
//} }
//func TestMultipleMsgDelegate(t *testing.T) { func TestMultipleMsgDelegate(t *testing.T) {
//sender, delegators := addrs[0], addrs[1:] sender, delegators := addrs[0], addrs[1:]
//_, _, mapper, deliverer := createTestInput(t, addrs[0], false, 1000) _, _, mapper, deliverer := createTestInput(t, addrs[0], false, 1000)
////first make a candidate //first make a candidate
//msgDeclareCandidacy := newTestMsgDeclareCandidacy(sender, pks[0], 10) msgDeclareCandidacy := newTestMsgDeclareCandidacy(sender, pks[0], 10)
//got := deliverer.declareCandidacy(msgDeclareCandidacy) got := deliverer.declareCandidacy(msgDeclareCandidacy)
//require.NoError(t, got, "expected msg to be ok, got %v", got) require.NoError(t, got, "expected msg to be ok, got %v", got)
//// delegate multiple parties // delegate multiple parties
//for i, delegator := range delegators { for i, delegator := range delegators {
//msgDelegate := newTestMsgDelegate(10, sender) msgDelegate := newTestMsgDelegate(10, sender)
//deliverer.sender = delegator deliverer.sender = delegator
//got := deliverer.delegate(msgDelegate) got := deliverer.delegate(msgDelegate)
//require.NoError(t, got, "expected msg %d to be ok, got %v", i, got) require.NoError(t, got, "expected msg %d to be ok, got %v", i, got)
////Check that the account is bonded //Check that the account is bonded
//bond := mapper.getDelegatorBond(delegator, sender) bond := mapper.getDelegatorBond(delegator, sender)
//assert.NotNil(t, bond, "expected delegatee bond %d to exist", bond) assert.NotNil(t, bond, "expected delegatee bond %d to exist", bond)
//} }
//// unbond them all // unbond them all
//for i, delegator := range delegators { for i, delegator := range delegators {
//msgUndelegate := NewMsgUnbond(sender, "10") msgUndelegate := NewMsgUnbond(sender, "10")
//deliverer.sender = delegator deliverer.sender = delegator
//got := deliverer.unbond(msgUndelegate) got := deliverer.unbond(msgUndelegate)
//require.NoError(t, got, "expected msg %d to be ok, got %v", i, got) require.NoError(t, got, "expected msg %d to be ok, got %v", i, got)
////Check that the account is unbonded //Check that the account is unbonded
//bond := mapper.getDelegatorBond(delegator, sender) bond := mapper.getDelegatorBond(delegator, sender)
//assert.Nil(t, bond, "expected delegatee bond %d to be nil", bond) assert.Nil(t, bond, "expected delegatee bond %d to be nil", bond)
//} }
//} }
//func TestVoidCandidacy(t *testing.T) { func TestVoidCandidacy(t *testing.T) {
//sender, delegator := addrs[0], addrs[1] sender, delegator := addrs[0], addrs[1]
//_, _, _, deliverer := createTestInput(t, addrs[0], false, 1000) _, _, _, deliverer := createTestInput(t, addrs[0], false, 1000)
//// create the candidate // create the candidate
//msgDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], 10) msgDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], 10)
//got := deliverer.declareCandidacy(msgDeclareCandidacy) got := deliverer.declareCandidacy(msgDeclareCandidacy)
//require.NoError(t, got, "expected no error on runMsgDeclareCandidacy") require.NoError(t, got, "expected no error on runMsgDeclareCandidacy")
//// bond a delegator // bond a delegator
//msgDelegate := newTestMsgDelegate(10, addrs[0]) msgDelegate := newTestMsgDelegate(10, addrs[0])
//deliverer.sender = delegator deliverer.sender = delegator
//got = deliverer.delegate(msgDelegate) got = deliverer.delegate(msgDelegate)
//require.NoError(t, got, "expected ok, got %v", got) require.NoError(t, got, "expected ok, got %v", got)
//// unbond the candidates bond portion // unbond the candidates bond portion
//msgUndelegate := NewMsgUnbond(addrs[0], "10") msgUndelegate := NewMsgUnbond(addrs[0], "10")
//deliverer.sender = sender deliverer.sender = sender
//got = deliverer.unbond(msgUndelegate) got = deliverer.unbond(msgUndelegate)
//require.NoError(t, got, "expected no error on runMsgDeclareCandidacy") require.NoError(t, got, "expected no error on runMsgDeclareCandidacy")
//// test that this pubkey cannot yet be bonded too // test that this pubkey cannot yet be bonded too
//deliverer.sender = delegator deliverer.sender = delegator
//got = deliverer.delegate(msgDelegate) got = deliverer.delegate(msgDelegate)
//assert.Error(t, got, "expected error, got %v", got) assert.Error(t, got, "expected error, got %v", got)
//// test that the delegator can still withdraw their bonds // test that the delegator can still withdraw their bonds
//got = deliverer.unbond(msgUndelegate) got = deliverer.unbond(msgUndelegate)
//require.NoError(t, got, "expected no error on runMsgDeclareCandidacy") require.NoError(t, got, "expected no error on runMsgDeclareCandidacy")
//// verify that the pubkey can now be reused // verify that the pubkey can now be reused
//got = deliverer.declareCandidacy(msgDeclareCandidacy) got = deliverer.declareCandidacy(msgDeclareCandidacy)
//assert.NoError(t, got, "expected ok, got %v", got) assert.NoError(t, got, "expected ok, got %v", got)
//} }

4
x/stake/keeper_keys.go
View File

@ -15,9 +15,9 @@ var (
CandidatesKey = []byte{0x02} // prefix for each key to a candidate CandidatesKey = []byte{0x02} // prefix for each key to a candidate
ValidatorsKey = []byte{0x03} // prefix for each key to a validator ValidatorsKey = []byte{0x03} // prefix for each key to a validator
AccUpdateValidatorsKey = []byte{0x04} // prefix for each key to a validator which is being updated AccUpdateValidatorsKey = []byte{0x04} // prefix for each key to a validator which is being updated
RecentValidatorsKey = []byte{0x04} // prefix for each key to the last updated validator group RecentValidatorsKey = []byte{0x05} // prefix for each key to the last updated validator group
DelegatorBondKeyPrefix = []byte{0x05} // prefix for each key to a delegator's bond DelegatorBondKeyPrefix = []byte{0x06} // prefix for each key to a delegator's bond
) )
const maxDigitsForAccount = 12 // ~220,000,000 atoms created at launch const maxDigitsForAccount = 12 // ~220,000,000 atoms created at launch