certusone
/
cosmos-sdk
mirror of https://github.com/certusone/cosmos-sdk.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Add a mock application module to test core IBC (#7187) 

* update setup to use channeltype and add mock app module

* rm print statement

* claim channel cap

* fix up test

* Update x/ibc/testing/coordinator.go

Co-authored-by: Federico Kunze <31522760+fedekunze@users.noreply.github.com>

* apply @fedekunze review suggestions

Co-authored-by: Aditya Sripal <adityasripal@gmail.com>
Co-authored-by: Federico Kunze <31522760+fedekunze@users.noreply.github.com>
This commit is contained in:
colin axnér 2020-08-31 15:58:23 +02:00 committed by GitHub
parent 91ff9fa417
commit 843bd24bca
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
21 changed files with 494 additions and 288 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
docs/ibc/overview.md
View File

@ -33,6 +33,7 @@ other blockchains, along with the proof spec necessary to properly verify proofs
client's consensus state. A client may be associated with any number of connections to multiple client's consensus state. A client may be associated with any number of connections to multiple
chains. The supported IBC clients are: chains. The supported IBC clients are:
* [Solo Machine light client](https://github.com/cosmos/cosmos-sdk/tree/master/x/ibc/light-clients/solomachine): devices such as phones, browsers, or laptops.
* [Tendermint light client](https://github.com/cosmos/cosmos-sdk/tree/master/x/ibc/07-tendermint): The default for SDK-based chains, * [Tendermint light client](https://github.com/cosmos/cosmos-sdk/tree/master/x/ibc/07-tendermint): The default for SDK-based chains,
* [Localhost (loopback) client](https://github.com/cosmos/cosmos-sdk/tree/master/x/ibc/09-localhost): Useful for * [Localhost (loopback) client](https://github.com/cosmos/cosmos-sdk/tree/master/x/ibc/09-localhost): Useful for
testing, simulation and relaying packets to modules on the same application. testing, simulation and relaying packets to modules on the same application.

14
simapp/app.go
View File

@ -55,6 +55,7 @@ import (
porttypes "github.com/cosmos/cosmos-sdk/x/ibc/05-port/types" porttypes "github.com/cosmos/cosmos-sdk/x/ibc/05-port/types"
ibchost "github.com/cosmos/cosmos-sdk/x/ibc/24-host" ibchost "github.com/cosmos/cosmos-sdk/x/ibc/24-host"
ibckeeper "github.com/cosmos/cosmos-sdk/x/ibc/keeper" ibckeeper "github.com/cosmos/cosmos-sdk/x/ibc/keeper"
ibcmock "github.com/cosmos/cosmos-sdk/x/ibc/testing/mock"
"github.com/cosmos/cosmos-sdk/x/mint" "github.com/cosmos/cosmos-sdk/x/mint"
mintkeeper "github.com/cosmos/cosmos-sdk/x/mint/keeper" mintkeeper "github.com/cosmos/cosmos-sdk/x/mint/keeper"
minttypes "github.com/cosmos/cosmos-sdk/x/mint/types" minttypes "github.com/cosmos/cosmos-sdk/x/mint/types"
@ -158,6 +159,7 @@ type SimApp struct {
// make scoped keepers public for test purposes // make scoped keepers public for test purposes
ScopedIBCKeeper capabilitykeeper.ScopedKeeper ScopedIBCKeeper capabilitykeeper.ScopedKeeper
ScopedTransferKeeper capabilitykeeper.ScopedKeeper ScopedTransferKeeper capabilitykeeper.ScopedKeeper
ScopedIBCMockKeeper capabilitykeeper.ScopedKeeper
// the module manager // the module manager
mm *module.Manager mm *module.Manager
@ -212,6 +214,9 @@ func NewSimApp(
app.CapabilityKeeper = capabilitykeeper.NewKeeper(appCodec, keys[capabilitytypes.StoreKey], memKeys[capabilitytypes.MemStoreKey]) app.CapabilityKeeper = capabilitykeeper.NewKeeper(appCodec, keys[capabilitytypes.StoreKey], memKeys[capabilitytypes.MemStoreKey])
scopedIBCKeeper := app.CapabilityKeeper.ScopeToModule(ibchost.ModuleName) scopedIBCKeeper := app.CapabilityKeeper.ScopeToModule(ibchost.ModuleName)
scopedTransferKeeper := app.CapabilityKeeper.ScopeToModule(ibctransfertypes.ModuleName) scopedTransferKeeper := app.CapabilityKeeper.ScopeToModule(ibctransfertypes.ModuleName)
// NOTE: the IBC mock keeper and application module is used only for testing core IBC. Do
// note replicate if you do not need to test core IBC or light clients.
scopedIBCMockKeeper := app.CapabilityKeeper.ScopeToModule(ibcmock.ModuleName)
// add keepers // add keepers
app.AccountKeeper = authkeeper.NewAccountKeeper( app.AccountKeeper = authkeeper.NewAccountKeeper(
@ -269,9 +274,14 @@ func NewSimApp(
) )
transferModule := transfer.NewAppModule(app.TransferKeeper) transferModule := transfer.NewAppModule(app.TransferKeeper)
// NOTE: the IBC mock keeper and application module is used only for testing core IBC. Do
// note replicate if you do not need to test core IBC or light clients.
mockModule := ibcmock.NewAppModule(scopedIBCMockKeeper)
// Create static IBC router, add transfer route, then set and seal it // Create static IBC router, add transfer route, then set and seal it
ibcRouter := porttypes.NewRouter() ibcRouter := porttypes.NewRouter()
ibcRouter.AddRoute(ibctransfertypes.ModuleName, transferModule) ibcRouter.AddRoute(ibctransfertypes.ModuleName, transferModule)
ibcRouter.AddRoute(ibcmock.ModuleName, mockModule)
app.IBCKeeper.SetRouter(ibcRouter) app.IBCKeeper.SetRouter(ibcRouter)
// create evidence keeper with router // create evidence keeper with router
@ -386,6 +396,10 @@ func NewSimApp(
app.ScopedIBCKeeper = scopedIBCKeeper app.ScopedIBCKeeper = scopedIBCKeeper
app.ScopedTransferKeeper = scopedTransferKeeper app.ScopedTransferKeeper = scopedTransferKeeper
// NOTE: the IBC mock keeper and application module is used only for testing core IBC. Do
// note replicate if you do not need to test core IBC or light clients.
app.ScopedIBCMockKeeper = scopedIBCMockKeeper
return app return app
} }

4
x/ibc-transfer/handler_test.go
View File

@ -7,6 +7,7 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types" sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/ibc-transfer/types" "github.com/cosmos/cosmos-sdk/x/ibc-transfer/types"
clientexported "github.com/cosmos/cosmos-sdk/x/ibc/02-client/exported"
channeltypes "github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types" channeltypes "github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types"
ibctesting "github.com/cosmos/cosmos-sdk/x/ibc/testing" ibctesting "github.com/cosmos/cosmos-sdk/x/ibc/testing"
) )
@ -30,7 +31,8 @@ func (suite *HandlerTestSuite) SetupTest() {
// constructs a send from chainA to chainB on the established channel/connection // constructs a send from chainA to chainB on the established channel/connection
// and sends the same coin back from chainB to chainA. // and sends the same coin back from chainB to chainA.
func (suite *HandlerTestSuite) TestHandleMsgTransfer() { func (suite *HandlerTestSuite) TestHandleMsgTransfer() {
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, channeltypes.UNORDERED)
originalBalance := suite.chainA.App.BankKeeper.GetBalance(suite.chainA.GetContext(), suite.chainA.SenderAccount.GetAddress(), sdk.DefaultBondDenom) originalBalance := suite.chainA.App.BankKeeper.GetBalance(suite.chainA.GetContext(), suite.chainA.SenderAccount.GetAddress(), sdk.DefaultBondDenom)
coinToSendToB := sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100)) coinToSendToB := sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100))

12
x/ibc-transfer/module.go
View File

@ -36,7 +36,7 @@ var (
_ module.AppModuleBasic = AppModuleBasic{} _ module.AppModuleBasic = AppModuleBasic{}
) )
// AppModuleBasic is the 20-transfer appmodulebasic // AppModuleBasic is the IBC Transfer AppModuleBasic
type AppModuleBasic struct{} type AppModuleBasic struct{}
// Name implements AppModuleBasic interface // Name implements AppModuleBasic interface
@ -47,6 +47,11 @@ func (AppModuleBasic) Name() string {
// RegisterCodec implements AppModuleBasic interface // RegisterCodec implements AppModuleBasic interface
func (AppModuleBasic) RegisterCodec(*codec.LegacyAmino) {} func (AppModuleBasic) RegisterCodec(*codec.LegacyAmino) {}
// RegisterInterfaces registers module concrete types into protobuf Any.
func (AppModuleBasic) RegisterInterfaces(registry codectypes.InterfaceRegistry) {
types.RegisterInterfaces(registry)
}
// DefaultGenesis returns default genesis state as raw bytes for the ibc // DefaultGenesis returns default genesis state as raw bytes for the ibc
// transfer module. // transfer module.
func (AppModuleBasic) DefaultGenesis(cdc codec.JSONMarshaler) json.RawMessage { func (AppModuleBasic) DefaultGenesis(cdc codec.JSONMarshaler) json.RawMessage {
@ -81,11 +86,6 @@ func (AppModuleBasic) GetQueryCmd() *cobra.Command {
return cli.GetQueryCmd() return cli.GetQueryCmd()
} }
// RegisterInterfaces registers module concrete types into protobuf Any.
func (AppModuleBasic) RegisterInterfaces(registry codectypes.InterfaceRegistry) {
types.RegisterInterfaces(registry)
}
// AppModule represents the AppModule for this module // AppModule represents the AppModule for this module
type AppModule struct { type AppModule struct {
AppModuleBasic AppModuleBasic

5
x/ibc/03-connection/keeper/grpc_query_test.go
View File

@ -8,6 +8,7 @@ import (
clientexported "github.com/cosmos/cosmos-sdk/x/ibc/02-client/exported" clientexported "github.com/cosmos/cosmos-sdk/x/ibc/02-client/exported"
clienttypes "github.com/cosmos/cosmos-sdk/x/ibc/02-client/types" clienttypes "github.com/cosmos/cosmos-sdk/x/ibc/02-client/types"
"github.com/cosmos/cosmos-sdk/x/ibc/03-connection/types" "github.com/cosmos/cosmos-sdk/x/ibc/03-connection/types"
channeltypes "github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types"
ibctesting "github.com/cosmos/cosmos-sdk/x/ibc/testing" ibctesting "github.com/cosmos/cosmos-sdk/x/ibc/testing"
) )
@ -268,7 +269,7 @@ func (suite *KeeperTestSuite) TestQueryConnectionClientState() {
{ {
"client state not found", "client state not found",
func() { func() {
_, _, connA, _, _, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, _, _, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
// set connection to empty so clientID is empty // set connection to empty so clientID is empty
suite.chainA.App.IBCKeeper.ConnectionKeeper.SetConnection(suite.chainA.GetContext(), connA.ID, types.ConnectionEnd{}) suite.chainA.App.IBCKeeper.ConnectionKeeper.SetConnection(suite.chainA.GetContext(), connA.ID, types.ConnectionEnd{})
@ -356,7 +357,7 @@ func (suite *KeeperTestSuite) TestQueryConnectionConsensusState() {
{ {
"consensus state not found", "consensus state not found",
func() { func() {
_, _, connA, _, _, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, _, _, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
req = &types.QueryConnectionConsensusStateRequest{ req = &types.QueryConnectionConsensusStateRequest{
ConnectionId: connA.ID, ConnectionId: connA.ID,

10
x/ibc/03-connection/keeper/verify_test.go
View File

@ -216,7 +216,7 @@ func (suite *KeeperTestSuite) TestVerifyChannelState() {
suite.Run(fmt.Sprintf("Case %s", tc.msg), func() { suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
suite.SetupTest() // reset suite.SetupTest() // reset
_, _, connA, _, _, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, _, _, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
connection := suite.chainA.GetConnection(connA) connection := suite.chainA.GetConnection(connA)
if tc.changeClientID { if tc.changeClientID {
connection.ClientId = ibctesting.InvalidID connection.ClientId = ibctesting.InvalidID
@ -267,7 +267,7 @@ func (suite *KeeperTestSuite) TestVerifyPacketCommitment() {
suite.Run(tc.msg, func() { suite.Run(tc.msg, func() {
suite.SetupTest() // reset suite.SetupTest() // reset
_, clientB, _, connB, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, clientB, _, connB, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
connection := suite.chainB.GetConnection(connB) connection := suite.chainB.GetConnection(connB)
if tc.changeClientID { if tc.changeClientID {
connection.ClientId = ibctesting.InvalidID connection.ClientId = ibctesting.InvalidID
@ -321,7 +321,7 @@ func (suite *KeeperTestSuite) TestVerifyPacketAcknowledgement() {
suite.Run(tc.msg, func() { suite.Run(tc.msg, func() {
suite.SetupTest() // reset suite.SetupTest() // reset
clientA, clientB, connA, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, connA, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
connection := suite.chainA.GetConnection(connA) connection := suite.chainA.GetConnection(connA)
if tc.changeClientID { if tc.changeClientID {
connection.ClientId = ibctesting.InvalidID connection.ClientId = ibctesting.InvalidID
@ -380,7 +380,7 @@ func (suite *KeeperTestSuite) TestVerifyPacketAcknowledgementAbsence() {
suite.Run(tc.msg, func() { suite.Run(tc.msg, func() {
suite.SetupTest() // reset suite.SetupTest() // reset
clientA, clientB, connA, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, connA, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
connection := suite.chainA.GetConnection(connA) connection := suite.chainA.GetConnection(connA)
if tc.changeClientID { if tc.changeClientID {
connection.ClientId = ibctesting.InvalidID connection.ClientId = ibctesting.InvalidID
@ -440,7 +440,7 @@ func (suite *KeeperTestSuite) TestVerifyNextSequenceRecv() {
suite.Run(tc.msg, func() { suite.Run(tc.msg, func() {
suite.SetupTest() // reset suite.SetupTest() // reset
clientA, clientB, connA, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, connA, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
connection := suite.chainA.GetConnection(connA) connection := suite.chainA.GetConnection(connA)
if tc.changeClientID { if tc.changeClientID {
connection.ClientId = ibctesting.InvalidID connection.ClientId = ibctesting.InvalidID

38
x/ibc/04-channel/keeper/grpc_query_test.go
View File

@ -126,7 +126,7 @@ func (suite *KeeperTestSuite) TestQueryChannels() {
{ {
"success", "success",
func() { func() {
_, _, connA0, connB0, testchannel0, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA0, connB0, testchannel0, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// channel0 on first connection on chainA // channel0 on first connection on chainA
counterparty0 := types.Counterparty{ counterparty0 := types.Counterparty{
PortId: connB0.Channels[0].PortID, PortId: connB0.Channels[0].PortID,
@ -134,7 +134,7 @@ func (suite *KeeperTestSuite) TestQueryChannels() {
} }
// channel1 is second channel on first connection on chainA // channel1 is second channel on first connection on chainA
testchannel1, _ := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA0, connB0, types.ORDERED) testchannel1, _ := suite.coordinator.CreateMockChannels(suite.chainA, suite.chainB, connA0, connB0, types.ORDERED)
counterparty1 := types.Counterparty{ counterparty1 := types.Counterparty{
PortId: connB0.Channels[1].PortID, PortId: connB0.Channels[1].PortID,
ChannelId: connB0.Channels[1].ID, ChannelId: connB0.Channels[1].ID,
@ -217,7 +217,7 @@ func (suite *KeeperTestSuite) TestQueryConnectionChannels() {
{ {
"success", "success",
func() { func() {
_, _, connA0, connB0, testchannel0, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA0, connB0, testchannel0, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// channel0 on first connection on chainA // channel0 on first connection on chainA
counterparty0 := types.Counterparty{ counterparty0 := types.Counterparty{
PortId: connB0.Channels[0].PortID, PortId: connB0.Channels[0].PortID,
@ -225,7 +225,7 @@ func (suite *KeeperTestSuite) TestQueryConnectionChannels() {
} }
// channel1 is second channel on first connection on chainA // channel1 is second channel on first connection on chainA
testchannel1, _ := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA0, connB0, types.ORDERED) testchannel1, _ := suite.coordinator.CreateMockChannels(suite.chainA, suite.chainB, connA0, connB0, types.ORDERED)
counterparty1 := types.Counterparty{ counterparty1 := types.Counterparty{
PortId: connB0.Channels[1].PortID, PortId: connB0.Channels[1].PortID,
ChannelId: connB0.Channels[1].ID, ChannelId: connB0.Channels[1].ID,
@ -259,7 +259,7 @@ func (suite *KeeperTestSuite) TestQueryConnectionChannels() {
{ {
"success, empty response", "success, empty response",
func() { func() {
suite.coordinator.Setup(suite.chainA, suite.chainB) suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
expChannels = []*types.IdentifiedChannel{} expChannels = []*types.IdentifiedChannel{}
req = &types.QueryConnectionChannelsRequest{ req = &types.QueryConnectionChannelsRequest{
Connection: "externalConnID", Connection: "externalConnID",
@ -345,7 +345,7 @@ func (suite *KeeperTestSuite) TestQueryChannelClientState() {
{ {
"connection not found", "connection not found",
func() { func() {
_, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
channel := suite.chainA.GetChannel(channelA) channel := suite.chainA.GetChannel(channelA)
// update channel to reference a connection that does not exist // update channel to reference a connection that does not exist
@ -363,7 +363,7 @@ func (suite *KeeperTestSuite) TestQueryChannelClientState() {
{ {
"client state for channel's connection not found", "client state for channel's connection not found",
func() { func() {
_, _, connA, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// set connection to empty so clientID is empty // set connection to empty so clientID is empty
suite.chainA.App.IBCKeeper.ConnectionKeeper.SetConnection(suite.chainA.GetContext(), connA.ID, connectiontypes.ConnectionEnd{}) suite.chainA.App.IBCKeeper.ConnectionKeeper.SetConnection(suite.chainA.GetContext(), connA.ID, connectiontypes.ConnectionEnd{})
@ -469,7 +469,7 @@ func (suite *KeeperTestSuite) TestQueryChannelConsensusState() {
{ {
"connection not found", "connection not found",
func() { func() {
_, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
channel := suite.chainA.GetChannel(channelA) channel := suite.chainA.GetChannel(channelA)
// update channel to reference a connection that does not exist // update channel to reference a connection that does not exist
@ -488,7 +488,7 @@ func (suite *KeeperTestSuite) TestQueryChannelConsensusState() {
{ {
"consensus state for channel's connection not found", "consensus state for channel's connection not found",
func() { func() {
_, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
req = &types.QueryChannelConsensusStateRequest{ req = &types.QueryChannelConsensusStateRequest{
PortId: channelA.PortID, PortId: channelA.PortID,
@ -606,7 +606,7 @@ func (suite *KeeperTestSuite) TestQueryPacketCommitment() {
{ {
"success", "success",
func() { func() {
_, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
expCommitment = []byte("hash") expCommitment = []byte("hash")
suite.chainA.App.IBCKeeper.ChannelKeeper.SetPacketCommitment(suite.chainA.GetContext(), channelA.PortID, channelA.ID, 1, expCommitment) suite.chainA.App.IBCKeeper.ChannelKeeper.SetPacketCommitment(suite.chainA.GetContext(), channelA.PortID, channelA.ID, 1, expCommitment)
@ -688,7 +688,7 @@ func (suite *KeeperTestSuite) TestQueryPacketCommitments() {
{ {
"success", "success",
func() { func() {
_, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
expCommitments = make([]*types.PacketAckCommitment, 9) expCommitments = make([]*types.PacketAckCommitment, 9)
@ -795,7 +795,7 @@ func (suite *KeeperTestSuite) TestQueryPacketAcknowledgement() {
{ {
"success", "success",
func() { func() {
_, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
expAck = []byte("hash") expAck = []byte("hash")
suite.chainA.App.IBCKeeper.ChannelKeeper.SetPacketAcknowledgement(suite.chainA.GetContext(), channelA.PortID, channelA.ID, 1, expAck) suite.chainA.App.IBCKeeper.ChannelKeeper.SetPacketAcknowledgement(suite.chainA.GetContext(), channelA.PortID, channelA.ID, 1, expAck)
@ -881,7 +881,7 @@ func (suite *KeeperTestSuite) TestQueryUnrelayedPackets() {
{ {
"basic success unrelayed packet commitments", "basic success unrelayed packet commitments",
func() { func() {
_, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// no ack exists // no ack exists
@ -898,7 +898,7 @@ func (suite *KeeperTestSuite) TestQueryUnrelayedPackets() {
{ {
"basic success unrelayed packet commitments, nothing to relay", "basic success unrelayed packet commitments, nothing to relay",
func() { func() {
_, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// ack exists // ack exists
ack := types.NewPacketAckCommitment(channelA.PortID, channelA.ID, 1, []byte("hash")) ack := types.NewPacketAckCommitment(channelA.PortID, channelA.ID, 1, []byte("hash"))
@ -917,7 +917,7 @@ func (suite *KeeperTestSuite) TestQueryUnrelayedPackets() {
{ {
"basic success unrelayed acknowledgements", "basic success unrelayed acknowledgements",
func() { func() {
_, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// ack exists // ack exists
ack := types.NewPacketAckCommitment(channelA.PortID, channelA.ID, 1, []byte("hash")) ack := types.NewPacketAckCommitment(channelA.PortID, channelA.ID, 1, []byte("hash"))
@ -936,7 +936,7 @@ func (suite *KeeperTestSuite) TestQueryUnrelayedPackets() {
{ {
"basic success unrelayed acknowledgements, nothing to relay", "basic success unrelayed acknowledgements, nothing to relay",
func() { func() {
_, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// no ack exists // no ack exists
@ -953,7 +953,7 @@ func (suite *KeeperTestSuite) TestQueryUnrelayedPackets() {
{ {
"success multiple unrelayed packet commitments", "success multiple unrelayed packet commitments",
func() { func() {
_, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
expSeq = []uint64{} // reset expSeq = []uint64{} // reset
packetCommitments := []uint64{} packetCommitments := []uint64{}
@ -981,7 +981,7 @@ func (suite *KeeperTestSuite) TestQueryUnrelayedPackets() {
{ {
"success multiple unrelayed acknowledgements", "success multiple unrelayed acknowledgements",
func() { func() {
_, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
expSeq = []uint64{} // reset expSeq = []uint64{} // reset
packetCommitments := []uint64{} packetCommitments := []uint64{}
@ -1077,7 +1077,7 @@ func (suite *KeeperTestSuite) TestQueryNextSequenceReceive() {
{ {
"success", "success",
func() { func() {
_, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
expSeq = 1 expSeq = 1
suite.chainA.App.IBCKeeper.ChannelKeeper.SetNextSequenceRecv(suite.chainA.GetContext(), channelA.PortID, channelA.ID, expSeq) suite.chainA.App.IBCKeeper.ChannelKeeper.SetNextSequenceRecv(suite.chainA.GetContext(), channelA.PortID, channelA.ID, expSeq)

26
x/ibc/04-channel/keeper/handshake_test.go
View File

@ -37,7 +37,7 @@ func (suite *KeeperTestSuite) TestChanOpenInit() {
portCap = suite.chainA.GetPortCapability(connA.NextTestChannel(ibctesting.TransferPort).PortID) portCap = suite.chainA.GetPortCapability(connA.NextTestChannel(ibctesting.TransferPort).PortID)
}, true}, }, true},
{"channel already exists", func() { {"channel already exists", func() {
_, _, connA, connB, _, _ = suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, connB, _, _ = suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
}, false}, }, false},
{"connection doesn't exist", func() { {"connection doesn't exist", func() {
// any non-nil values of connA and connB are acceptable // any non-nil values of connA and connB are acceptable
@ -308,7 +308,7 @@ func (suite *KeeperTestSuite) TestChanOpenAck() {
{"channel doesn't exist", func() {}, false}, {"channel doesn't exist", func() {}, false},
{"channel state is not INIT or TRYOPEN", func() { {"channel state is not INIT or TRYOPEN", func() {
// create fully open channels on both chains // create fully open channels on both chains
_, _, connA, connB, _, _ = suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, connB, _, _ = suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
channelA := connA.Channels[0] channelA := connA.Channels[0]
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, false}, }, false},
@ -430,7 +430,7 @@ func (suite *KeeperTestSuite) TestChanOpenConfirm() {
{"channel doesn't exist", func() {}, false}, {"channel doesn't exist", func() {}, false},
{"channel state is not TRYOPEN", func() { {"channel state is not TRYOPEN", func() {
// create fully open channels on both cahins // create fully open channels on both cahins
_, _, connA, connB, _, _ = suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, connB, _, _ = suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
channelB := connB.Channels[0] channelB := connB.Channels[0]
channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID) channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID)
}, false}, }, false},
@ -542,7 +542,7 @@ func (suite *KeeperTestSuite) TestChanCloseInit() {
testCases := []testCase{ testCases := []testCase{
{"success", func() { {"success", func() {
_, _, connA, connB, _, _ = suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, connB, _, _ = suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
channelA := connA.Channels[0] channelA := connA.Channels[0]
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, true}, }, true},
@ -557,7 +557,7 @@ func (suite *KeeperTestSuite) TestChanCloseInit() {
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, false}, }, false},
{"channel state is CLOSED", func() { {"channel state is CLOSED", func() {
_, _, connA, connB, _, _ = suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, connB, _, _ = suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
channelA := connA.Channels[0] channelA := connA.Channels[0]
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
@ -566,7 +566,7 @@ func (suite *KeeperTestSuite) TestChanCloseInit() {
suite.Require().NoError(err) suite.Require().NoError(err)
}, false}, }, false},
{"connection not found", func() { {"connection not found", func() {
_, _, connA, connB, _, _ = suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, connB, _, _ = suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
channelA := connA.Channels[0] channelA := connA.Channels[0]
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
@ -590,7 +590,7 @@ func (suite *KeeperTestSuite) TestChanCloseInit() {
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, false}, }, false},
{"channel capability not found", func() { {"channel capability not found", func() {
_, _, connA, connB, _, _ = suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, connB, _, _ = suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
channelCap = capabilitytypes.NewCapability(3) channelCap = capabilitytypes.NewCapability(3)
}, false}, }, false},
} }
@ -632,7 +632,7 @@ func (suite *KeeperTestSuite) TestChanCloseConfirm() {
testCases := []testCase{ testCases := []testCase{
{"success", func() { {"success", func() {
_, _, connA, connB, channelA, channelB = suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, connB, channelA, channelB = suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID) channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID)
err := suite.coordinator.SetChannelClosed(suite.chainA, suite.chainB, channelA) err := suite.coordinator.SetChannelClosed(suite.chainA, suite.chainB, channelA)
@ -649,14 +649,14 @@ func (suite *KeeperTestSuite) TestChanCloseConfirm() {
channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID) channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID)
}, false}, }, false},
{"channel state is CLOSED", func() { {"channel state is CLOSED", func() {
_, _, connA, connB, _, channelB = suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, connB, _, channelB = suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID) channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID)
err := suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, channelB) err := suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, channelB)
suite.Require().NoError(err) suite.Require().NoError(err)
}, false}, }, false},
{"connection not found", func() { {"connection not found", func() {
_, _, connA, connB, _, channelB = suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, connB, _, channelB = suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID) channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID)
// set the channel's connection hops to wrong connection ID // set the channel's connection hops to wrong connection ID
@ -680,7 +680,7 @@ func (suite *KeeperTestSuite) TestChanCloseConfirm() {
channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID) channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID)
}, false}, }, false},
{"consensus state not found", func() { {"consensus state not found", func() {
_, _, connA, connB, _, channelB = suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, connB, channelA, channelB = suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID) channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID)
err := suite.coordinator.SetChannelClosed(suite.chainA, suite.chainB, channelA) err := suite.coordinator.SetChannelClosed(suite.chainA, suite.chainB, channelA)
@ -690,11 +690,11 @@ func (suite *KeeperTestSuite) TestChanCloseConfirm() {
}, false}, }, false},
{"channel verification failed", func() { {"channel verification failed", func() {
// channel not closed // channel not closed
_, _, connA, connB, _, channelB = suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, connB, _, channelB = suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID) channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID)
}, false}, }, false},
{"channel capability not found", func() { {"channel capability not found", func() {
_, _, connA, connB, channelA, channelB = suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, connB, channelA, channelB = suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID) channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID)
err := suite.coordinator.SetChannelClosed(suite.chainA, suite.chainB, channelA) err := suite.coordinator.SetChannelClosed(suite.chainA, suite.chainB, channelA)

20
x/ibc/04-channel/keeper/keeper_test.go
View File

@ -60,7 +60,7 @@ func (suite *KeeperTestSuite) TestSetChannel() {
// TestGetAllChannels creates multiple channels on chain A through various connections // TestGetAllChannels creates multiple channels on chain A through various connections
// and tests their retrieval. 2 channels are on connA0 and 1 channel is on connA1 // and tests their retrieval. 2 channels are on connA0 and 1 channel is on connA1
func (suite KeeperTestSuite) TestGetAllChannels() { func (suite KeeperTestSuite) TestGetAllChannels() {
clientA, clientB, connA0, connB0, testchannel0, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, connA0, connB0, testchannel0, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// channel0 on first connection on chainA // channel0 on first connection on chainA
counterparty0 := types.Counterparty{ counterparty0 := types.Counterparty{
PortId: connB0.Channels[0].PortID, PortId: connB0.Channels[0].PortID,
@ -68,7 +68,7 @@ func (suite KeeperTestSuite) TestGetAllChannels() {
} }
// channel1 is second channel on first connection on chainA // channel1 is second channel on first connection on chainA
testchannel1, _ := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA0, connB0, types.ORDERED) testchannel1, _ := suite.coordinator.CreateMockChannels(suite.chainA, suite.chainB, connA0, connB0, types.ORDERED)
counterparty1 := types.Counterparty{ counterparty1 := types.Counterparty{
PortId: connB0.Channels[1].PortID, PortId: connB0.Channels[1].PortID,
ChannelId: connB0.Channels[1].ID, ChannelId: connB0.Channels[1].ID,
@ -114,8 +114,8 @@ func (suite KeeperTestSuite) TestGetAllChannels() {
// TestGetAllSequences sets all packet sequences for two different channels on chain A and // TestGetAllSequences sets all packet sequences for two different channels on chain A and
// tests their retrieval. // tests their retrieval.
func (suite KeeperTestSuite) TestGetAllSequences() { func (suite KeeperTestSuite) TestGetAllSequences() {
_, _, connA, connB, channelA0, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, connB, channelA0, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
channelA1, _ := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.UNORDERED) channelA1, _ := suite.coordinator.CreateMockChannels(suite.chainA, suite.chainB, connA, connB, types.UNORDERED)
seq1 := types.NewPacketSequence(channelA0.PortID, channelA0.ID, 1) seq1 := types.NewPacketSequence(channelA0.PortID, channelA0.ID, 1)
seq2 := types.NewPacketSequence(channelA0.PortID, channelA0.ID, 2) seq2 := types.NewPacketSequence(channelA0.PortID, channelA0.ID, 2)
@ -147,8 +147,8 @@ func (suite KeeperTestSuite) TestGetAllSequences() {
// TestGetAllCommitmentsAcks creates a set of acks and packet commitments on two different // TestGetAllCommitmentsAcks creates a set of acks and packet commitments on two different
// channels on chain A and tests their retrieval. // channels on chain A and tests their retrieval.
func (suite KeeperTestSuite) TestGetAllCommitmentsAcks() { func (suite KeeperTestSuite) TestGetAllCommitmentsAcks() {
_, _, connA, connB, channelA0, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, connB, channelA0, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
channelA1, _ := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.UNORDERED) channelA1, _ := suite.coordinator.CreateMockChannels(suite.chainA, suite.chainB, connA, connB, types.UNORDERED)
// channel 0 acks // channel 0 acks
ack1 := types.NewPacketAckCommitment(channelA0.PortID, channelA0.ID, 1, []byte("ack")) ack1 := types.NewPacketAckCommitment(channelA0.PortID, channelA0.ID, 1, []byte("ack"))
@ -194,7 +194,7 @@ func (suite KeeperTestSuite) TestGetAllCommitmentsAcks() {
// TestSetSequence verifies that the keeper correctly sets the sequence counters. // TestSetSequence verifies that the keeper correctly sets the sequence counters.
func (suite *KeeperTestSuite) TestSetSequence() { func (suite *KeeperTestSuite) TestSetSequence() {
_, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
ctxA := suite.chainA.GetContext() ctxA := suite.chainA.GetContext()
one := uint64(1) one := uint64(1)
@ -237,10 +237,10 @@ func (suite *KeeperTestSuite) TestSetSequence() {
// value of "seq" and then add non-consecutive up to the value of "maxSeq". A final commitment // value of "seq" and then add non-consecutive up to the value of "maxSeq". A final commitment
// with the value maxSeq + 1 is set on a different channel. // with the value maxSeq + 1 is set on a different channel.
func (suite *KeeperTestSuite) TestGetAllPacketCommitmentsAtChannel() { func (suite *KeeperTestSuite) TestGetAllPacketCommitmentsAtChannel() {
_, _, connA, connB, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, connB, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// create second channel // create second channel
channelA1, _ := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.UNORDERED) channelA1, _ := suite.coordinator.CreateMockChannels(suite.chainA, suite.chainB, connA, connB, types.UNORDERED)
ctxA := suite.chainA.GetContext() ctxA := suite.chainA.GetContext()
expectedSeqs := make(map[uint64]bool) expectedSeqs := make(map[uint64]bool)
@ -286,7 +286,7 @@ func (suite *KeeperTestSuite) TestGetAllPacketCommitmentsAtChannel() {
// TestSetPacketAcknowledgement verifies that packet acknowledgements are correctly // TestSetPacketAcknowledgement verifies that packet acknowledgements are correctly
// set in the keeper. // set in the keeper.
func (suite *KeeperTestSuite) TestSetPacketAcknowledgement() { func (suite *KeeperTestSuite) TestSetPacketAcknowledgement() {
_, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
ctxA := suite.chainA.GetContext() ctxA := suite.chainA.GetContext()
seq := uint64(10) seq := uint64(10)

99
x/ibc/04-channel/keeper/packet_test.go
View File

@ -37,54 +37,52 @@ func (suite *KeeperTestSuite) TestSendPacket() {
testCases := []testCase{ testCases := []testCase{
{"success: UNORDERED channel", func() { {"success: UNORDERED channel", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, true}, }, true},
{"success: ORDERED channel", func() { {"success: ORDERED channel", func() {
_, _, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, true}, }, true},
{"sending packet out of order on UNORDERED channel", func() { {"sending packet out of order on UNORDERED channel", func() {
// setup creates an unordered channel // setup creates an unordered channel
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 5, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 5, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, false}, }, false},
{"sending packet out of order on ORDERED channel", func() { {"sending packet out of order on ORDERED channel", func() {
_, _, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 5, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 5, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, false}, }, false},
{"packet basic validation failed, empty packet data", func() { {"packet basic validation failed, empty packet data", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket([]byte{}, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket([]byte{}, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, false}, }, false},
{"channel not found", func() { {"channel not found", func() {
// use wrong channel naming // use wrong channel naming
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, ibctesting.InvalidID, ibctesting.InvalidID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, ibctesting.InvalidID, ibctesting.InvalidID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, false}, }, false},
{"channel closed", func() { {"channel closed", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
err := suite.coordinator.SetChannelClosed(suite.chainA, suite.chainB, channelA) err := suite.coordinator.SetChannelClosed(suite.chainA, suite.chainB, channelA)
suite.Require().NoError(err) suite.Require().NoError(err)
}, false}, }, false},
{"packet dest port ≠ channel counterparty port", func() { {"packet dest port ≠ channel counterparty port", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// use wrong port for dest // use wrong port for dest
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, ibctesting.InvalidID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, ibctesting.InvalidID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, false}, }, false},
{"packet dest channel ID ≠ channel counterparty channel ID", func() { {"packet dest channel ID ≠ channel counterparty channel ID", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// use wrong channel for dest // use wrong channel for dest
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, ibctesting.InvalidID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, ibctesting.InvalidID, timeoutHeight, disabledTimeoutTimestamp)
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
@ -121,7 +119,7 @@ func (suite *KeeperTestSuite) TestSendPacket() {
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, false}, }, false},
{"client state not found", func() { {"client state not found", func() {
_, _, connA, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, connA, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// change connection client ID // change connection client ID
connection := suite.chainA.GetConnection(connA) connection := suite.chainA.GetConnection(connA)
@ -132,14 +130,14 @@ func (suite *KeeperTestSuite) TestSendPacket() {
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, false}, }, false},
{"timeout height passed", func() { {"timeout height passed", func() {
clientA, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// use client state latest height for timeout // use client state latest height for timeout
clientState := suite.chainA.GetClientState(clientA) clientState := suite.chainA.GetClientState(clientA)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, clientState.GetLatestHeight(), disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, clientState.GetLatestHeight(), disabledTimeoutTimestamp)
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, false}, }, false},
{"timeout timestamp passed", func() { {"timeout timestamp passed", func() {
clientA, _, connA, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, _, connA, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// use latest time on client state // use latest time on client state
clientState := suite.chainA.GetClientState(clientA) clientState := suite.chainA.GetClientState(clientA)
connection := suite.chainA.GetConnection(connA) connection := suite.chainA.GetConnection(connA)
@ -164,13 +162,13 @@ func (suite *KeeperTestSuite) TestSendPacket() {
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, false}, }, false},
{"next sequence wrong", func() { {"next sequence wrong", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
suite.chainA.App.IBCKeeper.ChannelKeeper.SetNextSequenceSend(suite.chainA.GetContext(), channelA.PortID, channelA.ID, 5) suite.chainA.App.IBCKeeper.ChannelKeeper.SetNextSequenceSend(suite.chainA.GetContext(), channelA.PortID, channelA.ID, 5)
channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) channelCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, false}, }, false},
{"channel capability not found", func() { {"channel capability not found", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
channelCap = capabilitytypes.NewCapability(5) channelCap = capabilitytypes.NewCapability(5)
}, false}, }, false},
@ -205,22 +203,21 @@ func (suite *KeeperTestSuite) TestRecvPacket() {
testCases := []testCase{ testCases := []testCase{
{"success: ORDERED channel", func() { {"success: ORDERED channel", func() {
_, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) _, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err) suite.Require().NoError(err)
}, true}, }, true},
{"success UNORDERED channel", func() { {"success UNORDERED channel", func() {
// setup uses an UNORDERED channel // setup uses an UNORDERED channel
_, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err) suite.Require().NoError(err)
}, true}, }, true},
{"success with out of order packet: UNORDERED channel", func() { {"success with out of order packet: UNORDERED channel", func() {
// setup uses an UNORDERED channel // setup uses an UNORDERED channel
_, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
// send 2 packets // send 2 packets
@ -233,8 +230,7 @@ func (suite *KeeperTestSuite) TestRecvPacket() {
// attempts to receive packet 2 without receiving packet 1 // attempts to receive packet 2 without receiving packet 1
}, true}, }, true},
{"out of order packet failure with ORDERED channel", func() { {"out of order packet failure with ORDERED channel", func() {
_, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) _, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
// send 2 packets // send 2 packets
@ -248,23 +244,23 @@ func (suite *KeeperTestSuite) TestRecvPacket() {
}, false}, }, false},
{"channel not found", func() { {"channel not found", func() {
// use wrong channel naming // use wrong channel naming
_, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, ibctesting.InvalidID, ibctesting.InvalidID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, ibctesting.InvalidID, ibctesting.InvalidID, timeoutHeight, disabledTimeoutTimestamp)
}, false}, }, false},
{"channel not open", func() { {"channel not open", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
err := suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, channelB) err := suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, channelB)
suite.Require().NoError(err) suite.Require().NoError(err)
}, false}, }, false},
{"packet source port ≠ channel counterparty port", func() { {"packet source port ≠ channel counterparty port", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// use wrong port for dest // use wrong port for dest
packet = types.NewPacket(validPacketData, 1, ibctesting.InvalidID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, ibctesting.InvalidID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
}, false}, }, false},
{"packet source channel ID ≠ channel counterparty channel ID", func() { {"packet source channel ID ≠ channel counterparty channel ID", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// use wrong port for dest // use wrong port for dest
packet = types.NewPacket(validPacketData, 1, channelA.PortID, ibctesting.InvalidID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, ibctesting.InvalidID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
}, false}, }, false},
@ -296,16 +292,16 @@ func (suite *KeeperTestSuite) TestRecvPacket() {
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
}, false}, }, false},
{"timeout height passed", func() { {"timeout height passed", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), disabledTimeoutTimestamp)
}, false}, }, false},
{"timeout timestamp passed", func() { {"timeout timestamp passed", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, disabledTimeoutHeight, uint64(suite.chainB.GetContext().BlockTime().UnixNano())) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, disabledTimeoutHeight, uint64(suite.chainB.GetContext().BlockTime().UnixNano()))
}, false}, }, false},
{"acknowledgement already received", func() { {"acknowledgement already received", func() {
// setup uses an UNORDERED channel // setup uses an UNORDERED channel
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
@ -331,7 +327,7 @@ func (suite *KeeperTestSuite) TestRecvPacket() {
}, false}, }, false},
{"validation failed", func() { {"validation failed", func() {
// packet commitment not set resulting in invalid proof // packet commitment not set resulting in invalid proof
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
}, false}, }, false},
} }
@ -369,26 +365,25 @@ func (suite *KeeperTestSuite) TestPacketExecuted() {
testCases := []testCase{ testCases := []testCase{
{"success: UNORDERED", func() { {"success: UNORDERED", func() {
// setup uses an UNORDERED channel // setup uses an UNORDERED channel
_, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID) channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID)
}, true}, }, true},
{"success: ORDERED", func() { {"success: ORDERED", func() {
_, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) _, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID) channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID)
}, true}, }, true},
{"channel not found", func() { {"channel not found", func() {
// use wrong channel naming // use wrong channel naming
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, ibctesting.InvalidID, ibctesting.InvalidID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, ibctesting.InvalidID, ibctesting.InvalidID, timeoutHeight, disabledTimeoutTimestamp)
channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID) channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID)
}, false}, }, false},
{"channel not OPEN", func() { {"channel not OPEN", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
err := suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, channelB) err := suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, channelB)
@ -409,15 +404,14 @@ func (suite *KeeperTestSuite) TestPacketExecuted() {
channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID) channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID)
}, false}, }, false},
{"capability not found", func() { {"capability not found", func() {
_, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) _, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
channelCap = capabilitytypes.NewCapability(3) channelCap = capabilitytypes.NewCapability(3)
}, false}, }, false},
{"acknowledgement is empty", func() { {"acknowledgement is empty", func() {
_, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID) channelCap = suite.chainB.GetChannelCapability(channelB.PortID, channelB.ID)
@ -457,8 +451,7 @@ func (suite *KeeperTestSuite) TestAcknowledgePacket() {
testCases := []testCase{ testCases := []testCase{
{"success on ordered channel", func() { {"success on ordered channel", func() {
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
// create packet commitment // create packet commitment
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
@ -470,7 +463,7 @@ func (suite *KeeperTestSuite) TestAcknowledgePacket() {
}, true}, }, true},
{"success on unordered channel", func() { {"success on unordered channel", func() {
// setup uses an UNORDERED channel // setup uses an UNORDERED channel
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
// create packet commitment // create packet commitment
@ -483,23 +476,23 @@ func (suite *KeeperTestSuite) TestAcknowledgePacket() {
}, true}, }, true},
{"channel not found", func() { {"channel not found", func() {
// use wrong channel naming // use wrong channel naming
_, _, _, _, _, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, _, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, ibctesting.InvalidID, ibctesting.InvalidID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, ibctesting.InvalidID, ibctesting.InvalidID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
}, false}, }, false},
{"channel not open", func() { {"channel not open", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
err := suite.coordinator.SetChannelClosed(suite.chainA, suite.chainB, channelA) err := suite.coordinator.SetChannelClosed(suite.chainA, suite.chainB, channelA)
suite.Require().NoError(err) suite.Require().NoError(err)
}, false}, }, false},
{"packet destination port ≠ channel counterparty port", func() { {"packet destination port ≠ channel counterparty port", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// use wrong port for dest // use wrong port for dest
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, ibctesting.InvalidID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, ibctesting.InvalidID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
}, false}, }, false},
{"packet destination channel ID ≠ channel counterparty channel ID", func() { {"packet destination channel ID ≠ channel counterparty channel ID", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// use wrong channel for dest // use wrong channel for dest
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, ibctesting.InvalidID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, ibctesting.InvalidID, timeoutHeight, disabledTimeoutTimestamp)
}, false}, }, false},
@ -532,12 +525,12 @@ func (suite *KeeperTestSuite) TestAcknowledgePacket() {
}, false}, }, false},
{"packet hasn't been sent", func() { {"packet hasn't been sent", func() {
// packet commitment never written // packet commitment never written
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
}, false}, }, false},
{"packet ack verification failed", func() { {"packet ack verification failed", func() {
// ack never written // ack never written
_, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
// create packet commitment // create packet commitment
@ -561,8 +554,7 @@ func (suite *KeeperTestSuite) TestAcknowledgePacket() {
suite.chainB.App.IBCKeeper.ChannelKeeper.SetPacketAcknowledgement(suite.chainB.GetContext(), channelB.PortID, channelB.ID, packet.GetSequence(), ibctesting.TestHash) suite.chainB.App.IBCKeeper.ChannelKeeper.SetPacketAcknowledgement(suite.chainB.GetContext(), channelB.PortID, channelB.ID, packet.GetSequence(), ibctesting.TestHash)
}, false}, }, false},
{"next ack sequence mismatch", func() { {"next ack sequence mismatch", func() {
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
// create packet commitment // create packet commitment
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
@ -607,8 +599,7 @@ func (suite *KeeperTestSuite) TestAcknowledgementExecuted() {
testCases := []testCase{ testCases := []testCase{
{"success ORDERED", func() { {"success ORDERED", func() {
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
@ -625,7 +616,7 @@ func (suite *KeeperTestSuite) TestAcknowledgementExecuted() {
}, true}, }, true},
{"success UNORDERED", func() { {"success UNORDERED", func() {
// setup uses an UNORDERED channel // setup uses an UNORDERED channel
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
// create packet commitment // create packet commitment
@ -640,11 +631,11 @@ func (suite *KeeperTestSuite) TestAcknowledgementExecuted() {
}, true}, }, true},
{"channel not found", func() { {"channel not found", func() {
// use wrong channel naming // use wrong channel naming
_, _, _, _, _, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, _, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, ibctesting.InvalidID, ibctesting.InvalidID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, ibctesting.InvalidID, ibctesting.InvalidID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
}, false}, }, false},
{"incorrect capability", func() { {"incorrect capability", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
chanCap = capabilitytypes.NewCapability(100) chanCap = capabilitytypes.NewCapability(100)

63
x/ibc/04-channel/keeper/timeout_test.go
View File

@ -24,8 +24,7 @@ func (suite *KeeperTestSuite) TestTimeoutPacket() {
{"success: ORDERED", func() { {"success: ORDERED", func() {
ordered = true ordered = true
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano())) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano()))
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
// need to update chainA's client representing chainB to prove missing ack // need to update chainA's client representing chainB to prove missing ack
@ -34,7 +33,7 @@ func (suite *KeeperTestSuite) TestTimeoutPacket() {
{"success: UNORDERED", func() { {"success: UNORDERED", func() {
ordered = false ordered = false
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), disabledTimeoutTimestamp)
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
// need to update chainA's client representing chainB to prove missing ack // need to update chainA's client representing chainB to prove missing ack
@ -42,23 +41,23 @@ func (suite *KeeperTestSuite) TestTimeoutPacket() {
}, true}, }, true},
{"channel not found", func() { {"channel not found", func() {
// use wrong channel naming // use wrong channel naming
_, _, _, _, _, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, _, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, ibctesting.InvalidID, ibctesting.InvalidID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, ibctesting.InvalidID, ibctesting.InvalidID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
}, false}, }, false},
{"channel not open", func() { {"channel not open", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
err := suite.coordinator.SetChannelClosed(suite.chainA, suite.chainB, channelA) err := suite.coordinator.SetChannelClosed(suite.chainA, suite.chainB, channelA)
suite.Require().NoError(err) suite.Require().NoError(err)
}, false}, }, false},
{"packet destination port ≠ channel counterparty port", func() { {"packet destination port ≠ channel counterparty port", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// use wrong port for dest // use wrong port for dest
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, ibctesting.InvalidID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, ibctesting.InvalidID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
}, false}, }, false},
{"packet destination channel ID ≠ channel counterparty channel ID", func() { {"packet destination channel ID ≠ channel counterparty channel ID", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// use wrong channel for dest // use wrong channel for dest
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, ibctesting.InvalidID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, ibctesting.InvalidID, timeoutHeight, disabledTimeoutTimestamp)
}, false}, }, false},
@ -74,8 +73,7 @@ func (suite *KeeperTestSuite) TestTimeoutPacket() {
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
}, false}, }, false},
{"timeout", func() { {"timeout", func() {
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint)
@ -84,15 +82,13 @@ func (suite *KeeperTestSuite) TestTimeoutPacket() {
ordered = true ordered = true
nextSeqRecv = 2 nextSeqRecv = 2
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, uint64(suite.chainB.GetContext().BlockTime().UnixNano())) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, uint64(suite.chainB.GetContext().BlockTime().UnixNano()))
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint)
}, false}, }, false},
{"packet hasn't been sent", func() { {"packet hasn't been sent", func() {
clientA, _, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, uint64(suite.chainB.GetContext().BlockTime().UnixNano())) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, uint64(suite.chainB.GetContext().BlockTime().UnixNano()))
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint)
}, false}, }, false},
@ -100,8 +96,7 @@ func (suite *KeeperTestSuite) TestTimeoutPacket() {
// set ordered to false resulting in wrong proof provided // set ordered to false resulting in wrong proof provided
ordered = false ordered = false
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), disabledTimeoutTimestamp)
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint)
@ -110,7 +105,7 @@ func (suite *KeeperTestSuite) TestTimeoutPacket() {
// set ordered to true resulting in wrong proof provided // set ordered to true resulting in wrong proof provided
ordered = true ordered = true
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), disabledTimeoutTimestamp)
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint)
@ -159,8 +154,7 @@ func (suite *KeeperTestSuite) TestTimeoutExecuted() {
testCases := []testCase{ testCases := []testCase{
{"success ORDERED", func() { {"success ORDERED", func() {
_, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) _, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano())) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano()))
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
@ -168,12 +162,11 @@ func (suite *KeeperTestSuite) TestTimeoutExecuted() {
}, true}, }, true},
{"channel not found", func() { {"channel not found", func() {
// use wrong channel naming // use wrong channel naming
_, _, _, _, _, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, _, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, ibctesting.InvalidID, ibctesting.InvalidID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, ibctesting.InvalidID, ibctesting.InvalidID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
}, false}, }, false},
{"incorrect capability", func() { {"incorrect capability", func() {
_, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) _, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano())) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano()))
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
@ -214,8 +207,7 @@ func (suite *KeeperTestSuite) TestTimeoutOnClose() {
testCases := []testCase{ testCases := []testCase{
{"success: ORDERED", func() { {"success: ORDERED", func() {
ordered = true ordered = true
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano())) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano()))
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, channelB) suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, channelB)
@ -226,7 +218,7 @@ func (suite *KeeperTestSuite) TestTimeoutOnClose() {
}, true}, }, true},
{"success: UNORDERED", func() { {"success: UNORDERED", func() {
ordered = false ordered = false
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), disabledTimeoutTimestamp)
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, channelB) suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, channelB)
@ -237,17 +229,17 @@ func (suite *KeeperTestSuite) TestTimeoutOnClose() {
}, true}, }, true},
{"channel not found", func() { {"channel not found", func() {
// use wrong channel naming // use wrong channel naming
_, _, _, _, _, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, _, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, ibctesting.InvalidID, ibctesting.InvalidID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, ibctesting.InvalidID, ibctesting.InvalidID, channelB.PortID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
}, false}, }, false},
{"packet dest port ≠ channel counterparty port", func() { {"packet dest port ≠ channel counterparty port", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// use wrong port for dest // use wrong port for dest
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, ibctesting.InvalidID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, ibctesting.InvalidID, channelB.ID, timeoutHeight, disabledTimeoutTimestamp)
chanCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) chanCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, false}, }, false},
{"packet dest channel ID ≠ channel counterparty channel ID", func() { {"packet dest channel ID ≠ channel counterparty channel ID", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
// use wrong channel for dest // use wrong channel for dest
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, ibctesting.InvalidID, timeoutHeight, disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, ibctesting.InvalidID, timeoutHeight, disabledTimeoutTimestamp)
chanCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) chanCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
@ -268,16 +260,14 @@ func (suite *KeeperTestSuite) TestTimeoutOnClose() {
chanCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) chanCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, false}, }, false},
{"packet hasn't been sent", func() { {"packet hasn't been sent", func() {
_, _, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano())) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano()))
chanCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) chanCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
}, false}, }, false},
{"packet already received", func() { {"packet already received", func() {
nextSeqRecv = 2 nextSeqRecv = 2
ordered = true ordered = true
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano())) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano()))
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, channelB) suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, channelB)
@ -288,8 +278,7 @@ func (suite *KeeperTestSuite) TestTimeoutOnClose() {
}, false}, }, false},
{"channel verification failed", func() { {"channel verification failed", func() {
ordered = true ordered = true
_, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) _, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano())) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano()))
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
chanCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID) chanCap = suite.chainA.GetChannelCapability(channelA.PortID, channelA.ID)
@ -297,8 +286,7 @@ func (suite *KeeperTestSuite) TestTimeoutOnClose() {
{"next seq receive verification failed", func() { {"next seq receive verification failed", func() {
// set ordered to false providing the wrong proof for ORDERED case // set ordered to false providing the wrong proof for ORDERED case
ordered = false ordered = false
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano())) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano()))
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, channelB) suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, channelB)
@ -308,7 +296,7 @@ func (suite *KeeperTestSuite) TestTimeoutOnClose() {
{"packet ack verification failed", func() { {"packet ack verification failed", func() {
// set ordered to true providing the wrong proof for UNORDERED case // set ordered to true providing the wrong proof for UNORDERED case
ordered = true ordered = true
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.UNORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), disabledTimeoutTimestamp) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), disabledTimeoutTimestamp)
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, channelB) suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, channelB)
@ -317,8 +305,7 @@ func (suite *KeeperTestSuite) TestTimeoutOnClose() {
}, false}, }, false},
{"channel capability not found", func() { {"channel capability not found", func() {
ordered = true ordered = true
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, types.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, types.ORDERED)
packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano())) packet = types.NewPacket(validPacketData, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano()))
suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, channelB) suite.coordinator.SetChannelClosed(suite.chainB, suite.chainA, channelB)

4
x/ibc/05-port/types/utils.go
View File

@ -1,11 +1,13 @@
package types package types
import "fmt"
// GetModuleOwner enforces that only IBC and the module bound to port can own the capability // GetModuleOwner enforces that only IBC and the module bound to port can own the capability
// while future implementations may allow multiple modules to bind to a port, currently we // while future implementations may allow multiple modules to bind to a port, currently we
// only allow one module to be bound to a port at any given time // only allow one module to be bound to a port at any given time
func GetModuleOwner(modules []string) string { func GetModuleOwner(modules []string) string {
if len(modules) != 2 { if len(modules) != 2 {
panic("capability should only be owned by port or channel owner and ibc module, multiple owners currently not supported") panic(fmt.Sprintf("capability should only be owned by port or channel owner and ibc module, multiple owners currently not supported, owners: %v", modules))
} }
if modules[0] == "ibc" { if modules[0] == "ibc" {

12
x/ibc/07-tendermint/types/client_state_test.go
View File

@ -212,7 +212,7 @@ func (suite *TendermintTestSuite) TestVerifyConnectionState() {
suite.SetupTest() // reset suite.SetupTest() // reset
// setup testing conditions // setup testing conditions
clientA, _, _, connB, _, _ := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, _, _, connB, _, _ := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
connection := suite.chainB.GetConnection(connB) connection := suite.chainB.GetConnection(connB)
var ok bool var ok bool
@ -290,7 +290,7 @@ func (suite *TendermintTestSuite) TestVerifyChannelState() {
suite.SetupTest() // reset suite.SetupTest() // reset
// setup testing conditions // setup testing conditions
clientA, _, _, _, _, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, _, _, _, _, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
channel := suite.chainB.GetChannel(channelB) channel := suite.chainB.GetChannel(channelB)
var ok bool var ok bool
@ -369,7 +369,7 @@ func (suite *TendermintTestSuite) TestVerifyPacketCommitment() {
suite.SetupTest() // reset suite.SetupTest() // reset
// setup testing conditions // setup testing conditions
clientA, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
packet := channeltypes.NewPacket(ibctesting.TestHash, 1, channelB.PortID, channelB.ID, channelA.PortID, channelA.ID, 100, 0) packet := channeltypes.NewPacket(ibctesting.TestHash, 1, channelB.PortID, channelB.ID, channelA.PortID, channelA.ID, 100, 0)
err := suite.coordinator.SendPacket(suite.chainB, suite.chainA, packet, clientA) err := suite.coordinator.SendPacket(suite.chainB, suite.chainA, packet, clientA)
suite.Require().NoError(err) suite.Require().NoError(err)
@ -451,7 +451,7 @@ func (suite *TendermintTestSuite) TestVerifyPacketAcknowledgement() {
suite.SetupTest() // reset suite.SetupTest() // reset
// setup testing conditions // setup testing conditions
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
packet := channeltypes.NewPacket(ibctesting.TestHash, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, 100, 0) packet := channeltypes.NewPacket(ibctesting.TestHash, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, 100, 0)
// send packet // send packet
@ -539,7 +539,7 @@ func (suite *TendermintTestSuite) TestVerifyPacketAcknowledgementAbsence() {
suite.SetupTest() // reset suite.SetupTest() // reset
// setup testing conditions // setup testing conditions
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
packet := channeltypes.NewPacket(ibctesting.TestHash, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, 100, 0) packet := channeltypes.NewPacket(ibctesting.TestHash, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, 100, 0)
// send packet, but no recv // send packet, but no recv
@ -626,7 +626,7 @@ func (suite *TendermintTestSuite) TestVerifyNextSeqRecv() {
suite.SetupTest() // reset suite.SetupTest() // reset
// setup testing conditions // setup testing conditions
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
packet := channeltypes.NewPacket(ibctesting.TestHash, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, 100, 0) packet := channeltypes.NewPacket(ibctesting.TestHash, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, 100, 0)
// send packet // send packet

3
x/ibc/07-tendermint/types/store_test.go
View File

@ -1,6 +1,7 @@
package types_test package types_test
import ( import (
channeltypes "github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types"
"github.com/cosmos/cosmos-sdk/x/ibc/07-tendermint/types" "github.com/cosmos/cosmos-sdk/x/ibc/07-tendermint/types"
host "github.com/cosmos/cosmos-sdk/x/ibc/24-host" host "github.com/cosmos/cosmos-sdk/x/ibc/24-host"
) )
@ -50,7 +51,7 @@ func (suite *TendermintTestSuite) TestGetConsensusState() {
suite.Run(tc.name, func() { suite.Run(tc.name, func() {
suite.SetupTest() suite.SetupTest()
clientA, _, _, _, _, _ = suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, _, _, _, _, _ = suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
clientState := suite.chainA.GetClientState(clientA) clientState := suite.chainA.GetClientState(clientA)
height = clientState.GetLatestHeight() height = clientState.GetLatestHeight()

2
x/ibc/genesis_test.go
View File

@ -240,7 +240,7 @@ func (suite *HandlerTestSuite) TestExportGenesis() {
"success", "success",
func() { func() {
// creates clients // creates clients
suite.coordinator.Setup(suite.chainA, suite.chainB) suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
// create extra clients // create extra clients
suite.coordinator.CreateClient(suite.chainA, suite.chainB, clientexported.Tendermint) suite.coordinator.CreateClient(suite.chainA, suite.chainB, clientexported.Tendermint)
suite.coordinator.CreateClient(suite.chainA, suite.chainB, clientexported.Tendermint) suite.coordinator.CreateClient(suite.chainA, suite.chainB, clientexported.Tendermint)

221
x/ibc/handler_test.go
View File

@ -5,9 +5,7 @@ import (
"github.com/stretchr/testify/suite" "github.com/stretchr/testify/suite"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/ibc" "github.com/cosmos/cosmos-sdk/x/ibc"
ibctransfertypes "github.com/cosmos/cosmos-sdk/x/ibc-transfer/types"
clientexported "github.com/cosmos/cosmos-sdk/x/ibc/02-client/exported" clientexported "github.com/cosmos/cosmos-sdk/x/ibc/02-client/exported"
channeltypes "github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types" channeltypes "github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types"
host "github.com/cosmos/cosmos-sdk/x/ibc/24-host" host "github.com/cosmos/cosmos-sdk/x/ibc/24-host"
@ -16,7 +14,7 @@ import (
const ( const (
timeoutHeight = uint64(10000) timeoutHeight = uint64(10000)
totalPackets = uint64(10) maxSequence = uint64(10)
) )
type HandlerTestSuite struct { type HandlerTestSuite struct {
@ -55,39 +53,37 @@ func (suite *HandlerTestSuite) TestHandleRecvPacket() {
expPass bool expPass bool
}{ }{
{"success: ORDERED", func() { {"success: ORDERED", func() {
_, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) _, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, channeltypes.ORDERED) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err) suite.Require().NoError(err)
}, true}, }, true},
{"success: UNORDERED", func() { {"success: UNORDERED", func() {
_, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err) suite.Require().NoError(err)
}, true}, }, true},
{"success: UNORDERED out of order packet", func() { {"success: UNORDERED out of order packet", func() {
// setup uses an UNORDERED channel // setup uses an UNORDERED channel
_, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
// attempts to receive packet with sequence 10 without receiving packet with sequence 1 // attempts to receive packet with sequence 10 without receiving packet with sequence 1
for i := uint64(1); i < 10; i++ { for i := uint64(1); i < 10; i++ {
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), i, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, i, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err) suite.Require().NoError(err)
} }
}, true}, }, true},
{"failure: ORDERED out of order packet", func() { {"failure: ORDERED out of order packet", func() {
_, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) _, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, channeltypes.ORDERED)
// attempts to receive packet with sequence 10 without receiving packet with sequence 1 // attempts to receive packet with sequence 10 without receiving packet with sequence 1
for i := uint64(1); i < 10; i++ { for i := uint64(1); i < 10; i++ {
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), i, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, i, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err) suite.Require().NoError(err)
@ -98,13 +94,12 @@ func (suite *HandlerTestSuite) TestHandleRecvPacket() {
suite.Require().NotNil(packet) suite.Require().NotNil(packet)
}, false}, }, false},
{"packet not sent", func() { {"packet not sent", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
}, false}, }, false},
{"ORDERED: packet already received (replay)", func() { {"ORDERED: packet already received (replay)", func() {
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, channeltypes.ORDERED) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err) suite.Require().NoError(err)
@ -113,9 +108,9 @@ func (suite *HandlerTestSuite) TestHandleRecvPacket() {
suite.Require().NoError(err) suite.Require().NoError(err)
}, false}, }, false},
{"UNORDERED: packet already received (replay)", func() { {"UNORDERED: packet already received (replay)", func() {
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err) suite.Require().NoError(err)
@ -178,9 +173,8 @@ func (suite *HandlerTestSuite) TestHandleAcknowledgePacket() {
expPass bool expPass bool
}{ }{
{"success: ORDERED", func() { {"success: ORDERED", func() {
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, channeltypes.ORDERED) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err) suite.Require().NoError(err)
@ -189,8 +183,8 @@ func (suite *HandlerTestSuite) TestHandleAcknowledgePacket() {
suite.Require().NoError(err) suite.Require().NoError(err)
}, true}, }, true},
{"success: UNORDERED", func() { {"success: UNORDERED", func() {
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err) suite.Require().NoError(err)
@ -200,11 +194,11 @@ func (suite *HandlerTestSuite) TestHandleAcknowledgePacket() {
}, true}, }, true},
{"success: UNORDERED acknowledge out of order packet", func() { {"success: UNORDERED acknowledge out of order packet", func() {
// setup uses an UNORDERED channel // setup uses an UNORDERED channel
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
// attempts to acknowledge ack with sequence 10 without acknowledging ack with sequence 1 (removing packet commitment) // attempts to acknowledge ack with sequence 10 without acknowledging ack with sequence 1 (removing packet commitment)
for i := uint64(1); i < 10; i++ { for i := uint64(1); i < 10; i++ {
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), i, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, i, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err) suite.Require().NoError(err)
@ -215,12 +209,11 @@ func (suite *HandlerTestSuite) TestHandleAcknowledgePacket() {
} }
}, true}, }, true},
{"failure: ORDERED acknowledge out of order packet", func() { {"failure: ORDERED acknowledge out of order packet", func() {
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, channeltypes.ORDERED)
// attempts to acknowledge ack with sequence 10 without acknowledging ack with sequence 1 (removing packet commitment // attempts to acknowledge ack with sequence 10 without acknowledging ack with sequence 1 (removing packet commitment
for i := uint64(1); i < 10; i++ { for i := uint64(1); i < 10; i++ {
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), i, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, i, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err) suite.Require().NoError(err)
@ -234,16 +227,15 @@ func (suite *HandlerTestSuite) TestHandleAcknowledgePacket() {
suite.Require().NotNil(packet) suite.Require().NotNil(packet)
}, false}, }, false},
{"packet not received", func() { {"packet not received", func() {
_, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err) suite.Require().NoError(err)
}, false}, }, false},
{"ORDERED: packet already acknowledged (replay)", func() { {"ORDERED: packet already acknowledged (replay)", func() {
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, channeltypes.ORDERED) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err) suite.Require().NoError(err)
@ -255,9 +247,9 @@ func (suite *HandlerTestSuite) TestHandleAcknowledgePacket() {
suite.Require().NoError(err) suite.Require().NoError(err)
}, false}, }, false},
{"UNORDERED: packet already received (replay)", func() { {"UNORDERED: packet already received (replay)", func() {
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err) suite.Require().NoError(err)
@ -275,7 +267,7 @@ func (suite *HandlerTestSuite) TestHandleAcknowledgePacket() {
suite.Run(tc.name, func() { suite.Run(tc.name, func() {
suite.SetupTest() // reset suite.SetupTest() // reset
ibctesting.TestHash = ibctransfertypes.FungibleTokenPacketAcknowledgement{true, ""}.GetBytes() ibctesting.TestHash = ibctesting.MockAcknowledgement
handler := ibc.NewHandler(*suite.chainA.App.IBCKeeper) handler := ibc.NewHandler(*suite.chainA.App.IBCKeeper)
@ -284,9 +276,7 @@ func (suite *HandlerTestSuite) TestHandleAcknowledgePacket() {
packetKey := host.KeyPacketAcknowledgement(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) packetKey := host.KeyPacketAcknowledgement(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
proof, proofHeight := suite.chainB.QueryProof(packetKey) proof, proofHeight := suite.chainB.QueryProof(packetKey)
ack := ibctesting.TestHash msg := channeltypes.NewMsgAcknowledgement(packet, ibctesting.MockAcknowledgement, proof, proofHeight, suite.chainA.SenderAccount.GetAddress())
msg := channeltypes.NewMsgAcknowledgement(packet, ack, proof, proofHeight, suite.chainA.SenderAccount.GetAddress())
_, err := handler(suite.chainA.GetContext(), msg) _, err := handler(suite.chainA.GetContext(), msg)
@ -297,8 +287,8 @@ func (suite *HandlerTestSuite) TestHandleAcknowledgePacket() {
_, err := handler(suite.chainA.GetContext(), msg) _, err := handler(suite.chainA.GetContext(), msg)
suite.Require().Error(err) suite.Require().Error(err)
// verify packet commitment was deleted // verify packet commitment was deleted on source chain
has := suite.chainA.App.IBCKeeper.ChannelKeeper.HasPacketCommitment(suite.chainA.GetContext(), packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) has := suite.chainA.App.IBCKeeper.ChannelKeeper.HasPacketCommitment(suite.chainA.GetContext(), packet.GetSourcePort(), packet.GetSourceChannel(), packet.GetSequence())
suite.Require().False(has) suite.Require().False(has)
} else { } else {
@ -325,14 +315,12 @@ func (suite *HandlerTestSuite) TestHandleTimeoutPacket() {
expPass bool expPass bool
}{ }{
{"success: ORDERED", func() { {"success: ORDERED", func() {
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, channeltypes.ORDERED) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano()))
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano()))
// send from chainA to chainB // create packet commitment
msg := ibctransfertypes.NewMsgTransfer(channelA.PortID, channelA.ID, ibctesting.TestCoin, suite.chainA.SenderAccount.GetAddress(), suite.chainB.SenderAccount.GetAddress().String(), packet.GetTimeoutHeight(), packet.GetTimeoutTimestamp()) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
err := suite.coordinator.SendMsg(suite.chainA, suite.chainB, clientB, msg) suite.Require().NoError(err)
suite.Require().NoError(err) // message committed
// need to update chainA client to prove missing ack // need to update chainA client to prove missing ack
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint)
@ -340,13 +328,12 @@ func (suite *HandlerTestSuite) TestHandleTimeoutPacket() {
packetKey = host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel()) packetKey = host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel())
}, true}, }, true},
{"success: UNORDERED", func() { {"success: UNORDERED", func() {
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano())) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), uint64(suite.chainB.GetContext().BlockTime().UnixNano()))
// send from chainA to chainB // create packet commitment
msg := ibctransfertypes.NewMsgTransfer(channelA.PortID, channelA.ID, ibctesting.TestCoin, suite.chainA.SenderAccount.GetAddress(), suite.chainB.SenderAccount.GetAddress().String(), packet.GetTimeoutHeight(), packet.GetTimeoutTimestamp()) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
err := suite.coordinator.SendMsg(suite.chainA, suite.chainB, clientB, msg) suite.Require().NoError(err)
suite.Require().NoError(err) // message committed
// need to update chainA client to prove missing ack // need to update chainA client to prove missing ack
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint)
@ -355,42 +342,35 @@ func (suite *HandlerTestSuite) TestHandleTimeoutPacket() {
}, true}, }, true},
{"success: UNORDERED timeout out of order packet", func() { {"success: UNORDERED timeout out of order packet", func() {
// setup uses an UNORDERED channel // setup uses an UNORDERED channel
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
msgs := make([]sdk.Msg, totalPackets)
// attempts to timeout the last packet sent without timing out the first packet // attempts to timeout the last packet sent without timing out the first packet
// packet sequences begin at 1 // packet sequences begin at 1
for i := uint64(0); i < totalPackets; i++ { for i := uint64(1); i < maxSequence; i++ {
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), i+1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, i, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), 0)
msgs[i] = ibctransfertypes.NewMsgTransfer(channelA.PortID, channelA.ID, ibctesting.TestCoin, suite.chainA.SenderAccount.GetAddress(), suite.chainB.SenderAccount.GetAddress().String(), packet.GetTimeoutHeight(), packet.GetTimeoutTimestamp())
// create packet commitment
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err)
} }
// send from chainA to chainB
err := suite.coordinator.SendMsgs(suite.chainA, suite.chainB, clientB, msgs)
suite.Require().NoError(err) // message committed
// need to update chainA client to prove missing ack
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint)
packetKey = host.KeyPacketAcknowledgement(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) packetKey = host.KeyPacketAcknowledgement(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
}, true}, }, true},
{"success: ORDERED timeout out of order packet", func() { {"success: ORDERED timeout out of order packet", func() {
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, channeltypes.ORDERED)
msgs := make([]sdk.Msg, totalPackets)
// attempts to timeout the last packet sent without timing out the first packet // attempts to timeout the last packet sent without timing out the first packet
// packet sequences begin at 1 // packet sequences begin at 1
for i := uint64(0); i < totalPackets; i++ { for i := uint64(1); i < maxSequence; i++ {
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), i+1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, i, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, uint64(suite.chainB.GetContext().BlockHeight()), 0)
msgs[i] = ibctransfertypes.NewMsgTransfer(channelA.PortID, channelA.ID, ibctesting.TestCoin, suite.chainA.SenderAccount.GetAddress(), suite.chainB.SenderAccount.GetAddress().String(), packet.GetTimeoutHeight(), packet.GetTimeoutTimestamp())
// create packet commitment
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err)
} }
// send from chainA to chainB
err := suite.coordinator.SendMsgs(suite.chainA, suite.chainB, clientB, msgs)
suite.Require().NoError(err) // message committed
// need to update chainA client to prove missing ack
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint)
packetKey = host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel()) packetKey = host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel())
@ -402,8 +382,8 @@ func (suite *HandlerTestSuite) TestHandleTimeoutPacket() {
packetKey = host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel()) packetKey = host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel())
}, false}, }, false},
{"UNORDERED: packet not sent", func() { {"UNORDERED: packet not sent", func() {
_, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) _, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
packetKey = host.KeyPacketAcknowledgement(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) packetKey = host.KeyPacketAcknowledgement(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
}, false}, }, false},
} }
@ -431,8 +411,8 @@ func (suite *HandlerTestSuite) TestHandleTimeoutPacket() {
_, err := handler(suite.chainA.GetContext(), msg) _, err := handler(suite.chainA.GetContext(), msg)
suite.Require().Error(err) suite.Require().Error(err)
// verify packet commitment was deleted // verify packet commitment was deleted on source chain
has := suite.chainA.App.IBCKeeper.ChannelKeeper.HasPacketCommitment(suite.chainA.GetContext(), packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) has := suite.chainA.App.IBCKeeper.ChannelKeeper.HasPacketCommitment(suite.chainA.GetContext(), packet.GetSourcePort(), packet.GetSourceChannel(), packet.GetSequence())
suite.Require().False(has) suite.Require().False(has)
} else { } else {
@ -460,19 +440,17 @@ func (suite *HandlerTestSuite) TestHandleTimeoutOnClosePacket() {
expPass bool expPass bool
}{ }{
{"success: ORDERED", func() { {"success: ORDERED", func() {
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, channeltypes.ORDERED) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
counterpartyChannel = ibctesting.TestChannel{ counterpartyChannel = ibctesting.TestChannel{
PortID: channelB.PortID, PortID: channelB.PortID,
ID: channelB.ID, ID: channelB.ID,
CounterpartyClientID: clientA, CounterpartyClientID: clientA,
} }
// send from chainA to chainB // create packet commitment
msg := ibctransfertypes.NewMsgTransfer(channelA.PortID, channelA.ID, ibctesting.TestCoin, suite.chainA.SenderAccount.GetAddress(), suite.chainB.SenderAccount.GetAddress().String(), packet.GetTimeoutHeight(), packet.GetTimeoutTimestamp()) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
err := suite.coordinator.SendMsg(suite.chainA, suite.chainB, clientB, msg) suite.Require().NoError(err)
suite.Require().NoError(err) // message committed
// need to update chainA client to prove missing ack // need to update chainA client to prove missing ack
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint)
@ -484,18 +462,17 @@ func (suite *HandlerTestSuite) TestHandleTimeoutOnClosePacket() {
}, true}, }, true},
{"success: UNORDERED", func() { {"success: UNORDERED", func() {
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
counterpartyChannel = ibctesting.TestChannel{ counterpartyChannel = ibctesting.TestChannel{
PortID: channelB.PortID, PortID: channelB.PortID,
ID: channelB.ID, ID: channelB.ID,
CounterpartyClientID: clientA, CounterpartyClientID: clientA,
} }
// send from chainA to chainB // create packet commitment
msg := ibctransfertypes.NewMsgTransfer(channelA.PortID, channelA.ID, ibctesting.TestCoin, suite.chainA.SenderAccount.GetAddress(), suite.chainB.SenderAccount.GetAddress().String(), packet.GetTimeoutHeight(), packet.GetTimeoutTimestamp()) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
err := suite.coordinator.SendMsg(suite.chainA, suite.chainB, clientB, msg) suite.Require().NoError(err)
suite.Require().NoError(err) // message committed
// need to update chainA client to prove missing ack // need to update chainA client to prove missing ack
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint)
@ -508,26 +485,24 @@ func (suite *HandlerTestSuite) TestHandleTimeoutOnClosePacket() {
}, true}, }, true},
{"success: UNORDERED timeout out of order packet", func() { {"success: UNORDERED timeout out of order packet", func() {
// setup uses an UNORDERED channel // setup uses an UNORDERED channel
clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
counterpartyChannel = ibctesting.TestChannel{ counterpartyChannel = ibctesting.TestChannel{
PortID: channelB.PortID, PortID: channelB.PortID,
ID: channelB.ID, ID: channelB.ID,
CounterpartyClientID: clientA, CounterpartyClientID: clientA,
} }
msgs := make([]sdk.Msg, totalPackets)
// attempts to timeout the last packet sent without timing out the first packet // attempts to timeout the last packet sent without timing out the first packet
// packet sequences begin at 1 // packet sequences begin at 1
for i := uint64(0); i < totalPackets; i++ { for i := uint64(1); i < maxSequence; i++ {
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), i+1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, i, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
msgs[i] = ibctransfertypes.NewMsgTransfer(channelA.PortID, channelA.ID, ibctesting.TestCoin, suite.chainA.SenderAccount.GetAddress(), suite.chainB.SenderAccount.GetAddress().String(), packet.GetTimeoutHeight(), packet.GetTimeoutTimestamp())
// create packet commitment
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err)
} }
// send from chainA to chainB
err := suite.coordinator.SendMsgs(suite.chainA, suite.chainB, clientB, msgs)
suite.Require().NoError(err) // message committed
// need to update chainA client to prove missing ack
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint)
packetKey = host.KeyPacketAcknowledgement(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) packetKey = host.KeyPacketAcknowledgement(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
@ -536,27 +511,23 @@ func (suite *HandlerTestSuite) TestHandleTimeoutOnClosePacket() {
}, true}, }, true},
{"success: ORDERED timeout out of order packet", func() { {"success: ORDERED timeout out of order packet", func() {
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, channeltypes.ORDERED)
counterpartyChannel = ibctesting.TestChannel{ counterpartyChannel = ibctesting.TestChannel{
PortID: channelB.PortID, PortID: channelB.PortID,
ID: channelB.ID, ID: channelB.ID,
CounterpartyClientID: clientA, CounterpartyClientID: clientA,
} }
msgs := make([]sdk.Msg, totalPackets)
// attempts to timeout the last packet sent without timing out the first packet // attempts to timeout the last packet sent without timing out the first packet
// packet sequences begin at 1 // packet sequences begin at 1
for i := uint64(0); i < totalPackets; i++ { for i := uint64(1); i < maxSequence; i++ {
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), i+1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, i, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
msgs[i] = ibctransfertypes.NewMsgTransfer(channelA.PortID, channelA.ID, ibctesting.TestCoin, suite.chainA.SenderAccount.GetAddress(), suite.chainB.SenderAccount.GetAddress().String(), packet.GetTimeoutHeight(), packet.GetTimeoutTimestamp())
// create packet commitment
err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
suite.Require().NoError(err)
} }
// send from chainA to chainB
err := suite.coordinator.SendMsgs(suite.chainA, suite.chainB, clientB, msgs)
suite.Require().NoError(err) // message committed
// need to update chainA client to prove missing ack
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint)
packetKey = host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel()) packetKey = host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel())
@ -571,8 +542,8 @@ func (suite *HandlerTestSuite) TestHandleTimeoutOnClosePacket() {
packetKey = host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel()) packetKey = host.KeyNextSequenceRecv(packet.GetDestPort(), packet.GetDestChannel())
}, false}, }, false},
{"UNORDERED: packet not sent", func() { {"UNORDERED: packet not sent", func() {
clientA, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB) clientA, _, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.UNORDERED)
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
packetKey = host.KeyPacketAcknowledgement(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) packetKey = host.KeyPacketAcknowledgement(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
counterpartyChannel = ibctesting.TestChannel{ counterpartyChannel = ibctesting.TestChannel{
PortID: channelB.PortID, PortID: channelB.PortID,
@ -585,19 +556,17 @@ func (suite *HandlerTestSuite) TestHandleTimeoutOnClosePacket() {
}, false}, }, false},
{"ORDERED: channel not closed", func() { {"ORDERED: channel not closed", func() {
clientA, clientB, connA, connB := suite.coordinator.SetupClientConnections(suite.chainA, suite.chainB, clientexported.Tendermint) clientA, clientB, _, _, channelA, channelB := suite.coordinator.Setup(suite.chainA, suite.chainB, channeltypes.ORDERED)
channelA, channelB := suite.coordinator.CreateTransferChannels(suite.chainA, suite.chainB, connA, connB, channeltypes.ORDERED) packet = channeltypes.NewPacket(ibctesting.MockCommitment, 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
packet = channeltypes.NewPacket(suite.chainA.GetPacketData(suite.chainB), 1, channelA.PortID, channelA.ID, channelB.PortID, channelB.ID, timeoutHeight, 0)
counterpartyChannel = ibctesting.TestChannel{ counterpartyChannel = ibctesting.TestChannel{
PortID: channelB.PortID, PortID: channelB.PortID,
ID: channelB.ID, ID: channelB.ID,
CounterpartyClientID: clientA, CounterpartyClientID: clientA,
} }
// send from chainA to chainB // create packet commitment
msg := ibctransfertypes.NewMsgTransfer(channelA.PortID, channelA.ID, ibctesting.TestCoin, suite.chainA.SenderAccount.GetAddress(), suite.chainB.SenderAccount.GetAddress().String(), packet.GetTimeoutHeight(), packet.GetTimeoutTimestamp()) err := suite.coordinator.SendPacket(suite.chainA, suite.chainB, packet, clientB)
err := suite.coordinator.SendMsg(suite.chainA, suite.chainB, clientB, msg) suite.Require().NoError(err)
suite.Require().NoError(err) // message committed
// need to update chainA client to prove missing ack // need to update chainA client to prove missing ack
suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint) suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, clientexported.Tendermint)
@ -633,8 +602,8 @@ func (suite *HandlerTestSuite) TestHandleTimeoutOnClosePacket() {
_, err := handler(suite.chainA.GetContext(), msg) _, err := handler(suite.chainA.GetContext(), msg)
suite.Require().Error(err) suite.Require().Error(err)
// verify packet commitment was deleted // verify packet commitment was deleted on source chain
has := suite.chainA.App.IBCKeeper.ChannelKeeper.HasPacketCommitment(suite.chainA.GetContext(), packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence()) has := suite.chainA.App.IBCKeeper.ChannelKeeper.HasPacketCommitment(suite.chainA.GetContext(), packet.GetSourcePort(), packet.GetSourceChannel(), packet.GetSequence())
suite.Require().False(has) suite.Require().False(has)
} else { } else {

23
x/ibc/testing/chain.go
View File

@ -31,6 +31,7 @@ import (
ibctmtypes "github.com/cosmos/cosmos-sdk/x/ibc/07-tendermint/types" ibctmtypes "github.com/cosmos/cosmos-sdk/x/ibc/07-tendermint/types"
commitmenttypes "github.com/cosmos/cosmos-sdk/x/ibc/23-commitment/types" commitmenttypes "github.com/cosmos/cosmos-sdk/x/ibc/23-commitment/types"
host "github.com/cosmos/cosmos-sdk/x/ibc/24-host" host "github.com/cosmos/cosmos-sdk/x/ibc/24-host"
"github.com/cosmos/cosmos-sdk/x/ibc/testing/mock"
"github.com/cosmos/cosmos-sdk/x/ibc/types" "github.com/cosmos/cosmos-sdk/x/ibc/types"
stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
) )
@ -48,6 +49,7 @@ const (
ChannelIDPrefix = "chan" ChannelIDPrefix = "chan"
TransferPort = ibctransfertypes.ModuleName TransferPort = ibctransfertypes.ModuleName
MockPort = mock.ModuleName
) )
// Default params variables used to create a TM client // Default params variables used to create a TM client
@ -57,6 +59,9 @@ var (
TestCoin = sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100)) TestCoin = sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100))
ConnectionVersion = connectiontypes.GetCompatibleEncodedVersions()[0] ConnectionVersion = connectiontypes.GetCompatibleEncodedVersions()[0]
MockAcknowledgement = mock.MockAcknowledgement
MockCommitment = mock.MockCommitment
) )
// TestChain is a testing struct that wraps a simapp with the last TM Header, the current ABCI // TestChain is a testing struct that wraps a simapp with the last TM Header, the current ABCI
@ -140,6 +145,10 @@ func NewTestChain(t *testing.T, chainID string) *TestChain {
Connections: make([]*TestConnection, 0), Connections: make([]*TestConnection, 0),
} }
cap := chain.App.IBCKeeper.PortKeeper.BindPort(chain.GetContext(), MockPort)
err = chain.App.ScopedIBCMockKeeper.ClaimCapability(chain.GetContext(), cap, host.PortPath(MockPort))
require.NoError(t, err)
chain.NextBlock() chain.NextBlock()
return chain return chain
@ -550,14 +559,28 @@ func (chain *TestChain) ConnectionOpenConfirm(
// CreatePortCapability binds and claims a capability for the given portID if it does not // CreatePortCapability binds and claims a capability for the given portID if it does not
// already exist. This function will fail testing on any resulting error. // already exist. This function will fail testing on any resulting error.
// NOTE: only creation of a capbility for a transfer or mock port is supported
// Other applications must bind to the port in InitGenesis or modify this code.
func (chain *TestChain) CreatePortCapability(portID string) { func (chain *TestChain) CreatePortCapability(portID string) {
// check if the portId is already binded, if not bind it // check if the portId is already binded, if not bind it
_, ok := chain.App.ScopedIBCKeeper.GetCapability(chain.GetContext(), host.PortPath(portID)) _, ok := chain.App.ScopedIBCKeeper.GetCapability(chain.GetContext(), host.PortPath(portID))
if !ok { if !ok {
// create capability using the IBC capability keeper
cap, err := chain.App.ScopedIBCKeeper.NewCapability(chain.GetContext(), host.PortPath(portID)) cap, err := chain.App.ScopedIBCKeeper.NewCapability(chain.GetContext(), host.PortPath(portID))
require.NoError(chain.t, err) require.NoError(chain.t, err)
switch portID {
case MockPort:
// claim capability using the mock capability keeper
err = chain.App.ScopedIBCMockKeeper.ClaimCapability(chain.GetContext(), cap, host.PortPath(portID))
require.NoError(chain.t, err)
case TransferPort:
// claim capability using the transfer capability keeper
err = chain.App.ScopedTransferKeeper.ClaimCapability(chain.GetContext(), cap, host.PortPath(portID)) err = chain.App.ScopedTransferKeeper.ClaimCapability(chain.GetContext(), cap, host.PortPath(portID))
require.NoError(chain.t, err) require.NoError(chain.t, err)
default:
panic(fmt.Sprintf("unsupported ibc testing package port ID %s", portID))
}
} }
chain.App.Commit() chain.App.Commit()

19
x/ibc/testing/coordinator.go
View File

@ -48,12 +48,12 @@ func NewCoordinator(t *testing.T, n int) *Coordinator {
// fail if any error occurs. The clientID's, TestConnections, and TestChannels are returned // fail if any error occurs. The clientID's, TestConnections, and TestChannels are returned
// for both chains. The channels created are connected to the ibc-transfer application. // for both chains. The channels created are connected to the ibc-transfer application.
func (coord *Coordinator) Setup( func (coord *Coordinator) Setup(
chainA, chainB *TestChain, chainA, chainB *TestChain, order channeltypes.Order,
) (string, string, *TestConnection, *TestConnection, TestChannel, TestChannel) { ) (string, string, *TestConnection, *TestConnection, TestChannel, TestChannel) {
clientA, clientB, connA, connB := coord.SetupClientConnections(chainA, chainB, clientexported.Tendermint) clientA, clientB, connA, connB := coord.SetupClientConnections(chainA, chainB, clientexported.Tendermint)
// channels can also be referenced through the returned connections // channels can also be referenced through the returned connections
channelA, channelB := coord.CreateTransferChannels(chainA, chainB, connA, connB, channeltypes.UNORDERED) channelA, channelB := coord.CreateMockChannels(chainA, chainB, connA, connB, order)
return clientA, clientB, connA, connB, channelA, channelB return clientA, clientB, connA, connB, channelA, channelB
} }
@ -164,6 +164,18 @@ func (coord *Coordinator) CreateConnection(
return connA, connB return connA, connB
} }
// CreateMockChannels constructs and executes channel handshake messages to create OPEN
// channels that use a mock application module that returns nil on all callbacks. This
// function is expects the channels to be successfully opened otherwise testing will
// fail.
func (coord *Coordinator) CreateMockChannels(
chainA, chainB *TestChain,
connA, connB *TestConnection,
order channeltypes.Order,
) (TestChannel, TestChannel) {
return coord.CreateChannel(chainA, chainB, connA, connB, MockPort, MockPort, order)
}
// CreateTransferChannels constructs and executes channel handshake messages to create OPEN // CreateTransferChannels constructs and executes channel handshake messages to create OPEN
// ibc-transfer channels on chainA and chainB. The function expects the channels to be // ibc-transfer channels on chainA and chainB. The function expects the channels to be
// successfully opened otherwise testing will fail. // successfully opened otherwise testing will fail.
@ -472,7 +484,8 @@ func (coord *Coordinator) ChanOpenInit(
sourceChannel := connection.AddTestChannel(sourcePortID) sourceChannel := connection.AddTestChannel(sourcePortID)
counterpartyChannel := counterpartyConnection.AddTestChannel(counterpartyPortID) counterpartyChannel := counterpartyConnection.AddTestChannel(counterpartyPortID)
// create port capability // NOTE: only creation of a capability for a transfer or mock port is supported
// Other applications must bind to the port in InitGenesis or modify this code.
source.CreatePortCapability(sourceChannel.PortID) source.CreatePortCapability(sourceChannel.PortID)
coord.IncrementTime() coord.IncrementTime()

6
x/ibc/testing/mock/README.md Normal file
View File

@ -0,0 +1,6 @@
This package is only intended to be used for testing core IBC. In order to maintain secure
testing, we need to do message passing and execution which requires connecting an IBC application
module that fulfills all the callbacks. We cannot connect to ibc-transfer which does not support
all channel types so instead we create a mock application module which does nothing. It simply
return nil in all cases so no error ever occurs. It is intended to be as minimal and lightweight
as possible and should never import simapp.

9
x/ibc/testing/mock/doc.go Normal file
View File

@ -0,0 +1,9 @@
/*
This package is only intended to be used for testing core IBC. In order to maintain secure
testing, we need to do message passing and execution which requires connecting an IBC application
module that fulfills all the callbacks. We cannot connect to ibc-transfer which does not support
all channel types so instead we create a mock application module which does nothing. It simply
return nil in all cases so no error ever occurs. It is intended to be as minimal and lightweight
as possible and should never import simapp.
*/
package mock

187
x/ibc/testing/mock/mock.go Normal file
View File

@ -0,0 +1,187 @@
package mock
import (
"encoding/json"
"github.com/gogo/protobuf/grpc"
"github.com/grpc-ecosystem/grpc-gateway/runtime"
"github.com/gorilla/mux"
"github.com/spf13/cobra"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/codec"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
sdk "github.com/cosmos/cosmos-sdk/types"
capabilitykeeper "github.com/cosmos/cosmos-sdk/x/capability/keeper"
capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types"
channeltypes "github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types"
host "github.com/cosmos/cosmos-sdk/x/ibc/24-host"
)
const (
ModuleName = "mock"
)
var (
MockAcknowledgement = []byte("mock acknowledgement")
MockCommitment = []byte("mock packet commitment")
)
// AppModuleBasic is the mock AppModuleBasic.
type AppModuleBasic struct{}
// Name implements AppModuleBasic interface.
func (AppModuleBasic) Name() string {
return ModuleName
}
// RegisterCodec implements AppModuleBasic interface.
func (AppModuleBasic) RegisterCodec(*codec.LegacyAmino) {}
// RegisterInterfaces implements AppModuleBasic interface.
func (AppModuleBasic) RegisterInterfaces(registry codectypes.InterfaceRegistry) {}
// DefaultGenesis implements AppModuleBasic interface.
func (AppModuleBasic) DefaultGenesis(cdc codec.JSONMarshaler) json.RawMessage {
return nil
}
// ValidateGenesis implements the AppModuleBasic interface.
func (AppModuleBasic) ValidateGenesis(codec.JSONMarshaler, client.TxEncodingConfig, json.RawMessage) error {
return nil
}
// RegisterRESTRoutes implements AppModuleBasic interface.
func (AppModuleBasic) RegisterRESTRoutes(clientCtx client.Context, rtr *mux.Router) {}
// RegisterGRPCRoutes implements AppModuleBasic interface.
func (a AppModuleBasic) RegisterGRPCRoutes(_ client.Context, _ *runtime.ServeMux) {}
// GetTxCmd implements AppModuleBasic interface.
func (AppModuleBasic) GetTxCmd() *cobra.Command {
return nil
}
// GetQueryCmd implements AppModuleBasic interface.
func (AppModuleBasic) GetQueryCmd() *cobra.Command {
return nil
}
// AppModule represents the AppModule for the mock module.
type AppModule struct {
AppModuleBasic
scopedKeeper capabilitykeeper.ScopedKeeper
}
// NewAppModule returns a mock AppModule instance.
func NewAppModule(sk capabilitykeeper.ScopedKeeper) AppModule {
return AppModule{
scopedKeeper: sk,
}
}
// RegisterInvariants implements the AppModule interface.
func (AppModule) RegisterInvariants(ir sdk.InvariantRegistry) {}
// Route implements the AppModule interface.
func (am AppModule) Route() sdk.Route {
return sdk.NewRoute(ModuleName, nil)
}
// QuerierRoute implements the AppModule interface.
func (AppModule) QuerierRoute() string {
return ""
}
// LegacyQuerierHandler implements the AppModule interface.
func (am AppModule) LegacyQuerierHandler(*codec.LegacyAmino) sdk.Querier {
return nil
}
// RegisterQueryService implements the AppModule interface.
func (am AppModule) RegisterQueryService(server grpc.Server) {}
// InitGenesis implements the AppModule interface.
func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONMarshaler, data json.RawMessage) []abci.ValidatorUpdate {
return []abci.ValidatorUpdate{}
}
// ExportGenesis implements the AppModule interface.
func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONMarshaler) json.RawMessage {
return nil
}
// BeginBlock implements the AppModule interface
func (am AppModule) BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock) {
}
// EndBlock implements the AppModule interface
func (am AppModule) EndBlock(ctx sdk.Context, req abci.RequestEndBlock) []abci.ValidatorUpdate {
return []abci.ValidatorUpdate{}
}
//____________________________________________________________________________
// OnChanOpenInit implements the IBCModule interface.
func (am AppModule) OnChanOpenInit(
ctx sdk.Context, _ channeltypes.Order, _ []string, portID string,
channelID string, chanCap *capabilitytypes.Capability, _ channeltypes.Counterparty, _ string,
) error {
// Claim channel capability passed back by IBC module
if err := am.scopedKeeper.ClaimCapability(ctx, chanCap, host.ChannelCapabilityPath(portID, channelID)); err != nil {
return err
}
return nil
}
// OnChanOpenTry implements the IBCModule interface.
func (am AppModule) OnChanOpenTry(
ctx sdk.Context, _ channeltypes.Order, _ []string, portID string,
channelID string, chanCap *capabilitytypes.Capability, _ channeltypes.Counterparty, _, _ string,
) error {
// Claim channel capability passed back by IBC module
if err := am.scopedKeeper.ClaimCapability(ctx, chanCap, host.ChannelCapabilityPath(portID, channelID)); err != nil {
return err
}
return nil
}
// OnChanOpenAck implements the IBCModule interface.
func (am AppModule) OnChanOpenAck(sdk.Context, string, string, string) error {
return nil
}
// OnChanOpenConfirm implements the IBCModule interface.
func (am AppModule) OnChanOpenConfirm(sdk.Context, string, string) error {
return nil
}
// OnChanCloseInit implements the IBCModule interface.
func (am AppModule) OnChanCloseInit(sdk.Context, string, string) error {
return nil
}
// OnChanCloseConfirm implements the IBCModule interface.
func (am AppModule) OnChanCloseConfirm(sdk.Context, string, string) error {
return nil
}
// OnRecvPacket implements the IBCModule interface.
func (am AppModule) OnRecvPacket(sdk.Context, channeltypes.Packet) (*sdk.Result, []byte, error) {
return nil, MockAcknowledgement, nil
}
// OnAcknowledgementPacket implements the IBCModule interface.
func (am AppModule) OnAcknowledgementPacket(sdk.Context, channeltypes.Packet, []byte) (*sdk.Result, error) {
return nil, nil
}
// OnTimeoutPacket implements the IBCModule interface.
func (am AppModule) OnTimeoutPacket(sdk.Context, channeltypes.Packet) (*sdk.Result, error) {
return nil, nil
}