konokenj.cdk-api-mcp-server 0.31.0__py3-none-any.whl → 0.57.0__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet-attribute-based-compute.ts

@@ -1,17 +1,55 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
 import * as cdk from 'aws-cdk-lib';
 import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as codebuild from 'aws-cdk-lib/aws-codebuild';
 import { Construct } from 'constructs';
 
-const configurations: codebuild.ComputeConfiguration[] = [
+type StackConfiguration = {
+  computeConfiguration: codebuild.ComputeConfiguration;
+  vpcProps?: ec2.VpcProps;
+  subnetSelection?: ec2.SubnetSelection;
+  securityGroupProps?: Array<Omit<ec2.SecurityGroupProps, 'vpc'>>;
+}
+const configurations: Array<StackConfiguration> = [
+  {
+    computeConfiguration: {
+      machineType: codebuild.MachineType.GENERAL,
+    },
+  },
   {
-    machineType: codebuild.MachineType.GENERAL,
+    computeConfiguration: {
+      machineType: codebuild.MachineType.GENERAL,
+      vCpu: 2,
+      memory: cdk.Size.gibibytes(4),
+      disk: cdk.Size.gibibytes(10),
+    },
   },
   {
-    machineType: codebuild.MachineType.GENERAL,
-    vCpu: 2,
-    memory: cdk.Size.gibibytes(4),
-    disk: cdk.Size.gibibytes(10),
+    computeConfiguration: {
+      machineType: codebuild.MachineType.GENERAL,
+    },
+    vpcProps: {
+      maxAzs: 1,
+      restrictDefaultSecurityGroup: false,
+    },
+  },
+  {
+    computeConfiguration: {
+      machineType: codebuild.MachineType.GENERAL,
+    },
+    vpcProps: {
+      maxAzs: 1,
+      // Incredibly, if you pass a SubnetSelection that produces more than 1
+      // subnet, you currently get this error:
+      // > Resource handler returned message: "Invalid vpc config: the maximum number of subnets is 1
+      // This seems like a terrible limitation from the CodeBuild team.
+      // maxAzs: 2,
+    },
+    subnetSelection: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },
+    securityGroupProps: [
+      { allowAllOutbound: true },
+      { allowAllIpv6Outbound: true },
+    ],
   },
 ];
 
@@ -19,14 +57,27 @@ class FleetStack extends cdk.Stack {
   public readonly fleet: codebuild.Fleet;
   public readonly project: codebuild.Project;
 
-  constructor(scope: Construct, id: string, computeConfiguration: codebuild.ComputeConfiguration) {
+  constructor(scope: Construct, id: string, { computeConfiguration, vpcProps, subnetSelection, securityGroupProps }: StackConfiguration) {
     super(scope, id);
 
+    let vpc: ec2.Vpc | undefined;
+    let securityGroups: Array<ec2.SecurityGroup> | undefined;
+    if (vpcProps) {
+      vpc = new ec2.Vpc(this, 'Vpc', vpcProps);
+      const refinedVpc = vpc;
+      securityGroups = securityGroupProps?.map((props, i) =>
+        new ec2.SecurityGroup(this, `SecurityGroup${i}`, { ...props, vpc: refinedVpc }),
+      );
+    }
+
     this.fleet = new codebuild.Fleet(this, 'MyFleet', {
       baseCapacity: 1,
       computeType: codebuild.FleetComputeType.ATTRIBUTE_BASED,
       computeConfiguration,
       environmentType: codebuild.EnvironmentType.LINUX_CONTAINER,
+      vpc,
+      securityGroups,
+      subnetSelection,
     });
 
     this.project = new codebuild.Project(this, 'MyProject', {
@@ -38,6 +89,7 @@ class FleetStack extends cdk.Stack {
       }),
       environment: {
         buildImage: codebuild.LinuxBuildImage.STANDARD_7_0,
+        fleet: this.fleet,
       },
     });
   }

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet-custom-instance-type.ts

@@ -0,0 +1,130 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as cdk from 'aws-cdk-lib';
+import * as codebuild from 'aws-cdk-lib/aws-codebuild';
+import { Construct } from 'constructs';
+
+type StackConfiguration = {
+  computeConfiguration: codebuild.ComputeConfiguration;
+  vpcProps?: ec2.VpcProps;
+  subnetSelection?: ec2.SubnetSelection;
+  securityGroupProps?: Array<Omit<ec2.SecurityGroupProps, 'vpc'>>;
+}
+const configurations: Array<StackConfiguration> = [
+  {
+    computeConfiguration: {
+      instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MEDIUM),
+    },
+  },
+  {
+    computeConfiguration: {
+      instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MEDIUM),
+      disk: cdk.Size.gibibytes(10),
+    },
+  },
+  {
+    computeConfiguration: {
+      instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MEDIUM),
+    },
+    vpcProps: {
+      maxAzs: 1,
+      restrictDefaultSecurityGroup: false,
+    },
+  },
+  {
+    computeConfiguration: {
+      instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MEDIUM),
+    },
+    vpcProps: {
+      maxAzs: 1,
+      // Incredibly, if you pass a SubnetSelection that produces more than 1
+      // subnet, you currently get this error:
+      // > Resource handler returned message: "Invalid vpc config: the maximum number of subnets is 1
+      // This seems like a terrible limitation from the CodeBuild team.
+      // maxAzs: 2,
+    },
+    subnetSelection: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },
+    securityGroupProps: [
+      { allowAllOutbound: true },
+      { allowAllIpv6Outbound: true },
+    ],
+  },
+];
+
+class FleetStack extends cdk.Stack {
+  public readonly fleet: codebuild.Fleet;
+  public readonly project: codebuild.Project;
+
+  constructor(scope: Construct, id: string, { computeConfiguration, vpcProps, subnetSelection, securityGroupProps }: StackConfiguration) {
+    super(scope, id);
+
+    let vpc: ec2.Vpc | undefined;
+    let securityGroups: Array<ec2.SecurityGroup> | undefined;
+    if (vpcProps) {
+      vpc = new ec2.Vpc(this, 'Vpc', vpcProps);
+      const refinedVpc = vpc;
+      securityGroups = securityGroupProps?.map((props, i) =>
+        new ec2.SecurityGroup(this, `SecurityGroup${i}`, { ...props, vpc: refinedVpc }),
+      );
+    }
+
+    this.fleet = new codebuild.Fleet(this, 'MyFleet', {
+      baseCapacity: 1,
+      computeType: codebuild.FleetComputeType.CUSTOM_INSTANCE_TYPE,
+      computeConfiguration,
+      environmentType: codebuild.EnvironmentType.LINUX_CONTAINER,
+      vpc,
+      securityGroups,
+      subnetSelection,
+    });
+
+    this.project = new codebuild.Project(this, 'MyProject', {
+      buildSpec: codebuild.BuildSpec.fromObject({
+        version: '0.2',
+        phases: {
+          build: { commands: ['echo "Nothing to do!"'] },
+        },
+      }),
+      environment: {
+        buildImage: codebuild.LinuxBuildImage.STANDARD_7_0,
+        fleet: this.fleet,
+      },
+    });
+  }
+}
+
+const app = new cdk.App();
+const stacks = configurations.map(
+  (config, index) => new FleetStack(
+    app,
+    `CustomInstanceTypeComputeFleetIntegStack${index}`,
+    config,
+  ),
+);
+
+const test = new integ.IntegTest(app, 'CustomInstanceTypeComputeFleetIntegTest', {
+  testCases: stacks,
+});
+
+const listFleets = test.assertions.awsApiCall('Codebuild', 'listFleets');
+for (const { fleet, project } of stacks) {
+  listFleets.expect(integ.ExpectedResult.objectLike({
+    fleets: integ.Match.arrayWith([fleet.fleetArn]),
+  }));
+
+  const startBuild = test.assertions.awsApiCall('Codebuild', 'startBuild', { projectName: project.projectName });
+
+  // Describe the build and wait for the status to be successful
+  test.assertions.awsApiCall('CodeBuild', 'batchGetBuilds', {
+    ids: [startBuild.getAttString('build.id')],
+  }).assertAtPath(
+    'builds.0.buildStatus',
+    integ.ExpectedResult.stringLikeRegexp('SUCCEEDED'),
+  ).waitForAssertions({
+    // After a custom instance type fleet is created, there can still be high
+    // latency on creating actual instances. Needs a long timeout, builds are
+    // pending until instances are initialized.
+    totalTimeout: cdk.Duration.minutes(10),
+    interval: cdk.Duration.seconds(30),
+  });
+}

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet-overflow-behavior.ts

@@ -0,0 +1,61 @@
+import * as cdk from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as codebuild from 'aws-cdk-lib/aws-codebuild';
+import { Construct } from 'constructs';
+
+class FleetStack extends cdk.Stack {
+  public readonly fleet: codebuild.Fleet;
+  public readonly project: codebuild.Project;
+
+  constructor(scope: Construct, id: string) {
+    super(scope, id);
+
+    this.fleet = new codebuild.Fleet(this, 'MyFleet', {
+      baseCapacity: 1,
+      computeType: codebuild.FleetComputeType.SMALL,
+      environmentType: codebuild.EnvironmentType.LINUX_CONTAINER,
+      overflowBehavior: codebuild.FleetOverflowBehavior.ON_DEMAND,
+    });
+
+    this.project = new codebuild.Project(this, 'MyProject', {
+      buildSpec: codebuild.BuildSpec.fromObject({
+        version: '0.2',
+        phases: {
+          build: { commands: ['echo "Nothing to do!"'] },
+        },
+      }),
+      environment: {
+        fleet: this.fleet,
+        buildImage: codebuild.LinuxBuildImage.STANDARD_7_0,
+      },
+    });
+  }
+}
+
+const app = new cdk.App();
+const stack= new FleetStack(
+  app,
+  'OverflowBehaviorFleetStack',
+);
+
+const test = new integ.IntegTest(app, 'OverflowBehaviorFleetInteg', {
+  testCases: [stack],
+});
+
+const listFleets = test.assertions.awsApiCall('Codebuild', 'listFleets');
+listFleets.expect(integ.ExpectedResult.objectLike({
+  fleets: integ.Match.arrayWith([stack.fleet.fleetArn]),
+}));
+
+const startBuild = test.assertions.awsApiCall('Codebuild', 'startBuild', { projectName: stack.project.projectName });
+
+// Describe the build and wait for the status to be successful
+test.assertions.awsApiCall('CodeBuild', 'batchGetBuilds', {
+  ids: [startBuild.getAttString('build.id')],
+}).assertAtPath(
+  'builds.0.buildStatus',
+  integ.ExpectedResult.stringLikeRegexp('SUCCEEDED'),
+).waitForAssertions({
+  totalTimeout: cdk.Duration.minutes(5),
+  interval: cdk.Duration.seconds(30),
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-s3-cache.ts

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as cdk from 'aws-cdk-lib';
+import * as codebuild from 'aws-cdk-lib/aws-codebuild';
+import { ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';
+
+const app = new cdk.App();
+
+const stack = new cdk.Stack(app, 'codebuild-s3-cache-stack');
+
+const bucket = new s3.Bucket(stack, 'MyBucket', {
+  removalPolicy: cdk.RemovalPolicy.DESTROY,
+  autoDeleteObjects: true,
+});
+
+const buildSpec = codebuild.BuildSpec.fromObject({
+  version: '0.2',
+  phases: {
+    build: {
+      commands: ['echo "Hello, CodeBuild!"'],
+    },
+  },
+  cache: {
+    paths: [
+      '/root/cachedir/**/*',
+    ],
+    key: 'unique-key',
+  },
+});
+
+const projectA = new codebuild.Project(stack, 'ProjectA', {
+  source: codebuild.Source.s3({
+    bucket,
+    path: 'path/to/source-a.zip',
+  }),
+  cache: codebuild.Cache.bucket(bucket, {
+    prefix: 'cache',
+    cacheNamespace: 'cache-namespace',
+  }),
+  buildSpec,
+});
+
+const projectB = new codebuild.Project(stack, 'ProjectB', {
+  source: codebuild.Source.s3({
+    bucket,
+    path: 'path/to/source-b.zip',
+  }),
+  cache: codebuild.Cache.bucket(bucket, {
+    prefix: 'cache',
+    cacheNamespace: 'cache-namespace',
+  }),
+  buildSpec,
+});
+
+const integ = new IntegTest(app, 'codebuild-s3-cache-integ', {
+  testCases: [stack],
+});
+
+[projectA, projectB].forEach((project) => {
+  integ.assertions.awsApiCall('CodeBuild', 'batchGetProjects', {
+    names: [project.projectName],
+  }).expect(ExpectedResult.objectLike({
+    projects: [{
+      cache: {
+        type: 'S3',
+        location: `${bucket.bucketName}/cache`,
+        cacheNamespace: 'cache-namespace',
+      },
+    }],
+  }));
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-windows-image.ts

@@ -25,8 +25,7 @@ new IntegTest(app, 'integ-project-windows-images', {
     new ImageTestStack(app, 'WinCore2019-1', WindowsBuildImage.WIN_SERVER_CORE_2019_BASE),
     new ImageTestStack(app, 'WinCore2019-2', WindowsBuildImage.WIN_SERVER_CORE_2019_BASE_2_0),
     new ImageTestStack(app, 'WinCore2019-3', WindowsBuildImage.WIN_SERVER_CORE_2019_BASE_3_0),
-    // Windows 2022 images are not supported for on-demand build projects
-    /* new ImageTestStack(app, 'WinCore2022-3', WindowsBuildImage.WIN_SERVER_CORE_2022_BASE_3_0), */
+    new ImageTestStack(app, 'WinCore2022-3', WindowsBuildImage.WIN_SERVER_CORE_2022_BASE_3_0),
   ],
 });
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codepipeline-actions/integ.pipeline-elastic-beanstalk-deploy.ts

@@ -2,11 +2,13 @@ import * as path from 'path';
 import * as codepipeline from 'aws-cdk-lib/aws-codepipeline';
 import * as elasticbeanstalk from 'aws-cdk-lib/aws-elasticbeanstalk';
 import * as iam from 'aws-cdk-lib/aws-iam';
+import { IManagedPolicy, ManagedPolicyReference } from 'aws-cdk-lib/aws-iam';
 import * as s3 from 'aws-cdk-lib/aws-s3';
 import * as deploy from 'aws-cdk-lib/aws-s3-deployment';
-import { App, Fn, RemovalPolicy, Stack } from 'aws-cdk-lib';
+import { App, Fn, RemovalPolicy, ResourceEnvironment, Stack, UnscopedValidationError } from 'aws-cdk-lib';
 import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as cpactions from 'aws-cdk-lib/aws-codepipeline-actions';
+import { Node } from 'constructs';
 
 /**
  * To validate that the deployment actually succeeds, perform the following actions:
@@ -43,16 +45,29 @@ const artifact = new deploy.BucketDeployment(stack, 'DeployApp', {
   extract: false,
 });
 
+function makePolicy(arn: string): IManagedPolicy {
+  return {
+    managedPolicyArn: arn,
+    get managedPolicyRef(): ManagedPolicyReference {
+      return {
+        policyArn: this.managedPolicyArn,
+      };
+    },
+    get node(): Node {
+      throw new UnscopedValidationError('The result of fromAwsManagedPolicyName can not be used in this API');
+    },
+    get env(): ResourceEnvironment {
+      throw new UnscopedValidationError('The result of fromAwsManagedPolicyName can not be used in this API');
+    },
+  };
+}
+
 const serviceRole = new iam.Role(stack, 'service-role', {
   roleName: 'codepipeline-elasticbeanstalk-action-test-serivce-role',
   assumedBy: new iam.ServicePrincipal('elasticbeanstalk.amazonaws.com'),
   managedPolicies: [
-    {
-      managedPolicyArn: 'arn:aws:iam::aws:policy/service-role/AWSElasticBeanstalkEnhancedHealth',
-    },
-    {
-      managedPolicyArn: 'arn:aws:iam::aws:policy/AWSElasticBeanstalkManagedUpdatesCustomerRolePolicy',
-    },
+    makePolicy('arn:aws:iam::aws:policy/service-role/AWSElasticBeanstalkEnhancedHealth'),
+    makePolicy('arn:aws:iam::aws:policy/AWSElasticBeanstalkManagedUpdatesCustomerRolePolicy'),
   ],
 });
 
@@ -60,15 +75,9 @@ const instanceProfileRole = new iam.Role(stack, 'instance-profile-role', {
   roleName: 'codepipeline-elasticbeanstalk-action-test-instance-profile-role',
   assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),
   managedPolicies: [
-    {
-      managedPolicyArn: 'arn:aws:iam::aws:policy/AWSElasticBeanstalkWebTier',
-    },
-    {
-      managedPolicyArn: 'arn:aws:iam::aws:policy/AWSElasticBeanstalkMulticontainerDocker',
-    },
-    {
-      managedPolicyArn: 'arn:aws:iam::aws:policy/AWSElasticBeanstalkWorkerTier',
-    },
+    makePolicy('arn:aws:iam::aws:policy/AWSElasticBeanstalkWebTier'),
+    makePolicy('arn:aws:iam::aws:policy/AWSElasticBeanstalkMulticontainerDocker'),
+    makePolicy('arn:aws:iam::aws:policy/AWSElasticBeanstalkWorkerTier'),
   ],
 });
 
@@ -85,7 +94,7 @@ const beanstalkEnv = new elasticbeanstalk.CfnEnvironment(stack, 'beanstlk-env',
   applicationName: beanstalkApp.applicationName!,
   environmentName: 'codepipeline-test-env',
   // see https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs
-  solutionStackName: '64bit Amazon Linux 2023 v6.5.2 running Node.js 20',
+  solutionStackName: '64bit Amazon Linux 2023 v6.6.2 running Node.js 20',
   optionSettings: [
     {
       namespace: 'aws:autoscaling:launchconfiguration',

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cognito/README.md

@@ -480,13 +480,13 @@ new cognito.UserPool(this, 'myuserpool', {
 
 ### Threat Protection
 
-This feature is only available if your Feature Plan is set to PLUS. 
-
 Threat Protection can be set to configure enforcement levels and automatic responses for users in password-based and custom-challenge authentication flows.
 For configuration, there are 2 options for standard authentication and custom authentication.
 These are represented with properties `standardThreatProtectionMode` and `customThreatProtectionMode`.
 See the [documentation on Threat Protection](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pool-settings-threat-protection.html)
 
+**Note**: Threat Protection requires the PLUS feature plan for new user pools. CDK allows you to configure threat protection settings at synthesis time, and CloudFormation will validate feature plan requirements at deployment time. Existing user pools that are grandfathered on LITE plans with threat protection enabled will continue to work.
+
 
 ### Emails
 
@@ -1004,6 +1004,17 @@ const userPoolClient = new cognito.UserPoolClient(this, 'UserPoolClient', {
 });
 ```
 
+[Refresh token rotation](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-using-the-refresh-token.html#using-the-refresh-token-rotation)
+can be configured to enable automatic rotation of refresh tokens. By default, refresh token rotation is disabled. When the refreshTokenRotationGracePeriod is 0, the grace period is disabled and a successful request immediately invalidates the submitted refresh token. 
+
+```ts
+const pool = new cognito.UserPool(this, 'Pool');
+pool.addClient('app-client', {
+  // ...
+  refreshTokenRotationGracePeriod: Duration.seconds(40)
+});
+```
+
 See [Adding user device and session data to API requests](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pool-settings-adaptive-authentication.html#user-pool-settings-adaptive-authentication-device-fingerprint) for more information.
 
 ### Resource Servers

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cognito/integ.user-pool-client-explicit-props.ts

@@ -43,6 +43,7 @@ const client = userpool.addClient('myuserpoolclient', {
   },
   preventUserExistenceErrors: true,
   authSessionValidity: Duration.minutes(3),
+  refreshTokenRotationGracePeriod: Duration.seconds(45),
   writeAttributes: (new ClientAttributes()).withStandardAttributes(
     {
       address: true,

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-docdb/README.md

@@ -28,6 +28,28 @@ By default, the master password will be generated and stored in AWS Secrets Mana
 
 Your cluster will be empty by default.
 
+## Serverless Clusters
+
+DocumentDB supports serverless clusters that automatically scale capacity based on your application's needs.
+To create a serverless cluster, specify the `serverlessV2ScalingConfiguration` instead of `instanceType`:
+
+```ts
+declare const vpc: ec2.Vpc;
+const cluster = new docdb.DatabaseCluster(this, 'Database', {
+  masterUser: {
+    username: 'myuser',
+  },
+  vpc,
+  serverlessV2ScalingConfiguration: {
+    minCapacity: 0.5,
+    maxCapacity: 2,
+  },
+  engineVersion: '5.0.0', // Serverless requires engine version 5.0.0 or higher
+});
+```
+
+**Note**: DocumentDB serverless requires engine version 5.0.0 or higher and is not compatible with all features. See the [AWS documentation](https://docs.aws.amazon.com/documentdb/latest/developerguide/docdb-serverless-limitations.html) for limitations.
+
 ## Connecting
 
 To control who can access the cluster, use the `.connections` attribute. DocumentDB databases have a default port, so
@@ -278,3 +300,5 @@ const cluster = new docdb.DatabaseCluster(this, 'Database', {
 ```
 
 **Note**: `StorageType.IOPT1` is supported starting with engine version 5.0.0.
+
+**Note**: For serverless clusters, storage type is managed automatically and cannot be specified.

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-docdb/integ.cluster-serverless.ts

@@ -0,0 +1,34 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as cdk from 'aws-cdk-lib';
+import * as constructs from 'constructs';
+import { DatabaseCluster } from 'aws-cdk-lib/aws-docdb';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+
+class TestStack extends cdk.Stack {
+  constructor(scope: constructs.Construct, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+    const vpc = new ec2.Vpc(this, 'VPC', { maxAzs: 2, restrictDefaultSecurityGroup: false });
+
+    new DatabaseCluster(this, 'Database', {
+      masterUser: {
+        username: 'docdb',
+      },
+      vpc,
+      serverlessV2ScalingConfiguration: {
+        minCapacity: 0.5,
+        maxCapacity: 2,
+      },
+      engineVersion: '5.0.0',
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+    });
+  }
+}
+
+const app = new cdk.App();
+
+const stack = new TestStack(app, 'aws-cdk-docdb-cluster-serverless');
+
+new IntegTest(app, 'aws-cdk-docdb-cluster-serverless-integ', {
+  testCases: [stack],
+});