fixing tests, working on TestUpdateSharesLocation
This commit is contained in:
rigelrozanski
parent
67123a3a46
commit
dc3c40fecc
|
|
@ -410,7 +410,6 @@ func TestStakeMsgs(t *testing.T) {
|
|||
require.Equal(t, addr1, validator.Address)
|
||||
require.Equal(t, sdk.Bonded, validator.Status)
|
||||
require.True(sdk.RatEq(t, sdk.NewRat(10), validator.BondedShares))
|
||||
require.True(sdk.RatEq(t, sdk.NewRat(1), validator.DelegatorShareExRate()))
|
||||
|
||||
// check the bond that should have been created as well
|
||||
bond, found := gapp.stakeKeeper.GetDelegation(ctxDeliver, addr1, addr1)
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ func TestIncrementsMsgDelegate(t *testing.T) {
|
|||
validator, found := keeper.GetValidator(ctx, validatorAddr)
|
||||
require.True(t, found)
|
||||
assert.Equal(t, bondAmount, validator.DelegatorShares.Evaluate())
|
||||
assert.Equal(t, bondAmount, validator.BondedShares.Evaluate())
|
||||
assert.Equal(t, bondAmount, validator.BondedShares.Evaluate(), "validator: %v", validator)
|
||||
|
||||
// just send the same msgbond multiple times
|
||||
msgDelegate := newTestMsgDelegate(delegatorAddr, validatorAddr, bondAmount)
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@ package stake
|
|||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
|
||||
sdk "github.com/cosmos/cosmos-sdk/types"
|
||||
"github.com/cosmos/cosmos-sdk/wire"
|
||||
|
|
@ -123,12 +124,15 @@ func (k Keeper) setValidator(ctx sdk.Context, validator Validator) {
|
|||
|
||||
// update the validator set for this validator
|
||||
valIsNowBonded := k.updateValidators(ctx, store, validator.Address)
|
||||
fmt.Printf("debug valIsNowBonded: %v\n", valIsNowBonded)
|
||||
fmt.Printf("debug validator0: %v\n", validator)
|
||||
|
||||
if oldValidator.Status != sdk.Bonded && valIsNowBonded {
|
||||
validator.Status = sdk.Bonded
|
||||
validator, pool = validator.UpdateSharesLocation(pool)
|
||||
k.setPool(ctx, pool)
|
||||
}
|
||||
fmt.Printf("debug validator1: %v\n", validator)
|
||||
|
||||
return
|
||||
}
|
||||
|
|
|
|||
|
|
@ -26,6 +26,7 @@ var (
|
|||
// This function tests setValidator, GetValidator, GetValidatorsBonded, removeValidator
|
||||
func TestValidatorBasics(t *testing.T) {
|
||||
ctx, _, keeper := createTestInput(t, false, 0)
|
||||
pool := keeper.GetPool(ctx)
|
||||
|
||||
//construct the validators
|
||||
var validators [3]Validator
|
||||
|
|
@ -33,13 +34,12 @@ func TestValidatorBasics(t *testing.T) {
|
|||
for i, amt := range amts {
|
||||
validators[i] = NewValidator(addrVals[i], pks[i], Description{})
|
||||
validators[i].Status = sdk.Bonded
|
||||
validators[i].BondedShares = sdk.NewRat(amt)
|
||||
validators[i].DelegatorShares = sdk.NewRat(amt)
|
||||
validators[i].addTokens(pool, amt)
|
||||
}
|
||||
|
||||
// check the empty keeper first
|
||||
_, found := keeper.GetValidator(ctx, addrVals[0])
|
||||
UnbondedSharesassert.False(t, found)
|
||||
assert.False(t, found)
|
||||
resVals := keeper.GetValidatorsBonded(ctx)
|
||||
assert.Zero(t, len(resVals))
|
||||
|
||||
|
|
@ -172,8 +172,6 @@ func GetValidatorSortingMixed(t *testing.T) {
|
|||
params.MaxValidators = 2
|
||||
keeper.setParams(ctx, params)
|
||||
|
||||
pool := keeper.GetPool(ctx)
|
||||
|
||||
// initialize some validators into the state
|
||||
amts := []int64{0, 100, 1, 400, 200}
|
||||
|
||||
|
|
@ -191,11 +189,21 @@ func GetValidatorSortingMixed(t *testing.T) {
|
|||
for i := range amts {
|
||||
keeper.setValidator(ctx, validators[i])
|
||||
}
|
||||
assert.Equal(t, sdk.Unbonded, keeper.GetValidator(ctx, addr[0]).Status)
|
||||
assert.Equal(t, sdk.Unbonded, keeper.GetValidator(ctx, addr[1]).Status)
|
||||
assert.Equal(t, sdk.Unbonded, keeper.GetValidator(ctx, addr[2]).Status)
|
||||
assert.Equal(t, sdk.Bonded, keeper.GetValidator(ctx, addr[3]).Status)
|
||||
assert.Equal(t, sdk.Bonded, keeper.GetValidator(ctx, addr[4]).Status)
|
||||
val0, found := keeper.GetValidator(ctx, addrs[0])
|
||||
require.True(t, found)
|
||||
val1, found := keeper.GetValidator(ctx, addrs[1])
|
||||
require.True(t, found)
|
||||
val2, found := keeper.GetValidator(ctx, addrs[2])
|
||||
require.True(t, found)
|
||||
val3, found := keeper.GetValidator(ctx, addrs[3])
|
||||
require.True(t, found)
|
||||
val4, found := keeper.GetValidator(ctx, addrs[4])
|
||||
require.True(t, found)
|
||||
assert.Equal(t, sdk.Unbonded, val0.Status)
|
||||
assert.Equal(t, sdk.Unbonded, val1.Status)
|
||||
assert.Equal(t, sdk.Unbonded, val2.Status)
|
||||
assert.Equal(t, sdk.Bonded, val3.Status)
|
||||
assert.Equal(t, sdk.Bonded, val4.Status)
|
||||
|
||||
// first make sure everything made it in to the gotValidator group
|
||||
gotValidators := keeper.GetValidatorsBondedByPower(ctx)
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ func TestBondedRatio(t *testing.T) {
|
|||
ctx, _, keeper := createTestInput(t, false, 0)
|
||||
pool := keeper.GetPool(ctx)
|
||||
pool.TotalSupply = 3
|
||||
pool.BondedPool = 2
|
||||
pool.BondedTokens = 2
|
||||
|
||||
// bonded pool / total supply
|
||||
require.Equal(t, pool.bondedRatio(), sdk.NewRat(2).Quo(sdk.NewRat(3)))
|
||||
|
|
@ -26,7 +26,7 @@ func TestBondedRatio(t *testing.T) {
|
|||
func TestBondedShareExRate(t *testing.T) {
|
||||
ctx, _, keeper := createTestInput(t, false, 0)
|
||||
pool := keeper.GetPool(ctx)
|
||||
pool.BondedPool = 3
|
||||
pool.BondedTokens = 3
|
||||
pool.BondedShares = sdk.NewRat(10)
|
||||
|
||||
// bonded pool / bonded shares
|
||||
|
|
@ -40,7 +40,7 @@ func TestBondedShareExRate(t *testing.T) {
|
|||
func TestUnbondingShareExRate(t *testing.T) {
|
||||
ctx, _, keeper := createTestInput(t, false, 0)
|
||||
pool := keeper.GetPool(ctx)
|
||||
pool.UnbondingPool = 3
|
||||
pool.UnbondingTokens = 3
|
||||
pool.UnbondingShares = sdk.NewRat(10)
|
||||
|
||||
// unbonding pool / unbonding shares
|
||||
|
|
@ -54,7 +54,7 @@ func TestUnbondingShareExRate(t *testing.T) {
|
|||
func TestUnbondedShareExRate(t *testing.T) {
|
||||
ctx, _, keeper := createTestInput(t, false, 0)
|
||||
pool := keeper.GetPool(ctx)
|
||||
pool.UnbondedPool = 3
|
||||
pool.UnbondedTokens = 3
|
||||
pool.UnbondedShares = sdk.NewRat(10)
|
||||
|
||||
// unbonded pool / unbonded shares
|
||||
|
|
@ -75,10 +75,10 @@ func TestAddTokensBonded(t *testing.T) {
|
|||
|
||||
// correct changes to bonded shares and bonded pool
|
||||
assert.Equal(t, poolB.BondedShares, poolA.BondedShares.Add(sharesB))
|
||||
assert.Equal(t, poolB.BondedPool, poolA.BondedPool+10)
|
||||
assert.Equal(t, poolB.BondedTokens, poolA.BondedTokens+10)
|
||||
|
||||
// same number of bonded shares / tokens when exchange rate is one
|
||||
assert.True(t, poolB.BondedShares.Equal(sdk.NewRat(poolB.BondedPool)))
|
||||
assert.True(t, poolB.BondedShares.Equal(sdk.NewRat(poolB.BondedTokens)))
|
||||
}
|
||||
|
||||
func TestRemoveSharesBonded(t *testing.T) {
|
||||
|
|
@ -91,10 +91,10 @@ func TestRemoveSharesBonded(t *testing.T) {
|
|||
|
||||
// correct changes to bonded shares and bonded pool
|
||||
assert.Equal(t, poolB.BondedShares, poolA.BondedShares.Sub(sdk.NewRat(10)))
|
||||
assert.Equal(t, poolB.BondedPool, poolA.BondedPool-tokensB)
|
||||
assert.Equal(t, poolB.BondedTokens, poolA.BondedTokens-tokensB)
|
||||
|
||||
// same number of bonded shares / tokens when exchange rate is one
|
||||
assert.True(t, poolB.BondedShares.Equal(sdk.NewRat(poolB.BondedPool)))
|
||||
assert.True(t, poolB.BondedShares.Equal(sdk.NewRat(poolB.BondedTokens)))
|
||||
}
|
||||
|
||||
func TestAddTokensUnbonded(t *testing.T) {
|
||||
|
|
@ -107,10 +107,10 @@ func TestAddTokensUnbonded(t *testing.T) {
|
|||
|
||||
// correct changes to unbonded shares and unbonded pool
|
||||
assert.Equal(t, poolB.UnbondedShares, poolA.UnbondedShares.Add(sharesB))
|
||||
assert.Equal(t, poolB.UnbondedPool, poolA.UnbondedPool+10)
|
||||
assert.Equal(t, poolB.UnbondedTokens, poolA.UnbondedTokens+10)
|
||||
|
||||
// same number of unbonded shares / tokens when exchange rate is one
|
||||
assert.True(t, poolB.UnbondedShares.Equal(sdk.NewRat(poolB.UnbondedPool)))
|
||||
assert.True(t, poolB.UnbondedShares.Equal(sdk.NewRat(poolB.UnbondedTokens)))
|
||||
}
|
||||
|
||||
func TestRemoveSharesUnbonded(t *testing.T) {
|
||||
|
|
@ -123,8 +123,8 @@ func TestRemoveSharesUnbonded(t *testing.T) {
|
|||
|
||||
// correct changes to unbonded shares and bonded pool
|
||||
assert.Equal(t, poolB.UnbondedShares, poolA.UnbondedShares.Sub(sdk.NewRat(10)))
|
||||
assert.Equal(t, poolB.UnbondedPool, poolA.UnbondedPool-tokensB)
|
||||
assert.Equal(t, poolB.UnbondedTokens, poolA.UnbondedTokens-tokensB)
|
||||
|
||||
// same number of unbonded shares / tokens when exchange rate is one
|
||||
assert.True(t, poolB.UnbondedShares.Equal(sdk.NewRat(poolB.UnbondedPool)))
|
||||
assert.True(t, poolB.UnbondedShares.Equal(sdk.NewRat(poolB.UnbondedTokens)))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ func TestGetInflation(t *testing.T) {
|
|||
hrsPerYrRat := sdk.NewRat(hrsPerYr)
|
||||
|
||||
// Governing Mechanism:
|
||||
// bondedRatio = BondedPool / TotalSupply
|
||||
// bondedRatio = BondedTokens / TotalSupply
|
||||
// inflationRateChangePerYear = (1- bondedRatio/ GoalBonded) * MaxInflationRateChange
|
||||
|
||||
tests := []struct {
|
||||
|
|
@ -47,7 +47,7 @@ func TestGetInflation(t *testing.T) {
|
|||
{"test 8", 67, 100, sdk.NewRat(15, 100), sdk.ZeroRat()},
|
||||
}
|
||||
for _, tc := range tests {
|
||||
pool.BondedPool, pool.TotalSupply = tc.setBondedPool, tc.setTotalSupply
|
||||
pool.BondedTokens, pool.TotalSupply = tc.setBondedPool, tc.setTotalSupply
|
||||
pool.Inflation = tc.setInflation
|
||||
keeper.setPool(ctx, pool)
|
||||
|
||||
|
|
@ -90,8 +90,8 @@ func TestProcessProvisions(t *testing.T) {
|
|||
var bondedShares int64 = 150000000
|
||||
var unbondedShares int64 = 400000000
|
||||
assert.Equal(t, totalSupply, pool.TotalSupply)
|
||||
assert.Equal(t, bondedShares, pool.BondedPool)
|
||||
assert.Equal(t, unbondedShares, pool.UnbondedPool)
|
||||
assert.Equal(t, bondedShares, pool.BondedTokens)
|
||||
assert.Equal(t, unbondedShares, pool.UnbondedTokens)
|
||||
|
||||
// initial bonded ratio ~ 27%
|
||||
assert.True(t, pool.bondedRatio().Equal(sdk.NewRat(bondedShares, totalSupply)), "%v", pool.bondedRatio())
|
||||
|
|
@ -100,33 +100,33 @@ func TestProcessProvisions(t *testing.T) {
|
|||
assert.True(t, pool.bondedShareExRate().Equal(sdk.OneRat()), "%v", pool.bondedShareExRate())
|
||||
|
||||
initialSupply := pool.TotalSupply
|
||||
initialUnbonded := pool.TotalSupply - pool.BondedPool
|
||||
initialUnbonded := pool.TotalSupply - pool.BondedTokens
|
||||
|
||||
// process the provisions a year
|
||||
for hr := 0; hr < 8766; hr++ {
|
||||
pool := keeper.GetPool(ctx)
|
||||
expInflation := keeper.nextInflation(ctx).Round(1000000000)
|
||||
expProvisions := (expInflation.Mul(sdk.NewRat(pool.TotalSupply)).Quo(hrsPerYrRat)).Evaluate()
|
||||
startBondedPool := pool.BondedPool
|
||||
startBondedPool := pool.BondedTokens
|
||||
startTotalSupply := pool.TotalSupply
|
||||
pool = keeper.processProvisions(ctx)
|
||||
keeper.setPool(ctx, pool)
|
||||
//fmt.Printf("hr %v, startBondedPool %v, expProvisions %v, pool.BondedPool %v\n", hr, startBondedPool, expProvisions, pool.BondedPool)
|
||||
require.Equal(t, startBondedPool+expProvisions, pool.BondedPool, "hr %v", hr)
|
||||
//fmt.Printf("hr %v, startBondedPool %v, expProvisions %v, pool.BondedTokens %v\n", hr, startBondedPool, expProvisions, pool.BondedTokens)
|
||||
require.Equal(t, startBondedPool+expProvisions, pool.BondedTokens, "hr %v", hr)
|
||||
require.Equal(t, startTotalSupply+expProvisions, pool.TotalSupply)
|
||||
}
|
||||
pool = keeper.GetPool(ctx)
|
||||
assert.NotEqual(t, initialSupply, pool.TotalSupply)
|
||||
assert.Equal(t, initialUnbonded, pool.UnbondedPool)
|
||||
//panic(fmt.Sprintf("debug total %v, bonded %v, diff %v\n", p.TotalSupply, p.BondedPool, pool.TotalSupply-pool.BondedPool))
|
||||
assert.Equal(t, initialUnbonded, pool.UnbondedTokens)
|
||||
//panic(fmt.Sprintf("debug total %v, bonded %v, diff %v\n", p.TotalSupply, p.BondedTokens, pool.TotalSupply-pool.BondedTokens))
|
||||
|
||||
// initial bonded ratio ~ from 27% to 40% increase for bonded holders ownership of total supply
|
||||
assert.True(t, pool.bondedRatio().Equal(sdk.NewRat(211813022, 611813022)), "%v", pool.bondedRatio())
|
||||
|
||||
// global supply
|
||||
assert.Equal(t, int64(611813022), pool.TotalSupply)
|
||||
assert.Equal(t, int64(211813022), pool.BondedPool)
|
||||
assert.Equal(t, unbondedShares, pool.UnbondedPool)
|
||||
assert.Equal(t, int64(211813022), pool.BondedTokens)
|
||||
assert.Equal(t, unbondedShares, pool.UnbondedTokens)
|
||||
|
||||
// test the value of validator shares
|
||||
assert.True(t, pool.bondedShareExRate().Mul(sdk.NewRat(bondedShares)).Equal(sdk.NewRat(211813022)), "%v", pool.bondedShareExRate())
|
||||
|
|
|
|||
|
|
@ -139,7 +139,6 @@ func (v Validator) abciValidatorZero(cdc *wire.Codec) abci.Validator {
|
|||
}
|
||||
}
|
||||
|
||||
// XXX write test
|
||||
// update the location of the shares within a validator if its bond status has changed
|
||||
func (v Validator) UpdateSharesLocation(p Pool) (Validator, Pool) {
|
||||
var tokens int64
|
||||
|
|
|
|||
|
|
@ -10,32 +10,58 @@ import (
|
|||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
func TestAddTokens(t *testing.T) {
|
||||
func TestAddTokensValidatorBonded(t *testing.T) {
|
||||
ctx, _, keeper := createTestInput(t, false, 0)
|
||||
|
||||
poolA := keeper.GetPool(ctx)
|
||||
valA := Validator{
|
||||
Status: sdk.Bonded,
|
||||
Address: addrs[0],
|
||||
PubKey: pks[0],
|
||||
BondedShares: sdk.NewRat(9),
|
||||
DelegatorShares: sdk.NewRat(9),
|
||||
}
|
||||
poolA.BondedPool = valA.BondedShares.Evaluate()
|
||||
poolA.BondedShares = valA.BondedShares
|
||||
assert.Equal(t, valA.DelegatorShareExRate(), sdk.OneRat())
|
||||
assert.Equal(t, poolA.bondedShareExRate(), sdk.OneRat())
|
||||
assert.Equal(t, poolA.unbondedShareExRate(), sdk.OneRat())
|
||||
valB, poolB, sharesB := valA.addTokens(poolA, 10)
|
||||
pool := keeper.GetPool(ctx)
|
||||
val := NewValidator(addrs[0], pks[0], Description{})
|
||||
val.Status = sdk.Bonded
|
||||
val, pool, delShares := val.addTokens(pool, 10)
|
||||
|
||||
// shares were issued
|
||||
assert.Equal(t, sdk.NewRat(10).Mul(valA.DelegatorShareExRate()), sharesB)
|
||||
// pool shares were added
|
||||
assert.Equal(t, valB.BondedShares, valA.BondedShares.Add(sdk.NewRat(10)))
|
||||
// conservation of tokens
|
||||
assert.Equal(t, poolB.BondedPool, 10+poolA.BondedPool)
|
||||
assert.Equal(t, sdk.OneRat(), val.DelegatorShareExRate(pool))
|
||||
assert.Equal(t, sdk.OneRat(), pool.bondedShareExRate())
|
||||
assert.Equal(t, sdk.OneRat(), pool.unbondingShareExRate())
|
||||
assert.Equal(t, sdk.OneRat(), pool.unbondedShareExRate())
|
||||
|
||||
assert.True(sdk.RatEq(t, sdk.NewRat(10), delShares))
|
||||
assert.True(sdk.RatEq(t, sdk.NewRat(10), val.BondedShares))
|
||||
}
|
||||
|
||||
func TestAddTokensValidatorUnbonding(t *testing.T) {
|
||||
ctx, _, keeper := createTestInput(t, false, 0)
|
||||
|
||||
pool := keeper.GetPool(ctx)
|
||||
val := NewValidator(addrs[0], pks[0], Description{})
|
||||
val.Status = sdk.Unbonding
|
||||
val, pool, delShares := val.addTokens(pool, 10)
|
||||
|
||||
assert.Equal(t, sdk.OneRat(), val.DelegatorShareExRate(pool))
|
||||
assert.Equal(t, sdk.OneRat(), pool.bondedShareExRate())
|
||||
assert.Equal(t, sdk.OneRat(), pool.unbondingShareExRate())
|
||||
assert.Equal(t, sdk.OneRat(), pool.unbondedShareExRate())
|
||||
|
||||
assert.True(sdk.RatEq(t, sdk.NewRat(10), delShares))
|
||||
assert.True(sdk.RatEq(t, sdk.NewRat(10), val.UnbondingShares))
|
||||
}
|
||||
|
||||
func TestAddTokensValidatorUnbonded(t *testing.T) {
|
||||
ctx, _, keeper := createTestInput(t, false, 0)
|
||||
|
||||
pool := keeper.GetPool(ctx)
|
||||
val := NewValidator(addrs[0], pks[0], Description{})
|
||||
val.Status = sdk.Unbonded
|
||||
val, pool, delShares := val.addTokens(pool, 10)
|
||||
|
||||
assert.Equal(t, sdk.OneRat(), val.DelegatorShareExRate(pool))
|
||||
assert.Equal(t, sdk.OneRat(), pool.bondedShareExRate())
|
||||
assert.Equal(t, sdk.OneRat(), pool.unbondingShareExRate())
|
||||
assert.Equal(t, sdk.OneRat(), pool.unbondedShareExRate())
|
||||
|
||||
assert.True(sdk.RatEq(t, sdk.NewRat(10), delShares))
|
||||
assert.True(sdk.RatEq(t, sdk.NewRat(10), val.UnbondedShares))
|
||||
}
|
||||
|
||||
// TODO refactor to make simpler like the AddToken tests above
|
||||
func TestRemoveShares(t *testing.T) {
|
||||
ctx, _, keeper := createTestInput(t, false, 0)
|
||||
|
||||
|
|
@ -47,9 +73,9 @@ func TestRemoveShares(t *testing.T) {
|
|||
BondedShares: sdk.NewRat(9),
|
||||
DelegatorShares: sdk.NewRat(9),
|
||||
}
|
||||
poolA.BondedPool = valA.BondedShares.Evaluate()
|
||||
poolA.BondedTokens = valA.BondedShares.Evaluate()
|
||||
poolA.BondedShares = valA.BondedShares
|
||||
assert.Equal(t, valA.DelegatorShareExRate(), sdk.OneRat())
|
||||
assert.Equal(t, valA.DelegatorShareExRate(poolA), sdk.OneRat())
|
||||
assert.Equal(t, poolA.bondedShareExRate(), sdk.OneRat())
|
||||
assert.Equal(t, poolA.unbondedShareExRate(), sdk.OneRat())
|
||||
valB, poolB, coinsB := valA.removeShares(poolA, sdk.NewRat(10))
|
||||
|
|
@ -57,9 +83,9 @@ func TestRemoveShares(t *testing.T) {
|
|||
// coins were created
|
||||
assert.Equal(t, coinsB, int64(10))
|
||||
// pool shares were removed
|
||||
assert.Equal(t, valB.BondedShares, valA.BondedShares.Sub(sdk.NewRat(10).Mul(valA.DelegatorShareExRate())))
|
||||
assert.Equal(t, valB.BondedShares, valA.BondedShares.Sub(sdk.NewRat(10).Mul(valA.DelegatorShareExRate(poolA))))
|
||||
// conservation of tokens
|
||||
assert.Equal(t, poolB.UnbondedPool+poolB.BondedPool+coinsB, poolA.UnbondedPool+poolA.BondedPool)
|
||||
assert.Equal(t, poolB.UnbondedTokens+poolB.BondedTokens+coinsB, poolA.UnbondedTokens+poolA.BondedTokens)
|
||||
|
||||
// specific case from random tests
|
||||
assets := sdk.NewRat(5102)
|
||||
|
|
@ -75,79 +101,54 @@ func TestRemoveShares(t *testing.T) {
|
|||
TotalSupply: 0,
|
||||
BondedShares: sdk.NewRat(248305),
|
||||
UnbondedShares: sdk.NewRat(232147),
|
||||
BondedPool: 248305,
|
||||
UnbondedPool: 232147,
|
||||
BondedTokens: 248305,
|
||||
UnbondedTokens: 232147,
|
||||
InflationLastTime: 0,
|
||||
Inflation: sdk.NewRat(7, 100),
|
||||
}
|
||||
shares := sdk.NewRat(29)
|
||||
msg := fmt.Sprintf("validator %s (status: %d, assets: %v, liabilities: %v, DelegatorShareExRate: %v)",
|
||||
val.Address, val.Status, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate())
|
||||
val.Address, val.Status, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate(pool))
|
||||
msg = fmt.Sprintf("Removed %v shares from %s", shares, msg)
|
||||
_, newPool, tokens := val.removeShares(pool, shares)
|
||||
require.Equal(t,
|
||||
tokens+newPool.UnbondedPool+newPool.BondedPool,
|
||||
pool.BondedPool+pool.UnbondedPool,
|
||||
tokens+newPool.UnbondedTokens+newPool.BondedTokens,
|
||||
pool.BondedTokens+pool.UnbondedTokens,
|
||||
"Tokens were not conserved: %s", msg)
|
||||
}
|
||||
|
||||
// TODO convert these commend out tests to test UpdateSharesLocation
|
||||
//func TestUpdateSharesLocation(t *testing.T) {
|
||||
//}
|
||||
//func TestBondedToUnbondedPool(t *testing.T) {
|
||||
//ctx, _, keeper := createTestInput(t, false, 0)
|
||||
func TestUpdateSharesLocation(t *testing.T) {
|
||||
ctx, _, keeper := createTestInput(t, false, 0)
|
||||
pool := keeper.GetPool(ctx)
|
||||
|
||||
//poolA := keeper.GetPool(ctx)
|
||||
//assert.Equal(t, poolA.bondedShareExRate(), sdk.OneRat())
|
||||
//assert.Equal(t, poolA.unbondedShareExRate(), sdk.OneRat())
|
||||
//valA := Validator{
|
||||
//Status: sdk.Bonded,
|
||||
//Address: addrs[0],
|
||||
//PubKey: pks[0],
|
||||
//BondedShares: sdk.OneRat(),
|
||||
//DelegatorShares: sdk.OneRat(),
|
||||
//}
|
||||
//poolB, valB := poolA.bondedToUnbondedPool(valA)
|
||||
val := NewValidator(addrs[0], pks[0], Description{})
|
||||
val.Status = sdk.Unbonded
|
||||
val, pool, _ = val.addTokens(pool, 100)
|
||||
assert.Equal(t, int64(0), val.BondedShares.Evaluate())
|
||||
assert.Equal(t, int64(0), val.UnbondingShares.Evaluate())
|
||||
assert.Equal(t, int64(100), val.UnbondedShares.Evaluate())
|
||||
assert.Equal(t, int64(0), pool.BondedTokens)
|
||||
assert.Equal(t, int64(0), pool.UnbondingTokens)
|
||||
assert.Equal(t, int64(100), pool.UnbondedTokens)
|
||||
|
||||
//// status unbonded
|
||||
//assert.Equal(t, valB.Status, sdk.Unbonded)
|
||||
//// same exchange rate, assets unchanged
|
||||
//assert.Equal(t, valB.BondedShares, valA.BondedShares)
|
||||
//// bonded pool decreased
|
||||
//assert.Equal(t, poolB.BondedPool, poolA.BondedPool-valA.BondedShares.Evaluate())
|
||||
//// unbonded pool increased
|
||||
//assert.Equal(t, poolB.UnbondedPool, poolA.UnbondedPool+valA.BondedShares.Evaluate())
|
||||
//// conservation of tokens
|
||||
//assert.Equal(t, poolB.UnbondedPool+poolB.BondedPool, poolA.BondedPool+poolA.UnbondedPool)
|
||||
//}
|
||||
val.Status = sdk.Unbonding
|
||||
val, pool = val.UpdateSharesLocation(pool)
|
||||
assert.Equal(t, int64(0), val.BondedShares.Evaluate())
|
||||
assert.Equal(t, int64(100), val.UnbondingShares.Evaluate())
|
||||
assert.Equal(t, int64(0), val.UnbondedShares.Evaluate())
|
||||
assert.Equal(t, int64(0), pool.BondedTokens)
|
||||
assert.Equal(t, int64(100), pool.UnbondingTokens)
|
||||
assert.Equal(t, int64(0), pool.UnbondedTokens)
|
||||
|
||||
//func TestUnbonbedtoBondedPool(t *testing.T) {
|
||||
//ctx, _, keeper := createTestInput(t, false, 0)
|
||||
|
||||
//poolA := keeper.GetPool(ctx)
|
||||
//assert.Equal(t, poolA.bondedShareExRate(), sdk.OneRat())
|
||||
//assert.Equal(t, poolA.unbondedShareExRate(), sdk.OneRat())
|
||||
//valA := Validator{
|
||||
//Status: sdk.Bonded,
|
||||
//Address: addrs[0],
|
||||
//PubKey: pks[0],
|
||||
//BondedShares: sdk.OneRat(),
|
||||
//DelegatorShares: sdk.OneRat(),
|
||||
//}
|
||||
//valA.Status = sdk.Unbonded
|
||||
//poolB, valB := poolA.unbondedToBondedPool(valA)
|
||||
|
||||
//// status bonded
|
||||
//assert.Equal(t, valB.Status, sdk.Bonded)
|
||||
//// same exchange rate, assets unchanged
|
||||
//assert.Equal(t, valB.BondedShares, valA.BondedShares)
|
||||
//// bonded pool increased
|
||||
//assert.Equal(t, poolB.BondedPool, poolA.BondedPool+valA.BondedShares.Evaluate())
|
||||
//// unbonded pool decreased
|
||||
//assert.Equal(t, poolB.UnbondedPool, poolA.UnbondedPool-valA.BondedShares.Evaluate())
|
||||
//// conservation of tokens
|
||||
//assert.Equal(t, poolB.UnbondedPool+poolB.BondedPool, poolA.BondedPool+poolA.UnbondedPool)
|
||||
//}
|
||||
val.Status = sdk.Bonded
|
||||
val, pool = val.UpdateSharesLocation(pool)
|
||||
assert.Equal(t, int64(100), val.BondedShares.Evaluate())
|
||||
assert.Equal(t, int64(0), val.UnbondingShares.Evaluate())
|
||||
assert.Equal(t, int64(0), val.UnbondedShares.Evaluate())
|
||||
assert.Equal(t, int64(0), pool.BondedTokens)
|
||||
assert.Equal(t, int64(100), pool.UnbondingTokens)
|
||||
assert.Equal(t, int64(0), pool.UnbondedTokens)
|
||||
}
|
||||
|
||||
//________________________________________________________________________________
|
||||
// TODO refactor this random setup
|
||||
|
|
@ -177,8 +178,8 @@ func randomSetup(r *rand.Rand, numValidators int) (Pool, Validators) {
|
|||
TotalSupply: 0,
|
||||
BondedShares: sdk.ZeroRat(),
|
||||
UnbondedShares: sdk.ZeroRat(),
|
||||
BondedPool: 0,
|
||||
UnbondedPool: 0,
|
||||
BondedTokens: 0,
|
||||
UnbondedTokens: 0,
|
||||
InflationLastTime: 0,
|
||||
Inflation: sdk.NewRat(7, 100),
|
||||
}
|
||||
|
|
@ -188,10 +189,10 @@ func randomSetup(r *rand.Rand, numValidators int) (Pool, Validators) {
|
|||
validator := randomValidator(r)
|
||||
if validator.Status == sdk.Bonded {
|
||||
pool.BondedShares = pool.BondedShares.Add(validator.BondedShares)
|
||||
pool.BondedPool += validator.BondedShares.Evaluate()
|
||||
pool.BondedTokens += validator.BondedShares.Evaluate()
|
||||
} else if validator.Status == sdk.Unbonded {
|
||||
pool.UnbondedShares = pool.UnbondedShares.Add(validator.BondedShares)
|
||||
pool.UnbondedPool += validator.BondedShares.Evaluate()
|
||||
pool.UnbondedTokens += validator.BondedShares.Evaluate()
|
||||
}
|
||||
validators[i] = validator
|
||||
}
|
||||
|
|
@ -208,11 +209,11 @@ func OpBondOrUnbond(r *rand.Rand, p Pool, val Validator) (Pool, Validator, int64
|
|||
var msg string
|
||||
if val.Status == sdk.Bonded {
|
||||
msg = fmt.Sprintf("sdk.Unbonded previously bonded validator %s (assets: %v, liabilities: %v, DelegatorShareExRate: %v)",
|
||||
val.Address, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate())
|
||||
val.Address, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate(p))
|
||||
val.Status = sdk.Unbonded
|
||||
} else if val.Status == sdk.Unbonded {
|
||||
msg = fmt.Sprintf("sdk.Bonded previously unbonded validator %s (assets: %v, liabilities: %v, DelegatorShareExRate: %v)",
|
||||
val.Address, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate())
|
||||
val.Address, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate(p))
|
||||
val.Status = sdk.Bonded
|
||||
}
|
||||
val, p = val.UpdateSharesLocation(p)
|
||||
|
|
@ -223,7 +224,7 @@ func OpBondOrUnbond(r *rand.Rand, p Pool, val Validator) (Pool, Validator, int64
|
|||
func OpAddTokens(r *rand.Rand, p Pool, val Validator) (Pool, Validator, int64, string) {
|
||||
tokens := int64(r.Int31n(1000))
|
||||
msg := fmt.Sprintf("validator %s (status: %d, assets: %v, liabilities: %v, DelegatorShareExRate: %v)",
|
||||
val.Address, val.Status, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate())
|
||||
val.Address, val.Status, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate(p))
|
||||
val, p, _ = val.addTokens(p, tokens)
|
||||
msg = fmt.Sprintf("Added %d tokens to %s", tokens, msg)
|
||||
return p, val, -1 * tokens, msg // tokens are removed so for accounting must be negative
|
||||
|
|
@ -240,7 +241,7 @@ func OpRemoveShares(r *rand.Rand, p Pool, val Validator) (Pool, Validator, int64
|
|||
}
|
||||
|
||||
msg := fmt.Sprintf("Removed %v shares from validator %s (status: %d, assets: %v, liabilities: %v, DelegatorShareExRate: %v)",
|
||||
shares, val.Address, val.Status, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate())
|
||||
shares, val.Address, val.Status, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate(p))
|
||||
|
||||
val, p, tokens := val.removeShares(p, shares)
|
||||
return p, val, tokens, msg
|
||||
|
|
@ -265,14 +266,14 @@ func assertInvariants(t *testing.T, msg string,
|
|||
|
||||
// total tokens conserved
|
||||
require.Equal(t,
|
||||
pOrig.UnbondedPool+pOrig.BondedPool,
|
||||
pMod.UnbondedPool+pMod.BondedPool+tokens,
|
||||
"Tokens not conserved - msg: %v\n, pOrig.BondedShares: %v, pOrig.UnbondedShares: %v, pMod.BondedShares: %v, pMod.UnbondedShares: %v, pOrig.UnbondedPool: %v, pOrig.BondedPool: %v, pMod.UnbondedPool: %v, pMod.BondedPool: %v, tokens: %v\n",
|
||||
pOrig.UnbondedTokens+pOrig.BondedTokens,
|
||||
pMod.UnbondedTokens+pMod.BondedTokens+tokens,
|
||||
"Tokens not conserved - msg: %v\n, pOrig.BondedShares: %v, pOrig.UnbondedShares: %v, pMod.BondedShares: %v, pMod.UnbondedShares: %v, pOrig.UnbondedTokens: %v, pOrig.BondedTokens: %v, pMod.UnbondedTokens: %v, pMod.BondedTokens: %v, tokens: %v\n",
|
||||
msg,
|
||||
pOrig.BondedShares, pOrig.UnbondedShares,
|
||||
pMod.BondedShares, pMod.UnbondedShares,
|
||||
pOrig.UnbondedPool, pOrig.BondedPool,
|
||||
pMod.UnbondedPool, pMod.BondedPool, tokens)
|
||||
pOrig.UnbondedTokens, pOrig.BondedTokens,
|
||||
pMod.UnbondedTokens, pMod.BondedTokens, tokens)
|
||||
|
||||
// nonnegative bonded shares
|
||||
require.False(t, pMod.BondedShares.LT(sdk.ZeroRat()),
|
||||
|
|
@ -297,10 +298,10 @@ func assertInvariants(t *testing.T, msg string,
|
|||
for _, cMod := range cMods {
|
||||
|
||||
// nonnegative ex rate
|
||||
require.False(t, cMod.DelegatorShareExRate().LT(sdk.ZeroRat()),
|
||||
require.False(t, cMod.DelegatorShareExRate(pMod).LT(sdk.ZeroRat()),
|
||||
"Applying operation \"%s\" resulted in negative validator.DelegatorShareExRate(): %v (validator.Address: %s)",
|
||||
msg,
|
||||
cMod.DelegatorShareExRate(),
|
||||
cMod.DelegatorShareExRate(pMod),
|
||||
cMod.Address,
|
||||
)
|
||||
|
||||
|
|
@ -310,7 +311,7 @@ func assertInvariants(t *testing.T, msg string,
|
|||
msg,
|
||||
cMod.BondedShares,
|
||||
cMod.DelegatorShares,
|
||||
cMod.DelegatorShareExRate(),
|
||||
cMod.DelegatorShareExRate(pMod),
|
||||
cMod.Address,
|
||||
)
|
||||
|
||||
|
|
@ -320,7 +321,7 @@ func assertInvariants(t *testing.T, msg string,
|
|||
msg,
|
||||
cMod.DelegatorShares,
|
||||
cMod.BondedShares,
|
||||
cMod.DelegatorShareExRate(),
|
||||
cMod.DelegatorShareExRate(pMod),
|
||||
cMod.Address,
|
||||
)
|
||||
|
||||
|
|
@ -342,20 +343,20 @@ func TestPossibleOverflow(t *testing.T) {
|
|||
TotalSupply: 0,
|
||||
BondedShares: assets,
|
||||
UnbondedShares: sdk.ZeroRat(),
|
||||
BondedPool: assets.Evaluate(),
|
||||
UnbondedPool: 0,
|
||||
BondedTokens: assets.Evaluate(),
|
||||
UnbondedTokens: 0,
|
||||
InflationLastTime: 0,
|
||||
Inflation: sdk.NewRat(7, 100),
|
||||
}
|
||||
tokens := int64(71)
|
||||
msg := fmt.Sprintf("validator %s (status: %d, assets: %v, liabilities: %v, DelegatorShareExRate: %v)",
|
||||
val.Address, val.Status, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate())
|
||||
val.Address, val.Status, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate(pool))
|
||||
newValidator, _, _ := val.addTokens(pool, tokens)
|
||||
|
||||
msg = fmt.Sprintf("Added %d tokens to %s", tokens, msg)
|
||||
require.False(t, newValidator.DelegatorShareExRate().LT(sdk.ZeroRat()),
|
||||
require.False(t, newValidator.DelegatorShareExRate(pool).LT(sdk.ZeroRat()),
|
||||
"Applying operation \"%s\" resulted in negative DelegatorShareExRate(): %v",
|
||||
msg, newValidator.DelegatorShareExRate())
|
||||
msg, newValidator.DelegatorShareExRate(pool))
|
||||
}
|
||||
|
||||
// run random operations in a random order on a random single-validator state, assert invariants hold
|
||||
|
|
|
|||
Loading…
Reference in New Issue