test: add integration test to test generated TS client

.github/workflows/test-integration.yml

@@ -17,7 +17,7 @@ jobs:
       - uses: actions/checkout@v2
       - name: Finding files and store to output
         id: set-matrix
-        run: echo "::set-output name=matrix::$({ cd integration && find . -type d -maxdepth 1 -print; } | tail -n +2 | cut -c 3- | jq -R . | jq -cs .)"
+        run: echo "::set-output name=matrix::$({ cd integration && find . -type d ! -name testdata -maxdepth 1 -print; } | tail -n +2 | cut -c 3- | jq -R . | jq -cs .)"
 
   integration:
     name: test ${{ matrix.test-path }}

changelog.md

@@ -17,6 +17,10 @@
 - Seal the capability keeper in the `app.go` template
 - Change faucet to allow C.O.R.S. preflight requests.
 
+### Features
+
+- Add generated TS client test support to integration tests.
+
 ## [`v0.24.0`](https://github.com/ignite/cli/releases/tag/v0.24.0)
 
 ### Features

ignite/cmd/generate_typescript_client.go

@@ -14,7 +14,6 @@ func NewGenerateTSClient() *cobra.Command {
 		RunE:  generateTSClientHandler,
 	}
 
-	c.Flags().AddFlagSet(flagSetProto3rdParty(""))
 	c.Flags().StringP(flagOutput, "o", "", "typescript client output path")
 
 	return c

integration/app.go

@@ -245,3 +245,13 @@ func (a App) EditConfig(apply func(*chainconfig.Config)) {
 	err = os.WriteFile(a.configPath, bz, 0o644)
 	require.NoError(a.env.t, err)
 }
+
+// GenerateTSClient runs the command to generate the Typescript client code.
+func (a App) GenerateTSClient() bool {
+	return a.env.Exec("generate typescript client", step.NewSteps(
+		step.New(
+			step.Exec(IgniteApp, "g", "ts-client", "--yes", "--clear-cache"),
+			step.Workdir(a.path),
+		),
+	))
+}

integration/client.go

@@ -0,0 +1,157 @@
+package envtest
+
+import (
+	"bytes"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/ignite/cli/ignite/chainconfig"
+	"github.com/ignite/cli/ignite/pkg/cmdrunner"
+	"github.com/ignite/cli/ignite/pkg/cmdrunner/step"
+)
+
+type clientOptions struct {
+	env                    map[string]string
+	testName, testFilePath string
+}
+
+// ClientOption defines options for the TS client test runner.
+type ClientOption func(*clientOptions)
+
+// ClientEnv option defines environment values for the tests.
+func ClientEnv(env map[string]string) ClientOption {
+	return func(o *clientOptions) {
+		for k, v := range env {
+			o.env[k] = v
+		}
+	}
+}
+
+// ClientTestName option defines a pattern to match the test names that should be run.
+func ClientTestName(pattern string) ClientOption {
+	return func(o *clientOptions) {
+		o.testName = pattern
+	}
+}
+
+// ClientTestFile option defines the name of the file where to look for tests.
+func ClientTestFile(filePath string) ClientOption {
+	return func(o *clientOptions) {
+		o.testFilePath = filePath
+	}
+}
+
+// RunClientTests runs the Typescript client tests.
+func (a App) RunClientTests(options ...ClientOption) bool {
+	npm, err := exec.LookPath("npm")
+	require.NoError(a.env.t, err, "npm binary not found")
+
+	// The root dir for the tests must be an absolute path.
+	// It is used as the start search point to find test files.
+	rootDir, err := os.Getwd()
+	require.NoError(a.env.t, err)
+
+	// The filename of this module is required to be able to define the location
+	// of the TS client test runner package to be used as working directory when
+	// running the tests.
+	_, filename, _, ok := runtime.Caller(0)
+	if !ok {
+		a.env.t.Fatal("failed to read file name")
+	}
+
+	opts := clientOptions{
+		env: map[string]string{
+			// Absolute path to the blockchain app directory
+			"TEST_CHAIN_PATH": a.path,
+			// Absolute path to the TS client directory
+			"TEST_TSCLIENT_DIR": filepath.Join(a.path, chainconfig.DefaultTSClientPath),
+		},
+	}
+	for _, o := range options {
+		o(&opts)
+	}
+
+	var (
+		output bytes.Buffer
+		env    []string
+	)
+
+	//  Install the dependencies needed to run TS client tests
+	ok = a.env.Exec("install client dependencies", step.NewSteps(
+		step.New(
+			step.Workdir(filepath.Join(a.path, chainconfig.DefaultTSClientPath)),
+			step.Stdout(&output),
+			step.Exec(npm, "install"),
+			step.PostExec(func(err error) error {
+				// Print the npm output when there is an error
+				if err != nil {
+					a.env.t.Log("\n", output.String())
+				}
+
+				return err
+			}),
+		),
+	))
+	if !ok {
+		return false
+	}
+
+	output.Reset()
+
+	args := []string{"run", "test", "--", "--dir", rootDir}
+	if opts.testName != "" {
+		args = append(args, "-t", opts.testName)
+	}
+
+	if opts.testFilePath != "" {
+		args = append(args, opts.testFilePath)
+	}
+
+	for k, v := range opts.env {
+		env = append(env, cmdrunner.Env(k, v))
+	}
+
+	// The tests are run from the TS client test runner package directory
+	runnerDir := filepath.Join(filepath.Dir(filename), "testdata/tstestrunner")
+
+	// TODO: Ignore stderr ? Errors are already displayed with traceback in the stdout
+	return a.env.Exec("run client tests", step.NewSteps(
+		// Make sure the test runner dependencies are installed
+		step.New(
+			step.Workdir(runnerDir),
+			step.Stdout(&output),
+			step.Exec(npm, "install"),
+			step.PostExec(func(err error) error {
+				// Print the npm output when there is an error
+				if err != nil {
+					a.env.t.Log("\n", output.String())
+				}
+
+				return err
+			}),
+		),
+		// Run the TS client tests
+		step.New(
+			step.Workdir(runnerDir),
+			step.Stdout(&output),
+			step.Env(env...),
+			step.PreExec(func() error {
+				// Clear the output from the previous step
+				output.Reset()
+
+				return nil
+			}),
+			step.Exec(npm, args...),
+			step.PostExec(func(err error) error {
+				// Always print tests output to be available on errors or when verbose is enabled
+				a.env.t.Log("\n", output.String())
+
+				return err
+			}),
+		),
+	))
+}

integration/cosmosgen/bank_module_test.go

@@ -0,0 +1,87 @@
+package cosmosgen_test
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"testing"
+
+	"github.com/ignite/cli/ignite/chainconfig"
+	"github.com/ignite/cli/ignite/pkg/xurl"
+	envtest "github.com/ignite/cli/integration"
+	"github.com/stretchr/testify/require"
+)
+
+func TestBankModule(t *testing.T) {
+	var (
+		env  = envtest.New(t)
+		app  = env.Scaffold("chain", "--no-module")
+		host = app.RandomizeServerPorts()
+	)
+
+	queryAPI, err := xurl.HTTP(host.API)
+	require.NoError(t, err)
+
+	txAPI, err := xurl.TCP(host.RPC)
+	require.NoError(t, err)
+
+	// Accounts to be included in the genesis
+	accounts := []chainconfig.Account{
+		{
+			Name:    "account1",
+			Address: "cosmos1j8hw8283hj80hhq8urxaj40syrzqp77dt8qwhm",
+			Mnemonic: fmt.Sprint(
+				"toe mail light plug pact length excess predict real artwork laundry when steel ",
+				"online adapt clutch debate vehicle dash alter rifle virtual season almost",
+			),
+			Coins: []string{"10000token", "10000stake"},
+		},
+		{
+			Name:    "account2",
+			Address: "cosmos19yy9sf00k00cjcwh532haeq8s63uhdy7qs5m2n",
+			Mnemonic: fmt.Sprint(
+				"someone major rule wrestle forget want job record coil table enter gold bracket ",
+				"zone tent music grow shiver width index radio matter asset when",
+			),
+			Coins: []string{"100token", "100stake"},
+		},
+		{
+			Name:    "account3",
+			Address: "cosmos10957ee377t2xpwyt4mlpedjldp592h0ylt8uz7",
+			Mnemonic: fmt.Sprint(
+				"edit effort own cat chuckle rookie mechanic side tool sausage other fade math ",
+				"joy midnight cabin act plastic spawn loud chest invest budget rebel",
+			),
+			Coins: []string{"100token", "100stake"},
+		},
+	}
+
+	app.EditConfig(func(cfg *chainconfig.Config) {
+		cfg.Accounts = append(cfg.Accounts, accounts...)
+	})
+
+	env.Must(app.GenerateTSClient())
+
+	ctx, cancel := context.WithTimeout(env.Ctx(), envtest.ServeTimeout)
+	defer cancel()
+
+	go func() {
+		app.Serve("should serve app", envtest.ExecCtx(ctx))
+	}()
+
+	// Wait for the server to be up before running the client tests
+	err = env.IsAppServed(ctx, host)
+	require.NoError(t, err)
+
+	testAccounts, err := json.Marshal(accounts)
+	require.NoError(t, err)
+
+	env.Must(app.RunClientTests(
+		envtest.ClientTestFile("bank_module_test.ts"),
+		envtest.ClientEnv(map[string]string{
+			"TEST_QUERY_API": queryAPI,
+			"TEST_TX_API":    txAPI,
+			"TEST_ACCOUNTS":  string(testAccounts),
+		}),
+	))
+}

integration/cosmosgen/bank_module_test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest'
+import { DirectSecp256k1HdWallet } from '@cosmjs/proto-signing'
+import { isDeliverTxSuccess } from '@cosmjs/stargate'
+
+describe('bank module', async () => {
+  const { Client } = await import('client')
+
+  it('should transfer to two different addresses', async () => {
+    const { account1, account2, account3 } = globalThis.accounts
+
+    const mnemonic = account1['Mnemonic']
+    const wallet = await DirectSecp256k1HdWallet.fromMnemonic(mnemonic)
+    const [account] = await wallet.getAccounts();
+
+    const denom = 'token'
+    const env = {
+      denom,
+	    rpcURL: globalThis.txApi,
+	    apiURL: globalThis.queryApi,
+    }
+    const client = new Client(env, wallet)
+
+    const toAddresses = [
+      account2['Address'],
+      account3['Address'],
+    ]
+
+    // Both accounts start with 100token before the transfer
+    const result = await client.signAndBroadcast([
+      client.CosmosBankV1Beta1.tx.msgSend({
+        value: {
+          fromAddress: account.address,
+          toAddress: toAddresses[0],
+          amount: [{ denom, amount: '100' }],
+        }
+      }),
+      client.CosmosBankV1Beta1.tx.msgSend({
+        value: {
+          fromAddress: account.address,
+          toAddress: toAddresses[1],
+          amount: [{ denom, amount: '200' }],
+        }
+      }),
+    ])
+
+    expect(isDeliverTxSuccess(result)).toEqual(true)
+
+    // Check that the transfers were successful
+    const cases = [
+      { address: toAddresses[0], wantAmount: '200' },
+      { address: toAddresses[1], wantAmount: '300' },
+    ]
+
+    for (let tc of cases) {
+      let response = await client.CosmosBankV1Beta1.query.queryBalance(tc.address, { denom })
+
+      expect(response.statusText).toEqual('OK')
+      expect(response.data.balance.amount).toEqual(tc.wantAmount)
+    }
+  })
+})