From e6bdd04cf00156eb507651dac2e7f8f43752c2c2 Mon Sep 17 00:00:00 2001
From: Calvin Combs <comcalvi@amazon.com>
Date: Thu, 20 Jan 2022 15:35:03 -0800
Subject: [PATCH 1/2] file deletion

---
 .../cloudformation-diff/lib/format.ts         |   2 +
 .../lib/api/cloudformation-deployments.ts     | 148 +++-
 .../aws-cdk/lib/api/hotswap-deployments.ts    |   1 -
 packages/aws-cdk/lib/cdk-toolkit.ts           |   4 +-
 .../api/cloudformation-deployments.test.ts    | 731 +++++++++++++++++-
 ...utput-one-param-stack.nested.template.json |  20 +
 ...ource-one-stack-stack.nested.template.json |  16 +
 .../one-resource-stack.nested.template.json   |  10 +
 ...urce-two-stacks-stack.nested.template.json |  22 +
 packages/aws-cdk/test/diff.test.ts            | 322 +++++---
 packages/aws-cdk/test/util.ts                 |  20 +
 11 files changed, 1180 insertions(+), 116 deletions(-)
 create mode 100644 packages/aws-cdk/test/diff-nested-stacks-templates/one-output-one-param-stack.nested.template.json
 create mode 100644 packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-one-stack-stack.nested.template.json
 create mode 100644 packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-stack.nested.template.json
 create mode 100644 packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-two-stacks-stack.nested.template.json

diff --git a/packages/@aws-cdk/cloudformation-diff/lib/format.ts b/packages/@aws-cdk/cloudformation-diff/lib/format.ts
index 3dee563f8cf36..570c670e2d381 100644
--- a/packages/@aws-cdk/cloudformation-diff/lib/format.ts
+++ b/packages/@aws-cdk/cloudformation-diff/lib/format.ts
@@ -272,8 +272,10 @@ class Formatter {
         this.formatObjectDiff(oldValue, newValue, `${linePrefix}   ${key === lastKey ? ' ' : '│'}`);
       } else if (oldValue !== undefined /* && newValue === undefined */) {
         this.print('%s   %s─ %s Removed: %s', linePrefix, treePrefix, REMOVAL, chalk.blue(`.${key}`));
+        this.formatObjectDiff(oldValue, newValue, `${linePrefix}   ${key === lastKey ? ' ' : '│'}`);
       } else /* if (oldValue === undefined && newValue !== undefined */ {
         this.print('%s   %s─ %s Added: %s', linePrefix, treePrefix, ADDITION, chalk.blue(`.${key}`));
+        this.formatObjectDiff(oldValue, newValue, `${linePrefix}   ${key === lastKey ? ' ' : '│'}`);
       }
     }
   }
diff --git a/packages/aws-cdk/lib/api/cloudformation-deployments.ts b/packages/aws-cdk/lib/api/cloudformation-deployments.ts
index a4438ff0ca8f7..21933c955b3b8 100644
--- a/packages/aws-cdk/lib/api/cloudformation-deployments.ts
+++ b/packages/aws-cdk/lib/api/cloudformation-deployments.ts
@@ -1,5 +1,8 @@
+import * as path from 'path';
 import * as cxapi from '@aws-cdk/cx-api';
 import { AssetManifest } from 'cdk-assets';
+import * as fs from 'fs-extra';
+import { LazyListStackResources, ListStackResources } from '../api/evaluate-cloudformation-template';
 import { Tag } from '../cdk-toolkit';
 import { debug, warning } from '../logging';
 import { publishAssets } from '../util/asset-publishing';
@@ -293,25 +296,20 @@ export class CloudFormationDeployments {
     this.sdkProvider = props.sdkProvider;
   }
 
-  public async readCurrentTemplate(stackArtifact: cxapi.CloudFormationStackArtifact): Promise<Template> {
-    debug(`Reading existing template for stack ${stackArtifact.displayName}.`);
-    let stackSdk: ISDK | undefined = undefined;
-    // try to assume the lookup role and fallback to the deploy role
-    try {
-      const result = await prepareSdkWithLookupRoleFor(this.sdkProvider, stackArtifact);
-      if (result.didAssumeRole) {
-        stackSdk = result.sdk;
-      }
-    } catch { }
+  public async readCurrentTemplateWithNestedStacks(rootStackArtifact: cxapi.CloudFormationStackArtifact): Promise<Template> {
+    const sdk = await this.prepareSdkForLookup(rootStackArtifact);
+    const deployedTemplate = await this.readCurrentTemplate(rootStackArtifact, sdk);
+    await this.replaceNestedStacksInRootStack(rootStackArtifact, deployedTemplate, sdk);
 
-    if (!stackSdk) {
-      stackSdk = (await this.prepareSdkFor(stackArtifact, undefined, Mode.ForReading)).stackSdk;
-    }
+    return deployedTemplate;
+  }
 
-    const cfn = stackSdk.cloudFormation();
+  public async readCurrentTemplate(stackArtifact: cxapi.CloudFormationStackArtifact, sdk?: ISDK): Promise<Template> {
+    if (!sdk) {
+      sdk = await this.prepareSdkForLookup(stackArtifact);
+    }
 
-    const stack = await CloudFormationStack.lookup(cfn, stackArtifact.stackName);
-    return stack.template();
+    return this.readCurrentStackTemplate(stackArtifact, stackArtifact.stackName, sdk);
   }
 
   public async deployStack(options: DeployStackOptions): Promise<DeployStackResult> {
@@ -372,6 +370,114 @@ export class CloudFormationDeployments {
     return stack.exists;
   }
 
+  private async readCurrentStackTemplate(stackArtifact: cxapi.CloudFormationStackArtifact, stackName: string, stackSdk: ISDK) : Promise<Template> {
+    // if `stackName !== stackArtifact.stackName`, then `stackArtifact` is an ancestor to a nested stack with name `stackName`.
+    debug(`Reading existing template for stack ${stackArtifact.displayName}.`);
+    const cfn = stackSdk.cloudFormation();
+    const stack = await CloudFormationStack.lookup(cfn, stackName);
+
+    return stack.template();
+  }
+
+  private async prepareSdkForLookup(stackArtifact: cxapi.CloudFormationStackArtifact): Promise<ISDK> {
+    let stackSdk: ISDK | undefined = undefined;
+    // try to assume the lookup role and fallback to the deploy role
+    try {
+      const result = await prepareSdkWithLookupRoleFor(this.sdkProvider, stackArtifact);
+      if (result.didAssumeRole) {
+        stackSdk = result.sdk;
+      }
+    } catch { }
+
+    if (!stackSdk) {
+      stackSdk = (await this.prepareSdkFor(stackArtifact, undefined, Mode.ForReading)).stackSdk;
+    }
+
+    return stackSdk;
+  }
+
+  private async replaceNestedStacksInRootStack(
+    rootStackArtifact: cxapi.CloudFormationStackArtifact, deployedTemplate: any, sdk: ISDK,
+  ): Promise<void> {
+    await this.replaceNestedStacksInParentTemplate(
+      rootStackArtifact, rootStackArtifact.template, deployedTemplate, rootStackArtifact.stackName, sdk,
+    );
+  }
+
+  private async replaceNestedStacksInParentTemplate(
+    rootStackArtifact: cxapi.CloudFormationStackArtifact,
+    generatedParentTemplate: any,
+    deployedParentTemplate: any,
+    parentStackName: string | undefined,
+    sdk: ISDK,
+  ): Promise<void> {
+    const listStackResources = parentStackName ? new LazyListStackResources(sdk, parentStackName) : undefined;
+
+    const parentNestedStackResources = Object.entries(generatedParentTemplate.Resources ?? {});
+    for (const [nestedStackLogicalId, resource] of parentNestedStackResources) {
+      if (!this.isCdkManagedNestedStack(resource)) {
+        continue;
+      }
+
+      const nestedStackResource: NestedStackResource = resource;
+      const assetPath = nestedStackResource.Metadata['aws:asset:path'];
+      const nestedStackTemplates = await this.getNestedStackTemplates(
+        rootStackArtifact, assetPath, nestedStackLogicalId, parentStackName, listStackResources, sdk,
+      );
+
+      generatedParentTemplate.Resources[nestedStackLogicalId].NestedTemplate = nestedStackTemplates.generatedNestedTemplate;
+      //generatedParentTemplate.Resources[nestedStackLogicalId].Type = 'AWS::CloudFormation::Stack';
+
+      if (deployedParentTemplate.Resources) {
+        deployedParentTemplate.Resources[nestedStackLogicalId].NestedTemplate = nestedStackTemplates.deployedNestedTemplate;
+        //deployedParentTemplate.Resources[nestedStackLogicalId].Type = 'AWS::CloudFormation::Stack';
+      }
+
+      await this.replaceNestedStacksInParentTemplate(
+        rootStackArtifact,
+        generatedParentTemplate.Resources[nestedStackLogicalId],
+        (deployedParentTemplate.Resources ?? {})[nestedStackLogicalId] ?? {},
+        nestedStackTemplates.nestedStackName,
+        sdk,
+      );
+    }
+  }
+
+  private async getNestedStackTemplates(
+    rootStackArtifact: cxapi.CloudFormationStackArtifact, nestedTemplateAssetPath: string, nestedStackLogicalId: string,
+    parentStackName: string | undefined, listStackResources: ListStackResources | undefined, sdk: ISDK,
+  ): Promise<NestedStackTemplates> {
+    const nestedTemplatePath = path.join(rootStackArtifact.assembly.directory, nestedTemplateAssetPath);
+    // CFN generates the nested stack name in the form `ParentStackName-NestedStackLogicalID-SomeHashWeCan'tCompute,
+    // so we get the ARN and manually extract the name.
+    //const nestedStackArn = (await listStackResources?.listStackResources())?.find(sr => sr.LogicalResourceId === nestedStackLogicalId)?.PhysicalResourceId;
+    let nestedStackArn: string | undefined = undefined;
+
+    try {
+      const stackResources = await listStackResources?.listStackResources();
+
+      if (stackResources) {
+        nestedStackArn = stackResources.find(sr => sr.LogicalResourceId === nestedStackLogicalId)?.PhysicalResourceId;
+      }
+    } catch (e) {
+      if (e.message !== `Stack with id ${parentStackName} does not exist`) {
+        throw e;
+      }
+    }
+    const nestedStackName = nestedStackArn?.slice(nestedStackArn.indexOf('/') + 1, nestedStackArn.lastIndexOf('/'));
+
+    return {
+      generatedNestedTemplate: JSON.parse(fs.readFileSync(nestedTemplatePath, 'utf-8')),
+      deployedNestedTemplate: nestedStackName
+        ? await this.readCurrentStackTemplate(rootStackArtifact, nestedStackName, sdk) : { Resources: {} },
+      nestedStackName,
+    };
+  }
+
+  private isCdkManagedNestedStack(stackResource: any): stackResource is NestedStackResource {
+    return stackResource.Type === 'AWS::CloudFormation::Stack' && stackResource.Metadata && stackResource.Metadata['aws:asset:path'];
+  }
+
   /**
    * Get the environment necessary for touching the given stack
    *
@@ -453,3 +559,13 @@ export class CloudFormationDeployments {
 function isAssetManifestArtifact(art: cxapi.CloudArtifact): art is cxapi.AssetManifestArtifact {
   return art instanceof cxapi.AssetManifestArtifact;
 }
+
+interface NestedStackTemplates {
+  readonly generatedNestedTemplate: any,
+  readonly deployedNestedTemplate: any,
+  readonly nestedStackName: string | undefined,
+}
+
+interface NestedStackResource {
+  readonly Metadata: { 'aws:asset:path': string };
+}
diff --git a/packages/aws-cdk/lib/api/hotswap-deployments.ts b/packages/aws-cdk/lib/api/hotswap-deployments.ts
index da46369aa79c9..aebeae1058b34 100644
--- a/packages/aws-cdk/lib/api/hotswap-deployments.ts
+++ b/packages/aws-cdk/lib/api/hotswap-deployments.ts
@@ -234,4 +234,3 @@ async function applyHotswappableChange(sdk: ISDK, hotswapOperation: HotswapOpera
     sdk.removeCustomUserAgent(customUserAgent);
   }
 }
-
diff --git a/packages/aws-cdk/lib/cdk-toolkit.ts b/packages/aws-cdk/lib/cdk-toolkit.ts
index 141dbb2f7c3f4..56c5302544a84 100644
--- a/packages/aws-cdk/lib/cdk-toolkit.ts
+++ b/packages/aws-cdk/lib/cdk-toolkit.ts
@@ -1,8 +1,8 @@
 import * as path from 'path';
 import { format } from 'util';
 import * as cxapi from '@aws-cdk/cx-api';
-import * as chokidar from 'chokidar';
 import * as chalk from 'chalk';
+import * as chokidar from 'chokidar';
 import * as fs from 'fs-extra';
 import * as promptly from 'promptly';
 import { environmentsFromDescriptors, globEnvironmentsFromStacks, looksLikeGlob } from '../lib/api/cxapp/environments';
@@ -104,7 +104,7 @@ export class CdkToolkit {
       // Compare N stacks against deployed templates
       for (const stack of stacks.stackArtifacts) {
         stream.write(format('Stack %s\n', chalk.bold(stack.displayName)));
-        const currentTemplate = await this.props.cloudFormation.readCurrentTemplate(stack);
+        const currentTemplate = await this.props.cloudFormation.readCurrentTemplateWithNestedStacks(stack);
         diffs += options.securityOnly
           ? numberFromBool(printSecurityDiff(currentTemplate, stack, RequireApproval.Broadening))
           : printStackDiff(currentTemplate, stack, strict, contextLines, stream);
diff --git a/packages/aws-cdk/test/api/cloudformation-deployments.test.ts b/packages/aws-cdk/test/api/cloudformation-deployments.test.ts
index f89518e8858e0..45be364b5305e 100644
--- a/packages/aws-cdk/test/api/cloudformation-deployments.test.ts
+++ b/packages/aws-cdk/test/api/cloudformation-deployments.test.ts
@@ -1,18 +1,37 @@
 jest.mock('../../lib/api/deploy-stack');
 
+import { CloudFormation } from 'aws-sdk';
 import { CloudFormationDeployments } from '../../lib/api/cloudformation-deployments';
 import { deployStack } from '../../lib/api/deploy-stack';
 import { ToolkitInfo } from '../../lib/api/toolkit-info';
-import { testStack } from '../util';
+import { CloudFormationStack } from '../../lib/api/util/cloudformation';
+import { instanceMockFrom, testStack } from '../util';
 import { mockBootstrapStack, MockSdkProvider } from '../util/mock-sdk';
 
 let sdkProvider: MockSdkProvider;
 let deployments: CloudFormationDeployments;
 let mockToolkitInfoLookup: jest.Mock;
+let currentCfnStackResources: { [key: string]: CloudFormation.StackResourceSummary[] };
+let numberOfTimesListStackResourcesWasCalled: number;
 beforeEach(() => {
   jest.resetAllMocks();
   sdkProvider = new MockSdkProvider();
   deployments = new CloudFormationDeployments({ sdkProvider });
+
+  numberOfTimesListStackResourcesWasCalled = 0;
+  currentCfnStackResources = {};
+  sdkProvider.stubCloudFormation({
+    listStackResources: ({ StackName: stackName }) => {
+      numberOfTimesListStackResourcesWasCalled++;
+      if (!currentCfnStackResources[stackName]) {
+        throw new Error(`Stack with id ${stackName} does not exist`);
+      }
+      return {
+        StackResourceSummaries: currentCfnStackResources[stackName],
+      };
+    },
+  });
+
   ToolkitInfo.lookup = mockToolkitInfoLookup = jest.fn().mockResolvedValue(ToolkitInfo.bootstrapStackNotFoundInfo(sdkProvider.sdk));
 });
 
@@ -142,3 +161,713 @@ test('if toolkit stack cannot be found but SSM parameter name is present deploym
 
   expect(requestedParameterName!).toEqual('/some/parameter');
 });
+
+test('readCurrentTemplateWithNestedStacks() can handle non-Resources in the template', async () => {
+  const cfnStack = instanceMockFrom((CloudFormationStack as any));
+  CloudFormationStack.lookup = jest.fn().mockImplementation((_, stackName: string) => {
+    switch (stackName) {
+      case 'OutputParamRoot':
+        (cfnStack as any).template = jest.fn().mockReturnValue({
+          Resources: {
+            NestedStack: {
+              Type: 'AWS::CloudFormation::Stack',
+              Metadata: {
+                'aws:asset:path': 'one-output-one-param-stack.nested.template.json',
+              },
+            },
+          },
+        });
+        break;
+
+      case 'NestedStack':
+        (cfnStack as any).template = jest.fn().mockReturnValue({
+          Resources: {
+            NestedResource: {
+              Type: 'AWS::Something',
+              Properties: {
+                Property: 'old-value',
+              },
+            },
+          },
+          Parameters: {
+            NestedParam: {
+              Type: 'String',
+            },
+          },
+          Outputs: {
+            NestedOutput: {
+              Value: {
+                Ref: 'NestedResource',
+              },
+            },
+          },
+        });
+        break;
+
+      default:
+        throw new Error('unknown stack name ' + stackName + ' found in cloudformation-deployments.test.ts');
+    }
+
+    return cfnStack;
+  });
+
+  const rootStack = testStack({
+    stackName: 'OutputParamRoot',
+    template: {
+      Resources: {
+        NestedStack: {
+          Type: 'AWS::CloudFormation::Stack',
+          Metadata: {
+            'aws:asset:path': 'one-output-one-param-stack.nested.template.json',
+          },
+        },
+      },
+    },
+  });
+
+  pushStackResourceSummaries('OutputParamRoot',
+    stackSummaryOf('NestedStack', 'AWS::CloudFormation::Stack',
+      'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/NestedStack/abcd',
+    ),
+  );
+  pushStackResourceSummaries('NestedStack',
+    stackSummaryOf('NestedResource', 'AWS::Something',
+      'arn:aws:something:bermuda-triangle-1337:123456789012:property',
+    ),
+  );
+
+  // WHEN
+  const deployedTemplate = await deployments.readCurrentTemplateWithNestedStacks(rootStack);
+
+  // THEN
+  expect(deployedTemplate).toEqual({
+    Resources: {
+      NestedStack: {
+        Type: 'AWS::CloudFormation::Stack',
+        Resources: {
+          NestedResource: {
+            Type: 'AWS::Something',
+            Properties: {
+              Property: 'old-value',
+            },
+          },
+        },
+        Outputs: {
+          NestedOutput: {
+            Value: {
+              Ref: 'NestedResource',
+            },
+          },
+        },
+        Parameters: {
+          NestedParam: {
+            Type: 'String',
+          },
+        },
+      },
+    },
+  });
+
+  expect(rootStack.template).toEqual({
+    Resources: {
+      NestedStack: {
+        Type: 'AWS::CloudFormation::Stack',
+        Resources: {
+          NestedResource: {
+            Type: 'AWS::Something',
+            Properties: {
+              Property: 'new-value',
+            },
+          },
+        },
+        Outputs: {
+          NestedOutput: {
+            Value: {
+              Ref: 'NestedResource',
+            },
+          },
+        },
+        Parameters: {
+          NestedParam: {
+            Type: 'Number',
+          },
+        },
+      },
+    },
+  });
+});
+
+test('readCurrentTemplateWithNestedStacks() with a 3-level nested + sibling structure works', async () => {
+  const cfnStack = instanceMockFrom((CloudFormationStack as any));
+  CloudFormationStack.lookup = jest.fn().mockImplementation((_, stackName: string) => {
+    switch (stackName) {
+      case 'MultiLevelRoot':
+        (cfnStack as any).template = jest.fn().mockReturnValue({
+          Resources: {
+            NestedStack: {
+              Type: 'AWS::CloudFormation::Stack',
+              Metadata: {
+                'aws:asset:path': 'one-resource-two-stacks-stack.nested.template.json',
+              },
+            },
+          },
+        });
+        break;
+
+      case 'NestedStack':
+        (cfnStack as any).template = jest.fn().mockReturnValue({
+          Resources: {
+            SomeResource: {
+              Type: 'AWS::Something',
+              Properties: {
+                Property: 'old-value',
+              },
+            },
+            NestedStackA: {
+              Type: 'AWS::CloudFormation::Stack',
+              Metadata: {
+                'aws:asset:path': 'one-resource-stack.nested.template.json',
+              },
+            },
+            NestedStackB: {
+              Type: 'AWS::CloudFormation::Stack',
+              Metadata: {
+                'aws:asset:path': 'one-resource-stack.nested.template.json',
+              },
+            },
+          },
+        });
+        break;
+
+      case 'NestedStackA':
+        (cfnStack as any).template = jest.fn().mockReturnValue({
+          Resources: {
+            SomeResource: {
+              Type: 'AWS::Something',
+              Properties: {
+                Property: 'old-value',
+              },
+            },
+          },
+        });
+        break;
+
+      case 'NestedStackB':
+        (cfnStack as any).template = jest.fn().mockReturnValue({
+          Resources: {
+            SomeResource: {
+              Type: 'AWS::Something',
+              Properties: {
+                Property: 'old-value',
+              },
+            },
+          },
+        });
+        break;
+
+      default:
+        throw new Error('unknown stack name ' + stackName + ' found in cloudformation-deployments.test.ts');
+    }
+
+    return cfnStack;
+  });
+
+  const rootStack = testStack({
+    stackName: 'MultiLevelRoot',
+    template: {
+      Resources: {
+        NestedStack: {
+          Type: 'AWS::CloudFormation::Stack',
+          Metadata: {
+            'aws:asset:path': 'one-resource-two-stacks-stack.nested.template.json',
+          },
+        },
+      },
+    },
+  });
+
+  pushStackResourceSummaries('MultiLevelRoot',
+    stackSummaryOf('NestedStack', 'AWS::CloudFormation::Stack',
+      'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/NestedStack/abcd',
+    ),
+  );
+  pushStackResourceSummaries('NestedStack',
+    stackSummaryOf('NestedStackA', 'AWS::CloudFormation::Stack',
+      'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/NestedStackA/abcd',
+    ),
+    stackSummaryOf('NestedStackB', 'AWS::CloudFormation::Stack',
+      'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/NestedStackB/abcd',
+    ),
+    stackSummaryOf('SomeResource', 'AWS::Something',
+      'arn:aws:something:bermuda-triangle-1337:123456789012:property',
+    ),
+  );
+  pushStackResourceSummaries('NestedStackA',
+    stackSummaryOf('NestedStack', 'AWS::CloudFormation::Stack',
+      'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/GrandChildA/abcd',
+    ),
+  );
+  pushStackResourceSummaries('NestedStackB',
+    stackSummaryOf('NestedStack', 'AWS::CloudFormation::Stack',
+      'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/GrandChildB/abcd',
+    ),
+  );
+  pushStackResourceSummaries('GrandChildA',
+    stackSummaryOf('SomeResource', 'AWS::Something',
+      'arn:aws:something:bermuda-triangle-1337:123456789012:property',
+    ),
+  );
+  pushStackResourceSummaries('GrandChildB',
+    stackSummaryOf('SomeResource', 'AWS::Something',
+      'arn:aws:something:bermuda-triangle-1337:123456789012:property',
+    ),
+  );
+
+  // WHEN
+  const deployedTemplate = await deployments.readCurrentTemplateWithNestedStacks(rootStack);
+
+  // THEN
+  expect(deployedTemplate).toEqual({
+    Resources: {
+      NestedStack: {
+        Type: 'AWS::CloudFormation::Stack',
+        Resources: {
+          NestedStackA: {
+            Type: 'AWS::CloudFormation::Stack',
+            Resources: {
+              SomeResource: {
+                Type: 'AWS::Something',
+                Properties: {
+                  Property: 'old-value',
+                },
+              },
+            },
+          },
+          NestedStackB: {
+            Type: 'AWS::CloudFormation::Stack',
+            Resources: {
+              SomeResource: {
+                Type: 'AWS::Something',
+                Properties: {
+                  Property: 'old-value',
+                },
+              },
+            },
+          },
+          SomeResource: {
+            Type: 'AWS::Something',
+            Properties: {
+              Property: 'old-value',
+            },
+          },
+        },
+      },
+    },
+  });
+
+  expect(rootStack.template).toEqual({
+    Resources: {
+      NestedStack: {
+        Type: 'AWS::CloudFormation::Stack',
+        Resources: {
+          NestedStackA: {
+            Type: 'AWS::CloudFormation::Stack',
+            Resources: {
+              SomeResource: {
+                Type: 'AWS::Something',
+                Properties: {
+                  Property: 'new-value',
+                },
+              },
+            },
+          },
+          NestedStackB: {
+            Type: 'AWS::CloudFormation::Stack',
+            Resources: {
+              SomeResource: {
+                Type: 'AWS::Something',
+                Properties: {
+                  Property: 'new-value',
+                },
+              },
+            },
+          },
+          SomeResource: {
+            Type: 'AWS::Something',
+            Properties: {
+              Property: 'new-value',
+            },
+          },
+        },
+      },
+    },
+  });
+});
+
+test('readCurrentTemplateWithNestedStacks() on an undeployed parent stack with an (also undeployed) nested stack works', async () => {
+  // GIVEN
+  const cfnStack = instanceMockFrom((CloudFormationStack as any));
+  CloudFormationStack.lookup = jest.fn().mockImplementation((_cfn: CloudFormation, _stackName: string) => {
+    (cfnStack as any).template = jest.fn().mockReturnValue({ });
+
+    return cfnStack;
+  });
+  const rootStack = testStack({
+    stackName: 'UndeployedParent',
+    template: {
+      Resources: {
+        NestedStack: {
+          Type: 'AWS::CloudFormation::Stack',
+          Metadata: {
+            'aws:asset:path': 'one-resource-one-stack-stack.nested.template.json',
+          },
+        },
+      },
+    },
+  });
+
+  // WHEN
+  const deployedTemplate = await deployments.readCurrentTemplateWithNestedStacks(rootStack);
+
+  // THEN
+  expect(deployedTemplate).toEqual({});
+});
+
+test('readCurrentTemplateWithNestedStacks() caches calls to listStackResources()', async () => {
+  // GIVEN
+  const cfnStack = instanceMockFrom((CloudFormationStack as any));
+  CloudFormationStack.lookup = jest.fn().mockImplementation((_cfn: CloudFormation, _stackName: string) => {
+    (cfnStack as any).template = jest.fn().mockReturnValue({
+      Resources:
+      {
+        NestedStackA: {
+          Type: 'AWS::CloudFormation::Stack',
+          Metadata: {
+            'aws:asset:path': 'one-resource-stack.nested.template.json',
+          },
+        },
+        NestedStackB: {
+          Type: 'AWS::CloudFormation::Stack',
+          Metadata: {
+            'aws:asset:path': 'one-resource-stack.nested.template.json',
+          },
+        },
+      },
+    });
+
+    return cfnStack;
+  });
+
+  const rootStack = testStack({
+    stackName: 'CachingRoot',
+    template: {
+      Resources: {
+        NestedStackA: {
+          Type: 'AWS::CloudFormation::Stack',
+          Metadata: {
+            'aws:asset:path': 'one-resource-stack.nested.template.json',
+          },
+        },
+        NestedStackB: {
+          Type: 'AWS::CloudFormation::Stack',
+          Metadata: {
+            'aws:asset:path': 'one-resource-stack.nested.template.json',
+          },
+        },
+      },
+    },
+  });
+
+  pushStackResourceSummaries('CachingRoot',
+    stackSummaryOf('NestedStackA', 'AWS::CloudFormation::Stack',
+      'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/one-resource-stack/abcd',
+    ),
+    stackSummaryOf('NestedStackB', 'AWS::CloudFormation::Stack',
+      'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/one-resource-stack/abcd',
+    ),
+  );
+
+  // WHEN
+  await deployments.readCurrentTemplateWithNestedStacks(rootStack);
+
+  // THEN
+  expect(numberOfTimesListStackResourcesWasCalled).toEqual(1);
+});
+
+test('readCurrentTemplateWithNestedStacks() succesfully ignores stacks without metadata', async () => {
+  // GIVEN
+  const cfnStack = instanceMockFrom((CloudFormationStack as any));
+  CloudFormationStack.lookup = jest.fn().mockImplementation((_cfn: CloudFormation, stackName: string) => {
+    if (stackName === 'MetadataRoot') {
+      (cfnStack as any).template = jest.fn().mockReturnValue({
+        Resources: {
+          WithMetadata: {
+            Type: 'AWS::CloudFormation::Stack',
+            Metadata: {
+              'aws:asset:path': 'one-resource-stack.nested.template.json',
+            },
+          },
+        },
+      });
+
+    } else {
+      (cfnStack as any).template = jest.fn().mockReturnValue({
+        Resources: {
+          SomeResource: {
+            Type: 'AWS::Something',
+            Properties: {
+              Property: 'old-value',
+            },
+          },
+        },
+      });
+    }
+
+    return cfnStack;
+  });
+
+  const rootStack = testStack({
+    stackName: 'MetadataRoot',
+    template: {
+      Resources: {
+        WithoutMetadata: {
+          Type: 'AWS::CloudFormation::Stack',
+        },
+        WithEmptyMetadata: {
+          Type: 'AWS::CloudFormation::Stack',
+          Metadata: {},
+        },
+        WithMetadata: {
+          Type: 'AWS::CloudFormation::Stack',
+          Metadata: {
+            'aws:asset:path': 'one-resource-stack.nested.template.json',
+          },
+        },
+      },
+    },
+  });
+
+  pushStackResourceSummaries('MetadataRoot', stackSummaryOf('WithMetadata', 'AWS::CloudFormation::Stack',
+    'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/one-resource-stack/abcd',
+  ));
+
+  // WHEN
+  const deployedTemplate = await deployments.readCurrentTemplateWithNestedStacks(rootStack);
+
+  // THEN
+  expect(deployedTemplate).toEqual({
+    Resources: {
+      WithMetadata: {
+        Type: 'AWS::CloudFormation::Stack',
+        Resources: {
+          SomeResource: {
+            Type: 'AWS::Something',
+            Properties: {
+              Property: 'old-value',
+            },
+          },
+        },
+      },
+    },
+  });
+
+  expect(rootStack.template).toEqual({
+    Resources: {
+      WithoutMetadata: { // Unchanged
+        Type: 'AWS::CloudFormation::Stack',
+      },
+      WithEmptyMetadata: { // Unchanged
+        Type: 'AWS::CloudFormation::Stack',
+        Metadata: {},
+      },
+      WithMetadata: { // Changed
+        Type: 'AWS::CloudFormation::Stack',
+        Resources: {
+          SomeResource: {
+            Type: 'AWS::Something',
+            Properties: {
+              Property: 'new-value',
+            },
+          },
+        },
+      },
+    },
+  });
+});
+
+test('readCurrentTemplateWithNestedStacks() does not erase the AWS::CloudFormation::Stack resource properties', async () => {
+  // GIVEN
+  const cfnStack = instanceMockFrom((CloudFormationStack as any));
+  CloudFormationStack.lookup = jest.fn().mockImplementation((_cfn: CloudFormation, stackName: string) => {
+    if (stackName === 'Root') {
+      (cfnStack as any).template = jest.fn().mockReturnValue({
+        Resources: {
+          WithProperties: {
+            Type: 'AWS::CloudFormation::Stack',
+            Properties: {
+              TimeoutInMinutes: 5,
+            },
+            Metadata: {
+              'aws:asset:path': 'one-resource-stack.nested.template.json',
+            },
+          },
+        },
+      });
+
+    } else {
+      (cfnStack as any).template = jest.fn().mockReturnValue({
+        Resources: {
+          SomeResource: {
+            Type: 'AWS::Something',
+            Properties: {
+              Property: 'old-value',
+            },
+          },
+        },
+      });
+    }
+
+    return cfnStack;
+  });
+
+  const rootStack = testStack({
+    stackName: 'Root',
+    template: {
+      Resources: {
+        WithProperties: {
+          Type: 'AWS::CloudFormation::Stack',
+          Properties: {
+            TimeoutInMinutes: 5,
+          },
+          Metadata: {
+            'aws:asset:path': 'one-resource-stack.nested.template.json',
+          },
+        },
+      },
+    },
+  });
+
+  pushStackResourceSummaries('Root', stackSummaryOf('WithProperties', 'AWS::CloudFormation::Stack',
+    'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/one-resource-stack/abcd',
+  ));
+
+  // WHEN
+  const deployedTemplate = await deployments.readCurrentTemplateWithNestedStacks(rootStack);
+
+  // THEN
+  expect(deployedTemplate).toEqual({
+    Resources: {
+      WithProperties: {
+        Type: 'AWS::CloudFormation::Stack',
+        Properties: {
+          TimeoutInMinutes: 5,
+        },
+        NestedTemplate: {
+          Resources: {
+            SomeResource: {
+              Type: 'AWS::Something',
+              Properties: {
+                Property: 'old-value',
+              },
+            },
+          },
+        },
+      },
+    },
+  });
+
+  expect(rootStack.template).toEqual({
+    Resources: {
+      WithProperties: {
+        Type: 'AWS::CloudFormation::Stack',
+        Properties: {
+          TimeoutInMinutes: 5,
+        },
+        NestedTemplate: {
+          Resources: {
+            SomeResource: {
+              Type: 'AWS::Something',
+              Properties: {
+                Property: 'new-value',
+              },
+            },
+          },
+        },
+      },
+    },
+  });
+});
+
+/*test('ListStackResources() does not swallow all errors', async () => {
+  // GIVEN
+  const cfnStack = instanceMockFrom((CloudFormationStack as any));
+  CloudFormationStack.lookup = jest.fn().mockImplementation((_cfn: CloudFormation, stackName: string) => {
+    if (stackName === 'Root') {
+      (cfnStack as any).template = jest.fn().mockReturnValue({
+        Resources: {
+          ChildStack: {
+            Type: 'AWS::CloudFormation::Stack',
+            Metadata: {
+              'aws:asset:path': 'one-resource-stack.nested.template.json',
+            },
+          },
+        },
+      });
+    } else {
+      (cfnStack as any).template = jest.fn().mockReturnValue({
+        Resources: {
+          SomeResource: {
+            Type: 'AWS::Something',
+            Properties: {
+              Property: 'old-value',
+            },
+          },
+        },
+      });
+    }
+
+    return cfnStack;
+  });
+
+  sdkProvider.stubCloudFormation({
+    listStackResources: ({ StackName: stackName }) => {
+      throw new Error(`A different error involving stack ${stackName} occurred`);
+    },
+  });
+  const rootStack = testStack({
+    stackName: 'Root',
+    template: {
+      Resources: {
+        ChildStack: {
+          Type: 'AWS::CloudFormation::Stack',
+          Metadata: {
+            'aws:asset:path': 'one-resource-stack.nested.template.json',
+          },
+        },
+      },
+    },
+  });
+
+  // THEN
+  expect(await deployments.readCurrentTemplateWithNestedStacks(rootStack)).toThrow('A different error involving stack Root occurred');
+
+});
+*/
+
+function pushStackResourceSummaries(stackName: string, ...items: CloudFormation.StackResourceSummary[]) {
+  if (!currentCfnStackResources[stackName]) {
+    currentCfnStackResources[stackName] = [];
+  }
+
+  currentCfnStackResources[stackName].push(...items);
+}
+
+function stackSummaryOf(logicalId: string, resourceType: string, physicalResourceId: string): CloudFormation.StackResourceSummary {
+  return {
+    LogicalResourceId: logicalId,
+    PhysicalResourceId: physicalResourceId,
+    ResourceType: resourceType,
+    ResourceStatus: 'CREATE_COMPLETE',
+    LastUpdatedTimestamp: new Date(),
+  };
+}
diff --git a/packages/aws-cdk/test/diff-nested-stacks-templates/one-output-one-param-stack.nested.template.json b/packages/aws-cdk/test/diff-nested-stacks-templates/one-output-one-param-stack.nested.template.json
new file mode 100644
index 0000000000000..a86df6dfe5f29
--- /dev/null
+++ b/packages/aws-cdk/test/diff-nested-stacks-templates/one-output-one-param-stack.nested.template.json
@@ -0,0 +1,20 @@
+{
+  "Resources": {
+    "NestedResource": {
+      "Type": "AWS::Something",
+      "Properties": {
+        "Property": "new-value"
+      }
+    }
+  },
+  "Parameters": {
+    "NestedParam": {
+      "Type": "Number"
+    }
+  },
+  "Outputs": {
+    "NestedOutput": {
+      "Value": { "Ref": "NestedResource" }
+    }
+  }
+}
diff --git a/packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-one-stack-stack.nested.template.json b/packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-one-stack-stack.nested.template.json
new file mode 100644
index 0000000000000..c3806df003850
--- /dev/null
+++ b/packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-one-stack-stack.nested.template.json
@@ -0,0 +1,16 @@
+{
+  "Resources": {
+    "SomeResource": {
+      "Type": "AWS::Something",
+      "Properties": {
+        "Property": "new-value"
+      }
+    },
+    "NestedStack": {
+      "Type": "AWS::CloudFormation::Stack",
+      "Metadata": {
+        "aws:asset:path": "one-resource-stack.nested.template.json"
+      }
+    }
+  }
+}
diff --git a/packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-stack.nested.template.json b/packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-stack.nested.template.json
new file mode 100644
index 0000000000000..f288b015bbf83
--- /dev/null
+++ b/packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-stack.nested.template.json
@@ -0,0 +1,10 @@
+{
+  "Resources": {
+    "SomeResource": {
+      "Type": "AWS::Something",
+      "Properties": {
+        "Property": "new-value"
+      }
+    }
+  }
+}
diff --git a/packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-two-stacks-stack.nested.template.json b/packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-two-stacks-stack.nested.template.json
new file mode 100644
index 0000000000000..1e2e4405391ea
--- /dev/null
+++ b/packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-two-stacks-stack.nested.template.json
@@ -0,0 +1,22 @@
+{
+  "Resources": {
+    "SomeResource": {
+      "Type": "AWS::Something",
+      "Properties": {
+        "Property": "new-value"
+      }
+    },
+    "NestedStackA": {
+      "Type": "AWS::CloudFormation::Stack",
+      "Metadata": {
+        "aws:asset:path": "one-resource-stack.nested.template.json"
+      }
+    },
+    "NestedStackB": {
+      "Type": "AWS::CloudFormation::Stack",
+      "Metadata": {
+        "aws:asset:path": "one-resource-stack.nested.template.json"
+      }
+    }
+  }
+}
diff --git a/packages/aws-cdk/test/diff.test.ts b/packages/aws-cdk/test/diff.test.ts
index 829c24d637ca9..d02795a8e6153 100644
--- a/packages/aws-cdk/test/diff.test.ts
+++ b/packages/aws-cdk/test/diff.test.ts
@@ -9,126 +9,256 @@ import { instanceMockFrom, MockCloudExecutable } from './util';
 let cloudExecutable: MockCloudExecutable;
 let cloudFormation: jest.Mocked<CloudFormationDeployments>;
 let toolkit: CdkToolkit;
-beforeEach(() => {
-  cloudExecutable = new MockCloudExecutable({
-    stacks: [{
-      stackName: 'A',
-      template: { resource: 'A' },
-    },
-    {
-      stackName: 'B',
-      depends: ['A'],
-      template: { resource: 'B' },
-    },
-    {
-      stackName: 'C',
-      depends: ['A'],
-      template: { resource: 'C' },
-      metadata: {
-        '/resource': [
-          {
-            type: cxschema.ArtifactMetadataEntryType.ERROR,
-            data: 'this is an error',
-          },
-        ],
+
+describe('non-nested stacks', () => {
+  beforeEach(() => {
+    cloudExecutable = new MockCloudExecutable({
+      stacks: [{
+        stackName: 'A',
+        template: { resource: 'A' },
       },
-    },
-    {
-      stackName: 'D',
-      template: { resource: 'D' },
-    }],
-  });
+      {
+        stackName: 'B',
+        depends: ['A'],
+        template: { resource: 'B' },
+      },
+      {
+        stackName: 'C',
+        depends: ['A'],
+        template: { resource: 'C' },
+        metadata: {
+          '/resource': [
+            {
+              type: cxschema.ArtifactMetadataEntryType.ERROR,
+              data: 'this is an error',
+            },
+          ],
+        },
+      },
+      {
+        stackName: 'D',
+        template: { resource: 'D' },
+      }],
+    });
+
+    cloudFormation = instanceMockFrom(CloudFormationDeployments);
 
-  cloudFormation = instanceMockFrom(CloudFormationDeployments);
+    toolkit = new CdkToolkit({
+      cloudExecutable,
+      cloudFormation,
+      configuration: cloudExecutable.configuration,
+      sdkProvider: cloudExecutable.sdkProvider,
+    });
 
-  toolkit = new CdkToolkit({
-    cloudExecutable,
-    cloudFormation,
-    configuration: cloudExecutable.configuration,
-    sdkProvider: cloudExecutable.sdkProvider,
+    // Default implementations
+    cloudFormation.readCurrentTemplateWithNestedStacks.mockImplementation((stackArtifact: CloudFormationStackArtifact) => {
+      if (stackArtifact.stackName === 'D') {
+        return Promise.resolve({ resource: 'D' });
+      }
+      return Promise.resolve({});
+    });
+    cloudFormation.deployStack.mockImplementation((options) => Promise.resolve({
+      noOp: true,
+      outputs: {},
+      stackArn: '',
+      stackArtifact: options.stack,
+    }));
   });
 
-  // Default implementations
-  cloudFormation.readCurrentTemplate.mockImplementation((stackArtifact: CloudFormationStackArtifact) => {
-    if (stackArtifact.stackName === 'D') {
-      return Promise.resolve({ resource: 'D' });
-    }
-    return Promise.resolve({});
+  test('diff can diff multiple stacks', async () => {
+    // GIVEN
+    const buffer = new StringWritable();
+
+    // WHEN
+    const exitCode = await toolkit.diff({
+      stackNames: ['B'],
+      stream: buffer,
+    });
+
+    // THEN
+    const plainTextOutput = buffer.data.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '');
+    expect(plainTextOutput).toContain('Stack A');
+    expect(plainTextOutput).toContain('Stack B');
+
+    expect(exitCode).toBe(0);
   });
-  cloudFormation.deployStack.mockImplementation((options) => Promise.resolve({
-    noOp: true,
-    outputs: {},
-    stackArn: '',
-    stackArtifact: options.stack,
-  }));
-});
 
-test('diff can diff multiple stacks', async () => {
-  // GIVEN
-  const buffer = new StringWritable();
+  test('exits with 1 with diffs and fail set to true', async () => {
+    // GIVEN
+    const buffer = new StringWritable();
+
+    // WHEN
+    const exitCode = await toolkit.diff({
+      stackNames: ['A'],
+      stream: buffer,
+      fail: true,
+    });
 
-  // WHEN
-  const exitCode = await toolkit.diff({
-    stackNames: ['B'],
-    stream: buffer,
+    // THEN
+    expect(exitCode).toBe(1);
   });
 
-  // THEN
-  const plainTextOutput = buffer.data.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '');
-  expect(plainTextOutput).toContain('Stack A');
-  expect(plainTextOutput).toContain('Stack B');
+  test('throws an error if no valid stack names given', async () => {
+    const buffer = new StringWritable();
 
-  expect(exitCode).toBe(0);
-});
+    // WHEN
+    await expect(() => toolkit.diff({
+      stackNames: ['X', 'Y', 'Z'],
+      stream: buffer,
+    })).rejects.toThrow('No stacks match the name(s) X,Y,Z');
+  });
+
+  test('exits with 1 with diff in first stack, but not in second stack and fail set to true', async () => {
+    // GIVEN
+    const buffer = new StringWritable();
 
-test('exits with 1 with diffs and fail set to true', async () => {
-  // GIVEN
-  const buffer = new StringWritable();
+    // WHEN
+    const exitCode = await toolkit.diff({
+      stackNames: ['A', 'D'],
+      stream: buffer,
+      fail: true,
+    });
 
-  // WHEN
-  const exitCode = await toolkit.diff({
-    stackNames: ['A'],
-    stream: buffer,
-    fail: true,
+    // THEN
+    expect(exitCode).toBe(1);
   });
 
-  // THEN
-  expect(exitCode).toBe(1);
+  test('throws an error during diffs on stack with error metadata', async () => {
+    const buffer = new StringWritable();
+
+    // WHEN
+    await expect(() => toolkit.diff({
+      stackNames: ['C'],
+      stream: buffer,
+    })).rejects.toThrow(/Found errors/);
+  });
 });
 
-test('throws an error if no valid stack names given', async () => {
-  const buffer = new StringWritable();
+describe('nested stacks', () => {
+  beforeEach(() => {
+    cloudExecutable = new MockCloudExecutable({
+      stacks: [{
+        stackName: 'Parent',
+        template: { },
+      }],
+    });
 
-  // WHEN
-  await expect(() => toolkit.diff({
-    stackNames: ['X', 'Y', 'Z'],
-    stream: buffer,
-  })).rejects.toThrow('No stacks match the name(s) X,Y,Z');
-});
+    cloudFormation = instanceMockFrom(CloudFormationDeployments);
 
-test('exits with 1 with diff in first stack, but not in second stack and fail set to true', async () => {
-  // GIVEN
-  const buffer = new StringWritable();
+    toolkit = new CdkToolkit({
+      cloudExecutable,
+      cloudFormation,
+      configuration: cloudExecutable.configuration,
+      sdkProvider: cloudExecutable.sdkProvider,
+    });
 
-  // WHEN
-  const exitCode = await toolkit.diff({
-    stackNames: ['A', 'D'],
-    stream: buffer,
-    fail: true,
+    cloudFormation.readCurrentTemplateWithNestedStacks.mockImplementation((stackArtifact: CloudFormationStackArtifact) => {
+      if (stackArtifact.stackName === 'Parent') {
+        stackArtifact.template.Resources = {
+          AdditionChild: {
+            Type: 'AWS::CloudFormation::Stack',
+            Resources: {
+              SomeResource: {
+                Type: 'AWS::Something',
+                Properties: {
+                  Prop: 'added-value',
+                },
+              },
+            },
+          },
+          DeletionChild: {
+            Type: 'AWS::CloudFormation::Stack',
+            Resources: {
+              SomeResource: {
+                Type: 'AWS::Something',
+              },
+            },
+          },
+          ChangedChild: {
+            Type: 'AWS::CloudFormation::Stack',
+            Resources: {
+              SomeResource: {
+                Type: 'AWS::Something',
+                Properties: {
+                  Prop: 'new-value',
+                },
+              },
+            },
+          },
+        };
+        return Promise.resolve({
+          Resources: {
+            AdditionChild: {
+              Type: 'AWS::CloudFormation::Stack',
+              Resources: {
+                SomeResource: {
+                  Type: 'AWS::Something',
+                },
+              },
+            },
+            DeletionChild: {
+              Type: 'AWS::CloudFormation::Stack',
+              Resources: {
+                SomeResource: {
+                  Type: 'AWS::Something',
+                  Properties: {
+                    Prop: 'value-to-be-removed',
+                  },
+                },
+              },
+            },
+            ChangedChild: {
+              Type: 'AWS::CloudFormation::Stack',
+              Resources: {
+                SomeResource: {
+                  Type: 'AWS::Something',
+                  Properties: {
+                    Prop: 'old-value',
+                  },
+                },
+              },
+            },
+          },
+        });
+      }
+      return Promise.resolve({});
+    });
   });
 
-  // THEN
-  expect(exitCode).toBe(1);
-});
+  test('diff can diff nested stacks', async () => {
+    // GIVEN
+    const buffer = new StringWritable();
+
+    // WHEN
+    const exitCode = await toolkit.diff({
+      stackNames: ['Parent'],
+      stream: buffer,
+    });
 
-test('throws an error during diffs on stack with error metadata', async () => {
-  const buffer = new StringWritable();
+    // THEN
+    const plainTextOutput = buffer.data.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '');
+    expect(plainTextOutput.trim()).toEqual(`Stack Parent
+Resources
+[~] AWS::CloudFormation::Stack AdditionChild 
+ └─ [~] Resources
+     └─ [~] .SomeResource:
+         └─ [+] Added: .Properties
+             └─ {\"Prop\":\"added-value\"}
+[~] AWS::CloudFormation::Stack DeletionChild 
+ └─ [~] Resources
+     └─ [~] .SomeResource:
+         └─ [-] Removed: .Properties
+             └─ {\"Prop\":\"value-to-be-removed\"}
+[~] AWS::CloudFormation::Stack ChangedChild 
+ └─ [~] Resources
+     └─ [~] .SomeResource:
+         └─ [~] .Properties:
+             └─ [~] .Prop:
+                 ├─ [-] old-value
+                 └─ [+] new-value`);
 
-  // WHEN
-  await expect(() => toolkit.diff({
-    stackNames: ['C'],
-    stream: buffer,
-  })).rejects.toThrow(/Found errors/);
+    expect(exitCode).toBe(0);
+  });
 });
 
 class StringWritable extends Writable {
diff --git a/packages/aws-cdk/test/util.ts b/packages/aws-cdk/test/util.ts
index 494efcff1982e..63781e9b882d9 100644
--- a/packages/aws-cdk/test/util.ts
+++ b/packages/aws-cdk/test/util.ts
@@ -49,11 +49,31 @@ function clone(obj: any) {
   return JSON.parse(JSON.stringify(obj));
 }
 
+function addNestedStacks(templatePath: string, outdir: string, rootStackTemplate?: any) {
+  let template = rootStackTemplate;
+
+  if (!template) {
+    const templatePathWithDir = path.join('diff-nested-stacks-templates', templatePath);
+    template = JSON.parse(fs.readFileSync(path.join(__dirname, templatePathWithDir)).toString());
+    fs.writeFileSync(path.join(outdir, templatePath), JSON.stringify(template, undefined, 2));
+  }
+
+  for (const logicalId in template.Resources) {
+    if (template.Resources[logicalId].Type === 'AWS::CloudFormation::Stack') {
+      if (template.Resources[logicalId].Metadata && template.Resources[logicalId].Metadata['aws:asset:path']) {
+        const nestedTemplatePath = template.Resources[logicalId].Metadata['aws:asset:path'];
+        addNestedStacks(nestedTemplatePath, outdir);
+      }
+    }
+  }
+}
+
 function addAttributes(assembly: TestAssembly, builder: cxapi.CloudAssemblyBuilder) {
   for (const stack of assembly.stacks) {
     const templateFile = `${stack.stackName}.template.json`;
     const template = stack.template ?? DEFAULT_FAKE_TEMPLATE;
     fs.writeFileSync(path.join(builder.outdir, templateFile), JSON.stringify(template, undefined, 2));
+    addNestedStacks(templateFile, builder.outdir, template);
 
     // we call patchStackTags here to simulate the tags formatter
     // that is used when building real manifest files.

From 2b0ca60de2cfc61bad4ca4a5e44e6c25136b34cb Mon Sep 17 00:00:00 2001
From: Calvin Combs <comcalvi@amazon.com>
Date: Thu, 20 Jan 2022 15:45:54 -0800
Subject: [PATCH 2/2] removed line

---
 packages/aws-cdk/lib/api/cloudformation-deployments.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/packages/aws-cdk/lib/api/cloudformation-deployments.ts b/packages/aws-cdk/lib/api/cloudformation-deployments.ts
index 21933c955b3b8..607aecba38f49 100644
--- a/packages/aws-cdk/lib/api/cloudformation-deployments.ts
+++ b/packages/aws-cdk/lib/api/cloudformation-deployments.ts
@@ -430,7 +430,6 @@ export class CloudFormationDeployments {
 
       if (deployedParentTemplate.Resources) {
         deployedParentTemplate.Resources[nestedStackLogicalId].NestedTemplate = nestedStackTemplates.deployedNestedTemplate;
-        //deployedParentTemplate.Resources[nestedStackLogicalId].Type = 'AWS::CloudFormation::Stack';
       }
 
       await this.replaceNestedStacksInParentTemplate(