From 6949a9549b87160c2de7f088bbc584b6da5af8ed Mon Sep 17 00:00:00 2001 From: Samuel K Date: Mon, 9 Nov 2026 10:17:36 -0600 Subject: [PATCH] fix(e2e): prevent blocked live output from hanging commands --- e2e/framework/exec.go | 33 ++++-- e2e/framework/exec_capture_test.go | 107 ++++++++++++++++++ e2e/framework/framework.go | 11 +- e2e/framework/internal/livetee/tee.go | 93 +++++++++++++++ e2e/framework/internal/livetee/tee_test.go | 82 ++++++++++++++ e2e/framework/runenv/dependencies.go | 18 ++- e2e/framework/runenv/exec.go | 75 +++--------- e2e/framework/runenv/exec_test.go | 82 +++++++++++--- .../provider_kubernetes_image_config_file.go | 16 +-- hack/ci/suites.yaml | 1 + 10 files changed, 412 insertions(+), 106 deletions(-) create mode 100644 e2e/framework/exec_capture_test.go create mode 100644 e2e/framework/internal/livetee/tee.go create mode 100644 e2e/framework/internal/livetee/tee_test.go diff --git a/e2e/framework/exec.go b/e2e/framework/exec.go index 3af73a9fc3..b23aeddfe2 100644 --- a/e2e/framework/exec.go +++ b/e2e/framework/exec.go @@ -5,13 +5,13 @@ import ( "context" "encoding/json" "fmt" - "io" "os" "os/exec" "path/filepath" "strings" "time" + "github.com/devsy-org/devsy/e2e/framework/internal/livetee" "github.com/devsy-org/devsy/pkg/docker" ) @@ -29,10 +29,16 @@ func (f *Framework) ExecCommandOutput(ctx context.Context, args []string) (strin cmd := exec.CommandContext(ctx, filepath.Join(f.DevsyBinDir, f.DevsyBinName), args...) docker.PrepareForGroupCancellation(cmd) cmd.WaitDelay = execWaitDelay - cmd.Stdout = io.MultiWriter(os.Stdout, &execOut) + outTee := livetee.New(&execOut, os.Stdout) + cmd.Stdout = outTee cmd.Stderr = os.Stderr - if err := cmd.Run(); err != nil { + err := cmd.Run() + f.liveStdoutDropped.Add(outTee.Close()) + if err != nil { + if ctx.Err() != nil { + return execOut.String(), ctx.Err() + } return "", err } @@ -67,10 +73,16 @@ func (f *Framework) ExecCommandContaining( cmd := exec.CommandContext(ctx, filepath.Join(f.DevsyBinDir, f.DevsyBinName), args...) docker.PrepareForGroupCancellation(cmd) cmd.WaitDelay = execWaitDelay - cmd.Stdout = io.MultiWriter(os.Stdout, &execOut) + outTee := livetee.New(&execOut, os.Stdout) + cmd.Stdout = outTee cmd.Stderr = os.Stderr - if err := cmd.Run(); err != nil { + err := cmd.Run() + f.liveStdoutDropped.Add(outTee.Close()) + if err != nil { + if ctx.Err() != nil { + return ctx.Err() + } return err } @@ -91,10 +103,17 @@ func (f *Framework) ExecCommandCapture(ctx context.Context, args []string) (stri cmd := exec.CommandContext(ctx, filepath.Join(f.DevsyBinDir, f.DevsyBinName), args...) docker.PrepareForGroupCancellation(cmd) cmd.WaitDelay = execWaitDelay - cmd.Stdout = io.MultiWriter(os.Stdout, &execOut) - cmd.Stderr = io.MultiWriter(os.Stderr, &execErr) + outTee := livetee.New(&execOut, os.Stdout) + cmd.Stdout = outTee + errTee := livetee.New(&execErr, os.Stderr) + cmd.Stderr = errTee err := cmd.Run() + f.liveStdoutDropped.Add(outTee.Close()) + f.liveStderrDropped.Add(errTee.Close()) + if err != nil && ctx.Err() != nil { + err = ctx.Err() + } return execOut.String(), execErr.String(), err } diff --git a/e2e/framework/exec_capture_test.go b/e2e/framework/exec_capture_test.go new file mode 100644 index 0000000000..330d988f14 --- /dev/null +++ b/e2e/framework/exec_capture_test.go @@ -0,0 +1,107 @@ +package framework + +import ( + "context" + "fmt" + "io" + "os" + "os/exec" + "path/filepath" + "strings" + "testing" + "time" + + "github.com/stretchr/testify/suite" +) + +func TestCaptureChild(t *testing.T) { + switch os.Getenv("DEVSY_CAPTURE_CHILD") { + case "exit": + _, _ = fmt.Fprint(os.Stdout, "stdout") + _, _ = fmt.Fprint(os.Stderr, "stderr") + os.Exit(3) + case "blocked": + _, _ = fmt.Fprint(os.Stdout, strings.Repeat("x", 2<<20)) + _, _ = fmt.Fprint(os.Stderr, "ready") + time.Sleep(time.Minute) + os.Exit(0) + } +} + +type captureSuite struct{ suite.Suite } + +func TestCaptureSuite(t *testing.T) { suite.Run(t, new(captureSuite)) } +func (s *captureSuite) TestExit() { + s.T().Setenv("DEVSY_CAPTURE_CHILD", "exit") + out, stderr, err := s.framework(). + ExecCommandCapture(context.Background(), []string{"-test.run=^TestCaptureChild$"}) + var exit *exec.ExitError + s.Require().ErrorAs(err, &exit) + s.Equal(3, exit.ExitCode()) + s.Equal("stdout", out) + s.Equal("stderr", stderr) +} + +func (s *captureSuite) TestBlockedLiveOutput() { + s.T().Setenv("DEVSY_CAPTURE_CHILD", "blocked") + outRead, outWrite, err := os.Pipe() + s.Require().NoError(err) + errRead, errWrite, err := os.Pipe() + s.Require().NoError(err) + oldOut, oldErr := os.Stdout, os.Stderr + os.Stdout, os.Stderr = outWrite, errWrite + defer func() { + os.Stdout, os.Stderr = oldOut, oldErr + _ = outRead.Close() + _ = outWrite.Close() + _ = errRead.Close() + _ = errWrite.Close() + }() + f := s.framework() + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + type result struct { + out, stderr string + err error + } + done := make(chan result, 1) + go func() { + out, stderr, err := f.ExecCommandCapture(ctx, []string{"-test.run=^TestCaptureChild$"}) + done <- result{out, stderr, err} + }() + ready := make(chan error, 1) + go func() { + b := make([]byte, 5) + _, err := io.ReadFull(errRead, b) + if err == nil && string(b) != "ready" { + err = fmt.Errorf("unexpected stderr %q", b) + } + ready <- err + }() + select { + case err := <-ready: + s.Require().NoError(err) + case <-time.After(15 * time.Second): + s.FailNow("child did not complete output") + } + cancel() + select { + case got := <-done: + s.ErrorIs(got.err, context.Canceled) + s.Equal(strings.Repeat("x", 2<<20), got.out) + s.Equal("ready", got.stderr) + dropped, _ := f.LiveOutputDropped() + s.Positive(dropped) + case <-time.After(40 * time.Second): + s.FailNow("capture did not return") + } +} + +func (s *captureSuite) framework() *Framework { + executable, err := os.Executable() + s.Require().NoError(err) + return &Framework{ + DevsyBinDir: filepath.Dir(executable), + DevsyBinName: filepath.Base(executable), + } +} diff --git a/e2e/framework/framework.go b/e2e/framework/framework.go index f4b81784bb..ceb97e00f7 100644 --- a/e2e/framework/framework.go +++ b/e2e/framework/framework.go @@ -2,11 +2,14 @@ package framework import ( "runtime" + "sync/atomic" ) type Framework struct { - DevsyBinDir string - DevsyBinName string + DevsyBinDir string + DevsyBinName string + liveStdoutDropped atomic.Int64 + liveStderrDropped atomic.Int64 } func NewDefaultFramework(path string) *Framework { @@ -33,3 +36,7 @@ func NewDefaultFramework(path string) *Framework { return &Framework{DevsyBinDir: path, DevsyBinName: binName} } + +func (f *Framework) LiveOutputDropped() (int64, int64) { + return f.liveStdoutDropped.Load(), f.liveStderrDropped.Load() +} diff --git a/e2e/framework/internal/livetee/tee.go b/e2e/framework/internal/livetee/tee.go new file mode 100644 index 0000000000..3301227bb7 --- /dev/null +++ b/e2e/framework/internal/livetee/tee.go @@ -0,0 +1,93 @@ +package livetee + +import ( + "io" + "sync" + "time" +) + +const ( + chunkSize = 8 << 10 + queueChunks = 128 + drainTimeout = 100 * time.Millisecond +) + +type Tee struct { + capture io.Writer + chunks chan []byte + done chan struct{} + mu sync.Mutex + queued int64 + dropped int64 + stopped bool +} + +func New(capture, live io.Writer) *Tee { + t := &Tee{capture: capture} + if live != nil { + t.chunks = make(chan []byte, queueChunks) + t.done = make(chan struct{}) + go t.run(live) + } + return t +} + +func (t *Tee) Write(p []byte) (int, error) { + n, err := t.capture.Write(p) + if t.chunks == nil { + return n, err + } + for remaining := p[:n]; len(remaining) > 0; { + size := min(len(remaining), chunkSize) + chunk := make([]byte, size) + copy(chunk, remaining[:size]) + t.mu.Lock() + select { + case t.chunks <- chunk: + t.queued += int64(size) + default: + t.dropped += int64(size) + } + t.mu.Unlock() + remaining = remaining[size:] + } + return n, err +} + +func (t *Tee) Close() int64 { + if t.chunks != nil { + close(t.chunks) + timer := time.NewTimer(drainTimeout) + defer timer.Stop() + select { + case <-t.done: + case <-timer.C: + t.mu.Lock() + t.stopped = true + t.dropped += t.queued + t.queued = 0 + t.mu.Unlock() + } + } + t.mu.Lock() + defer t.mu.Unlock() + return t.dropped +} + +func (t *Tee) run(live io.Writer) { + defer close(t.done) + for chunk := range t.chunks { + t.mu.Lock() + if t.stopped { + t.mu.Unlock() + return + } + t.queued -= int64(len(chunk)) + t.mu.Unlock() + n, _ := live.Write(chunk) + n = max(0, min(n, len(chunk))) + t.mu.Lock() + t.dropped += int64(len(chunk) - n) + t.mu.Unlock() + } +} diff --git a/e2e/framework/internal/livetee/tee_test.go b/e2e/framework/internal/livetee/tee_test.go new file mode 100644 index 0000000000..df06a2cf1f --- /dev/null +++ b/e2e/framework/internal/livetee/tee_test.go @@ -0,0 +1,82 @@ +package livetee + +import ( + "bytes" + "io" + "sync/atomic" + "testing" + "time" + + "github.com/stretchr/testify/suite" +) + +type teeSuite struct{ suite.Suite } + +func TestTeeSuite(t *testing.T) { suite.Run(t, new(teeSuite)) } + +type blockedWriter struct { + entered chan struct{} + release chan struct{} + writes atomic.Int64 +} + +func (w *blockedWriter) Write(p []byte) (int, error) { + w.writes.Add(1) + select { + case <-w.entered: + default: + close(w.entered) + } + <-w.release + return len(p), nil +} + +func (s *teeSuite) TestBlockedDropsAndReleases() { + w := &blockedWriter{entered: make(chan struct{}), release: make(chan struct{})} + var captured bytes.Buffer + tee := New(&captured, w) + _, err := tee.Write([]byte("first")) + s.Require().NoError(err) + select { + case <-w.entered: + case <-time.After(5 * time.Second): + s.FailNow("writer not entered") + } + payload := bytes.Repeat([]byte("x"), (queueChunks+2)*chunkSize) + _, err = tee.Write(payload) + s.Require().NoError(err) + s.Equal(int64((queueChunks+2)*chunkSize), tee.Close()) + s.Equal(append([]byte("first"), payload...), captured.Bytes()) + close(w.release) + select { + case <-tee.done: + s.Equal(int64(1), w.writes.Load()) + case <-time.After(5 * time.Second): + s.FailNow("writer did not finish") + } +} + +func (s *teeSuite) TestLiveOrder() { + var captured, live bytes.Buffer + tee := New(&captured, &live) + for _, part := range []string{"one", "two", "three"} { + _, err := tee.Write([]byte(part)) + s.Require().NoError(err) + } + s.Zero(tee.Close()) + s.Equal("onetwothree", captured.String()) + s.Equal(captured.String(), live.String()) +} + +type shortWriter struct{} + +func (shortWriter) Write(p []byte) (int, error) { return len(p) / 2, io.ErrShortWrite } + +func (s *teeSuite) TestShortWriteCountsDroppedBytes() { + var captured bytes.Buffer + tee := New(&captured, shortWriter{}) + _, err := tee.Write([]byte("123456")) + s.Require().NoError(err) + s.Equal(int64(3), tee.Close()) + s.Equal("123456", captured.String()) +} diff --git a/e2e/framework/runenv/dependencies.go b/e2e/framework/runenv/dependencies.go index 849e80f98b..33cb5242b6 100644 --- a/e2e/framework/runenv/dependencies.go +++ b/e2e/framework/runenv/dependencies.go @@ -30,19 +30,17 @@ type Command struct { Dir string Timeout time.Duration CancelProcessGroup bool - // Stdout and Stderr optionally receive output live, in addition to the - // tail-capped capture returned in CommandResult. - Stdout io.Writer - Stderr io.Writer + Stdout io.Writer + Stderr io.Writer } -// CommandResult is the bounded outcome of a Command. Stdout and Stderr hold -// only the last maxCaptureBytes of output. type CommandResult struct { - ExitCode int // -1 when the process did not exit normally - Stdout string - Stderr string - TimedOut bool + ExitCode int // -1 when the process did not exit normally + Stdout string + Stderr string + StdoutDropped int64 + StderrDropped int64 + TimedOut bool } // Runner executes a Command. A nonzero exit status is reported through diff --git a/e2e/framework/runenv/exec.go b/e2e/framework/runenv/exec.go index 8ff84f9daa..bdb42a577e 100644 --- a/e2e/framework/runenv/exec.go +++ b/e2e/framework/runenv/exec.go @@ -1,24 +1,22 @@ package runenv import ( + "bytes" "context" "errors" "fmt" - "io" "os" "os/exec" "regexp" "runtime" "strings" - "sync" "time" + "github.com/devsy-org/devsy/e2e/framework/internal/livetee" "github.com/devsy-org/devsy/pkg/docker" ) const ( - // maxCaptureBytes bounds each captured stream; older output is dropped. - maxCaptureBytes = 64 << 10 // waitDelay bounds how long Wait lingers on pipes held by orphaned children. waitDelay = 5 * time.Second redacted = "[REDACTED]" @@ -26,7 +24,6 @@ const ( minSecretLen = 6 ) -// ExecRunner runs real subprocesses with bounded capture and a hard timeout. type ExecRunner struct{} func (ExecRunner) Run(ctx context.Context, c Command) (CommandResult, error) { @@ -38,7 +35,8 @@ func (ExecRunner) Run(ctx context.Context, c Command) (CommandResult, error) { ctx, cancel = context.WithTimeout(ctx, c.Timeout) defer cancel() } - stdout, stderr := newTailBuffer(maxCaptureBytes), newTailBuffer(maxCaptureBytes) + var stdout, stderr bytes.Buffer + outTee, errTee := livetee.New(&stdout, c.Stdout), livetee.New(&stderr, c.Stderr) //nolint:gosec // G204: ExecRunner runs the command its caller specified, by design cmd := exec.CommandContext(ctx, c.Path, c.Args...) if c.CancelProcessGroup { @@ -47,11 +45,17 @@ func (ExecRunner) Run(ctx context.Context, c Command) (CommandResult, error) { cmd.Dir = c.Dir cmd.Env = overlayEnv(os.Environ(), c.Env, runtime.GOOS == "windows") cmd.WaitDelay = waitDelay - cmd.Stdout = teeWriter(stdout, c.Stdout) - cmd.Stderr = teeWriter(stderr, c.Stderr) + cmd.Stdout = outTee + cmd.Stderr = errTee err := cmd.Run() - res := CommandResult{Stdout: stdout.String(), Stderr: stderr.String()} + outDropped, errDropped := outTee.Close(), errTee.Close() + res := CommandResult{ + Stdout: stdout.String(), + Stderr: stderr.String(), + StdoutDropped: outDropped, + StderrDropped: errDropped, + } return finishRun(ctx, c.Path, res, err) } @@ -71,6 +75,10 @@ func finishRun( res.ExitCode, res.TimedOut = -1, true return res, nil } + if ctxErr := ctx.Err(); ctxErr != nil { + res.ExitCode = -1 + return res, ctxErr + } if exitErr, ok := errors.AsType[*exec.ExitError](err); ok { res.ExitCode = exitErr.ExitCode() return res, nil @@ -83,55 +91,6 @@ func finishRun( return res, fmt.Errorf("run %s: %w", path, err) } -func teeWriter(capture io.Writer, live io.Writer) io.Writer { - if live == nil { - return capture - } - return io.MultiWriter(capture, live) -} - -// tailBuffer keeps the last limit bytes written to it. -type tailBuffer struct { - mu sync.Mutex - limit int - buf []byte - dropped int64 -} - -func newTailBuffer(limit int) *tailBuffer { return &tailBuffer{limit: limit} } - -func (t *tailBuffer) Write(p []byte) (int, error) { - t.mu.Lock() - defer t.mu.Unlock() - n := len(p) - switch { - case n >= t.limit: - t.dropped += int64(len(t.buf) + n - t.limit) - t.buf = append(t.buf[:0], p[n-t.limit:]...) - case len(t.buf)+n > t.limit: - drop := len(t.buf) + n - t.limit - t.dropped += int64(drop) - t.buf = append(t.buf[:0], t.buf[drop:]...) - t.buf = append(t.buf, p...) - default: - t.buf = append(t.buf, p...) - } - return n, nil -} - -func (t *tailBuffer) String() string { - t.mu.Lock() - defer t.mu.Unlock() - s := strings.ToValidUTF8(string(t.buf), "") - if t.dropped > 0 { - return fmt.Sprintf("[%d earlier bytes dropped]\n%s", t.dropped, s) - } - return s -} - -// overlayEnv returns base with every overlay entry applied: an overlay NAME -// replaces all same-named base entries (case-insensitive when foldCase, as on -// Windows) instead of appending a duplicate. Later overlay entries win. func overlayEnv(base, overlay []string, foldCase bool) []string { if len(overlay) == 0 { return base diff --git a/e2e/framework/runenv/exec_test.go b/e2e/framework/runenv/exec_test.go index 11b5b3e39e..c1503cae42 100644 --- a/e2e/framework/runenv/exec_test.go +++ b/e2e/framework/runenv/exec_test.go @@ -24,14 +24,21 @@ func TestHelperProcess(t *testing.T) { t.Skip("helper process only") } switch mode { + case "success": + _, _ = fmt.Fprint(os.Stdout, "stdout") + _, _ = fmt.Fprint(os.Stderr, "stderr") case "exit3": fmt.Fprint(os.Stderr, "bad things") os.Exit(3) + case "output-sleep": + _, _ = fmt.Fprint(os.Stderr, "diagnostic") + _, _ = fmt.Fprint(os.Stdout, "ready") + time.Sleep(time.Minute) case "sleep": time.Sleep(time.Minute) case "flood": chunk := strings.Repeat("x", 1024) - for range 4 * maxCaptureBytes / 1024 { + for range 256 { _, _ = os.Stdout.WriteString(chunk) } _, _ = os.Stdout.WriteString("END") @@ -54,6 +61,21 @@ func helperCommand(mode string, extraEnv ...string) Command { } } +func (s *ExecSuite) TestSuccessCapturesBothStreams() { + var stdout, stderr bytes.Buffer + cmd := helperCommand("success") + cmd.Stdout, cmd.Stderr = &stdout, &stderr + res, err := (ExecRunner{}).Run(context.Background(), cmd) + s.Require().NoError(err) + s.Zero(res.ExitCode) + s.Equal("stdout", res.Stdout) + s.Equal("stderr", res.Stderr) + s.Equal(res.Stdout, stdout.String()) + s.Equal(res.Stderr, stderr.String()) + s.Zero(res.StdoutDropped) + s.Zero(res.StderrDropped) +} + func (s *ExecSuite) TestExitCodeAndStderr() { res, err := ExecRunner{}.Run(context.Background(), helperCommand("exit3")) s.Require().NoError(err) @@ -73,17 +95,17 @@ func (s *ExecSuite) TestTimeoutKillsChild() { s.Less(time.Since(start), 20*time.Second) } -func (s *ExecSuite) TestCaptureIsTailCappedAndLiveTee() { +func (s *ExecSuite) TestFullCaptureAndLiveTee() { var live bytes.Buffer cmd := helperCommand("flood") cmd.Stdout = &live res, err := ExecRunner{}.Run(context.Background(), cmd) s.Require().NoError(err) s.Zero(res.ExitCode) - s.LessOrEqual(len(res.Stdout), maxCaptureBytes+64) - s.Contains(res.Stdout, "earlier bytes dropped") + s.Equal(strings.Repeat("x", 256*1024)+"END", res.Stdout) s.True(strings.HasSuffix(res.Stdout, "END")) - s.Greater(live.Len(), maxCaptureBytes, "live writer sees everything") + s.Equal(res.Stdout, live.String()) + s.Zero(res.StdoutDropped) } func (s *ExecSuite) TestEnvOverlayReplacesParent() { @@ -108,16 +130,6 @@ func (s *ExecSuite) TestStartFailureAndCancel() { s.Require().Error(err) } -func (s *ExecSuite) TestTailBuffer() { - tb := newTailBuffer(8) - _, _ = tb.Write([]byte("abcd")) - s.Equal("abcd", tb.String()) - _, _ = tb.Write([]byte("efghij")) - s.Equal("[2 earlier bytes dropped]\ncdefghij", tb.String()) - _, _ = tb.Write([]byte("0123456789")) - s.Equal("[12 earlier bytes dropped]\n23456789", tb.String()) -} - func (s *ExecSuite) TestOverlayEnv() { const ( empty = "EMPTY=" @@ -184,3 +196,43 @@ func (s *ExecSuite) TestRedact() { s.Equal("plain output: 3 specs passed", Redact("plain output: 3 specs passed")) s.Equal("short x stays", Redact("short x stays", "x"), "tiny secrets ignored") } + +type blockedWriter struct { + entered chan struct{} + release chan struct{} +} + +func (w *blockedWriter) Write(p []byte) (int, error) { + close(w.entered) + <-w.release + return len(p), nil +} + +func (s *ExecSuite) TestBlockedLiveWriterCancellation() { + w := &blockedWriter{entered: make(chan struct{}), release: make(chan struct{})} + defer close(w.release) + cmd := helperCommand("output-sleep") + cmd.Stdout = w + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + type outcome struct { + result CommandResult + err error + } + done := make(chan outcome, 1) + go func() { result, err := (ExecRunner{}).Run(ctx, cmd); done <- outcome{result, err} }() + select { + case <-w.entered: + case <-time.After(10 * time.Second): + s.FailNow("writer not entered") + } + cancel() + select { + case got := <-done: + s.ErrorIs(got.err, context.Canceled) + s.Equal("ready", got.result.Stdout) + s.Equal("diagnostic", got.result.Stderr) + case <-time.After(10 * time.Second): + s.FailNow("canceled command blocked") + } +} diff --git a/e2e/tests/up/provider_kubernetes_image_config_file.go b/e2e/tests/up/provider_kubernetes_image_config_file.go index b0cc97f202..f0ff2570c3 100644 --- a/e2e/tests/up/provider_kubernetes_image_config_file.go +++ b/e2e/tests/up/provider_kubernetes_image_config_file.go @@ -46,17 +46,6 @@ type imageConfigFixture struct { uid, controlUID, configDigest string } -type imageConfigOutput struct { - mu sync.Mutex - buffer bytes.Buffer -} - -func (o *imageConfigOutput) Write(data []byte) (int, error) { - o.mu.Lock() - defer o.mu.Unlock() - return o.buffer.Write(data) -} - type imageConfigLogObserver struct { mu sync.Mutex tail []byte @@ -111,11 +100,10 @@ func imageConfigCommand( default: return "", fmt.Errorf("unsupported fixture command %q", program) } - output := &imageConfigOutput{} result, err := (runenv.ExecRunner{}).Run(ctx, runenv.Command{ - Path: program, Args: args, Env: env, Stdout: output, Stderr: output, + Path: program, Args: args, Env: env, }) - out := strings.TrimSpace(output.buffer.String()) + out := strings.TrimSpace(result.Stdout + result.Stderr) if err != nil { return out, fmt.Errorf("run %s: %w", program, err) } diff --git a/hack/ci/suites.yaml b/hack/ci/suites.yaml index 5f62bbfa2f..3414e9334c 100644 --- a/hack/ci/suites.yaml +++ b/hack/ci/suites.yaml @@ -25,6 +25,7 @@ unit: description: E2E runtime helper packages packages: - ./e2e/framework/runenv/... + - ./e2e/framework/internal/livetee - ./e2e/framework/dockerwsl - ./e2e/framework/ginkgoreport - ./e2e/cmd/devsy-ci