fix(controller): honor scaleUpPreviewCheckPoint reset on blueGreen pod template change

When a new pod template is rolled out while the previous revision had
already completed prePromotionAnalysis (and thus set
status.blueGreen.scaleUpPreviewCheckPoint=true), the new revision
inherits that value and Argo Rollouts skips creating an AnalysisRun for
it entirely -- including the prePromotionAnalysis gate.

syncRolloutStatusBlueGreen calls resetRolloutStatus(&newStatus) on pod
template change, which clears newStatus.BlueGreen.ScaleUpPreviewCheckPoint.
The subsequent call to calculateScaleUpPreviewCheckPoint read prevValue
from c.rollout.Status (the pre-reset value) rather than the newStatus
parameter that was just reset, immediately clobbering the reset.

Read prevValue from newStatus so the reset applied earlier in the same
reconcile is honored, matching the documented behavior:

  // ... gets reset to false when the pod template changes, or the
  // rollout fully promotes (stableRS == newRS)

Add a regression test that fails on the old behavior and passes with
the fix.

Signed-off-by: Abizer Lokhandwala <abizer@abizer.me>

Author: abizer

rollout/bluegreen.go

@@ -326,8 +326,11 @@ func (c *rolloutContext) calculateScaleUpPreviewCheckPoint(newStatus v1alpha1.Ro
 	}
 
 	// Once the ScaleUpPreviewCheckPoint is set to true, the rollout should keep that value until
-	// the newRS becomes the new stableRS or there is a template change.
-	prevValue := c.rollout.Status.BlueGreen.ScaleUpPreviewCheckPoint
+	// the newRS becomes the new stableRS or there is a template change. Read from newStatus rather
+	// than c.rollout.Status so that a reset applied earlier in this reconcile (e.g. by
+	// resetRolloutStatus on a pod template change) is honored instead of being clobbered by the
+	// pre-reset value.
+	prevValue := newStatus.BlueGreen.ScaleUpPreviewCheckPoint
 	if prevValue {
 		return true
 	}

rollout/bluegreen_test.go

@@ -20,6 +20,7 @@ import (
 	"github.com/argoproj/argo-rollouts/utils/annotations"
 	"github.com/argoproj/argo-rollouts/utils/conditions"
 	"github.com/argoproj/argo-rollouts/utils/hash"
+	logutil "github.com/argoproj/argo-rollouts/utils/log"
 	rolloututil "github.com/argoproj/argo-rollouts/utils/rollout"
 	timeutil "github.com/argoproj/argo-rollouts/utils/time"
 )
@@ -1193,6 +1194,46 @@ func TestPreviewReplicaCountHandleScaleUpPreviewCheckPoint(t *testing.T) {
 	})
 }
 
+// TestCalculateScaleUpPreviewCheckPointHonorsReset is a regression test for
+// https://github.com/argoproj/argo-rollouts/issues/<TBD>.
+//
+// When a new pod template arrives while the previous revision had already completed
+// prePromotionAnalysis, syncRolloutStatusBlueGreen calls resetRolloutStatus(&newStatus),
+// which sets newStatus.BlueGreen.ScaleUpPreviewCheckPoint=false. The subsequent call to
+// calculateScaleUpPreviewCheckPoint must honor that reset — i.e. read prevValue from
+// newStatus, not from c.rollout.Status — otherwise the new revision inherits the
+// previous revision's scaleUpPreviewCheckPoint=true and skips its own prePromotionAnalysis.
+func TestCalculateScaleUpPreviewCheckPointHonorsReset(t *testing.T) {
+	r := newBlueGreenRollout("foo", 5, nil, "active", "")
+	r.Spec.Strategy.BlueGreen.PreviewReplicaCount = ptr.To[int32](3)
+	r.Spec.Strategy.BlueGreen.PrePromotionAnalysis = &v1alpha1.RolloutAnalysis{
+		Templates: []v1alpha1.AnalysisTemplateRef{{TemplateName: "test"}},
+	}
+	// The previous revision's status carried ScaleUpPreviewCheckPoint=true (its
+	// prePromotionAnalysis had succeeded). c.rollout.Status still reflects that value
+	// at the start of this reconcile.
+	r.Status.BlueGreen.ScaleUpPreviewCheckPoint = true
+	newRS := newReplicaSetWithStatus(r, 0, 0)
+
+	c := &rolloutContext{
+		rollout:      r,
+		newRS:        newRS,
+		log:          logutil.WithRollout(r),
+		pauseContext: &pauseContext{rollout: r},
+	}
+
+	// resetRolloutStatus has already cleared the checkpoint on newStatus for this
+	// reconcile. With no AnalysisRun yet for the new revision (currentArs is empty),
+	// completedPrePromotionAnalysis() is false, so prePromotion must run before the
+	// checkpoint can flip. The function must read prevValue from newStatus rather than
+	// the stale c.rollout.Status, then fall through and return false.
+	newStatus := v1alpha1.RolloutStatus{}
+	newStatus.BlueGreen.ScaleUpPreviewCheckPoint = false
+
+	assert.False(t, c.calculateScaleUpPreviewCheckPoint(newStatus),
+		"scaleUpPreviewCheckPoint must be reset on pod template change so the new revision's prePromotionAnalysis runs")
+}
+
 func TestBlueGreenRolloutIgnoringScalingUsePreviewRSCount(t *testing.T) {
 	f := newFixture(t)
 	defer f.Close()