feat: add txtar driver for gnoland integration test

.github/workflows/gnoland.yml

@@ -73,7 +73,14 @@ jobs:
         run: |
           export GOPATH=$HOME/go
           export GOTEST_FLAGS="-v -p 1 -timeout=30m -coverprofile=coverage.out -covermode=atomic"
+          export LOG_DIR="${{ runner.temp }}/logs/test-${{ matrix.goversion }}-gnoland"
           make ${{ matrix.args }}
+      - name: Upload Test Log
+        if: always() 
+        uses: actions/upload-artifact@v3
+        with:
+          name: logs-test-gnoland-go${{ matrix.goversion }}
+          path: ${{ runner.temp }}/logs/**/*.log
       - uses: actions/upload-artifact@v3
         if: ${{ runner.os == 'Linux' && matrix.goversion == '1.21.x' }}
         with:

Dockerfile

@@ -17,7 +17,8 @@ RUN         rm -rf /opt/gno/src/.git
 
 # runtime-base + runtime-tls
 FROM        debian:stable-slim AS runtime-base
-ENV         PATH="${PATH}:/opt/gno/bin"
+ENV         PATH="${PATH}:/opt/gno/bin" \
+            GNOROOT="/opt/gno/src"
 WORKDIR     /opt/gno/src
 FROM        runtime-base AS runtime-tls
 RUN         apt-get update && apt-get install -y expect ca-certificates && update-ca-certificates

docs/testing_guide.md

@@ -0,0 +1,86 @@
+# Gnoland Testing Guide
+
+This guide provides an overview of our testing practices and conventions. While most of our testing aligns with typical Go practices, there are exceptions and specifics you should be aware of.
+
+## Standard Package Testing
+
+For most packages, tests are written and executed in the standard Go manner:
+
+- Tests are located alongside the code they test.
+- The `go test` command can be used to execute tests.
+
+However, as mentioned earlier, there are some exceptions. In the following sections, we will explore our specialized tests and how to work with them.
+
+## Gno Filetests
+
+**Location:** `gnovm/test/files`
+
+These are our custom file-based tests tailored specifically for this project.
+
+**Execution:** 
+
+From the gnovm directory, There are two main commands to run Gno filetests:
+
+1. To test native files, use:
+```
+make _test.gnolang.native
+```
+
+2. To test standard libraries, use:
+```
+make _test.gnolang.stdlibs
+```
+
+**Golden Files Update:** 
+
+Golden files are references for expected outputs. Sometimes, after certain updates, these need to be synchronized. To do so:
+
+1. For native tests:
+```
+make _test.gnolang.native.sync
+```
+
+2. For standard library tests:
+```
+make _test.gnolang.stdlibs.sync
+```
+
+## Integration Tests
+
+**Location:** `gno.land/**/testdata`
+
+From the gno.land directory, Integration tests are designed to ensure different parts of the project work cohesively. Specifically:
+
+1. **InMemory Node Integration Testing:**  
+   Found in `gno.land/cmd/gnoland/testdata`, these are dedicated to running integration tests against a genuine `gnoland` node.
+
+2. **Integration Features Testing:**  
+   Located in `gno.land/pkg/integration/testdata`, these tests target integrations specific commands.
+
+These integration tests utilize the `testscript` package and follow the `txtar` file specifications. 
+
+**Documentation:**
+
+- For general `testscript` package documentation, refer to: [testscript documentation](https://github.com/rogpeppe/go-internal/blob/v1.11.0/testscript/doc.go)
+
+- For more specific details about our integration tests, consult our extended documentation: [gnoland integration documentation](https://github.com/gnolang/gno/blob/master/gno.land/pkg/integration/doc.go)
+
+**Execution:** 
+
+To run the integration tests (alongside other packages):
+
+```
+make _test.pkgs
+```
+
+**Golden Files Update within txtar:** 
+
+For tests utilizing the `cmp` command inside `txtar` files, golden files can be synchronized using:
+
+```
+make _test.pkgs.sync
+```
+
+---
+
+As the project evolves, this guide might be updated. 

gno.land/Makefile

@@ -47,7 +47,10 @@ test: _test.gnoland _test.gnoweb _test.gnokey _test.pkgs
 
 GOTEST_FLAGS ?= -v -p 1 -timeout=30m
 
-_test.gnoland:; go test $(GOTEST_FLAGS) ./cmd/gnoland
-_test.gnoweb:;  go test $(GOTEST_FLAGS) ./cmd/gnoweb
-_test.gnokey:;  go test $(GOTEST_FLAGS) ./cmd/gnokey
-_test.pkgs:;    go test $(GOTEST_FLAGS) ./pkg/...
+_test.gnoland:;      go test $(GOTEST_FLAGS) ./cmd/gnoland
+_test.gnoweb:;       go test $(GOTEST_FLAGS) ./cmd/gnoweb
+_test.gnokey:;       go test $(GOTEST_FLAGS) ./cmd/gnokey
+_test.pkgs:;         go test $(GOTEST_FLAGS) ./pkg/...
+_test.pkgs.sync:;    UPDATE_SCRIPTS=true go test $(GOTEST_FLAGS) ./pkg/...
+
+

gno.land/cmd/gnokey/main.go

@@ -5,11 +5,12 @@
 	"fmt"
 	"os"
 
+	"github.com/gnolang/gno/tm2/pkg/commands"
 	"github.com/gnolang/gno/tm2/pkg/crypto/keys/client"
 )
 
 func main() {
-	cmd := client.NewRootCmd()
+	cmd := client.NewRootCmd(commands.NewDefaultIO())
 
 	if err := cmd.ParseAndRun(context.Background(), os.Args[1:]); err != nil {
 		_, _ = fmt.Fprintf(os.Stderr, "%+v\n", err)

gno.land/cmd/gnoland/integration_test.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/gnolang/gno/gno.land/pkg/integration"
+	"github.com/rogpeppe/go-internal/testscript"
+)
+
+func TestTestdata(t *testing.T) {
+	testscript.Run(t, integration.SetupGnolandTestScript(t, "testdata"))
+}

gno.land/cmd/gnoland/testdata/addpkg.txtar

@@ -0,0 +1,26 @@
+# test for add package
+
+## start a new node
+gnoland start
+
+## add bar.gno package located in $WORK directory as gno.land/r/foobar/bar
+gnokey maketx addpkg -pkgdir $WORK -pkgpath gno.land/r/foobar/bar -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
+
+## execute Render
+gnokey maketx call -pkgpath gno.land/r/foobar/bar -func Render -gas-fee 1000000ugnot -gas-wanted 2000000 -args '' -broadcast -chainid=tendermint_test test1
+
+## compare render
+cmp stdout stdout.golden
+
+-- bar.gno --
+package bar
+
+func Render(path string) string {
+ 	return "hello from foo"
+}
+
+-- stdout.golden --
+("hello from foo" string)
+OK!
+GAS WANTED: 2000000
+GAS USED:   69163

gno.land/pkg/gnoland/app.go

@@ -2,6 +2,8 @@ package gnoland
 
 import (
 	"fmt"
+	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 
@@ -20,34 +22,62 @@ import (
 	"github.com/gnolang/gno/tm2/pkg/store/iavl"
 )
 
+type AppOptions struct {
+	DB dbm.DB
+	// `gnoRootDir` should point to the local location of the gno repository.
+	// It serves as the gno equivalent of GOROOT.
+	GnoRootDir            string
+	SkipFailingGenesisTxs bool
+	Logger                log.Logger
+	MaxCycles             int64
+}
+
+func NewAppOptions() *AppOptions {
+	return &AppOptions{
+		Logger:     log.NewNopLogger(),
+		DB:         dbm.NewMemDB(),
+		GnoRootDir: GuessGnoRootDir(),
+	}
+}
+
+func (c *AppOptions) validate() error {
+	if c.Logger == nil {
+		return fmt.Errorf("no logger provided")
+	}
+
+	if c.DB == nil {
+		return fmt.Errorf("no db provided")
+	}
+
+	return nil
+}
+
 // NewApp creates the GnoLand application.
-func NewApp(rootDir string, skipFailingGenesisTxs bool, logger log.Logger, maxCycles int64) (abci.Application, error) {
-	// Get main DB.
-	db, err := dbm.NewDB("gnolang", dbm.GoLevelDBBackend, filepath.Join(rootDir, "data"))
-	if err != nil {
-		return nil, fmt.Errorf("error initializing database %q using path %q: %w", dbm.GoLevelDBBackend, rootDir, err)
+func NewAppWithOptions(cfg *AppOptions) (abci.Application, error) {
+	if err := cfg.validate(); err != nil {
+		return nil, err
 	}
 
 	// Capabilities keys.
 	mainKey := store.NewStoreKey("main")
 	baseKey := store.NewStoreKey("base")
 
 	// Create BaseApp.
-	baseApp := sdk.NewBaseApp("gnoland", logger, db, baseKey, mainKey)
+	baseApp := sdk.NewBaseApp("gnoland", cfg.Logger, cfg.DB, baseKey, mainKey)
 	baseApp.SetAppVersion("dev")
 
 	// Set mounts for BaseApp's MultiStore.
-	baseApp.MountStoreWithDB(mainKey, iavl.StoreConstructor, db)
-	baseApp.MountStoreWithDB(baseKey, dbadapter.StoreConstructor, db)
+	baseApp.MountStoreWithDB(mainKey, iavl.StoreConstructor, cfg.DB)
+	baseApp.MountStoreWithDB(baseKey, dbadapter.StoreConstructor, cfg.DB)
 
 	// Construct keepers.
 	acctKpr := auth.NewAccountKeeper(mainKey, ProtoGnoAccount)
 	bankKpr := bank.NewBankKeeper(acctKpr)
-	stdlibsDir := filepath.Join("..", "gnovm", "stdlibs")
-	vmKpr := vm.NewVMKeeper(baseKey, mainKey, acctKpr, bankKpr, stdlibsDir, maxCycles)
+	stdlibsDir := filepath.Join(cfg.GnoRootDir, "gnovm", "stdlibs")
+	vmKpr := vm.NewVMKeeper(baseKey, mainKey, acctKpr, bankKpr, stdlibsDir, cfg.MaxCycles)
 
 	// Set InitChainer
-	baseApp.SetInitChainer(InitChainer(baseApp, acctKpr, bankKpr, skipFailingGenesisTxs))
+	baseApp.SetInitChainer(InitChainer(baseApp, acctKpr, bankKpr, cfg.SkipFailingGenesisTxs))
 
 	// Set AnteHandler
 	authOptions := auth.AnteOptions{
@@ -88,6 +118,23 @@ func NewApp(rootDir string, skipFailingGenesisTxs bool, logger log.Logger, maxCy
 	return baseApp, nil
 }
 
+// NewApp creates the GnoLand application.
+func NewApp(dataRootDir string, skipFailingGenesisTxs bool, logger log.Logger, maxCycles int64) (abci.Application, error) {
+	var err error
+
+	cfg := NewAppOptions()
+
+	// Get main DB.
+	cfg.DB, err = dbm.NewDB("gnolang", dbm.GoLevelDBBackend, filepath.Join(dataRootDir, "data"))
+	if err != nil {
+		return nil, fmt.Errorf("error initializing database %q using path %q: %w", dbm.GoLevelDBBackend, dataRootDir, err)
+	}
+
+	cfg.Logger = logger
+
+	return NewAppWithOptions(cfg)
+}
+
 // InitChainer returns a function that can initialize the chain with genesis.
 func InitChainer(baseApp *sdk.BaseApp, acctKpr auth.AccountKeeperI, bankKpr bank.BankKeeperI, skipFailingGenesisTxs bool) func(sdk.Context, abci.RequestInitChain) abci.ResponseInitChain {
 	return func(ctx sdk.Context, req abci.RequestInitChain) abci.ResponseInitChain {
@@ -107,14 +154,15 @@ func InitChainer(baseApp *sdk.BaseApp, acctKpr auth.AccountKeeperI, bankKpr bank
 		for i, tx := range genState.Txs {
 			res := baseApp.Deliver(tx)
 			if res.IsErr() {
-				fmt.Println("ERROR LOG:", res.Log)
-				fmt.Println("#", i, string(amino.MustMarshalJSON(tx)))
+				ctx.Logger().Error("LOG", res.Log)
+				ctx.Logger().Error("#", i, string(amino.MustMarshalJSON(tx)))
+
 				// NOTE: comment out to ignore.
 				if !skipFailingGenesisTxs {
 					panic(res.Error)
 				}
 			} else {
-				fmt.Println("SUCCESS:", string(amino.MustMarshalJSON(tx)))
+				ctx.Logger().Info("SUCCESS:", string(amino.MustMarshalJSON(tx)))
 			}
 		}
 		// Done!
@@ -146,3 +194,25 @@ func EndBlocker(vmk vm.VMKeeperI) func(ctx sdk.Context, req abci.RequestEndBlock
 		return abci.ResponseEndBlock{}
 	}
 }
+
+func GuessGnoRootDir() string {
+	var rootdir string
+
+	// First try to get the root directory from the GNOROOT environment variable.
+	if rootdir = os.Getenv("GNOROOT"); rootdir != "" {
+		return filepath.Clean(rootdir)
+	}
+
+	if gobin, err := exec.LookPath("go"); err == nil {
+		// If GNOROOT is not set, try to guess the root directory using the `go list` command.
+		cmd := exec.Command(gobin, "list", "-m", "-mod=mod", "-f", "{{.Dir}}", "github.com/gnolang/gno")
+		out, err := cmd.CombinedOutput()
+		if err != nil {
+			panic(fmt.Errorf("invalid gno directory %q: %w", rootdir, err))
+		}
+
+		return strings.TrimSpace(string(out))
+	}
+
+	panic("no go binary available, unable to determine gno root-dir path")
+}