0g-chain/tests/e2e/testutil/suite.go
2024-08-02 12:22:00 +08:00

246 lines
8.2 KiB
Go

package testutil
import (
"fmt"
"math/big"
"github.com/ethereum/go-ethereum/common"
"github.com/stretchr/testify/suite"
sdkmath "cosmossdk.io/math"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/0glabs/0g-chain/app"
"github.com/0glabs/0g-chain/tests/e2e/runner"
"github.com/0glabs/0g-chain/tests/util"
)
const (
FundedAccountName = "whale"
// use coin type 60 so we are compatible with accounts from `kava add keys --eth <name>`
// these accounts use the ethsecp256k1 signing algorithm that allows the signing client
// to manage both sdk & evm txs.
Bip44CoinType = 60
IbcPort = "transfer"
IbcChannel = "channel-0"
)
// DeployedErc20 is a type that wraps the details of the pre-deployed erc20 used by the e2e test suite.
// The Address comes from SuiteConfig.KavaErc20Address
// The CosmosDenom is fetched from the EnabledConversionPairs param of x/evmutil.
// The tests expect the following:
// - the funded account has a nonzero balance of the erc20
// - the erc20 is enabled for conversion to sdk.Coin
// - the corresponding sdk.Coin is enabled as a cdp collateral type
// These requirements are checked in InitKavaEvmData().
type DeployedErc20 struct {
Address common.Address
CosmosDenom string
CdpCollateralType string
}
// E2eTestSuite is a testify test suite for running end-to-end integration tests on Kava.
type E2eTestSuite struct {
suite.Suite
config SuiteConfig
runner runner.NodeRunner
Kava *Chain
Ibc *Chain
UpgradeHeight int64
DeployedErc20 DeployedErc20
cost costSummary
enableRefunds bool
}
// costSummary wraps info about what funds get irrecoverably spent by the test suite run
type costSummary struct {
sdkAddress string
evmAddress string
erc20BalanceBefore *big.Int
erc20BalanceAfter *big.Int
sdkBalanceBefore sdk.Coins
sdkBalanceAfter sdk.Coins
}
// String implements fmt.Stringer
func (s costSummary) String() string {
before := sdk.NewCoins(s.sdkBalanceBefore...).Add(sdk.NewCoin("erc20", sdkmath.NewIntFromBigInt(s.erc20BalanceBefore)))
after := sdk.NewCoins(s.sdkBalanceAfter...).Add(sdk.NewCoin("erc20", sdkmath.NewIntFromBigInt(s.erc20BalanceAfter)))
cost, _ := before.SafeSub(after...)
return fmt.Sprintf("Cost Summary for %s (%s):\nbefore:\n%s\nafter:\n%s\ncost:\n%s\n",
s.sdkAddress, s.evmAddress, util.PrettyPrintCoins(before), util.PrettyPrintCoins(after), util.PrettyPrintCoins(cost),
)
}
// SetupSuite is run before all tests. It initializes chain connections and sets up the
// account used for funding accounts in the tests.
func (suite *E2eTestSuite) SetupSuite() {
var err error
fmt.Println("setting up test suite.")
app.SetSDKConfig()
suiteConfig := ParseSuiteConfig()
suite.config = suiteConfig
suite.DeployedErc20 = DeployedErc20{
Address: common.HexToAddress(suiteConfig.KavaErc20Address),
// Denom & CdpCollateralType are fetched in InitKavaEvmData()
}
// setup the correct NodeRunner for the given config
if suiteConfig.Kvtool != nil {
suite.runner = suite.SetupKvtoolNodeRunner()
} else if suiteConfig.LiveNetwork != nil {
suite.runner = suite.SetupLiveNetworkNodeRunner()
} else {
panic("expected either kvtool or live network configs to be defined")
}
chains := suite.runner.StartChains()
kavachain := chains.MustGetChain("kava")
suite.Kava, err = NewChain(suite.T(), kavachain, suiteConfig.FundedAccountMnemonic)
if err != nil {
suite.runner.Shutdown()
suite.T().Fatalf("failed to create kava chain querier: %s", err)
}
if suiteConfig.IncludeIbcTests {
ibcchain := chains.MustGetChain("ibc")
suite.Ibc, err = NewChain(suite.T(), ibcchain, suiteConfig.FundedAccountMnemonic)
if err != nil {
suite.runner.Shutdown()
suite.T().Fatalf("failed to create ibc chain querier: %s", err)
}
}
suite.InitKavaEvmData()
whale := suite.Kava.GetAccount(FundedAccountName)
suite.cost = costSummary{
sdkAddress: whale.SdkAddress.String(),
evmAddress: whale.EvmAddress.Hex(),
sdkBalanceBefore: suite.Kava.QuerySdkForBalances(whale.SdkAddress),
erc20BalanceBefore: suite.Kava.GetErc20Balance(suite.DeployedErc20.Address, whale.EvmAddress),
}
}
// TearDownSuite is run after all tests have run.
// In the event of a panic during the tests, it is run after testify recovers.
func (suite *E2eTestSuite) TearDownSuite() {
fmt.Println("tearing down test suite.")
whale := suite.Kava.GetAccount(FundedAccountName)
if suite.enableRefunds {
suite.cost.sdkBalanceAfter = suite.Kava.QuerySdkForBalances(whale.SdkAddress)
suite.cost.erc20BalanceAfter = suite.Kava.GetErc20Balance(suite.DeployedErc20.Address, whale.EvmAddress)
fmt.Println("==BEFORE REFUNDS==")
fmt.Println(suite.cost)
fmt.Println("attempting to return all unused funds")
suite.Kava.ReturnAllFunds()
fmt.Println("==AFTER REFUNDS==")
}
// calculate & output cost summary for funded account
suite.cost.sdkBalanceAfter = suite.Kava.QuerySdkForBalances(whale.SdkAddress)
suite.cost.erc20BalanceAfter = suite.Kava.GetErc20Balance(suite.DeployedErc20.Address, whale.EvmAddress)
fmt.Println(suite.cost)
// close all account request channels
suite.Kava.Shutdown()
if suite.Ibc != nil {
suite.Ibc.Shutdown()
}
// gracefully shutdown docker container(s)
suite.runner.Shutdown()
}
// SetupKvtoolNodeRunner is a helper method for building a KvtoolRunnerConfig from the suite config.
func (suite *E2eTestSuite) SetupKvtoolNodeRunner() *runner.KvtoolRunner {
// upgrade tests are only supported on kvtool networks
suite.UpgradeHeight = suite.config.Kvtool.KavaUpgradeHeight
suite.enableRefunds = false
runnerConfig := runner.KvtoolRunnerConfig{
KavaConfigTemplate: suite.config.Kvtool.KavaConfigTemplate,
IncludeIBC: suite.config.IncludeIbcTests,
ImageTag: "local",
EnableAutomatedUpgrade: suite.config.Kvtool.IncludeAutomatedUpgrade,
KavaUpgradeName: suite.config.Kvtool.KavaUpgradeName,
KavaUpgradeHeight: suite.config.Kvtool.KavaUpgradeHeight,
KavaUpgradeBaseImageTag: suite.config.Kvtool.KavaUpgradeBaseImageTag,
SkipShutdown: suite.config.SkipShutdown,
}
return runner.NewKvtoolRunner(runnerConfig)
}
// SetupLiveNetworkNodeRunner is a helper method for building a LiveNodeRunner from the suite config.
func (suite *E2eTestSuite) SetupLiveNetworkNodeRunner() *runner.LiveNodeRunner {
// live network setup doesn't presently support ibc
if suite.config.IncludeIbcTests {
panic("ibc tests not supported for live network configuration")
}
// Manually set upgrade height for live networks
suite.UpgradeHeight = suite.config.LiveNetwork.UpgradeHeight
suite.enableRefunds = true
runnerConfig := runner.LiveNodeRunnerConfig{
KavaRpcUrl: suite.config.LiveNetwork.KavaRpcUrl,
KavaGrpcUrl: suite.config.LiveNetwork.KavaGrpcUrl,
KavaEvmRpcUrl: suite.config.LiveNetwork.KavaEvmRpcUrl,
UpgradeHeight: suite.config.LiveNetwork.UpgradeHeight,
}
return runner.NewLiveNodeRunner(runnerConfig)
}
// SkipIfIbcDisabled should be called at the start of tests that require IBC.
// It gracefully skips the current test if IBC tests are disabled.
func (suite *E2eTestSuite) SkipIfIbcDisabled() {
if !suite.config.IncludeIbcTests {
suite.T().SkipNow()
}
}
// SkipIfUpgradeDisabled should be called at the start of tests that require automated upgrades.
// It gracefully skips the current test if upgrades are dissabled.
// Note: automated upgrade tests are currently only enabled for Kvtool suite runs.
func (suite *E2eTestSuite) SkipIfUpgradeDisabled() {
if suite.config.Kvtool != nil && !suite.config.Kvtool.IncludeAutomatedUpgrade {
fmt.Println("skipping upgrade test, kvtool automated upgrade is disabled")
suite.T().SkipNow()
}
// If there isn't a manual upgrade height set in the config, skip the test
if suite.config.LiveNetwork != nil && suite.config.LiveNetwork.UpgradeHeight == 0 {
fmt.Println("skipping upgrade test, live network upgrade height is not set")
suite.T().SkipNow()
}
}
// SkipIfKvtoolDisabled should be called at the start of tests that require kvtool.
func (suite *E2eTestSuite) SkipIfKvtoolDisabled() {
if suite.config.Kvtool == nil {
suite.T().SkipNow()
}
}
// BigIntsEqual is a helper method for comparing the equality of two big ints
func (suite *E2eTestSuite) BigIntsEqual(expected *big.Int, actual *big.Int, msg string) {
suite.Truef(expected.Cmp(actual) == 0, "%s (expected: %s, actual: %s)", msg, expected.String(), actual.String())
}