laconicd-deprecated/x/registry/client/testutil/grpc.go

643 lines
15 KiB
Go
Raw Normal View History

package testutil
import (
"encoding/json"
"fmt"
2022-04-20 07:37:38 +00:00
"os"
"time"
2022-12-09 04:17:14 +00:00
"github.com/cerc-io/laconicd/x/registry/client/cli"
nstypes "github.com/cerc-io/laconicd/x/registry/types"
"github.com/cosmos/cosmos-sdk/client/flags"
clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
2022-04-23 15:53:51 +00:00
"github.com/cosmos/cosmos-sdk/testutil/rest"
sdk "github.com/cosmos/cosmos-sdk/types"
tmcli "github.com/tendermint/tendermint/libs/cli"
)
const badPath = "/asdasd"
func (s *IntegrationTestSuite) TestGRPCQueryParams() {
val := s.network.Validators[0]
sr := s.Require()
2022-12-09 04:17:14 +00:00
reqURL := val.APIAddress + "/vulcanize/registry/v1beta1/params"
testCases := []struct {
name string
url string
expectErr bool
errorMsg string
}{
{
"invalid url",
reqURL + badPath,
true,
"",
},
{
"Success",
2022-10-17 11:03:31 +00:00
reqURL,
false,
"",
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
resp, err := rest.GetRequest(tc.url)
s.NoError(err)
require := s.Require()
if tc.expectErr {
require.Contains(string(resp), tc.errorMsg)
} else {
var response nstypes.QueryParamsResponse
err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
sr.NoError(err)
params := nstypes.DefaultParams()
params.RecordRent = sdk.NewCoin(s.cfg.BondDenom, nstypes.DefaultRecordRent)
params.RecordRentDuration = 10 * time.Second
params.AuthorityGracePeriod = 10 * time.Second
sr.Equal(response.GetParams().String(), params.String())
}
})
}
}
// nolint: all
func (s *IntegrationTestSuite) TestGRPCQueryWhoIs() {
val := s.network.Validators[0]
sr := s.Require()
2022-12-09 04:17:14 +00:00
reqUrl := val.APIAddress + "/vulcanize/registry/v1beta1/whois/%s"
2022-10-17 06:47:56 +00:00
authorityName := "QueryWhoIS"
testCases := []struct {
name string
url string
expectErr bool
errorMsg string
preRun func(authorityName string)
}{
{
"invalid url",
reqUrl + badPath,
true,
"",
func(authorityName string) {
},
},
{
"Success",
reqUrl,
false,
"",
func(authorityName string) {
clientCtx := val.ClientCtx
cmd := cli.GetCmdReserveName()
args := []string{
authorityName,
fmt.Sprintf("--owner=%s", accountAddress),
fmt.Sprintf("--%s=%s", flags.FlagFrom, accountName),
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=json", tmcli.OutputFlag),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
fmt.Sprintf("--%s=%s", flags.FlagFees, fmt.Sprintf("3%s", s.cfg.BondDenom)),
}
out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, args)
sr.NoError(err)
var d sdk.TxResponse
err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &d)
sr.NoError(err)
sr.Zero(d.Code)
},
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
tc.preRun(authorityName)
tc.url = fmt.Sprintf(tc.url, authorityName)
resp, err := rest.GetRequest(tc.url)
s.NoError(err)
require := s.Require()
if tc.expectErr {
require.Contains(string(resp), tc.errorMsg)
} else {
var response nstypes.QueryWhoisResponse
err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
sr.NoError(err)
sr.Equal(nstypes.AuthorityActive, response.GetNameAuthority().Status)
}
})
}
}
func (s *IntegrationTestSuite) TestGRPCQueryLookup() {
val := s.network.Validators[0]
sr := s.Require()
reqURL := val.APIAddress + "/vulcanize/registry/v1beta1/lookup"
2022-10-17 06:47:56 +00:00
authorityName := "QueryLookUp"
testCases := []struct {
name string
url string
expectErr bool
errorMsg string
preRun func(authorityName string)
}{
{
"invalid url",
reqURL + badPath,
true,
"",
func(authorityName string) {
},
},
{
"Success",
fmt.Sprintf(reqURL+"?crn=crn://%s/", authorityName),
false,
"",
func(authorityName string) {
// create name record
createNameRecord(authorityName, s)
},
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
tc.preRun(authorityName)
resp, err := rest.GetRequest(tc.url)
s.NoError(err)
if tc.expectErr {
sr.Contains(string(resp), tc.errorMsg)
} else {
2022-04-20 07:37:38 +00:00
var response nstypes.QueryLookupCrnResponse
err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
sr.NoError(err)
sr.NotZero(len(response.Name.Latest.Id))
}
})
}
}
// nolint: all
func (s *IntegrationTestSuite) TestGRPCQueryRecordExpiryQueue() {
val := s.network.Validators[0]
sr := s.Require()
2022-12-09 04:17:14 +00:00
reqUrl := val.APIAddress + "/vulcanize/registry/v1beta1/record-expiry"
testCases := []struct {
name string
url string
expectErr bool
errorMsg string
preRun func(bondId string)
}{
{
"invalid url",
reqUrl + badPath,
true,
"",
func(bondId string) {
},
},
{
"Success",
reqUrl,
false,
"",
func(bondId string) {
dir, err := os.Getwd()
sr.NoError(err)
payloadPath := dir + "/service_provider_example.yml"
args := []string{
fmt.Sprintf("--%s=%s", flags.FlagFrom, accountName),
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=json", tmcli.OutputFlag),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
fmt.Sprintf("--%s=%s", flags.FlagFees, fmt.Sprintf("3%s", s.cfg.BondDenom)),
}
args = append([]string{payloadPath, bondId}, args...)
clientCtx := val.ClientCtx
cmd := cli.GetCmdSetRecord()
out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, args)
sr.NoError(err)
var d sdk.TxResponse
err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &d)
sr.NoError(err)
sr.Zero(d.Code)
},
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
tc.preRun(s.bondID)
// wait 12 seconds for records expires
time.Sleep(time.Second * 12)
resp, err := rest.GetRequest(tc.url)
s.NoError(err)
require := s.Require()
if tc.expectErr {
require.Contains(string(resp), tc.errorMsg)
} else {
var response nstypes.QueryGetRecordExpiryQueueResponse
err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
sr.NoError(err)
sr.NotZero(len(response.GetRecords()))
}
})
}
}
// nolint: all
func (s *IntegrationTestSuite) TestGRPCQueryAuthorityExpiryQueue() {
val := s.network.Validators[0]
sr := s.Require()
2022-12-09 04:17:14 +00:00
reqUrl := val.APIAddress + "/vulcanize/registry/v1beta1/authority-expiry"
testCases := []struct {
name string
url string
expectErr bool
errorMsg string
preRun func(authorityName string)
}{
{
"invalid url",
reqUrl + badPath,
true,
"",
func(authorityName string) {
},
},
{
"Success",
reqUrl,
false,
"",
func(authorityName string) {
// reserving the name
clientCtx := val.ClientCtx
cmd := cli.GetCmdReserveName()
args := []string{
authorityName,
fmt.Sprintf("--owner=%s", accountAddress),
fmt.Sprintf("--%s=%s", flags.FlagFrom, accountName),
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=json", tmcli.OutputFlag),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
fmt.Sprintf("--%s=%s", flags.FlagFees, fmt.Sprintf("3%s", s.cfg.BondDenom)),
}
out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, args)
sr.NoError(err)
var d sdk.TxResponse
err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &d)
sr.NoError(err)
sr.Zero(d.Code)
},
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
tc.preRun("QueryAuthorityExpiryQueue")
// wait 12 seconds to name authorites expires
time.Sleep(time.Second * 12)
resp, err := rest.GetRequest(tc.url)
s.NoError(err)
require := s.Require()
if tc.expectErr {
require.Contains(string(resp), tc.errorMsg)
} else {
var response nstypes.QueryGetAuthorityExpiryQueueResponse
err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
sr.NoError(err)
// removed from expiry queue as no bond set
sr.Zero(len(response.GetAuthorities()))
}
})
}
}
// nolint: all
func (s *IntegrationTestSuite) TestGRPCQueryListRecords() {
val := s.network.Validators[0]
sr := s.Require()
2022-12-09 04:17:14 +00:00
reqUrl := val.APIAddress + "/vulcanize/registry/v1beta1/records"
testCases := []struct {
name string
url string
expectErr bool
errorMsg string
preRun func(bondId string)
}{
{
"invalid url",
reqUrl + badPath,
true,
"",
func(bondId string) {
},
},
{
"Success",
reqUrl,
false,
"",
func(bondId string) {
dir, err := os.Getwd()
sr.NoError(err)
payloadPath := dir + "/service_provider_example.yml"
args := []string{
fmt.Sprintf("--%s=%s", flags.FlagFrom, accountName),
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=json", tmcli.OutputFlag),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
fmt.Sprintf("--%s=%s", flags.FlagFees, fmt.Sprintf("3%s", s.cfg.BondDenom)),
}
args = append([]string{payloadPath, bondId}, args...)
clientCtx := val.ClientCtx
cmd := cli.GetCmdSetRecord()
out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, args)
sr.NoError(err)
var d sdk.TxResponse
err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &d)
sr.NoError(err)
sr.Zero(d.Code)
},
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
tc.preRun(s.bondID)
resp, err := rest.GetRequest(tc.url)
s.NoError(err)
require := s.Require()
if tc.expectErr {
require.Contains(string(resp), tc.errorMsg)
} else {
var response nstypes.QueryListRecordsResponse
err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
sr.NoError(err)
sr.NotZero(len(response.GetRecords()))
2022-10-17 11:03:31 +00:00
sr.Equal(s.bondID, response.GetRecords()[0].GetBondId())
}
})
}
}
func (s *IntegrationTestSuite) TestGRPCQueryGetRecordByID() {
val := s.network.Validators[0]
sr := s.Require()
2022-12-09 04:17:14 +00:00
reqURL := val.APIAddress + "/vulcanize/registry/v1beta1/records/%s"
testCases := []struct {
name string
url string
expectErr bool
errorMsg string
preRun func(bondId string) string
}{
{
"invalid url",
reqURL + badPath,
true,
"",
func(bondId string) string {
return ""
},
},
{
"Success",
2022-10-17 11:03:31 +00:00
reqURL,
false,
"",
func(bondId string) string {
// creating the record
createRecord(bondId, s)
// list the records
clientCtx := val.ClientCtx
cmd := cli.GetCmdList()
args := []string{
fmt.Sprintf("--%s=json", tmcli.OutputFlag),
}
out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, args)
sr.NoError(err)
var records []nstypes.ReadableRecord
err = json.Unmarshal(out.Bytes(), &records)
sr.NoError(err)
2022-10-17 11:03:31 +00:00
return records[0].ID
},
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
recordID := tc.preRun(s.bondID)
tc.url = fmt.Sprintf(reqURL, recordID)
resp, err := rest.GetRequest(tc.url)
s.NoError(err)
require := s.Require()
if tc.expectErr {
require.Contains(string(resp), tc.errorMsg)
} else {
2022-10-17 11:03:31 +00:00
var response nstypes.QueryRecordByIDResponse
err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
sr.NoError(err)
record := response.GetRecord()
sr.NotZero(len(record.GetId()))
sr.Equal(record.GetId(), recordID)
}
})
}
}
func (s *IntegrationTestSuite) TestGRPCQueryGetRecordByBondID() {
val := s.network.Validators[0]
sr := s.Require()
2022-12-09 04:17:14 +00:00
reqURL := val.APIAddress + "/vulcanize/registry/v1beta1/records-by-bond-id/%s"
testCases := []struct {
name string
url string
expectErr bool
errorMsg string
preRun func(bondId string)
}{
{
"invalid url",
reqURL + badPath,
true,
"",
func(bondId string) {
},
},
{
"Success",
2022-10-17 11:03:31 +00:00
reqURL,
false,
"",
func(bondId string) {
// creating the record
createRecord(bondId, s)
},
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
tc.preRun(s.bondID)
tc.url = fmt.Sprintf(reqURL, s.bondID)
resp, err := rest.GetRequest(tc.url)
s.NoError(err)
require := s.Require()
if tc.expectErr {
require.Contains(string(resp), tc.errorMsg)
} else {
2022-10-17 11:03:31 +00:00
var response nstypes.QueryRecordByBondIDResponse
err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
sr.NoError(err)
records := response.GetRecords()
sr.NotZero(len(records))
2022-10-17 11:03:31 +00:00
sr.Equal(records[0].GetBondId(), s.bondID)
}
})
}
}
2022-12-09 04:17:14 +00:00
func (s *IntegrationTestSuite) TestGRPCQueryGetRegistryModuleBalance() {
val := s.network.Validators[0]
sr := s.Require()
2022-12-09 04:17:14 +00:00
reqURL := val.APIAddress + "/vulcanize/registry/v1beta1/balance"
testCases := []struct {
name string
url string
expectErr bool
errorMsg string
preRun func(bondId string)
}{
{
"invalid url",
reqURL + badPath,
true,
"",
func(bondId string) {
},
},
{
"Success",
2022-10-17 11:03:31 +00:00
reqURL,
false,
"",
func(bondId string) {
// creating the record
createRecord(bondId, s)
},
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
tc.preRun(s.bondID)
resp, err := rest.GetRequest(tc.url)
s.NoError(err)
require := s.Require()
if tc.expectErr {
require.Contains(string(resp), tc.errorMsg)
} else {
2022-12-09 04:17:14 +00:00
var response nstypes.GetRegistryModuleBalanceResponse
err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
sr.NoError(err)
sr.NotZero(len(response.GetBalances()))
}
})
}
}
func (s *IntegrationTestSuite) TestGRPCQueryNamesList() {
val := s.network.Validators[0]
sr := s.Require()
2022-12-09 04:17:14 +00:00
reqURL := val.APIAddress + "/vulcanize/registry/v1beta1/names"
testCases := []struct {
name string
url string
expectErr bool
errorMsg string
preRun func(authorityName string)
}{
{
"invalid url",
reqURL + badPath,
true,
"",
func(authorityName string) {
},
},
{
"Success",
2022-10-17 11:03:31 +00:00
reqURL,
false,
"",
func(authorityName string) {
// create name record
createNameRecord(authorityName, s)
},
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
tc.preRun("ListNameRecords")
resp, err := rest.GetRequest(tc.url)
s.NoError(err)
require := s.Require()
if tc.expectErr {
require.Contains(string(resp), tc.errorMsg)
} else {
var response nstypes.QueryListNameRecordsResponse
err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
sr.NoError(err)
sr.NotZero(len(response.GetNames()))
}
})
}
}
2022-10-17 11:03:31 +00:00
func createRecord(bondID string, s *IntegrationTestSuite) {
val := s.network.Validators[0]
sr := s.Require()
dir, err := os.Getwd()
sr.NoError(err)
payloadPath := dir + "/service_provider_example.yml"
args := []string{
fmt.Sprintf("--%s=%s", flags.FlagFrom, accountName),
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=json", tmcli.OutputFlag),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
fmt.Sprintf("--%s=%s", flags.FlagFees, fmt.Sprintf("3%s", s.cfg.BondDenom)),
}
2022-10-17 11:03:31 +00:00
args = append([]string{payloadPath, bondID}, args...)
clientCtx := val.ClientCtx
cmd := cli.GetCmdSetRecord()
out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, args)
sr.NoError(err)
var d sdk.TxResponse
err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &d)
sr.NoError(err)
sr.Zero(d.Code, d.RawLog)
}