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-stepfunctions-tasks/integ.evaluate-expression-arm64.ts

@@ -0,0 +1,27 @@
+import { App, Stack } from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as cdk from 'aws-cdk-lib';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+
+const app = new App();
+const stack = new Stack(app, 'aws-cdk-sfn-evaluate-expression-arm64-integ');
+
+const evaluateExpression = new tasks.EvaluateExpression(stack, 'EvaluateExpression', {
+  expression: '$.a + $.b',
+  architecture: lambda.Architecture.ARM_64,
+});
+
+const sm = new sfn.StateMachine(stack, 'StateMachine', {
+  definitionBody: sfn.DefinitionBody.fromChainable(evaluateExpression),
+  timeout: cdk.Duration.seconds(30),
+});
+
+new cdk.CfnOutput(stack, 'stateMachineArn', {
+  value: sm.stateMachineArn,
+});
+
+new integ.IntegTest(app, 'EvaluateExpressionArm64Test', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.evaluate-expression-default.ts

@@ -0,0 +1,25 @@
+import { App, Stack } from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as cdk from 'aws-cdk-lib';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+
+const app = new App();
+const stack = new Stack(app, 'aws-cdk-sfn-evaluate-expression-default-integ');
+
+const evaluateExpression = new tasks.EvaluateExpression(stack, 'EvaluateExpression', {
+  expression: '$.a + $.b',
+});
+
+const sm = new sfn.StateMachine(stack, 'StateMachine', {
+  definitionBody: sfn.DefinitionBody.fromChainable(evaluateExpression),
+  timeout: cdk.Duration.seconds(30),
+});
+
+new cdk.CfnOutput(stack, 'stateMachineArn', {
+  value: sm.stateMachineArn,
+});
+
+new integ.IntegTest(app, 'EvaluateExpressionDefaultTest', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.evaluate-expression-mixed-arch.ts

@@ -0,0 +1,35 @@
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as cdk from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'aws-cdk-sfn-evaluate-expression-mixed-arch-integ');
+
+const evalTaskArm = new tasks.EvaluateExpression(stack, 'EvalExpressionArm', {
+  expression: '$.a + $.b',
+  runtime: lambda.Runtime.NODEJS_20_X,
+  architecture: lambda.Architecture.ARM_64,
+});
+
+const evalTaskX86 = new tasks.EvaluateExpression(stack, 'EvalExpressionX86', {
+  expression: '$.a * $.b',
+  runtime: lambda.Runtime.NODEJS_20_X,
+  architecture: lambda.Architecture.X86_64,
+});
+
+const definition = new sfn.Pass(stack, 'Start', {
+  result: sfn.Result.fromObject({ a: 3, b: 4 }),
+}).next(new sfn.Parallel(stack, 'ParallelEval')
+  .branch(evalTaskArm)
+  .branch(evalTaskX86),
+);
+
+new sfn.StateMachine(stack, 'StateMachine', {
+  definitionBody: sfn.DefinitionBody.fromChainable(definition),
+});
+
+new integ.IntegTest(app, 'EvaluateExpressionMixedArchTest', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.evaluate-expression-nodejs22.ts

@@ -0,0 +1,27 @@
+import { App, Stack, StackProps } from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import { Construct } from 'constructs';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+
+class TestStack extends Stack {
+  constructor(scope: Construct, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    const task = new tasks.EvaluateExpression(this, 'Task', {
+      expression: '$.a + $.b',
+      runtime: lambda.Runtime.NODEJS_22_X,
+    });
+
+    new sfn.StateMachine(this, 'StateMachine', {
+      definition: task,
+    });
+  }
+}
+
+const app = new App();
+
+new integ.IntegTest(app, 'EvaluateExpressionNodejs22', {
+  testCases: [new TestStack(app, 'evaluate-expression-nodejs22')],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.evaluate-expression-x86.ts

@@ -0,0 +1,27 @@
+import { App, Stack } from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as cdk from 'aws-cdk-lib';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+
+const app = new App();
+const stack = new Stack(app, 'aws-cdk-sfn-evaluate-expression-x86-integ');
+
+const evaluateExpression = new tasks.EvaluateExpression(stack, 'EvaluateExpression', {
+  expression: '$.a + $.b',
+  architecture: lambda.Architecture.X86_64,
+});
+
+const sm = new sfn.StateMachine(stack, 'StateMachine', {
+  definitionBody: sfn.DefinitionBody.fromChainable(evaluateExpression),
+  timeout: cdk.Duration.seconds(30),
+});
+
+new cdk.CfnOutput(stack, 'stateMachineArn', {
+  value: sm.stateMachineArn,
+});
+
+new integ.IntegTest(app, 'EvaluateExpressionX86Test', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.invoke-json-path.ts

@@ -0,0 +1,102 @@
+/// !cdk-integ aws-stepfunctions-tasks-http-invoke-json-path-integ
+
+import * as path from 'path';
+import { IntegTest, ExpectedResult } from '@aws-cdk/integ-tests-alpha';
+import * as cdk from 'aws-cdk-lib';
+import * as apigateway from 'aws-cdk-lib/aws-apigateway';
+import * as events from 'aws-cdk-lib/aws-events';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as lambda from 'aws-cdk-lib/aws-lambda-nodejs';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+import { password, username } from './my-lambda-handler';
+
+/*
+ * Creates an API Gateway instance with a GET method and mock integration,
+ * secured with basic auth. It then creates a matching Connection and uses it
+ * in a state machine with a task state to invoke the endpoint.
+ *
+ * Stack verification steps :
+ * * aws stepfunctions start-execution --state-machine-arn <deployed state machine arn> : should return execution arn
+ * * aws stepfunctions describe-execution --execution-arn <execution-arn generated before> : should return status as SUCCEEDED
+ */
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'aws-stepfunctions-tasks-http-invoke-json-path-integ');
+
+const authorizerHandler = new lambda.NodejsFunction(stack, 'AuthorizerHandler', {
+  entry: path.resolve(__dirname, 'my-lambda-handler', 'index.ts'),
+  handler: 'handler',
+});
+
+const authorizer = new apigateway.TokenAuthorizer(stack, 'Authorizer', {
+  handler: authorizerHandler,
+  identitySource: 'method.request.header.Authorization',
+  resultsCacheTtl: cdk.Duration.seconds(0),
+});
+
+const api = new apigateway.RestApi(stack, 'IntegRestApi');
+
+api.root.addResource('test-json-path').addMethod(
+  'GET',
+  new apigateway.MockIntegration({
+    integrationResponses: [
+      {
+        statusCode: '200',
+        responseTemplates: {
+          'application/json': JSON.stringify({ message: 'Hello, tester!' }),
+        },
+      },
+    ],
+    passthroughBehavior: apigateway.PassthroughBehavior.NEVER,
+    requestTemplates: {
+      'application/json': '{ "statusCode": 200 }',
+    },
+  }),
+  {
+    authorizer,
+    methodResponses: [
+      {
+        statusCode: '200',
+      },
+    ],
+  },
+);
+
+const connection = new events.Connection(stack, 'Connection', {
+  authorization: events.Authorization.basic(username, cdk.SecretValue.unsafePlainText(password)),
+});
+
+const httpInvokeTask = new tasks.HttpInvoke(stack, 'Invoke HTTP Endpoint', {
+  apiRoot: api.urlForPath('/'),
+  apiEndpoint: sfn.TaskInput.fromJsonPathAt('$.endpointPath'),
+  connection,
+  method: sfn.TaskInput.fromText('GET'),
+});
+
+const sm = new sfn.StateMachine(stack, 'StateMachine', {
+  definition: httpInvokeTask,
+  timeout: cdk.Duration.seconds(30),
+});
+
+const testCase = new IntegTest(app, 'HttpInvokeTest', {
+  testCases: [stack],
+});
+
+// Start an execution
+const start = testCase.assertions.awsApiCall('StepFunctions', 'startExecution', {
+  stateMachineArn: sm.stateMachineArn,
+  input: JSON.stringify({
+    endpointPath: 'test-json-path',
+  }),
+});
+
+// describe the results of the execution
+const describe = testCase.assertions.awsApiCall('StepFunctions', 'describeExecution', {
+  executionArn: start.getAttString('executionArn'),
+});
+
+// assert the results
+describe.expect(ExpectedResult.objectLike({
+  status: 'SUCCEEDED',
+}));
+
+app.synth();

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

@@ -87,6 +87,28 @@ const schedule = synthetics.Schedule.cron({
 
 If you want the canary to run just once upon deployment, you can use `Schedule.once()`.
 
+### Automatic Retries
+
+You can configure the canary to automatically retry failed runs by using the `maxRetries` property.
+
+This is only supported on the following runtimes or newer: `Runtime.SYNTHETICS_NODEJS_PUPPETEER_10_0`, `Runtime.SYNTHETICS_NODEJS_PLAYWRIGHT_2_0`, `Runtime.SYNTHETICS_PYTHON_SELENIUM_5_1`.
+
+Max retries can be set between 0 and 2. Canaries which time out after 10 minutes are automatically limited to one retry.
+
+For more information, see [Configuring your canary to retry automatically](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Canaries_autoretry.html).
+
+```ts
+const canary = new synthetics.Canary(this, 'MyCanary', {
+  schedule: synthetics.Schedule.rate(Duration.minutes(5)), 
+  test: synthetics.Test.custom({
+    handler: 'canary.handler',
+    code: synthetics.Code.fromAsset(path.join(__dirname, 'canaries')),
+  }),
+  runtime: synthetics.Runtime.SYNTHETICS_PYTHON_SELENIUM_5_1,
+  maxRetries: 2, // The canary run will retry up to 2 times on a failure
+});
+```
+
 ### Active Tracing
 
 You can choose to enable active AWS X-Ray tracing on canaries that use the `syn-nodejs-2.0` or later runtime by setting `activeTracing` to `true`.
@@ -143,6 +165,33 @@ const canary = new synthetics.Canary(this, 'MyCanary', {
 });
 ```
 
+### Browser Type Configuration
+
+You can configure which browsers your canary uses for testing by specifying the `browserConfigs` property. This allows you to test your application across different browsers to ensure compatibility.
+
+Available browser types:
+- `BrowserType.CHROME` - Google Chrome browser
+- `BrowserType.FIREFOX` - Mozilla Firefox browser
+
+You can specify up to 2 browser configurations. When multiple browsers are configured, the canary will run tests on each browser sequentially.
+
+```ts
+const canary = new synthetics.Canary(this, 'MyCanary', {
+  schedule: synthetics.Schedule.rate(Duration.minutes(5)),
+  test: synthetics.Test.custom({
+    code: synthetics.Code.fromAsset(path.join(__dirname, 'canary')),
+    handler: 'index.handler',
+  }),
+  runtime: synthetics.Runtime.SYNTHETICS_NODEJS_PUPPETEER_9_1,
+  browserConfigs: [
+    synthetics.BrowserType.CHROME,
+    synthetics.BrowserType.FIREFOX,
+  ],
+});
+```
+
+> **Note:** Firefox support is available for Node.js runtimes (Puppeteer and Playwright) but not for Python Selenium runtimes. When using Firefox, ensure your runtime version supports it.
+
 ### Deleting underlying resources on canary deletion
 
 When you delete a lambda, the following underlying resources are isolated in your AWS account:
@@ -218,7 +267,7 @@ new synthetics.Canary(this, 'Bucket Canary', {
 ```
 
 > **Note:** Synthetics have a specified folder structure for canaries.
-> For Node with puppeteer scripts supplied via `code.fromAsset()` or `code.fromBucket()`, the canary resource requires the following folder structure:
+> For Node with puppeteer scripts supplied via `code.fromAsset()` or `code.fromBucket()`, the canary resource requires the following folder structure for runtime versions older than `syn-nodejs-puppeteer-11.0`:
 >
 > ```plaintext
 > canary/
@@ -227,6 +276,22 @@ new synthetics.Canary(this, 'Bucket Canary', {
 >         ├── <filename>.js
 > ```
 >
+> For puppeteer based runtime versions newer than or equal to `syn-nodejs-puppeteer-11.0`, `nodjs/node_modules` is not necessary but supported. 
+>
+> Both
+> ```plaintext
+> canary/
+> ├── nodejs/
+>    ├── node_modules/
+>         ├── <filename>.js
+> ```
+> And 
+> ```plaintext
+> canary/
+>  ├── <filename>.js
+> ```
+> are supported.
+>
 > For Node with playwright scripts supplied via `code.fromAsset()` or `code.fromBucket()`, the canary resource requires the following folder structure:
 >
 > ```plaintext
@@ -368,3 +433,21 @@ const canary = new synthetics.Canary(this, 'MyCanary', {
 });
 ```
 
+### Tag replication
+
+You can configure a canary to replicate its tags to the underlying Lambda function. This is useful when you want the same tags that are applied to the canary to also be applied to the Lambda function that the canary uses.
+
+```ts
+const canary = new synthetics.Canary(this, 'MyCanary', {
+  schedule: synthetics.Schedule.rate(Duration.minutes(5)),
+  test: synthetics.Test.custom({
+    code: synthetics.Code.fromAsset(path.join(__dirname, 'canary')),
+    handler: 'index.handler',
+  }),
+  runtime: synthetics.Runtime.SYNTHETICS_NODEJS_PUPPETEER_7_0,
+  resourcesToReplicateTags: [synthetics.ResourceToReplicateTags.LAMBDA_FUNCTION],
+});
+```
+
+When you specify `ResourceToReplicateTags.LAMBDA_FUNCTION` in the `resourcesToReplicateTags` property, CloudWatch Synthetics will keep the tags of the canary and the Lambda function synchronized. Any future changes you make to the canary's tags will also be applied to the function.
+

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-synthetics/integ.canary-browser-type.ts

@@ -0,0 +1,35 @@
+import * as path from 'node:path';
+import { App, Duration, Size, Stack, StackProps } from 'aws-cdk-lib/core';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { Construct } from 'constructs';
+import * as synthetics from 'aws-cdk-lib/aws-synthetics';
+
+class TestStack extends Stack {
+  public canary: synthetics.Canary;
+
+  constructor(scope: Construct, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    this.canary = new synthetics.Canary(this, 'BrowserTypeCanary', {
+      runtime: synthetics.Runtime.SYNTHETICS_NODEJS_PUPPETEER_11_0,
+      test: synthetics.Test.custom({
+        handler: 'canary.handler',
+        code: synthetics.Code.fromAsset(path.join(__dirname, 'canaries')),
+      }),
+      memory: Size.mebibytes(2048),
+      timeout: Duration.minutes(4),
+      maxRetries: 2,
+      browserConfigs: [
+        synthetics.BrowserType.CHROME,
+        synthetics.BrowserType.FIREFOX,
+      ],
+    });
+  }
+}
+
+const app = new App();
+const testStack = new TestStack(app, 'SyntheticsCanaryBrowserTypeStack');
+
+new IntegTest(app, 'SyntheticsCanaryBrowserType', {
+  testCases: [testStack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-synthetics/integ.canary-resources-to-replicate-tags.ts

@@ -0,0 +1,36 @@
+import * as path from 'node:path';
+import { App, Duration, Size, Stack, StackProps, Tags } from 'aws-cdk-lib/core';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { Construct } from 'constructs';
+import * as synthetics from 'aws-cdk-lib/aws-synthetics';
+
+class TestStack extends Stack {
+  public canary: synthetics.Canary;
+
+  constructor(scope: Construct, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    this.canary = new synthetics.Canary(this, 'TagReplicationCanary', {
+      canaryName: 'tag-replication',
+      runtime: synthetics.Runtime.SYNTHETICS_NODEJS_PUPPETEER_7_0,
+      test: synthetics.Test.custom({
+        handler: 'canary.handler',
+        code: synthetics.Code.fromAsset(path.join(__dirname, 'canaries')),
+      }),
+      memory: Size.mebibytes(1024),
+      timeout: Duration.minutes(3),
+      resourcesToReplicateTags: [synthetics.ResourceToReplicateTags.LAMBDA_FUNCTION],
+    });
+
+    Tags.of(this.canary).add('Environment', 'test');
+    Tags.of(this.canary).add('Owner', 'cdk-team');
+    Tags.of(this.canary).add('Project', 'synthetics-tag-replication');
+  }
+}
+
+const app = new App();
+const testStack = new TestStack(app, 'SyntheticsCanaryResourcesToReplicateTagsStack');
+
+new IntegTest(app, 'SyntheticsCanaryResourcesToReplicateTags', {
+  testCases: [testStack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-synthetics/integ.canary-retry.ts

@@ -0,0 +1,32 @@
+import * as path from 'node:path';
+import { App, Duration, Size, Stack, StackProps } from 'aws-cdk-lib/core';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { Construct } from 'constructs';
+import * as synthetics from 'aws-cdk-lib/aws-synthetics';
+
+class TestStack extends Stack {
+  public canary: synthetics.Canary;
+
+  constructor(scope: Construct, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    this.canary = new synthetics.Canary(this, 'RetryCanary', {
+      canaryName: 'retry',
+      runtime: synthetics.Runtime.SYNTHETICS_PYTHON_SELENIUM_5_1,
+      test: synthetics.Test.custom({
+        handler: 'canary.handler',
+        code: synthetics.Code.fromAsset(path.join(__dirname, 'canaries')),
+      }),
+      memory: Size.mebibytes(2048),
+      timeout: Duration.minutes(4),
+      maxRetries: 2,
+    });
+  }
+}
+
+const app = new App();
+const testStack = new TestStack(app, 'SyntheticsCanaryRetryStack');
+
+new IntegTest(app, 'SyntheticsCanaryRetry', {
+  testCases: [testStack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-synthetics/integ.canary-runtime-validation.ts

@@ -0,0 +1,43 @@
+import * as path from 'node:path';
+import { App, Duration, Size, Stack, StackProps } from 'aws-cdk-lib/core';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { Construct } from 'constructs';
+import * as synthetics from 'aws-cdk-lib/aws-synthetics';
+
+class TestStack extends Stack {
+  public puppeteer11RootCanary: synthetics.Canary;
+  public puppeteer11NodeModulesCanary: synthetics.Canary;
+
+  constructor(scope: Construct, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    // Test puppeteer 11.0+ with root-level files only
+    this.puppeteer11RootCanary = new synthetics.Canary(this, 'Puppeteer11RootCanary', {
+      runtime: synthetics.Runtime.SYNTHETICS_NODEJS_PUPPETEER_11_0,
+      test: synthetics.Test.custom({
+        handler: 'canary.handler',
+        code: synthetics.Code.fromAsset(path.join(__dirname, 'canaries-runtime-validation', 'root-only')),
+      }),
+      memory: Size.mebibytes(1024),
+      timeout: Duration.minutes(2),
+    });
+
+    // Test puppeteer 11.0+ also supports nodejs/node_modules structure
+    this.puppeteer11NodeModulesCanary = new synthetics.Canary(this, 'Puppeteer11NodeModulesCanary', {
+      runtime: synthetics.Runtime.SYNTHETICS_NODEJS_PUPPETEER_11_0,
+      test: synthetics.Test.custom({
+        handler: 'canary.handler',
+        code: synthetics.Code.fromAsset(path.join(__dirname, 'canaries')),
+      }),
+      memory: Size.mebibytes(1024),
+      timeout: Duration.minutes(2),
+    });
+  }
+}
+
+const app = new App();
+const testStack = new TestStack(app, 'SyntheticsCanaryRuntimeValidationStack');
+
+new IntegTest(app, 'SyntheticsCanaryRuntimeValidation', {
+  testCases: [testStack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-synthetics/integ.canary.ts

@@ -114,6 +114,7 @@ const selenium41 = createCanaryByRuntimes(Runtime.SYNTHETICS_PYTHON_SELENIUM_4_1
 const selenium50 = createCanaryByRuntimes(Runtime.SYNTHETICS_PYTHON_SELENIUM_5_0);
 const selenium51 = createCanaryByRuntimes(Runtime.SYNTHETICS_PYTHON_SELENIUM_5_1);
 const selenium60 = createCanaryByRuntimes(Runtime.SYNTHETICS_PYTHON_SELENIUM_6_0);
+const selenium70 = createCanaryByRuntimes(Runtime.SYNTHETICS_PYTHON_SELENIUM_7_0);
 
 const test = new IntegTest(app, 'IntegCanaryTest', {
   testCases: [stack],
@@ -142,6 +143,7 @@ const test = new IntegTest(app, 'IntegCanaryTest', {
   selenium50,
   selenium51,
   selenium60,
+  selenium70,
 ].forEach((canary) => test.assertions
   .awsApiCall('Synthetics', 'getCanaryRuns', {
     Name: canary.canaryName,

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/cloudformation-include/integ.novalue-nonstring.ts

@@ -0,0 +1,25 @@
+import * as path from 'path';
+import * as cdk from 'aws-cdk-lib';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { CfnInclude } from 'aws-cdk-lib/cloudformation-include';
+
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'integ-cfninclude-novalue-boolean');
+
+const templateFile = path.join(__dirname, 'test-templates', 'novalue-boolean.json');
+
+// Include a template that has a AWS::NoValue property in place of a boolean
+const cfnInclude = new CfnInclude(stack, 'Template', {
+  templateFile,
+});
+
+const bucket = cfnInclude.getResource('TestBucket');
+
+new cdk.CfnOutput(stack, 'BucketName', {
+  value: bucket.ref,
+});
+
+// The fact that synthesis is successful means that AWS::NoValue is evaluated correctly.
+new IntegTest(app, 'CfnIncludeNoValueBooleanTest', {
+  testCases: [stack],
+});