fix: improve faucet reliability

go.mod

@@ -55,6 +55,7 @@ require (
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
 	golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf
 	google.golang.org/grpc v1.42.0
+	gopkg.in/yaml.v2 v2.4.0 // indirect
 )
 
 replace (

integration/env.go

@@ -20,6 +20,7 @@ import (
 	"github.com/tendermint/starport/starport/pkg/availableport"
 	"github.com/tendermint/starport/starport/pkg/cmdrunner"
 	"github.com/tendermint/starport/starport/pkg/cmdrunner/step"
+	"github.com/tendermint/starport/starport/pkg/cosmosfaucet"
 	"github.com/tendermint/starport/starport/pkg/gocmd"
 	"github.com/tendermint/starport/starport/pkg/httpstatuschecker"
 	"github.com/tendermint/starport/starport/pkg/xexec"
@@ -29,6 +30,7 @@ import (
 const (
 	ServeTimeout = time.Minute * 15
 	StarportApp  = "starport"
+	ConfigYML    = "config.yml"
 )
 
 var isCI, _ = strconv.ParseBool(os.Getenv("CI"))
@@ -233,7 +235,7 @@ func (e Env) Simulate(appPath string, numBlocks, blockSize int) {
 // EnsureAppIsSteady ensures that app living at the path can compile and its tests
 // are passing.
 func (e Env) EnsureAppIsSteady(appPath string) {
-	_, statErr := os.Stat(filepath.Join(appPath, "config.yml"))
+	_, statErr := os.Stat(filepath.Join(appPath, ConfigYML))
 	require.False(e.t, os.IsNotExist(statErr), "config.yml cannot be found")
 
 	e.Exec("make sure app is steady",
@@ -257,6 +259,15 @@ func (e Env) IsAppServed(ctx context.Context, host chainconfig.Host) error {
 	return backoff.Retry(checkAlive, backoff.WithContext(backoff.NewConstantBackOff(time.Second), ctx))
 }
 
+// IsFaucetServed checks that faucet of the app is served properly
+func (e Env) IsFaucetServed(ctx context.Context, faucetClient cosmosfaucet.HTTPClient) error {
+	checkAlive := func() error {
+		_, err := faucetClient.FaucetInfo(ctx)
+		return err
+	}
+	return backoff.Retry(checkAlive, backoff.WithContext(backoff.NewConstantBackOff(time.Second), ctx))
+}
+
 // TmpDir creates a new temporary directory.
 func (e Env) TmpDir() (path string) {
 	path, err := os.MkdirTemp("", "integration")
@@ -269,7 +280,7 @@ func (e Env) TmpDir() (path string) {
 // its config.yml and returns new values.
 func (e Env) RandomizeServerPorts(path string, configFile string) chainconfig.Host {
 	if configFile == "" {
-		configFile = "config.yml"
+		configFile = ConfigYML
 	}
 
 	// generate random server ports and servers list.
@@ -306,10 +317,38 @@ func (e Env) RandomizeServerPorts(path string, configFile string) chainconfig.Ho
 	return servers
 }
 
+// ConfigureFaucet finds a random port for the app faucet and updates config.yml with this port and provided coins options
+func (e Env) ConfigureFaucet(path string, configFile string, coins, coinsMax []string) string {
+	if configFile == "" {
+		configFile = ConfigYML
+	}
+
+	// find a random available port
+	port, err := availableport.Find(1)
+	require.NoError(e.t, err)
+
+	configyml, err := os.OpenFile(filepath.Join(path, configFile), os.O_RDWR|os.O_CREATE, 0755)
+	require.NoError(e.t, err)
+	defer configyml.Close()
+
+	var conf chainconfig.Config
+	require.NoError(e.t, yaml.NewDecoder(configyml).Decode(&conf))
+
+	conf.Faucet.Port = port[0]
+	conf.Faucet.Coins = coins
+	conf.Faucet.CoinsMax = coinsMax
+	require.NoError(e.t, configyml.Truncate(0))
+	_, err = configyml.Seek(0, 0)
+	require.NoError(e.t, err)
+	require.NoError(e.t, yaml.NewEncoder(configyml).Encode(conf))
+
+	return xurl.HTTP(fmt.Sprintf("0.0.0.0:%d", port[0]))
+}
+
 // SetRandomHomeConfig sets in the blockchain config files generated temporary directories for home directories
 func (e Env) SetRandomHomeConfig(path string, configFile string) {
 	if configFile == "" {
-		configFile = "config.yml"
+		configFile = ConfigYML
 	}
 
 	// update config.yml with the generated temporary directories

integration/faucet/faucet_test.go

@@ -0,0 +1,114 @@
+package faucet_test
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+	"testing"
+	"time"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+	"github.com/stretchr/testify/require"
+	envtest "github.com/tendermint/starport/integration"
+	"github.com/tendermint/starport/starport/pkg/cosmosclient"
+	"github.com/tendermint/starport/starport/pkg/cosmosfaucet"
+	"github.com/tendermint/starport/starport/pkg/xurl"
+	"golang.org/x/sync/errgroup"
+)
+
+const (
+	addr = "cosmos1zqr2gd7hwkyw55knad0l6ml6ngutd70878evqj"
+)
+
+var (
+	defaultCoins = []string{"10token", "1stake"}
+	maxCoins     = []string{"102token", "100000000stake"}
+)
+
+func TestRequestCoinsFromFaucet(t *testing.T) {
+	var (
+		env          = envtest.New(t)
+		apath        = env.Scaffold("faucet")
+		servers      = env.RandomizeServerPorts(apath, "")
+		faucetURL    = env.ConfigureFaucet(apath, "", defaultCoins, maxCoins)
+		ctx, cancel  = context.WithTimeout(env.Ctx(), envtest.ServeTimeout)
+		faucetClient = cosmosfaucet.NewClient(faucetURL)
+	)
+	isErrTransferRequest := func(err error, expectedCode int) {
+		require.ErrorAs(t, err, &cosmosfaucet.ErrTransferRequest{})
+		errTransfer := err.(cosmosfaucet.ErrTransferRequest)
+		require.EqualValues(t, expectedCode, errTransfer.StatusCode)
+	}
+
+	// serve the app
+	go func() {
+		env.Serve("should serve app", apath, "", "", envtest.ExecCtx(ctx))
+	}()
+
+	// wait servers to be online
+	defer cancel()
+	err := env.IsAppServed(ctx, servers)
+	require.NoError(t, err)
+
+	err = env.IsFaucetServed(ctx, faucetClient)
+	require.NoError(t, err)
+
+	// error "account doesn't have any balances" occurs if a sleep is not included
+	time.Sleep(time.Second * 1)
+
+	cosmosClient, err := cosmosclient.New(ctx, cosmosclient.WithNodeAddress(xurl.HTTP(servers.RPC)))
+	require.NoError(t, err)
+
+	// the faucet sends the default faucet coins value when not specified
+	_, err = faucetClient.Transfer(ctx, cosmosfaucet.NewTransferRequest(addr, nil))
+	require.NoError(t, err)
+	checkAccountBalance(t, ctx, cosmosClient, addr, defaultCoins)
+
+	// the faucet can send a specified amount of coins
+	_, err = faucetClient.Transfer(ctx, cosmosfaucet.NewTransferRequest(addr, []string{"20token", "2stake"}))
+	require.NoError(t, err)
+	checkAccountBalance(t, ctx, cosmosClient, addr, []string{"30token", "3stake"})
+
+	// faucet request fails on malformed coins
+	_, err = faucetClient.Transfer(ctx, cosmosfaucet.NewTransferRequest(addr, []string{"no-token"}))
+	isErrTransferRequest(err, http.StatusBadRequest)
+
+	// faucet request fails when requesting more than max coins
+	_, err = faucetClient.Transfer(ctx, cosmosfaucet.NewTransferRequest(addr, []string{"500token"}))
+	isErrTransferRequest(err, http.StatusInternalServerError)
+
+	// faucet request fails when transfer should fail
+	_, err = faucetClient.Transfer(ctx, cosmosfaucet.NewTransferRequest(addr, []string{"500nonexistent"}))
+	isErrTransferRequest(err, http.StatusInternalServerError)
+
+	// send several request in parallel and check max coins is not overflown
+	g, ctx := errgroup.WithContext(ctx)
+	for i := 0; i < 10; i++ {
+		g.Go(func() error {
+			_, err = faucetClient.Transfer(ctx, cosmosfaucet.NewTransferRequest(addr, nil))
+			if err != nil && !errors.As(err, &cosmosfaucet.ErrTransferRequest{}) {
+				return err
+			}
+			return nil
+		})
+	}
+	require.NoError(t, g.Wait())
+	checkAccountBalance(t, ctx, cosmosClient, addr, []string{"100token", "10stake"})
+}
+
+func checkAccountBalance(t *testing.T, ctx context.Context, c cosmosclient.Client, accAddr string, coins []string) {
+	resp, err := banktypes.NewQueryClient(c.Context).AllBalances(ctx, &banktypes.QueryAllBalancesRequest{
+		Address: accAddr,
+	})
+	require.NoError(t, err)
+
+	require.Len(t, resp.Balances, len(coins))
+	expectedCoins, err := sdk.ParseCoinsNormalized(strings.Join(coins, ","))
+	require.NoError(t, err)
+	require.True(t, resp.Balances.IsEqual(expectedCoins),
+		fmt.Sprintf("%s should be equals to %s", resp.Balances.String(), expectedCoins.String()),
+	)
+}

starport/cmd/chain_faucet.go

@@ -2,11 +2,10 @@ package starportcmd
 
 import (
 	"fmt"
-	"strings"
 
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/spf13/cobra"
 	"github.com/tendermint/starport/starport/pkg/chaincmd"
-	"github.com/tendermint/starport/starport/pkg/cosmoscoin"
 	"github.com/tendermint/starport/starport/services/chain"
 )
 
@@ -47,14 +46,15 @@ func chainFaucetHandler(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	for _, coin := range strings.Split(coins, ",") {
-		amount, denom, err := cosmoscoin.Parse(coin)
-		if err != nil {
-			return fmt.Errorf("%s: %s", err, coin)
-		}
-		if err := faucet.Transfer(cmd.Context(), toAddress, amount, denom); err != nil {
-			return err
-		}
+	// parse provided coins
+	parsedCoins, err := sdk.ParseCoinsNormalized(coins)
+	if err != nil {
+		return err
+	}
+
+	// perform transfer from faucet
+	if err := faucet.Transfer(cmd.Context(), toAddress, parsedCoins); err != nil {
+		return err
 	}
 
 	fmt.Println("📨 Coins sent.")

starport/pkg/chaincmd/chaincmd.go

@@ -534,6 +534,18 @@ func (c ChainCmd) BankSendCommand(fromAddress, toAddress, amount string) step.Op
 	return c.cliCommand(command)
 }
 
+// QueryTxCommand returns the command to query tx
+func (c ChainCmd) QueryTxCommand(txHash string) step.Option {
+	command := []string{
+		commandQuery,
+		"tx",
+		txHash,
+	}
+
+	command = c.attachNode(command)
+	return c.cliCommand(command)
+}
+
 // QueryTxEventsCommand returns the command to query events.
 func (c ChainCmd) QueryTxEventsCommand(query string) step.Option {
 	command := []string{

starport/pkg/chaincmd/runner/chain.go

@@ -4,13 +4,14 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"os"
 	"regexp"
 	"strings"
 	"time"
 
+	"github.com/cenkalti/backoff"
+	"github.com/pkg/errors"
 	"github.com/tendermint/starport/starport/pkg/chaincmd"
 	"github.com/tendermint/starport/starport/pkg/cmdrunner/step"
 	"github.com/tendermint/starport/starport/pkg/cosmosver"
@@ -163,7 +164,7 @@ func (r Runner) Status(ctx context.Context) (NodeStatus, error) {
 }
 
 // BankSend sends amount from fromAccount to toAccount.
-func (r Runner) BankSend(ctx context.Context, fromAccount, toAccount, amount string) error {
+func (r Runner) BankSend(ctx context.Context, fromAccount, toAccount, amount string) (string, error) {
 	b := newBuffer()
 	opt := []step.Option{
 		r.chainCmd.BankSendCommand(fromAccount, toAccount, amount),
@@ -181,30 +182,55 @@ func (r Runner) BankSend(ctx context.Context, fromAccount, toAccount, amount str
 		if strings.Contains(err.Error(), "key not found") || // stargate
 			strings.Contains(err.Error(), "unknown address") || // launchpad
 			strings.Contains(b.String(), "item could not be found") { // launchpad
-			return errors.New("account doesn't have any balances")
+			return "", errors.New("account doesn't have any balances")
 		}
 
-		return err
+		return "", err
 	}
 
-	out := struct {
-		Code  int    `json:"code"`
-		Error string `json:"raw_log"`
-	}{}
-
-	data, err := b.JSONEnsuredBytes()
+	txResult, err := decodeTxResult(b)
 	if err != nil {
-		return err
-	}
-	if err := json.Unmarshal(data, &out); err != nil {
-		return err
+		return "", err
 	}
 
-	if out.Code > 0 {
-		return fmt.Errorf("cannot send tokens (SDK code %d): %s", out.Code, out.Error)
+	if txResult.Code > 0 {
+		return "", fmt.Errorf("cannot send tokens (SDK code %d): %s", txResult.Code, txResult.RawLog)
 	}
 
-	return nil
+	return txResult.TxHash, nil
+}
+
+// WaitTx waits until a tx is successfully added to a block and can be queried
+func (r Runner) WaitTx(ctx context.Context, txHash string, retryDelay time.Duration, maxRetry int) error {
+	retry := 0
+
+	// retry querying the request
+	checkTx := func() error {
+		b := newBuffer()
+		if err := r.run(ctx, runOptions{stdout: b}, r.chainCmd.QueryTxCommand(txHash)); err != nil {
+			// filter not found error and check for max retry
+			if !strings.Contains(err.Error(), "not found") {
+				return backoff.Permanent(err)
+			}
+			retry++
+			if retry == maxRetry {
+				return backoff.Permanent(fmt.Errorf("can't retrieve tx %s", txHash))
+			}
+			return err
+		}
+
+		// parse tx and check code
+		txResult, err := decodeTxResult(b)
+		if err != nil {
+			return backoff.Permanent(err)
+		}
+		if txResult.Code != 0 {
+			return backoff.Permanent(fmt.Errorf("tx %s failed: %s", txHash, txResult.RawLog))
+		}
+
+		return nil
+	}
+	return backoff.Retry(checkTx, backoff.WithContext(backoff.NewConstantBackOff(retryDelay), ctx))
 }
 
 // Export exports the state of the chain into the specified file

starport/pkg/chaincmd/runner/runner.go

@@ -4,6 +4,7 @@ package chaincmdrunner
 import (
 	"bytes"
 	"context"
+	"encoding/json"
 	"io"
 
 	"github.com/ghodss/yaml"
@@ -176,3 +177,20 @@ func (b *buffer) JSONEnsuredBytes() ([]byte, error) {
 
 	return bytes, nil
 }
+
+type txResult struct {
+	Code   int    `json:"code"`
+	RawLog string `json:"raw_log"`
+	TxHash string `json:"txhash"`
+}
+
+func decodeTxResult(b *buffer) (txResult, error) {
+	var r txResult
+
+	data, err := b.JSONEnsuredBytes()
+	if err != nil {
+		return r, err
+	}
+
+	return r, json.Unmarshal(data, &r)
+}