laconicd-deprecated/x/auction/keeper/grpc_query_test.go

356 lines
8.4 KiB
Go
Raw Normal View History

package keeper_test
import (
"context"
"fmt"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/tharsis/ethermint/app"
"github.com/tharsis/ethermint/x/auction/types"
)
const testCommitHash = "71D8CF34026E32A3A34C2C2D4ADF25ABC8D7943A4619761BE27F196603D91B9D"
func (suite *KeeperTestSuite) TestGrpcGetAllAuctions() {
client, ctx, k := suite.queryClient, suite.ctx, suite.app.AuctionKeeper
testCases := []struct {
msg string
req *types.AuctionsRequest
createAuctions bool
auctionCount int
}{
{
"fetch auctions when no auctions exist",
&types.AuctionsRequest{},
false,
0,
},
{
"fetch auctions with one auction created",
&types.AuctionsRequest{},
true,
1,
},
}
for _, test := range testCases {
suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
if test.createAuctions {
account := app.CreateRandomAccounts(1)[0]
err := simapp.FundAccount(suite.app.BankKeeper, ctx, account, sdk.NewCoins(
sdk.Coin{Amount: sdk.NewInt(100), Denom: sdk.DefaultBondDenom},
))
_, err = k.CreateAuction(ctx, types.NewMsgCreateAuction(k.GetParams(ctx), account))
suite.Require().NoError(err)
}
resp, _ := client.Auctions(context.Background(), test.req)
suite.Require().Equal(test.auctionCount, len(resp.GetAuctions().Auctions))
})
}
}
func (suite *KeeperTestSuite) TestGrpcQueryParams() {
testCases := []struct {
msg string
req *types.QueryParamsRequest
}{
{
"fetch params",
&types.QueryParamsRequest{},
},
}
for _, test := range testCases {
suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
resp, err := suite.queryClient.QueryParams(context.Background(), test.req)
suite.Require().Nil(err)
suite.Require().Equal(*(resp.Params), types.DefaultParams())
})
}
}
func (suite *KeeperTestSuite) TestGrpcGetAuction() {
testCases := []struct {
msg string
req *types.AuctionRequest
createAuction bool
}{
{
"fetch auction with empty auction ID",
&types.AuctionRequest{},
false,
},
{
"fetch auction with valid auction ID",
&types.AuctionRequest{},
true,
},
}
for _, test := range testCases {
suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
if test.createAuction {
auction, _, err := suite.createAuctionAndCommitBid(false)
suite.Require().NoError(err)
test.req.Id = auction.Id
}
resp, err := suite.queryClient.GetAuction(context.Background(), test.req)
if test.createAuction {
suite.Require().Nil(err)
suite.Require().NotNil(resp.GetAuction())
suite.Require().Equal(test.req.Id, resp.GetAuction().Id)
} else {
suite.Require().NotNil(err)
suite.Require().Error(err)
}
})
}
}
func (suite *KeeperTestSuite) TestGrpcGetBids() {
testCases := []struct {
msg string
req *types.BidsRequest
createAuction bool
commitBid bool
bidCount int
}{
{
"fetch all bids when no auction exists",
&types.BidsRequest{},
false,
false,
0,
},
{
"fetch all bids for valid auction but no added bids",
&types.BidsRequest{},
true,
false,
0,
},
{
"fetch all bids for valid auction and valid bid",
&types.BidsRequest{},
true,
true,
1,
},
}
for _, test := range testCases {
suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
if test.createAuction {
auction, _, err := suite.createAuctionAndCommitBid(test.commitBid)
suite.Require().NoError(err)
test.req.AuctionId = auction.Id
}
resp, err := suite.queryClient.GetBids(context.Background(), test.req)
if test.createAuction {
suite.Require().Nil(err)
suite.Require().Equal(test.bidCount, len(resp.GetBids()))
} else {
suite.Require().NotNil(err)
suite.Require().Error(err)
}
})
}
}
func (suite *KeeperTestSuite) TestGrpcGetBid() {
testCases := []struct {
msg string
req *types.BidRequest
createAuctionAndBid bool
}{
{
"fetch bid when bid does not exist",
&types.BidRequest{},
false,
},
{
"fetch bid when valid bid exists",
&types.BidRequest{},
true,
},
}
for _, test := range testCases {
suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
if test.createAuctionAndBid {
auction, bid, err := suite.createAuctionAndCommitBid(test.createAuctionAndBid)
suite.Require().NoError(err)
test.req.AuctionId = auction.Id
test.req.Bidder = bid.BidderAddress
}
resp, err := suite.queryClient.GetBid(context.Background(), test.req)
if test.createAuctionAndBid {
suite.Require().NoError(err)
suite.Require().NotNil(resp.Bid)
suite.Require().Equal(test.req.Bidder, resp.Bid.BidderAddress)
} else {
suite.Require().NotNil(err)
suite.Require().Error(err)
}
})
}
}
func (suite *KeeperTestSuite) TestGrpcGetAuctionsByBidder() {
testCases := []struct {
msg string
req *types.AuctionsByBidderRequest
createAuctionAndCommitBid bool
auctionCount int
}{
{
"get auctions by bidder with invalid bidder address",
&types.AuctionsByBidderRequest{},
false,
0,
},
{
"get auctions by bidder with valid auction and bid",
&types.AuctionsByBidderRequest{},
true,
1,
},
}
for _, test := range testCases {
suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
if test.createAuctionAndCommitBid {
_, bid, err := suite.createAuctionAndCommitBid(test.createAuctionAndCommitBid)
suite.Require().NoError(err)
test.req.BidderAddress = bid.BidderAddress
}
resp, err := suite.queryClient.AuctionsByBidder(context.Background(), test.req)
if test.createAuctionAndCommitBid {
suite.Require().NoError(err)
suite.Require().NotNil(resp.Auctions)
suite.Require().Equal(test.auctionCount, len(resp.Auctions.Auctions))
} else {
suite.Require().NotNil(err)
suite.Require().Error(err)
}
})
}
}
func (suite *KeeperTestSuite) TestGrpcGetAuctionsByOwner() {
testCases := []struct {
msg string
req *types.AuctionsByOwnerRequest
createAuction bool
auctionCount int
}{
{
"get auctions by owner with invalid owner address",
&types.AuctionsByOwnerRequest{},
false,
0,
},
{
"get auctions by owner with valid auction",
&types.AuctionsByOwnerRequest{},
true,
1,
},
}
for _, test := range testCases {
suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
if test.createAuction {
auction, _, err := suite.createAuctionAndCommitBid(false)
suite.Require().NoError(err)
test.req.OwnerAddress = auction.OwnerAddress
}
resp, err := suite.queryClient.AuctionsByOwner(context.Background(), test.req)
if test.createAuction {
suite.Require().NoError(err)
suite.Require().NotNil(resp.Auctions)
suite.Require().Equal(test.auctionCount, len(resp.Auctions.Auctions))
} else {
suite.Require().NotNil(err)
suite.Require().Error(err)
}
})
}
}
func (suite KeeperTestSuite) TestGrpcQueryBalance() {
testCases := []struct {
msg string
req *types.BalanceRequest
createAuction bool
auctionCount int
}{
{
"get balance with no auctions created",
&types.BalanceRequest{},
false,
0,
},
{
"get balance with single auction created",
&types.BalanceRequest{},
true,
1,
},
}
for _, test := range testCases {
if test.createAuction {
_, _, err := suite.createAuctionAndCommitBid(true)
suite.Require().NoError(err)
}
resp, err := suite.queryClient.Balance(context.Background(), test.req)
suite.Require().NoError(err)
suite.Require().Equal(test.auctionCount, len(resp.GetBalance()))
}
}
func (suite *KeeperTestSuite) createAuctionAndCommitBid(commitBid bool) (*types.Auction, *types.Bid, error) {
ctx, k := suite.ctx, suite.app.AuctionKeeper
accCount := 1
if commitBid {
accCount++
}
accounts := app.CreateRandomAccounts(accCount)
for _, account := range accounts {
err := simapp.FundAccount(suite.app.BankKeeper, ctx, account, sdk.NewCoins(
sdk.Coin{Amount: sdk.NewInt(100), Denom: sdk.DefaultBondDenom},
))
if err != nil {
return nil, nil, err
}
}
auction, err := k.CreateAuction(ctx, types.NewMsgCreateAuction(k.GetParams(ctx), accounts[0]))
if err != nil {
return nil, nil, err
}
if commitBid {
bid, err := k.CommitBid(ctx, types.NewMsgCommitBid(auction.Id, testCommitHash, accounts[1]))
if err != nil {
return nil, nil, err
}
return auction, bid, nil
}
return auction, nil, nil
}