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

     1  //go:build ignore
     2  
     3  package ammswap
     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 MockApp 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 registerCodec(cdc *codec.Codec) {
    40  	RegisterCodec(cdc)
    41  	token.RegisterCodec(cdc)
    42  	supply.RegisterCodec(cdc)
    43  }
    44  
    45  func getMockApp(t *testing.T, numGenAccs int) (mockApp *MockApp, addrKeysSlice mock.AddrKeysSlice) {
    46  	return getMockAppWithBalance(t, numGenAccs, 100)
    47  }
    48  
    49  // initialize the mock application for this module
    50  func getMockAppWithBalance(t *testing.T, numGenAccs int, balance int64) (mockApp *MockApp,
    51  	addrKeysSlice mock.AddrKeysSlice) {
    52  	mapp := mock.NewApp()
    53  	registerCodec(mapp.Cdc.GetCdc())
    54  
    55  	mockApp = &MockApp{
    56  		App:       mapp,
    57  		keySwap:   sdk.NewKVStoreKey(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  		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(DefaultParamspace),
    95  	)
    96  
    97  	mockApp.Router().AddRoute(RouterKey, NewHandler(mockApp.swapKeeper))
    98  	mockApp.QueryRouter().AddRoute(QuerierRoute, NewQuerier(mockApp.swapKeeper))
    99  
   100  	mockApp.SetBeginBlocker(getBeginBlocker(mockApp.swapKeeper))
   101  	mockApp.SetEndBlocker(getEndBlocker(mockApp.swapKeeper))
   102  	mockApp.SetInitChainer(getInitChainer(mockApp.App, mockApp.supplyKeeper,
   103  		[]exported.ModuleAccountI{feeCollector}))
   104  
   105  	decCoins, err := sdk.ParseDecCoins(fmt.Sprintf("%d%s,%d%s,%d%s,%d%s",
   106  		balance, types.TestQuotePooledToken, balance, types.TestBasePooledToken, balance, types.TestBasePooledToken2, balance, types.TestBasePooledToken3))
   107  	require.Nil(t, err)
   108  	coins := decCoins
   109  
   110  	keysSlice, genAccs := CreateGenAccounts(numGenAccs, coins)
   111  	addrKeysSlice = keysSlice
   112  
   113  	// todo: checkTx in mock app
   114  	mockApp.SetAnteHandler(nil)
   115  
   116  	app := mockApp
   117  	require.NoError(t, app.CompleteSetup(
   118  		app.keySwap,
   119  		app.keyToken,
   120  		app.keyLock,
   121  		app.keySupply,
   122  	))
   123  	mock.SetGenesis(mockApp.App, genAccs)
   124  
   125  	for i := 0; i < numGenAccs; i++ {
   126  		mock.CheckBalance(t, app.App, keysSlice[i].Address, coins)
   127  		mockApp.TotalCoinsSupply = mockApp.TotalCoinsSupply.Add2(coins)
   128  	}
   129  
   130  	return mockApp, addrKeysSlice
   131  }
   132  
   133  func getBeginBlocker(keeper Keeper) sdk.BeginBlocker {
   134  	return func(ctx sdk.Context, req abci.RequestBeginBlock) abci.ResponseBeginBlock {
   135  		BeginBlocker(ctx, keeper)
   136  		return abci.ResponseBeginBlock{}
   137  	}
   138  }
   139  
   140  func getEndBlocker(keeper Keeper) sdk.EndBlocker {
   141  	return func(ctx sdk.Context, req abci.RequestEndBlock) abci.ResponseEndBlock {
   142  		EndBlocker(ctx, keeper)
   143  		return abci.ResponseEndBlock{}
   144  	}
   145  }
   146  
   147  func getInitChainer(mapp *mock.App, supplyKeeper staking.SupplyKeeper,
   148  	blacklistedAddrs []exported.ModuleAccountI) sdk.InitChainer {
   149  	return func(ctx sdk.Context, req abci.RequestInitChain) abci.ResponseInitChain {
   150  		mapp.InitChainer(ctx, req)
   151  		// set module accounts
   152  		for _, macc := range blacklistedAddrs {
   153  			supplyKeeper.SetModuleAccount(ctx, macc)
   154  		}
   155  		return abci.ResponseInitChain{}
   156  	}
   157  }
   158  
   159  func CreateGenAccounts(numAccs int, genCoins sdk.Coins) (addrKeysSlice mock.AddrKeysSlice,
   160  	genAccs []auth.Account) {
   161  	for i := 0; i < numAccs; i++ {
   162  		privKey := secp256k1.GenPrivKey()
   163  		pubKey := privKey.PubKey()
   164  		addr := sdk.AccAddress(pubKey.Address())
   165  
   166  		addrKeys := mock.NewAddrKeys(addr, pubKey, privKey)
   167  		account := &auth.BaseAccount{
   168  			Address: addr,
   169  			Coins:   genCoins,
   170  		}
   171  		genAccs = append(genAccs, account)
   172  		addrKeysSlice = append(addrKeysSlice, addrKeys)
   173  	}
   174  	return
   175  }