feat: add integration tests for IBC chains

changelog.md

@@ -5,6 +5,7 @@
 ### Features
 
 - [#3835](https://github.com/ignite/cli/pull/3835) Add `--minimal` flag to `scaffold chain` to scaffold a chain with the least amount of sdk modules
+- [#3820](https://github.com/ignite/cli/pull/3820) Add integration tests for IBC chains
 
 ## [`v28.1.1`](https://github.com/ignite/cli/releases/tag/v28.1.1)
 

ignite/pkg/goanalysis/goanalysis.go

@@ -279,3 +279,73 @@
 		},
 	}
 }
+
+// ReplaceCode replace a function implementation into a package path. The method will find
+// the method signature and re-write the method implementation based in the new function.
+func ReplaceCode(pkgPath, oldFunctionName, newFunction string) (err error) {
+	absPath, err := filepath.Abs(pkgPath)
+	if err != nil {
+		return err
+	}
+
+	fileSet := token.NewFileSet()
+	all, err := parser.ParseDir(fileSet, absPath, func(os.FileInfo) bool { return true }, parser.ParseComments)
+	if err != nil {
+		return err
+	}
+
+	for _, pkg := range all {
+		for _, f := range pkg.Files {
+			found := false
+			ast.Inspect(f, func(n ast.Node) bool {
+				// Check if the node is a function declaration.
+				if funcDecl, ok := n.(*ast.FuncDecl); ok {
+					// Check if the function has the name you want to replace.
+					if funcDecl.Name.Name == oldFunctionName {
+						// Replace the function body with the replacement code.
+						funcDecl.Body, err = parseReplacementCode(newFunction)
+						found = true
+						return false
+					}
+				}
+				return true
+			})
+			if err != nil {
+				return err
+			}
+			if !found {
+				continue
+			}
+			filePath := fileSet.Position(f.Package).Filename
+			outFile, err := os.Create(filePath)
+			if err != nil {
+				return err
+			}
+
+			// Format and write the modified AST to the output file.
+			if err := format.Node(outFile, fileSet, f); err != nil {
+				return err
+			}
+			if err := outFile.Close(); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// parseReplacementCode parse the replacement code and create a *ast.BlockStmt.
+func parseReplacementCode(code string) (*ast.BlockStmt, error) {
+	fset := token.NewFileSet()
+	node, err := parser.ParseFile(fset, "", code, parser.ParseComments)
+	if err != nil {
+		return nil, err
+	}
+	// Assuming there's only one function in the replacement code.
+	if len(node.Decls) > 0 {
+		if funcDecl, ok := node.Decls[0].(*ast.FuncDecl); ok {
+			return funcDecl.Body, nil
+		}
+	}
+	return nil, errors.Errorf("replacement code does not contain a valid function declaration")
+}

ignite/pkg/goanalysis/goanalysis_test.go

@@ -503,3 +503,77 @@ func TestUpdateInitImports(t *testing.T) {
 		})
 	}
 }
+
+func TestReplaceCode(t *testing.T) {
+	var (
+		newFunction = `package test
+func NewMethod1() {
+	n := "test new method"
+	bla := fmt.Sprintf("test new - %s", n)
+	fmt.Println(bla)
+}`
+		rollback = `package test
+func NewMethod1() {
+	foo := 100
+	bar := fmt.Sprintf("test - %d", foo)
+	fmt.Println(bar)
+}`
+	)
+
+	type args struct {
+		path            string
+		oldFunctionName string
+		newFunction     string
+	}
+	tests := []struct {
+		name string
+		args args
+		err  error
+	}{
+		{
+			name: "function fooTest",
+			args: args{
+				path:            "testdata",
+				oldFunctionName: "fooTest",
+				newFunction:     newFunction,
+			},
+		},
+		{
+			name: "function BazTest",
+			args: args{
+				path:            "testdata",
+				oldFunctionName: "BazTest",
+				newFunction:     newFunction,
+			},
+		},
+		{
+			name: "function invalidFunction",
+			args: args{
+				path:            "testdata",
+				oldFunctionName: "invalidFunction",
+				newFunction:     newFunction,
+			},
+		},
+		{
+			name: "invalid path",
+			args: args{
+				path:            "invalid_path",
+				oldFunctionName: "invalidPath",
+				newFunction:     newFunction,
+			},
+			err: os.ErrNotExist,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := goanalysis.ReplaceCode(tt.args.path, tt.args.oldFunctionName, tt.args.newFunction)
+			if tt.err != nil {
+				require.Error(t, err)
+				require.ErrorIs(t, err, tt.err)
+				return
+			}
+			require.NoError(t, err)
+			require.NoError(t, goanalysis.ReplaceCode(tt.args.path, tt.args.oldFunctionName, rollback))
+		})
+	}
+}

ignite/pkg/goanalysis/testdata/replace.go

@@ -0,0 +1,16 @@
+package testdata
+
+import "fmt"
+
+func fooTest() {
+	n := "test new method"
+	bla := fmt.Sprintf("test new - %s", n)
+	fmt.
+		Println(bla)
+}
+
+func BazTest() {
+	foo := 100
+	bar := fmt.Sprintf("test - %d", foo)
+	fmt.Println(bar)
+}

ignite/pkg/goenv/goenv.go

@@ -55,3 +55,8 @@
 	}
 	return filepath.Join(build.Default.GOPATH, modDir)
 }
+
+// GoPath returns the go path.
+func GoPath() string {
+	return os.Getenv(GOPATH)
+}

ignite/templates/app/files/cmd/{{binaryNamePrefix}}d/cmd/commands.go.plush

@@ -22,6 +22,7 @@ import (
 	authcmd "github.com/cosmos/cosmos-sdk/x/auth/client/cli"
 	"github.com/cosmos/cosmos-sdk/x/crisis"
 	genutilcli "github.com/cosmos/cosmos-sdk/x/genutil/client/cli"
+	ibccmd "github.com/cosmos/ibc-go/v8/modules/core/client/cli"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 
@@ -87,6 +88,7 @@ func queryCommand() *cobra.Command {
 		server.QueryBlocksCmd(),
 		authcmd.QueryTxCmd(),
 		server.QueryBlockResultsCmd(),
+		ibccmd.GetQueryCmd(),
 	)
 	cmd.PersistentFlags().String(flags.FlagChainID, "", "The network chain ID")
 
@@ -113,6 +115,7 @@ func txCommand() *cobra.Command {
 		authcmd.GetEncodeCommand(),
 		authcmd.GetDecodeCommand(),
 		authcmd.GetSimulateCmd(),
+		ibccmd.GetTxCmd(),
 	)
 	cmd.PersistentFlags().String(flags.FlagChainID, "", "The network chain ID")
 

ignite/templates/ibc/files/packet/messages/x/{{moduleName}}/client/cli/tx_{{packetName}}.go.plush

@@ -14,6 +14,7 @@ import (
 
 var _ = strconv.Itoa(0)
 
+// CmdSend<%= packetName.UpperCamel %>() returns the <%= packetName.UpperCamel %> send packet command.
 // This command does not use AutoCLI because it gives a better UX to do not.
 func CmdSend<%= packetName.UpperCamel %>() *cobra.Command {
 	flagPacketTimeoutTimestamp := "packet-timeout-timestamp"

integration/app.go

@@ -118,6 +118,10 @@ func (a App) SourcePath() string {
 	return a.path
 }
 
+func (a *App) SetHomePath(homePath string) {
+	a.homePath = homePath
+}
+
 func (a *App) SetConfigPath(path string) {
 	a.configPath = path
 }