allow captures from truncated command output

Author: theodore-s-beers

checks/cli.go

@@ -118,10 +118,7 @@ func runCLICommandWithOutputLimit(
 		result.Stdout = ExtractTmdlBlock(result.Stdout, *command.StdoutFilterTmdl)
 	}
 
-	if stdout.truncated || stderr.truncated {
-		result.Err = fmt.Sprintf("command output exceeded the %d-byte per-stream limit", maxOutputBytesPerStream)
-		result.ExitCode = -2
-	} else if err := parseStdoutVariables(result.Stdout, command.StdoutVariables, captured); err != nil {
+	if err := parseStdoutVariables(result.Stdout, command.StdoutVariables, captured); err != nil {
 		result.Err = err.Error()
 	}
 	return result

checks/cli_test.go

@@ -2,43 +2,75 @@ package checks
 
 import (
 	"runtime"
-	"strings"
 	"testing"
 
 	api "github.com/bootdotdev/bootdev/client"
 )
 
 func TestRunCLICommandCapsOutput(t *testing.T) {
-	command := `printf 'abcdefgh'`
-	if runtime.GOOS == "windows" {
-		command = `[Console]::Out.Write('abcdefgh')`
-	}
-
-	variables := map[string]string{}
-	result := runCLICommandWithOutputLimit(
-		api.CLIStepCLICommand{
-			Command: command,
-			StdoutVariables: []api.CLICommandStdoutVariable{{
-				Name:  "partial",
-				Regex: `(abcd)`,
-			}},
+	for _, tc := range []struct {
+		name, command, windowsCommand, stdout, stderr, pattern, value string
+		exitCode                                                      int
+		wantFailure                                                   bool
+	}{
+		{
+			name:           "stdout overflow",
+			command:        `printf 'abcdefgh'`,
+			windowsCommand: `[Console]::Out.Write('abcdefgh')`,
+			stdout:         "abcd", pattern: `^(abcd)$`, value: "abcd",
 		},
-		variables,
-		4,
-		defaultShell(),
-	)
-
-	if !strings.Contains(result.Err, "per-stream limit") {
-		t.Fatalf("command error = %q, want per-stream output limit error", result.Err)
-	}
-	if result.ExitCode >= 0 {
-		t.Fatalf("exit code = %d, want internal failure", result.ExitCode)
-	}
-	if result.Stdout != "abcd" {
-		t.Fatalf("stdout = %q, want capped output %q", result.Stdout, "abcd")
-	}
-	if _, ok := variables["partial"]; ok {
-		t.Fatal("truncated output unexpectedly populated a stdout variable")
+		{
+			name:           "stderr overflow",
+			command:        `printf 'ok'; printf 'abcdefgh' >&2`,
+			windowsCommand: `[Console]::Out.Write('ok'); [Console]::Error.Write('abcdefgh')`,
+			stdout:         "ok", stderr: "abcd", pattern: `^(ok)$`, value: "ok",
+		},
+		{
+			name:           "nonzero exit",
+			command:        `printf 'abcdefgh'; exit 7`,
+			windowsCommand: `[Console]::Out.Write('abcdefgh'); exit 7`,
+			stdout:         "abcd", pattern: `^(abcd)$`, value: "abcd", exitCode: 7,
+		},
+		{
+			name:           "capture beyond limit",
+			command:        `printf 'abcdefgh'`,
+			windowsCommand: `[Console]::Out.Write('abcdefgh')`,
+			stdout:         "abcd", pattern: `(efgh)`, wantFailure: true,
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			command := tc.command
+			if runtime.GOOS == "windows" {
+				command = tc.windowsCommand
+			}
+			step := api.CLIStepCLICommand{
+				Command:         command,
+				StdoutVariables: []api.CLICommandStdoutVariable{{Name: "token", Regex: tc.pattern}},
+			}
+			variables := map[string]string{"token": "old"}
+			result := runCLICommandWithOutputLimit(step, variables, 4, defaultShell())
+			if result.ExitCode != tc.exitCode {
+				t.Fatalf("exit code = %d, want %d", result.ExitCode, tc.exitCode)
+			}
+			if result.Stdout != tc.stdout || result.Stderr != tc.stderr {
+				t.Fatalf("stdout/stderr = %q/%q, want %q/%q", result.Stdout, result.Stderr, tc.stdout, tc.stderr)
+			}
+			if tc.wantFailure {
+				if result.Err == "" {
+					t.Fatal("missing capture should fail")
+				}
+				if _, found := variables["token"]; found {
+					t.Fatal("failed capture retained the old token")
+				}
+				return
+			}
+			if result.Err != "" {
+				t.Fatalf("unexpected command error: %s", result.Err)
+			}
+			if variables["token"] != tc.value {
+				t.Fatalf("capture = %q, want %q", variables["token"], tc.value)
+			}
+		})
 	}
 }