0g-chain/x/incentive/keeper/rewards_borrow_update_test.go
Ruaridh cf16029e77
Incentive refactor: hard rewards (#929)
* organise testing committee gen state

* remove repeated test app initialization

* minor fixes from linter in tests

* move more setup to SetupApp

* split up KeeperTestSuite for each reward type

* simplify KeeperTestSuite

* simplify PayoutKeeperSuite

* simplify DelegatorRewardSuite

* simplify SupplyRewardsSuite

* simplify BorrowRewardsSuite

* simplify USDXRewardsSuite

* add auth genesis builder for easier test setup

* migrate all incentive tests to auth builder

* add incentive genesis builder for easier setup
migrate hard incentive tests

* migrate all tests to incentive builder

* add hard genesis builder

* small tidy ups

* deduplicate initialTime from borrow tests

* deduplicate initialtTime from supply tests

* deduplicate initialTime from usdx and keeper tests

* deduplicate initialTime in delgator tests

* deduplicate genesis time in payout test

* deduplicate test app initialization

* make authGenesisBuilder available for all modules

* remove unused pricefeed setup

* export incentive genesis builder

* remove commented out test cases

* migrate cdp test to new test state builders

* migrate vv payout tests to use new builders

* add SynchronizeHardBorrowReward unit test

* extract calculatReward method

* tidy up unit test for borrow rewards

* add helper method to RewardIndexes

* user helper to extract logic from SyncBorrowReward

* add Get methods to (Multi)RewardIndexes

* replace params.Subspace in keeper to test easier

* add unit tests for usdx minting

* refactor InitializeUSDXMintingClaim

* add unit tests for InitializeHardBorrowRewards

* refactor SynchronizeUSDXMintingReward

* add unit tests for UpdateHardBorrowIndexDenoms

* change rewardSource type to Dec
needed by delegation rewards

* fix typo in test names

* refactor UpdateHardBorrowIndexDenoms

* update genesis test TODO to use auth builder

* add skipped test for bug in usdx sync

* extract common method for calculating rewards

* doc comment tidy

* add unit tests for delegator rewards

* tidy up test files

* remove old TODOs

* reaarrange InitializeHardDelegatorReward
to fit with other init reward functions

* duplicate borrow unit tests to create supply tests

* add tests for syncing with zero rewards per second

* refactor SynchronizeHardDelegatorRewards

* refactor supply rewards in same way as borrow

* fix total delegation calculation bug

* fix new usdx reward bug

* fix new supply/borrow reward bug

* remove working comment

* standardize behaviour when global factors missing

* improve documentation for CalculateRewards

* standardize variable names

* remove panic from calculateSingleReward

* wip

* Tidy up comments

* remove wip comment
2021-06-21 22:05:17 +01:00

120 lines
4.0 KiB
Go

package keeper_test
import (
"testing"
"github.com/stretchr/testify/suite"
hardtypes "github.com/kava-labs/kava/x/hard/types"
"github.com/kava-labs/kava/x/incentive/types"
)
// UpdateHardBorrowIndexDenomsTests runs unit tests for the keeper.UpdateHardBorrowIndexDenoms method
//
// inputs
// - claim in store if it exists (only claim.BorrowRewardIndexes)
// - global indexes in store
// - borrow function arg (only borrow.Amount)
//
// outputs
// - sets a claim
type UpdateHardBorrowIndexDenomsTests struct {
unitTester
}
func TestUpdateHardBorrowIndexDenoms(t *testing.T) {
suite.Run(t, new(UpdateHardBorrowIndexDenomsTests))
}
func (suite *UpdateHardBorrowIndexDenomsTests) TestClaimIndexesAreRemovedForDenomsNoLongerBorrowed() {
claim := types.HardLiquidityProviderClaim{
BaseMultiClaim: types.BaseMultiClaim{
Owner: arbitraryAddress(),
},
BorrowRewardIndexes: nonEmptyMultiRewardIndexes,
}
suite.storeClaim(claim)
suite.storeGlobalBorrowIndexes(claim.BorrowRewardIndexes)
// remove one denom from the indexes already in the borrow
expectedIndexes := claim.BorrowRewardIndexes[1:]
borrow := hardtypes.Borrow{
Borrower: claim.Owner,
Amount: arbitraryCoinsWithDenoms(extractCollateralTypes(expectedIndexes)...),
}
suite.keeper.UpdateHardBorrowIndexDenoms(suite.ctx, borrow)
syncedClaim, _ := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, claim.Owner)
suite.Equal(expectedIndexes, syncedClaim.BorrowRewardIndexes)
}
func (suite *UpdateHardBorrowIndexDenomsTests) TestClaimIndexesAreAddedForNewlyBorrowedDenoms() {
claim := types.HardLiquidityProviderClaim{
BaseMultiClaim: types.BaseMultiClaim{
Owner: arbitraryAddress(),
},
BorrowRewardIndexes: nonEmptyMultiRewardIndexes,
}
suite.storeClaim(claim)
globalIndexes := appendUniqueMultiRewardIndex(claim.BorrowRewardIndexes)
suite.storeGlobalBorrowIndexes(globalIndexes)
borrow := hardtypes.Borrow{
Borrower: claim.Owner,
Amount: arbitraryCoinsWithDenoms(extractCollateralTypes(globalIndexes)...),
}
suite.keeper.UpdateHardBorrowIndexDenoms(suite.ctx, borrow)
syncedClaim, _ := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, claim.Owner)
suite.Equal(globalIndexes, syncedClaim.BorrowRewardIndexes)
}
func (suite *UpdateHardBorrowIndexDenomsTests) TestClaimIndexesAreUnchangedWhenBorrowedDenomsUnchanged() {
claim := types.HardLiquidityProviderClaim{
BaseMultiClaim: types.BaseMultiClaim{
Owner: arbitraryAddress(),
},
BorrowRewardIndexes: nonEmptyMultiRewardIndexes,
}
suite.storeClaim(claim)
// Set global indexes with same denoms but different values.
// UpdateHardBorrowIndexDenoms should ignore the new values.
suite.storeGlobalBorrowIndexes(increaseAllRewardFactors(claim.BorrowRewardIndexes))
borrow := hardtypes.Borrow{
Borrower: claim.Owner,
Amount: arbitraryCoinsWithDenoms(extractCollateralTypes(claim.BorrowRewardIndexes)...),
}
suite.keeper.UpdateHardBorrowIndexDenoms(suite.ctx, borrow)
syncedClaim, _ := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, claim.Owner)
suite.Equal(claim.BorrowRewardIndexes, syncedClaim.BorrowRewardIndexes)
}
func (suite *UpdateHardBorrowIndexDenomsTests) TestEmptyClaimIndexesAreAddedForNewlyBorrowedButNotRewardedDenoms() {
claim := types.HardLiquidityProviderClaim{
BaseMultiClaim: types.BaseMultiClaim{
Owner: arbitraryAddress(),
},
BorrowRewardIndexes: nonEmptyMultiRewardIndexes,
}
suite.storeClaim(claim)
suite.storeGlobalBorrowIndexes(claim.BorrowRewardIndexes)
// add a denom to the borrowed amount that is not in the global or claim's indexes
expectedIndexes := appendUniqueEmptyMultiRewardIndex(claim.BorrowRewardIndexes)
borrowedDenoms := extractCollateralTypes(expectedIndexes)
borrow := hardtypes.Borrow{
Borrower: claim.Owner,
Amount: arbitraryCoinsWithDenoms(borrowedDenoms...),
}
suite.keeper.UpdateHardBorrowIndexDenoms(suite.ctx, borrow)
syncedClaim, _ := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, claim.Owner)
suite.Equal(expectedIndexes, syncedClaim.BorrowRewardIndexes)
}