test: account/keeper tests for ICA

modules/apps/27-interchain-accounts/keeper/account.go

@@ -58,16 +58,3 @@ func (k Keeper) RegisterInterchainAccount(ctx sdk.Context, portID string) {
 	k.accountKeeper.SetAccount(ctx, interchainAccount)
 	k.SetInterchainAccountAddress(ctx, portID, interchainAccount.Address)
 }
-
-func (k Keeper) GetInterchainAccount(ctx sdk.Context, addr sdk.AccAddress) (types.InterchainAccount, error) {
-	acc := k.accountKeeper.GetAccount(ctx, addr)
-	if acc == nil {
-		return types.InterchainAccount{}, sdkerrors.Wrap(types.ErrInterchainAccountNotFound, "there is no account")
-	}
-
-	interchainAccount, ok := acc.(*types.InterchainAccount)
-	if !ok {
-		return types.InterchainAccount{}, sdkerrors.Wrap(types.ErrInterchainAccountNotFound, "account is not an interchain account")
-	}
-	return *interchainAccount, nil
-}

modules/apps/27-interchain-accounts/keeper/account_test.go

@@ -17,7 +17,6 @@ func (suite *KeeperTestSuite) TestInitInterchainAccount() {
 		malleate func()
 		expPass  bool
 	}{
-
 		{
 			"success", func() {}, true,
 		},
@@ -31,6 +30,11 @@ func (suite *KeeperTestSuite) TestInitInterchainAccount() {
 		   			}, false,
 		   		},
 		*/
+		{
+			"fails to generate port-id", func() {
+				owner = ""
+			}, false,
+		},
 		{
 			"MsgChanOpenInit fails - channel is already active", func() {
 				portID, err := types.GeneratePortID(owner, path.EndpointA.ConnectionID, path.EndpointB.ConnectionID)

modules/apps/27-interchain-accounts/keeper/handshake.go

@@ -112,23 +112,3 @@ func (k Keeper) OnChanOpenConfirm(
 ) error {
 	return nil
 }
-
-// May want to use these for re-opening a channel when it is closed
-//// OnChanCloseInit implements the IBCModule interface
-//func (am AppModule) OnChanCloseInit(
-//	ctx sdk.Context,
-//	portID,
-//	channelID string,
-//) error {
-//	// Disallow user-initiated channel closing for transfer channels
-//	return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "user cannot close channel")
-//}
-
-//// OnChanCloseConfirm implements the IBCModule interface
-//func (am AppModule) OnChanCloseConfirm(
-//	ctx sdk.Context,
-//	portID,
-//	channelID string,
-//) error {
-//	return nil
-//}

modules/apps/27-interchain-accounts/keeper/keeper_test.go

@@ -119,6 +119,20 @@ func (suite *KeeperTestSuite) TestGetInterchainAccountAddress() {
 	suite.Require().Empty(retrievedAddr)
 }
 
+func (suite *KeeperTestSuite) TestIsActiveChannel() {
+	suite.SetupTest() // reset
+	path := NewICAPath(suite.chainA, suite.chainB)
+	owner := "owner"
+	suite.coordinator.SetupConnections(path)
+
+	err := suite.SetupICAPath(path, owner)
+	suite.Require().NoError(err)
+	portID := path.EndpointA.ChannelConfig.PortID
+
+	isActive := suite.chainA.GetSimApp().ICAKeeper.IsActiveChannel(suite.chainA.GetContext(), portID)
+	suite.Require().Equal(isActive, true)
+}
+
 func (suite *KeeperTestSuite) TestSetInterchainAccountAddress() {
 	expectedAddr, portID := "address", "port"
 	suite.chainA.GetSimApp().ICAKeeper.SetInterchainAccountAddress(suite.chainA.GetContext(), portID, expectedAddr)

modules/apps/27-interchain-accounts/types/account.go

@@ -5,13 +5,12 @@ import (
 	"fmt"
 	"strings"
 
-	yaml "gopkg.in/yaml.v2"
-
 	crypto "github.com/cosmos/cosmos-sdk/crypto/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	"github.com/tendermint/tendermint/crypto/tmhash"
+	"gopkg.in/yaml.v2"
 
 	connectiontypes "github.com/cosmos/ibc-go/modules/core/03-connection/types"
 )
@@ -66,20 +65,24 @@ func NewInterchainAccount(ba *authtypes.BaseAccount, accountOwner string) *Inter
 }
 
 // SetPubKey - Implements AccountI
-func (InterchainAccount) SetPubKey(pubKey crypto.PubKey) error {
+func (ia InterchainAccount) SetPubKey(pubKey crypto.PubKey) error {
 	return fmt.Errorf("not supported for interchain accounts")
 }
 
 // SetSequence - Implements AccountI
-func (InterchainAccount) SetSequence(seq uint64) error {
+func (ia InterchainAccount) SetSequence(seq uint64) error {
 	return fmt.Errorf("not supported for interchain accounts")
 }
 
 func (ia InterchainAccount) Validate() error {
+	if strings.TrimSpace(ia.AccountOwner) == "" {
+		return fmt.Errorf("AccountOwner cannot be empty")
+	}
+
 	return ia.BaseAccount.Validate()
 }
 
-type ibcAccountPretty struct {
+type interchainAccountPretty struct {
 	Address       sdk.AccAddress `json:"address" yaml:"address"`
 	PubKey        string         `json:"public_key" yaml:"public_key"`
 	AccountNumber uint64         `json:"account_number" yaml:"account_number"`
@@ -99,7 +102,7 @@ func (ia InterchainAccount) MarshalYAML() (interface{}, error) {
 		return nil, err
 	}
 
-	bs, err := yaml.Marshal(ibcAccountPretty{
+	bs, err := yaml.Marshal(interchainAccountPretty{
 		Address:       accAddr,
 		PubKey:        "",
 		AccountNumber: ia.AccountNumber,
@@ -121,7 +124,7 @@ func (ia InterchainAccount) MarshalJSON() ([]byte, error) {
 		return nil, err
 	}
 
-	return json.Marshal(ibcAccountPretty{
+	return json.Marshal(interchainAccountPretty{
 		Address:       accAddr,
 		PubKey:        "",
 		AccountNumber: ia.AccountNumber,
@@ -132,7 +135,7 @@ func (ia InterchainAccount) MarshalJSON() ([]byte, error) {
 
 // UnmarshalJSON unmarshals raw JSON bytes into a ModuleAccount.
 func (ia *InterchainAccount) UnmarshalJSON(bz []byte) error {
-	var alias ibcAccountPretty
+	var alias interchainAccountPretty
 	if err := json.Unmarshal(bz, &alias); err != nil {
 		return err
 	}

modules/apps/27-interchain-accounts/types/account_test.go

@@ -1,12 +1,18 @@
 package types_test
 
 import (
+	"encoding/json"
 	"testing"
 
+	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	"github.com/stretchr/testify/suite"
+	"gopkg.in/yaml.v2"
+
 	"github.com/cosmos/ibc-go/modules/apps/27-interchain-accounts/types"
 	channeltypes "github.com/cosmos/ibc-go/modules/core/04-channel/types"
 	ibctesting "github.com/cosmos/ibc-go/testing"
-	"github.com/stretchr/testify/suite"
 )
 
 type TypesTestSuite struct {
@@ -88,3 +94,84 @@ func (suite *TypesTestSuite) TestGeneratePortID() {
 		})
 	}
 }
+
+func (suite *TypesTestSuite) TestInterchainAccount() {
+	pubkey := secp256k1.GenPrivKey().PubKey()
+	addr := sdk.AccAddress(pubkey.Address())
+	baseAcc := authtypes.NewBaseAccountWithAddress(addr)
+	interchainAcc := types.NewInterchainAccount(baseAcc, "account-owner-id")
+
+	// should fail when trying to set the public key or sequence of an interchain account
+	err := interchainAcc.SetPubKey(pubkey)
+	suite.Require().Error(err)
+	err = interchainAcc.SetSequence(1)
+	suite.Require().Error(err)
+}
+
+func (suite *TypesTestSuite) TestGenesisAccountValidate() {
+	pubkey := secp256k1.GenPrivKey().PubKey()
+	addr := sdk.AccAddress(pubkey.Address())
+	baseAcc := authtypes.NewBaseAccountWithAddress(addr)
+	pubkey = secp256k1.GenPrivKey().PubKey()
+	ownerAddr := sdk.AccAddress(pubkey.Address())
+
+	testCases := []struct {
+		name    string
+		acc     authtypes.GenesisAccount
+		expPass bool
+	}{
+		{
+			"interchain account with empty AccountOwner field",
+			types.NewInterchainAccount(baseAcc, ""),
+			false,
+		},
+		{
+			"success",
+			types.NewInterchainAccount(baseAcc, ownerAddr.String()),
+			true,
+		},
+	}
+
+	for _, tc := range testCases {
+		err := tc.acc.Validate()
+
+		if tc.expPass {
+			suite.Require().NoError(err)
+		} else {
+			suite.Require().Error(err)
+		}
+	}
+}
+
+func (suite *TypesTestSuite) TestInterchainAccountMarshalYAML() {
+	suite.SetupTest() // reset
+	addr, err := sdk.AccAddressFromHex("0000000000000000000000000000000000000000")
+	suite.Require().NoError(err)
+	ba := authtypes.NewBaseAccountWithAddress(addr)
+
+	interchainAcc := types.NewInterchainAccount(ba, "accountOwner")
+
+	bs, err := yaml.Marshal(interchainAcc)
+	suite.Require().NoError(err)
+
+	want := "|\n  address: cosmos1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqnrql8a\n  public_key: \"\"\n  account_number: 0\n  sequence: 0\n  account_owner: accountOwner\n"
+	suite.Require().Equal(want, string(bs))
+}
+
+func (suite *TypesTestSuite) TestInterchainAccountJSON() {
+	pubkey := secp256k1.GenPrivKey().PubKey()
+	addr := sdk.AccAddress(pubkey.Address())
+	baseAcc := authtypes.NewBaseAccountWithAddress(addr)
+
+	interchainAcc := types.NewInterchainAccount(baseAcc, "owner-address")
+
+	bz, err := json.Marshal(interchainAcc)
+	suite.Require().NoError(err)
+
+	bz1, err := interchainAcc.MarshalJSON()
+	suite.Require().NoError(err)
+	suite.Require().Equal(string(bz), string(bz1))
+
+	var a types.InterchainAccount
+	suite.Require().NoError(json.Unmarshal(bz, &a))
+}