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

tests compile

This commit is contained in:
rigelrozanski 2018-03-17 23:13:42 +01:00
parent 3f0d7edb06
commit acc5bda225
5 changed files with 61 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
x/stake/handler_test.go
View File

@ -40,7 +40,8 @@ func newTestMsgDelegate(amt int64, address sdk.Address) MsgDelegate {
} }
func TestDuplicatesMsgDeclareCandidacy(t *testing.T) { func TestDuplicatesMsgDeclareCandidacy(t *testing.T) {
accStore := initAccounts(1000) // for accounts //accStore := initAccounts(1000)
// XXX initalize values in accounts to 1000
_, deliverer := createTestInput(t, addrs[0], false) _, deliverer := createTestInput(t, addrs[0], false)
_, checker := createTestInput(t, addrs[0], true) _, checker := createTestInput(t, addrs[0], true)
@ -61,8 +62,9 @@ func TestDuplicatesMsgDeclareCandidacy(t *testing.T) {
} }
func TestIncrementsMsgDelegate(t *testing.T) { func TestIncrementsMsgDelegate(t *testing.T) {
initSender := int64(1000) //initSender := int64(1000)
accStore := initAccounts(initSender) // for accounts //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)
// first declare candidacy // first declare candidacy
@ -81,22 +83,23 @@ func TestIncrementsMsgDelegate(t *testing.T) {
//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.loadCandidates() candidates := mapper.loadCandidates()
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)] //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) //assert.Equal(t, expectedSender, gotSender, "i: %v, %v, %v", i, expectedSender, gotSender) // XXX fix
} }
} }
func TestIncrementsMsgUnbond(t *testing.T) { func TestIncrementsMsgUnbond(t *testing.T) {
initSender := int64(0) //initSender := int64(0)
accStore := initAccounts(initSender) // for accounts //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)
// set initial bond // set initial bond
initBond := int64(1000) initBond := int64(1000)
accStore[string(deliverer.sender)] = initBond //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 tx to be ok, got %v", got) assert.NoError(t, got, "expected initial bond tx to be ok, got %v", got)
@ -112,12 +115,12 @@ func TestIncrementsMsgUnbond(t *testing.T) {
//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.loadCandidates() candidates := mapper.loadCandidates()
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)] //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) //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
@ -183,49 +186,51 @@ func TestMultipleMsgDeclareCandidacy(t *testing.T) {
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.loadCandidate(addrs[i]) candidatePost := mapper.loadCandidate(addrs[i])
balanceGot, balanceExpd := accStore[string(candidatePre.Owner.Address)], initSender balanceGot, balanceExpd := accStore[string(candidatePre.Address)], initSender
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) {
accStore := initAccounts(1000) //accStore := initAccounts(1000)
// XXX initalize values in accounts to 1000
sender, delegators := addrs[0], addrs[1:] sender, delegators := addrs[0], addrs[1:]
mapper, deliverer := createTestInput(t, addrs[0], false) mapper, deliverer := createTestInput(t, addrs[0], false)
//first make a candidate //first make a candidate
txDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], 10) txDeclareCandidacy := newTestMsgDeclareCandidacy(sender, pks[0], 10)
got := deliverer.declareCandidacy(txDeclareCandidacy) got := deliverer.declareCandidacy(txDeclareCandidacy)
require.NoError(t, got, "expected tx to be ok, got %v", got) require.NoError(t, got, "expected tx to be ok, got %v", got)
// delegate multiple parties // delegate multiple parties
for i, delegator := range delegators { for i, delegator := range delegators {
txDelegate := newTestMsgDelegate(10, addrs[0]) txDelegate := newTestMsgDelegate(10, sender)
deliverer.sender = delegator deliverer.sender = delegator
got := deliverer.delegate(txDelegate) got := deliverer.delegate(txDelegate)
require.NoError(t, got, "expected tx %d to be ok, got %v", i, got) require.NoError(t, got, "expected tx %d to be ok, got %v", i, got)
//Check that the account is bonded //Check that the account is bonded
bond := mapper.loadDelegatorBond(delegator, addrs[0]) bond := mapper.loadDelegatorBond(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 {
txUndelegate := NewMsgUnbond(addrs[0], "10") txUndelegate := NewMsgUnbond(sender, "10")
deliverer.sender = delegator deliverer.sender = delegator
got := deliverer.unbond(txUndelegate) got := deliverer.unbond(txUndelegate)
require.NoError(t, got, "expected tx %d to be ok, got %v", i, got) require.NoError(t, got, "expected tx %d to be ok, got %v", i, got)
//Check that the account is unbonded //Check that the account is unbonded
bond := mapper.loadDelegatorBond(delegator, addrs[0]) bond := mapper.loadDelegatorBond(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) {
accStore := initAccounts(1000) // for accounts // XXX use accountMapper to init all accounts to 1000
//accStore := initAccounts(1000)
sender, delegator := addrs[0], addrs[1] sender, delegator := addrs[0], addrs[1]
_, deliverer := createTestInput(t, addrs[0], false) _, deliverer := createTestInput(t, addrs[0], false)

4
x/stake/mapper_test.go
View File

@ -222,7 +222,7 @@ func TestState(t *testing.T) {
} }
bondsEqual := func(b1, b2 *DelegatorBond) bool { bondsEqual := func(b1, b2 *DelegatorBond) bool {
return b1.PubKey.Equals(b2.PubKey) && return bytes.Equal(b1.Address, b2.Address) &&
b1.Shares == b2.Shares b1.Shares == b2.Shares
} }
@ -259,8 +259,6 @@ func TestState(t *testing.T) {
func TestGetValidators(t *testing.T) { func TestGetValidators(t *testing.T) {
mapper, _ := createTestInput(t, nil, false) mapper, _ := createTestInput(t, nil, false)
N := 5
addrs := newAddrs(N)
candidatesFromAddrs(mapper, addrs, []int64{400, 200, 0, 0, 0}) candidatesFromAddrs(mapper, addrs, []int64{400, 200, 0, 0, 0})
validators := mapper.getValidators(5) validators := mapper.getValidators(5)

5
x/stake/test_common.go
View File

@ -87,7 +87,6 @@ func createTestInput(t *testing.T, sender sdk.Address, isCheckTx bool) (Mapper,
require.Nil(t, err) require.Nil(t, err)
ctx := sdk.NewContext(ms, abci.Header{ChainID: "foochainid"}, isCheckTx, nil) ctx := sdk.NewContext(ms, abci.Header{ChainID: "foochainid"}, isCheckTx, nil)
store := ms.GetKVStore(keyStake)
cdc := makeTestCodec() cdc := makeTestCodec()
mapper := NewMapper(ctx, cdc, keyStake) mapper := NewMapper(ctx, cdc, keyStake)
@ -155,7 +154,7 @@ var addrs = []sdk.Address{
// NOTE: PubKey is supposed to be the binaryBytes of the crypto.PubKey // NOTE: PubKey is supposed to be the binaryBytes of the crypto.PubKey
// instead this is just being set the address here for testing purposes // instead this is just being set the address here for testing purposes
func candidatesFromAddrs(mapper Mapper, addrs []crypto.Address, amts []int64) { func candidatesFromAddrs(mapper Mapper, addrs []crypto.Address, amts []int64) {
for i := 0; i < len(addrs); i++ { for i := 0; i < len(amts); i++ {
c := &Candidate{ c := &Candidate{
Status: Unbonded, Status: Unbonded,
PubKey: pks[i], PubKey: pks[i],
@ -168,7 +167,7 @@ func candidatesFromAddrs(mapper Mapper, addrs []crypto.Address, amts []int64) {
} }
} }
func candidatesFromActorsEmpty(addrs []crypto.Address) (candidates Candidates) { func candidatesFromAddrsEmpty(addrs []crypto.Address) (candidates Candidates) {
for i := 0; i < len(addrs); i++ { for i := 0; i < len(addrs); i++ {
c := &Candidate{ c := &Candidate{
Status: Unbonded, Status: Unbonded,

46
x/stake/tick_test.go
View File

@ -8,9 +8,9 @@ import (
) )
func TestGetInflation(t *testing.T) { func TestGetInflation(t *testing.T) {
store, ctx, key := createTestInput(t, false) mapper, _ := createTestInput(t, nil, false)
params := loadParams(store) params := mapper.loadParams()
gs := loadGlobalState(store) gs := mapper.loadGlobalState()
// Governing Mechanism: // Governing Mechanism:
// bondedRatio = BondedPool / TotalSupply // bondedRatio = BondedPool / TotalSupply
@ -21,24 +21,24 @@ func TestGetInflation(t *testing.T) {
setInflation, expectedChange sdk.Rat setInflation, expectedChange sdk.Rat
}{ }{
// with 0% bonded atom supply the inflation should increase by InflationRateChange // with 0% bonded atom supply the inflation should increase by InflationRateChange
{0, 0, sdk.New(7, 100), params.InflationRateChange.Quo(hrsPerYr)}, {0, 0, sdk.NewRat(7, 100), params.InflationRateChange.Quo(hrsPerYr)},
// 100% bonded, starting at 20% inflation and being reduced // 100% bonded, starting at 20% inflation and being reduced
{1, 1, sdk.New(20, 100), sdk.One.Sub(sdk.One.Quo(params.GoalBonded)).Mul(params.InflationRateChange).Quo(hrsPerYr)}, {1, 1, sdk.NewRat(20, 100), sdk.OneRat.Sub(sdk.OneRat.Quo(params.GoalBonded)).Mul(params.InflationRateChange).Quo(hrsPerYr)},
// 50% bonded, starting at 10% inflation and being increased // 50% bonded, starting at 10% inflation and being increased
{1, 2, sdk.New(10, 100), sdk.One.Sub(sdk.New(1, 2).Quo(params.GoalBonded)).Mul(params.InflationRateChange).Quo(hrsPerYr)}, {1, 2, sdk.NewRat(10, 100), sdk.OneRat.Sub(sdk.NewRat(1, 2).Quo(params.GoalBonded)).Mul(params.InflationRateChange).Quo(hrsPerYr)},
// test 7% minimum stop (testing with 100% bonded) // test 7% minimum stop (testing with 100% bonded)
{1, 1, sdk.New(7, 100), sdk.Zero}, {1, 1, sdk.NewRat(7, 100), sdk.ZeroRat},
{1, 1, sdk.New(70001, 1000000), sdk.New(-1, 1000000)}, {1, 1, sdk.NewRat(70001, 1000000), sdk.NewRat(-1, 1000000)},
// test 20% maximum stop (testing with 0% bonded) // test 20% maximum stop (testing with 0% bonded)
{0, 0, sdk.New(20, 100), sdk.Zero}, {0, 0, sdk.NewRat(20, 100), sdk.ZeroRat},
{0, 0, sdk.New(199999, 1000000), sdk.New(1, 1000000)}, {0, 0, sdk.NewRat(199999, 1000000), sdk.NewRat(1, 1000000)},
// perfect balance shouldn't change inflation // perfect balance shouldn't change inflation
{67, 100, sdk.New(15, 100), sdk.Zero}, {67, 100, sdk.NewRat(15, 100), sdk.ZeroRat},
} }
for _, tc := range tests { for _, tc := range tests {
gs.BondedPool, gs.TotalSupply = tc.setBondedPool, tc.setTotalSupply gs.BondedPool, gs.TotalSupply = tc.setBondedPool, tc.setTotalSupply
@ -53,14 +53,12 @@ func TestGetInflation(t *testing.T) {
} }
func TestProcessProvisions(t *testing.T) { func TestProcessProvisions(t *testing.T) {
store, ctx, key := createTestInput(t, false) mapper, _ := createTestInput(t, nil, false)
params := loadParams(store) params := mapper.loadParams()
gs := loadGlobalState(store) gs := mapper.loadGlobalState()
// create some candidates some bonded, some unbonded // create some candidates some bonded, some unbonded
n := 10 candidates := candidatesFromAddrsEmpty(addrs)
actors := newActors(n)
candidates := candidatesFromActorsEmpty(actors)
for i, candidate := range candidates { for i, candidate := range candidates {
if i < 5 { if i < 5 {
candidate.Status = Bonded candidate.Status = Bonded
@ -68,14 +66,14 @@ func TestProcessProvisions(t *testing.T) {
mintedTokens := int64((i + 1) * 10000000) mintedTokens := int64((i + 1) * 10000000)
gs.TotalSupply += mintedTokens gs.TotalSupply += mintedTokens
candidate.addTokens(mintedTokens, gs) candidate.addTokens(mintedTokens, gs)
saveCandidate(store, candidate) mapper.saveCandidate(candidate)
} }
var totalSupply int64 = 550000000 var totalSupply int64 = 550000000
var bondedShares int64 = 150000000 var bondedShares int64 = 150000000
var unbondedShares int64 = 400000000 var unbondedShares int64 = 400000000
// initial bonded ratio ~ 27% // initial bonded ratio ~ 27%
assert.True(t, gs.bondedRatio().Equal(sdk.New(bondedShares, totalSupply)), "%v", gs.bondedRatio()) assert.True(t, gs.bondedRatio().Equal(sdk.NewRat(bondedShares, totalSupply)), "%v", gs.bondedRatio())
// Supplies // Supplies
assert.Equal(t, totalSupply, gs.TotalSupply) assert.Equal(t, totalSupply, gs.TotalSupply)
@ -83,7 +81,7 @@ func TestProcessProvisions(t *testing.T) {
assert.Equal(t, unbondedShares, gs.UnbondedPool) assert.Equal(t, unbondedShares, gs.UnbondedPool)
// test the value of candidate shares // test the value of candidate shares
assert.True(t, gs.bondedShareExRate().Equal(sdk.One), "%v", gs.bondedShareExRate()) assert.True(t, gs.bondedShareExRate().Equal(sdk.OneRat), "%v", gs.bondedShareExRate())
initialSupply := gs.TotalSupply initialSupply := gs.TotalSupply
initialUnbonded := gs.TotalSupply - gs.BondedPool initialUnbonded := gs.TotalSupply - gs.BondedPool
@ -91,10 +89,10 @@ func TestProcessProvisions(t *testing.T) {
// process the provisions a year // process the provisions a year
for hr := 0; hr < 8766; hr++ { for hr := 0; hr < 8766; hr++ {
expInflation := nextInflation(gs, params).Round(1000000000) expInflation := nextInflation(gs, params).Round(1000000000)
expProvisions := (expInflation.Mul(sdk.New(gs.TotalSupply)).Quo(hrsPerYr)).Evaluate() expProvisions := (expInflation.Mul(sdk.NewRat(gs.TotalSupply)).Quo(hrsPerYr)).Evaluate()
startBondedPool := gs.BondedPool startBondedPool := gs.BondedPool
startTotalSupply := gs.TotalSupply startTotalSupply := gs.TotalSupply
processProvisions(store, gs, params) processProvisions(mapper, gs, params)
assert.Equal(t, startBondedPool+expProvisions, gs.BondedPool) assert.Equal(t, startBondedPool+expProvisions, gs.BondedPool)
assert.Equal(t, startTotalSupply+expProvisions, gs.TotalSupply) assert.Equal(t, startTotalSupply+expProvisions, gs.TotalSupply)
} }
@ -103,7 +101,7 @@ func TestProcessProvisions(t *testing.T) {
//panic(fmt.Sprintf("debug total %v, bonded %v, diff %v\n", gs.TotalSupply, gs.BondedPool, gs.TotalSupply-gs.BondedPool)) //panic(fmt.Sprintf("debug total %v, bonded %v, diff %v\n", gs.TotalSupply, gs.BondedPool, gs.TotalSupply-gs.BondedPool))
// initial bonded ratio ~ 35% ~ 30% increase for bonded holders // initial bonded ratio ~ 35% ~ 30% increase for bonded holders
assert.True(t, gs.bondedRatio().Equal(sdk.New(105906511, 305906511)), "%v", gs.bondedRatio()) assert.True(t, gs.bondedRatio().Equal(sdk.NewRat(105906511, 305906511)), "%v", gs.bondedRatio())
// global supply // global supply
assert.Equal(t, int64(611813022), gs.TotalSupply) assert.Equal(t, int64(611813022), gs.TotalSupply)
@ -111,6 +109,6 @@ func TestProcessProvisions(t *testing.T) {
assert.Equal(t, unbondedShares, gs.UnbondedPool) assert.Equal(t, unbondedShares, gs.UnbondedPool)
// test the value of candidate shares // test the value of candidate shares
assert.True(t, gs.bondedShareExRate().Mul(sdk.New(bondedShares)).Equal(sdk.New(211813022)), "%v", gs.bondedShareExRate()) assert.True(t, gs.bondedShareExRate().Mul(sdk.NewRat(bondedShares)).Equal(sdk.NewRat(211813022)), "%v", gs.bondedShareExRate())
} }

48
x/stake/tx_test.go
View File

@ -6,7 +6,6 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
crypto "github.com/tendermint/go-crypto"
wire "github.com/tendermint/go-wire" wire "github.com/tendermint/go-wire"
sdk "github.com/cosmos/cosmos-sdk/types" sdk "github.com/cosmos/cosmos-sdk/types"
@ -30,8 +29,8 @@ func TestMsgAddrValidateBasic(t *testing.T) {
address sdk.Address address sdk.Address
wantErr bool wantErr bool
}{ }{
{"basic good", pks[0], false}, {"basic good", addrs[0], false},
{"empty delegator", crypto.PubKey{}, true}, {"empty delegator", sdk.Address{}, true},
} }
for _, tc := range tests { for _, tc := range tests {
@ -53,49 +52,24 @@ func TestValidateCoin(t *testing.T) {
} }
for _, tc := range tests { for _, tc := range tests {
assert.Equal(t, tc.wantErr, tx.validateCoin(tc.coin) != nil, assert.Equal(t, tc.wantErr, validateCoin(tc.coin) != nil,
"test: %v, tx.ValidateBasic: %v", tc.name, tx.ValidateBasic()) "test: %v, tx.ValidateBasic: %v", tc.name, validateCoin(tc.coin))
} }
} }
func TestAllAreTx(t *testing.T) { func TestSerializeMsg(t *testing.T) {
// make sure all types construct properly // make sure all types construct properly
pubKey := newPubKey("1234567890")
bondAmt := 1234321 bondAmt := 1234321
bond := sdk.Coin{Denom: "ATOM", Amount: int64(bondAmt)} bond := sdk.Coin{Denom: "atom", Amount: int64(bondAmt)}
txDelegate := NewMsgDelegate(bond, pubKey)
_, ok := txDelegate.(MsgDelegate)
assert.True(t, ok, "%#v", txDelegate)
txUnbond := NewMsgUnbond(strconv.Itoa(bondAmt), pubKey)
_, ok = txUnbond.(MsgUnbond)
assert.True(t, ok, "%#v", txUnbond)
txDecl := NewMsgDeclareCandidacy(bond, pubKey, Description{})
_, ok = txDecl.(MsgDeclareCandidacy)
assert.True(t, ok, "%#v", txDecl)
txEditCan := NewMsgEditCandidacy(pubKey, Description{})
_, ok = txEditCan.(MsgEditCandidacy)
assert.True(t, ok, "%#v", txEditCan)
}
func TestSerializeTx(t *testing.T) {
// make sure all types construct properly
pubKey := newPubKey("1234567890")
bondAmt := 1234321
bond := sdk.Coin{Denom: "ATOM", Amount: int64(bondAmt)}
tests := []struct { tests := []struct {
tx sdk.Tx tx sdk.Msg
}{ }{
{NewMsgUnbond(strconv.Itoa(bondAmt), pubKey)}, {NewMsgDeclareCandidacy(addrs[0], pks[0], bond, Description{})},
{NewMsgDeclareCandidacy(bond, pubKey, Description{})}, {NewMsgEditCandidacy(addrs[0], Description{})},
{NewMsgDeclareCandidacy(bond, pubKey, Description{})}, {NewMsgDelegate(addrs[0], bond)},
// {NewTxRevokeCandidacy(pubKey)}, {NewMsgUnbond(addrs[0], strconv.Itoa(bondAmt))},
} }
for i, tc := range tests { for i, tc := range tests {