Mirroristas/planetmint-go
2
0
Fork 0
mirror of https://github.com/planetmint/planetmint-go.git synced 2025-03-30 15:08:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: remove duplicate test scenarios (#278)

Browse Source 
* refactor: remove duplicate test scenarios

* chore: remove deprecated rest testutil
---------

Signed-off-by: Lorenz Herzberger <lorenzherzberger@gmail.com>
This commit is contained in:
Lorenz Herzberger 2024-01-11 15:59:53 +01:00 committed by GitHub
parent 2534828fc6
commit 461891cde8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 17 additions and 402 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
tests/e2e/asset/cli_test.go
View File

@ -14,8 +14,3 @@ func TestE2ETestSuite(t *testing.T) {
cfg.NumValidators = 1
suite.Run(t, NewE2ETestSuite(cfg))
}
func TestRESTMachineAttestationSuite(t *testing.T) {
cfg := network.DefaultConfig()
suite.Run(t, NewRestE2ETestSuite(cfg))
}

115
tests/e2e/asset/rest.go
View File

@ -1,115 +0,0 @@
package asset
import (
"fmt"
"github.com/planetmint/planetmint-go/config"
"github.com/planetmint/planetmint-go/testutil"
e2etestutil "github.com/planetmint/planetmint-go/testutil/e2e"
"github.com/planetmint/planetmint-go/testutil/network"
"github.com/planetmint/planetmint-go/testutil/sample"
"github.com/stretchr/testify/suite"
assettypes "github.com/planetmint/planetmint-go/x/asset/types"
txtypes "github.com/cosmos/cosmos-sdk/types/tx"
)
type RestE2ETestSuite struct {
suite.Suite
cfg network.Config
network *network.Network
}
func NewRestE2ETestSuite(cfg network.Config) *RestE2ETestSuite {
return &RestE2ETestSuite{cfg: cfg}
}
// SetupSuite initializes asset E2ETestSuite
func (s *RestE2ETestSuite) SetupSuite() {
conf := config.GetConfig()
conf.FeeDenom = "stake"
s.T().Log("setting up e2e test suite")
s.network = network.New(s.T())
err := e2etestutil.AttestMachine(s.network, sample.Name, sample.Mnemonic, 0)
s.Require().NoError(err)
}
// TearDownSuite clean up after testing
func (s *RestE2ETestSuite) TearDownSuite() {
s.T().Log("tearing down e2e test suite")
}
// TestNotarizeAssetREST notarizes asset over REST endpoint
func (s *RestE2ETestSuite) TestNotarizeAssetREST() {
val := s.network.Validators[0]
// Create Msg
k, err := val.ClientCtx.Keyring.Key(sample.Name)
s.Require().NoError(err)
addr, err := k.GetAddress()
s.Require().NoError(err)
cid := sample.Asset()
testCases := []struct {
name string
msg assettypes.MsgNotarizeAsset
rawLog string
expectCheckTxErr bool
}{
{
"invalid address",
assettypes.MsgNotarizeAsset{
Creator: "invalid creator address",
Cid: cid,
},
"invalid address",
true,
},
{
"machine not found",
assettypes.MsgNotarizeAsset{
Creator: "plmnt1v5394e8vmfrp4qzdav7xkze0f567w3tsgxf09j",
Cid: cid,
},
"machine not found",
true,
},
{
"valid notarization",
assettypes.MsgNotarizeAsset{
Creator: addr.String(),
Cid: cid,
},
"[]",
true,
},
}
for _, tc := range testCases {
// Prepare Tx
txBytes, err := testutil.PrepareTx(val, &tc.msg, sample.Name)
s.Require().NoError(err)
// Broadcast Tx
broadcastTxResponse, err := testutil.BroadcastTx(val, txBytes)
s.Require().NoError(err)
s.Require().NoError(s.network.WaitForNextBlock())
tx, err := testutil.GetRequest(fmt.Sprintf("%s/cosmos/tx/v1beta1/txs/%s", val.APIAddress, broadcastTxResponse.TxResponse.TxHash))
s.Require().NoError(err)
if !tc.expectCheckTxErr {
var txRes txtypes.GetTxResponse
err = val.ClientCtx.Codec.UnmarshalJSON(tx, &txRes)
s.Require().NoError(err)
s.Require().Contains(txRes.TxResponse.RawLog, tc.rawLog)
} else {
s.Require().Contains(broadcastTxResponse.TxResponse.RawLog, tc.rawLog)
}
}
}

21
tests/e2e/asset/suite.go
View File

@ -8,6 +8,7 @@ import (
clitestutil "github.com/planetmint/planetmint-go/testutil/cli"
e2etestutil "github.com/planetmint/planetmint-go/testutil/e2e"
assetcli "github.com/planetmint/planetmint-go/x/asset/client/cli"
assettypes "github.com/planetmint/planetmint-go/x/asset/types"
"github.com/stretchr/testify/assert"
@ -62,23 +63,35 @@ func (s *E2ETestSuite) TestNotarizeAsset() {
"valid notarization",
assettypes.NewMsgNotarizeAsset(addr.String(), sample.Asset()),
"[]",
false,
},
{
"machine not found",
assettypes.NewMsgNotarizeAsset("plmnt1v5394e8vmfrp4qzdav7xkze0f567w3tsgxf09j", sample.Asset()),
"error during CheckTx or ReCheckTx: machine not found",
true,
},
}
for _, tc := range testCases {
out, err := e2etestutil.BuildSignBroadcastTx(s.T(), addr, tc.msg)
s.Require().NoError(err)
if tc.expectCheckTxErr {
s.Require().Error(err)
} else {
s.Require().NoError(err)
}
txResponse, err := lib.GetTxResponseFromOut(out)
s.Require().NoError(err)
s.Require().NoError(s.network.WaitForNextBlock())
rawLog, err := clitestutil.GetRawLogFromTxOut(val, out)
s.Require().NoError(err)
if !tc.expectCheckTxErr {
assert.Contains(s.T(), rawLog, tc.rawLog)
assert.Equal(s.T(), int(0), int(txResponse.Code))
args := []string{sample.Asset()}
asset, err := clitestutil.ExecTestCLICmd(val.ClientCtx, assetcli.CmdGetNotarizedAsset(), args)
s.Require().NoError(err)
assert.Contains(s.T(), asset.String(), sample.Asset())
} else {
assert.Contains(s.T(), txResponse.RawLog, tc.rawLog)
}

5
tests/e2e/machine/cli_test.go
View File

@ -14,8 +14,3 @@ func TestE2ETestSuite(t *testing.T) {
cfg.NumValidators = 1
suite.Run(t, NewE2ETestSuite(cfg))
}
func TestRESTMachineAttestationSuite(t *testing.T) {
cfg := network.DefaultConfig()
suite.Run(t, NewRestE2ETestSuite(cfg))
}

106
tests/e2e/machine/rest.go
View File

@ -1,106 +0,0 @@
package machine
import (
"fmt"
"github.com/planetmint/planetmint-go/config"
"github.com/planetmint/planetmint-go/testutil"
"github.com/planetmint/planetmint-go/testutil/network"
"github.com/planetmint/planetmint-go/testutil/sample"
machinetypes "github.com/planetmint/planetmint-go/x/machine/types"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/suite"
clitestutil "github.com/planetmint/planetmint-go/testutil/cli"
e2etestutil "github.com/planetmint/planetmint-go/testutil/e2e"
)
// RestE2ETestSuite struct definition of machine suite
type RestE2ETestSuite struct {
suite.Suite
cfg network.Config
network *network.Network
}
// NewRestE2ETestSuite returns configured machine RestE2ETestSuite
func NewRestE2ETestSuite(cfg network.Config) *RestE2ETestSuite {
return &RestE2ETestSuite{cfg: cfg}
}
// SetupSuite initializes machine E2ETestSuite
func (s *RestE2ETestSuite) SetupSuite() {
conf := config.GetConfig()
conf.FeeDenom = "stake"
s.T().Log("setting up e2e test suite")
s.network = network.New(s.T())
// create machine account for attestation
account, err := e2etestutil.CreateAccount(s.network, sample.Name, sample.Mnemonic)
s.Require().NoError(err)
err = e2etestutil.FundAccount(s.network, account)
s.Require().NoError(err)
}
// TearDownSuite clean up after testing
func (s *RestE2ETestSuite) TearDownSuite() {
s.T().Log("tearing down e2e test suite")
}
func (s *RestE2ETestSuite) TestAttestMachineREST() {
val := s.network.Validators[0]
baseURL := val.APIAddress
// Query Sequence Number
k, err := val.ClientCtx.Keyring.Key(sample.Name)
s.Require().NoError(err)
addr, err := k.GetAddress()
s.Require().NoError(err)
prvKey, pubKey := sample.KeyPair()
// Register TA
ta := sample.TrustAnchor(pubKey)
taMsg := machinetypes.MsgRegisterTrustAnchor{
Creator: val.Address.String(),
TrustAnchor: &ta,
}
out, err := e2etestutil.BuildSignBroadcastTx(s.T(), val.Address, &taMsg)
s.Require().NoError(err)
s.Require().NoError(s.network.WaitForNextBlock())
rawLog, err := clitestutil.GetRawLogFromTxOut(val, out)
s.Require().NoError(err)
assert.Contains(s.T(), rawLog, "planetmintgo.machine.MsgRegisterTrustAnchor")
// Create Attest Machine TX
machine := sample.Machine(sample.Name, pubKey, prvKey, addr.String())
msg := machinetypes.MsgAttestMachine{
Creator: addr.String(),
Machine: &machine,
}
out, err = e2etestutil.BuildSignBroadcastTx(s.T(), addr, &msg)
s.Require().NoError(err)
// give machine attestation some time to issue the liquid asset
s.Require().NoError(s.network.WaitForNextBlock())
s.Require().NoError(s.network.WaitForNextBlock())
s.Require().NoError(s.network.WaitForNextBlock())
rawLog, err = clitestutil.GetRawLogFromTxOut(val, out)
s.Require().NoError(err)
assert.Contains(s.T(), rawLog, "planetmintgo.machine.MsgAttestMachine")
queryMachineURL := fmt.Sprintf("%s/planetmint/machine/get_machine_by_public_key/%s", baseURL, pubKey)
queryMachineRes, err := testutil.GetRequest(queryMachineURL)
s.Require().NoError(err)
var qmRes machinetypes.QueryGetMachineByPublicKeyResponse
err = val.ClientCtx.Codec.UnmarshalJSON(queryMachineRes, &qmRes)
s.Require().NoError(err)
s.Require().Equal(&machine, qmRes.Machine)
}

167
testutil/rest.go
View File

@ -1,167 +0,0 @@
package testutil
import (
"bytes"
"fmt"
"io"
"net/http"
"github.com/cosmos/cosmos-sdk/client/tx"
"github.com/cosmos/cosmos-sdk/testutil/network"
cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
sdk "github.com/cosmos/cosmos-sdk/types"
txtypes "github.com/cosmos/cosmos-sdk/types/tx"
"github.com/cosmos/cosmos-sdk/types/tx/signing"
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
xauthsigning "github.com/cosmos/cosmos-sdk/x/auth/signing"
)
// GetRequest defines a wrapper around an HTTP GET request with a provided URL.
// An error is returned if the request or reading the body fails.
func GetRequest(url string) ([]byte, error) {
res, err := http.Get(url) //nolint:gosec,noctx // only used for testing
if err != nil {
return nil, err
}
defer func() {
_ = res.Body.Close()
}()
body, err := io.ReadAll(res.Body)
if err != nil {
return nil, err
}
return body, nil
}
// PostRequest defines a wrapper around an HTTP POST request with a provided URL and data.
// An error is returned if the request or reading the body fails.
func PostRequest(url, contentType string, data []byte) ([]byte, error) {
res, err := http.Post(url, contentType, bytes.NewBuffer(data)) //nolint:gosec,noctx // only used for testing
if err != nil {
return nil, fmt.Errorf("error while sending post request: %w", err)
}
defer func() {
_ = res.Body.Close()
}()
bz, err := io.ReadAll(res.Body)
if err != nil {
return nil, fmt.Errorf("error reading response body: %w", err)
}
return bz, nil
}
func PrepareTx(val *network.Validator, msg sdk.Msg, signer string) ([]byte, error) {
k, err := val.ClientCtx.Keyring.Key(signer)
if err != nil {
return nil, err
}
addr, err := k.GetAddress()
if err != nil {
return nil, err
}
reqAccountInfo := fmt.Sprintf("%s/cosmos/auth/v1beta1/account_info/%s", val.APIAddress, addr.String())
respAccountInfo, err := GetRequest(reqAccountInfo)
if err != nil {
return nil, err
}
var resAccountInfo authtypes.QueryAccountInfoResponse
err = val.ClientCtx.Codec.UnmarshalJSON(respAccountInfo, &resAccountInfo)
if err != nil {
return nil, err
}
txBuilder := val.ClientCtx.TxConfig.NewTxBuilder()
err = txBuilder.SetMsgs(msg)
if err != nil {
return nil, err
}
txBuilder.SetGasLimit(200000)
txBuilder.SetFeeAmount(sdk.Coins{sdk.NewInt64Coin("stake", 2)})
txBuilder.SetTimeoutHeight(0)
pk, err := k.GetPubKey()
if err != nil {
return nil, err
}
sk := k.GetLocal().PrivKey
var priv cryptotypes.PrivKey
err = val.ClientCtx.Codec.UnpackAny(sk, &priv)
if err != nil {
return nil, err
}
sigV2 := signing.SignatureV2{
PubKey: pk,
Data: &signing.SingleSignatureData{
SignMode: val.ClientCtx.TxConfig.SignModeHandler().DefaultMode(),
Signature: nil,
},
Sequence: resAccountInfo.Info.Sequence,
}
err = txBuilder.SetSignatures(sigV2)
if err != nil {
return nil, err
}
signerData := xauthsigning.SignerData{
ChainID: val.ClientCtx.ChainID,
AccountNumber: resAccountInfo.Info.AccountNumber,
Sequence: resAccountInfo.Info.Sequence,
}
sigV2, err = tx.SignWithPrivKey(
val.ClientCtx.TxConfig.SignModeHandler().DefaultMode(), signerData,
txBuilder, priv, val.ClientCtx.TxConfig, resAccountInfo.Info.Sequence,
)
if err != nil {
return nil, err
}
err = txBuilder.SetSignatures(sigV2)
if err != nil {
return nil, err
}
txBytes, err := val.ClientCtx.TxConfig.TxEncoder()(txBuilder.GetTx())
if err != nil {
return nil, err
}
return txBytes, nil
}
func BroadcastTx(val *network.Validator, txBytes []byte) (*txtypes.BroadcastTxResponse, error) {
broadcastTxURL := fmt.Sprintf("%s/cosmos/tx/v1beta1/txs", val.APIAddress)
req := txtypes.BroadcastTxRequest{
TxBytes: txBytes,
Mode: txtypes.BroadcastMode_BROADCAST_MODE_SYNC,
}
broadCastTxBody, err := val.ClientCtx.Codec.MarshalJSON(&req)
if err != nil {
return nil, err
}
broadCastTxResponse, err := PostRequest(broadcastTxURL, "application/json", broadCastTxBody)
if err != nil {
return nil, err
}
var bctRes txtypes.BroadcastTxResponse
err = val.ClientCtx.Codec.UnmarshalJSON(broadCastTxResponse, &bctRes)
if err != nil {
return nil, err
}
return &bctRes, nil
}