feat(taskspec): include inline steps in Status.Steps when StepActions are used

Maximilien-R · Maximilien-R · commit 1b37def46efd · 2025-10-03T17:06:11.000+02:00
When at least one StepAction is referenced, `TaskRun.Status.Steps` is
pre-populated to capture provenance for remote steps during resolution.
However, inline steps were not included at that stage and only appeared
later during pod-based status reconciliation. This contributed to confusing
ordering and visibility for dashboards relying on `Status.Steps`.

In the Tekton Dashboard specifically, StepAction-backed steps showed up
first (because they were present in `Status.Steps` right after resolution),
while inline steps appeared only after the pod was created and
`MakeTaskRunStatus` had run to append them. This resulted in steps
"popping" into view and reshuffling, which was confusing.

When a `TaskRun` references at least one `StepAction`, in the resolution
flow, the inline `Step` should also append an entry in `Status.Steps` even
if it has no `Provenance`.

add comment for readibility
diff --git a/pkg/reconciler/taskrun/resources/taskspec.go b/pkg/reconciler/taskrun/resources/taskspec.go
@@ -174,6 +174,8 @@ func resolveStepRef(ctx context.Context, taskSpec v1.TaskSpec, taskRun *v1.TaskR
 
 // updateTaskRunProvenance update the TaskRun's status with source provenance information for a given step
 func updateTaskRunProvenance(taskRun *v1.TaskRun, stepName string, stepIndex int, source *v1.RefSource, stepStatusIndex map[string]int) {
+	var provenance *v1.Provenance
+
 	// The StepState already exists. Update it in place
 	if index, found := stepStatusIndex[stepName]; found {
 		if taskRun.Status.Steps[index].Provenance == nil {
@@ -183,10 +185,12 @@ func updateTaskRunProvenance(taskRun *v1.TaskRun, stepName string, stepIndex int
 		return
 	}
 
+	provenance = &v1.Provenance{RefSource: source}
+
 	// No existing StepState found. Create and append a new one
 	newState := v1.StepState{
 		Name:       pod.TrimStepPrefix(pod.StepName(stepName, stepIndex)),
-		Provenance: &v1.Provenance{RefSource: source},
+		Provenance: provenance,
 	}
 	taskRun.Status.Steps = append(taskRun.Status.Steps, newState)
 }
@@ -237,15 +241,13 @@ func GetStepActionsData(ctx context.Context, taskSpec v1.TaskSpec, taskRun *v1.T
 	for i, step := range taskSpec.Steps {
 		if step.Ref == nil {
 			steps[i] = step
+			updateTaskRunProvenance(taskRun, step.Name, i, nil, stepStatusIndex) // create StepState for inline step with nil provenance
 			continue
 		}
 
 		stepRefResolution := stepRefResolutions[i]
 		steps[i] = *stepRefResolution.resolvedStep
-
-		if stepRefResolution.source != nil {
-			updateTaskRunProvenance(taskRun, stepRefResolution.resolvedStep.Name, i, stepRefResolution.source, stepStatusIndex)
-		}
+		updateTaskRunProvenance(taskRun, stepRefResolution.resolvedStep.Name, i, stepRefResolution.source, stepStatusIndex)
 	}
 
 	return steps, nil
diff --git a/pkg/reconciler/taskrun/resources/taskspec_test.go b/pkg/reconciler/taskrun/resources/taskspec_test.go
@@ -756,6 +756,216 @@ spec:
 	}
 }
 
+func TestGetStepActionsData_Status(t *testing.T) {
+	firstStepAction := parse.MustParseV1beta1StepAction(t, `
+metadata:
+  name: first-stepaction
+  namespace: default
+spec:
+  image: myImage
+`)
+	firstStepActionSource := v1.RefSource{
+		URI:    "ref-source",
+		Digest: map[string]string{"sha256": "abcd123456"},
+	}
+
+	firstStepActionBytes, err := yaml.Marshal(firstStepAction)
+	if err != nil {
+		t.Fatal("failed to marshal StepAction", err)
+	}
+	rr := test.NewResolvedResource(firstStepActionBytes, map[string]string{}, &firstStepActionSource, nil)
+	requester := test.NewRequester(rr, nil, resource.ResolverPayload{})
+
+	tests := []struct {
+		name        string
+		tr          *v1.TaskRun
+		stepActions []*v1beta1.StepAction
+		want        v1.TaskRunStatus
+	}{
+		{
+			name: "inline only",
+			tr: &v1.TaskRun{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "mytaskrun",
+					Namespace: "default",
+				},
+				Spec: v1.TaskRunSpec{
+					TaskSpec: &v1.TaskSpec{
+						Steps: []v1.Step{
+							{
+								Name:  "first-inline",
+								Image: "ubuntu",
+							},
+							{
+								Name:  "second-inline",
+								Image: "ubuntu",
+							},
+						},
+					},
+				},
+			},
+			want: v1.TaskRunStatus{},
+		}, {
+			name: "StepAction only",
+			tr: &v1.TaskRun{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "mytaskrun",
+					Namespace: "default",
+				},
+				Spec: v1.TaskRunSpec{
+					TaskSpec: &v1.TaskSpec{
+						Steps: []v1.Step{
+							{
+								Name: "first-remote",
+								Ref: &v1.Ref{
+									Name: "first-stepaction",
+									ResolverRef: v1.ResolverRef{
+										Resolver: "foobar",
+									},
+								},
+							},
+							{
+								Name: "second-remote",
+								Ref: &v1.Ref{
+									Name: "second-stepaction",
+								},
+							},
+						},
+					},
+				},
+			},
+			stepActions: []*v1beta1.StepAction{
+				firstStepAction,
+				{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:      "second-stepaction",
+						Namespace: "default",
+					},
+					Spec: v1beta1.StepActionSpec{
+						Image: "myimage",
+					},
+				},
+			},
+			want: v1.TaskRunStatus{
+				TaskRunStatusFields: v1.TaskRunStatusFields{
+					Steps: []v1.StepState{
+						{
+							Name: "first-remote",
+							Provenance: &v1.Provenance{
+								RefSource: &v1.RefSource{
+									URI:    "ref-source",
+									Digest: map[string]string{"sha256": "abcd123456"},
+								},
+							},
+						},
+						{
+							Name:       "second-remote",
+							Provenance: &v1.Provenance{},
+						},
+					},
+				},
+			},
+		},
+		{
+			name: "mixed inline and StepAction",
+			tr: &v1.TaskRun{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "mytaskrun",
+					Namespace: "default",
+				},
+				Spec: v1.TaskRunSpec{
+					TaskSpec: &v1.TaskSpec{
+						Steps: []v1.Step{
+							{
+								Name:  "first-inline",
+								Image: "ubuntu",
+							},
+							{
+								Name: "second-remote",
+								Ref: &v1.Ref{
+									Name: "first-stepaction",
+									ResolverRef: v1.ResolverRef{
+										Resolver: "foobar",
+									},
+								},
+							},
+							{
+								Name:  "third-inline",
+								Image: "ubuntu",
+							},
+							{
+								Name: "fourth-remote",
+								Ref: &v1.Ref{
+									Name: "second-stepaction",
+								},
+							},
+						},
+					},
+				},
+			},
+			stepActions: []*v1beta1.StepAction{
+				firstStepAction,
+				{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:      "second-stepaction",
+						Namespace: "default",
+					},
+					Spec: v1beta1.StepActionSpec{
+						Image: "myimage",
+					},
+				},
+			},
+			want: v1.TaskRunStatus{
+				TaskRunStatusFields: v1.TaskRunStatusFields{
+					Steps: []v1.StepState{
+						{
+							Name:       "first-inline",
+							Provenance: &v1.Provenance{},
+						},
+						{
+							Name: "second-remote",
+							Provenance: &v1.Provenance{
+								RefSource: &v1.RefSource{
+									URI:    "ref-source",
+									Digest: map[string]string{"sha256": "abcd123456"},
+								},
+							},
+						},
+						{
+							Name:       "third-inline",
+							Provenance: &v1.Provenance{},
+						},
+						{
+							Name:       "fourth-remote",
+							Provenance: &v1.Provenance{},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := t.Context()
+			tektonclient := fake.NewSimpleClientset()
+			for _, sa := range tt.stepActions {
+				if err := tektonclient.Tracker().Add(sa); err != nil {
+					t.Fatal(err)
+				}
+			}
+
+			_, err := GetStepActionsData(ctx, *tt.tr.Spec.TaskSpec, tt.tr, tektonclient, nil, requester)
+			if err != nil {
+				t.Fatalf("Did not expect an error but got : %s", err)
+			}
+			if d := cmp.Diff(tt.want, tt.tr.Status); d != "" {
+				t.Errorf("the taskrun status did not match what was expected diff: %s", diff.PrintWantGot(d))
+			}
+		})
+	}
+}
+
 func TestGetStepActionsData(t *testing.T) {
 	taskRunUser := int64(1001)
 	stepActionUser := int64(1000)
