chore(systemtests): Remove testutil dependency (backport #21995)

tests/systemtests/authz_test.go

@@ -4,6 +4,7 @@ package systemtests
 
 import (
 	"fmt"
+	"net/http"
 	"os"
 	"testing"
 	"time"
@@ -670,73 +671,84 @@ func TestAuthzGRPCQueries(t *testing.T) {
 	invalidMsgTypeOutput := `{"code":2, "message":"codespace authz code 2: authorization not found: authorization not found for invalidMsg type", "details":[]}`
 	expGrantOutput := fmt.Sprintf(`{"grants":[{%s}],"pagination":null}`, grant1)
 
-	grantTestCases := []GRPCTestCase{
+	grantTestCases := []RestTestCase{
 		{
 			"invalid granter address",
 			fmt.Sprintf(grantURL, "invalid_granter", grantee1Addr, msgSendTypeURL),
+			http.StatusInternalServerError,
 			bech32FailOutput,
 		},
 		{
 			"invalid grantee address",
 			fmt.Sprintf(grantURL, granterAddr, "invalid_grantee", msgSendTypeURL),
+			http.StatusInternalServerError,
 			bech32FailOutput,
 		},
 		{
 			"with empty granter",
 			fmt.Sprintf(grantURL, "", grantee1Addr, msgSendTypeURL),
+			http.StatusInternalServerError,
 			emptyStrOutput,
 		},
 		{
 			"with empty grantee",
 			fmt.Sprintf(grantURL, granterAddr, "", msgSendTypeURL),
+			http.StatusInternalServerError,
 			emptyStrOutput,
 		},
 		{
 			"invalid msg-type",
 			fmt.Sprintf(grantURL, granterAddr, grantee1Addr, "invalidMsg"),
+			http.StatusInternalServerError,
 			invalidMsgTypeOutput,
 		},
 		{
 			"valid grant query",
 			fmt.Sprintf(grantURL, granterAddr, grantee1Addr, msgSendTypeURL),
+			http.StatusOK,
 			expGrantOutput,
 		},
 	}
 
-	RunGRPCQueries(t, grantTestCases)
+	RunRestQueries(t, grantTestCases)
 
 	// test query grants grpc endpoint
 	grantsURL := baseurl + "/cosmos/authz/v1beta1/grants?granter=%s&grantee=%s"
 
-	grantsTestCases := []GRPCTestCase{
+	grantsTestCases := []RestTestCase{
 		{
 			"expect single grant",
 			fmt.Sprintf(grantsURL, granterAddr, grantee1Addr),
+			http.StatusOK,
 			fmt.Sprintf(`{"grants":[{%s}],"pagination":{"next_key":null,"total":"1"}}`, grant1),
 		},
 		{
 			"expect two grants",
 			fmt.Sprintf(grantsURL, granterAddr, grantee2Addr),
+			http.StatusOK,
 			fmt.Sprintf(`{"grants":[{%s},{%s}],"pagination":{"next_key":null,"total":"2"}}`, grant2, grant3),
 		},
 		{
 			"expect single grant with pagination",
 			fmt.Sprintf(grantsURL+"&pagination.limit=1", granterAddr, grantee2Addr),
+			http.StatusOK,
 			fmt.Sprintf(`{"grants":[{%s}],"pagination":{"next_key":"L2Nvc21vcy5nb3YudjEuTXNnVm90ZQ==","total":"0"}}`, grant2),
 		},
 		{
 			"expect single grant with pagination limit and offset",
 			fmt.Sprintf(grantsURL+"&pagination.limit=1&pagination.offset=1", granterAddr, grantee2Addr),
+			http.StatusOK,
 			fmt.Sprintf(`{"grants":[{%s}],"pagination":{"next_key":null,"total":"0"}}`, grant3),
 		},
 		{
 			"expect two grants with pagination",
 			fmt.Sprintf(grantsURL+"&pagination.limit=2", granterAddr, grantee2Addr),
+			http.StatusOK,
 			fmt.Sprintf(`{"grants":[{%s},{%s}],"pagination":{"next_key":null,"total":"0"}}`, grant2, grant3),
 		},
 	}
 
-	RunGRPCQueries(t, grantsTestCases)
+	RunRestQueries(t, grantsTestCases)
 
 	// test query grants by granter grpc endpoint
 	grantsByGranterURL := baseurl + "/cosmos/authz/v1beta1/grants/granter/%s"
@@ -745,49 +757,55 @@ func TestAuthzGRPCQueries(t *testing.T) {
 	granterQueryOutput := fmt.Sprintf(`{"grants":[{"granter":"%s","grantee":"%s",%s}],"pagination":{"next_key":null,"total":"1"}}`,
 		grantee1Addr, grantee2Addr, grant4)
 
-	granterTestCases := []GRPCTestCase{
+	granterTestCases := []RestTestCase{
 		{
 			"invalid granter account address",
 			fmt.Sprintf(grantsByGranterURL, "invalid address"),
+			http.StatusInternalServerError,
 			decodingFailedOutput,
 		},
 		{
 			"no authorizations found from granter",
 			fmt.Sprintf(grantsByGranterURL, grantee2Addr),
+			http.StatusOK,
 			noAuthorizationsOutput,
 		},
 		{
 			"valid granter query",
 			fmt.Sprintf(grantsByGranterURL, grantee1Addr),
+			http.StatusOK,
 			granterQueryOutput,
 		},
 	}
 
-	RunGRPCQueries(t, granterTestCases)
+	RunRestQueries(t, granterTestCases)
 
 	// test query grants by grantee grpc endpoint
 	grantsByGranteeURL := baseurl + "/cosmos/authz/v1beta1/grants/grantee/%s"
 	grantee1GrantsOutput := fmt.Sprintf(`{"grants":[{"granter":"%s","grantee":"%s",%s}],"pagination":{"next_key":null,"total":"1"}}`, granterAddr, grantee1Addr, grant1)
 
-	granteeTestCases := []GRPCTestCase{
+	granteeTestCases := []RestTestCase{
 		{
 			"invalid grantee account address",
 			fmt.Sprintf(grantsByGranteeURL, "invalid address"),
+			http.StatusInternalServerError,
 			decodingFailedOutput,
 		},
 		{
 			"no authorizations found from grantee",
 			fmt.Sprintf(grantsByGranteeURL, granterAddr),
+			http.StatusOK,
 			noAuthorizationsOutput,
 		},
 		{
 			"valid grantee query",
 			fmt.Sprintf(grantsByGranteeURL, grantee1Addr),
+			http.StatusOK,
 			grantee1GrantsOutput,
 		},
 	}
 
-	RunGRPCQueries(t, granteeTestCases)
+	RunRestQueries(t, granteeTestCases)
 }
 
 func setupChain(t *testing.T) (*CLIWrapper, string, string) {

tests/systemtests/bank_test.go

@@ -4,15 +4,13 @@ package systemtests
 
 import (
 	"fmt"
+	"net/http"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/tidwall/gjson"
 	"github.com/tidwall/sjson"
-
-	"github.com/cosmos/cosmos-sdk/testutil"
-	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
 
 func TestBankSendTxCmd(t *testing.T) {
@@ -53,7 +51,7 @@ func TestBankSendTxCmd(t *testing.T) {
 	insufficientCmdArgs = append(insufficientCmdArgs, fmt.Sprintf("%d%s", valBalance, denom), "--fees=10stake")
 	rsp = cli.Run(insufficientCmdArgs...)
 	RequireTxFailure(t, rsp)
-	require.Contains(t, rsp, sdkerrors.ErrInsufficientFunds.Error())
+	require.Contains(t, rsp, "insufficient funds")
 
 	// test tx bank send with unauthorized signature
 	assertUnauthorizedErr := func(_ assert.TestingT, gotErr error, gotOutputs ...interface{}) bool {
@@ -234,23 +232,26 @@ func TestBankGRPCQueries(t *testing.T) {
 	blockHeight := sut.CurrentHeight()
 
 	supplyTestCases := []struct {
-		name    string
-		url     string
-		headers map[string]string
-		expOut  string
+		name        string
+		url         string
+		headers     map[string]string
+		expHttpCode int
+		expOut      string
 	}{
 		{
 			"test GRPC total supply",
 			supplyUrl,
 			map[string]string{
 				blockHeightHeader: fmt.Sprintf("%d", blockHeight),
 			},
+			http.StatusOK,
 			expTotalSupplyOutput,
 		},
 		{
 			"test GRPC total supply of a specific denom",
 			supplyUrl + "/by_denom?denom=" + newDenom,
 			map[string]string{},
+			http.StatusOK,
 			specificDenomOutput,
 		},
 		{
@@ -259,67 +260,75 @@ func TestBankGRPCQueries(t *testing.T) {
 			map[string]string{
 				blockHeightHeader: fmt.Sprintf("%d", blockHeight+5),
 			},
+			http.StatusInternalServerError,
 			"invalid height",
 		},
 		{
 			"test GRPC total supply of a bogus denom",
 			supplyUrl + "/by_denom?denom=foobar",
 			map[string]string{},
+			http.StatusOK,
+			// http.StatusNotFound,
 			bogusDenomOutput,
 		},
 	}
 
 	for _, tc := range supplyTestCases {
 		t.Run(tc.name, func(t *testing.T) {
-			resp, err := testutil.GetRequestWithHeaders(tc.url, tc.headers)
-			require.NoError(t, err)
+			resp := GetRequestWithHeaders(t, tc.url, tc.headers, tc.expHttpCode)
 			require.Contains(t, string(resp), tc.expOut)
 		})
 	}
 
 	// test denom metadata endpoint
 	denomMetadataUrl := baseurl + "/cosmos/bank/v1beta1/denoms_metadata"
-	dmTestCases := []GRPCTestCase{
+	dmTestCases := []RestTestCase{
 		{
 			"test GRPC client metadata",
 			denomMetadataUrl,
+			http.StatusOK,
 			fmt.Sprintf(`{"metadatas":%s,"pagination":{"next_key":null,"total":"2"}}`, bankDenomMetadata),
 		},
 		{
 			"test GRPC client metadata of a specific denom",
 			denomMetadataUrl + "/uatom",
+			http.StatusOK,
 			fmt.Sprintf(`{"metadata":%s}`, atomDenomMetadata),
 		},
 		{
 			"test GRPC client metadata of a bogus denom",
 			denomMetadataUrl + "/foobar",
+			http.StatusNotFound,
 			`{"code":5, "message":"client metadata for denom foobar", "details":[]}`,
 		},
 	}
 
-	RunGRPCQueries(t, dmTestCases)
+	RunRestQueries(t, dmTestCases)
 
 	// test bank balances endpoint
 	balanceUrl := baseurl + "/cosmos/bank/v1beta1/balances/"
 	allBalancesOutput := `{"balances":[` + specificDenomOutput + `,{"denom":"stake","amount":"10000000"}],"pagination":{"next_key":null,"total":"2"}}`
 
-	balanceTestCases := []GRPCTestCase{
+	balanceTestCases := []RestTestCase{
 		{
 			"test GRPC total account balance",
 			balanceUrl + account1Addr,
+			http.StatusOK,
 			allBalancesOutput,
 		},
 		{
 			"test GRPC account balance of a specific denom",
 			fmt.Sprintf("%s%s/by_denom?denom=%s", balanceUrl, account1Addr, newDenom),
+			http.StatusOK,
 			fmt.Sprintf(`{"balance":%s}`, specificDenomOutput),
 		},
 		{
 			"test GRPC account balance of a bogus denom",
 			fmt.Sprintf("%s%s/by_denom?denom=foobar", balanceUrl, account1Addr),
+			http.StatusOK,
 			fmt.Sprintf(`{"balance":%s}`, bogusDenomOutput),
 		},
 	}
 
-	RunGRPCQueries(t, balanceTestCases)
+	RunRestQueries(t, balanceTestCases)
 }

tests/systemtests/bankv2_test.go

@@ -0,0 +1,58 @@
+//go:build system_test
+
+package systemtests
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/tidwall/gjson"
+)
+
+func TestBankV2SendTxCmd(t *testing.T) {
+	// Currently only run with app v2
+	if !isV2() {
+		t.Skip()
+	}
+	// scenario: test bank send command
+	// given a running chain
+
+	sut.ResetChain(t)
+	cli := NewCLIWrapper(t, sut, verbose)
+
+	// get validator address
+	valAddr := gjson.Get(cli.Keys("keys", "list"), "1.address").String()
+	require.NotEmpty(t, valAddr)
+
+	// add new key
+	receiverAddr := cli.AddKey("account1")
+	denom := "stake"
+	sut.StartChain(t)
+
+	// query validator balance and make sure it has enough balance
+	var transferAmount int64 = 1000
+	raw := cli.CustomQuery("q", "bankv2", "balance", valAddr, denom)
+	valBalance := gjson.Get(raw, "balance.amount").Int()
+
+	require.Greater(t, valBalance, transferAmount, "not enough balance found with validator")
+
+	bankSendCmdArgs := []string{"tx", "bankv2", "send", valAddr, receiverAddr, fmt.Sprintf("%d%s", transferAmount, denom)}
+
+	// test valid transaction
+	rsp := cli.Run(append(bankSendCmdArgs, "--fees=1stake")...)
+	txResult, found := cli.AwaitTxCommitted(rsp)
+	require.True(t, found)
+	RequireTxSuccess(t, txResult)
+
+	// Check balance after send
+	valRaw := cli.CustomQuery("q", "bankv2", "balance", valAddr, denom)
+	valBalanceAfer := gjson.Get(valRaw, "balance.amount").Int()
+
+	// TODO: Make DeductFee ante handler work with bank/v2
+	require.Equal(t, valBalanceAfer, valBalance-transferAmount)
+
+	receiverRaw := cli.CustomQuery("q", "bankv2", "balance", receiverAddr, denom)
+	receiverBalance := gjson.Get(receiverRaw, "balance.amount").Int()
+	require.Equal(t, receiverBalance, transferAmount)
+}