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

cdk_api_mcp_server/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Kenji Kono <konoken@amazon.co.jp>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.29.0"
+__version__ = "0.31.0"

cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-lambda-python-alpha/README.md

@@ -65,22 +65,23 @@ new python.PythonFunction(this, 'MyFunction', {
 
 ## Packaging
 
-If `requirements.txt`, `Pipfile` or `poetry.lock` exists at the entry path, the construct will handle installing all required modules in a [Lambda compatible Docker container](https://gallery.ecr.aws/sam/build-python3.7) according to the `runtime` and with the Docker platform based on the target architecture of the Lambda function.
+If `requirements.txt`, `Pipfile`, `uv.lock` or `poetry.lock` exists at the entry path, the construct will handle installing all required modules in a [Lambda compatible Docker container](https://gallery.ecr.aws/sam/build-python3.13) according to the `runtime` and with the Docker platform based on the target architecture of the Lambda function.
 
 Python bundles are only recreated and published when a file in a source directory has changed.
 Therefore (and as a general best-practice), it is highly recommended to commit a lockfile with a
 list of all transitive dependencies and their exact versions. This will ensure that when any dependency version is updated, the bundle asset is recreated and uploaded.
 
-To that end, we recommend using [`pipenv`] or [`poetry`] which have lockfile support.
+To that end, we recommend using [`pipenv`], [`uv`] or [`poetry`] which have lockfile support.
 
 - [`pipenv`](https://pipenv-fork.readthedocs.io/en/latest/basics.html#example-pipfile-lock)
 - [`poetry`](https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control)
+- [`uv`](https://docs.astral.sh/uv/concepts/projects/sync/#exporting-the-lockfile)
 
 Packaging is executed using the `Packaging` class, which:
 
 1. Infers the packaging type based on the files present.
-2. If it sees a `Pipfile` or a `poetry.lock` file, it exports it to a compatible `requirements.txt` file with credentials (if they're available in the source files or in the bundling container).
-3. Installs dependencies using `pip`.
+2. If it sees a `Pipfile`, `uv.lock` or a `poetry.lock` file, it exports it to a compatible `requirements.txt` file with credentials (if they're available in the source files or in the bundling container).
+3. Installs dependencies using `pip` or `uv`.
 4. Copies the dependencies into an asset that is bundled for the Lambda package.
 
 **Lambda with a requirements.txt**
@@ -109,6 +110,18 @@ Packaging is executed using the `Packaging` class, which:
 ├── poetry.lock # your poetry lock file has to be present at the entry path
 ```
 
+**Lambda with a uv.lock**
+
+Reference: https://docs.astral.sh/uv/concepts/projects/layout/
+
+```plaintext
+.
+├── lambda_function.py # exports a function named 'handler'
+├── pyproject.toml # your poetry project definition
+├── uv.lock # your uv lock file has to be present at the entry path
+├── .python-version # this file is ignored, python version is configured via Runtime
+```
+
 **Excluding source files**
 
 You can exclude files from being copied using the optional bundling string array parameter `assetExcludes`:

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2/integ.api-dualstack.ts

@@ -4,13 +4,14 @@ import * as cdk from 'aws-cdk-lib';
 import * as apigw from 'aws-cdk-lib/aws-apigatewayv2';
 
 const app = new cdk.App();
-const stack = new cdk.Stack(app, 'DualStackWebsocketApiStack');
+const stack = new cdk.Stack(app, 'DualStackHttpApiStack');
 
-new apigw.WebSocketApi(stack, 'WebSocketApi', {
+new apigw.HttpApi(stack, 'HttpApi', {
+  routeSelectionExpression: true,
   ipAddressType: apigw.IpAddressType.DUAL_STACK,
 });
 
-new IntegTest(app, 'DualStackWebsocketApiInteg', {
+new IntegTest(app, 'DualStackHttpApiInteg', {
   testCases: [stack],
 });
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2/integ.api.ts

@@ -6,9 +6,11 @@ import * as apigw from 'aws-cdk-lib/aws-apigatewayv2';
 const app = new cdk.App();
 const stack = new cdk.Stack(app, 'aws-cdk-aws-apigatewayv2');
 
-new apigw.WebSocketApi(stack, 'WebSocketApi');
+new apigw.HttpApi(stack, 'HttpApi', {
+  routeSelectionExpression: true,
+});
 
-new IntegTest(app, 'web-socket-api', {
+new IntegTest(app, 'http-api', {
   testCases: [stack],
 });
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2/integ.stage.ts

@@ -1,20 +1,33 @@
 #!/usr/bin/env node
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 import * as cdk from 'aws-cdk-lib';
-import * as apigw from 'aws-cdk-lib/aws-apigatewayv2';
+import * as apigwv2 from 'aws-cdk-lib/aws-apigatewayv2';
+import * as apigw from 'aws-cdk-lib/aws-apigateway';
+import * as logs from 'aws-cdk-lib/aws-logs';
 
 const app = new cdk.App();
-const stack = new cdk.Stack(app, 'aws-cdk-aws-apigatewayv2-websocket-stage');
+const stack = new cdk.Stack(app, 'aws-cdk-aws-apigatewayv2-http-stage');
 
-const webSocketApi = new apigw.WebSocketApi(stack, 'WebSocketApi');
-new apigw.WebSocketStage(stack, 'WebSocketStage', {
-  webSocketApi,
-  stageName: 'dev',
+const testLogGroup = new logs.LogGroup(stack, 'MyLogGroup');
+
+const httpApi = new apigwv2.HttpApi(stack, 'HttpApi', { createDefaultStage: false });
+new apigwv2.HttpStage(stack, 'HttpStageWithProperties', {
+  httpApi,
   throttle: {
     rateLimit: 1000,
     burstLimit: 1000,
   },
   detailedMetricsEnabled: true,
   description: 'My Stage',
+  accessLogSettings: {
+    destination: new apigwv2.LogGroupLogDestination(testLogGroup),
+    format: apigw.AccessLogFormat.custom(JSON.stringify({
+      extendedRequestId: apigw.AccessLogField.contextExtendedRequestId(),
+      requestTime: apigw.AccessLogField.contextRequestTime(),
+    })),
+  },
 });
 
-app.synth();
+new IntegTest(app, 'aws-cdk-aws-apigatewayv2-http-stage-test', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2-authorizers/integ.iam.ts

@@ -1,53 +1,46 @@
 import * as apigatewayv2 from 'aws-cdk-lib/aws-apigatewayv2';
-import { WebSocketLambdaIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';
 import * as iam from 'aws-cdk-lib/aws-iam';
-import { Code, Function, Runtime } from 'aws-cdk-lib/aws-lambda';
 import * as cdk from 'aws-cdk-lib';
-import { Stack } from 'aws-cdk-lib';
-import * as integ from '@aws-cdk/integ-tests-alpha';
-import { WebSocketIamAuthorizer } from 'aws-cdk-lib/aws-apigatewayv2-authorizers';
+import { HttpIamAuthorizer } from 'aws-cdk-lib/aws-apigatewayv2-authorizers';
 
-const app = new cdk.App({
-  postCliContext: {
-    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
-  },
-});
+class ExampleComIntegration extends apigatewayv2.HttpRouteIntegration {
+  public bind(): apigatewayv2.HttpRouteIntegrationConfig {
+    return {
+      type: apigatewayv2.HttpIntegrationType.HTTP_PROXY,
+      payloadFormatVersion: apigatewayv2.PayloadFormatVersion.VERSION_1_0,
+      method: apigatewayv2.HttpMethod.GET,
+      uri: 'https://www.example.com/',
+    };
+  }
+}
+
+const app = new cdk.App();
 const stack = new cdk.Stack(app, 'IntegApiGatewayV2Iam');
 const user = new iam.User(stack, 'User');
 const userAccessKey = new iam.AccessKey(stack, 'UserAccess', {
   user,
 });
 
-const handler = new Function(stack, 'auth-function', {
-  runtime: Runtime.NODEJS_18_X,
-  code: Code.fromInline('exports.handler = () => {return true}'),
-  handler: 'index.handler',
+const httpApi = new apigatewayv2.HttpApi(stack, 'HttpApi', {
+  defaultAuthorizer: new HttpIamAuthorizer(),
 });
 
-const webSocketApi = new apigatewayv2.WebSocketApi(stack, 'WebSocketApi', {
-  connectRouteOptions: {
-    integration: new WebSocketLambdaIntegration('WebSocketLambdaIntegration', handler),
-    authorizer: new WebSocketIamAuthorizer(),
-  },
+const [fooRoute] = httpApi.addRoutes({
+  integration: new ExampleComIntegration('examplecom'),
+  path: '/foo',
 });
 
-const arn = Stack.of(stack).formatArn({
-  service: 'execute-api',
-  resource: webSocketApi.apiId,
+fooRoute.grantInvoke(user);
+
+const [booksRoute] = httpApi.addRoutes({
+  integration: new ExampleComIntegration('examplecom'),
+  path: '/books/{book}',
 });
 
-user.attachInlinePolicy(new iam.Policy(stack, 'AllowInvoke', {
-  statements: [
-    new iam.PolicyStatement({
-      actions: ['execute-api:Invoke'],
-      effect: iam.Effect.ALLOW,
-      resources: [arn],
-    }),
-  ],
-}));
+booksRoute.grantInvoke(user);
 
-new integ.IntegTest(app, 'ApiGatewayV2WebSocketIamTest', {
-  testCases: [stack],
+new cdk.CfnOutput(stack, 'API', {
+  value: httpApi.url!,
 });
 
 new cdk.CfnOutput(stack, 'TESTACCESSKEYID', {
@@ -62,4 +55,15 @@ new cdk.CfnOutput(stack, 'TESTREGION', {
   value: stack.region,
 });
 
-app.synth();
+/*
+ * Stack verification steps:
+ * * Get cURL version 7.75.0 or later so you can use the --aws-sigv4 option
+ * * Curl <url>/foo without sigv4 and expect a 403
+ * * Curl <url>/books/something without sigv4 and expect a 403
+ * * Curl <url>/foo with sigv4 from the authorized user and expect 200
+ * * Curl <url>/books/something with sigv4 from the authorized user and expect 200
+ *
+ * Reference:
+ * * Using cURL 7.75.0 or later via the official docker image: docker run --rm curlimages/curl -s -o/dev/null -w"%{http_code}" <url>
+ * * Args to enable sigv4 with authorized credentials: --user "$TESTACCESSKEYID:$TESTSECRETACCESSKEY" --aws-sigv4 "aws:amz:$TESTREGION:execute-api"
+ */

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2-integrations/integ.sqs.ts

@@ -1,72 +1,85 @@
-import { HttpMethod, PassthroughBehavior, WebSocketApi, WebSocketStage } from 'aws-cdk-lib/aws-apigatewayv2';
+import * as apigwv2 from 'aws-cdk-lib/aws-apigatewayv2';
 import * as sqs from 'aws-cdk-lib/aws-sqs';
-import * as iam from 'aws-cdk-lib/aws-iam';
-import { App, Stack, Aws } from 'aws-cdk-lib';
-import { WebSocketAwsIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';
-import { IntegTest } from '@aws-cdk/integ-tests-alpha';
-
-/*
- * Stack verification steps:
- * 1. Verify manually that the integration has type "AWS"
- */
+import { App, Stack } from 'aws-cdk-lib';
+import { HttpSqsIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';
+import * as integ from '@aws-cdk/integ-tests-alpha';
 
 const app = new App();
-const stack = new Stack(app, 'integ-aws-websocket-sqs-integration');
+const stack = new Stack(app, 'sqs-integration');
 
-const sqsMessageQueue = new sqs.Queue(stack, 'MessageSQSQueue', {
-  fifo: true,
-  queueName: 'MessageSQSQueue.fifo',
-});
+const queue = new sqs.Queue(stack, 'Queue');
 
-// API Gateway WebSocket API
-const webSocketApi = new WebSocketApi(stack, 'webSocketApi', {
-  description: 'Send websocket data to SQS which is then processed by a Lambda 2',
-  routeSelectionExpression: '$request.body.action',
+const httpApi = new apigwv2.HttpApi(stack, 'Api');
+httpApi.addRoutes({
+  path: '/default',
+  methods: [apigwv2.HttpMethod.POST],
+  integration: new HttpSqsIntegration('defaultIntegration', {
+    queue,
+  }),
 });
-
-// Optionally, create a WebSocket stage
-new WebSocketStage(stack, 'DevStage', {
-  webSocketApi: webSocketApi,
-  stageName: 'dev',
-  autoDeploy: true,
+httpApi.addRoutes({
+  path: '/send-message',
+  methods: [apigwv2.HttpMethod.POST],
+  integration: new HttpSqsIntegration('sendMessageIntegration', {
+    queue,
+    subtype: apigwv2.HttpIntegrationSubtype.SQS_SEND_MESSAGE,
+  }),
 });
-
-// IAM Role for API Gateway
-const webSocketApiRole = new iam.Role(stack, 'webSocketApiRole', {
-  assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com'),
+httpApi.addRoutes({
+  path: '/receive-message',
+  methods: [apigwv2.HttpMethod.POST],
+  integration: new HttpSqsIntegration('receiveMessageIntegration', {
+    queue,
+    subtype: apigwv2.HttpIntegrationSubtype.SQS_RECEIVE_MESSAGE,
+  }),
 });
-
-webSocketApiRole.addToPolicy(
-  new iam.PolicyStatement({
-    actions: ['sqs:SendMessage'],
-    effect: iam.Effect.ALLOW,
-    resources: [sqsMessageQueue.queueArn],
+httpApi.addRoutes({
+  path: '/delete-message',
+  methods: [apigwv2.HttpMethod.POST],
+  integration: new HttpSqsIntegration('deleteMessageIntegration', {
+    queue,
+    subtype: apigwv2.HttpIntegrationSubtype.SQS_DELETE_MESSAGE,
   }),
-);
-
-webSocketApi.addRoute('$default', {
-  integration: new WebSocketAwsIntegration('SQSSendMessage', {
-    integrationUri: `arn:aws:apigateway:${Aws.REGION}:sqs:path/${Aws.ACCOUNT_ID}/${sqsMessageQueue.queueName}`,
-    integrationMethod: HttpMethod.POST,
-    credentialsRole: webSocketApiRole,
-    passthroughBehavior: PassthroughBehavior.NEVER,
-    templateSelectionExpression: '\\$default',
-    requestTemplates: {
-      $default: 'Action=SendMessage&MessageGroupId=$input.path(\'$.MessageGroupId\')&MessageDeduplicationId=$context.requestId&MessageAttribute.1.Name=connectionId&MessageAttribute.1.Value.StringValue=$context.connectionId&MessageAttribute.1.Value.DataType=String&MessageAttribute.2.Name=requestId&MessageAttribute.2.Value.StringValue=$context.requestId&MessageAttribute.2.Value.DataType=String&MessageBody=$input.json(\'$\')',
-    },
-    requestParameters: {
-      'integration.request.header.Content-Type': '\'application/x-www-form-urlencoded\'',
-    },
+});
+httpApi.addRoutes({
+  path: '/purge-queue',
+  methods: [apigwv2.HttpMethod.POST],
+  integration: new HttpSqsIntegration('purgeQueueIntegration', {
+    queue,
+    subtype: apigwv2.HttpIntegrationSubtype.SQS_PURGE_QUEUE,
   }),
 });
 
-new IntegTest(app, 'apigatewayv2-aws-integration-sqs-integ-test', {
+const integTest = new integ.IntegTest(app, 'SqsIntegrationIntegTest', {
   testCases: [stack],
-  cdkCommandOptions: {
-    deploy: {
-      args: {
-        rollback: true,
-      },
-    },
-  },
 });
+
+const defaultAssertion = integTest.assertions.httpApiCall(
+  `${httpApi.apiEndpoint}/default`, {
+    body: JSON.stringify({ MessageBody: 'Hello World!' }),
+    method: 'POST',
+  },
+);
+defaultAssertion.expect(integ.ExpectedResult.objectLike({ status: 200, statusText: 'OK' }));
+
+const sendMessageAssertion = integTest.assertions.httpApiCall(
+  `${httpApi.apiEndpoint}/send-message`, {
+    body: JSON.stringify({ MessageBody: 'Hello World!' }),
+    method: 'POST',
+  },
+);
+sendMessageAssertion.expect(integ.ExpectedResult.objectLike({ status: 200, statusText: 'OK' }));
+
+const receiveMessageAssertion = integTest.assertions.httpApiCall(
+  `${httpApi.apiEndpoint}/receive-message`, {
+    method: 'POST',
+  },
+);
+receiveMessageAssertion.expect(integ.ExpectedResult.objectLike({ status: 200, statusText: 'OK' }));
+
+const purgeQueueAssertion = integTest.assertions.httpApiCall(
+  `${httpApi.apiEndpoint}/purge-queue`, {
+    method: 'POST',
+  },
+);
+purgeQueueAssertion.expect(integ.ExpectedResult.objectLike({ status: 200, statusText: 'OK' }));

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

@@ -84,6 +84,7 @@ plan.addSelection('Selection', {
 To add rules to a plan, use `addRule()`:
 
 ```ts
+import { TimeZone } from 'aws-cdk-lib';
 declare const plan: backup.BackupPlan;
 plan.addRule(new backup.BackupPlanRule({
   completionWindow: Duration.hours(2),
@@ -93,6 +94,7 @@ plan.addRule(new backup.BackupPlanRule({
     hour: '3',
     minute: '30',
   }),
+  scheduleExpressionTimezone: TimeZone.ETC_UTC,
   moveToColdStorageAfter: Duration.days(30),
 }));
 ```

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-backup/integ.backup.ts

@@ -1,6 +1,7 @@
 import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
 import * as efs from 'aws-cdk-lib/aws-efs';
-import { App, Duration, RemovalPolicy, Stack, StackProps, CfnParameter } from 'aws-cdk-lib';
+import * as events from 'aws-cdk-lib/aws-events';
+import { App, Duration, RemovalPolicy, Stack, StackProps, CfnParameter, TimeZone } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
 import * as backup from 'aws-cdk-lib/aws-backup';
 
@@ -61,6 +62,16 @@ class TestStack extends Stack {
         stage: 'prod',
       },
     }));
+
+    plan.addRule(new backup.BackupPlanRule({
+      backupVault: vault,
+      scheduleExpression: events.Schedule.cron({
+        day: '15',
+        hour: '3',
+        minute: '30',
+      }),
+      scheduleExpressionTimezone: TimeZone.ETC_UTC,
+    }));
   }
 }
 

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

@@ -959,3 +959,35 @@ const dashboard = new cw.Dashboard(this, 'Dash', {
 ```
 
 You can add a variable after object instantiation with the method `dashboard.addVariable()`.
+
+### Cross-Account Visibility
+
+Both Log and Metric Widget objects support cross-account visibility by allowing you to specify the AWS Account ID that the data (logs or metrics) originates from.
+
+**Prerequisites:**
+1. The monitoring account must be set up as a monitoring account
+2. The source account must grant permissions to the monitoring account
+3. Appropriate IAM roles and policies must be configured
+
+For detailed setup instructions, see [Cross-Account Cross-Region CloudWatch Console](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html).
+
+
+To use this feature, you can set the `accountId` property on `LogQueryWidget`, `GraphWidget`, `AlarmWidget`, `SingleValueWidget`, and `GaugeWidget` constructs:
+
+```ts
+declare const dashboard: cloudwatch.Dashboard;
+
+dashboard.addWidgets(new cloudwatch.GraphWidget({
+  // ...
+  accountId: '123456789012',
+}));
+
+dashboard.addWidgets(new cloudwatch.LogQueryWidget({
+  logGroupNames: ['my-log-group'],
+  // ...
+  accountId: '123456789012',
+  queryLines: [
+    'fields @message',
+  ],
+}));
+```

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudwatch/integ.alarm-and-dashboard.ts

@@ -92,6 +92,7 @@ dashboard.addWidgets(new cloudwatch.LogQueryWidget({
   logGroupNames: ['my-log-group'],
   queryString: `fields @message
                 | filter @message like /Error/`,
+  accountId: '123456789012',
 }));
 dashboard.addWidgets(new cloudwatch.SingleValueWidget({
   title: 'Sent message size',

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudwatch/integ.math-alarm-and-dashboard.ts

@@ -51,6 +51,7 @@ const dashboard = new cloudwatch.Dashboard(stack, 'Dash', {
 dashboard.addWidgets(new cloudwatch.AlarmWidget({
   title: 'Total messages in queue',
   alarm,
+  accountId: '123456789012',
 }));
 
 dashboard.addWidgets(new cloudwatch.GraphWidget({
@@ -58,18 +59,21 @@ dashboard.addWidgets(new cloudwatch.GraphWidget({
   left: [sumExpression],
   right: [metricA, metricB],
   leftAnnotations: [alarm.toAnnotation()],
+  accountId: '123456789012',
 }));
 
 dashboard.addWidgets(new cloudwatch.GraphWidget({
   title: 'Percentage of messages in each queue as pie chart',
   left: [metricA, metricB],
   view: cloudwatch.GraphWidgetView.PIE,
+  accountId: '123456789012',
   setPeriodToTimeRange: true,
 }));
 
 dashboard.addWidgets(new cloudwatch.SingleValueWidget({
   title: 'Current total messages in queue',
   metrics: [sumExpression],
+  accountId: '123456789012',
 }));
 
 new IntegTest(app, 'cdk-integ-math-alarm-and-dashboard', {

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codedeploy/integ.deployment-config.ts

@@ -2,28 +2,17 @@ import * as cdk from 'aws-cdk-lib';
 import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as codedeploy from 'aws-cdk-lib/aws-codedeploy';
 
-const app = new cdk.App({
-  postCliContext: {
-    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
-  },
-});
-const stack = new cdk.Stack(app, 'aws-cdk-codedeploy-lambda-config');
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'aws-cdk-codedeploy-ecs-config');
 
-new codedeploy.LambdaDeploymentConfig(stack, 'LinearConfig', {
+new codedeploy.EcsDeploymentConfig(stack, 'LinearConfig', {
   trafficRouting: codedeploy.TrafficRouting.timeBasedLinear({
     interval: cdk.Duration.minutes(1),
     percentage: 5,
   }),
 });
 
-new codedeploy.CustomLambdaDeploymentConfig(stack, 'CustomConfig', {
-  interval: cdk.Duration.minutes(1),
-  percentage: 5,
-  type: cdk.aws_codedeploy.CustomLambdaDeploymentConfigType.LINEAR,
-  deploymentConfigName: 'hello',
-});
-
-new integ.IntegTest(app, 'LambdaDeploymentConfigTest', {
+new integ.IntegTest(app, 'EcsDeploymentConfigTest', {
   testCases: [stack],
 });