github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/x/order/keeper/keeper_test.go (about)

     1  //go:build ignore
     2  
     3  package keeper
     4  
     5  import (
     6  	"testing"
     7  
     8  	"github.com/fibonacci-chain/fbc/x/common"
     9  
    10  	sdk "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types"
    11  	"github.com/stretchr/testify/require"
    12  
    13  	"github.com/fibonacci-chain/fbc/x/dex"
    14  	"github.com/fibonacci-chain/fbc/x/order/types"
    15  	token "github.com/fibonacci-chain/fbc/x/token/types"
    16  )
    17  
    18  func TestKeeper_Cache2Disk(t *testing.T) {
    19  	testInput := CreateTestInputWithBalance(t, 1, 100)
    20  	keeper := testInput.OrderKeeper
    21  	ctx := testInput.Ctx
    22  	feeParams := types.DefaultTestParams()
    23  	feeParams.OrderExpireBlocks = 1
    24  	keeper.SetParams(ctx, &feeParams)
    25  
    26  	tokenPair := dex.GetBuiltInTokenPair()
    27  	err := testInput.DexKeeper.SaveTokenPair(ctx, tokenPair)
    28  	require.Nil(t, err)
    29  
    30  	// mock order
    31  	order := mockOrder("", types.TestTokenPair, types.BuyOrder, "8", "1")
    32  	order.Sender = testInput.TestAddrs[0]
    33  	err = keeper.PlaceOrder(ctx, order)
    34  	require.Nil(t, err)
    35  
    36  	require.EqualValues(t, 0, len(keeper.GetDepthBookFromDB(ctx, types.TestTokenPair).Items))
    37  
    38  	// flush
    39  	keeper.Cache2Disk(ctx)
    40  	require.EqualValues(t, 1, len(keeper.GetDepthBookFromDB(ctx, types.TestTokenPair).Items))
    41  
    42  	keeper.RemoveOrderFromDepthBook(order, types.FeeTypeOrderCancel)
    43  	require.EqualValues(t, 1, keeper.cache.cancelNum)
    44  	keeper.RemoveOrderFromDepthBook(order, types.FeeTypeOrderExpire)
    45  	require.EqualValues(t, 1, keeper.cache.expireNum)
    46  }
    47  
    48  func TestCache(t *testing.T) {
    49  	testInput := CreateTestInputWithBalance(t, 1, 100)
    50  	keeper := testInput.OrderKeeper
    51  	ctx := testInput.Ctx
    52  	feeParams := types.DefaultTestParams()
    53  	feeParams.OrderExpireBlocks = 1
    54  	keeper.SetParams(ctx, &feeParams)
    55  
    56  	tokenPair := dex.GetBuiltInTokenPair()
    57  	err := testInput.DexKeeper.SaveTokenPair(ctx, tokenPair)
    58  	require.Nil(t, err)
    59  
    60  	err = keeper.AddCollectedFees(ctx,
    61  		sdk.SysCoins{{Denom: common.NativeToken, Amount: sdk.MustNewDecFromStr("0.25920000")}},
    62  		testInput.TestAddrs[0], types.FeeTypeOrderExpire, true)
    63  	require.Nil(t, err)
    64  	tokenKeeper := keeper.GetTokenKeeper()
    65  	require.NotNil(t, tokenKeeper)
    66  
    67  	// mock order
    68  	order := mockOrder("", types.TestTokenPair, types.BuyOrder, "10.0", "1.0")
    69  	order.Sender = testInput.TestAddrs[0]
    70  	err = keeper.PlaceOrder(ctx, order)
    71  	require.Nil(t, err)
    72  	require.EqualValues(t, 1, keeper.GetParams(ctx).OrderExpireBlocks)
    73  	require.EqualValues(t, 1, keeper.GetOperationMetric().OpenNum)
    74  
    75  	// current cache
    76  	require.EqualValues(t, 1, keeper.diskCache.openNum)
    77  	require.EqualValues(t, 1, keeper.diskCache.storeOrderNum)
    78  	copycache := keeper.GetDepthBookCopy(types.TestTokenPair)
    79  	require.EqualValues(t, 1, len(copycache.Items))
    80  	require.EqualValues(t, 0, len(keeper.GetDepthBookCopy("ABC").Items))
    81  	require.EqualValues(t, 1, len(keeper.GetDiskCache().getDepthBook(types.TestTokenPair).Items))
    82  	require.EqualValues(t, 0, len(keeper.GetDepthBookFromDB(ctx, types.TestTokenPair).Items))
    83  	require.EqualValues(t, 1, len(keeper.GetDiskCache().GetUpdatedDepthbookKeys()))
    84  
    85  	// flush
    86  	keeper.Cache2Disk(ctx)
    87  	require.EqualValues(t, 1, len(keeper.GetDiskCache().getDepthBook(types.TestTokenPair).Items))
    88  	require.EqualValues(t, 1, len(keeper.GetDepthBookFromDB(ctx, types.TestTokenPair).Items))
    89  
    90  	// new cache
    91  	keeper.cache = NewCache()
    92  	keeper.diskCache = newDiskCache()
    93  	require.EqualValues(t, 0, keeper.diskCache.openNum)
    94  	require.EqualValues(t, 0, keeper.diskCache.storeOrderNum)
    95  	require.Nil(t, keeper.GetDiskCache().getDepthBook(types.TestTokenPair))
    96  	keeper.ResetCache(ctx)
    97  	require.EqualValues(t, 1, keeper.diskCache.openNum)
    98  	require.EqualValues(t, 1, keeper.diskCache.storeOrderNum)
    99  	require.EqualValues(t, 1, len(keeper.GetDiskCache().getDepthBook(types.TestTokenPair).Items))
   100  
   101  	params := keeper.GetParams(ctx)
   102  	require.EqualValues(t, 1, params.OrderExpireBlocks)
   103  
   104  	keeper.SetMetric()
   105  	met := keeper.GetMetric()
   106  	require.NotNil(t, met)
   107  }
   108  
   109  func TestKeeper_LockCoins(t *testing.T) {
   110  	testInput := CreateTestInputWithBalance(t, 1, 100)
   111  	keeper := testInput.OrderKeeper
   112  	ctx := testInput.Ctx
   113  	feeParams := types.DefaultTestParams()
   114  	feeParams.OrderExpireBlocks = 1
   115  	keeper.SetParams(ctx, &feeParams)
   116  
   117  	tokenPair := dex.GetBuiltInTokenPair()
   118  	err := testInput.DexKeeper.SaveTokenPair(ctx, tokenPair)
   119  	require.Nil(t, err)
   120  
   121  	// mock order
   122  	order := mockOrder("", types.TestTokenPair, types.BuyOrder, "8", "1")
   123  	order.Sender = testInput.TestAddrs[0]
   124  	err = keeper.PlaceOrder(ctx, order)
   125  	require.Nil(t, err)
   126  
   127  	//not enough coin to lock
   128  	err = keeper.LockCoins(ctx, testInput.TestAddrs[0], sdk.SysCoins{{Denom: common.NativeToken, Amount: sdk.MustNewDecFromStr("99.7408")}}, token.LockCoinsTypeQuantity)
   129  	require.NotNil(t, err)
   130  
   131  	//lock coin
   132  	err = keeper.LockCoins(ctx, testInput.TestAddrs[0], sdk.SysCoins{{Denom: common.NativeToken, Amount: sdk.MustNewDecFromStr("90")}}, token.LockCoinsTypeQuantity)
   133  	require.Nil(t, err)
   134  
   135  	//not enough coin to placeorder
   136  	err = keeper.PlaceOrder(ctx, order)
   137  	require.NotNil(t, err)
   138  
   139  	keeper.UnlockCoins(ctx, testInput.TestAddrs[0], sdk.SysCoins{{Denom: common.NativeToken, Amount: sdk.MustNewDecFromStr("90")}}, token.LockCoinsTypeQuantity)
   140  
   141  	//placeorder success
   142  	err = keeper.PlaceOrder(ctx, order)
   143  	require.Nil(t, err)
   144  }
   145  
   146  func TestKeeper_BurnLockedCoins(t *testing.T) {
   147  	testInput := CreateTestInputWithBalance(t, 1, 100)
   148  	keeper := testInput.OrderKeeper
   149  	ctx := testInput.Ctx
   150  	feeParams := types.DefaultTestParams()
   151  	feeParams.OrderExpireBlocks = 1
   152  	keeper.SetParams(ctx, &feeParams)
   153  
   154  	tokenPair := dex.GetBuiltInTokenPair()
   155  	err := testInput.DexKeeper.SaveTokenPair(ctx, tokenPair)
   156  	require.Nil(t, err)
   157  
   158  	// mock order
   159  	order := mockOrder("", types.TestTokenPair, types.BuyOrder, "10", "1")
   160  	order.Sender = testInput.TestAddrs[0]
   161  	err = keeper.PlaceOrder(ctx, order)
   162  	require.Nil(t, err)
   163  
   164  	keeper.BalanceAccount(ctx, testInput.TestAddrs[0],
   165  		sdk.MustParseCoins(common.NativeToken, "8"),
   166  		sdk.MustParseCoins(common.NativeToken, "9"),
   167  	)
   168  
   169  	keeper.CancelOrder(ctx, order, nil)
   170  	require.EqualValues(t, 0, len(keeper.GetLastClosedOrderIDs(ctx)))
   171  
   172  	account := keeper.GetCoins(ctx, testInput.TestAddrs[0])
   173  	require.NotNil(t, account)
   174  	require.EqualValues(t, "99.000000000000000000", account[0].Amount.String())
   175  }
   176  
   177  func TestLastPrice(t *testing.T) {
   178  	testInput := CreateTestInput(t)
   179  	keeper := testInput.OrderKeeper
   180  	ctx := testInput.Ctx
   181  
   182  	tokenPair := dex.GetBuiltInTokenPair()
   183  	err := testInput.DexKeeper.SaveTokenPair(ctx, tokenPair)
   184  	require.Nil(t, err)
   185  
   186  	price := keeper.GetLastPrice(ctx, "xxxb_"+common.NativeToken)
   187  	require.Equal(t, sdk.ZeroDec(), price)
   188  
   189  	keeper.SetLastPrice(ctx, "xxxb_"+common.NativeToken, sdk.MustNewDecFromStr("9.9"))
   190  	price = keeper.GetLastPrice(ctx, "xxxb_"+common.NativeToken)
   191  	require.Equal(t, sdk.MustNewDecFromStr("9.9"), price)
   192  
   193  	require.EqualValues(t, sdk.MustNewDecFromStr("10.0"), keeper.GetLastPrice(ctx, types.TestTokenPair))
   194  	keeper.SetLastPrice(ctx, types.TestTokenPair, sdk.MustNewDecFromStr("1.234"))
   195  	require.EqualValues(t, sdk.MustNewDecFromStr("1.234"), keeper.GetLastPrice(ctx, types.TestTokenPair))
   196  
   197  }
   198  
   199  func TestLastExpiredBlockHeight(t *testing.T) {
   200  	testInput := CreateTestInput(t)
   201  	keeper := testInput.OrderKeeper
   202  	ctx := testInput.Ctx
   203  
   204  	require.EqualValues(t, 0, keeper.GetLastExpiredBlockHeight(ctx))
   205  	keeper.SetLastExpiredBlockHeight(ctx, 100)
   206  	require.EqualValues(t, 100, keeper.GetLastExpiredBlockHeight(ctx))
   207  }
   208  
   209  func TestBlockOrderNum(t *testing.T) {
   210  	testInput := CreateTestInput(t)
   211  	keeper := testInput.OrderKeeper
   212  	ctx := testInput.Ctx
   213  
   214  	require.EqualValues(t, 0, keeper.GetBlockOrderNum(ctx, 10))
   215  	keeper.SetBlockOrderNum(ctx, 10, 1)
   216  	require.EqualValues(t, 1, keeper.GetBlockOrderNum(ctx, 10))
   217  	keeper.DropBlockOrderNum(ctx, 10)
   218  	require.EqualValues(t, 0, keeper.GetBlockOrderNum(ctx, 10))
   219  }
   220  
   221  func TestExpireBlockHeight(t *testing.T) {
   222  	testInput := CreateTestInput(t)
   223  	keeper := testInput.OrderKeeper
   224  	ctx := testInput.Ctx
   225  	var blockHeight int64 = 10
   226  	expireBlockHeight := []int64{1, 2}
   227  	require.EqualValues(t, []int64{}, keeper.GetExpireBlockHeight(ctx, blockHeight))
   228  	keeper.SetExpireBlockHeight(ctx, blockHeight, expireBlockHeight)
   229  	require.EqualValues(t, expireBlockHeight, keeper.GetExpireBlockHeight(ctx, blockHeight))
   230  	keeper.DropExpireBlockHeight(ctx, blockHeight)
   231  	require.EqualValues(t, []int64{}, keeper.GetExpireBlockHeight(ctx, blockHeight))
   232  }
   233  
   234  func TestBlockMatchResult(t *testing.T) {
   235  	testInput := CreateTestInput(t)
   236  	keeper := testInput.OrderKeeper
   237  
   238  	require.Nil(t, keeper.GetBlockMatchResult())
   239  	blockMatchResult := &types.BlockMatchResult{
   240  		BlockHeight: 1,
   241  		ResultMap:   make(map[string]types.MatchResult),
   242  		TimeStamp:   1,
   243  	}
   244  	keeper.SetBlockMatchResult(blockMatchResult)
   245  	require.EqualValues(t, blockMatchResult, keeper.GetBlockMatchResult())
   246  
   247  }
   248  
   249  func TestDropOrder(t *testing.T) {
   250  	testInput := CreateTestInput(t)
   251  	keeper := testInput.OrderKeeper
   252  	ctx := testInput.Ctx.WithBlockHeight(10)
   253  
   254  	tokenPair := dex.GetBuiltInTokenPair()
   255  	err := testInput.DexKeeper.SaveTokenPair(ctx, tokenPair)
   256  	require.Nil(t, err)
   257  
   258  	order := mockOrder("", types.TestTokenPair, types.BuyOrder, "10.0", "1.0")
   259  	order.Sender = testInput.TestAddrs[0]
   260  	err = keeper.PlaceOrder(ctx, order)
   261  	require.Nil(t, err)
   262  
   263  	order2 := keeper.GetOrder(ctx, order.OrderID)
   264  	require.EqualValues(t, order2, order)
   265  
   266  	keeper.DropOrder(ctx, order.OrderID)
   267  	require.Nil(t, keeper.GetOrder(ctx, order.OrderID))
   268  }
   269  
   270  func TestKeeper_UpdateOrder(t *testing.T) {
   271  	common.InitConfig()
   272  	testInput := CreateTestInput(t)
   273  	keeper := testInput.OrderKeeper
   274  	ctx := testInput.Ctx.WithBlockHeight(10)
   275  
   276  	tokenPair := dex.GetBuiltInTokenPair()
   277  	err := testInput.DexKeeper.SaveTokenPair(ctx, tokenPair)
   278  	require.Nil(t, err)
   279  
   280  	order := mockOrder("", types.TestTokenPair, types.BuyOrder, "10.0", "1.0")
   281  	order.Sender = testInput.TestAddrs[0]
   282  	err = keeper.PlaceOrder(ctx, order)
   283  	require.Nil(t, err)
   284  
   285  	//xxb_fibo:10.00000000:BUY
   286  	require.EqualValues(t, "ID0000000010-1", keeper.diskCache.orderIDsMap.Data["xxb_"+common.NativeToken+":10.000000000000000000:BUY"][0])
   287  
   288  	order.Price = sdk.MustNewDecFromStr("11.0")
   289  
   290  	//update order
   291  	keeper.UpdateOrder(order, ctx)
   292  	require.EqualValues(t, 1, len(keeper.GetUpdatedOrderIDs()))
   293  	require.EqualValues(t, 1, len(keeper.GetUpdatedDepthbookKeys()))
   294  	require.EqualValues(t, 0, len(keeper.GetProductPriceOrderIDs("abc")))
   295  	require.EqualValues(t, 0, len(keeper.GetProductPriceOrderIDs(types.TestTokenPair)))
   296  	require.EqualValues(t, 0, len(keeper.GetProductPriceOrderIDsFromDB(ctx, types.TestTokenPair)))
   297  
   298  	require.EqualValues(t, "ID0000000010-1", keeper.cache.updatedOrderIDs[0])
   299  
   300  	order.Status = types.OrderStatusFilled
   301  	keeper.UpdateOrder(order, ctx)
   302  	require.EqualValues(t, 1, keeper.cache.fullFillNum)
   303  
   304  }
   305  
   306  func TestKeeper_SendFeesToProductOwner(t *testing.T) {
   307  	testInput := CreateTestInputWithBalance(t, 1, 100)
   308  	keeper := testInput.OrderKeeper
   309  	ctx := testInput.Ctx
   310  	feeParams := types.DefaultTestParams()
   311  	feeParams.OrderExpireBlocks = 1
   312  	keeper.SetParams(ctx, &feeParams)
   313  
   314  	tokenPair := dex.GetBuiltInTokenPair()
   315  	err := testInput.DexKeeper.SaveTokenPair(ctx, tokenPair)
   316  	require.Nil(t, err)
   317  	testInput.DexKeeper.SetOperator(ctx, dex.DEXOperator{
   318  		Address:            tokenPair.Owner,
   319  		HandlingFeeAddress: tokenPair.Owner,
   320  	})
   321  
   322  	// place order err
   323  	order := mockOrder("", types.TestTokenPair, types.BuyOrder, "108", "1")
   324  	order.Sender = testInput.TestAddrs[0]
   325  	err = keeper.PlaceOrder(ctx, order)
   326  	require.NotNil(t, err)
   327  
   328  	// mock order
   329  	order = mockOrder("", types.TestTokenPair, types.BuyOrder, "8", "1")
   330  	order.Sender = testInput.TestAddrs[0]
   331  	err = keeper.PlaceOrder(ctx, order)
   332  	require.Nil(t, err)
   333  
   334  	fee := GetOrderNewFee(order)
   335  
   336  	dealFee := sdk.SysCoins{{Denom: common.NativeToken, Amount: sdk.MustNewDecFromStr("0.2592")}}
   337  	require.EqualValues(t, fee, dealFee)
   338  
   339  	_, err = keeper.SendFeesToProductOwner(ctx, dealFee, order.Sender, types.FeeTypeOrderDeal, order.Product)
   340  	require.Nil(t, err)
   341  }
   342  
   343  func TestKeeper_GetBestBidAndAsk(t *testing.T) {
   344  	testInput := CreateTestInputWithBalance(t, 1, 100)
   345  	keeper := testInput.OrderKeeper
   346  	ctx := testInput.Ctx
   347  
   348  	ask, _ := keeper.GetBestBidAndAsk(ctx, types.TestTokenPair)
   349  	require.EqualValues(t, sdk.MustNewDecFromStr("0"), ask)
   350  }
   351  
   352  func TestKeeper_InsertOrderIntoDepthBook(t *testing.T) {
   353  	testInput := CreateTestInputWithBalance(t, 1, 100)
   354  	keeper := testInput.OrderKeeper
   355  
   356  	// mock order
   357  	order := mockOrder("", types.TestTokenPair, types.BuyOrder, "8", "1")
   358  	order.Sender = testInput.TestAddrs[0]
   359  	keeper.InsertOrderIntoDepthBook(order)
   360  	require.EqualValues(t, 1, len(keeper.diskCache.depthBookMap.data))
   361  }
   362  
   363  func TestFilterDelistedProducts(t *testing.T) {
   364  	testInput := CreateTestInput(t)
   365  	keeper := testInput.OrderKeeper
   366  	ctx := testInput.Ctx.WithBlockHeight(10)
   367  
   368  	tokenPair := dex.GetBuiltInTokenPair()
   369  	err := keeper.dexKeeper.SaveTokenPair(ctx, tokenPair)
   370  	require.Nil(t, err)
   371  
   372  	productsList := []string{
   373  		"xxb_yyb",
   374  		types.TestTokenPair,
   375  		"ttb_qqb",
   376  	}
   377  
   378  	expectedProductsList := []string{
   379  		types.TestTokenPair,
   380  	}
   381  
   382  	cleanProducts := keeper.FilterDelistedProducts(ctx, productsList)
   383  	require.EqualValues(t, expectedProductsList, cleanProducts)
   384  }