package keeper_test import ( "testing" "time" "github.com/stretchr/testify/suite" sdk "github.com/cosmos/cosmos-sdk/types" abci "github.com/tendermint/tendermint/abci/types" tmtime "github.com/tendermint/tendermint/types/time" "github.com/kava-labs/kava/app" "github.com/kava-labs/kava/x/bep3/keeper" "github.com/kava-labs/kava/x/bep3/types" ) const LongtermStorageDuration = 86400 type KeeperTestSuite struct { suite.Suite keeper keeper.Keeper app app.TestApp ctx sdk.Context } func (suite *KeeperTestSuite) SetupTest() { config := sdk.GetConfig() app.SetBech32AddressPrefixes(config) suite.ResetChain() return } func (suite *KeeperTestSuite) ResetChain() { tApp := app.NewTestApp() ctx := tApp.NewContext(true, abci.Header{Height: 1, Time: tmtime.Now()}) keeper := tApp.GetBep3Keeper() suite.app = tApp suite.ctx = ctx suite.keeper = keeper } func (suite *KeeperTestSuite) TestGetSetAtomicSwap() { suite.ResetChain() // Set new atomic swap atomicSwap := atomicSwap(suite.ctx, 1) suite.keeper.SetAtomicSwap(suite.ctx, atomicSwap) // Check atomic swap in store s, found := suite.keeper.GetAtomicSwap(suite.ctx, atomicSwap.GetSwapID()) suite.True(found) suite.Equal(atomicSwap, s) // Check fake atomic swap not in store fakeSwapID := types.CalculateSwapID(atomicSwap.RandomNumberHash, TestUser2, "otheraddress") _, found = suite.keeper.GetAtomicSwap(suite.ctx, fakeSwapID) suite.False(found) } func (suite *KeeperTestSuite) TestRemoveAtomicSwap() { suite.ResetChain() // Set new atomic swap atomicSwap := atomicSwap(suite.ctx, 1) suite.keeper.SetAtomicSwap(suite.ctx, atomicSwap) // Check atomic swap in store s, found := suite.keeper.GetAtomicSwap(suite.ctx, atomicSwap.GetSwapID()) suite.True(found) suite.Equal(atomicSwap, s) suite.keeper.RemoveAtomicSwap(suite.ctx, atomicSwap.GetSwapID()) // Check atomic swap not in store _, found = suite.keeper.GetAtomicSwap(suite.ctx, atomicSwap.GetSwapID()) suite.False(found) } func (suite *KeeperTestSuite) TestIterateAtomicSwaps() { suite.ResetChain() // Set atomic swaps atomicSwaps := atomicSwaps(suite.ctx, 4) for _, s := range atomicSwaps { suite.keeper.SetAtomicSwap(suite.ctx, s) } // Read each atomic swap from the store var readAtomicSwaps types.AtomicSwaps suite.keeper.IterateAtomicSwaps(suite.ctx, func(a types.AtomicSwap) bool { readAtomicSwaps = append(readAtomicSwaps, a) return false }) // Check expected values suite.Equal(len(atomicSwaps), len(readAtomicSwaps)) } func (suite *KeeperTestSuite) TestGetAllAtomicSwaps() { suite.ResetChain() // Set atomic swaps atomicSwaps := atomicSwaps(suite.ctx, 4) for _, s := range atomicSwaps { suite.keeper.SetAtomicSwap(suite.ctx, s) } // Get and check atomic swaps res := suite.keeper.GetAllAtomicSwaps(suite.ctx) suite.Equal(4, len(res)) } func (suite *KeeperTestSuite) TestInsertIntoByBlockIndex() { suite.ResetChain() // Set new atomic swap in by block index atomicSwap := atomicSwap(suite.ctx, 1) suite.keeper.InsertIntoByBlockIndex(suite.ctx, atomicSwap) // Block index lacks getter methods, must use iteration to get count of swaps in store var swapIDs [][]byte suite.keeper.IterateAtomicSwapsByBlock(suite.ctx, atomicSwap.ExpireHeight+1, func(id []byte) bool { swapIDs = append(swapIDs, id) return false }) suite.Equal(len(swapIDs), 1) // Marshal the expected swapID cdc := suite.app.Codec() res, _ := cdc.MarshalBinaryBare(atomicSwap.GetSwapID()) expectedSwapID := res[1:] suite.Equal(expectedSwapID, swapIDs[0]) } func (suite *KeeperTestSuite) TestRemoveFromByBlockIndex() { suite.ResetChain() // Set new atomic swap in by block index atomicSwap := atomicSwap(suite.ctx, 1) suite.keeper.InsertIntoByBlockIndex(suite.ctx, atomicSwap) // Check stored data in block index var swapIDsPre [][]byte suite.keeper.IterateAtomicSwapsByBlock(suite.ctx, atomicSwap.ExpireHeight+1, func(id []byte) bool { swapIDsPre = append(swapIDsPre, id) return false }) suite.Equal(len(swapIDsPre), 1) suite.keeper.RemoveFromByBlockIndex(suite.ctx, atomicSwap) // Check stored data not in block index var swapIDsPost [][]byte suite.keeper.IterateAtomicSwapsByBlock(suite.ctx, atomicSwap.ExpireHeight+1, func(id []byte) bool { swapIDsPost = append(swapIDsPost, id) return false }) suite.Equal(len(swapIDsPost), 0) } func (suite *KeeperTestSuite) TestIterateAtomicSwapsByBlock() { suite.ResetChain() type args struct { blockCtx sdk.Context swap types.AtomicSwap } var testCases []args for i := 0; i < 8; i++ { // Set up context 100 blocks apart blockCtx := suite.ctx.WithBlockHeight(int64(i) * 100) // Initialize a new atomic swap (different randomNumberHash = different swap IDs) timestamp := tmtime.Now().Add(time.Duration(i) * time.Minute).Unix() randomNumber, _ := types.GenerateSecureRandomNumber() randomNumberHash := types.CalculateRandomHash(randomNumber[:], timestamp) atomicSwap := types.NewAtomicSwap(cs(c("bnb", 50000)), randomNumberHash, uint64(blockCtx.BlockHeight()), timestamp, TestUser1, TestUser2, TestSenderOtherChain, TestRecipientOtherChain, 0, types.Open, true, types.Incoming) // Insert into block index suite.keeper.InsertIntoByBlockIndex(blockCtx, atomicSwap) // Add to local block index testCases = append(testCases, args{blockCtx, atomicSwap}) } // Set up the expected swap IDs for a given cutoff block cutoffBlock := int64(450) var expectedSwapIDs [][]byte for _, tc := range testCases { if tc.blockCtx.BlockHeight() < cutoffBlock || tc.blockCtx.BlockHeight() == cutoffBlock { expectedSwapIDs = append(expectedSwapIDs, tc.swap.GetSwapID()) } } // Read the swap IDs from store for a given cutoff block var readSwapIDs [][]byte suite.keeper.IterateAtomicSwapsByBlock(suite.ctx, uint64(cutoffBlock), func(id []byte) bool { readSwapIDs = append(readSwapIDs, id) return false }) suite.Equal(expectedSwapIDs, readSwapIDs) } func (suite *KeeperTestSuite) TestInsertIntoLongtermStorage() { suite.ResetChain() // Set atomic swap in longterm storage atomicSwap := atomicSwap(suite.ctx, 1) atomicSwap.ClosedBlock = suite.ctx.BlockHeight() suite.keeper.InsertIntoLongtermStorage(suite.ctx, atomicSwap) // Longterm storage lacks getter methods, must use iteration to get count of swaps in store var swapIDs [][]byte suite.keeper.IterateAtomicSwapsLongtermStorage(suite.ctx, uint64(atomicSwap.ClosedBlock+LongtermStorageDuration), func(id []byte) bool { swapIDs = append(swapIDs, id) return false }) suite.Equal(len(swapIDs), 1) // Marshal the expected swapID cdc := suite.app.Codec() res, _ := cdc.MarshalBinaryBare(atomicSwap.GetSwapID()) expectedSwapID := res[1:] suite.Equal(expectedSwapID, swapIDs[0]) } func (suite *KeeperTestSuite) TestRemoveFromLongtermStorage() { suite.ResetChain() // Set atomic swap in longterm storage atomicSwap := atomicSwap(suite.ctx, 1) atomicSwap.ClosedBlock = suite.ctx.BlockHeight() suite.keeper.InsertIntoLongtermStorage(suite.ctx, atomicSwap) // Longterm storage lacks getter methods, must use iteration to get count of swaps in store var swapIDs [][]byte suite.keeper.IterateAtomicSwapsLongtermStorage(suite.ctx, uint64(atomicSwap.ClosedBlock+LongtermStorageDuration), func(id []byte) bool { swapIDs = append(swapIDs, id) return false }) suite.Equal(len(swapIDs), 1) suite.keeper.RemoveFromLongtermStorage(suite.ctx, atomicSwap) // Check stored data not in block index var swapIDsPost [][]byte suite.keeper.IterateAtomicSwapsLongtermStorage(suite.ctx, uint64(atomicSwap.ClosedBlock+LongtermStorageDuration), func(id []byte) bool { swapIDsPost = append(swapIDsPost, id) return false }) suite.Equal(len(swapIDsPost), 0) } func (suite *KeeperTestSuite) TestIterateAtomicSwapsLongtermStorage() { suite.ResetChain() // Set up atomic swaps with stagged closed blocks var swaps types.AtomicSwaps for i := 0; i < 8; i++ { timestamp := tmtime.Now().Unix() randomNumber, _ := types.GenerateSecureRandomNumber() randomNumberHash := types.CalculateRandomHash(randomNumber[:], timestamp) atomicSwap := types.NewAtomicSwap(cs(c("bnb", 50000)), randomNumberHash, uint64(suite.ctx.BlockHeight()), timestamp, TestUser1, TestUser2, TestSenderOtherChain, TestRecipientOtherChain, 100, types.Open, true, types.Incoming) // Set closed block staggered by 100 blocks and insert into longterm storage atomicSwap.ClosedBlock = int64(i) * 100 suite.keeper.InsertIntoLongtermStorage(suite.ctx, atomicSwap) // Add to local longterm storage swaps = append(swaps, atomicSwap) } // Set up the expected swap IDs for a given cutoff block. cutoffBlock := int64(LongtermStorageDuration + 350) var expectedSwapIDs [][]byte for _, swap := range swaps { if swap.ClosedBlock+LongtermStorageDuration < cutoffBlock || swap.ClosedBlock+LongtermStorageDuration == cutoffBlock { expectedSwapIDs = append(expectedSwapIDs, swap.GetSwapID()) } } // Read the swap IDs from store for a given cutoff block var readSwapIDs [][]byte suite.keeper.IterateAtomicSwapsLongtermStorage(suite.ctx, uint64(cutoffBlock), func(id []byte) bool { readSwapIDs = append(readSwapIDs, id) return false }) // At the cutoff block, iteration should return half of the swap IDs suite.Equal(len(swaps)/2, len(expectedSwapIDs)) suite.Equal(len(swaps)/2, len(readSwapIDs)) // Should be the same IDs suite.Equal(expectedSwapIDs, readSwapIDs) } func (suite *KeeperTestSuite) TestGetSetAssetSupply() { suite.ResetChain() denom := "bnb" // Put asset supply in store assetSupply := types.NewAssetSupply(denom, c(denom, 0), c(denom, 0), c(denom, 50000), c(denom, 100000)) suite.keeper.SetAssetSupply(suite.ctx, assetSupply, []byte(denom)) // Check asset in store storedAssetSupply, found := suite.keeper.GetAssetSupply(suite.ctx, []byte(denom)) suite.True(found) suite.Equal(assetSupply, storedAssetSupply) // Check fake asset supply not in store fakeDenom := "xyz" _, found = suite.keeper.GetAssetSupply(suite.ctx, []byte(fakeDenom)) suite.False(found) } func (suite *KeeperTestSuite) TestIterateAssetSupplies() { suite.ResetChain() // Set asset supplies supplies := assetSupplies(5) for _, supply := range supplies { suite.keeper.SetAssetSupply(suite.ctx, supply, []byte(supply.Denom)) } // Read each asset supply from the store var readSupplies types.AssetSupplies suite.keeper.IterateAssetSupplies(suite.ctx, func(a types.AssetSupply) bool { readSupplies = append(readSupplies, a) return false }) // Check expected values for i := 0; i < len(supplies); i++ { suite.Contains(readSupplies, supplies[i]) } } func (suite *KeeperTestSuite) TestGetAllAssetSupplies() { suite.ResetChain() // Set asset supplies count := 3 supplies := assetSupplies(count) for _, supply := range supplies { suite.keeper.SetAssetSupply(suite.ctx, supply, []byte(supply.Denom)) } // Get all asset supplies readSupplies := suite.keeper.GetAllAssetSupplies(suite.ctx) suite.Equal(count, len(readSupplies)) // Check expected values for i := 0; i < count; i++ { suite.Contains(readSupplies, supplies[i]) } } func TestKeeperTestSuite(t *testing.T) { suite.Run(t, new(KeeperTestSuite)) }