chore: add additional testcases for fswap

CHANGELOG.md

@@ -67,6 +67,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 * (x/fbridge) [\#1395](https://github.com/Finschia/finschia-sdk/pull/1395) Return error instead of panic for behaviors triggered by client
 * (x/fswap) [\#1396](https://github.com/Finschia/finschia-sdk/pull/1396) refactor to use snake_case in proto
 * (x/fswap) [\#1391](https://github.com/Finschia/finschia-sdk/pull/1391) add cli_test for fswap module
+* (x/fswap) [\#1415](https://github.com/Finschia/finschia-sdk/pull/1415) add more testcases for fswap module
 
 ### Bug Fixes
 * chore(deps) [\#1141](https://github.com/Finschia/finschia-sdk/pull/1141) Bump github.com/cosmos/ledger-cosmos-go from 0.12.2 to 0.13.2 to fix ledger signing issue

x/fswap/keeper/genesis_test.go

@@ -2,7 +2,13 @@ package keeper_test
 
 import (
 	"fmt"
+	"testing"
 
+	"github.com/stretchr/testify/require"
+	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+
+	"github.com/Finschia/finschia-sdk/simapp"
+	"github.com/Finschia/finschia-sdk/testutil/testdata"
 	sdk "github.com/Finschia/finschia-sdk/types"
 	"github.com/Finschia/finschia-sdk/x/fswap/types"
 )
@@ -45,3 +51,78 @@ func (s *KeeperTestSuite) TestInitAndExportGenesis() {
 	s.Require().Equal(testGenesis.GetSwapStats(), exportGenesis.GetSwapStats())
 	s.Require().Equal(testGenesis.GetSwappeds(), exportGenesis.GetSwappeds())
 }
+
+func TestInitGenesis(t *testing.T) {
+	generateState := func() *types.GenesisState {
+		testSwapRate, _ := sdk.NewDecFromStr("1234567890")
+		return &types.GenesisState{
+			Swaps: []types.Swap{
+				{
+					FromDenom:           "aaa",
+					ToDenom:             "bbb",
+					AmountCapForToDenom: sdk.NewInt(1234567890000),
+					SwapRate:            testSwapRate,
+				},
+			},
+			SwapStats: types.SwapStats{
+				SwapCount: 1,
+			},
+			Swappeds: []types.Swapped{
+				{
+					FromCoinAmount: sdk.Coin{
+						Denom:  "aaa",
+						Amount: sdk.ZeroInt(),
+					},
+					ToCoinAmount: sdk.Coin{
+						Denom:  "bbb",
+						Amount: sdk.ZeroInt(),
+					},
+				},
+			},
+		}
+	}
+	checkTx := false
+	app := simapp.Setup(checkTx)
+	testdata.RegisterInterfaces(app.InterfaceRegistry())
+	testdata.RegisterMsgServer(app.MsgServiceRouter(), testdata.MsgServerImpl{})
+	ctx := app.BaseApp.NewContext(checkTx, tmproto.Header{})
+	keeper := app.FswapKeeper
+
+	tests := []struct {
+		name          string
+		genState      *types.GenesisState
+		expectedError error
+	}{
+		{
+			name:          "valid",
+			genState:      generateState(),
+			expectedError: nil,
+		},
+		{
+			name: "invalid: swapCount",
+			genState: func() *types.GenesisState {
+				state := generateState()
+				state.SwapStats.SwapCount = -1
+				return state
+			}(),
+			expectedError: types.ErrInvalidState,
+		},
+		{
+			name: "invalid: swaps count exceeds limit",
+			genState: func() *types.GenesisState {
+				state := generateState()
+				state.Swaps = append(state.Swaps, state.Swaps[0])
+				state.Swappeds = append(state.Swappeds, state.Swappeds[0])
+				state.SwapStats.SwapCount = 2
+				return state
+			}(),
+			expectedError: types.ErrCanNotHaveMoreSwap,
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			err := keeper.InitGenesis(ctx, tc.genState)
+			require.ErrorIs(t, tc.expectedError, err)
+		})
+	}
+}

x/fswap/keeper/grpc_query_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/Finschia/finschia-sdk/baseapp"
 	"github.com/Finschia/finschia-sdk/simapp"
 	sdk "github.com/Finschia/finschia-sdk/types"
+	"github.com/Finschia/finschia-sdk/types/query"
 	bank "github.com/Finschia/finschia-sdk/x/bank/types"
 	"github.com/Finschia/finschia-sdk/x/fswap/keeper"
 	"github.com/Finschia/finschia-sdk/x/fswap/types"
@@ -42,17 +43,17 @@ func (s *FSwapQueryTestSuite) SetupTest() {
 	s.queryClient = types.NewQueryClient(queryHelper)
 	s.keeper = s.app.FswapKeeper
 
-	pebSwapRateForCony, err := sdk.NewDecFromStr("148079656000000")
+	kaiSwapRateForCony, err := sdk.NewDecFromStr("148079656000000")
 	s.Require().NoError(err)
 	swapCap := sdk.NewInt(1000)
 	s.Require().NoError(err)
 	s.fromDenom = "cony"
-	s.toDenom = "kei"
+	s.toDenom = "kai"
 	s.swap = types.Swap{
 		FromDenom:           s.fromDenom,
 		ToDenom:             s.toDenom,
 		AmountCapForToDenom: swapCap,
-		SwapRate:            pebSwapRateForCony,
+		SwapRate:            kaiSwapRateForCony,
 	}
 	s.toDenomMetadata = bank.Metadata{
 		Description: "This is metadata for to-coin",
@@ -88,48 +89,229 @@ func (s *FSwapQueryTestSuite) SetupTest() {
 func (s *FSwapQueryTestSuite) TestQuerySwapRequest() {
 	tests := []struct {
 		name             string
-		FromDenom        string
-		ToDenom          string
-		wantErr          bool
+		request          *types.QuerySwapRequest
+		expectedResponse *types.QuerySwapResponse
 		expectedGrpcCode codes.Code
 	}{
 		{
-			name:             "valid",
-			FromDenom:        s.fromDenom,
-			ToDenom:          s.toDenom,
-			wantErr:          false,
+			name: "valid",
+			request: &types.QuerySwapRequest{
+				FromDenom: s.fromDenom,
+				ToDenom:   s.toDenom,
+			},
+			expectedResponse: &types.QuerySwapResponse{
+				Swap: types.Swap{
+					FromDenom:           s.swap.FromDenom,
+					ToDenom:             s.swap.ToDenom,
+					AmountCapForToDenom: s.swap.AmountCapForToDenom,
+					SwapRate:            s.swap.SwapRate,
+				},
+			},
 			expectedGrpcCode: codes.OK,
 		},
 		{
-			name:             "invalid: empty fromDenom",
-			FromDenom:        "",
-			ToDenom:          s.toDenom,
-			wantErr:          true,
+			name: "invalid: empty fromDenom",
+			request: &types.QuerySwapRequest{
+				FromDenom: "",
+				ToDenom:   s.toDenom,
+			},
 			expectedGrpcCode: codes.InvalidArgument,
 		},
 		{
-			name:             "invalid: empty toDenom",
-			FromDenom:        s.fromDenom,
-			ToDenom:          "",
-			wantErr:          true,
+			name: "invalid: empty toDenom",
+			request: &types.QuerySwapRequest{
+				FromDenom: s.fromDenom,
+				ToDenom:   "",
+			},
 			expectedGrpcCode: codes.InvalidArgument,
 		},
 		{
-			name:             "invalid: the same fromDenom and toDenom",
-			FromDenom:        s.fromDenom,
-			ToDenom:          s.fromDenom,
-			wantErr:          true,
+			name: "invalid: the same fromDenom and toDenom",
+			request: &types.QuerySwapRequest{
+				FromDenom: s.fromDenom,
+				ToDenom:   s.fromDenom,
+			},
 			expectedGrpcCode: codes.InvalidArgument,
 		},
+		{
+			name: "invalid: unregistered swap",
+			request: &types.QuerySwapRequest{
+				FromDenom: s.toDenom,
+				ToDenom:   s.fromDenom,
+			},
+			expectedGrpcCode: codes.NotFound,
+		},
+	}
+	for _, tc := range tests {
+		s.Run(tc.name, func() {
+			response, err := s.queryClient.Swap(s.ctx.Context(), tc.request)
+			s.Require().Equal(tc.expectedResponse, response)
+			actualGrpcCode := status.Code(err)
+			s.Require().Equal(tc.expectedGrpcCode, actualGrpcCode, actualGrpcCode.String())
+		})
+	}
+}
+
+func (s *FSwapQueryTestSuite) TestQuerySwappedRequest() {
+	tests := []struct {
+		name             string
+		request          *types.QuerySwappedRequest
+		expectedResponse *types.QuerySwappedResponse
+		expectedGrpcCode codes.Code
+	}{
+		{
+			name: "valid",
+			request: &types.QuerySwappedRequest{
+				FromDenom: s.fromDenom,
+				ToDenom:   s.toDenom,
+			},
+			expectedResponse: &types.QuerySwappedResponse{
+				FromCoinAmount: sdk.NewCoin(s.fromDenom, sdk.ZeroInt()),
+				ToCoinAmount:   sdk.NewCoin(s.toDenom, sdk.ZeroInt()),
+			},
+			expectedGrpcCode: codes.OK,
+		},
+		{
+			name: "invalid: empty fromDenom",
+			request: &types.QuerySwappedRequest{
+				FromDenom: "",
+				ToDenom:   s.toDenom,
+			},
+			expectedResponse: nil,
+			expectedGrpcCode: codes.Unknown,
+		},
+		{
+			name: "invalid: empty toDenom",
+			request: &types.QuerySwappedRequest{
+				FromDenom: s.fromDenom,
+				ToDenom:   "",
+			},
+			expectedResponse: nil,
+			expectedGrpcCode: codes.Unknown,
+		},
+		{
+			name: "invalid: unregistered swap",
+			request: &types.QuerySwappedRequest{
+				FromDenom: s.toDenom,
+				ToDenom:   s.fromDenom,
+			},
+			expectedResponse: nil,
+			expectedGrpcCode: codes.Unknown,
+		},
 	}
 	for _, tc := range tests {
 		s.Run(tc.name, func() {
-			m := &types.QuerySwapRequest{
-				FromDenom: tc.FromDenom,
-				ToDenom:   tc.ToDenom,
-			}
+			response, err := s.queryClient.Swapped(s.ctx.Context(), tc.request)
+			s.Require().Equal(tc.expectedResponse, response)
+			actualGrpcCode := status.Code(err)
+			s.Require().Equal(tc.expectedGrpcCode, actualGrpcCode, actualGrpcCode.String())
+		})
+	}
+}
 
-			_, err := s.queryClient.Swap(s.ctx.Context(), m)
+func (s *FSwapQueryTestSuite) TestQueryTotalSwappableToCoinAmountRequest() {
+	tests := []struct {
+		name             string
+		request          *types.QueryTotalSwappableToCoinAmountRequest
+		expectedResponse *types.QueryTotalSwappableToCoinAmountResponse
+		expectedGrpcCode codes.Code
+	}{
+		{
+			name: "valid",
+			request: &types.QueryTotalSwappableToCoinAmountRequest{
+				FromDenom: s.fromDenom,
+				ToDenom:   s.toDenom,
+			},
+			expectedResponse: &types.QueryTotalSwappableToCoinAmountResponse{
+				SwappableAmount: sdk.NewCoin(s.toDenom, s.swap.AmountCapForToDenom),
+			},
+			expectedGrpcCode: codes.OK,
+		},
+		{
+			name: "invalid: empty fromDenom",
+			request: &types.QueryTotalSwappableToCoinAmountRequest{
+				FromDenom: "",
+				ToDenom:   s.toDenom,
+			},
+			expectedResponse: nil,
+			expectedGrpcCode: codes.Unknown,
+		},
+		{
+			name: "invalid: empty toDenom",
+			request: &types.QueryTotalSwappableToCoinAmountRequest{
+				FromDenom: s.fromDenom,
+				ToDenom:   "",
+			},
+			expectedResponse: nil,
+			expectedGrpcCode: codes.Unknown,
+		},
+		{
+			name: "invalid: unregistered swap",
+			request: &types.QueryTotalSwappableToCoinAmountRequest{
+				FromDenom: s.toDenom,
+				ToDenom:   s.fromDenom,
+			},
+			expectedResponse: nil,
+			expectedGrpcCode: codes.Unknown,
+		},
+	}
+	for _, tc := range tests {
+		s.Run(tc.name, func() {
+			response, err := s.queryClient.TotalSwappableToCoinAmount(s.ctx.Context(), tc.request)
+			s.Require().Equal(tc.expectedResponse, response)
+			actualGrpcCode := status.Code(err)
+			s.Require().Equal(tc.expectedGrpcCode, actualGrpcCode, actualGrpcCode.String())
+		})
+	}
+}
+
+func (s *FSwapQueryTestSuite) TestQuerySwapsRequest() {
+	tests := []struct {
+		name             string
+		request          *types.QuerySwapsRequest
+		expectedResponse *types.QuerySwapsResponse
+		expectedGrpcCode codes.Code
+	}{
+		{
+			name: "valid",
+			request: &types.QuerySwapsRequest{
+				Pagination: nil,
+			},
+			expectedResponse: &types.QuerySwapsResponse{
+				Swaps: []types.Swap{
+					{
+						FromDenom:           s.swap.FromDenom,
+						ToDenom:             s.swap.ToDenom,
+						AmountCapForToDenom: s.swap.AmountCapForToDenom,
+						SwapRate:            s.swap.SwapRate,
+					},
+				},
+				Pagination: &query.PageResponse{
+					NextKey: nil,
+					Total:   1,
+				},
+			},
+			expectedGrpcCode: codes.OK,
+		},
+		{
+			name: "invalid request",
+			request: &types.QuerySwapsRequest{
+				Pagination: &query.PageRequest{
+					Key:        []byte("invalid-key"),
+					Offset:     1,
+					Limit:      0,
+					CountTotal: false,
+					Reverse:    false,
+				},
+			},
+			expectedResponse: nil,
+			expectedGrpcCode: codes.Unknown,
+		},
+	}
+	for _, tc := range tests {
+		s.Run(tc.name, func() {
+			response, err := s.queryClient.Swaps(s.ctx.Context(), tc.request)
+			s.Require().Equal(tc.expectedResponse, response)
 			actualGrpcCode := status.Code(err)
 			s.Require().Equal(tc.expectedGrpcCode, actualGrpcCode, actualGrpcCode.String())
 		})