laconicd/tests/integration/common.go

package integration_test

import (
	"context"
	"testing"

	"cosmossdk.io/core/appmodule"
	"cosmossdk.io/log"
	"cosmossdk.io/math"
	storetypes "cosmossdk.io/store/types"
	"cosmossdk.io/x/bank"
	bankkeeper "cosmossdk.io/x/bank/keeper"
	banktypes "cosmossdk.io/x/bank/types"
	minttypes "cosmossdk.io/x/mint/types"
	"github.com/cosmos/cosmos-sdk/baseapp"
	"github.com/cosmos/cosmos-sdk/codec"
	codectestutil "github.com/cosmos/cosmos-sdk/codec/testutil"
	"github.com/cosmos/cosmos-sdk/runtime"
	"github.com/cosmos/cosmos-sdk/testutil/integration"
	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
	sdk "github.com/cosmos/cosmos-sdk/types"
	moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil"
	"github.com/cosmos/cosmos-sdk/x/auth"
	authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
	authsims "github.com/cosmos/cosmos-sdk/x/auth/simulation"
	authtestutil "github.com/cosmos/cosmos-sdk/x/auth/testutil"
	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
	gomock "go.uber.org/mock/gomock"

	"git.vdb.to/cerc-io/laconicd/app/params"
	"git.vdb.to/cerc-io/laconicd/utils"
	auctiontypes "git.vdb.to/cerc-io/laconicd/x/auction"
	auctionkeeper "git.vdb.to/cerc-io/laconicd/x/auction/keeper"
	auctionmodule "git.vdb.to/cerc-io/laconicd/x/auction/module"
	bondtypes "git.vdb.to/cerc-io/laconicd/x/bond"
	bondkeeper "git.vdb.to/cerc-io/laconicd/x/bond/keeper"
	bondmodule "git.vdb.to/cerc-io/laconicd/x/bond/module"
	registrytypes "git.vdb.to/cerc-io/laconicd/x/registry"
	registrykeeper "git.vdb.to/cerc-io/laconicd/x/registry/keeper"
	registrymodule "git.vdb.to/cerc-io/laconicd/x/registry/module"
)

type TestFixture struct {
	App *integration.App

	SdkCtx sdk.Context
	cdc    codec.Codec
	keys   map[string]*storetypes.KVStoreKey

	AccountKeeper authkeeper.AccountKeeper
	BankKeeper    bankkeeper.Keeper

	AuctionKeeper  *auctionkeeper.Keeper
	BondKeeper     *bondkeeper.Keeper
	RegistryKeeper registrykeeper.Keeper
}

func (tf *TestFixture) Setup(t *testing.T) error {
	keys := storetypes.NewKVStoreKeys(
		authtypes.StoreKey, banktypes.StoreKey, auctiontypes.StoreKey, bondtypes.StoreKey, registrytypes.StoreKey,
	)
	cdc := moduletestutil.MakeTestEncodingConfig(
		codectestutil.CodecOptions{},
		auth.AppModule{},
		auctionmodule.AppModule{},
		bondmodule.AppModule{},
		registrymodule.AppModule{},
	).Codec

	logger := log.NewNopLogger() // Use log.NewTestLogger(kts.T()) for help with debugging
	cms := integration.CreateMultiStore(keys, logger)

	newCtx := sdk.NewContext(cms, true, logger)

	authority := authtypes.NewModuleAddress("gov")

	// gomock initializations
	ctrl := gomock.NewController(t)
	accountsModKeeper := authtestutil.NewMockAccountsModKeeper(ctrl)
	acctNum := uint64(0)
	accountsModKeeper.EXPECT().NextAccountNumber(gomock.Any()).AnyTimes().DoAndReturn(func(ctx context.Context) (uint64, error) {
		currNum := acctNum
		acctNum++
		return currNum, nil
	})

	maccPerms := map[string][]string{
		minttypes.ModuleName:                         {authtypes.Minter},
		auctiontypes.ModuleName:                      {},
		auctiontypes.AuctionBurnModuleAccountName:    {},
		bondtypes.ModuleName:                         {},
		registrytypes.ModuleName:                     {},
		registrytypes.RecordRentModuleAccountName:    {},
		registrytypes.AuthorityRentModuleAccountName: {},
	}

	accountKeeper := authkeeper.NewAccountKeeper(
		runtime.NewEnvironment(runtime.NewKVStoreService(keys[authtypes.StoreKey]), logger),
		cdc,
		authtypes.ProtoBaseAccount,
		accountsModKeeper,
		maccPerms,
		utils.NewAddressCodec(),
		params.Bech32PrefixAccAddr,
		authority.String(),
	)

	blockedAddresses := map[string]bool{
		accountKeeper.GetAuthority(): false,
	}
	bankKeeper := bankkeeper.NewBaseKeeper(
		runtime.NewEnvironment(runtime.NewKVStoreService(keys[banktypes.StoreKey]), logger),
		cdc,
		accountKeeper,
		blockedAddresses,
		authority.String(),
	)

	auctionKeeper := auctionkeeper.NewKeeper(
		runtime.NewEnvironment(runtime.NewKVStoreService(keys[auctiontypes.StoreKey]), logger),
		cdc,
		accountKeeper,
		bankKeeper,
		authority.String(),
		logger,
	)

	bondKeeper := bondkeeper.NewKeeper(
		runtime.NewEnvironment(runtime.NewKVStoreService(keys[bondtypes.StoreKey]), logger),
		cdc,
		runtime.NewKVStoreService(keys[bondtypes.StoreKey]),
		accountKeeper,
		bankKeeper,
		authority.String(),
		logger,
	)

	registryKeeper := registrykeeper.NewKeeper(
		runtime.NewEnvironment(runtime.NewKVStoreService(keys[registrytypes.StoreKey]), logger),
		cdc,
		accountKeeper,
		bankKeeper,
		bondKeeper,
		auctionKeeper,
		authority.String(),
		logger,
	)

	authModule := auth.NewAppModule(cdc, accountKeeper, accountsModKeeper, authsims.RandomGenesisAccounts, nil)
	bankModule := bank.NewAppModule(cdc, bankKeeper, accountKeeper)
	auctionModule := auctionmodule.NewAppModule(cdc, auctionKeeper)
	bondModule := bondmodule.NewAppModule(cdc, bondKeeper)
	registryModule := registrymodule.NewAppModule(cdc, registryKeeper)

	router := baseapp.NewMsgServiceRouter()
	queryRouter := baseapp.NewGRPCQueryRouter()

	integrationApp := integration.NewIntegrationApp(
		newCtx, logger, keys, cdc,
		utils.NewAddressCodec(),
		utils.NewValAddressCodec(),
		map[string]appmodule.AppModule{
			authtypes.ModuleName:     authModule,
			banktypes.ModuleName:     bankModule,
			auctiontypes.ModuleName:  auctionModule,
			bondtypes.ModuleName:     bondModule,
			registrytypes.ModuleName: registryModule,
		},
		router, queryRouter)

	ctx := integrationApp.Context()

	// Register MsgServer and QueryServer
	auctiontypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), auctionkeeper.NewMsgServerImpl(auctionKeeper))
	auctiontypes.RegisterQueryServer(integrationApp.QueryHelper(), auctionkeeper.NewQueryServerImpl(auctionKeeper))

	bondtypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), bondkeeper.NewMsgServerImpl(bondKeeper))
	bondtypes.RegisterQueryServer(integrationApp.QueryHelper(), bondkeeper.NewQueryServerImpl(bondKeeper))

	registrytypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), registrykeeper.NewMsgServerImpl(registryKeeper))
	registrytypes.RegisterQueryServer(integrationApp.QueryHelper(), registrykeeper.NewQueryServerImpl(registryKeeper))

	// set default params
	if err := auctionKeeper.Params.Set(ctx, auctiontypes.DefaultParams()); err != nil {
		return err
	}
	if err := bondKeeper.Params.Set(ctx, bondtypes.DefaultParams()); err != nil {
		return err
	}
	if err := registryKeeper.Params.Set(ctx, registrytypes.DefaultParams()); err != nil {
		return err
	}

	tf.App = integrationApp
	tf.SdkCtx, tf.cdc, tf.keys = sdk.UnwrapSDKContext(ctx), cdc, keys
	tf.AccountKeeper, tf.BankKeeper = accountKeeper, bankKeeper
	tf.AuctionKeeper, tf.BondKeeper, tf.RegistryKeeper = auctionKeeper, bondKeeper, registryKeeper

	return nil
}

func (kts *TestFixture) MakeTestAccounts(numAccounts int, funds math.Int) []sdk.AccAddress {
	accounts := simtestutil.CreateRandomAccounts(numAccounts)
	coins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, funds))
	const mintModuleName = "mint"
	for _, addr := range accounts {
		println("funding test account:", addr.String())
		if err := kts.BankKeeper.MintCoins(kts.SdkCtx, mintModuleName, coins); err != nil {
			panic(err)
		}

		if err := kts.BankKeeper.SendCoinsFromModuleToAccount(kts.SdkCtx, mintModuleName, addr, coins); err != nil {
			panic(err)
		}

	}

	for _, acct := range accounts {
		kts.AccountKeeper.SetAccount(kts.SdkCtx, kts.AccountKeeper.NewAccountWithAddress(kts.SdkCtx, acct))
	}
	return accounts
}