Mukan Erkin Törük
88dd97a9f8
Some checks failed
CodeQL / Analyze (push) Waiting to run
golangci-lint / lint (push) Waiting to run
Tests / Code Coverage / build (amd64) (push) Waiting to run
Tests / Code Coverage / build (arm64) (push) Waiting to run
Tests / Code Coverage / unit-tests (map[additional-args:-tags="test_e2e" name:e2e path:./e2e]) (push) Waiting to run
Tests / Code Coverage / unit-tests (map[name:08-wasm path:./modules/light-clients/08-wasm]) (push) Waiting to run
Tests / Code Coverage / unit-tests (map[name:ibc-go path:.]) (push) Waiting to run
Docker Build & Push Simapp (main) / docker-build (push) Has been cancelled
364 lines
12 KiB
Go
364 lines
12 KiB
Go
package keeper_test
|
|
|
|
import (
|
|
"testing"
|
|
|
|
testifysuite "github.com/stretchr/testify/suite"
|
|
|
|
"git.cw.tr/mukan-network/mukan-sdk/runtime"
|
|
authtypes "git.cw.tr/mukan-network/mukan-sdk/x/auth/types"
|
|
govtypes "git.cw.tr/mukan-network/mukan-sdk/x/gov/types"
|
|
|
|
"git.cw.tr/mukan-network/mukan-ibc/modules/apps/27-interchain-accounts/controller/keeper"
|
|
"git.cw.tr/mukan-network/mukan-ibc/modules/apps/27-interchain-accounts/controller/types"
|
|
genesistypes "git.cw.tr/mukan-network/mukan-ibc/modules/apps/27-interchain-accounts/genesis/types"
|
|
icatypes "git.cw.tr/mukan-network/mukan-ibc/modules/apps/27-interchain-accounts/types"
|
|
channelkeeper "git.cw.tr/mukan-network/mukan-ibc/modules/core/04-channel/keeper"
|
|
channeltypes "git.cw.tr/mukan-network/mukan-ibc/modules/core/04-channel/types"
|
|
ibctesting "git.cw.tr/mukan-network/mukan-ibc/testing"
|
|
)
|
|
|
|
var (
|
|
// TestOwnerAddress defines a reusable bech32 address for testing purposes
|
|
TestOwnerAddress = "cosmos17dtl0mjt3t77kpuhg2edqzjpszulwhgzuj9ljs"
|
|
|
|
// TestPortID defines a reusable port identifier for testing purposes
|
|
TestPortID, _ = icatypes.NewControllerPortID(TestOwnerAddress)
|
|
|
|
// TestVersion defines a reusable interchainaccounts version string for testing purposes
|
|
TestVersion = string(icatypes.ModuleCdc.MustMarshalJSON(&icatypes.Metadata{
|
|
Version: icatypes.Version,
|
|
ControllerConnectionId: ibctesting.FirstConnectionID,
|
|
HostConnectionId: ibctesting.FirstConnectionID,
|
|
Encoding: icatypes.EncodingProtobuf,
|
|
TxType: icatypes.TxTypeSDKMultiMsg,
|
|
}))
|
|
)
|
|
|
|
type KeeperTestSuite struct {
|
|
testifysuite.Suite
|
|
|
|
coordinator *ibctesting.Coordinator
|
|
|
|
// testing chains used for convenience and readability
|
|
chainA *ibctesting.TestChain
|
|
chainB *ibctesting.TestChain
|
|
chainC *ibctesting.TestChain
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) SetupTest() {
|
|
suite.coordinator = ibctesting.NewCoordinator(suite.T(), 3)
|
|
suite.chainA = suite.coordinator.GetChain(ibctesting.GetChainID(1))
|
|
suite.chainB = suite.coordinator.GetChain(ibctesting.GetChainID(2))
|
|
suite.chainC = suite.coordinator.GetChain(ibctesting.GetChainID(3))
|
|
}
|
|
|
|
func NewICAPath(chainA, chainB *ibctesting.TestChain, ordering channeltypes.Order) *ibctesting.Path {
|
|
path := ibctesting.NewPath(chainA, chainB)
|
|
path.EndpointA.ChannelConfig.PortID = icatypes.HostPortID
|
|
path.EndpointB.ChannelConfig.PortID = icatypes.HostPortID
|
|
path.EndpointA.ChannelConfig.Order = ordering
|
|
path.EndpointB.ChannelConfig.Order = ordering
|
|
path.EndpointA.ChannelConfig.Version = TestVersion
|
|
path.EndpointB.ChannelConfig.Version = TestVersion
|
|
|
|
return path
|
|
}
|
|
|
|
// SetupICAPath invokes the InterchainAccounts entrypoint and subsequent channel handshake handlers
|
|
func SetupICAPath(path *ibctesting.Path, owner string) error {
|
|
if err := RegisterInterchainAccount(path.EndpointA, owner); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := path.EndpointB.ChanOpenTry(); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := path.EndpointA.ChanOpenAck(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return path.EndpointB.ChanOpenConfirm()
|
|
}
|
|
|
|
// RegisterInterchainAccount is a helper function for starting the channel handshake
|
|
func RegisterInterchainAccount(endpoint *ibctesting.Endpoint, owner string) error {
|
|
portID, err := icatypes.NewControllerPortID(owner)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
channelSequence := endpoint.Chain.App.GetIBCKeeper().ChannelKeeper.GetNextChannelSequence(endpoint.Chain.GetContext())
|
|
|
|
if err := endpoint.Chain.GetSimApp().ICAControllerKeeper.RegisterInterchainAccount(endpoint.Chain.GetContext(), endpoint.ConnectionID, owner, TestVersion, endpoint.ChannelConfig.Order); err != nil {
|
|
return err
|
|
}
|
|
|
|
// commit state changes for proof verification
|
|
endpoint.Chain.NextBlock()
|
|
|
|
// update port/channel ids
|
|
endpoint.ChannelID = channeltypes.FormatChannelIdentifier(channelSequence)
|
|
endpoint.ChannelConfig.PortID = portID
|
|
|
|
return nil
|
|
}
|
|
|
|
func TestKeeperTestSuite(t *testing.T) {
|
|
testifysuite.Run(t, new(KeeperTestSuite))
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestNewKeeper() {
|
|
testCases := []struct {
|
|
name string
|
|
instantiateFn func()
|
|
errMsg string
|
|
}{
|
|
{"success", func() {
|
|
keeper.NewKeeper(
|
|
suite.chainA.GetSimApp().AppCodec(),
|
|
runtime.NewKVStoreService(suite.chainA.GetSimApp().GetKey(types.StoreKey)),
|
|
suite.chainA.GetSimApp().GetSubspace(types.SubModuleName),
|
|
suite.chainA.GetSimApp().IBCKeeper.ChannelKeeper,
|
|
suite.chainA.GetSimApp().IBCKeeper.ChannelKeeper,
|
|
suite.chainA.GetSimApp().MsgServiceRouter(),
|
|
suite.chainA.GetSimApp().ICAControllerKeeper.GetAuthority(),
|
|
)
|
|
}, ""},
|
|
{"failure: empty authority", func() {
|
|
keeper.NewKeeper(
|
|
suite.chainA.GetSimApp().AppCodec(),
|
|
runtime.NewKVStoreService(suite.chainA.GetSimApp().GetKey(types.StoreKey)),
|
|
suite.chainA.GetSimApp().GetSubspace(types.SubModuleName),
|
|
suite.chainA.GetSimApp().IBCKeeper.ChannelKeeper,
|
|
suite.chainA.GetSimApp().IBCKeeper.ChannelKeeper,
|
|
suite.chainA.GetSimApp().MsgServiceRouter(),
|
|
"", // authority
|
|
)
|
|
}, "authority must be non-empty"},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
|
|
suite.SetupTest()
|
|
|
|
suite.Run(tc.name, func() {
|
|
if tc.errMsg == "" {
|
|
suite.Require().NotPanics(
|
|
tc.instantiateFn,
|
|
)
|
|
} else {
|
|
suite.Require().PanicsWithError(
|
|
tc.errMsg,
|
|
tc.instantiateFn,
|
|
)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestGetAllPorts() {
|
|
for _, ordering := range []channeltypes.Order{channeltypes.UNORDERED, channeltypes.ORDERED} {
|
|
suite.SetupTest()
|
|
|
|
path := NewICAPath(suite.chainA, suite.chainB, ordering)
|
|
path.SetupConnections()
|
|
|
|
err := SetupICAPath(path, TestOwnerAddress)
|
|
suite.Require().NoError(err)
|
|
|
|
expectedPorts := []string{TestPortID}
|
|
|
|
ports := suite.chainA.GetSimApp().ICAControllerKeeper.GetAllPorts(suite.chainA.GetContext())
|
|
suite.Require().Len(ports, len(expectedPorts))
|
|
suite.Require().Equal(expectedPorts, ports)
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestGetInterchainAccountAddress() {
|
|
for _, ordering := range []channeltypes.Order{channeltypes.UNORDERED, channeltypes.ORDERED} {
|
|
suite.SetupTest()
|
|
|
|
path := NewICAPath(suite.chainA, suite.chainB, ordering)
|
|
path.SetupConnections()
|
|
|
|
err := SetupICAPath(path, TestOwnerAddress)
|
|
suite.Require().NoError(err)
|
|
|
|
counterpartyPortID := path.EndpointA.ChannelConfig.PortID
|
|
|
|
retrievedAddr, found := suite.chainA.GetSimApp().ICAControllerKeeper.GetInterchainAccountAddress(suite.chainA.GetContext(), ibctesting.FirstConnectionID, counterpartyPortID)
|
|
suite.Require().True(found)
|
|
suite.Require().NotEmpty(retrievedAddr)
|
|
|
|
retrievedAddr, found = suite.chainA.GetSimApp().ICAControllerKeeper.GetInterchainAccountAddress(suite.chainA.GetContext(), "invalid conn", "invalid port")
|
|
suite.Require().False(found)
|
|
suite.Require().Empty(retrievedAddr)
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestGetAllActiveChannels() {
|
|
for _, ordering := range []channeltypes.Order{channeltypes.UNORDERED, channeltypes.ORDERED} {
|
|
var (
|
|
expectedChannelID = "test-channel"
|
|
expectedPortID = "test-port"
|
|
)
|
|
|
|
suite.SetupTest()
|
|
|
|
path := NewICAPath(suite.chainA, suite.chainB, ordering)
|
|
path.SetupConnections()
|
|
|
|
err := SetupICAPath(path, TestOwnerAddress)
|
|
suite.Require().NoError(err)
|
|
|
|
suite.chainA.GetSimApp().ICAControllerKeeper.SetActiveChannelID(suite.chainA.GetContext(), ibctesting.FirstConnectionID, expectedPortID, expectedChannelID)
|
|
|
|
expectedChannels := []genesistypes.ActiveChannel{
|
|
{
|
|
ConnectionId: ibctesting.FirstConnectionID,
|
|
PortId: TestPortID,
|
|
ChannelId: path.EndpointA.ChannelID,
|
|
IsMiddlewareEnabled: true,
|
|
},
|
|
{
|
|
ConnectionId: ibctesting.FirstConnectionID,
|
|
PortId: expectedPortID,
|
|
ChannelId: expectedChannelID,
|
|
IsMiddlewareEnabled: false,
|
|
},
|
|
}
|
|
|
|
activeChannels := suite.chainA.GetSimApp().ICAControllerKeeper.GetAllActiveChannels(suite.chainA.GetContext())
|
|
suite.Require().Len(activeChannels, len(expectedChannels))
|
|
suite.Require().Equal(expectedChannels, activeChannels)
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestGetAllInterchainAccounts() {
|
|
for _, ordering := range []channeltypes.Order{channeltypes.UNORDERED, channeltypes.ORDERED} {
|
|
var (
|
|
expectedAccAddr = "test-acc-addr"
|
|
expectedPortID = "test-port"
|
|
)
|
|
|
|
suite.SetupTest()
|
|
|
|
path := NewICAPath(suite.chainA, suite.chainB, ordering)
|
|
path.SetupConnections()
|
|
|
|
err := SetupICAPath(path, TestOwnerAddress)
|
|
suite.Require().NoError(err)
|
|
|
|
interchainAccAddr, exists := suite.chainB.GetSimApp().ICAHostKeeper.GetInterchainAccountAddress(suite.chainB.GetContext(), path.EndpointB.ConnectionID, path.EndpointA.ChannelConfig.PortID)
|
|
suite.Require().True(exists)
|
|
|
|
suite.chainA.GetSimApp().ICAControllerKeeper.SetInterchainAccountAddress(suite.chainA.GetContext(), ibctesting.FirstConnectionID, expectedPortID, expectedAccAddr)
|
|
|
|
expectedAccounts := []genesistypes.RegisteredInterchainAccount{
|
|
{
|
|
ConnectionId: ibctesting.FirstConnectionID,
|
|
PortId: TestPortID,
|
|
AccountAddress: interchainAccAddr,
|
|
},
|
|
{
|
|
ConnectionId: ibctesting.FirstConnectionID,
|
|
PortId: expectedPortID,
|
|
AccountAddress: expectedAccAddr,
|
|
},
|
|
}
|
|
|
|
interchainAccounts := suite.chainA.GetSimApp().ICAControllerKeeper.GetAllInterchainAccounts(suite.chainA.GetContext())
|
|
suite.Require().Len(interchainAccounts, len(expectedAccounts))
|
|
suite.Require().Equal(expectedAccounts, interchainAccounts)
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestIsActiveChannel() {
|
|
for _, ordering := range []channeltypes.Order{channeltypes.UNORDERED, channeltypes.ORDERED} {
|
|
suite.SetupTest()
|
|
|
|
path := NewICAPath(suite.chainA, suite.chainB, ordering)
|
|
owner := TestOwnerAddress
|
|
path.SetupConnections()
|
|
|
|
err := SetupICAPath(path, owner)
|
|
suite.Require().NoError(err)
|
|
portID := path.EndpointA.ChannelConfig.PortID
|
|
|
|
isActive := suite.chainA.GetSimApp().ICAControllerKeeper.IsActiveChannel(suite.chainA.GetContext(), ibctesting.FirstConnectionID, portID)
|
|
suite.Require().Equal(isActive, true)
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestSetInterchainAccountAddress() {
|
|
var (
|
|
expectedAccAddr = "test-acc-addr"
|
|
expectedPortID = "test-port"
|
|
)
|
|
|
|
suite.chainA.GetSimApp().ICAControllerKeeper.SetInterchainAccountAddress(suite.chainA.GetContext(), ibctesting.FirstConnectionID, expectedPortID, expectedAccAddr)
|
|
|
|
retrievedAddr, found := suite.chainA.GetSimApp().ICAControllerKeeper.GetInterchainAccountAddress(suite.chainA.GetContext(), ibctesting.FirstConnectionID, expectedPortID)
|
|
suite.Require().True(found)
|
|
suite.Require().Equal(expectedAccAddr, retrievedAddr)
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestSetAndGetParams() {
|
|
testCases := []struct {
|
|
name string
|
|
input types.Params
|
|
}{
|
|
{"success: set params false", types.NewParams(false)},
|
|
{"success: set params true", types.NewParams(true)},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
suite.Run(tc.name, func() {
|
|
suite.SetupTest() // reset
|
|
ctx := suite.chainA.GetContext()
|
|
|
|
suite.chainA.GetSimApp().ICAControllerKeeper.SetParams(ctx, tc.input)
|
|
expected := tc.input
|
|
p := suite.chainA.GetSimApp().ICAControllerKeeper.GetParams(ctx)
|
|
suite.Require().Equal(expected, p)
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestUnsetParams() {
|
|
suite.SetupTest()
|
|
|
|
ctx := suite.chainA.GetContext()
|
|
store := suite.chainA.GetContext().KVStore(suite.chainA.GetSimApp().GetKey(types.SubModuleName))
|
|
store.Delete([]byte(types.ParamsKey))
|
|
|
|
suite.Require().Panics(func() {
|
|
suite.chainA.GetSimApp().ICAControllerKeeper.GetParams(ctx)
|
|
})
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestGetAuthority() {
|
|
suite.SetupTest()
|
|
|
|
authority := suite.chainA.GetSimApp().ICAControllerKeeper.GetAuthority()
|
|
expectedAuth := authtypes.NewModuleAddress(govtypes.ModuleName).String()
|
|
suite.Require().Equal(expectedAuth, authority)
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestWithICS4Wrapper() {
|
|
suite.SetupTest()
|
|
|
|
// test if the ics4 wrapper is the channel keeper initially
|
|
ics4Wrapper := suite.chainA.GetSimApp().ICAControllerKeeper.GetICS4Wrapper()
|
|
|
|
_, isChannelKeeper := ics4Wrapper.(*channelkeeper.Keeper)
|
|
suite.Require().True(isChannelKeeper)
|
|
suite.Require().IsType((*channelkeeper.Keeper)(nil), ics4Wrapper)
|
|
|
|
// set the ics4 wrapper to the channel keeper
|
|
suite.chainA.GetSimApp().ICAControllerKeeper.WithICS4Wrapper(nil)
|
|
ics4Wrapper = suite.chainA.GetSimApp().ICAControllerKeeper.GetICS4Wrapper()
|
|
suite.Require().Nil(ics4Wrapper)
|
|
}
|