LaconicNetwork/cosmos-sdk
10
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

testing staking

Browse Source 
...

...
This commit is contained in:
rigelrozanski 2018-03-19 16:53:20 +01:00
parent b8cdf05921
commit c1d8aefecd
6 changed files with 91 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
x/auth/mapper.go
View File

@ -165,7 +165,6 @@ func (am accountMapper) decodeAccount(bz []byte) sdk.Account {
accI := oldwire.ReadBinary(struct{ sdk.Account }{}, r, len(bz), n, err)
if *err != nil {
panic(*err)
}
acc := accI.(struct{ sdk.Account }).Account

149
x/stake/handler_test.go
View File

@ -14,21 +14,12 @@ import (
//______________________________________________________________________
// XXX delete need to init accounts in the transact!
func initAccounts(amount int64) map[string]int64 {
accStore := map[string]int64{}
for _, addr := range addrs {
accStore[string(addr)] = amount
}
return accStore
}
func newTestMsgDeclareCandidacy(address sdk.Address, pubKey crypto.PubKey, amt int64) MsgDeclareCandidacy {
return MsgDeclareCandidacy{
MsgAddr: NewMsgAddr(address),
PubKey: pubKey,
Bond: sdk.Coin{"fermion", amt},
Description: Description{},
Bond: sdk.Coin{"fermion", amt},
PubKey: pubKey,
}
}
@ -40,45 +31,40 @@ func newTestMsgDelegate(amt int64, address sdk.Address) MsgDelegate {
}
func TestDuplicatesMsgDeclareCandidacy(t *testing.T) {
//accStore := initAccounts(1000)
// XXX initalize values in accounts to 1000
_, deliverer := createTestInput(t, addrs[0], false)
_, checker := createTestInput(t, addrs[0], true)
_, _, _, deliverer := createTestInput(t, addrs[0], false, 1000)
_, _, _, checker := createTestInput(t, addrs[0], true, 1000)
txDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], 10)
got := deliverer.declareCandidacy(txDeclareCandidacy)
msgDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], 10)
got := deliverer.declareCandidacy(msgDeclareCandidacy)
assert.NoError(t, got, "expected no error on runMsgDeclareCandidacy")
// one sender can bond to two different addresses
txDeclareCandidacy.Address = addrs[1]
err := checker.declareCandidacy(txDeclareCandidacy)
msgDeclareCandidacy.Address = addrs[1]
err := checker.declareCandidacy(msgDeclareCandidacy)
assert.Nil(t, err, "didn't expected error on checkTx")
// two addrs cant bond to the same pubkey
checker.sender = addrs[1]
txDeclareCandidacy.Address = addrs[0]
err = checker.declareCandidacy(txDeclareCandidacy)
msgDeclareCandidacy.Address = addrs[0]
err = checker.declareCandidacy(msgDeclareCandidacy)
assert.NotNil(t, err, "expected error on checkTx")
}
func TestIncrementsMsgDelegate(t *testing.T) {
//initSender := int64(1000)
//accStore := initAccounts(initSender) // for accounts
// XXX initalize values in accounts to 1000
mapper, deliverer := createTestInput(t, addrs[0], false)
_, _, mapper, deliverer := createTestInput(t, addrs[0], false, 1000)
// first declare candidacy
bondAmount := int64(10)
txDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], bondAmount)
got := deliverer.declareCandidacy(txDeclareCandidacy)
assert.NoError(t, got, "expected declare candidacy tx to be ok, got %v", got)
msgDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], bondAmount)
got := deliverer.declareCandidacy(msgDeclareCandidacy)
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,
// just send the same txbond multiple times
txDelegate := newTestMsgDelegate(bondAmount, addrs[0])
// just send the same msgbond multiple times
msgDelegate := newTestMsgDelegate(bondAmount, addrs[0])
for i := 0; i < 5; i++ {
got := deliverer.delegate(txDelegate)
assert.NoError(t, got, "expected tx %d to be ok, got %v", i, got)
got := deliverer.delegate(msgDelegate)
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
candidates := mapper.loadCandidates()
@ -92,25 +78,22 @@ func TestIncrementsMsgDelegate(t *testing.T) {
}
func TestIncrementsMsgUnbond(t *testing.T) {
//initSender := int64(0)
//accStore := initAccounts(initSender) // for accounts
// XXX initalize values in accounts to 0
mapper, deliverer := createTestInput(t, addrs[0], false)
_, _, mapper, deliverer := createTestInput(t, addrs[0], false, 0)
// set initial bond
initBond := int64(1000)
//accStore[string(deliverer.sender)] = initBond //XXX use StoreMapper
got := deliverer.declareCandidacy(newTestMsgDeclareCandidacy(addrs[0], pks[0], initBond))
assert.NoError(t, got, "expected initial bond tx to be ok, got %v", got)
assert.NoError(t, got, "expected initial bond msg to be ok, got %v", got)
// just send the same txunbond multiple times
// just send the same msgunbond multiple times
// XXX use decimals here
unbondShares, unbondSharesStr := int64(10), "10"
txUndelegate := NewMsgUnbond(addrs[0], unbondSharesStr)
msgUndelegate := NewMsgUnbond(addrs[0], unbondSharesStr)
nUnbonds := 5
for i := 0; i < nUnbonds; i++ {
got := deliverer.unbond(txUndelegate)
assert.NoError(t, got, "expected tx %d to be ok, got %v", i, got)
got := deliverer.unbond(msgUndelegate)
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
candidates := mapper.loadCandidates()
@ -133,41 +116,42 @@ func TestIncrementsMsgUnbond(t *testing.T) {
}
for _, c := range errorCases {
unbondShares := strconv.Itoa(int(c))
txUndelegate := NewMsgUnbond(addrs[0], unbondShares)
got = deliverer.unbond(txUndelegate)
assert.Error(t, got, "expected unbond tx to fail")
msgUndelegate := NewMsgUnbond(addrs[0], unbondShares)
got = deliverer.unbond(msgUndelegate)
assert.Error(t, got, "expected unbond msg to fail")
}
leftBonded := initBond - unbondShares*int64(nUnbonds)
// should be unable to unbond one more than we have
txUndelegate = NewMsgUnbond(addrs[0], strconv.Itoa(int(leftBonded)+1))
got = deliverer.unbond(txUndelegate)
assert.Error(t, got, "expected unbond tx to fail")
msgUndelegate = NewMsgUnbond(addrs[0], strconv.Itoa(int(leftBonded)+1))
got = deliverer.unbond(msgUndelegate)
assert.Error(t, got, "expected unbond msg to fail")
// should be able to unbond just what we have
txUndelegate = NewMsgUnbond(addrs[0], strconv.Itoa(int(leftBonded)))
got = deliverer.unbond(txUndelegate)
assert.NoError(t, got, "expected unbond tx to pass")
msgUndelegate = NewMsgUnbond(addrs[0], strconv.Itoa(int(leftBonded)))
got = deliverer.unbond(msgUndelegate)
assert.NoError(t, got, "expected unbond msg to pass")
}
func TestMultipleMsgDeclareCandidacy(t *testing.T) {
initSender := int64(1000)
accStore := initAccounts(initSender)
ctx, accStore, mapper, deliverer := createTestInput(t, addrs[0], false, initSender)
addrs := []sdk.Address{addrs[0], addrs[1], addrs[2]}
mapper, deliverer := createTestInput(t, addrs[0], false)
// bond them all
for i, addr := range addrs {
txDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[i], pks[i], 10)
msgDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[i], pks[i], 10)
deliverer.sender = addr
got := deliverer.declareCandidacy(txDeclareCandidacy)
assert.NoError(t, got, "expected tx %d to be ok, got %v", i, got)
got := deliverer.declareCandidacy(msgDeclareCandidacy)
assert.NoError(t, got, "expected msg %d to be ok, got %v", i, got)
//Check that the account is bonded
candidates := mapper.loadCandidates()
require.Equal(t, i, len(candidates))
val := candidates[i]
balanceGot, balanceExpd := accStore[string(val.Address)], initSender-10
balanceExpd := initSender - 10
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, 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)
@ -176,39 +160,38 @@ func TestMultipleMsgDeclareCandidacy(t *testing.T) {
// unbond them all
for i, addr := range addrs {
candidatePre := mapper.loadCandidate(addrs[i])
txUndelegate := NewMsgUnbond(addrs[i], "10")
msgUndelegate := NewMsgUnbond(addrs[i], "10")
deliverer.sender = addr
got := deliverer.unbond(txUndelegate)
assert.NoError(t, got, "expected tx %d to be ok, got %v", i, got)
got := deliverer.unbond(msgUndelegate)
assert.NoError(t, got, "expected msg %d to be ok, got %v", i, got)
//Check that the account is unbonded
candidates := mapper.loadCandidates()
assert.Equal(t, len(addrs)-(i+1), len(candidates), "expected %d candidates got %d", len(addrs)-(i+1), len(candidates))
candidatePost := mapper.loadCandidate(addrs[i])
balanceGot, balanceExpd := accStore[string(candidatePre.Address)], initSender
balanceExpd := initSender
balanceGot := accStore.GetAccount(ctx, candidatePre.Address).GetCoins()
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)
}
}
func TestMultipleMsgDelegate(t *testing.T) {
//accStore := initAccounts(1000)
// XXX initalize values in accounts to 1000
sender, delegators := addrs[0], addrs[1:]
mapper, deliverer := createTestInput(t, addrs[0], false)
_, _, mapper, deliverer := createTestInput(t, addrs[0], false, 1000)
//first make a candidate
txDeclareCandidacy := newTestMsgDeclareCandidacy(sender, pks[0], 10)
got := deliverer.declareCandidacy(txDeclareCandidacy)
require.NoError(t, got, "expected tx to be ok, got %v", got)
msgDeclareCandidacy := newTestMsgDeclareCandidacy(sender, pks[0], 10)
got := deliverer.declareCandidacy(msgDeclareCandidacy)
require.NoError(t, got, "expected msg to be ok, got %v", got)
// delegate multiple parties
for i, delegator := range delegators {
txDelegate := newTestMsgDelegate(10, sender)
msgDelegate := newTestMsgDelegate(10, sender)
deliverer.sender = delegator
got := deliverer.delegate(txDelegate)
require.NoError(t, got, "expected tx %d to be ok, got %v", i, got)
got := deliverer.delegate(msgDelegate)
require.NoError(t, got, "expected msg %d to be ok, got %v", i, got)
//Check that the account is bonded
bond := mapper.loadDelegatorBond(delegator, sender)
@ -217,10 +200,10 @@ func TestMultipleMsgDelegate(t *testing.T) {
// unbond them all
for i, delegator := range delegators {
txUndelegate := NewMsgUnbond(sender, "10")
msgUndelegate := NewMsgUnbond(sender, "10")
deliverer.sender = delegator
got := deliverer.unbond(txUndelegate)
require.NoError(t, got, "expected tx %d to be ok, got %v", i, got)
got := deliverer.unbond(msgUndelegate)
require.NoError(t, got, "expected msg %d to be ok, got %v", i, got)
//Check that the account is unbonded
bond := mapper.loadDelegatorBond(delegator, sender)
@ -229,38 +212,36 @@ func TestMultipleMsgDelegate(t *testing.T) {
}
func TestVoidCandidacy(t *testing.T) {
// XXX use accountMapper to init all accounts to 1000
//accStore := initAccounts(1000)
sender, delegator := addrs[0], addrs[1]
_, deliverer := createTestInput(t, addrs[0], false)
_, _, _, deliverer := createTestInput(t, addrs[0], false, 1000)
// create the candidate
txDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], 10)
got := deliverer.declareCandidacy(txDeclareCandidacy)
msgDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], 10)
got := deliverer.declareCandidacy(msgDeclareCandidacy)
require.NoError(t, got, "expected no error on runMsgDeclareCandidacy")
// bond a delegator
txDelegate := newTestMsgDelegate(10, addrs[0])
msgDelegate := newTestMsgDelegate(10, addrs[0])
deliverer.sender = delegator
got = deliverer.delegate(txDelegate)
got = deliverer.delegate(msgDelegate)
require.NoError(t, got, "expected ok, got %v", got)
// unbond the candidates bond portion
txUndelegate := NewMsgUnbond(addrs[0], "10")
msgUndelegate := NewMsgUnbond(addrs[0], "10")
deliverer.sender = sender
got = deliverer.unbond(txUndelegate)
got = deliverer.unbond(msgUndelegate)
require.NoError(t, got, "expected no error on runMsgDeclareCandidacy")
// test that this pubkey cannot yet be bonded too
deliverer.sender = delegator
got = deliverer.delegate(txDelegate)
got = deliverer.delegate(msgDelegate)
assert.Error(t, got, "expected error, got %v", got)
// test that the delegator can still withdraw their bonds
got = deliverer.unbond(txUndelegate)
got = deliverer.unbond(msgUndelegate)
require.NoError(t, got, "expected no error on runMsgDeclareCandidacy")
// verify that the pubkey can now be reused
got = deliverer.declareCandidacy(txDeclareCandidacy)
got = deliverer.declareCandidacy(msgDeclareCandidacy)
assert.NoError(t, got, "expected ok, got %v", got)
}

4
x/stake/mapper_test.go
View File

@ -161,7 +161,7 @@ import (
//}
func TestState(t *testing.T) {
mapper, _ := createTestInput(t, nil, false)
_, _, mapper, _ := createTestInput(t, nil, false, 0)
addrDel := sdk.Address([]byte("addressdelegator"))
addrVal := sdk.Address([]byte("addressvalidator"))
@ -258,7 +258,7 @@ func TestState(t *testing.T) {
}
func TestGetValidators(t *testing.T) {
mapper, _ := createTestInput(t, nil, false)
_, _, mapper, _ := createTestInput(t, nil, false, 0)
candidatesFromAddrs(mapper, addrs, []int64{400, 200, 0, 0, 0})
validators := mapper.getValidators(5)

36
x/stake/test_common.go
View File

@ -75,11 +75,10 @@ func paramsNoInflation() Params {
}
// hogpodge of all sorts of input required for testing
//func createTestInput(t *testing.T, sender sdk.Address, isCheckTx bool) (sdk.KVStore, sdk.Context, sdk.StoreKey, Mapper, bank.CoinKeeper, transact) {
func createTestInput(t *testing.T, sender sdk.Address, isCheckTx bool) (Mapper, transact) {
func createTestInput(t *testing.T, sender sdk.Address, isCheckTx bool, initCoins int64) (sdk.Context, sdk.AccountMapper, Mapper, transact) {
db := dbm.NewMemDB()
keyMain := sdk.NewKVStoreKey("main")
keyStake := sdk.NewKVStoreKey("stake")
keyMain := keyStake //sdk.NewKVStoreKey("main") //XXX fix multistore
ms := store.NewCommitMultiStore(db)
ms.MountStoreWithDB(keyStake, sdk.StoreTypeIAVL, db)
@ -96,12 +95,17 @@ func createTestInput(t *testing.T, sender sdk.Address, isCheckTx bool) (Mapper,
&auth.BaseAccount{}, // prototype
)
ck := bank.NewCoinKeeper(accountMapper)
params := paramsNoInflation()
mapper.saveParams(params)
// fill all the addresses with some coins
for _, addr := range addrs {
ck.AddCoins(ctx, addr, sdk.Coins{{params.BondDenom, initCoins}})
}
tr := newTransact(ctx, sender, mapper, ck)
return mapper, tr
return ctx, accountMapper, mapper, tr
}
func newPubKey(pk string) (res crypto.PubKey) {
@ -130,7 +134,7 @@ var pks = []crypto.PubKey{
// for incode address generation
func testAddr(addr string) sdk.Address {
res, err := sdk.GetAddress("0XA58856F0FD53BF058B4909A21AEC019107BA6160")
res, err := sdk.GetAddress(addr)
if err != nil {
panic(err)
}
@ -139,16 +143,16 @@ func testAddr(addr string) sdk.Address {
// dummy addresses used for testing
var addrs = []sdk.Address{
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6160"),
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6161"),
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6162"),
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6163"),
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6164"),
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6165"),
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6166"),
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6167"),
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6168"),
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6169"),
testAddr("A58856F0FD53BF058B4909A21AEC019107BA6160"),
testAddr("A58856F0FD53BF058B4909A21AEC019107BA6161"),
testAddr("A58856F0FD53BF058B4909A21AEC019107BA6162"),
testAddr("A58856F0FD53BF058B4909A21AEC019107BA6163"),
testAddr("A58856F0FD53BF058B4909A21AEC019107BA6164"),
testAddr("A58856F0FD53BF058B4909A21AEC019107BA6165"),
testAddr("A58856F0FD53BF058B4909A21AEC019107BA6166"),
testAddr("A58856F0FD53BF058B4909A21AEC019107BA6167"),
testAddr("A58856F0FD53BF058B4909A21AEC019107BA6168"),
testAddr("A58856F0FD53BF058B4909A21AEC019107BA6169"),
}
// NOTE: PubKey is supposed to be the binaryBytes of the crypto.PubKey

4
x/stake/tick_test.go
View File

@ -8,7 +8,7 @@ import (
)
func TestGetInflation(t *testing.T) {
mapper, _ := createTestInput(t, nil, false)
_, _, mapper, _ := createTestInput(t, nil, false, 0)
params := mapper.loadParams()
gs := mapper.loadGlobalState()
@ -53,7 +53,7 @@ func TestGetInflation(t *testing.T) {
}
func TestProcessProvisions(t *testing.T) {
mapper, _ := createTestInput(t, nil, false)
_, _, mapper, _ := createTestInput(t, nil, false, 0)
params := mapper.loadParams()
gs := mapper.loadGlobalState()

6
x/stake/tx.go
View File

@ -49,9 +49,8 @@ func (msg MsgAddr) ValidateBasic() sdk.Error {
type MsgDeclareCandidacy struct {
MsgAddr
Description
Bond sdk.Coin `json:"bond"`
Address sdk.Address `json:"address"`
PubKey crypto.PubKey `json:"pubkey"`
Bond sdk.Coin `json:"bond"`
PubKey crypto.PubKey `json:"pubkey"`
}
func NewMsgDeclareCandidacy(address sdk.Address, pubkey crypto.PubKey, bond sdk.Coin, description Description) MsgDeclareCandidacy {
@ -59,7 +58,6 @@ func NewMsgDeclareCandidacy(address sdk.Address, pubkey crypto.PubKey, bond sdk.
MsgAddr: NewMsgAddr(address),
Description: description,
Bond: bond,
Address: address,
PubKey: pubkey,
}
}