support reading stdout/stderr from streams

It can be useful to let the user run the test command(s) itself, for example
when complex shell scripts are involved which need to invoke `go test` multiple
times.

With -stdin, the `go test` stdout is expected on stdin of gotestsum, so it can
be used in a pipe. To detect abnormal termination of the test commands, bash
with "set -o pipefail" should be used. Beware that such failures are not
detected by gotestsum.

To also capture stderr with gotestsum, stderr must get redirected like this:

   mkfifo /tmp/pipe
   go test ... 2>/tmp/pipe | gotestsum -stdin -stderr 3 3</tmp/pipe

Author: pohly

cmd/main.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"fmt"
@@ -70,6 +71,10 @@ func setupFlags(name string) (*pflag.FlagSet, *options) {
 		"use different icons, see help for options")
 	flags.BoolVar(&opts.rawCommand, "raw-command", false,
 		"don't prepend 'go test -json' to the 'go test' command")
+	flags.BoolVar(&opts.readStdin, "stdin", false,
+		"don't run any command, instead read go test stdout from stdin")
+	flags.IntVar(&opts.readStderrFD, "stderr", 0,
+		"read go test stderr from a certain `file descriptor` (only valid in combination with -stdin)")
 	flags.BoolVar(&opts.ignoreNonJSONOutputLines, "ignore-non-json-output-lines", false,
 		"write non-JSON 'go test' output lines to stderr instead of failing")
 	flags.Lookup("ignore-non-json-output-lines").Hidden = true
@@ -176,6 +181,8 @@ type options struct {
 	formatOptions                testjson.FormatOptions
 	debug                        bool
 	rawCommand                   bool
+	readStdin                    bool
+	readStderrFD                 int
 	ignoreNonJSONOutputLines     bool
 	jsonFile                     string
 	jsonFileTimingEvents         string
@@ -212,6 +219,15 @@ func (o options) Validate() error {
 		return fmt.Errorf("-failfast can not be used with --rerun-fails " +
 			"because not all test cases will run")
 	}
+	if o.rawCommand && o.readStdin {
+		return errors.New("-stdin and -rawCommand are mutually exclusive")
+	}
+	if o.readStdin && len(o.args) > 0 {
+		return fmt.Errorf("-stdin does not support additional arguments (%q)", o.args)
+	}
+	if o.readStderrFD > 0 && !o.readStdin {
+		return errors.New("-stderr depends on -stdin")
+	}
 	return nil
 }
 
@@ -264,29 +280,45 @@ func run(opts *options) error {
 		return err
 	}
 
-	goTestProc, err := startGoTestFn(ctx, "", goTestCmdArgs(opts, rerunOpts{}))
-	if err != nil {
-		return err
-	}
-
 	handler, err := newEventHandler(opts)
 	if err != nil {
 		return err
 	}
 	defer handler.Close() // nolint: errcheck
 	cfg := testjson.ScanConfig{
-		Stdout:                   goTestProc.stdout,
-		Stderr:                   goTestProc.stderr,
 		Handler:                  handler,
 		Stop:                     cancel,
 		IgnoreNonJSONOutputLines: opts.ignoreNonJSONOutputLines,
 	}
+
+	var goTestProc *proc
+	if opts.readStdin {
+		cfg.Stdout = os.Stdin
+		if opts.readStderrFD > 0 {
+			cfg.Stderr = os.NewFile(uintptr(opts.readStderrFD), fmt.Sprintf("go test stderr on fd %d", opts.stderr))
+		} else {
+			cfg.Stderr = bytes.NewReader(nil)
+		}
+	} else {
+		p, err := startGoTestFn(ctx, "", goTestCmdArgs(opts, rerunOpts{}))
+		if err != nil {
+			return err
+		}
+		goTestProc = p
+		cfg.Stdout = p.stdout
+		cfg.Stderr = p.stderr
+	}
+
 	exec, err := testjson.ScanTestOutput(cfg)
 	handler.Flush()
 	if err != nil {
 		return finishRun(opts, exec, err)
 	}
 
+	if opts.readStdin {
+		return finishRun(opts, exec, nil)
+	}
+
 	exitErr := goTestProc.cmd.Wait()
 	if signum := atomic.LoadInt32(&goTestProc.signal); signum != 0 {
 		return finishRun(opts, exec, exitError{num: signalExitCode + int(signum)})

cmd/testdata/gotestsum-help-text

@@ -26,6 +26,8 @@ Flags:
       --rerun-fails-max-failures int                do not rerun any tests if the initial run has more than this number of failures (default 10)
       --rerun-fails-report string                   write a report to the file, of the tests that were rerun
       --rerun-fails-run-root-test                   rerun the entire root testcase when any of its subtests fail, instead of only the failed subtest
+      --stderr file descriptor                      read go test stderr from a certain file descriptor (only valid in combination with -stdin)
+      --stdin                                       don't run any command, instead read go test stdout from stdin
       --version                                     show version and exit
       --watch                                       watch go files, and run tests when a file is modified
       --watch-chdir                                 in watch mode change the working directory to the directory with the modified file before running tests