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

     1  //go:build ignore
     2  
     3  package keeper
     4  
     5  import (
     6  	"fmt"
     7  	"testing"
     8  
     9  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/codec"
    10  	sdk "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types"
    11  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/auth"
    12  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/bank"
    13  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/mock"
    14  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/supply"
    15  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/supply/exported"
    16  	abci "github.com/fibonacci-chain/fbc/libs/tendermint/abci/types"
    17  	"github.com/fibonacci-chain/fbc/libs/tendermint/crypto/secp256k1"
    18  	"github.com/fibonacci-chain/fbc/x/ammswap/types"
    19  	staking "github.com/fibonacci-chain/fbc/x/staking/types"
    20  	"github.com/stretchr/testify/require"
    21  
    22  	"github.com/fibonacci-chain/fbc/x/token"
    23  )
    24  
    25  type TestInput struct {
    26  	*mock.App
    27  
    28  	keySwap   *sdk.KVStoreKey
    29  	keyToken  *sdk.KVStoreKey
    30  	keyLock   *sdk.KVStoreKey
    31  	keySupply *sdk.KVStoreKey
    32  
    33  	bankKeeper   bank.Keeper
    34  	swapKeeper   Keeper
    35  	tokenKeeper  token.Keeper
    36  	supplyKeeper supply.Keeper
    37  }
    38  
    39  func regCodec(cdc *codec.Codec) {
    40  	types.RegisterCodec(cdc)
    41  	token.RegisterCodec(cdc)
    42  	supply.RegisterCodec(cdc)
    43  }
    44  
    45  func GetTestInput(t *testing.T, numGenAccs int) (mockApp *TestInput, addrKeysSlice mock.AddrKeysSlice) {
    46  	return getTestInputWithBalance(t, numGenAccs, 100)
    47  }
    48  
    49  // initialize the mock application for this module
    50  func getTestInputWithBalance(t *testing.T, numGenAccs int, balance int64) (mockApp *TestInput,
    51  	addrKeysSlice mock.AddrKeysSlice) {
    52  	mapp := mock.NewApp()
    53  	regCodec(mapp.Cdc.GetCdc())
    54  
    55  	mockApp = &TestInput{
    56  		App:       mapp,
    57  		keySwap:   sdk.NewKVStoreKey(types.StoreKey),
    58  		keyToken:  sdk.NewKVStoreKey(token.StoreKey),
    59  		keyLock:   sdk.NewKVStoreKey(token.KeyLock),
    60  		keySupply: sdk.NewKVStoreKey(supply.StoreKey),
    61  	}
    62  
    63  	feeCollector := supply.NewEmptyModuleAccount(auth.FeeCollectorName)
    64  	blacklistedAddrs := make(map[string]bool)
    65  	blacklistedAddrs[feeCollector.String()] = true
    66  
    67  	mockApp.bankKeeper = bank.NewBaseKeeper(mockApp.AccountKeeper,
    68  		mockApp.ParamsKeeper.Subspace(bank.DefaultParamspace),
    69  		blacklistedAddrs)
    70  
    71  	maccPerms := map[string][]string{
    72  		auth.FeeCollectorName: nil,
    73  		token.ModuleName:      {supply.Minter, supply.Burner},
    74  		types.ModuleName:      {supply.Minter, supply.Burner},
    75  	}
    76  	mockApp.supplyKeeper = supply.NewKeeper(mockApp.Cdc.GetCdc(), mockApp.keySupply, mockApp.AccountKeeper,
    77  		mockApp.bankKeeper, maccPerms)
    78  
    79  	mockApp.tokenKeeper = token.NewKeeper(
    80  		mockApp.bankKeeper,
    81  		mockApp.ParamsKeeper.Subspace(token.DefaultParamspace),
    82  		auth.FeeCollectorName,
    83  		mockApp.supplyKeeper,
    84  		mockApp.keyToken,
    85  		mockApp.keyLock,
    86  		mockApp.Cdc.GetCdc(),
    87  		true, mockApp.AccountKeeper)
    88  
    89  	mockApp.swapKeeper = NewKeeper(
    90  		mockApp.supplyKeeper,
    91  		mockApp.tokenKeeper,
    92  		mockApp.Cdc.GetCdc(),
    93  		mockApp.keySwap,
    94  		mockApp.ParamsKeeper.Subspace(types.DefaultParamspace),
    95  	)
    96  
    97  	mockApp.QueryRouter().AddRoute(types.QuerierRoute, NewQuerier(mockApp.swapKeeper))
    98  
    99  	mockApp.SetInitChainer(initChainer(mockApp.App, mockApp.supplyKeeper,
   100  		[]exported.ModuleAccountI{feeCollector}))
   101  
   102  	decCoins, err := sdk.ParseDecCoins(fmt.Sprintf("%d%s,%d%s,%d%s,%d%s",
   103  		balance, types.TestQuotePooledToken, balance, types.TestBasePooledToken, balance, types.TestBasePooledToken2, balance, types.TestBasePooledToken3))
   104  	require.Nil(t, err)
   105  	coins := decCoins
   106  
   107  	keysSlice, genAccs := GenAccounts(numGenAccs, coins)
   108  	addrKeysSlice = keysSlice
   109  
   110  	// todo: checkTx in mock app
   111  	mockApp.SetAnteHandler(nil)
   112  
   113  	app := mockApp
   114  	require.NoError(t, app.CompleteSetup(
   115  		app.keySwap,
   116  		app.keyToken,
   117  		app.keyLock,
   118  		app.keySupply,
   119  	))
   120  	mock.SetGenesis(mockApp.App, genAccs)
   121  
   122  	for i := 0; i < numGenAccs; i++ {
   123  		mock.CheckBalance(t, app.App, keysSlice[i].Address, coins)
   124  		mockApp.TotalCoinsSupply = mockApp.TotalCoinsSupply.Add2(coins)
   125  	}
   126  
   127  	return mockApp, addrKeysSlice
   128  }
   129  
   130  func initChainer(mapp *mock.App, supplyKeeper staking.SupplyKeeper,
   131  	blacklistedAddrs []exported.ModuleAccountI) sdk.InitChainer {
   132  	return func(ctx sdk.Context, req abci.RequestInitChain) abci.ResponseInitChain {
   133  		mapp.InitChainer(ctx, req)
   134  		// set module accounts
   135  		for _, macc := range blacklistedAddrs {
   136  			supplyKeeper.SetModuleAccount(ctx, macc)
   137  		}
   138  		return abci.ResponseInitChain{}
   139  	}
   140  }
   141  
   142  func GenAccounts(numAccs int, genCoins sdk.Coins) (addrKeysSlice mock.AddrKeysSlice,
   143  	genAccs []auth.Account) {
   144  	for i := 0; i < numAccs; i++ {
   145  		privKey := secp256k1.GenPrivKey()
   146  		pubKey := privKey.PubKey()
   147  		addr := sdk.AccAddress(pubKey.Address())
   148  
   149  		addrKeys := mock.NewAddrKeys(addr, pubKey, privKey)
   150  		account := &auth.BaseAccount{
   151  			Address: addr,
   152  			Coins:   genCoins,
   153  		}
   154  		genAccs = append(genAccs, account)
   155  		addrKeysSlice = append(addrKeysSlice, addrKeys)
   156  	}
   157  	return
   158  }