fix: graceful exit using ctrl+C if not test are running

cmd/main.go

@@ -32,14 +32,17 @@ func Run(name string, args []string) error {
 	opts.args = flags.Args()
 	setupLogging(opts)
 
+	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer cancel()
+
 	switch {
 	case opts.version:
 		fmt.Fprintf(os.Stdout, "gotestsum version %s\n", version)
 		return nil
 	case opts.watch:
-		return runWatcher(opts)
+		return runWatcher(ctx, opts)
 	}
-	return run(opts)
+	return run(ctx, cancel, opts)
 }
 
 func setupFlags(name string) (*pflag.FlagSet, *options) {
@@ -268,10 +271,7 @@ func setupLogging(opts *options) {
 	color.NoColor = opts.noColor
 }
 
-func run(opts *options) error {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
+func run(ctx context.Context, cancel context.CancelFunc, opts *options) error {
 	if err := opts.Validate(); err != nil {
 		return err
 	}
@@ -464,9 +464,8 @@ func startGoTest(ctx context.Context, dir string, args []string) (*proc, error)
 	}
 	log.Debugf("go test pid: %d", cmd.Process.Pid)
 
-	ctx, cancel := context.WithCancel(ctx)
 	newSignalHandler(ctx, cmd.Process.Pid, &p)
-	p.cmd = &cancelWaiter{cancel: cancel, wrapped: p.cmd}
+	p.cmd = &cancelWaiter{wrapped: p.cmd}
 	return &p, nil
 }
 
@@ -510,40 +509,28 @@ func (e exitError) ExitCode() int {
 const signalExitCode = 128
 
 func newSignalHandler(ctx context.Context, pid int, p *proc) {
-	c := make(chan os.Signal, 1)
-	signal.Notify(c, os.Interrupt)
-
 	go func() {
-		defer signal.Stop(c)
-
-		select {
-		case <-ctx.Done():
+		<-ctx.Done() // when ctx is cancelled, find process and kill it
+		atomic.StoreInt32(&p.signal, int32(syscall.SIGINT))
+		proc, err := os.FindProcess(pid)
+		if err != nil {
+			log.Errorf("failed to find pid of 'go test': %v", err)
+			return
+		}
+		if err := proc.Signal(os.Interrupt); err != nil {
+			log.Errorf("failed to interrupt 'go test': %v", err)
 			return
-		case s := <-c:
-			atomic.StoreInt32(&p.signal, int32(s.(syscall.Signal)))
-
-			proc, err := os.FindProcess(pid)
-			if err != nil {
-				log.Errorf("failed to find pid of 'go test': %v", err)
-				return
-			}
-			if err := proc.Signal(s); err != nil {
-				log.Errorf("failed to interrupt 'go test': %v", err)
-				return
-			}
 		}
 	}()
 }
 
 // cancelWaiter wraps a waiter to cancel the context after the wrapped
 // Wait exits.
 type cancelWaiter struct {
-	cancel  func()
 	wrapped waiter
 }
 
 func (w *cancelWaiter) Wait() error {
 	err := w.wrapped.Wait()
-	w.cancel()
 	return err
 }

cmd/main_e2e_test.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"bytes"
+	"context"
 	goversion "go/version"
 	"os"
 	"path/filepath"
@@ -11,14 +12,15 @@ import (
 	"testing"
 	"time"
 
-	"gotest.tools/gotestsum/internal/text"
 	"gotest.tools/v3/assert"
 	"gotest.tools/v3/env"
 	"gotest.tools/v3/fs"
 	"gotest.tools/v3/golden"
 	"gotest.tools/v3/icmd"
 	"gotest.tools/v3/poll"
 	"gotest.tools/v3/skip"
+
+	"gotest.tools/gotestsum/internal/text"
 )
 
 func TestMain(m *testing.M) {
@@ -41,6 +43,10 @@ func TestE2E_RerunFails(t *testing.T) {
 		args        []string
 		expectedErr string
 	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	t.Cleanup(cancel)
+
 	fn := func(t *testing.T, tc testCase) {
 		tmpFile := fs.NewFile(t, t.Name()+"-seedfile", fs.WithContent("0"))
 		defer tmpFile.Remove()
@@ -58,7 +64,9 @@ func TestE2E_RerunFails(t *testing.T) {
 		bufStderr := new(bytes.Buffer)
 		opts.stderr = bufStderr
 
-		err := run(opts)
+		err := run(ctx, cancel, opts)
+		// when we expect an error, it may be wrapped so we do a substring match
+		// rather than an exact match
 		if tc.expectedErr != "" {
 			assert.Error(t, err, tc.expectedErr)
 		} else {
@@ -215,6 +223,9 @@ func TestE2E_MaxFails_EndTestRun(t *testing.T) {
 		t.Skip("too slow for short run")
 	}
 
+	ctx, cancel := context.WithCancel(context.Background())
+	t.Cleanup(cancel)
+
 	tmpFile := fs.NewFile(t, t.Name()+"-seedfile", fs.WithContent("0"))
 	defer tmpFile.Remove()
 
@@ -233,7 +244,7 @@ func TestE2E_MaxFails_EndTestRun(t *testing.T) {
 	bufStderr := new(bytes.Buffer)
 	opts.stderr = bufStderr
 
-	err := run(opts)
+	err := run(ctx, cancel, opts)
 	assert.Error(t, err, "ending test run because max failures was reached")
 	out := text.ProcessLines(t, bufStdout,
 		text.OpRemoveSummaryLineElapsedTime,
@@ -249,6 +260,9 @@ func TestE2E_IgnoresWarnings(t *testing.T) {
 	}
 	t.Setenv("GITHUB_ACTIONS", "no")
 
+	ctx, cancel := context.WithCancel(context.Background())
+	t.Cleanup(cancel)
+
 	flags, opts := setupFlags("gotestsum")
 	args := []string{
 		"--rerun-fails=1",
@@ -264,7 +278,7 @@ func TestE2E_IgnoresWarnings(t *testing.T) {
 	bufStderr := new(bytes.Buffer)
 	opts.stderr = bufStderr
 
-	err := run(opts)
+	err := run(ctx, cancel, opts)
 	assert.Error(t, err, "exit status 1")
 	out := text.ProcessLines(t, bufStdout,
 		text.OpRemoveSummaryLineElapsedTime,

cmd/main_test.go

@@ -2,12 +2,14 @@ package cmd
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strings"
+	"sync"
 	"testing"
 
 	"github.com/fatih/color"
@@ -31,11 +33,15 @@ func TestUsage_WithFlagsFromSetupFlags(t *testing.T) {
 	golden.Assert(t, buf.String(), "gotestsum-help-text")
 }
 
+var noColorMu sync.Mutex // prevent data race in parallel tests
+
 func patchNoColor(t *testing.T, value bool) {
+	noColorMu.Lock()
 	orig := color.NoColor
 	color.NoColor = value
 	t.Cleanup(func() {
 		color.NoColor = orig
+		noColorMu.Unlock()
 	})
 }
 
@@ -338,6 +344,9 @@ func runCase(t *testing.T, name string, fn func(t *testing.T)) {
 }
 
 func TestRun_RerunFails_WithTooManyInitialFailures(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	t.Cleanup(cancel)
+
 	jsonFailed := `{"Package": "pkg", "Action": "run"}
 {"Package": "pkg", "Test": "TestOne", "Action": "run"}
 {"Package": "pkg", "Test": "TestOne", "Action": "fail"}
@@ -367,11 +376,14 @@ func TestRun_RerunFails_WithTooManyInitialFailures(t *testing.T) {
 		stderr:                       os.Stderr,
 		hideSummary:                  newHideSummaryValue(),
 	}
-	err := run(opts)
+	err := run(ctx, cancel, opts)
 	assert.ErrorContains(t, err, "number of test failures (2) exceeds maximum (1)", out.String())
 }
 
 func TestRun_RerunFails_BuildErrorPreventsRerun(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	t.Cleanup(cancel)
+
 	jsonFailed := `{"Package": "pkg", "Action": "run"}
 {"Package": "pkg", "Test": "TestOne", "Action": "run"}
 {"Package": "pkg", "Test": "TestOne", "Action": "fail"}
@@ -401,7 +413,7 @@ func TestRun_RerunFails_BuildErrorPreventsRerun(t *testing.T) {
 		stderr:                       os.Stderr,
 		hideSummary:                  newHideSummaryValue(),
 	}
-	err := run(opts)
+	err := run(ctx, cancel, opts)
 	assert.ErrorContains(t, err, "rerun aborted because previous run had errors", out.String())
 }
 
@@ -415,6 +427,8 @@ func TestRun_RerunFails_PanicPreventsRerun(t *testing.T) {
 {"Package": "pkg", "Test": "TestOne", "Action": "output","Output":"panic: something went wrong\n"}
 {"Package": "pkg", "Action": "fail"}
 `
+	ctx, cancel := context.WithCancel(context.Background())
+	t.Cleanup(cancel)
 
 	fn := func([]string) *proc {
 		return &proc{
@@ -437,14 +451,17 @@ func TestRun_RerunFails_PanicPreventsRerun(t *testing.T) {
 		stderr:                       os.Stderr,
 		hideSummary:                  newHideSummaryValue(),
 	}
-	err := run(opts)
+	err := run(ctx, cancel, opts)
 	assert.ErrorContains(t, err, "rerun aborted because previous run had a suspected panic", out.String())
 }
 
 func TestRun_InputFromStdin(t *testing.T) {
 	stdin := os.Stdin
 	t.Cleanup(func() { os.Stdin = stdin })
 
+	ctx, cancel := context.WithCancel(context.Background())
+	t.Cleanup(cancel)
+
 	r, w, err := os.Pipe()
 	assert.NilError(t, err)
 	t.Cleanup(func() { _ = r.Close() })
@@ -466,7 +483,7 @@ func TestRun_InputFromStdin(t *testing.T) {
 	}()
 
 	stdout := new(bytes.Buffer)
-	err = run(&options{
+	err = run(ctx, cancel, &options{
 		args:        []string{"cat"},
 		format:      "testname",
 		hideSummary: newHideSummaryValue(),
@@ -484,6 +501,9 @@ func TestRun_JsonFileIsSyncedBeforePostRunCommand(t *testing.T) {
 
 	input := golden.Get(t, "../../testjson/testdata/input/go-test-json.out")
 
+	ctx, cancel := context.WithCancel(context.Background())
+	t.Cleanup(cancel)
+
 	fn := func([]string) *proc {
 		return &proc{
 			cmd:    fakeWaiter{},
@@ -510,7 +530,7 @@ func TestRun_JsonFileIsSyncedBeforePostRunCommand(t *testing.T) {
 			command: []string{"cat", jsonFile},
 		},
 	}
-	err := run(opts)
+	err := run(ctx, cancel, opts)
 	assert.NilError(t, err)
 	expected := string(input)
 	_, actual, _ := strings.Cut(out.String(), "s\n") // remove the DONE line
@@ -520,6 +540,9 @@ func TestRun_JsonFileIsSyncedBeforePostRunCommand(t *testing.T) {
 func TestRun_JsonFileTimingEvents(t *testing.T) {
 	input := golden.Get(t, "../../testjson/testdata/input/go-test-json.out")
 
+	ctx, cancel := context.WithCancel(context.Background())
+	t.Cleanup(cancel)
+
 	fn := func([]string) *proc {
 		return &proc{
 			cmd:    fakeWaiter{},
@@ -543,7 +566,7 @@ func TestRun_JsonFileTimingEvents(t *testing.T) {
 		hideSummary:          &hideSummaryValue{value: testjson.SummarizeNone},
 		jsonFileTimingEvents: jsonFileTiming,
 	}
-	err := run(opts)
+	err := run(ctx, cancel, opts)
 	assert.NilError(t, err)
 
 	raw, err := os.ReadFile(jsonFileTiming)

cmd/watch.go

@@ -11,10 +11,7 @@ import (
 	"gotest.tools/gotestsum/testjson"
 )
 
-func runWatcher(opts *options) error {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
+func runWatcher(ctx context.Context, opts *options) error {
 	w := &watchRuns{opts: *opts}
 	return filewatcher.Watch(ctx, opts.packages, opts.watchClear, w.run)
 }
@@ -24,7 +21,7 @@ type watchRuns struct {
 	prevExec *testjson.Execution
 }
 
-func (w *watchRuns) run(event filewatcher.Event) error {
+func (w *watchRuns) run(ctx context.Context, event filewatcher.Event) error {
 	if event.Debug {
 		path, cleanup, err := delveInitFile(w.prevExec)
 		if err != nil {
@@ -53,7 +50,7 @@ func (w *watchRuns) run(event filewatcher.Event) error {
 	opts.packages = append(opts.packages, event.Args...)
 
 	var err error
-	if w.prevExec, err = runSingle(&opts, dir); !IsExitCoder(err) {
+	if w.prevExec, err = runSingle(ctx, &opts, dir); !IsExitCoder(err) {
 		return err
 	}
 	return nil
@@ -62,8 +59,8 @@ func (w *watchRuns) run(event filewatcher.Event) error {
 // runSingle is similar to run. It doesn't support rerun-fails. It may be
 // possible to share runSingle with run, but the defer close on the handler
 // would require at least 3 return values, so for now it is a copy.
-func runSingle(opts *options, dir string) (*testjson.Execution, error) {
-	ctx, cancel := context.WithCancel(context.Background())
+func runSingle(ctx context.Context, opts *options, dir string) (*testjson.Execution, error) {
+	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
 	if err := opts.Validate(); err != nil {