feat: config option to prefer one-by-one recommendation rollouts

castai/resource_workload_scaling_policy.go

@@ -45,6 +45,7 @@ const (
 	FieldRolloutBehavior                           = "rollout_behavior"
 	FieldRolloutBehaviorType                       = "type"
 	FieldRolloutBehaviorNoDisruptionType           = "NO_DISRUPTION"
+	FieldRolloutBehaviorPreferOneByOneType         = "prefer_one_by_one"
 	FieldPredictiveScaling                         = "predictive_scaling"
 	FieldConfidenceThreshold                       = "threshold"
 	DeprecatedFieldApplyThreshold                  = "apply_threshold"
@@ -291,11 +292,16 @@ It can be either:
 					Schema: map[string]*schema.Schema{
 						FieldRolloutBehaviorType: {
 							Type:     schema.TypeString,
-							Required: true,
+							Optional: true,
 							Description: `Defines the rollout type to be used when applying recommendations.
 	- NO_DISRUPTION - pods are restarted without causing service disruption.`,
 							ValidateDiagFunc: validation.ToDiagFunc(validation.StringInSlice([]string{FieldRolloutBehaviorNoDisruptionType}, false)),
 						},
+						FieldRolloutBehaviorPreferOneByOneType: {
+							Type:        schema.TypeBool,
+							Optional:    true,
+							Description: `Defines if pods should be restarted one by one to avoid service disruption.`,
+						},
 					},
 				},
 			},
@@ -1358,20 +1364,35 @@ func toRolloutBehavior(m map[string]any) *sdk.WorkloadoptimizationV1RolloutBehav
 	if v, ok := m[FieldRolloutBehaviorType].(string); ok && v != "" {
 		r.Type = lo.ToPtr(sdk.WorkloadoptimizationV1RolloutBehaviorType(v))
 	}
+	if v, ok := m[FieldRolloutBehaviorPreferOneByOneType].(bool); ok {
+		r.PreferOneByOne = lo.ToPtr(v)
+	}
+
+	if r.Type == nil && r.PreferOneByOne == nil {
+		return nil
+	}
 
 	return r
 }
 
 func toRolloutBehaviorMap(s *sdk.WorkloadoptimizationV1RolloutBehaviorSettings) []map[string]any {
-	if s == nil || s.Type == nil {
+	if s == nil {
 		return nil
 	}
 
-	return []map[string]any{
-		{
-			FieldRolloutBehaviorType: string(*s.Type),
-		},
+	if s.Type == nil && s.PreferOneByOne == nil {
+		return nil
 	}
+
+	m := map[string]any{}
+	if s.Type != nil {
+		m[FieldRolloutBehaviorType] = string(*s.Type)
+	}
+	if s.PreferOneByOne != nil {
+		m[FieldRolloutBehaviorPreferOneByOneType] = *s.PreferOneByOne
+	}
+
+	return []map[string]any{m}
 }
 
 func getWorkloadScalingPolicyByName(ctx context.Context, client sdk.ClientWithResponsesInterface, clusterID, name string) (*sdk.WorkloadoptimizationV1WorkloadScalingPolicy, error) {

castai/resource_workload_scaling_policy_test.go

@@ -582,6 +582,42 @@ func Test_toRolloutBehavior(t *testing.T) {
 				Type: lo.ToPtr(sdk.NODISRUPTION),
 			},
 		},
+		"should return rollout behavior settings with prefer_one_by_one": {
+			args: map[string]any{
+				FieldRolloutBehaviorType:               FieldRolloutBehaviorNoDisruptionType,
+				FieldRolloutBehaviorPreferOneByOneType: true,
+			},
+			exp: &sdk.WorkloadoptimizationV1RolloutBehaviorSettings{
+				Type:           lo.ToPtr(sdk.NODISRUPTION),
+				PreferOneByOne: lo.ToPtr(true),
+			},
+		},
+		"should return rollout behavior settings with prefer_one_by_one false": {
+			args: map[string]any{
+				FieldRolloutBehaviorType:               FieldRolloutBehaviorNoDisruptionType,
+				FieldRolloutBehaviorPreferOneByOneType: false,
+			},
+			exp: &sdk.WorkloadoptimizationV1RolloutBehaviorSettings{
+				Type:           lo.ToPtr(sdk.NODISRUPTION),
+				PreferOneByOne: lo.ToPtr(false),
+			},
+		},
+		"should return rollout behavior settings with only prefer_one_by_one": {
+			args: map[string]any{
+				FieldRolloutBehaviorPreferOneByOneType: true,
+			},
+			exp: &sdk.WorkloadoptimizationV1RolloutBehaviorSettings{
+				PreferOneByOne: lo.ToPtr(true),
+			},
+		},
+		"should return nil when only prefer_one_by_one is false": {
+			args: map[string]any{
+				FieldRolloutBehaviorPreferOneByOneType: false,
+			},
+			exp: &sdk.WorkloadoptimizationV1RolloutBehaviorSettings{
+				PreferOneByOne: lo.ToPtr(false),
+			},
+		},
 		"should return nil on empty map": {
 			args: map[string]any{},
 			exp:  nil,
@@ -596,6 +632,83 @@ func Test_toRolloutBehavior(t *testing.T) {
 	}
 }
 
+func Test_toRolloutBehaviorMap(t *testing.T) {
+	tests := map[string]struct {
+		args *sdk.WorkloadoptimizationV1RolloutBehaviorSettings
+		exp  []map[string]any
+	}{
+		"should return rollout behavior map": {
+			args: &sdk.WorkloadoptimizationV1RolloutBehaviorSettings{
+				Type: lo.ToPtr(sdk.NODISRUPTION),
+			},
+			exp: []map[string]any{
+				{
+					FieldRolloutBehaviorType: string(sdk.NODISRUPTION),
+				},
+			},
+		},
+		"should return rollout behavior map with prefer_one_by_one": {
+			args: &sdk.WorkloadoptimizationV1RolloutBehaviorSettings{
+				Type:           lo.ToPtr(sdk.NODISRUPTION),
+				PreferOneByOne: lo.ToPtr(true),
+			},
+			exp: []map[string]any{
+				{
+					FieldRolloutBehaviorType:               string(sdk.NODISRUPTION),
+					FieldRolloutBehaviorPreferOneByOneType: true,
+				},
+			},
+		},
+		"should return rollout behavior map with prefer_one_by_one false": {
+			args: &sdk.WorkloadoptimizationV1RolloutBehaviorSettings{
+				Type:           lo.ToPtr(sdk.NODISRUPTION),
+				PreferOneByOne: lo.ToPtr(false),
+			},
+			exp: []map[string]any{
+				{
+					FieldRolloutBehaviorType:               string(sdk.NODISRUPTION),
+					FieldRolloutBehaviorPreferOneByOneType: false,
+				},
+			},
+		},
+		"should return rollout behavior map with only prefer_one_by_one": {
+			args: &sdk.WorkloadoptimizationV1RolloutBehaviorSettings{
+				PreferOneByOne: lo.ToPtr(true),
+			},
+			exp: []map[string]any{
+				{
+					FieldRolloutBehaviorPreferOneByOneType: true,
+				},
+			},
+		},
+		"should return rollout behavior map with only prefer_one_by_one false": {
+			args: &sdk.WorkloadoptimizationV1RolloutBehaviorSettings{
+				PreferOneByOne: lo.ToPtr(false),
+			},
+			exp: []map[string]any{
+				{
+					FieldRolloutBehaviorPreferOneByOneType: false,
+				},
+			},
+		},
+		"should return nil for nil input": {
+			args: nil,
+			exp:  nil,
+		},
+		"should return nil for empty settings": {
+			args: &sdk.WorkloadoptimizationV1RolloutBehaviorSettings{},
+			exp:  nil,
+		},
+	}
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			r := require.New(t)
+			got := toRolloutBehaviorMap(tt.args)
+			r.Equal(tt.exp, got)
+		})
+	}
+}
+
 func Test_resourceWorkloadScalingPolicyCreate(t *testing.T) {
 	organizationId := "63d2af53-9a42-4968-be1e-39316ebfd8d4"
 	clusterId := "4e4cd9eb-82eb-407e-a926-e5fef81cab50"