@aws-cdk-testing/cli-integ 2.61.0

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@aws-cdk-testing/cli-integ",
+  "description": "Integration tests for the AWS CDK CLI",
+  "version": "2.61.0",
+  "bin": {
+    "run-suite": "bin/run-suite",
+    "download-and-run-old-tests": "bin/download-and-run-old-tests",
+    "query-github": "bin/query-github",
+    "apply-patches": "bin/apply-patches",
+    "test-root": "bin/test-root",
+    "stage-distribution": "bin/stage-distribution"
+  },
+  "scripts": {
+    "build": "cdk-build",
+    "watch": "cdk-watch",
+    "lint": "cdk-lint",
+    "pkglint": "pkglint -f",
+    "test": "cdk-test",
+    "package": "cdk-package",
+    "build+test": "yarn build && yarn test",
+    "build+extract": "yarn build",
+    "build+test+package": "yarn build+test && yarn package",
+    "build+test+extract": "yarn build+test"
+  },
+  "author": {
+    "name": "Amazon Web Services",
+    "url": "https://aws.amazon.com",
+    "organization": true
+  },
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/node": "^14.18.31",
+    "@aws-cdk/cdk-build-tools": "2.61.0",
+    "@types/semver": "^7.3.12",
+    "@types/yargs": "^17.0.13",
+    "@types/fs-extra": "^9.0.0",
+    "@types/glob": "^7.2.0",
+    "@types/npm": "^7.19.0",
+    "@aws-cdk/pkglint": "2.61.0"
+  },
+  "dependencies": {
+    "@octokit/rest": "^18.12.0",
+    "jest": "^27.5.1",
+    "aws-sdk": "^2.1211.0",
+    "axios": "^0.27.2",
+    "jest-junit": "^14.0.0",
+    "semver": "^7.3.8",
+    "ts-mock-imports": "^1.3.8",
+    "yargs": "^17.5.0",
+    "glob": "^7.2.3",
+    "p-queue": "^6.6.2",
+    "fs-extra": "^9.1.0",
+    "npm": "^8.11.0"
+  },
+  "repository": {
+    "url": "https://github.com/aws/aws-cdk.git",
+    "type": "git",
+    "directory": "packages/@aws-cdk-testing/cli-integ"
+  },
+  "keywords": [
+    "aws",
+    "cdk"
+  ],
+  "homepage": "https://github.com/aws/aws-cdk",
+  "engines": {
+    "node": ">= 14.15.0"
+  },
+  "stability": "experimental",
+  "maturity": "experimental",
+  "publishConfig": {
+    "tag": "latest"
+  }
+}

package/resources/cdk-apps/app/app.js

@@ -0,0 +1,463 @@
+const path = require('path');
+
+var constructs = require('constructs');
+if (process.env.PACKAGE_LAYOUT_VERSION === '1') {
+  var cdk = require('@aws-cdk/core');
+  var ec2 = require('@aws-cdk/aws-ec2');
+  var s3 = require('@aws-cdk/aws-s3');
+  var ssm = require('@aws-cdk/aws-ssm');
+  var iam = require('@aws-cdk/aws-iam');
+  var sns = require('@aws-cdk/aws-sns');
+  var sqs = require('@aws-cdk/aws-sqs');
+  var lambda = require('@aws-cdk/aws-lambda');
+  var docker = require('@aws-cdk/aws-ecr-assets');
+} else {
+  var cdk = require('aws-cdk-lib');
+  var {
+    aws_ec2: ec2,
+    aws_s3: s3,
+    aws_ssm: ssm,
+    aws_iam: iam,
+    aws_sns: sns,
+    aws_sqs: sqs,
+    aws_lambda: lambda,
+    aws_ecr_assets: docker
+  } = require('aws-cdk-lib');
+}
+
+const { Annotations } = cdk;
+const { StackWithNestedStack, StackWithNestedStackUsingParameters } = require('./nested-stack');
+
+const stackPrefix = process.env.STACK_NAME_PREFIX;
+if (!stackPrefix) {
+  throw new Error(`the STACK_NAME_PREFIX environment variable is required`);
+}
+
+class MyStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+    new sns.Topic(this, 'topic');
+
+    if (cdk.AvailabilityZoneProvider) { // <= 0.34.0
+      new cdk.AvailabilityZoneProvider(this).availabilityZones;
+    } else if (cdk.Context) { // <= 0.35.0
+      cdk.Context.getAvailabilityZones(this);
+    } else {
+      this.availabilityZones;
+    }
+
+    const parameterName = '/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2';
+    getSsmParameterValue(this, parameterName);
+  }
+}
+
+function getSsmParameterValue(scope, parameterName) {
+  return ssm.StringParameter.valueFromLookup(scope, parameterName);
+}
+
+class YourStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+    new sns.Topic(this, 'topic1');
+    new sns.Topic(this, 'topic2');
+  }
+}
+
+class ImportableStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    if (!process.env.OMIT_TOPIC) {
+      const queue = new sqs.Queue(this, 'Queue', {
+        removalPolicy: process.env.ORPHAN_TOPIC ? cdk.RemovalPolicy.RETAIN : cdk.RemovalPolicy.DESTROY,
+      });
+
+      new cdk.CfnOutput(this, 'QueueName', {
+        value: queue.queueName,
+      });
+      new cdk.CfnOutput(this, 'QueueLogicalId', {
+        value: queue.node.defaultChild.logicalId,
+      });
+    }
+
+    new cdk.CfnWaitConditionHandle(this, 'Handle');
+  }
+}
+
+class StackUsingContext extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+    new cdk.CfnResource(this, 'Handle', {
+      type: 'AWS::CloudFormation::WaitConditionHandle'
+    });
+
+    new cdk.CfnOutput(this, 'Output', {
+      value: this.availabilityZones[0],
+    });
+  }
+}
+
+class ParameterStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    new sns.Topic(this, 'TopicParameter', {
+      topicName: new cdk.CfnParameter(this, 'TopicNameParam').valueAsString
+    });
+  }
+}
+
+class OtherParameterStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    new sns.Topic(this, 'TopicParameter', {
+      topicName: new cdk.CfnParameter(this, 'OtherTopicNameParam').valueAsString
+    });
+  }
+}
+
+class MultiParameterStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    new sns.Topic(this, 'TopicParameter', {
+      displayName: new cdk.CfnParameter(this, 'DisplayNameParam').valueAsString
+    });
+    new sns.Topic(this, 'OtherTopicParameter', {
+      displayName: new cdk.CfnParameter(this, 'OtherDisplayNameParam').valueAsString
+    });
+  }
+}
+
+class OutputsStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    const topic = new sns.Topic(this, 'MyOutput', {
+      topicName: `${cdk.Stack.of(this).stackName}MyTopic`
+    });
+
+    new cdk.CfnOutput(this, 'TopicName', {
+      value: topic.topicName
+    })
+  }
+}
+
+class AnotherOutputsStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    const topic = new sns.Topic(this, 'MyOtherOutput', {
+      topicName: `${cdk.Stack.of(this).stackName}MyOtherTopic`
+    });
+
+    new cdk.CfnOutput(this, 'TopicName', {
+      value: topic.topicName
+    });
+  }
+}
+
+class IamStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    new iam.Role(this, 'SomeRole', {
+      assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com')
+    });
+  }
+}
+
+class ProvidingStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    this.topic = new sns.Topic(this, 'BogusTopic'); // Some filler
+  }
+}
+
+class StackWithError extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    this.topic = new sns.Topic(this, 'BogusTopic'); // Some filler
+    Annotations.of(this).addError('This is an error');
+  }
+}
+
+class StageWithError extends cdk.Stage {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    new StackWithError(this, 'Stack');
+  }
+}
+
+class ConsumingStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    new sns.Topic(this, 'BogusTopic');  // Some filler
+    new cdk.CfnOutput(this, 'IConsumedSomething', { value: props.providingStack.topic.topicArn });
+  }
+}
+
+class MissingSSMParameterStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    const parameterName = constructs.Node.of(this).tryGetContext('test:ssm-parameter-name');
+    if (parameterName) {
+      const param = getSsmParameterValue(this, parameterName);
+      new iam.Role(this, 'PhonyRole', { assumedBy: new iam.AccountPrincipal(param) });
+    }
+  }
+}
+
+class LambdaStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    const fn = new lambda.Function(this, 'my-function', {
+      code: lambda.Code.asset(path.join(__dirname, 'lambda')),
+      runtime: lambda.Runtime.NODEJS_14_X,
+      handler: 'index.handler'
+    });
+
+    new cdk.CfnOutput(this, 'FunctionArn', { value: fn.functionArn });
+  }
+}
+
+class LambdaHotswapStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    const fn = new lambda.Function(this, 'my-function', {
+      code: lambda.Code.asset(path.join(__dirname, 'lambda')),
+      runtime: lambda.Runtime.NODEJS_14_X,
+      handler: 'index.handler',
+      description: process.env.DYNAMIC_LAMBDA_PROPERTY_VALUE ?? "description",
+      environment: {
+        SomeVariable: process.env.DYNAMIC_LAMBDA_PROPERTY_VALUE ?? "environment",
+      }
+    });
+
+    new cdk.CfnOutput(this, 'FunctionName', { value: fn.functionName });
+  }
+}
+
+class DockerStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    new docker.DockerImageAsset(this, 'image', {
+      directory: path.join(__dirname, 'docker')
+    });
+
+    // Add at least a single resource (WaitConditionHandle), otherwise this stack will never
+    // be deployed (and its assets never built)
+    new cdk.CfnResource(this, 'Handle', {
+      type: 'AWS::CloudFormation::WaitConditionHandle'
+    });
+  }
+}
+
+class DockerStackWithCustomFile extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    new docker.DockerImageAsset(this, 'image', {
+      directory: path.join(__dirname, 'docker'),
+      file: 'Dockerfile.Custom'
+    });
+
+    // Add at least a single resource (WaitConditionHandle), otherwise this stack will never
+    // be deployed (and its assets never built)
+    new cdk.CfnResource(this, 'Handle', {
+      type: 'AWS::CloudFormation::WaitConditionHandle'
+    });
+  }
+}
+
+/**
+ * A stack that will never succeed deploying (done in a way that CDK cannot detect but CFN will complain about)
+ */
+class FailedStack extends cdk.Stack {
+
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    // fails on 'Property PolicyDocument cannot be empty'.
+    new cdk.CfnResource(this, 'EmptyPolicy', {
+      type: 'AWS::IAM::Policy'
+    })
+
+  }
+
+}
+
+const VPC_TAG_NAME = 'custom-tag';
+const VPC_TAG_VALUE = `${stackPrefix}-bazinga!`;
+
+class DefineVpcStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    const vpc = new ec2.Vpc(this, 'VPC', {
+      maxAzs: 1,
+    })
+    cdk.Aspects.of(vpc).add(new cdk.Tag(VPC_TAG_NAME, VPC_TAG_VALUE));
+  }
+}
+
+class ImportVpcStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    ec2.Vpc.fromLookup(this, 'DefaultVPC', { isDefault: true });
+    ec2.Vpc.fromLookup(this, 'ByTag', { tags: { [VPC_TAG_NAME]: VPC_TAG_VALUE } });
+  }
+}
+
+class ConditionalResourceStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    if (!process.env.NO_RESOURCE) {
+      new iam.User(this, 'User');
+    }
+  }
+}
+
+class BundlingStage extends cdk.Stage {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+    const stack = new cdk.Stack(this, 'BundlingStack');
+
+    new lambda.Function(stack, 'Handler', {
+      code: lambda.Code.fromAsset(path.join(__dirname, 'lambda')),
+      handler: 'index.handler',
+      runtime: lambda.Runtime.NODEJS_16_X,
+    });
+  }
+}
+
+class SomeStage extends cdk.Stage {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    new YourStack(this, 'StackInStage');
+  }
+}
+
+class StageUsingContext extends cdk.Stage {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    new StackUsingContext(this, 'StackInStage');
+  }
+}
+
+class BuiltinLambdaStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    new s3.Bucket(this, 'Bucket', {
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+      autoDeleteObjects: true, // will deploy a Nodejs lambda backed custom resource
+    });
+  }
+}
+
+const app = new cdk.App({
+  context: {
+    '@aws-cdk/core:assetHashSalt': process.env.CODEBUILD_BUILD_ID, // Force all assets to be unique, but consistent in one build
+  },
+});
+
+const defaultEnv = {
+  account: process.env.CDK_DEFAULT_ACCOUNT,
+  region: process.env.CDK_DEFAULT_REGION
+};
+
+// Sometimes we don't want to synthesize all stacks because it will impact the results
+const stackSet = process.env.INTEG_STACK_SET || 'default';
+
+switch (stackSet) {
+  case 'default':
+    // Deploy all does a wildcard ${stackPrefix}-test-*
+    new MyStack(app, `${stackPrefix}-test-1`, { env: defaultEnv });
+    new YourStack(app, `${stackPrefix}-test-2`);
+    // Deploy wildcard with parameters does ${stackPrefix}-param-test-*
+    new ParameterStack(app, `${stackPrefix}-param-test-1`);
+    new OtherParameterStack(app, `${stackPrefix}-param-test-2`);
+    // Deploy stack with multiple parameters
+    new MultiParameterStack(app, `${stackPrefix}-param-test-3`);
+    // Deploy stack with outputs does ${stackPrefix}-outputs-test-*
+    new OutputsStack(app, `${stackPrefix}-outputs-test-1`);
+    new AnotherOutputsStack(app, `${stackPrefix}-outputs-test-2`);
+    // Not included in wildcard
+    new IamStack(app, `${stackPrefix}-iam-test`, { env: defaultEnv });
+    const providing = new ProvidingStack(app, `${stackPrefix}-order-providing`);
+    new ConsumingStack(app, `${stackPrefix}-order-consuming`, { providingStack: providing });
+
+    new MissingSSMParameterStack(app, `${stackPrefix}-missing-ssm-parameter`, { env: defaultEnv });
+
+    new LambdaStack(app, `${stackPrefix}-lambda`);
+    new LambdaHotswapStack(app, `${stackPrefix}-lambda-hotswap`);
+    new DockerStack(app, `${stackPrefix}-docker`);
+    new DockerStackWithCustomFile(app, `${stackPrefix}-docker-with-custom-file`);
+    const failed = new FailedStack(app, `${stackPrefix}-failed`)
+
+    // A stack that depends on the failed stack -- used to test that '-e' does not deploy the failing stack
+    const dependsOnFailed = new OutputsStack(app, `${stackPrefix}-depends-on-failed`);
+    dependsOnFailed.addDependency(failed);
+
+    if (process.env.ENABLE_VPC_TESTING) { // Gating so we don't do context fetching unless that's what we are here for
+      const env = { account: process.env.CDK_DEFAULT_ACCOUNT, region: process.env.CDK_DEFAULT_REGION };
+      if (process.env.ENABLE_VPC_TESTING === 'DEFINE')
+        new DefineVpcStack(app, `${stackPrefix}-define-vpc`, { env });
+      if (process.env.ENABLE_VPC_TESTING === 'IMPORT')
+        new ImportVpcStack(app, `${stackPrefix}-import-vpc`, { env });
+    }
+
+    new ConditionalResourceStack(app, `${stackPrefix}-conditional-resource`)
+
+    new StackWithNestedStack(app, `${stackPrefix}-with-nested-stack`);
+    new StackWithNestedStackUsingParameters(app, `${stackPrefix}-with-nested-stack-using-parameters`);
+
+    new YourStack(app, `${stackPrefix}-termination-protection`, {
+      terminationProtection: process.env.TERMINATION_PROTECTION !== 'FALSE' ? true : false,
+    });
+
+    new SomeStage(app, `${stackPrefix}-stage`);
+
+    new BuiltinLambdaStack(app, `${stackPrefix}-builtin-lambda-function`);
+
+    new ImportableStack(app, `${stackPrefix}-importable-stack`);
+
+    new BundlingStage(app, `${stackPrefix}-bundling-stage`);
+    break;
+
+  case 'stage-using-context':
+    // Cannot be combined with other test stacks, because we use this to test
+    // that stage context is propagated up and causes synth to fail when combined
+    // with '--no-lookups'.
+
+    // Needs a dummy stack at the top level because the CLI will fail otherwise
+    new YourStack(app, `${stackPrefix}-toplevel`, { env: defaultEnv });
+    new StageUsingContext(app, `${stackPrefix}-stage-using-context`, {
+      env: defaultEnv,
+    });
+    break;
+
+  case 'stage-with-errors':
+    const stage = new StageWithError(app, `${stackPrefix}-stage-with-errors`);
+    stage.synth({ validateOnSynthesis: true });
+    break;
+
+  default:
+    throw new Error(`Unrecognized INTEG_STACK_SET: '${stackSet}'`);
+}
+
+app.synth();

package/resources/cdk-apps/app/cdk.json

@@ -0,0 +1,7 @@
+{
+  "app": "node app.js",
+  "versionReporting": false,
+  "context": {
+    "aws-cdk:enableDiffNoFail": "true"
+  }
+}

package/resources/cdk-apps/app/docker/Dockerfile

@@ -0,0 +1,2 @@
+FROM public.ecr.aws/docker/library/alpine:latest
+

package/resources/cdk-apps/app/docker/Dockerfile.Custom

@@ -0,0 +1,2 @@
+FROM public.ecr.aws/docker/library/alpine:latest
+

package/resources/cdk-apps/app/lambda/index.js

@@ -0,0 +1,4 @@
+exports.handler = async function(event) {
+  const response = require('./response.json');
+  return response;
+};

package/resources/cdk-apps/app/lambda/response.json

@@ -0,0 +1,3 @@
+{
+  "response": "hello, dear asset!"
+}

package/resources/cdk-apps/app/nested-stack.js

@@ -0,0 +1,49 @@
+if (process.env.PACKAGE_LAYOUT_VERSION === '1') {
+  var cfn = require('@aws-cdk/aws-cloudformation');
+  var sns = require('@aws-cdk/aws-sns');
+  var { Stack, CfnParameter } = require('@aws-cdk/core');
+} else {
+  var {
+    aws_cloudformation: cfn,
+    aws_sns: sns,
+  } = require('aws-cdk-lib');
+  var { Stack, CfnParameter } = require('aws-cdk-lib');
+}
+
+class StackWithNestedStack extends Stack {
+  constructor(scope, id) {
+    super(scope, id);
+    new MyNestedStack(this, 'MyNested');
+  }
+}
+
+class MyNestedStack extends cfn.NestedStack {
+  constructor(scope, id) {
+    super(scope, id);
+
+    new sns.Topic(this, 'MyTopic');
+  }
+}
+
+class StackWithNestedStackUsingParameters extends Stack {
+  constructor(scope, id) {
+    super(scope, id);
+    const topicNameParam = new CfnParameter(this, 'MyTopicParam');
+    new MyNestedStackUsingParameters(this, 'MyNested', {
+      parameters: {'MyTopicParam': topicNameParam.valueAsString}
+    });
+  }
+}
+
+class MyNestedStackUsingParameters extends cfn.NestedStack {
+  constructor(scope, id, props) {
+    super(scope, id, props);
+
+    new sns.Topic(this, 'MyTopic', {
+      topicName: new CfnParameter(this, 'MyTopicParam')
+    });
+  }
+}
+
+exports.StackWithNestedStack = StackWithNestedStack;
+exports.StackWithNestedStackUsingParameters = StackWithNestedStackUsingParameters;

package/resources/cdk-apps/cfn-include-app/.gitignore

@@ -0,0 +1 @@
+!cfn-include-app.js

package/resources/cdk-apps/cfn-include-app/cdk.json

@@ -0,0 +1,4 @@
+{
+  "app": "node cfn-include-app.js",
+  "versionReporting": false
+}

package/resources/cdk-apps/cfn-include-app/cfn-include-app.js

@@ -0,0 +1,21 @@
+const path = require('path');
+
+const uberPackage = process.env.UBERPACKAGE;
+if (!uberPackage) {
+  throw new Error('The UBERPACKAGE environment variable is required for running this app!');
+}
+
+const cfn_inc = require(`${uberPackage}/cloudformation-include`);
+const core = require(`${uberPackage}`);
+
+const app = new core.App();
+const stack = new core.Stack(app, 'Stack');
+const cfnInclude = new cfn_inc.CfnInclude(stack, 'Template', {
+  templateFile: path.join(__dirname, 'example-template.json'),
+});
+const cfnBucket = cfnInclude.getResource('Bucket');
+if (cfnBucket.bucketName !== 'my-example-bucket') {
+  throw new Error(`Expected bucketName to be 'my-example-bucket', got: '${cfnBucket.bucketName}'`);
+}
+
+app.synth();

package/resources/cdk-apps/cfn-include-app/example-template.json

@@ -0,0 +1,13 @@
+{
+  "Resources": {
+    "NoopHandle": {
+      "Type": "AWS::CloudFormation::WaitConditionHandle"
+    },
+    "Bucket": {
+      "Type": "AWS::S3::Bucket",
+      "Properties": {
+        "BucketName": "my-example-bucket"
+      }
+    }
+  }
+}

package/resources/cdk-apps/sam_cdk_integ_app/bin/test-app.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+if (process.env.PACKAGE_LAYOUT_VERSION === '1') {
+    var { App } = require('@aws-cdk/core');
+} else {
+    var { App } = require('aws-cdk-lib');
+}
+var test_stack_1 = require('../lib/test-stack');
+var app = new App();
+const stackPrefix = process.env.STACK_NAME_PREFIX;
+new test_stack_1.CDKSupportDemoRootStack(app, `${stackPrefix}-TestStack`);
+app.synth();

package/resources/cdk-apps/sam_cdk_integ_app/cdk.json

@@ -0,0 +1,6 @@
+{
+  "app": "node bin/test-app.js",
+  "context": {
+    
+  }
+}

package/resources/cdk-apps/sam_cdk_integ_app/lib/nested-stack.js

@@ -0,0 +1,19 @@
+if (process.env.PACKAGE_LAYOUT_VERSION === '1') {
+  var { NestedStack } = require('@aws-cdk/core');
+  var { Function, Runtime, Code } = require('@aws-cdk/aws-lambda');
+} else {
+  var { NestedStack } = require('aws-cdk-lib');
+  var { Function, Runtime, Code } = require('aws-cdk-lib/aws-lambda');
+}
+
+class NestedStack1 extends NestedStack {
+  constructor(scope, id, props) {
+    super(scope, id, props);
+    new Function(this, 'FunctionPythonRuntime', {
+      runtime: Runtime.PYTHON_3_7,
+      code: Code.fromAsset('./src/python/Function'),
+      handler: 'app.lambda_handler',
+    });
+  }
+}
+exports.NestedStack1 = NestedStack1;