feat(STONEINTG-1677): consolidated Gitlab status reporting

- add HTTP 422 as unrecoverable across all three forge reporters
- add ReportConsolidatedStatus to reporter.go  GitLab posts a
  single "X/Y passed" status when scenario count exceeds the
  per-pipeline job threshold; GitHub and Forgejo are no-ops
- propagate IsOptional through TestReport so optional failures do
  not set the consolidated status to failed
- add threshold config via GITLAB_MAX_INDIVIDUAL_STATUSES env var
  (default 50) with adapter routing logic
- unit tests for consolidated status, transition error suppression,
  and threshold routing

Assisted by: Cursor AI

Signed-off-by: jcullina <jcullina@redhat.com>

Author: jencull

internal/controller/statusreport/statusreport_adapter.go

@@ -525,23 +525,26 @@ func (a *Adapter) iterateIntegrationTestStatusDetailsInStatusReport(reporter sta
 		return nil
 	}
 
+	// Build the per-scenario test reports. These are always needed — for comment
+	// text in both paths and for per-scenario commit statuses in the individual path.
+	var allReports []status.TestReport
 	for _, integrationTestStatusDetail := range integrationTestStatusDetails {
-		// set isFinalStatus to true if there is at least one integration test status is in final status, which means the comment for integration test might not be updated again to have only one comment for each component
 		if integrationTestStatusDetail.Status.IsFinal() {
 			isFinalStatus = true
 		}
 		testReport, reportErr := status.GenerateTestReport(a.context, a.client, *integrationTestStatusDetail, testedSnapshot, componentNameOrPrGroup)
 		if reportErr != nil {
 			a.logger.Error(reportErr, fmt.Sprintf("failed to generate test report for integration test scenario %s/%s",
 				testedSnapshot.Namespace, integrationTestStatusDetail.ScenarioName))
-			if writeErr := status.WriteSnapshotReportStatus(a.context, a.client, testedSnapshot, srs); writeErr != nil { // try to write what was already written
+			if writeErr := status.WriteSnapshotReportStatus(a.context, a.client, testedSnapshot, srs); writeErr != nil {
 				return fmt.Errorf("failed to generate test report AND write snapshot report status metadata: %w", e.Join(reportErr, writeErr))
 			}
 			return fmt.Errorf("failed to generate test report: %w", reportErr)
 		}
+		allReports = append(allReports, *testReport)
+
 		// split passed and failing integration test report in gitlab comment to show failing tests on top
 		if integrationTestStatusDetail.Status == intgteststat.IntegrationTestStatusTestPassed {
-			// generate comment for passed integration test with short text which has pipelinerun link but without task run details
 			commentForEachTest, err := status.FormatCommentForSuccessfulTest(testReport.Summary, testReport.ShortText)
 			if err != nil {
 				return fmt.Errorf("failed to generate comment for status of integration test scenario %s/%s : %w", testedSnapshot.Namespace, testReport.ScenarioName, err)
@@ -554,38 +557,70 @@ func (a *Adapter) iterateIntegrationTestStatusDetailsInStatusReport(reporter sta
 			}
 			commentForFailingIntegrationTests = append(commentForFailingIntegrationTests, commentForEachTest)
 		}
+	}
 
-		if srs.IsNewer(integrationTestStatusDetail.ScenarioName, destinationSnapshot.Name, integrationTestStatusDetail.LastUpdateTime) {
-			a.logger.Info("Integration Test contains new status updates", "scenario.Name", integrationTestStatusDetail.ScenarioName, "destinationSnapshot.Name", destinationSnapshot.Name, "testedSnapshot", testedSnapshot.Name)
-
-		} else {
-			//integration test contains no changes
-			a.logger.Info("Integration Test doen't contain new status updates", "scenario.Name", integrationTestStatusDetail.ScenarioName)
-			continue
-		}
+	// When the number of scenarios exceeds the configured threshold for GitLab or
+	// Forgejo reporters, post a single consolidated commit status instead of one
+	// per scenario to avoid exhausting the provider's per-pipeline job limit.
+	useConsolidated := reporter.GetReporterName() == status.GitLabProvider &&
+		len(integrationTestStatusDetails) > status.MaxIndividualStatuses
 
-		if statusCode, reportStatusErr := reporter.ReportStatus(a.context, *testReport); reportStatusErr != nil {
-			if integrationTestStatusDetail.Status.IsFinal() && integrationTestStatusDetail.TestPipelineRunName != "" {
-				a.logger.Error(reportStatusErr, fmt.Sprintf("failed to report status to git provider for completed integration pipelinerun %s/%s, then finalizer test.appstudio.openshift.io/pipelinerun might not be removed from it later", testedSnapshot.Namespace, integrationTestStatusDetail.TestPipelineRunName))
-			}
+	if useConsolidated {
+		a.logger.Info("Scenario count exceeds threshold, using consolidated commit status",
+			"scenarioCount", len(integrationTestStatusDetails), "threshold", status.MaxIndividualStatuses,
+			"reporter", reporter.GetReporterName())
 
+		if statusCode, reportErr := reporter.ReportConsolidatedStatus(a.context, allReports); reportErr != nil {
 			if reporter.ReturnCodeIsUnrecoverable(statusCode) {
-				a.logger.Error(reportStatusErr, fmt.Sprintf("failed to report status to git provider for integration pipelinerun %s/%s, the statusCode %d is not easily recoverable", testedSnapshot.Namespace, integrationTestStatusDetail.TestPipelineRunName, statusCode))
+				a.logger.Error(reportErr, "consolidated status report failed with unrecoverable error, skipping",
+					"statusCode", statusCode)
 				return nil
-			} else {
-				return fmt.Errorf("failed to update status: %w", reportStatusErr)
 			}
+			return fmt.Errorf("failed to report consolidated status: %w", reportErr)
 		}
 
-		if writeErr := status.WriteSnapshotReportStatus(a.context, a.client, testedSnapshot, srs); writeErr != nil { // try to write what was already written
-			return fmt.Errorf("failed to report status AND write snapshot report status metadata: %w", writeErr)
+		// Mark all scenarios as reported so they are not re-reported on the next reconcile
+		for _, detail := range integrationTestStatusDetails {
+			srs.SetLastUpdateTime(detail.ScenarioName, destinationSnapshot.Name, detail.LastUpdateTime)
+		}
+		if writeErr := status.WriteSnapshotReportStatus(a.context, a.client, testedSnapshot, srs); writeErr != nil {
+			return fmt.Errorf("failed to write snapshot report status after consolidated status: %w", writeErr)
 		}
+	} else {
+		// Per-scenario path: post one commit status per scenario.
+		for i, integrationTestStatusDetail := range integrationTestStatusDetails {
+			testReport := allReports[i]
 
-		a.logger.Info("Successfully report integration test status for snapshot",
-			"testedSnapshot.Name", testedSnapshot.Name,
-			"destinationSnapshot.Name", destinationSnapshot.Name,
-			"testStatus", integrationTestStatusDetail.Status)
-		srs.SetLastUpdateTime(integrationTestStatusDetail.ScenarioName, destinationSnapshot.Name, integrationTestStatusDetail.LastUpdateTime)
+			if srs.IsNewer(integrationTestStatusDetail.ScenarioName, destinationSnapshot.Name, integrationTestStatusDetail.LastUpdateTime) {
+				a.logger.Info("Integration Test contains new status updates", "scenario.Name", integrationTestStatusDetail.ScenarioName, "destinationSnapshot.Name", destinationSnapshot.Name, "testedSnapshot", testedSnapshot.Name)
+			} else {
+				a.logger.Info("Integration Test doen't contain new status updates", "scenario.Name", integrationTestStatusDetail.ScenarioName)
+				continue
+			}
+
+			if statusCode, reportStatusErr := reporter.ReportStatus(a.context, testReport); reportStatusErr != nil {
+				if integrationTestStatusDetail.Status.IsFinal() && integrationTestStatusDetail.TestPipelineRunName != "" {
+					a.logger.Error(reportStatusErr, fmt.Sprintf("failed to report status to git provider for completed integration pipelinerun %s/%s, then finalizer test.appstudio.openshift.io/pipelinerun might not be removed from it later", testedSnapshot.Namespace, integrationTestStatusDetail.TestPipelineRunName))
+				}
+
+				if reporter.ReturnCodeIsUnrecoverable(statusCode) {
+					a.logger.Error(reportStatusErr, fmt.Sprintf("failed to report status to git provider for integration pipelinerun %s/%s, the statusCode %d is not easily recoverable", testedSnapshot.Namespace, integrationTestStatusDetail.TestPipelineRunName, statusCode))
+					return nil
+				} else {
+					return fmt.Errorf("failed to update status: %w", reportStatusErr)
+				}
+			}
+
+			if writeErr := status.WriteSnapshotReportStatus(a.context, a.client, testedSnapshot, srs); writeErr != nil {
+				return fmt.Errorf("failed to report status AND write snapshot report status metadata: %w", writeErr)
+			}
+
+			a.logger.Info("Successfully report integration test status for snapshot",
+				"testedSnapshot.Name", testedSnapshot.Name,
+				"destinationSnapshot.Name", destinationSnapshot.Name,
+				"testStatus", integrationTestStatusDetail.Status)
+			srs.SetLastUpdateTime(integrationTestStatusDetail.ScenarioName, destinationSnapshot.Name, integrationTestStatusDetail.LastUpdateTime)
+		}
 	}
 
 	// update integration test status comment for gitlab and forgejo reporters when comment is not disabled

status/mock_reporter.go

@@ -60,6 +60,8 @@ type TestReport struct {
 	ShortText string
 	// test status
 	Status intgteststat.IntegrationTestStatus
+	// IsOptional is true when the scenario is optional (failure does not block promotion)
+	IsOptional bool
 	// short summary of test results
 	Summary string
 	// time when test started
@@ -79,6 +81,11 @@ type ReporterInterface interface {
 	GetReporterName() string
 	// Update status of the integration test
 	ReportStatus(context.Context, TestReport) (int, error)
+	// ReportConsolidatedStatus posts a single aggregated commit status summarising
+	// all integration test results. Used when the per-scenario count exceeds the
+	// git provider's per-pipeline job limit. Reporters that do not support this
+	// (e.g. GitHub) should return (http.StatusCreated, nil).
+	ReportConsolidatedStatus(context.Context, []TestReport) (int, error)
 	// Is the return code a recoverable error
 	ReturnCodeIsUnrecoverable(statusCode int) bool
 	// Update status comment in the gitlab merge request, implemented and used in reporter_gitlab.go

status/reporter.go

@@ -385,6 +385,13 @@ func (r *ForgejoReporter) DeleteExistingComments(commentIDs []int64) (int, error
 	return lastStatusCode, nil
 }
 
+// blank implementation to satisfy ReporterInterface — consolidated status
+// reporting is not yet needed for Forgejo due to its small user base.
+// Implement when a per-pipeline job limit becomes a practical concern.
+func (r *ForgejoReporter) ReportConsolidatedStatus(_ context.Context, _ []TestReport) (int, error) {
+	return http.StatusCreated, nil
+}
+
 // ReportStatus reports test result to forgejo
 func (r *ForgejoReporter) ReportStatus(ctx context.Context, report TestReport) (int, error) {
 	var statusCode = 0

status/reporter_forgejo.go

@@ -634,6 +634,12 @@ func (r *GitHubReporter) UpdateStatusInComment(arg0, arg1 string, arg2 bool) (in
 	return http.StatusCreated, nil
 }
 
+// blank implementation to satisfy ReporterInterface — GitHub does not have a
+// per-pipeline job limit that requires status consolidation.
+func (r *GitHubReporter) ReportConsolidatedStatus(_ context.Context, _ []TestReport) (int, error) {
+	return http.StatusCreated, nil
+}
+
 // Initialize github reporter. Must be called before updating status
 func (r *GitHubReporter) Initialize(ctx context.Context, snapshot *applicationapiv1alpha1.Snapshot) (int, error) {
 	var statusCode int
@@ -714,5 +720,7 @@ func (r *GitHubReporter) ReportStatus(ctx context.Context, report TestReport) (i
 }
 
 func (r *GitHubReporter) ReturnCodeIsUnrecoverable(statusCode int) bool {
-	return statusCode == http.StatusForbidden || statusCode == http.StatusUnauthorized || statusCode == http.StatusBadRequest || statusCode == http.StatusNotFound
+	return statusCode == http.StatusForbidden || statusCode == http.StatusUnauthorized ||
+		statusCode == http.StatusBadRequest || statusCode == http.StatusNotFound ||
+		statusCode == http.StatusUnprocessableEntity
 }