fix(bitbucket-cloud): fix status key handling for build statuses

Bitbucket Cloud limits commit status keys to 40 characters and uses
them to identify build statuses. Generated a new key on each
CreateStatus call causing duplicate statuses instead of updating
existing ones.

Fix the 40-char truncation to safely handle short names, use 1-based
indexing for status keys, and persist the generated key as a
PipelineRun annotation (pipeline-run-status-key) so subsequent calls
reuse the same key. Move GetCheckName to provider.GetBBCloudStatusKey,
add Index field to matcher.Match for stable instance counts, and add
e2e test to verify build status reporting.

https://redhat.atlassian.net/browse/SRVKP-11710

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: zakisk

pkg/apis/pipelinesascode/keys/keys.go

@@ -64,11 +64,10 @@ const (
 	SecretCreated          = pipelinesascode.GroupName + "/secret-created"
 	CloneURL               = pipelinesascode.GroupName + "/clone-url"
 	// PublicGithubAPIURL default is "https://api.github.com" but it can be overridden by X-GitHub-Enterprise-Host header.
-	PublicGithubAPIURL   = "https://api.github.com"
-	GithubApplicationID  = "github-application-id"
-	GithubPrivateKey     = "github-private-key"
-	ResultsRecordSummary = "results.tekton.dev/recordSummaryAnnotations"
-
+	PublicGithubAPIURL    = "https://api.github.com"
+	GithubApplicationID   = "github-application-id"
+	GithubPrivateKey      = "github-private-key"
+	ResultsRecordSummary  = "results.tekton.dev/recordSummaryAnnotations"
 	SpanContextAnnotation = "tekton.dev/pipelinerunSpanContext"
 )
 

pkg/matcher/annotation_matcher.go

@@ -157,6 +157,7 @@ func getTargetBranch(prun *tektonv1.PipelineRun, event *info.Event) (bool, strin
 
 type Match struct {
 	PipelineRun *tektonv1.PipelineRun
+	Index       int
 	Repo        *apipac.Repository
 	Config      map[string]string
 }

pkg/pipelineascode/pipelineascode.go

@@ -146,6 +146,7 @@ func (p *PacRun) Run(ctx context.Context) error {
 
 		go func(match matcher.Match, i int) {
 			defer wg.Done()
+			match.Index = i
 			p.debugf("starting pipelinerun %s (index=%d)", match.PipelineRun.GetGenerateName(), i)
 			pr, err := p.startPR(ctx, match)
 			if err != nil {
@@ -259,13 +260,14 @@ func (p *PacRun) startPR(ctx context.Context, match matcher.Match) (*tektonv1.Pi
 		return nil, fmt.Errorf("cannot create message template: %w", err)
 	}
 	status := providerstatus.StatusOpts{
-		Status:                  inProgressStatus,
-		Conclusion:              providerstatus.ConclusionPending,
-		Text:                    msg,
-		DetailsURL:              consoleURL,
-		PipelineRunName:         pr.GetName(),
-		PipelineRun:             pr,
-		OriginalPipelineRunName: pr.GetAnnotations()[keys.OriginalPRName],
+		Status:                   inProgressStatus,
+		Conclusion:               providerstatus.ConclusionPending,
+		Text:                     msg,
+		DetailsURL:               consoleURL,
+		PipelineRunName:          pr.GetName(),
+		PipelineRun:              pr,
+		OriginalPipelineRunName:  pr.GetAnnotations()[keys.OriginalPRName],
+		InstanceCountForCheckRun: match.Index,
 	}
 
 	// Patch the pipelineRun with the appropriate annotations and labels.

pkg/provider/bitbucketcloud/bitbucket.go

@@ -113,8 +113,10 @@ func (v *Provider) CreateStatus(_ context.Context, event *info.Event, statusopts
 		detailsURL = statusopts.DetailsURL
 	}
 
+	key := provider.GetBBCloudStatusKey(statusopts, v.pacInfo)
+
 	cso := &bitbucket.CommitStatusOptions{
-		Key:         provider.GetCheckName(statusopts, v.pacInfo),
+		Key:         key,
 		Url:         detailsURL,
 		State:       string(state),
 		Description: statusopts.Title,

pkg/provider/bitbucketcloud/test/bbcloudtest.go

@@ -189,7 +189,7 @@ func MuxCreateCommitstatus(t *testing.T, mux *http.ServeMux, event *info.Event,
 		err := json.Unmarshal(bit, cso)
 		assert.NilError(t, err)
 		pacOpts := &info.PacOpts{Settings: settings.Settings{ApplicationName: applicationName}}
-		assert.Equal(t, provider.GetCheckName(expStatus, pacOpts), cso.Key)
+		assert.Equal(t, provider.GetBBCloudStatusKey(expStatus, pacOpts), cso.Key)
 
 		if expStatus.DetailsURL != "" {
 			assert.Equal(t, expStatus.DetailsURL, cso.Url)

pkg/provider/bitbucketcloud/types/types.go

@@ -125,6 +125,19 @@ type Comments struct {
 	Values []Comment
 }
 
+type Status struct {
+	Key         string     `json:"key"`
+	Type        string     `json:"type"`
+	State       string     `json:"state"`
+	Name        string     `json:"name"`
+	RefName     string     `json:"refname"`
+	Commit      Commit     `json:"commit"`
+	URL         string     `json:"url"`
+	Repository  Repository `json:"repository"`
+	Description string     `json:"description"`
+	Links       Links      `json:"links"`
+}
+
 type CommitStatusState string
 
 // See: https://api.bitbucket.org/swagger.json attribute:

pkg/provider/provider.go

@@ -1,6 +1,8 @@
 package provider
 
 import (
+	"crypto/sha256"
+	"encoding/hex"
 	"fmt"
 	"net/url"
 	"regexp"
@@ -221,6 +223,42 @@ func GetCheckName(status providerstatus.StatusOpts, pacopts *info.PacOpts) strin
 	return status.OriginalPipelineRunName
 }
 
+// GetBBCloudStatusKey returns a unique key for Bitbucket Cloud build commit status.
+// Bitbucket Cloud limits the key to 40 characters. When both ApplicationName and
+// OriginalPipelineRunName are set and their combined form ("{appName} / {prName}")
+// fits within 40 chars, that combined form is used. Otherwise, the
+// OriginalPipelineRunName alone is used. If the name exceeds 40 chars, it is
+// truncated to 33 chars with a 6-char hash suffix for uniqueness. If only
+// ApplicationName is set, it is returned truncated to 40 chars.
+func GetBBCloudStatusKey(status providerstatus.StatusOpts, pacopts *info.PacOpts) string {
+	if pacopts.ApplicationName != "" {
+		if status.OriginalPipelineRunName == "" {
+			if len(pacopts.ApplicationName) > 40 {
+				return pacopts.ApplicationName[:40]
+			}
+			return pacopts.ApplicationName
+		}
+		key := fmt.Sprintf("%s / %s", pacopts.ApplicationName, status.OriginalPipelineRunName)
+		// if application name and pipeline run name combined are less than 40 characters, return the key
+		// otherwise, skip it here and let the only pipeline run being returned.
+		if len(key) <= 40 {
+			return key
+		}
+	}
+
+	if len(status.OriginalPipelineRunName) > 40 {
+		hash := getNameHash(status.OriginalPipelineRunName)
+		return fmt.Sprintf("%s-%s", status.OriginalPipelineRunName[:33], hash)
+	}
+
+	return status.OriginalPipelineRunName
+}
+
+func getNameHash(input string) string {
+	hash := sha256.Sum256([]byte(input))
+	return hex.EncodeToString(hash[:])[:6]
+}
+
 func IsZeroSHA(sha string) bool {
 	return sha == "0000000000000000000000000000000000000000"
 }

pkg/provider/provider_test.go

@@ -1,6 +1,7 @@
 package provider
 
 import (
+	"strings"
 	"testing"
 
 	"github.com/openshift-pipelines/pipelines-as-code/pkg/apis/pipelinesascode/v1alpha1"
@@ -867,3 +868,92 @@ func TestGetGitOpsCommentPrefix(t *testing.T) {
 		})
 	}
 }
+
+func TestGetBBCloudStatusKey(t *testing.T) {
+	tests := []struct {
+		name     string
+		status   status.StatusOpts
+		pacopts  *info.PacOpts
+		expected string
+	}{
+		{
+			name:   "application name only no pipeline run name",
+			status: status.StatusOpts{OriginalPipelineRunName: ""},
+			pacopts: &info.PacOpts{
+				Settings: settings.Settings{ApplicationName: "MyApp"},
+			},
+			expected: "MyApp",
+		},
+		{
+			name:   "application name longer than 40 truncated",
+			status: status.StatusOpts{OriginalPipelineRunName: ""},
+			pacopts: &info.PacOpts{
+				Settings: settings.Settings{ApplicationName: strings.Repeat("x", 50)},
+			},
+			expected: strings.Repeat("x", 40),
+		},
+		{
+			name:   "app and pr name combined fit in 40 chars",
+			status: status.StatusOpts{OriginalPipelineRunName: "my-pr"},
+			pacopts: &info.PacOpts{
+				Settings: settings.Settings{ApplicationName: "MyApp"},
+			},
+			expected: "MyApp / my-pr",
+		},
+		{
+			name:   "app and pr name combined exceed 40 chars falls back to pr name only",
+			status: status.StatusOpts{OriginalPipelineRunName: "this-is-a-very-long-pipeline-run-name"},
+			pacopts: &info.PacOpts{
+				Settings: settings.Settings{ApplicationName: "MyApplication"},
+			},
+			expected: "this-is-a-very-long-pipeline-run-name",
+		},
+		{
+			name:   "no application name short pipeline run name",
+			status: status.StatusOpts{OriginalPipelineRunName: "my-pr"},
+			pacopts: &info.PacOpts{
+				Settings: settings.Settings{ApplicationName: ""},
+			},
+			expected: "my-pr",
+		},
+		{
+			name:   "no application name pipeline run name exactly 40",
+			status: status.StatusOpts{OriginalPipelineRunName: strings.Repeat("a", 40)},
+			pacopts: &info.PacOpts{
+				Settings: settings.Settings{ApplicationName: ""},
+			},
+			expected: strings.Repeat("a", 40),
+		},
+		{
+			name:   "no application name pipeline run name longer than 40 truncated with hash",
+			status: status.StatusOpts{OriginalPipelineRunName: strings.Repeat("c", 50)},
+			pacopts: &info.PacOpts{
+				Settings: settings.Settings{ApplicationName: ""},
+			},
+			expected: strings.Repeat("c", 33) + "-5de6bf",
+		},
+		{
+			name:   "no application name no pipeline run name",
+			status: status.StatusOpts{OriginalPipelineRunName: ""},
+			pacopts: &info.PacOpts{
+				Settings: settings.Settings{ApplicationName: ""},
+			},
+			expected: "",
+		},
+		{
+			name:   "long pr name with app produces stable hash",
+			status: status.StatusOpts{OriginalPipelineRunName: strings.Repeat("b", 50)},
+			pacopts: &info.PacOpts{
+				Settings: settings.Settings{ApplicationName: "App"},
+			},
+			expected: strings.Repeat("b", 33) + "-c01a9b",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := GetBBCloudStatusKey(tt.status, tt.pacopts)
+			assert.Equal(t, tt.expected, got)
+			assert.Assert(t, len(got) <= 40, "key length %d exceeds 40 char limit: %s", len(got), got)
+		})
+	}
+}

test/bitbucket_cloud_pullrequest_test.go

@@ -5,11 +5,14 @@ package test
 import (
 	"context"
 	"fmt"
+	"strings"
 	"testing"
 	"time"
 
 	"github.com/ktrysmt/go-bitbucket"
+	"github.com/mitchellh/mapstructure"
 	"github.com/openshift-pipelines/pipelines-as-code/pkg/params/triggertype"
+	"github.com/openshift-pipelines/pipelines-as-code/pkg/provider/bitbucketcloud/types"
 	tbb "github.com/openshift-pipelines/pipelines-as-code/test/pkg/bitbucketcloud"
 	"github.com/openshift-pipelines/pipelines-as-code/test/pkg/options"
 	"github.com/openshift-pipelines/pipelines-as-code/test/pkg/payload"
@@ -107,6 +110,65 @@ func TestBitbucketCloudPullRequestCancelInProgressMerged(t *testing.T) {
 	assert.Equal(t, prs.Items[0].GetStatusCondition().GetCondition(apis.ConditionSucceeded).GetReason(), "Cancelled", "should have been cancelled")
 }
 
+func TestBitbucketCloudPRBuildStatusReported(t *testing.T) {
+	targetNS := names.SimpleNameGenerator.RestrictLengthWithRandomSuffix("pac-e2e-ns")
+	ctx := context.Background()
+
+	runcnx, opts, bprovider, err := tbb.Setup(ctx)
+	if err != nil {
+		t.Skip(err.Error())
+		return
+	}
+	bcrepo := tbb.CreateCRD(ctx, t, bprovider, runcnx, opts, targetNS)
+	targetRefName := names.SimpleNameGenerator.RestrictLengthWithRandomSuffix("pac-e2e-test")
+	title := "TestPullRequest - " + targetRefName
+
+	entries, err := payload.GetEntries(
+		map[string]string{".tekton/pipelinerun.yaml": "testdata/pipelinerun.yaml"},
+		targetNS, options.MainBranch, triggertype.PullRequest.String(), map[string]string{})
+	assert.NilError(t, err)
+
+	pr, repobranch := tbb.MakePR(t, bprovider, runcnx, bcrepo, opts, title, targetRefName, entries)
+	defer tbb.TearDown(ctx, t, runcnx, bprovider, opts, pr.ID, targetRefName, targetNS, false)
+
+	hash, ok := repobranch.Target["hash"].(string)
+	assert.Assert(t, ok)
+
+	sopt := twait.SuccessOpt{
+		TargetNS:        targetNS,
+		OnEvent:         triggertype.PullRequest.String(),
+		NumberofPRMatch: 1,
+		SHA:             hash,
+		Title:           title,
+		MinNumberStatus: 1,
+	}
+	twait.Succeeded(ctx, t, runcnx, opts, sopt)
+
+	resp, err := bprovider.Client().Repositories.Commits.GetCommitStatuses(&bitbucket.CommitsOptions{
+		Owner:    opts.Organization,
+		RepoSlug: opts.Repo,
+		Revision: hash,
+	})
+	assert.NilError(t, err)
+
+	statusesMap, ok := resp.(map[string]any)
+	assert.Equal(t, ok, true, "cannot convert Bitbucket commit statuses response to map[string]any")
+
+	statuses := []*types.Status{}
+
+	err = mapstructure.Decode(statusesMap["values"], &statuses)
+	assert.NilError(t, err, fmt.Sprintf("cannot decode Bitbucket commit statuses from response payload: %v", err))
+
+	foundStatus := false
+	for _, status := range statuses {
+		if strings.Contains(status.Key, "pipelinerun-") {
+			foundStatus = true
+			break
+		}
+	}
+	assert.Equal(t, foundStatus, true, "should have found the status for the pipeline run")
+}
+
 // Local Variables:
 // compile-command: "go test -tags=e2e -v -run TestBitbucketCloudPullRequest$ ."
 // End: