fix(gitlab): fallback to commit status on /retest

Added a fallback mechanism to retrieve commit statuses from the git
provider when the corresponding PipelineRuns are missing from the
cluster due to pruning. This ensures that the retest logic correctly
identifies previously successful templates and avoids re-running them
unnecessarily.

Issues Related (partial): #2580
Jira: https://issues.redhat.com/browse/SRVKP-11112
Signed-off-by: Chmouel Boudjnah <chmouel@redhat.com>

Author: chmouel

docs/content/docs/guides/gitops-commands/_index.md

@@ -25,7 +25,7 @@ failure is not with your PR but seems to be an infrastructure issue.
 - Previously **failed** PipelineRuns exist for the same commit, OR
 - No PipelineRun has run for the same commit yet
 
-If a successful PipelineRun already exists for the same commit, `/retest` **skips** it to avoid unnecessary duplication.
+If a successful PipelineRun already exists for the same commit, `/retest` **skips** it to avoid unnecessary duplication. When PipelineRuns have been pruned from the cluster (for example, by a retention policy), Pipelines-as-Code falls back to querying the Git provider's commit status API to determine which pipelines previously succeeded, ensuring only failed pipelines are re-run even when the original PipelineRun objects no longer exist.
 
 **When to use it:** To force a rerun regardless of previous status, use:
 

docs/content/docs/guides/repository-crd/comment-settings.md

@@ -41,6 +41,15 @@ in the target repository, because GitLab only creates pipeline entries for commi
 that actually trigger CI in that specific project. If either status update
 succeeds, Pipelines-as-Code does not post a comment on the Merge Request.
 
+Successful commit status reporting is also important for the `/retest` command.
+When PipelineRuns are pruned from the cluster, Pipelines-as-Code queries
+GitLab's commit status API to identify which pipelines previously succeeded,
+ensuring only failed pipelines are re-run. If commit statuses were never
+reported (for example, because both status updates failed and only a comment was
+posted), Pipelines-as-Code cannot determine prior results and will fail to
+re-run any pipelines when `/retest` unless you retest individual pipelineruns
+with `/test <pipeline-name>`.
+
 When a status update succeeds, you can see the status in the GitLab UI in the `Pipelines` tab, as
 shown in the following example:
 

pkg/matcher/annotation_matcher.go

@@ -424,7 +424,7 @@ func MatchPipelinerunByAnnotation(ctx context.Context, logger *zap.SugaredLogger
 		if event.EventType == opscomments.RetestAllCommentEventType.String() ||
 			event.EventType == opscomments.OkToTestCommentEventType.String() {
 			logger.Debugf("MatchPipelinerunByAnnotation: filtering successful templates for event_type=%s", event.EventType)
-			filtered := filterSuccessfulTemplates(ctx, logger, cs, event, repo, matchedPRs)
+			filtered := filterSuccessfulTemplates(ctx, logger, cs, event, repo, vcx, matchedPRs)
 			if len(filtered) == 0 {
 				return nil, ErrNoFailedPipelineToRetest
 			}
@@ -438,7 +438,7 @@ func MatchPipelinerunByAnnotation(ctx context.Context, logger *zap.SugaredLogger
 
 // filterSuccessfulTemplates filters out templates that already have successful PipelineRuns
 // when executing /ok-to-test or /retest gitops commands, implementing per-template checking.
-func filterSuccessfulTemplates(ctx context.Context, logger *zap.SugaredLogger, cs *params.Run, event *info.Event, repo *apipac.Repository, matchedPRs []Match) []Match {
+func filterSuccessfulTemplates(ctx context.Context, logger *zap.SugaredLogger, cs *params.Run, event *info.Event, repo *apipac.Repository, vcx provider.Interface, matchedPRs []Match) []Match {
 	if event.SHA == "" {
 		return matchedPRs
 	}
@@ -469,7 +469,7 @@ func filterSuccessfulTemplates(ctx context.Context, logger *zap.SugaredLogger, c
 			continue // Skip PipelineRuns without template identification
 		}
 
-		// Check if this PipelineRun succeeded
+		// Only completed successful PipelineRuns should suppress a /retest.
 		if pr.Status.GetCondition(apis.ConditionSucceeded).IsTrue() {
 			// Keep the most recent successful run for each template
 			if existing, exists := successfulTemplates[originalPRName]; !exists ||
@@ -479,6 +479,20 @@ func filterSuccessfulTemplates(ctx context.Context, logger *zap.SugaredLogger, c
 		}
 	}
 
+	// Also check provider commit statuses (covers pruned PipelineRuns)
+	commitStatuses, err := vcx.GetCommitStatuses(ctx, event)
+	if err != nil {
+		logger.Warnf("failed to get commit statuses from provider for SHA %s: %v", event.SHA, err)
+	} else if len(commitStatuses) > 0 {
+		appName := cs.Info.GetPacOpts().ApplicationName
+		for _, cs := range commitStatuses {
+			originalName := parseOriginalPRName(cs.Name, appName)
+			if originalName != "" && isSuccessStatus(cs.Status) {
+				successfulTemplates[originalName] = &tektonv1.PipelineRun{} // placeholder
+			}
+		}
+	}
+
 	// Filter out templates that have successful runs
 	var filteredPRs []Match
 
@@ -497,6 +511,26 @@ func filterSuccessfulTemplates(ctx context.Context, logger *zap.SugaredLogger, c
 	return filteredPRs
 }
 
+// parseOriginalPRName extracts the original PipelineRun name from a commit status name.
+// The commit status name format is "ApplicationName / OriginalPRName".
+func parseOriginalPRName(checkName, appName string) string {
+	prefix := appName + " / "
+	if strings.HasPrefix(checkName, prefix) {
+		return strings.TrimPrefix(checkName, prefix)
+	}
+	return ""
+}
+
+// isSuccessStatus returns true if the status string represents a successful state
+// across different git providers.
+func isSuccessStatus(status string) bool {
+	switch strings.ToLower(status) {
+	case "success", "successful", "completed":
+		return true
+	}
+	return false
+}
+
 func buildAvailableMatchingAnnotationErr(event *info.Event, pruns []*tektonv1.PipelineRun) string {
 	errmsg := "available annotations of the PipelineRuns annotations in .tekton/ dir:"
 	for _, prun := range pruns {

pkg/matcher/annotation_matcher_test.go

@@ -25,6 +25,7 @@ import (
 	ghprovider "github.com/openshift-pipelines/pipelines-as-code/pkg/provider/github"
 	testclient "github.com/openshift-pipelines/pipelines-as-code/pkg/test/clients"
 	ghtesthelper "github.com/openshift-pipelines/pipelines-as-code/pkg/test/github"
+	testprovider "github.com/openshift-pipelines/pipelines-as-code/pkg/test/provider"
 	testnewrepo "github.com/openshift-pipelines/pipelines-as-code/pkg/test/repository"
 	tektonv1 "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1"
 	"go.uber.org/zap"
@@ -3078,6 +3079,33 @@ func TestFilterSuccessfulTemplates(t *testing.T) {
 		},
 	}
 
+	// Template E: has a running run - should be kept for /retest
+	runningPRE := &tektonv1.PipelineRun{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "template-e-running",
+			Namespace: "test-ns",
+			Labels: map[string]string{
+				keys.SHA:            "test-sha",
+				keys.OriginalPRName: "template-e",
+			},
+			Annotations: map[string]string{
+				keys.OriginalPRName: "template-e",
+			},
+			CreationTimestamp: now,
+		},
+		Status: tektonv1.PipelineRunStatus{
+			Status: knativeduckv1.Status{
+				Conditions: knativeduckv1.Conditions{
+					apis.Condition{
+						Type:   apis.ConditionSucceeded,
+						Status: corev1.ConditionUnknown,
+						Reason: "Running",
+					},
+				},
+			},
+		},
+	}
+
 	// PipelineRun with different SHA - should not interfere
 	differentSHAPR := &tektonv1.PipelineRun{
 		ObjectMeta: metav1.ObjectMeta{
@@ -3128,7 +3156,7 @@ func TestFilterSuccessfulTemplates(t *testing.T) {
 	// Setup test clients
 	tdata := testclient.Data{
 		PipelineRuns: []*tektonv1.PipelineRun{
-			successfulPRA, failedPRB, olderSuccessfulPRD, newerSuccessfulPRD, differentSHAPR, noOriginalNamePR,
+			successfulPRA, failedPRB, olderSuccessfulPRD, newerSuccessfulPRD, runningPRE, differentSHAPR, noOriginalNamePR,
 		},
 		Repositories: []*v1alpha1.Repository{repo},
 	}
@@ -3169,8 +3197,9 @@ func TestFilterSuccessfulTemplates(t *testing.T) {
 				createMatchedPR("template-b"), // has failed run - should be kept
 				createMatchedPR("template-c"), // no previous runs - should be kept
 				createMatchedPR("template-d"), // has multiple successful runs - should be filtered
+				createMatchedPR("template-e"), // has a running run - should be kept
 			},
-			expectedNames: []string{"template-b", "template-c"},
+			expectedNames: []string{"template-b", "template-c", "template-e"},
 		},
 		{
 			name:      "Ok-to-test command filters templates with successful runs",
@@ -3250,7 +3279,7 @@ func TestFilterSuccessfulTemplates(t *testing.T) {
 				return
 			}
 
-			filtered := filterSuccessfulTemplates(ctx, logger, cs, event, repo, tt.matchedPRs)
+			filtered := filterSuccessfulTemplates(ctx, logger, cs, event, repo, &ghprovider.Provider{}, tt.matchedPRs)
 
 			// Check that the correct number of templates remain
 			assert.Equal(t, len(tt.expectedNames), len(filtered),
@@ -3288,3 +3317,130 @@ func TestFilterSuccessfulTemplates(t *testing.T) {
 		})
 	}
 }
+
+func TestFilterSuccessfulTemplatesFallbackToCommitStatuses(t *testing.T) {
+	ctx, _ := rtesting.SetupFakeContext(t)
+	observer, _ := zapobserver.New(zap.DebugLevel)
+	logger := zap.New(observer).Sugar()
+
+	repo := &v1alpha1.Repository{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "test-repo",
+			Namespace: "test-ns",
+		},
+	}
+
+	// No PipelineRuns in the cluster (pruned)
+	tdata := testclient.Data{
+		Repositories: []*v1alpha1.Repository{repo},
+	}
+	stdata, _ := testclient.SeedTestData(t, ctx, tdata)
+
+	cs := &params.Run{
+		Clients: clients.Clients{
+			Log:    logger,
+			Tekton: stdata.Pipeline,
+			Kube:   stdata.Kube,
+		},
+	}
+	pac := info.NewPacOpts()
+	pac.ApplicationName = "Pipelines as Code CI"
+	cs.Info.Pac = pac
+
+	createMatchedPR := func(name string) Match {
+		return Match{
+			PipelineRun: &tektonv1.PipelineRun{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: name,
+				},
+			},
+		}
+	}
+
+	tests := []struct {
+		name           string
+		commitStatuses []provider.CommitStatusInfo
+		matchedPRs     []Match
+		expectedNames  []string
+	}{
+		{
+			name: "Fallback filters successful templates from commit statuses",
+			commitStatuses: []provider.CommitStatusInfo{
+				{Name: "Pipelines as Code CI / template-a", Status: "success"},
+				{Name: "Pipelines as Code CI / template-b", Status: "failed"},
+			},
+			matchedPRs: []Match{
+				createMatchedPR("template-a"),
+				createMatchedPR("template-b"),
+				createMatchedPR("template-c"),
+			},
+			expectedNames: []string{"template-b", "template-c"},
+		},
+		{
+			name: "Fallback with all successful statuses filters all",
+			commitStatuses: []provider.CommitStatusInfo{
+				{Name: "Pipelines as Code CI / template-a", Status: "success"},
+				{Name: "Pipelines as Code CI / template-b", Status: "successful"},
+			},
+			matchedPRs: []Match{
+				createMatchedPR("template-a"),
+				createMatchedPR("template-b"),
+			},
+			expectedNames: []string{},
+		},
+		{
+			name: "Fallback ignores statuses with different app name prefix",
+			commitStatuses: []provider.CommitStatusInfo{
+				{Name: "Other App / template-a", Status: "success"},
+				{Name: "Pipelines as Code CI / template-b", Status: "success"},
+			},
+			matchedPRs: []Match{
+				createMatchedPR("template-a"),
+				createMatchedPR("template-b"),
+			},
+			expectedNames: []string{"template-a"},
+		},
+		{
+			name:           "No commit statuses re-runs all",
+			commitStatuses: nil,
+			matchedPRs: []Match{
+				createMatchedPR("template-a"),
+				createMatchedPR("template-b"),
+			},
+			expectedNames: []string{"template-a", "template-b"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			event := &info.Event{
+				EventType: "retest",
+				SHA:       "test-sha-pruned",
+			}
+			vcx := &testprovider.TestProviderImp{
+				CommitStatuses: tt.commitStatuses,
+			}
+
+			filtered := filterSuccessfulTemplates(ctx, logger, cs, event, repo, vcx, tt.matchedPRs)
+
+			assert.Equal(t, len(tt.expectedNames), len(filtered),
+				"Expected %d templates but got %d", len(tt.expectedNames), len(filtered))
+
+			var actualNames []string
+			for _, match := range filtered {
+				actualNames = append(actualNames, getName(match.PipelineRun))
+			}
+
+			for _, expectedName := range tt.expectedNames {
+				found := false
+				for _, actualName := range actualNames {
+					if actualName == expectedName {
+						found = true
+						break
+					}
+				}
+				assert.Assert(t, found, "Expected template %s not found in %v", expectedName, actualNames)
+			}
+		})
+	}
+}

pkg/provider/bitbucketcloud/bitbucket.go

@@ -159,6 +159,10 @@ func (v *Provider) CreateStatus(_ context.Context, event *info.Event, statusopts
 	return nil
 }
 
+func (v *Provider) GetCommitStatuses(_ context.Context, _ *info.Event) ([]provider.CommitStatusInfo, error) {
+	return nil, nil
+}
+
 func (v *Provider) GetTektonDir(_ context.Context, event *info.Event, path, provenance string) (string, error) {
 	v.provenance = provenance
 	repositoryFiles, err := v.getDir(event, path)

pkg/provider/bitbucketdatacenter/bitbucketdatacenter.go

@@ -170,6 +170,10 @@ func (v *Provider) CreateStatus(ctx context.Context, event *info.Event, statusOp
 	return nil
 }
 
+func (v *Provider) GetCommitStatuses(_ context.Context, _ *info.Event) ([]provider.CommitStatusInfo, error) {
+	return nil, nil
+}
+
 func (v *Provider) concatAllYamlFiles(ctx context.Context, objects []string, sha string, runevent *info.Event) (string, error) {
 	var allTemplates string
 	for _, value := range objects {

pkg/provider/gitea/gitea.go

@@ -360,6 +360,10 @@ func (v *Provider) createStatusCommit(ctx context.Context, event *info.Event, pa
 	return nil
 }
 
+func (v *Provider) GetCommitStatuses(_ context.Context, _ *info.Event) ([]provider.CommitStatusInfo, error) {
+	return nil, nil
+}
+
 func (v *Provider) GetTektonDir(_ context.Context, event *info.Event, path, provenance string) (string, error) {
 	// default set provenance from the SHA
 	revision := event.SHA

pkg/provider/github/github.go

@@ -330,6 +330,10 @@ func (v *Provider) SetClient(ctx context.Context, run *params.Run, event *info.E
 	return nil
 }
 
+func (v *Provider) GetCommitStatuses(_ context.Context, _ *info.Event) ([]provider.CommitStatusInfo, error) {
+	return nil, nil
+}
+
 // GetTektonDir retrieves all YAML files from the .tekton directory and returns them as a single concatenated multi-document YAML file.
 func (v *Provider) GetTektonDir(ctx context.Context, runevent *info.Event, path, provenance string) (string, error) {
 	tektonDirSha := ""