Function TestErrorCollectorIntegration

pkg/workflow/error_aggregation_test.go:134–207

TestErrorCollectorIntegration tests the full flow of error collection

(t *testing.T)

// TestErrorCollectorIntegration tests the full flow of error collection
func TestErrorCollectorIntegration(t *testing.T) {
	tests := []struct {
		name          string
		failFast      bool
		errors        []error
		expectError   bool
		expectCount   int
		shouldContain []string
	}{
		{
			name:        "no errors collected",
			failFast:    false,
			errors:      []error{},
			expectError: false,
			expectCount: 0,
		},
		{
			name:          "single error aggregated",
			failFast:      false,
			errors:        []error{errors.New("error 1")},
			expectError:   true,
			expectCount:   1,
			shouldContain: []string{"error 1"},
		},
		{
			name:          "multiple errors aggregated",
			failFast:      false,
			errors:        []error{errors.New("error 1"), errors.New("error 2"), errors.New("error 3")},
			expectError:   true,
			expectCount:   3,
			shouldContain: []string{"error 1", "error 2", "error 3"},
		},
		{
			name:          "fail-fast stops at first error",
			failFast:      true,
			errors:        []error{errors.New("error 1"), errors.New("error 2")},
			expectError:   true,
			expectCount:   0, // No errors collected in fail-fast mode
			shouldContain: []string{},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			collector := NewErrorCollector(tt.failFast)

			// Add all errors
			for _, err := range tt.errors {
				result := collector.Add(err)
				if tt.failFast && err != nil {
					// In fail-fast mode, Add should return error immediately
					assert.Error(t, result, "Should return error in fail-fast mode")
					return // Stop test here for fail-fast mode
				}
			}

			// Get the aggregated error
			err := collector.Error()