fix(autoscaling): StepScalingPolicy intervals not checked for going over allowable maximum

packages/aws-cdk-lib/aws-applicationautoscaling/lib/step-scaling-policy.ts

@@ -15,6 +15,8 @@ export interface BasicStepScalingPolicyProps {
    * The intervals for scaling.
    *
    * Maps a range of metric values to a particular scaling behavior.
+   *
+   * Must be between 2 and 40 steps.
    */
   readonly scalingSteps: ScalingInterval[];
 
@@ -111,6 +113,10 @@ export class StepScalingPolicy extends Construct {
       throw new Error('You must supply at least 2 intervals for autoscaling');
     }
 
+    if (props.scalingSteps.length > 40) {
+      throw new Error('You must have less than 40 steps in StepScalingPolicyProps.scalingSteps');
+    }
+
     if (props.datapointsToAlarm !== undefined && props.datapointsToAlarm < 1) {
       throw new RangeError(`datapointsToAlarm cannot be less than 1, got: ${props.datapointsToAlarm}`);
     }

packages/aws-cdk-lib/aws-applicationautoscaling/test/step-scaling-policy.test.ts

@@ -273,6 +273,47 @@ describe('step scaling policy', () => {
       });
     }).toThrow('datapointsToAlarm cannot be less than 1, got: 0');
   });
+
+  test('scalingSteps must have at least 2 steps', () => {
+    // GIVEN
+    const stack = new cdk.Stack();
+    const target = createScalableTarget(stack);
+
+    expect(() => {
+      target.scaleOnMetric('Tracking', {
+        metric: new cloudwatch.Metric({ namespace: 'Test', metricName: 'Metric' }),
+        scalingSteps: [
+          { lower: 0, upper: 2, change: +1 },
+        ],
+      });
+    }).toThrow(/must supply at least 2/);
+  });
+
+  test('scalingSteps has a maximum of 40 steps', () => {
+    // GIVEN
+    const stack = new cdk.Stack();
+    const target = createScalableTarget(stack);
+
+    const numSteps = 41;
+    const messagesPerTask = 20;
+    let steps: appscaling.ScalingInterval[] = [];
+
+    for (let i = 0; i < numSteps; ++i) {
+      const step: appscaling.ScalingInterval = {
+        lower: i * messagesPerTask,
+        upper: i * (messagesPerTask + 1) - 1,
+        change: i + 1,
+      };
+      steps.push(step);
+    }
+
+    expect(() => {
+      target.scaleOnMetric('Tracking', {
+        metric: new cloudwatch.Metric({ namespace: 'Test', metricName: 'Metric' }),
+        scalingSteps: steps,
+      });
+    }).toThrow(/must have less than 40/);
+  });
 });
 
 /**

packages/aws-cdk-lib/aws-autoscaling/lib/step-scaling-policy.ts

@@ -15,6 +15,8 @@ export interface BasicStepScalingPolicyProps {
    * The intervals for scaling.
    *
    * Maps a range of metric values to a particular scaling behavior.
+   *
+   * Must be between 2 and 40 steps.
    */
   readonly scalingSteps: ScalingInterval[];
 
@@ -96,6 +98,10 @@ export class StepScalingPolicy extends Construct {
       throw new Error('You must supply at least 2 intervals for autoscaling');
     }
 
+    if (props.scalingSteps.length > 40) {
+      throw new Error('You must have less than 40 steps in StepScalingPolicyProps.scalingSteps');
+    }
+
     const adjustmentType = props.adjustmentType || AdjustmentType.CHANGE_IN_CAPACITY;
     const changesAreAbsolute = adjustmentType === AdjustmentType.EXACT_CAPACITY;
 

packages/aws-cdk-lib/aws-autoscaling/test/scaling.test.ts

@@ -327,6 +327,61 @@ test('step scaling with evaluation period configured', () => {
   });
 });
 
+describe('step-scaling-policy scalingSteps length validation checks', () => {
+  test('scalingSteps must have at least 2 steps', () => {
+    // GIVEN
+    const stack = new cdk.Stack();
+    const fixture = new ASGFixture(stack, 'Fixture');
+
+    expect(() => {
+      fixture.asg.scaleOnMetric('Metric', {
+        metric: new cloudwatch.Metric({
+          metricName: 'Legs',
+          namespace: 'Henk',
+          dimensionsMap: { Mustache: 'Bushy' },
+        }),
+        estimatedInstanceWarmup: cdk.Duration.seconds(150),
+        // only one scaling step throws an error
+        scalingSteps: [
+          { lower: 0, upper: 2, change: +1 },
+        ],
+      });
+    }).toThrow(/must supply at least 2/);
+  });
+
+  test('scalingSteps has a maximum of 40 steps', () => {
+    // GIVEN
+    const stack = new cdk.Stack();
+    const fixture = new ASGFixture(stack, 'Fixture');
+
+    const numSteps = 41;
+    const messagesPerTask = 20;
+    let steps: autoscaling.ScalingInterval[] = [];
+
+    for (let i = 0; i < numSteps; ++i) {
+      const step: autoscaling.ScalingInterval = {
+        lower: i * messagesPerTask,
+        upper: i * (messagesPerTask + 1) - 1,
+        change: i + 1,
+      };
+      steps.push(step);
+    }
+
+    expect(() => {
+      fixture.asg.scaleOnMetric('Metric', {
+        metric: new cloudwatch.Metric({
+          metricName: 'Legs',
+          namespace: 'Henk',
+          dimensionsMap: { Mustache: 'Bushy' },
+        }),
+        estimatedInstanceWarmup: cdk.Duration.seconds(150),
+        // only one scaling step throws an error
+        scalingSteps: steps,
+      });
+    }).toThrow(/must have less than 40/);
+  });
+});
+
 class ASGFixture extends Construct {
   public readonly vpc: ec2.Vpc;
   public readonly asg: autoscaling.AutoScalingGroup;