forked from cerc-io/laconicd
Prathamesh Musale
213c390c37
Part of https://www.notion.so/Rename-laconic2d-to-laconicd-9028d0c020d24d1288e92ebcb773d7a7 Co-authored-by: neeraj <neeraj.rtly@gmail.com> Reviewed-on: cerc-io/laconic2d#26 Co-authored-by: Prathamesh Musale <prathamesh@noreply.git.vdb.to> Co-committed-by: Prathamesh Musale <prathamesh@noreply.git.vdb.to>
422 lines
10 KiB
Go
422 lines
10 KiB
Go
package keeper_test
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"path/filepath"
|
|
"reflect"
|
|
|
|
types "git.vdb.to/cerc-io/laconicd/x/registry"
|
|
"git.vdb.to/cerc-io/laconicd/x/registry/client/cli"
|
|
"git.vdb.to/cerc-io/laconicd/x/registry/helpers"
|
|
registryKeeper "git.vdb.to/cerc-io/laconicd/x/registry/keeper"
|
|
)
|
|
|
|
func (kts *KeeperTestSuite) TestGrpcQueryParams() {
|
|
testCases := []struct {
|
|
msg string
|
|
req *types.QueryParamsRequest
|
|
}{
|
|
{
|
|
"Get Params",
|
|
&types.QueryParamsRequest{},
|
|
},
|
|
}
|
|
for _, test := range testCases {
|
|
kts.Run(fmt.Sprintf("Case %s ", test.msg), func() {
|
|
resp, _ := kts.queryClient.Params(context.Background(), test.req)
|
|
defaultParams := types.DefaultParams()
|
|
kts.Require().Equal(defaultParams.String(), resp.GetParams().String())
|
|
})
|
|
}
|
|
}
|
|
|
|
func (kts *KeeperTestSuite) TestGrpcGetRecordLists() {
|
|
ctx, queryClient := kts.SdkCtx, kts.queryClient
|
|
sr := kts.Require()
|
|
|
|
var recordId string
|
|
examples := []string{
|
|
"../../../data/examples/service_provider_example.yml",
|
|
"../../../data/examples/website_registration_example.yml",
|
|
"../../../data/examples/general_record_example.yml",
|
|
}
|
|
testCases := []struct {
|
|
msg string
|
|
req *types.QueryRecordsRequest
|
|
createRecords bool
|
|
expErr bool
|
|
noOfRecords int
|
|
}{
|
|
{
|
|
"Empty Records",
|
|
&types.QueryRecordsRequest{},
|
|
false,
|
|
false,
|
|
0,
|
|
},
|
|
{
|
|
"List Records",
|
|
&types.QueryRecordsRequest{},
|
|
true,
|
|
false,
|
|
3,
|
|
},
|
|
{
|
|
"Filter with type",
|
|
&types.QueryRecordsRequest{
|
|
Attributes: []*types.QueryRecordsRequest_KeyValueInput{
|
|
{
|
|
Key: "type",
|
|
Value: &types.QueryRecordsRequest_ValueInput{
|
|
Value: &types.QueryRecordsRequest_ValueInput_String_{String_: "WebsiteRegistrationRecord"},
|
|
},
|
|
},
|
|
},
|
|
All: true,
|
|
},
|
|
true,
|
|
false,
|
|
1,
|
|
},
|
|
// Skip the following test as querying with recursive values not supported (PR https://git.vdb.to/cerc-io/laconicd/pulls/112)
|
|
// See function RecordsFromAttributes (QueryValueToJSON call) in the registry keeper implementation (x/registry/keeper/keeper.go)
|
|
// {
|
|
// "Filter with tag (extant) (https://git.vdb.to/cerc-io/laconicd/issues/129)",
|
|
// &types.QueryRecordsRequest{
|
|
// Attributes: []*types.QueryRecordsRequest_KeyValueInput{
|
|
// {
|
|
// Key: "tags",
|
|
// // Value: &types.QueryRecordsRequest_ValueInput{
|
|
// // Value: &types.QueryRecordsRequest_ValueInput_String_{"tagA"},
|
|
// // },
|
|
// Value: &types.QueryRecordsRequest_ValueInput{
|
|
// Value: &types.QueryRecordsRequest_ValueInput_Array{Array: &types.QueryRecordsRequest_ArrayInput{
|
|
// Values: []*types.QueryRecordsRequest_ValueInput{
|
|
// {
|
|
// Value: &types.QueryRecordsRequest_ValueInput_String_{"tagA"},
|
|
// },
|
|
// },
|
|
// }},
|
|
// },
|
|
// // Throws: "Recursive query values are not supported"
|
|
// },
|
|
// },
|
|
// All: true,
|
|
// },
|
|
// true,
|
|
// false,
|
|
// 1,
|
|
// },
|
|
{
|
|
"Filter with tag (non-existent) (https://git.vdb.to/cerc-io/laconicd/issues/129)",
|
|
&types.QueryRecordsRequest{
|
|
Attributes: []*types.QueryRecordsRequest_KeyValueInput{
|
|
{
|
|
Key: "tags",
|
|
Value: &types.QueryRecordsRequest_ValueInput{
|
|
Value: &types.QueryRecordsRequest_ValueInput_String_{String_: "NOEXIST"},
|
|
},
|
|
},
|
|
},
|
|
All: true,
|
|
},
|
|
true,
|
|
false,
|
|
0,
|
|
},
|
|
{
|
|
"Filter test for key collision (https://git.vdb.to/cerc-io/laconicd/issues/122)",
|
|
&types.QueryRecordsRequest{
|
|
Attributes: []*types.QueryRecordsRequest_KeyValueInput{
|
|
{
|
|
Key: "typ",
|
|
Value: &types.QueryRecordsRequest_ValueInput{
|
|
Value: &types.QueryRecordsRequest_ValueInput_String_{String_: "eWebsiteRegistrationRecord"},
|
|
},
|
|
},
|
|
},
|
|
All: true,
|
|
},
|
|
true,
|
|
false,
|
|
0,
|
|
},
|
|
{
|
|
"Filter with attributes ServiceProviderRegistration",
|
|
&types.QueryRecordsRequest{
|
|
Attributes: []*types.QueryRecordsRequest_KeyValueInput{
|
|
{
|
|
Key: "x500state_name",
|
|
Value: &types.QueryRecordsRequest_ValueInput{
|
|
Value: &types.QueryRecordsRequest_ValueInput_String_{String_: "california"},
|
|
},
|
|
},
|
|
},
|
|
All: true,
|
|
},
|
|
true,
|
|
false,
|
|
1,
|
|
},
|
|
}
|
|
for _, test := range testCases {
|
|
kts.Run(fmt.Sprintf("Case %s ", test.msg), func() {
|
|
if test.createRecords {
|
|
for _, example := range examples {
|
|
filePath, err := filepath.Abs(example)
|
|
sr.NoError(err)
|
|
payloadType, err := cli.GetPayloadFromFile(filePath)
|
|
sr.NoError(err)
|
|
payload := payloadType.ToPayload()
|
|
record, err := kts.RegistryKeeper.SetRecord(ctx, types.MsgSetRecord{
|
|
BondId: kts.bond.GetId(),
|
|
Signer: kts.accounts[0].String(),
|
|
Payload: payload,
|
|
})
|
|
sr.NoError(err)
|
|
sr.NotNil(record.Id)
|
|
}
|
|
}
|
|
|
|
resp, err := queryClient.Records(context.Background(), test.req)
|
|
|
|
if test.expErr {
|
|
kts.Error(err)
|
|
} else {
|
|
sr.NoError(err)
|
|
sr.Equal(test.noOfRecords, len(resp.GetRecords()))
|
|
if test.createRecords && test.noOfRecords > 0 {
|
|
recordId = resp.GetRecords()[0].GetId()
|
|
sr.NotZero(resp.GetRecords())
|
|
sr.Equal(resp.GetRecords()[0].GetBondId(), kts.bond.GetId())
|
|
|
|
for _, record := range resp.GetRecords() {
|
|
recAttr := helpers.MustUnmarshalJSON[types.AttributeMap](record.Attributes)
|
|
|
|
for _, attr := range test.req.GetAttributes() {
|
|
enc, err := registryKeeper.QueryValueToJSON(attr.Value)
|
|
sr.NoError(err)
|
|
av := helpers.MustUnmarshalJSON[any](enc)
|
|
|
|
if nil != av && nil != recAttr[attr.Key] &&
|
|
reflect.Slice == reflect.TypeOf(recAttr[attr.Key]).Kind() &&
|
|
reflect.Slice != reflect.TypeOf(av).Kind() {
|
|
found := false
|
|
allValues := recAttr[attr.Key].([]interface{})
|
|
for i := range allValues {
|
|
if av == allValues[i] {
|
|
fmt.Printf("Found %s in %s", allValues[i], recAttr[attr.Key])
|
|
found = true
|
|
}
|
|
}
|
|
sr.Equal(true, found, fmt.Sprintf("Unable to find %s in %s", av, recAttr[attr.Key]))
|
|
} else {
|
|
if attr.Key[:4] == "x500" {
|
|
sr.Equal(av, recAttr["x500"].(map[string]interface{})[attr.Key[4:]])
|
|
} else {
|
|
sr.Equal(av, recAttr[attr.Key])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
// Get the records by record id
|
|
testCases1 := []struct {
|
|
msg string
|
|
req *types.QueryGetRecordRequest
|
|
createRecord bool
|
|
expErr bool
|
|
noOfRecords int
|
|
}{
|
|
{
|
|
"Invalid Request without record id",
|
|
&types.QueryGetRecordRequest{},
|
|
false,
|
|
true,
|
|
0,
|
|
},
|
|
{
|
|
"With Record ID",
|
|
&types.QueryGetRecordRequest{
|
|
Id: recordId,
|
|
},
|
|
true,
|
|
false,
|
|
1,
|
|
},
|
|
}
|
|
for _, test := range testCases1 {
|
|
kts.Run(fmt.Sprintf("Case %s ", test.msg), func() {
|
|
resp, err := queryClient.GetRecord(context.Background(), test.req)
|
|
|
|
if test.expErr {
|
|
kts.Error(err)
|
|
} else {
|
|
sr.NoError(err)
|
|
sr.NotNil(resp.GetRecord())
|
|
if test.createRecord {
|
|
sr.Equal(resp.GetRecord().BondId, kts.bond.GetId())
|
|
sr.Equal(resp.GetRecord().Id, recordId)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
// Get the records by record id
|
|
testCasesByBondId := []struct {
|
|
msg string
|
|
req *types.QueryGetRecordsByBondIdRequest
|
|
createRecord bool
|
|
expErr bool
|
|
noOfRecords int
|
|
}{
|
|
{
|
|
"Invalid Request without bond id",
|
|
&types.QueryGetRecordsByBondIdRequest{},
|
|
false,
|
|
true,
|
|
0,
|
|
},
|
|
{
|
|
"With Bond ID",
|
|
&types.QueryGetRecordsByBondIdRequest{
|
|
Id: kts.bond.GetId(),
|
|
},
|
|
true,
|
|
false,
|
|
1,
|
|
},
|
|
}
|
|
for _, test := range testCasesByBondId {
|
|
kts.Run(fmt.Sprintf("Case %s ", test.msg), func() {
|
|
resp, err := queryClient.GetRecordsByBondId(context.Background(), test.req)
|
|
|
|
if test.expErr {
|
|
sr.Zero(resp.GetRecords())
|
|
} else {
|
|
sr.NoError(err)
|
|
sr.NotNil(resp.GetRecords())
|
|
if test.createRecord {
|
|
sr.NotZero(resp.GetRecords())
|
|
sr.Equal(resp.GetRecords()[0].GetBondId(), kts.bond.GetId())
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (kts *KeeperTestSuite) TestGrpcQueryRegistryModuleBalance() {
|
|
queryClient, ctx := kts.queryClient, kts.SdkCtx
|
|
sr := kts.Require()
|
|
examples := []string{
|
|
"../../../data/examples/service_provider_example.yml",
|
|
"../../../data/examples/website_registration_example.yml",
|
|
}
|
|
testCases := []struct {
|
|
msg string
|
|
req *types.QueryGetRegistryModuleBalanceRequest
|
|
createRecords bool
|
|
expErr bool
|
|
noOfRecords int
|
|
}{
|
|
{
|
|
"Get Module Balance",
|
|
&types.QueryGetRegistryModuleBalanceRequest{},
|
|
true,
|
|
false,
|
|
1,
|
|
},
|
|
}
|
|
for _, test := range testCases {
|
|
kts.Run(fmt.Sprintf("Case %s ", test.msg), func() {
|
|
if test.createRecords {
|
|
for _, example := range examples {
|
|
filePath, err := filepath.Abs(example)
|
|
sr.NoError(err)
|
|
payloadType, err := cli.GetPayloadFromFile(filePath)
|
|
sr.NoError(err)
|
|
payload := payloadType.ToPayload()
|
|
record, err := kts.RegistryKeeper.SetRecord(ctx, types.MsgSetRecord{
|
|
BondId: kts.bond.GetId(),
|
|
Signer: kts.accounts[0].String(),
|
|
Payload: payload,
|
|
})
|
|
sr.NoError(err)
|
|
sr.NotNil(record.Id)
|
|
}
|
|
}
|
|
resp, err := queryClient.GetRegistryModuleBalance(context.Background(), test.req)
|
|
if test.expErr {
|
|
kts.Error(err)
|
|
} else {
|
|
sr.NoError(err)
|
|
sr.Equal(test.noOfRecords, len(resp.GetBalances()))
|
|
if test.createRecords {
|
|
balance := resp.GetBalances()[0]
|
|
sr.Equal(balance.AccountName, types.RecordRentModuleAccountName)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (kts *KeeperTestSuite) TestGrpcQueryWhoIs() {
|
|
queryClient, ctx := kts.queryClient, kts.SdkCtx
|
|
sr := kts.Require()
|
|
authorityName := "TestGrpcQueryWhoIs"
|
|
|
|
testCases := []struct {
|
|
msg string
|
|
req *types.QueryWhoisRequest
|
|
createName bool
|
|
expErr bool
|
|
noOfRecords int
|
|
}{
|
|
{
|
|
"Invalid Request without name",
|
|
&types.QueryWhoisRequest{},
|
|
false,
|
|
true,
|
|
1,
|
|
},
|
|
{
|
|
"Success",
|
|
&types.QueryWhoisRequest{},
|
|
true,
|
|
false,
|
|
1,
|
|
},
|
|
}
|
|
for _, test := range testCases {
|
|
kts.Run(fmt.Sprintf("Case %s ", test.msg), func() {
|
|
if test.createName {
|
|
err := kts.RegistryKeeper.ReserveAuthority(ctx, types.MsgReserveAuthority{
|
|
Name: authorityName,
|
|
Signer: kts.accounts[0].String(),
|
|
Owner: kts.accounts[0].String(),
|
|
})
|
|
sr.NoError(err)
|
|
test.req = &types.QueryWhoisRequest{Name: authorityName}
|
|
}
|
|
resp, err := queryClient.Whois(context.Background(), test.req)
|
|
if test.expErr {
|
|
kts.Error(err)
|
|
sr.Nil(resp)
|
|
} else {
|
|
sr.NoError(err)
|
|
if test.createName {
|
|
nameAuth := resp.NameAuthority
|
|
sr.NotNil(nameAuth)
|
|
sr.Equal(nameAuth.OwnerAddress, kts.accounts[0].String())
|
|
sr.Equal(types.AuthorityActive, nameAuth.Status)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|