LaconicNetwork/cosmos-sdk
10
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

refactor(nft): CLI tests using Tendermint Mock (#13256)

Browse Source 
* wip: move nft cli tests to e2e tests

* wip: add cli tests using Tendermint Mock

* cleanup genutil test file

* remove unncessary test cases

* address review comments

Co-authored-by: Julien Robert <julien@rbrt.fr>
Co-authored-by: Marko <marbar3778@yahoo.com>
Co-authored-by: Aleksandr Bezobchuk <alexanderbez@users.noreply.github.com>
This commit is contained in:
likhita-809 2022-09-19 18:31:49 +05:30 committed by GitHub
parent 7252f4a758
commit 7ebbfa0b30
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 538 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
tests/e2e/nft/client/testutil/cli_test.go → tests/e2e/nft/cli_test.go
View File

@ -1,7 +1,7 @@
//go:build e2e
// +build e2e
package testutil
package nft
import (
"testing"
@ -9,12 +9,12 @@ import (
"github.com/stretchr/testify/suite"
"cosmossdk.io/simapp"
"github.com/cosmos/cosmos-sdk/testutil/network"
clienttestutil "github.com/cosmos/cosmos-sdk/x/nft/client/testutil"
)
func TestIntegrationTestSuite(t *testing.T) {
cfg := network.DefaultConfig(simapp.NewTestNetworkFixture)
cfg.NumValidators = 1
suite.Run(t, clienttestutil.NewIntegrationTestSuite(cfg))
suite.Run(t, NewIntegrationTestSuite(cfg))
}

2
x/nft/client/testutil/grpc.go → tests/e2e/nft/grpc.go
View File

@ -1,4 +1,4 @@
package testutil
package nft
import (
"fmt"

2
x/nft/client/testutil/query.go → tests/e2e/nft/query.go
View File

@ -1,4 +1,4 @@
package testutil
package nft
import (
"github.com/cosmos/cosmos-sdk/x/nft"

2
x/nft/client/testutil/test_helper.go → tests/e2e/nft/test_helper.go
View File

@ -1,4 +1,4 @@
package testutil
package nft
import (
"fmt"

6
x/nft/client/testutil/tx.go → tests/e2e/nft/tx.go
View File

@ -1,4 +1,4 @@
package testutil
package nft
import (
"fmt"
@ -6,7 +6,7 @@ import (
"github.com/stretchr/testify/suite"
"github.com/cosmos/cosmos-sdk/client/flags"
"github.com/cosmos/cosmos-sdk/testutil/cli"
clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
"github.com/cosmos/cosmos-sdk/testutil/network"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/nft"
@ -160,6 +160,6 @@ func (s *IntegrationTestSuite) initAccount() {
s.Require().NoError(err)
amount := sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(200)))
_, err = cli.MsgSendExec(ctx, val.Address, s.owner, amount, args...)
_, err = clitestutil.MsgSendExec(ctx, val.Address, s.owner, amount, args...)
s.Require().NoError(err)
}

3
x/genutil/client/cli/validate_genesis_test.go
View File

@ -67,9 +67,6 @@ var v040Valid = `{
}`
func (s *CLITestSuite) TestValidateGenesis() {
// accounts := testutil.CreateKeyringAccounts(s.T(), s.kr, 1)
// val0 := accounts[0]
testCases := []struct {
name string
genesis string

303
x/nft/client/cli/query_test.go Normal file
View File

@ -0,0 +1,303 @@
package cli_test
import (
"fmt"
tmcli "github.com/tendermint/tendermint/libs/cli"
"github.com/cosmos/cosmos-sdk/testutil"
clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
"github.com/cosmos/cosmos-sdk/x/nft"
"github.com/cosmos/cosmos-sdk/x/nft/client/cli"
)
func (s *CLITestSuite) TestQueryClass() {
testCases := []struct {
name string
args struct {
ClassID string
}
expectErr bool
}{
{
name: "valid case",
args: struct {
ClassID string
}{
ClassID: testClassID,
},
expectErr: false,
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.GetCmdQueryClass()
var args []string
args = append(args, tc.args.ClassID)
args = append(args, fmt.Sprintf("--%s=json", tmcli.OutputFlag))
out, err := clitestutil.ExecTestCLICmd(s.clientCtx, cmd, args)
if tc.expectErr {
s.Require().Error(err)
} else {
s.Require().NoError(err)
var result nft.QueryClassResponse
err = s.clientCtx.Codec.UnmarshalJSON(out.Bytes(), &result)
s.Require().NoError(err)
}
})
}
}
func (s *CLITestSuite) TestQueryClasses() {
testCases := []struct {
name string
expectErr bool
}{
{
name: "no params",
expectErr: false,
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.GetCmdQueryClasses()
var args []string
args = append(args, fmt.Sprintf("--%s=json", tmcli.OutputFlag))
out, err := clitestutil.ExecTestCLICmd(s.clientCtx, cmd, args)
if tc.expectErr {
s.Require().Error(err)
} else {
s.Require().NoError(err)
var result nft.QueryClassesResponse
err = s.clientCtx.Codec.UnmarshalJSON(out.Bytes(), &result)
s.Require().NoError(err)
}
})
}
}
func (s *CLITestSuite) TestQueryNFT() {
testCases := []struct {
name string
args struct {
ClassID string
ID string
}
expectErr bool
}{
{
name: "valid case",
args: struct {
ClassID string
ID string
}{
ClassID: testClassID,
ID: testID,
},
expectErr: false,
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.GetCmdQueryNFT()
var args []string
args = append(args, tc.args.ClassID)
args = append(args, tc.args.ID)
args = append(args, fmt.Sprintf("--%s=json", tmcli.OutputFlag))
out, err := clitestutil.ExecTestCLICmd(s.clientCtx, cmd, args)
if tc.expectErr {
s.Require().Error(err)
} else {
s.Require().NoError(err)
var result nft.QueryNFTResponse
err = s.clientCtx.Codec.UnmarshalJSON(out.Bytes(), &result)
s.Require().NoError(err)
}
})
}
}
func (s *CLITestSuite) TestQueryNFTs() {
accounts := testutil.CreateKeyringAccounts(s.T(), s.kr, 1)
testCases := []struct {
name string
args struct {
ClassID string
Owner string
}
expectErr bool
}{
{
name: "empty class id and owner",
args: struct {
ClassID string
Owner string
}{},
expectErr: true,
},
{
name: "valid case",
args: struct {
ClassID string
Owner string
}{
ClassID: testClassID,
Owner: accounts[0].Address.String(),
},
expectErr: false,
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.GetCmdQueryNFTs()
var args []string
args = append(args, fmt.Sprintf("--%s=%s", cli.FlagClassID, tc.args.ClassID))
args = append(args, fmt.Sprintf("--%s=%s", cli.FlagOwner, tc.args.Owner))
args = append(args, fmt.Sprintf("--%s=json", tmcli.OutputFlag))
out, err := clitestutil.ExecTestCLICmd(s.clientCtx, cmd, args)
if tc.expectErr {
s.Require().Error(err)
} else {
s.Require().NoError(err)
var result nft.QueryNFTsResponse
err = s.clientCtx.Codec.UnmarshalJSON(out.Bytes(), &result)
s.Require().NoError(err)
}
})
}
}
func (s *CLITestSuite) TestQueryOwner() {
testCases := []struct {
name string
args struct {
ClassID string
ID string
}
expectErr bool
}{
{
name: "valid case",
args: struct {
ClassID string
ID string
}{
ClassID: testClassID,
ID: testID,
},
expectErr: false,
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.GetCmdQueryOwner()
var args []string
args = append(args, tc.args.ClassID)
args = append(args, tc.args.ID)
args = append(args, fmt.Sprintf("--%s=json", tmcli.OutputFlag))
out, err := clitestutil.ExecTestCLICmd(s.clientCtx, cmd, args)
if tc.expectErr {
s.Require().Error(err)
} else {
s.Require().NoError(err)
var result nft.QueryOwnerResponse
err = s.clientCtx.Codec.UnmarshalJSON(out.Bytes(), &result)
s.Require().NoError(err)
}
})
}
}
func (s *CLITestSuite) TestQueryBalance() {
accounts := testutil.CreateKeyringAccounts(s.T(), s.kr, 1)
testCases := []struct {
name string
args struct {
ClassID string
Owner string
}
expectErr bool
}{
{
name: "valid case",
args: struct {
ClassID string
Owner string
}{
ClassID: testClassID,
Owner: accounts[0].Address.String(),
},
expectErr: false,
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.GetCmdQueryBalance()
var args []string
args = append(args, tc.args.Owner)
args = append(args, tc.args.ClassID)
args = append(args, fmt.Sprintf("--%s=json", tmcli.OutputFlag))
out, err := clitestutil.ExecTestCLICmd(s.clientCtx, cmd, args)
if tc.expectErr {
s.Require().Error(err)
} else {
s.Require().NoError(err)
var result nft.QueryBalanceResponse
err = s.clientCtx.Codec.UnmarshalJSON(out.Bytes(), &result)
s.Require().NoError(err)
}
})
}
}
func (s *CLITestSuite) TestQuerySupply() {
testCases := []struct {
name string
args struct {
ClassID string
}
expectErr bool
}{
{
name: "valid case",
args: struct {
ClassID string
}{
ClassID: testClassID,
},
expectErr: false,
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.GetCmdQuerySupply()
var args []string
args = append(args, tc.args.ClassID)
args = append(args, fmt.Sprintf("--%s=json", tmcli.OutputFlag))
out, err := clitestutil.ExecTestCLICmd(s.clientCtx, cmd, args)
if tc.expectErr {
s.Require().Error(err)
} else {
s.Require().NoError(err)
var result nft.QuerySupplyResponse
err = s.clientCtx.Codec.UnmarshalJSON(out.Bytes(), &result)
s.Require().NoError(err)
}
})
}
}

226
x/nft/client/cli/tx_test.go Normal file
View File

@ -0,0 +1,226 @@
package cli_test
import (
"bytes"
"context"
"fmt"
"io"
"testing"
"github.com/stretchr/testify/suite"
abci "github.com/tendermint/tendermint/abci/types"
tmbytes "github.com/tendermint/tendermint/libs/bytes"
rpcclient "github.com/tendermint/tendermint/rpc/client"
rpcclientmock "github.com/tendermint/tendermint/rpc/client/mock"
coretypes "github.com/tendermint/tendermint/rpc/core/types"
tmtypes "github.com/tendermint/tendermint/types"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/client/flags"
"github.com/cosmos/cosmos-sdk/crypto/keyring"
svrcmd "github.com/cosmos/cosmos-sdk/server/cmd"
"github.com/cosmos/cosmos-sdk/testutil"
clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
"github.com/cosmos/cosmos-sdk/testutil/network"
sdk "github.com/cosmos/cosmos-sdk/types"
testutilmod "github.com/cosmos/cosmos-sdk/types/module/testutil"
"github.com/cosmos/cosmos-sdk/x/genutil"
"github.com/cosmos/cosmos-sdk/x/nft"
"github.com/cosmos/cosmos-sdk/x/nft/client/cli"
nfttestutil "github.com/cosmos/cosmos-sdk/x/nft/testutil"
)
const (
OwnerName = "owner"
Owner = "cosmos1kznrznww4pd6gx0zwrpthjk68fdmqypjpkj5hp"
OwnerArmor = `-----BEGIN TENDERMINT PRIVATE KEY-----
salt: C3586B75587D2824187D2CDA22B6AFB6
type: secp256k1
kdf: bcrypt
1+15OrCKgjnwym1zO3cjo/SGe3PPqAYChQ5wMHjdUbTZM7mWsH3/ueL6swgjzI3b
DDzEQAPXBQflzNW6wbne9IfT651zCSm+j1MWaGk=
=wEHs
-----END TENDERMINT PRIVATE KEY-----`
testClassID = "kitty"
testClassName = "Crypto Kitty"
testClassSymbol = "kitty"
testClassDescription = "Crypto Kitty"
testClassURI = "class uri"
testID = "kitty1"
testURI = "kitty uri"
)
var (
ExpClass = nft.Class{
Id: testClassID,
Name: testClassName,
Symbol: testClassSymbol,
Description: testClassDescription,
Uri: testClassURI,
}
ExpNFT = nft.NFT{
ClassId: testClassID,
Id: testID,
Uri: testURI,
}
)
var _ client.TendermintRPC = (*mockTendermintRPC)(nil)
type mockTendermintRPC struct {
rpcclientmock.Client
responseQuery abci.ResponseQuery
}
func newMockTendermintRPC(respQuery abci.ResponseQuery) mockTendermintRPC {
return mockTendermintRPC{responseQuery: respQuery}
}
func (_ mockTendermintRPC) BroadcastTxCommit(_ context.Context, _ tmtypes.Tx) (*coretypes.ResultBroadcastTxCommit, error) {
return &coretypes.ResultBroadcastTxCommit{}, nil
}
func (m mockTendermintRPC) ABCIQueryWithOptions(
_ context.Context,
_ string, _ tmbytes.HexBytes,
_ rpcclient.ABCIQueryOptions,
) (*coretypes.ResultABCIQuery, error) {
return &coretypes.ResultABCIQuery{Response: m.responseQuery}, nil
}
type CLITestSuite struct {
suite.Suite
kr keyring.Keyring
encCfg testutilmod.TestEncodingConfig
baseCtx client.Context
clientCtx client.Context
ctx context.Context
owner sdk.AccAddress
}
func TestCLITestSuite(t *testing.T) {
suite.Run(t, new(CLITestSuite))
}
func (s *CLITestSuite) SetupSuite() {
s.encCfg = testutilmod.MakeTestEncodingConfig(genutil.AppModuleBasic{})
s.kr = keyring.NewInMemory(s.encCfg.Codec)
s.baseCtx = client.Context{}.
WithKeyring(s.kr).
WithTxConfig(s.encCfg.TxConfig).
WithCodec(s.encCfg.Codec).
WithClient(mockTendermintRPC{Client: rpcclientmock.Client{}}).
WithAccountRetriever(client.MockAccountRetriever{}).
WithOutput(io.Discard).
WithChainID("test-chain")
s.ctx = svrcmd.CreateExecuteContext(context.Background())
var outBuf bytes.Buffer
ctxGen := func() client.Context {
bz, _ := s.encCfg.Codec.Marshal(&sdk.TxResponse{})
c := newMockTendermintRPC(abci.ResponseQuery{
Value: bz,
})
return s.baseCtx.WithClient(c)
}
s.clientCtx = ctxGen().WithOutput(&outBuf)
cfg, err := network.DefaultConfigWithAppConfig(nfttestutil.AppConfig)
s.Require().NoError(err)
genesisState := cfg.GenesisState
nftGenesis := nft.GenesisState{
Classes: []*nft.Class{&ExpClass},
Entries: []*nft.Entry{{
Owner: Owner,
Nfts: []*nft.NFT{&ExpNFT},
}},
}
nftDataBz, err := s.encCfg.Codec.MarshalJSON(&nftGenesis)
s.Require().NoError(err)
genesisState[nft.ModuleName] = nftDataBz
s.initAccount()
}
func (s *CLITestSuite) TestCLITxSend() {
accounts := testutil.CreateKeyringAccounts(s.T(), s.kr, 1)
args := []string{
fmt.Sprintf("--%s=%s", flags.FlagFrom, OwnerName),
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(10))).String()),
}
testCases := []struct {
name string
args []string
expectedCode uint32
expectErr bool
}{
{
"valid transaction",
[]string{
testClassID,
testID,
accounts[0].Address.String(),
},
0,
false,
},
}
for _, tc := range testCases {
tc := tc
s.Run(tc.name, func() {
args = append(args, tc.args...)
cmd := cli.NewCmdSend()
cmd.SetContext(s.ctx)
cmd.SetArgs(args)
s.Require().NoError(client.SetCmdClientContextHandler(s.clientCtx, cmd))
out, err := clitestutil.ExecTestCLICmd(s.clientCtx, cmd, args)
if tc.expectErr {
s.Require().Error(err)
} else {
var txResp sdk.TxResponse
s.Require().NoError(err)
s.Require().NoError(s.clientCtx.Codec.UnmarshalJSON(out.Bytes(), &txResp), out.String())
s.Require().Equal(tc.expectedCode, txResp.Code, out.String())
}
})
}
}
func (s *CLITestSuite) initAccount() {
ctx := s.clientCtx
err := ctx.Keyring.ImportPrivKey(OwnerName, OwnerArmor, "1234567890")
s.Require().NoError(err)
accounts := testutil.CreateKeyringAccounts(s.T(), s.kr, 1)
keyinfo, err := ctx.Keyring.Key(OwnerName)
s.Require().NoError(err)
args := []string{
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(10))).String()),
}
s.owner, err = keyinfo.GetAddress()
s.Require().NoError(err)
amount := sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(200)))
_, err = clitestutil.MsgSendExec(ctx, accounts[0].Address, s.owner, amount, args...)
s.Require().NoError(err)
}