github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/x/token/querier_test.go (about) 1 package token 2 3 import ( 4 "testing" 5 6 "github.com/fibonacci-chain/fbc/x/token/types" 7 8 sdk "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types" 9 "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/mock" 10 abci "github.com/fibonacci-chain/fbc/libs/tendermint/abci/types" 11 "github.com/fibonacci-chain/fbc/x/common" 12 "github.com/stretchr/testify/require" 13 ) 14 15 func TestQueryOrder(t *testing.T) { 16 mapp, keeper, _ := getMockDexApp(t, 0) 17 mapp.BeginBlock(abci.RequestBeginBlock{Header: abci.Header{Height: 2}}) 18 ctx := mapp.BaseApp.NewContext(false, abci.Header{}) 19 20 _, testAccounts := CreateGenAccounts(2, 21 sdk.SysCoins{ 22 sdk.NewDecCoinFromDec(common.NativeToken, sdk.NewDec(1000000000)), 23 }) 24 25 token := types.Token{ 26 Description: "okblockchain coin", 27 Symbol: common.NativeToken, 28 OriginalSymbol: common.NativeToken, 29 OriginalTotalSupply: sdk.NewDec(1000000000), 30 Owner: testAccounts[0].baseAccount.Address, 31 Mintable: true, 32 } 33 34 coins := sdk.NewCoins(sdk.NewDecCoinFromDec(token.Symbol, token.OriginalTotalSupply)) 35 err := keeper.supplyKeeper.MintCoins(ctx, types.ModuleName, coins) 36 require.NoError(t, err) 37 38 keeper.NewToken(ctx, token) 39 40 querier := NewQuerier(keeper) 41 path := []string{types.QueryInfo, ""} 42 res, err := querier(ctx, path, abci.RequestQuery{}) 43 require.NotNil(t, err) 44 require.Equal(t, []byte(nil), res) 45 path = []string{types.QueryInfo, common.NativeToken} 46 res, err = querier(ctx, path, abci.RequestQuery{}) 47 require.Nil(t, err) 48 49 var token2 types.Token 50 keeper.cdc.MustUnmarshalJSON(res, &token2) 51 require.EqualValues(t, token, token2) 52 } 53 54 func TestQueryTokens(t *testing.T) { 55 mapp, keeper, _ := getMockDexApp(t, 0) 56 mapp.BeginBlock(abci.RequestBeginBlock{Header: abci.Header{Height: 2}}) 57 ctx := mapp.BaseApp.NewContext(false, abci.Header{}) 58 59 _, testAccounts := CreateGenAccounts(2, 60 sdk.SysCoins{ 61 sdk.NewDecCoinFromDec(common.NativeToken, sdk.NewDec(1000000000)), 62 }) 63 64 token := types.Token{ 65 Description: "okblockchain coin", 66 Symbol: common.NativeToken, 67 OriginalSymbol: common.NativeToken, 68 OriginalTotalSupply: sdk.NewDec(1000000000), 69 Owner: testAccounts[0].baseAccount.Address, 70 Mintable: true, 71 } 72 73 coins := sdk.NewCoins(sdk.NewDecCoinFromDec(token.Symbol, token.OriginalTotalSupply)) 74 err := keeper.supplyKeeper.MintCoins(ctx, types.ModuleName, coins) 75 require.NoError(t, err) 76 77 keeper.NewToken(ctx, token) 78 79 var originTokens []types.Token 80 originTokens = append(originTokens, token) 81 82 querier := NewQuerier(keeper) 83 84 path := []string{types.QueryTokens} 85 res, err := querier(ctx, path, abci.RequestQuery{}) 86 require.Nil(t, err) 87 88 var tokens []types.Token 89 keeper.cdc.MustUnmarshalJSON(res, &tokens) 90 require.EqualValues(t, originTokens, tokens) 91 92 //token V2 93 path = []string{types.QueryTokenV2, common.NativeToken} 94 res, err = querier(ctx, path, abci.RequestQuery{}) 95 require.Nil(t, err) 96 require.Panics(t, func() { keeper.cdc.MustUnmarshalJSON(res, &tokens) }) 97 require.EqualValues(t, originTokens, tokens) 98 //no symbol 99 path = []string{types.QueryTokenV2, ""} 100 res, err = querier(ctx, path, abci.RequestQuery{}) 101 //require.EqualValues(t, sdk.CodeInvalidCoins, err.Code()) 102 require.NotNil(t, err) 103 require.Equal(t, []byte(nil), res) 104 105 //tokens V2 106 path = []string{types.QueryTokensV2} 107 res, err = querier(ctx, path, abci.RequestQuery{}) 108 require.Nil(t, err) 109 110 keeper.cdc.MustUnmarshalJSON(res, &tokens) 111 require.EqualValues(t, originTokens, tokens) 112 113 //query with address 114 path = []string{types.QueryTokens, testAccounts[0].baseAccount.Address.String()} 115 res, err = querier(ctx, path, abci.RequestQuery{}) 116 require.Nil(t, err) 117 118 keeper.cdc.MustUnmarshalJSON(res, &tokens) 119 require.EqualValues(t, originTokens, tokens) 120 121 //query with invalid address 122 token = types.Token{ 123 Description: "okblockchain coin", 124 Symbol: common.NativeToken, 125 OriginalSymbol: common.NativeToken, 126 OriginalTotalSupply: sdk.NewDec(1000000000), 127 //TotalSupply: sdk.NewDec(1000000000), 128 Owner: []byte("abc"), 129 Mintable: true, 130 } 131 132 keeper.NewToken(ctx, token) 133 path = []string{types.QueryTokens, "abc"} 134 res, err = querier(ctx, path, abci.RequestQuery{}) 135 //require.EqualValues(t, sdk.CodeInvalidAddress, err.Code()) 136 require.NotNil(t, err) 137 require.Equal(t, []byte(nil), res) 138 } 139 140 func TestQueryUserTokens(t *testing.T) { 141 mapp, keeper, _ := getMockDexApp(t, 0) 142 mapp.BeginBlock(abci.RequestBeginBlock{Header: abci.Header{Height: 2}}) 143 ctx := mapp.BaseApp.NewContext(false, abci.Header{}) 144 145 _, testAccounts := CreateGenAccounts(2, 146 sdk.SysCoins{ 147 sdk.NewDecCoinFromDec(common.NativeToken, sdk.NewDec(1000000000)), 148 }) 149 150 token := types.Token{ 151 Description: "okblockchain coin", 152 Symbol: common.NativeToken, 153 OriginalSymbol: common.NativeToken, 154 OriginalTotalSupply: sdk.NewDec(1000000000), 155 Owner: testAccounts[0].baseAccount.Address, 156 Mintable: true, 157 } 158 159 coins := sdk.NewCoins(sdk.NewDecCoinFromDec(token.Symbol, token.OriginalTotalSupply)) 160 err := keeper.supplyKeeper.MintCoins(ctx, types.ModuleName, coins) 161 require.NoError(t, err) 162 163 keeper.NewToken(ctx, token) 164 165 var originTokens []types.Token 166 originTokens = append(originTokens, token) 167 168 querier := NewQuerier(keeper) 169 170 path := []string{types.QueryTokens, testAccounts[0].baseAccount.Address.String()} 171 res, err := querier(ctx, path, abci.RequestQuery{}) 172 require.Nil(t, err) 173 174 var tokens []types.Token 175 keeper.cdc.MustUnmarshalJSON(res, &tokens) 176 require.EqualValues(t, originTokens, tokens) 177 } 178 179 func TestQueryCurrency(t *testing.T) { 180 mapp, keeper, _ := getMockDexApp(t, 0) 181 mapp.BeginBlock(abci.RequestBeginBlock{Header: abci.Header{Height: 2}}) 182 ctx := mapp.BaseApp.NewContext(false, abci.Header{}) 183 184 _, testAccounts := CreateGenAccounts(2, 185 sdk.SysCoins{ 186 sdk.NewDecCoinFromDec(common.NativeToken, sdk.NewDec(1000000000)), 187 }) 188 189 token := types.Token{ 190 Description: "okblockchain coin", 191 Symbol: common.NativeToken, 192 OriginalSymbol: common.NativeToken, 193 OriginalTotalSupply: sdk.NewDec(1000000000), 194 Owner: testAccounts[0].baseAccount.Address, 195 Mintable: true, 196 } 197 198 keeper.NewToken(ctx, token) 199 keeper.supplyKeeper.MintCoins(ctx, types.ModuleName, sdk.NewDecCoinsFromDec(common.NativeToken, sdk.NewDec(1000000000))) 200 201 //var originTokens []types.Token 202 originalTokens := []types.Currency{ 203 { 204 Description: "okblockchain coin", 205 Symbol: common.NativeToken, 206 TotalSupply: sdk.NewDec(1000000000), 207 }, 208 } 209 210 querier := NewQuerier(keeper) 211 path := []string{types.QueryCurrency} 212 res, err := querier(ctx, path, abci.RequestQuery{}) 213 require.Nil(t, err) 214 215 var currency []types.Currency 216 keeper.cdc.MustUnmarshalJSON(res, ¤cy) 217 require.EqualValues(t, originalTokens, currency) 218 } 219 220 func TestQueryAccount(t *testing.T) { 221 mapp, keeper, _ := getMockDexApp(t, 0) 222 mapp.BeginBlock(abci.RequestBeginBlock{Header: abci.Header{Height: 2}}) 223 ctx := mapp.BaseApp.NewContext(false, abci.Header{}) 224 225 genAccs, testAccounts := CreateGenAccounts(1, 226 sdk.SysCoins{ 227 sdk.NewDecCoinFromDec(common.NativeToken, sdk.NewDec(1000000000)), 228 }) 229 mock.SetGenesis(mapp.App, types.DecAccountArrToBaseAccountArr(genAccs)) 230 231 token := types.Token{ 232 Description: "okblockchain coin", 233 Symbol: common.NativeToken, 234 OriginalSymbol: common.NativeToken, 235 OriginalTotalSupply: sdk.NewDec(1000000000), 236 Owner: testAccounts[0].baseAccount.Address, 237 Mintable: true, 238 } 239 240 originalCoinsInfo := types.CoinsInfo{ 241 types.CoinInfo{ 242 Symbol: common.NativeToken, 243 Available: "1000000000.000000000000000000", 244 Locked: "0", 245 }, 246 } 247 248 keeper.NewToken(ctx, token) 249 250 querier := NewQuerier(keeper) 251 path := []string{types.QueryAccount, testAccounts[0].baseAccount.Address.String()} 252 var accountParam types.AccountParam 253 accountParam.Symbol = common.NativeToken 254 accountParam.Show = "partial" 255 256 bz, err := keeper.cdc.MarshalJSON(accountParam) 257 require.Nil(t, err) 258 res, err := querier(ctx, path, abci.RequestQuery{Data: nil}) 259 require.Error(t, err) 260 require.Equal(t, []byte(nil), res) 261 res, err = querier(ctx, path, abci.RequestQuery{Data: bz}) 262 require.Nil(t, err) 263 264 //var coinsInfo CoinsInfo 265 var accountResponse types.AccountResponse 266 keeper.cdc.MustUnmarshalJSON(res, &accountResponse) 267 268 require.EqualValues(t, originalCoinsInfo, accountResponse.Currencies) 269 270 path = []string{types.QueryAccount, "notexist"} 271 _, err = querier(ctx, path, abci.RequestQuery{}) 272 require.Error(t, err) 273 274 path = []string{"not_exist", "notexist"} 275 _, err = querier(ctx, path, abci.RequestQuery{}) 276 require.Error(t, err) 277 278 //account V2 279 var param types.AccountParamV2 280 path = []string{types.QueryAccountV2, testAccounts[0].baseAccount.Address.String()} 281 param.Currency = "" 282 param.HideZero = "partial" 283 284 bz = keeper.cdc.MustMarshalJSON(param) 285 _, err = querier(ctx, path, abci.RequestQuery{Data: nil}) 286 require.Error(t, err) 287 //Currency nil 288 _, err = querier(ctx, path, abci.RequestQuery{Data: bz}) 289 require.Nil(t, err) 290 //hide no 291 param.Currency = "" 292 param.HideZero = "no" 293 bz = keeper.cdc.MustMarshalJSON(param) 294 _, err = querier(ctx, path, abci.RequestQuery{Data: bz}) 295 require.Nil(t, err) 296 297 param.Currency = common.NativeToken 298 param.HideZero = "no" 299 bz = keeper.cdc.MustMarshalJSON(param) 300 _, err = querier(ctx, path, abci.RequestQuery{Data: bz}) 301 require.Nil(t, err) 302 303 //err address 304 path = []string{types.QueryAccountV2, "abc"} 305 _, err = querier(ctx, path, abci.RequestQuery{Data: nil}) 306 require.Error(t, err) 307 } 308 309 func TestQueryAccount_ShowAll(t *testing.T) { 310 mapp, keeper, _ := getMockDexApp(t, 0) 311 mapp.BeginBlock(abci.RequestBeginBlock{Header: abci.Header{Height: 2}}) 312 ctx := mapp.BaseApp.NewContext(false, abci.Header{}) 313 314 genAccs, testAccounts := CreateGenAccounts(1, 315 sdk.SysCoins{ 316 sdk.NewDecCoinFromDec(common.NativeToken, sdk.NewDec(1000000000)), 317 }) 318 mock.SetGenesis(mapp.App, types.DecAccountArrToBaseAccountArr(genAccs)) 319 320 tokens := []types.Token{ 321 { 322 Description: "okblockchain coin", 323 Symbol: common.NativeToken, 324 OriginalSymbol: common.NativeToken, 325 OriginalTotalSupply: sdk.NewDec(1000000000), 326 Owner: testAccounts[0].baseAccount.Address, 327 Mintable: true, 328 }, 329 { 330 Description: "not_exist", 331 Symbol: "xxb", 332 OriginalSymbol: "xxb", 333 OriginalTotalSupply: sdk.ZeroDec(), 334 Owner: testAccounts[0].baseAccount.Address, 335 Mintable: false, 336 }, 337 } 338 for _, token := range tokens { 339 keeper.NewToken(ctx, token) 340 } 341 342 originalCoinsInfo := types.CoinsInfo{ 343 types.CoinInfo{ 344 Symbol: common.NativeToken, 345 Available: "1000000000.000000000000000000", 346 Locked: "0", 347 }, 348 types.CoinInfo{ 349 Symbol: "xxb", 350 Available: "0", 351 Locked: "0", 352 }, 353 } 354 355 querier := NewQuerier(keeper) 356 357 accountParam := types.AccountParam{ 358 Symbol: "", 359 Show: "all", 360 } 361 bz := keeper.cdc.MustMarshalJSON(accountParam) 362 path := []string{types.QueryAccount, testAccounts[0].baseAccount.Address.String()} 363 res, err := querier(ctx, path, abci.RequestQuery{Data: bz}) 364 require.Nil(t, err) 365 366 var accountResponse types.AccountResponse 367 keeper.cdc.MustUnmarshalJSON(res, &accountResponse) 368 require.EqualValues(t, originalCoinsInfo, accountResponse.Currencies) 369 } 370 371 func TestQueryParameters(t *testing.T) { 372 mapp, keeper, _ := getMockDexApp(t, 0) 373 mapp.BeginBlock(abci.RequestBeginBlock{Header: abci.Header{Height: 2}}) 374 ctx := mapp.BaseApp.NewContext(false, abci.Header{}) 375 376 genAccs, _ := CreateGenAccounts(1, 377 sdk.SysCoins{ 378 sdk.NewDecCoinFromDec(common.NativeToken, sdk.NewDec(1000000000)), 379 }) 380 mock.SetGenesis(mapp.App, types.DecAccountArrToBaseAccountArr(genAccs)) 381 382 params := types.DefaultParams() 383 keeper.SetParams(ctx, params) 384 385 querier := NewQuerier(keeper) 386 path := []string{types.QueryParameters} 387 388 res, err := querier(ctx, path, abci.RequestQuery{}) 389 require.Nil(t, err) 390 //res, err := queryParameters(ctx, keeper) 391 //require.Nil(t, err) 392 393 var actualParams types.Params 394 err1 := keeper.cdc.UnmarshalJSON(res, &actualParams) 395 require.Nil(t, err1) 396 require.EqualValues(t, actualParams, params) 397 } 398 399 func TestQueryKeysNum(t *testing.T) { 400 mapp, keeper, _ := getMockDexApp(t, 0) 401 mapp.BeginBlock(abci.RequestBeginBlock{Header: abci.Header{Height: 2}}) 402 ctx := mapp.BaseApp.NewContext(false, abci.Header{}) 403 404 genAccs, _ := CreateGenAccounts(1, 405 sdk.SysCoins{ 406 sdk.NewDecCoinFromDec(common.NativeToken, sdk.NewDec(1000000000)), 407 }) 408 mock.SetGenesis(mapp.App, types.DecAccountArrToBaseAccountArr(genAccs)) 409 410 path := []string{types.QueryKeysNum} 411 querier := NewQuerier(keeper) 412 res, err := querier(ctx, path, abci.RequestQuery{}) 413 require.Nil(t, err) 414 415 keyNums := map[string]int64{"token": 1, 416 "lock": 0, 417 "tokenPair": 1, 418 } 419 420 resMap := make(map[string]int64) 421 err1 := keeper.cdc.UnmarshalJSON(res, &resMap) 422 require.Nil(t, err1) 423 require.EqualValues(t, keyNums, keyNums) 424 } 425 426 func TestCreateParam(t *testing.T) { 427 ctx, kepper, kv, data := CreateParam(t, true) 428 require.NotNil(t, ctx) 429 require.NotNil(t, kepper) 430 require.NotNil(t, kv) 431 require.EqualValues(t, "testToken", string(data)) 432 }