example using go test to replace/wrap shell tests in tw

README.md

example go test wrapping or replacing shell tests in tw

tw has a 'gem-check' test.

The test is shell code that invokes ruby and looks at output.

I think we can use the functionality in 'go test' to replace a lot of the "shell test infrastructure".

'gem_test.go' here replaces the --require= functionality in seen there in gem-check.

The benefits are:

• less shell footguns.
• standard output of 'go test'
• easy re-use of golang function
• no dependencies on /bin/sh (or grep, tee, busybox, sed, awk...) inside the test environment.

example run [pass]

You can run this example here just like this.

$ go test -args rake
PASS
ok  	example.com/gemcheck	0.081s

example run [fail]

$ go test -args gofoo rake
testing gofoo
testing rake
--- FAIL: TestGem (0.09s)
    --- FAIL: TestGem/gofoo (0.03s)
        gem_test.go:57: Failed require 'gofoo': stderr: 
            stdout: require gofoo: cannot load such file -- gofoo
FAIL
exit status 1
FAIL	example.com/gemcheck	0.098s

TODO

One way to include this would be to create a multi-call binary in go that would take a 'gem-check' subcommand and then call it from the pipeline. Such as:

$ tw-checks gem-check --require=rake

Other subcommands of tw-checks could just as easily replace other shell programs like ldd-check or header-check

gem_test.go

package main

import (
	"bytes"
	"os"
	"os/exec"
	"strings"
	"testing"
)

func exeCmd(command string, args ...string) (string, string, error, int) {
	cmd := exec.Command(command, args...)

	var stdoutBuf, stderrBuf bytes.Buffer
	cmd.Stdout = &stdoutBuf
	cmd.Stderr = &stderrBuf
	var rc int

	err := cmd.Run()
	if err != nil {
		if exitError, ok := err.(*exec.ExitError); ok {
			rc = exitError.ExitCode()
			err = nil
		}
	}

	stdout := stdoutBuf.String()
	stderr := stderrBuf.String()

	return stdout, stderr, err, rc
}

func ruby_require(r string) (string, string, error, int) {
	blob := `\
#!/usr/bin/ruby
r = ARGV[0]
begin
  require r
  print "pass"
  exit 0
rescue LoadError => error
  print "require #{r}: #{error}"
  exit 3
end
exit 9
`
	return exeCmd("ruby", "-e", blob, r)
}

func testRequire(t *testing.T, req string) {
	stdout, stderr, err, rc := ruby_require(req)
	if rc == 0 {
		return
	}
	if rc == 3 {
		t.Errorf("Failed require '%s': stderr: %s\nstdout: %s\n",
			req, stderr, stdout)
		return
	}
	t.Errorf("Unexpected rc %d on import '%s'. err=%v.\nstderr: %s\nstdout: %s\n",
		rc, req, err, stderr, stdout)
	return
}

func TestGem(t *testing.T) {
	if len(os.Args) < 1 {
		t.Error("must supply things to check")
	}
	reqs := []string{}
	for _, r := range os.Args[1:] {
		if !strings.HasPrefix(r, "-") {
			reqs = append(reqs, r)
		}
	}
	for _, r := range reqs {
		t.Run(r, func(t *testing.T) { testRequire(t, r) })
	}
}

go.mod

module example.com/gemcheck

go 1.22.4