Function TestFormatErrorChain

pkg/console/console_formatting_test.go:381–457

(t *testing.T)

}

func TestFormatErrorChain(t *testing.T) {
	tests := []struct {
		name             string
		err              error
		expectedContains []string
		expectMultiLine  bool
	}{
		{
			name:             "nil error",
			err:              nil,
			expectedContains: []string{},
			expectMultiLine:  false,
		},
		{
			name:             "simple single error",
			err:              errors.New("file not found"),
			expectedContains: []string{"✗", "file not found"},
			expectMultiLine:  false,
		},
		{
			name:             "two-level wrapped error",
			err:              fmt.Errorf("outer: %w", errors.New("inner cause")),
			expectedContains: []string{"✗", "outer", "inner cause"},
			expectMultiLine:  true,
		},
		{
			name: "three-level wrapped error chain",
			err: fmt.Errorf("workflow not found: %w",
				fmt.Errorf("failed to download: %w",
					errors.New("HTTP 404: Not Found"))),
			expectedContains: []string{"✗", "workflow not found", "failed to download", "HTTP 404: Not Found"},
			expectMultiLine:  true,
		},
		{
			name:             "multiline error from errors.Join",
			err:              errors.Join(errors.New("error one"), errors.New("error two")),
			expectedContains: []string{"✗", "error one", "error two"},
			expectMultiLine:  true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := FormatErrorChain(tt.err)

			for _, expected := range tt.expectedContains {
				if !strings.Contains(result, expected) {
					t.Errorf("FormatErrorChain() = %q, should contain %q", result, expected)
				}
			}

			if tt.expectMultiLine && !strings.Contains(result, "\n") {
				t.Errorf("FormatErrorChain() should produce multi-line output for wrapped/joined errors, got: %q", result)
			}

			// Verify indentation: continuation lines should start with spaces, first line should not
			if tt.expectMultiLine && tt.err != nil {
				lines := strings.Split(result, "\n")