test(cli): cdk import works when used on a stack containing a nodejs lambda function (#33372)

### Improves testing for #33322.

### Reason for this change

The original test (removed below) does not adequately test the CDK import fix from the above-mentioned PR. It calls CDK synth, but does not use the CLI and does not test `cdk import`.

### Description of changes

The old test is removed.

The new test ensures that `cdk import` works when an already-deployed stack contains a NodeJSFunction lambda. In our test, we deploy a stack containing a NodeJSFunction Lambda. We also create, orphan, and import an S3 bucket, which replicates the customer scenario in issue #31999.

The test:
1. Installs `esbuild` so that we can use it for bundling.
2. Deploys a NodeJSFunction and an S3 bucket.
3. Orphans the S3 bucket but allows the bucket to persist (not destroyed).
4. Imports the S3 bucket into the template using its `BucketName` property.

The test will fail if the import operation fails for any reason.

The test does not assert any specific values or patterns for asset metadata keys. When investigating the issue, the metadata keys were different when using import-synth (skipped bundling) and deploy/diff/synth (did not skip bundling). The difference in the keys was another symptom of the same issue.

### Describe any new or updated permissions being added

No permissions changes.


### Description of how you validated changes

This PR tests the feature. I ensured that the test failed on code prior to the change in PR #33322, and passes on code following the change.

### Checklist
- [X] My code adheres to the [CONTRIBUTING GUIDE](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md) and [DESIGN GUIDELINES](https://github.com/aws/aws-cdk/blob/main/docs/DESIGN_GUIDELINES.md)

----

*By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license*

Author: iankhou

packages/@aws-cdk-testing/cli-integ/resources/cdk-apps/app/app.js

@@ -11,6 +11,7 @@ if (process.env.PACKAGE_LAYOUT_VERSION === '1') {
   var sns = require('@aws-cdk/aws-sns');
   var sqs = require('@aws-cdk/aws-sqs');
   var lambda = require('@aws-cdk/aws-lambda');
+  var node_lambda = require('@aws-cdk/aws-lambda-nodejs');
   var sso = require('@aws-cdk/aws-sso');
   var docker = require('@aws-cdk/aws-ecr-assets');
   var appsync = require('@aws-cdk/aws-appsync');
@@ -28,6 +29,7 @@ if (process.env.PACKAGE_LAYOUT_VERSION === '1') {
     aws_sns: sns,
     aws_sqs: sqs,
     aws_lambda: lambda,
+    aws_lambda_nodejs: node_lambda,
     aws_ecr_assets: docker,
     aws_appsync: appsync,
     Stack
@@ -264,6 +266,20 @@ class ImportableStack extends cdk.Stack {
       });
     }
 
+    if (process.env.INCLUDE_SINGLE_BUCKET === '1') {
+      const bucket = new s3.Bucket(this, 'test-bucket', {
+        removalPolicy: (process.env.RETAIN_SINGLE_BUCKET === '1') ? cdk.RemovalPolicy.RETAIN : cdk.RemovalPolicy.DESTROY,
+      });
+    
+      new cdk.CfnOutput(this, 'BucketLogicalId', {
+        value: bucket.node.defaultChild.logicalId,
+      });
+
+      new cdk.CfnOutput(this, 'BucketName', {
+        value: bucket.bucketName,
+      });
+    }
+
     if (process.env.LARGE_TEMPLATE === '1') {
       for (let i = 1; i <= 70; i++) {
         new sqs.Queue(this, `cdk-import-queue-test${i}`, {
@@ -272,6 +288,24 @@ class ImportableStack extends cdk.Stack {
         });
       }
     }
+
+    if (process.env.INCLUDE_NODEJS_FUNCTION_LAMBDA === '1') {
+      new node_lambda.NodejsFunction(
+        this,
+        'cdk-import-nodejs-lambda-test',
+        {
+          bundling: {
+            minify: true,
+            sourceMap: false,
+            sourcesContent: false,
+            target: 'ES2020',
+            forceDockerBundling: true,
+          },
+          runtime: lambda.Runtime.NODEJS_18_X,
+          entry: path.join(__dirname, 'lambda/index.js')
+        }
+      )
+    }
   }
 }
 

packages/@aws-cdk-testing/cli-integ/tests/cli-integ-tests/cli.integtest.ts

@@ -2252,6 +2252,73 @@ integTest(
   }),
 );
 
+/**
+ * Create an S3 bucket, orphan that bucket, then import the bucket, with a NodeJSFunction lambda also in the stack.
+ *
+ * Validates fix for https://github.com/aws/aws-cdk/issues/31999 (import fails)
+ */
+integTest(
+  'test resource import with construct that requires bundling',
+  withDefaultFixture(async (fixture) => {
+    // GIVEN
+    const outputsFile = path.join(fixture.integTestDir, 'outputs', 'outputs.json');
+    await fs.mkdir(path.dirname(outputsFile), { recursive: true });
+
+    // First, create a stack that includes a NodeJSFunction lambda and one bucket that will be removed from the stack but NOT deleted from AWS.
+    await fixture.cdkDeploy('importable-stack', {
+      modEnv: { INCLUDE_NODEJS_FUNCTION_LAMBDA: '1', INCLUDE_SINGLE_BUCKET: '1', RETAIN_SINGLE_BUCKET: '1' },
+      options: ['--outputs-file', outputsFile],
+    });
+
+    try {
+      // Second, now the bucket we will remove is in the stack and has a logicalId. We can now make the resource mapping file.
+      // This resource mapping file will be used to tell the import operation what bucket to bring into the stack.
+      const fullStackName = fixture.fullStackName('importable-stack');
+      const outputs = JSON.parse((await fs.readFile(outputsFile, { encoding: 'utf-8' })).toString());
+      const bucketLogicalId = outputs[fullStackName].BucketLogicalId;
+      const bucketName = outputs[fullStackName].BucketName;
+      const bucketResourceMap = {
+        [bucketLogicalId]: {
+          BucketName: bucketName,
+        },
+      };
+      const mappingFile = path.join(fixture.integTestDir, 'outputs', 'mapping.json');
+      await fs.writeFile(mappingFile, JSON.stringify(bucketResourceMap), { encoding: 'utf-8' });
+
+      // Third, remove the bucket from the stack, but don't delete the bucket from AWS.
+      await fixture.cdkDeploy('importable-stack', {
+        modEnv: { INCLUDE_NODEJS_FUNCTION_LAMBDA: '1', INCLUDE_SINGLE_BUCKET: '0', RETAIN_SINGLE_BUCKET: '0' },
+      });
+      const cfnTemplateBeforeImport = await fixture.aws.cloudFormation.send(
+        new GetTemplateCommand({ StackName: fullStackName }),
+      );
+      expect(cfnTemplateBeforeImport.TemplateBody).not.toContain(bucketLogicalId);
+
+      // WHEN
+      await fixture.cdk(['import', '--resource-mapping', mappingFile, fixture.fullStackName('importable-stack')], {
+        modEnv: { INCLUDE_NODEJS_FUNCTION_LAMBDA: '1', INCLUDE_SINGLE_BUCKET: '1', RETAIN_SINGLE_BUCKET: '0' },
+      });
+
+      // THEN
+      const describeStacksResponse = await fixture.aws.cloudFormation.send(
+        new DescribeStacksCommand({ StackName: fullStackName }),
+      );
+      const cfnTemplateAfterImport = await fixture.aws.cloudFormation.send(
+        new GetTemplateCommand({ StackName: fullStackName }),
+      );
+
+      // If bundling is skipped during import for NodeJSFunction lambda, then the operation should fail and exit
+      expect(describeStacksResponse.Stacks![0].StackStatus).toEqual('IMPORT_COMPLETE');
+
+      // If the import operation is successful, the template should contain the imported bucket
+      expect(cfnTemplateAfterImport.TemplateBody).toContain(bucketLogicalId);
+    } finally {
+      // Clean up the resources we created
+      await fixture.cdkDestroy('importable-stack');
+    }
+  }),
+);
+
 /**
  * Create a queue, orphan that queue, then import the queue.
  *

packages/@aws-cdk-testing/framework-integ/test/aws-lambda-nodejs/test/integ.nodejs.build.images.ts

@@ -1,8 +1,6 @@
 import * as path from 'path';
-import * as fs from 'fs';
-import { App, Stack, StackProps, ValidationError } from 'aws-cdk-lib';
+import { App, Stack, StackProps } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
-import * as lambda from 'aws-cdk-lib/aws-lambda';
 import * as lambdaNodeJs from 'aws-cdk-lib/aws-lambda-nodejs';
 import { ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';
 import { IFunction, Runtime } from 'aws-cdk-lib/aws-lambda';
@@ -51,39 +49,3 @@ stack.lambdaFunctions.forEach(func=> {
     ExecutedVersion: '$LATEST',
   }));
 });
-
-// Ensure that the code is bundled
-const assembly = app.synth();
-
-stack.lambdaFunctions.forEach((func) => {
-  const template = assembly.getStackArtifact(stack.artifactId).template;
-  const resourceName = stack.getLogicalId(func.node.defaultChild as lambda.CfnFunction);
-  const resource = template.Resources[resourceName];
-
-  if (!resource || resource.Type !== 'AWS::Lambda::Function') {
-    throw new ValidationError(`Could not find Lambda function resource for ${func.functionName}`, stack);
-  }
-
-  const s3Bucket = resource.Properties.Code.S3Bucket;
-  const s3Key = resource.Properties.Code.S3Key;
-
-  if (!s3Bucket || !s3Key) {
-    throw new ValidationError(`Could not find S3 location for function ${func.functionName}`, stack);
-  }
-
-  const assetId = s3Key.split('.')[0]; // S3Key format is <hash>.zip"
-  const assetDir = path.join(assembly.directory, `asset.${assetId}`);
-
-  try {
-    if (!fs.existsSync(assetDir) || !fs.statSync(assetDir).isDirectory()) {
-      throw new ValidationError(`Asset directory does not exist for function ${func.functionName}: ${assetDir}`, stack);
-    }
-
-    const indexPath = path.join(assetDir, 'index.js');
-    if (!fs.existsSync(indexPath)) {
-      throw new ValidationError(`index.js not found in asset directory for function ${func.functionName}`, stack);
-    }
-  } catch (error) {
-    throw error;
-  }
-});