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) {
accStore := initAccounts(1000) // for accounts
//accStore := initAccounts(1000)
// XXX initalize values in accounts to 1000
_, deliverer := createTestInput(t, addrs[0], false)
_, checker := createTestInput(t, addrs[0], true)
@ -61,8 +62,9 @@ func TestDuplicatesMsgDeclareCandidacy(t *testing.T) {
}
func TestIncrementsMsgDelegate(t *testing.T) {
initSender := int64(1000)
accStore := initAccounts(initSender) // for accounts
//initSender := int64(1000)
//accStore := initAccounts(initSender) // for accounts
// XXX initalize values in accounts to 1000
mapper, deliverer := createTestInput(t, addrs[0], false)
// first declare candidacy
@ -81,22 +83,23 @@ func TestIncrementsMsgDelegate(t *testing.T) {
//Check that the accounts and the bond account have the appropriate values
candidates := mapper.loadCandidates()
expectedBond += bondAmount
expectedSender := initSender - expectedBond
//expectedSender := initSender - expectedBond
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, 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) {
initSender := int64(0)
accStore := initAccounts(initSender) // for accounts
//initSender := int64(0)
//accStore := initAccounts(initSender) // for accounts
// XXX initalize values in accounts to 0
mapper, deliverer := createTestInput(t, addrs[0], false)
// set initial bond
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))
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
candidates := mapper.loadCandidates()
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()
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, 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
@ -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))
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.Equal(t, balanceExpd, balanceGot, "expected account to have %d, got %d", balanceExpd, balanceGot)
}
}
func TestMultipleMsgDelegate(t *testing.T) {
accStore := initAccounts(1000)
//accStore := initAccounts(1000)
// XXX initalize values in accounts to 1000
sender, delegators := addrs[0], addrs[1:]
mapper, deliverer := createTestInput(t, addrs[0], false)
//first make a candidate
txDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], 10)
txDeclareCandidacy := newTestMsgDeclareCandidacy(sender, pks[0], 10)
got := deliverer.declareCandidacy(txDeclareCandidacy)
require.NoError(t, got, "expected tx to be ok, got %v", got)
// delegate multiple parties
for i, delegator := range delegators {
txDelegate := newTestMsgDelegate(10, addrs[0])
txDelegate := newTestMsgDelegate(10, sender)
deliverer.sender = delegator
got := deliverer.delegate(txDelegate)
require.NoError(t, got, "expected tx %d to be ok, got %v", i, got)
//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)
}
// unbond them all
for i, delegator := range delegators {
txUndelegate := NewMsgUnbond(addrs[0], "10")
txUndelegate := NewMsgUnbond(sender, "10")
deliverer.sender = delegator
got := deliverer.unbond(txUndelegate)
require.NoError(t, got, "expected tx %d to be ok, got %v", i, got)
//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)
}
}
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]
_, 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 {
return b1.PubKey.Equals(b2.PubKey) &&
return bytes.Equal(b1.Address, b2.Address) &&
b1.Shares == b2.Shares
}
@ -259,8 +259,6 @@ func TestState(t *testing.T) {
func TestGetValidators(t *testing.T) {
mapper, _ := createTestInput(t, nil, false)
N := 5
addrs := newAddrs(N)
candidatesFromAddrs(mapper, addrs, []int64{400, 200, 0, 0, 0})
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)
ctx := sdk.NewContext(ms, abci.Header{ChainID: "foochainid"}, isCheckTx, nil)
store := ms.GetKVStore(keyStake)
cdc := makeTestCodec()
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
// instead this is just being set the address here for testing purposes
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{
Status: Unbonded,
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++ {
c := &Candidate{
Status: Unbonded,

46
x/stake/tick_test.go
View File

@ -8,9 +8,9 @@ import (
)
func TestGetInflation(t *testing.T) {
store, ctx, key := createTestInput(t, false)
params := loadParams(store)
gs := loadGlobalState(store)
mapper, _ := createTestInput(t, nil, false)
params := mapper.loadParams()
gs := mapper.loadGlobalState()
// Governing Mechanism:
// bondedRatio = BondedPool / TotalSupply
@ -21,24 +21,24 @@ func TestGetInflation(t *testing.T) {
setInflation, expectedChange sdk.Rat
}{
// 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
{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
{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)
{1, 1, sdk.New(7, 100), sdk.Zero},
{1, 1, sdk.New(70001, 1000000), sdk.New(-1, 1000000)},
{1, 1, sdk.NewRat(7, 100), sdk.ZeroRat},
{1, 1, sdk.NewRat(70001, 1000000), sdk.NewRat(-1, 1000000)},
// test 20% maximum stop (testing with 0% bonded)
{0, 0, sdk.New(20, 100), sdk.Zero},
{0, 0, sdk.New(199999, 1000000), sdk.New(1, 1000000)},
{0, 0, sdk.NewRat(20, 100), sdk.ZeroRat},
{0, 0, sdk.NewRat(199999, 1000000), sdk.NewRat(1, 1000000)},
// 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 {
gs.BondedPool, gs.TotalSupply = tc.setBondedPool, tc.setTotalSupply
@ -53,14 +53,12 @@ func TestGetInflation(t *testing.T) {
}
func TestProcessProvisions(t *testing.T) {
store, ctx, key := createTestInput(t, false)
params := loadParams(store)
gs := loadGlobalState(store)
mapper, _ := createTestInput(t, nil, false)
params := mapper.loadParams()
gs := mapper.loadGlobalState()
// create some candidates some bonded, some unbonded
n := 10
actors := newActors(n)
candidates := candidatesFromActorsEmpty(actors)
candidates := candidatesFromAddrsEmpty(addrs)
for i, candidate := range candidates {
if i < 5 {
candidate.Status = Bonded
@ -68,14 +66,14 @@ func TestProcessProvisions(t *testing.T) {
mintedTokens := int64((i + 1) * 10000000)
gs.TotalSupply += mintedTokens
candidate.addTokens(mintedTokens, gs)
saveCandidate(store, candidate)
mapper.saveCandidate(candidate)
}
var totalSupply int64 = 550000000
var bondedShares int64 = 150000000
var unbondedShares int64 = 400000000
// 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
assert.Equal(t, totalSupply, gs.TotalSupply)
@ -83,7 +81,7 @@ func TestProcessProvisions(t *testing.T) {
assert.Equal(t, unbondedShares, gs.UnbondedPool)
// 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
initialUnbonded := gs.TotalSupply - gs.BondedPool
@ -91,10 +89,10 @@ func TestProcessProvisions(t *testing.T) {
// process the provisions a year
for hr := 0; hr < 8766; hr++ {
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
startTotalSupply := gs.TotalSupply
processProvisions(store, gs, params)
processProvisions(mapper, gs, params)
assert.Equal(t, startBondedPool+expProvisions, gs.BondedPool)
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))
// 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
assert.Equal(t, int64(611813022), gs.TotalSupply)
@ -111,6 +109,6 @@ func TestProcessProvisions(t *testing.T) {
assert.Equal(t, unbondedShares, gs.UnbondedPool)
// 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"
crypto "github.com/tendermint/go-crypto"
wire "github.com/tendermint/go-wire"
sdk "github.com/cosmos/cosmos-sdk/types"
@ -30,8 +29,8 @@ func TestMsgAddrValidateBasic(t *testing.T) {
address sdk.Address
wantErr bool
}{
{"basic good", pks[0], false},
{"empty delegator", crypto.PubKey{}, true},
{"basic good", addrs[0], false},
{"empty delegator", sdk.Address{}, true},
}
for _, tc := range tests {
@ -53,49 +52,24 @@ func TestValidateCoin(t *testing.T) {
}
for _, tc := range tests {
assert.Equal(t, tc.wantErr, tx.validateCoin(tc.coin) != nil,
"test: %v, tx.ValidateBasic: %v", tc.name, tx.ValidateBasic())
assert.Equal(t, tc.wantErr, validateCoin(tc.coin) != nil,
"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
pubKey := newPubKey("1234567890")
bondAmt := 1234321
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)}
bond := sdk.Coin{Denom: "atom", Amount: int64(bondAmt)}
tests := []struct {
tx sdk.Tx
tx sdk.Msg
}{
{NewMsgUnbond(strconv.Itoa(bondAmt), pubKey)},
{NewMsgDeclareCandidacy(bond, pubKey, Description{})},
{NewMsgDeclareCandidacy(bond, pubKey, Description{})},
// {NewTxRevokeCandidacy(pubKey)},
{NewMsgDeclareCandidacy(addrs[0], pks[0], bond, Description{})},
{NewMsgEditCandidacy(addrs[0], Description{})},
{NewMsgDelegate(addrs[0], bond)},
{NewMsgUnbond(addrs[0], strconv.Itoa(bondAmt))},
}
for i, tc := range tests {