fix: e2e test reliability

Makefile

@@ -234,7 +234,8 @@ test-e2e-cov: $(TEST_E2E_DEPS)
 
 test-e2e-clean:
 	docker stop umee0 umee1 umee2 umee-gaia-relayer gaiaval0 umee-price-feeder || true
-	docker rm umee0 umee1 umee2 umee-gaia-relayer gaiaval0 umee-price-feeder
+	docker rm umee0 umee1 umee2 umee-gaia-relayer gaiaval0 umee-price-feeder || true
+	docker network prune -f
 
 test-qa: 
 	@go test ./tests/qa/... -timeout 30m -v -tags='test_qa'

tests/e2e/e2e_metoken_test.go

@@ -246,3 +246,23 @@ func (s *E2ETest) executeRedeemWithFailure(umeeAddr string, meToken sdk.Coin, as
 		500*time.Millisecond,
 	)
 }
+
+func (s *E2ETest) TxMetokenSwap(umeeAddr string, asset sdk.Coin, meTokenDenom string) error {
+	req := &metoken.MsgSwap{
+		User:         umeeAddr,
+		Asset:        asset,
+		MetokenDenom: meTokenDenom,
+	}
+
+	return s.BroadcastTxWithRetry(req)
+}
+
+func (s *E2ETest) TxMetokenRedeem(umeeAddr string, meToken sdk.Coin, assetDenom string) error {
+	req := &metoken.MsgRedeem{
+		User:       umeeAddr,
+		Metoken:    meToken,
+		AssetDenom: assetDenom,
+	}
+
+	return s.BroadcastTxWithRetry(req)
+}

tests/e2e/e2e_oracle_test.go

@@ -0,0 +1,49 @@
+package e2e
+
+import (
+	"time"
+
+	"github.com/umee-network/umee/v6/tests/grpc"
+)
+
+// TestMedians queries for the oracle params, collects historical
+// prices based on those params, checks that the stored medians and
+// medians deviations are correct, updates the oracle params with
+// a gov prop, then checks the medians and median deviations again.
+func (s *E2ETest) TestMedians() {
+	err := grpc.MedianCheck(s.Umee)
+	s.Require().NoError(err)
+}
+
+func (s *E2ETest) TestUpdateOracleParams() {
+	params, err := s.Umee.QueryOracleParams()
+	s.Require().NoError(err)
+
+	s.Require().Equal(uint64(5), params.HistoricStampPeriod)
+	s.Require().Equal(uint64(4), params.MaximumPriceStamps)
+	s.Require().Equal(uint64(20), params.MedianStampPeriod)
+
+	// simple retry loop to submit and pass a proposal
+	for i := 0; i < 3; i++ {
+		err = grpc.SubmitAndPassProposal(
+			s.Umee,
+			grpc.OracleParamChanges(10, 2, 20),
+		)
+		if err == nil {
+			break
+		}
+
+		time.Sleep(1 * time.Second)
+	}
+
+	s.Require().NoError(err, "submit and pass proposal")
+
+	params, err = s.Umee.QueryOracleParams()
+	s.Require().NoError(err)
+
+	s.Require().Equal(uint64(10), params.HistoricStampPeriod)
+	s.Require().Equal(uint64(2), params.MaximumPriceStamps)
+	s.Require().Equal(uint64(20), params.MedianStampPeriod)
+
+	s.Require().NoError(err)
+}

tests/e2e/e2e_test.go

@@ -5,16 +5,21 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/suite"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	setup "github.com/umee-network/umee/v6/tests/e2e/setup"
-	"github.com/umee-network/umee/v6/tests/grpc"
 )
 
 type E2ETest struct {
 	setup.E2ETestSuite
 }
 
+// TestE2ETestSuite is the entry point for e2e testing. It runs after the docker build commands
+// listed in Makefile as prerequisites to test-e2e. It first calls E2ETestSuite.SetupSuite() and
+// then runs all public methods on the suite whose names match regex "^Test". These tests appear
+// to run in series (and in alphabetical order), so the only other transactions being submitted
+// while they run are the price feeder votes by the validators running in docker containers.
 func TestE2ETestSuite(t *testing.T) {
 	suite.Run(t, new(E2ETest))
 }
@@ -48,45 +53,3 @@ func (s *E2ETest) mustFailTx(msg sdk.Msg, errSubstring string) {
 		errSubstring,
 	)
 }
-
-// TestMedians queries for the oracle params, collects historical
-// prices based on those params, checks that the stored medians and
-// medians deviations are correct, updates the oracle params with
-// a gov prop, then checks the medians and median deviations again.
-func (s *E2ETest) TestMedians() {
-	err := grpc.MedianCheck(s.Umee)
-	s.Require().NoError(err)
-}
-
-func (s *E2ETest) TestUpdateOracleParams() {
-	params, err := s.Umee.QueryOracleParams()
-	s.Require().NoError(err)
-
-	s.Require().Equal(uint64(5), params.HistoricStampPeriod)
-	s.Require().Equal(uint64(4), params.MaximumPriceStamps)
-	s.Require().Equal(uint64(20), params.MedianStampPeriod)
-
-	// simple retry loop to submit and pass a proposal
-	for i := 0; i < 3; i++ {
-		err = grpc.SubmitAndPassProposal(
-			s.Umee,
-			grpc.OracleParamChanges(10, 2, 20),
-		)
-		if err == nil {
-			break
-		}
-
-		time.Sleep(1 * time.Second)
-	}
-
-	s.Require().NoError(err, "submit and pass proposal")
-
-	params, err = s.Umee.QueryOracleParams()
-	s.Require().NoError(err)
-
-	s.Require().Equal(uint64(10), params.HistoricStampPeriod)
-	s.Require().Equal(uint64(2), params.MaximumPriceStamps)
-	s.Require().Equal(uint64(20), params.MedianStampPeriod)
-
-	s.Require().NoError(err)
-}

tests/e2e/setup/accounts.go

@@ -0,0 +1,63 @@
+package setup
+
+import (
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/crypto/keyring"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	appparams "github.com/umee-network/umee/v6/app/params"
+	"github.com/umee-network/umee/v6/util/coin"
+	"github.com/umee-network/umee/v6/x/metoken/mocks"
+)
+
+type testAccount struct {
+	mnemonic string
+	keyInfo  keyring.Record
+	addr     sdk.AccAddress
+}
+
+var (
+	// Initial coins to give to validator 0 (which it uses to fund test accounts)
+	val0Coins = sdk.NewCoins(
+		coin.New(appparams.BondDenom, 1_000000_000000),
+		coin.New(PhotonDenom, 1_000000_000000),
+		coin.New(mocks.USDTBaseDenom, 1_000000_000000),
+	)
+	// Initial coins to give to all other validators
+	val1Coins = sdk.NewCoins(
+		coin.New(appparams.BondDenom, 1_000000_000000),
+	)
+
+	// Number of test accounts to initialize in chain.TestAccounts
+	numTestAccounts = 1
+
+	// Initial coins to give to each test account. Ensure that this * numTestAccounts < val0Coins
+	testAccountCoins = sdk.NewCoins(
+		coin.New(appparams.BondDenom, 100000_000000),
+		coin.New(PhotonDenom, 100000_000000),
+		coin.New(mocks.USDTBaseDenom, 100000_000000),
+	)
+
+	// TODO: stake less on the validators, and instead delegate from a test account
+	stakeAmountCoin  = coin.New(appparams.BondDenom, 1000)
+	stakeAmountCoin2 = coin.New(appparams.BondDenom, 5000)
+)
+
+// create a test account, which is an address with a mnemonic stored only in memory, to be used with the network.
+// these are created randomly each time and added to the suite, so they should be accessed by c.TestAccounts[i >= 0]
+// and queries by the desired account's address
+func (c *chain) createTestAccount(cdc codec.Codec) error {
+	mnemonic, info, err := createMemoryKey(cdc)
+	if err != nil {
+		return err
+	}
+	ta := testAccount{}
+	ta.keyInfo = *info
+	ta.mnemonic = mnemonic
+	ta.addr, err = info.GetAddress() // TODO: verify this address starts with "umee1"
+	if err != nil {
+		return err
+	}
+	c.TestAccounts = append(c.TestAccounts, &ta)
+	return nil
+}

tests/e2e/setup/chain.go

@@ -41,9 +41,11 @@ type chain struct {
 	dataDir        string
 	ID             string
 	Validators     []*validator
+	TestAccounts   []*testAccount
 	GaiaValidators []*gaiaValidator
 }
 
+// newChain creates a chain with a random chain ID and makes a temporary directory to hold its data
 func newChain() (*chain, error) {
 	tmpDir, err := os.MkdirTemp("", "umee-e2e-testnet-")
 	if err != nil {
@@ -56,64 +58,44 @@ func newChain() (*chain, error) {
 	}, nil
 }
 
+// configDir is located at <chain.dataDir>/<chain.ID>
 func (c *chain) configDir() string {
 	return fmt.Sprintf("%s/%s", c.dataDir, c.ID)
 }
 
+// createAndInitValidators adds a number of validators to the chain and initializes their
+// keys, config.toml and genesis.json in separate config directories created for each validator.
+// Their monikers are all set to "umee" but their indexes are different.
 func (c *chain) createAndInitValidators(cdc codec.Codec, count int) error {
 	for i := 0; i < count; i++ {
-		node := c.createValidator(i)
+		node := validator{
+			chain:   c,
+			index:   i,
+			moniker: "umee",
+		}
 
-		// generate genesis files
+		// create config directory and initializes config.toml and genesis.json
 		if err := node.init(cdc); err != nil {
 			return err
 		}
 
-		c.Validators = append(c.Validators, node)
-
-		// create keys
+		// generate a random key and save to keyring-backend-test in the validator's config directory
 		if err := node.createKey(cdc, "val"); err != nil {
 			return err
 		}
+		// loads or generates a node key in the validator's config directory
+		// TODO (comment): which are we doing? loading or generating?
 		if err := node.createNodeKey(); err != nil {
 			return err
 		}
+		// loads or generates a consensus key in the validator's config directory
+		// TODO (comment): which are we doing? loading or generating?
 		if err := node.createConsensusKey(); err != nil {
 			return err
 		}
-	}
-
-	return nil
-}
 
-func (c *chain) createAndInitGaiaValidator(cdc codec.Codec) error {
-	// create gaia validator
-	gaiaVal := c.createGaiaValidator(0)
-
-	// create keys
-	mnemonic, info, err := createMemoryKey(cdc)
-	if err != nil {
-		return err
+		c.Validators = append(c.Validators, &node)
 	}
 
-	gaiaVal.keyInfo = *info
-	gaiaVal.mnemonic = mnemonic
-
-	c.GaiaValidators = append(c.GaiaValidators, gaiaVal)
-
 	return nil
 }
-
-func (c *chain) createValidator(index int) *validator {
-	return &validator{
-		chain:   c,
-		index:   index,
-		moniker: "umee",
-	}
-}
-
-func (c *chain) createGaiaValidator(index int) *gaiaValidator {
-	return &gaiaValidator{
-		index: index,
-	}
-}