refactor: address round 2 PR feedback

Author: Lee Hannigan

.projenrc.ts

@@ -1533,6 +1533,7 @@ const cliInteg = configureProject(
       '@octokit/rest@^20', // newer versions are ESM only
       '@aws-sdk/client-codeartifact',
       '@aws-sdk/client-cloudformation',
+      '@aws-sdk/client-dynamodb',
       '@aws-sdk/client-ecr',
       '@aws-sdk/client-ecr-public',
       '@aws-sdk/client-ecs',

packages/@aws-cdk-testing/cli-integ/.projen/deps.json

@@ -1,6 +1,5 @@
-import { promises as fs } from 'fs';
-import * as path from 'path';
 import { DescribeStacksCommand, GetTemplateCommand } from '@aws-sdk/client-cloudformation';
+import { DynamoDBClient, PutItemCommand, GetItemCommand, DeleteTableCommand } from '@aws-sdk/client-dynamodb';
 import * as yaml from 'yaml';
 import { integTest, withDefaultFixture } from '../../../lib';
 
@@ -18,61 +17,70 @@ integTest(
     );
     const outputs = describeResponse.Stacks?.[0]?.Outputs ?? [];
     const tableName = outputs.find((o) => o.OutputKey === 'TableName')?.OutputValue;
-    const functionName = outputs.find((o) => o.OutputKey === 'FunctionName')?.OutputValue;
     expect(tableName).toBeDefined();
-    expect(functionName).toBeDefined();
 
-    // Put an item in the table before orphan
-    const itemFile = path.join(fixture.integTestDir, 'test-item.json');
-    await fs.writeFile(itemFile, JSON.stringify({ PK: { S: 'before-orphan' } }));
-    await fixture.shell([
-      'aws', 'dynamodb', 'put-item',
-      '--table-name', tableName!,
-      '--item', `file://${itemFile}`,
-      '--region', fixture.aws.region,
-    ]);
+    const dynamodb = new DynamoDBClient({ region: fixture.aws.region });
 
-    // Orphan the table
-    const orphanOutput = await fixture.cdk([
-      'orphan',
-      '--path', `${stackName}/MyTable`,
-      '--unstable=orphan',
-      '--force',
-    ]);
+    try {
+      // Verify the table resource exists in the template before orphaning
+      const templateBefore = await fixture.aws.cloudFormation.send(
+        new GetTemplateCommand({ StackName: stackName }),
+      );
+      const templateBodyBefore = yaml.parse(templateBefore.TemplateBody!);
+      expect(templateBodyBefore.Resources).toHaveProperty('MyTable794EDED1');
 
-    // Verify the output contains a resource mapping for import
-    expect(orphanOutput).toContain('resource-mapping-inline');
-    expect(orphanOutput).toContain('TableName');
+      // Put an item in the table before orphan
+      await dynamodb.send(new PutItemCommand({
+        TableName: tableName!,
+        Item: { PK: { S: 'before-orphan' } },
+      }));
 
-    // Verify the table is no longer in the stack template
-    const templateAfter = await fixture.aws.cloudFormation.send(
-      new GetTemplateCommand({ StackName: stackName }),
-    );
-    const templateBody = yaml.parse(templateAfter.TemplateBody!);
-    expect(templateBody.Resources).not.toHaveProperty('MyTable794EDED1');
+      // Orphan the table
+      const orphanOutput = await fixture.cdk([
+        'orphan',
+        '--path', `${stackName}/MyTable`,
+        '--unstable=orphan',
+        '--force',
+      ]);
+
+      // Verify the output contains a resource mapping for import
+      expect(orphanOutput).toContain('resource-mapping-inline');
+      expect(orphanOutput).toContain('TableName');
+
+      // Verify the template after orphan: table gone, Lambda env vars replaced with literals
+      const templateAfter = await fixture.aws.cloudFormation.send(
+        new GetTemplateCommand({ StackName: stackName }),
+      );
+      const templateBody = yaml.parse(templateAfter.TemplateBody!);
 
-    // Verify the Lambda still exists and its env vars have been replaced with literals
-    // (Ref -> physical table name, GetAtt -> physical ARN)
-    const lambdaResource = Object.values(templateBody.Resources).find(
-      (r: any) => r.Type === 'AWS::Lambda::Function',
-    ) as any;
-    expect(lambdaResource).toBeDefined();
-    const envVars = lambdaResource.Properties?.Environment?.Variables ?? {};
-    // TABLE_NAME should be a literal string (not a {Ref})
-    expect(typeof envVars.TABLE_NAME).toBe('string');
-    expect(envVars.TABLE_NAME).toContain('MyTable');
-    // TABLE_ARN should be a literal string (not a {Fn::GetAtt})
-    expect(typeof envVars.TABLE_ARN).toBe('string');
-    expect(envVars.TABLE_ARN).toContain('arn:aws:dynamodb');
+      expect(templateBody.Resources).not.toHaveProperty('MyTable794EDED1');
+      expect(templateBody).toMatchObject({
+        Resources: expect.objectContaining({
+          Consumer8D6BE417: expect.objectContaining({
+            Type: 'AWS::Lambda::Function',
+            Properties: expect.objectContaining({
+              Environment: {
+                Variables: {
+                  TABLE_NAME: expect.stringContaining('MyTable'),
+                  TABLE_ARN: expect.stringContaining('arn:aws:dynamodb'),
+                },
+              },
+            }),
+          }),
+        }),
+      });
 
-    // Verify the table still exists and data is intact
-    const getItemOutput = await fixture.shell([
-      'aws', 'dynamodb', 'get-item',
-      '--table-name', tableName!,
-      '--key', `file://${itemFile}`,
-      '--region', fixture.aws.region,
-      '--output', 'json',
-    ]);
-    expect(getItemOutput).toContain('before-orphan');
+      // Verify the table still exists and data is intact (strongly consistent read)
+      const getItemResult = await dynamodb.send(new GetItemCommand({
+        TableName: tableName!,
+        Key: { PK: { S: 'before-orphan' } },
+        ConsistentRead: true,
+      }));
+      expect(getItemResult.Item?.PK?.S).toBe('before-orphan');
+    } finally {
+      // Clean up the retained table to avoid leaking resources
+      await dynamodb.send(new DeleteTableCommand({ TableName: tableName! })).catch(() => {
+      });
+    }
   }),
 );