fix(CLI): diff --template crashes

packages/@aws-cdk/cloudformation-diff/lib/diff-template.ts

@@ -51,6 +51,10 @@ export function fullDiff(
   isImport?: boolean,
 ): types.TemplateDiff {
 
+  if (!currentTemplate || !newTemplate) {
+    throw new Error('trying to diff a template that is not defined');
+  }
+
   normalize(currentTemplate);
   normalize(newTemplate);
   const theDiff = diffTemplate(currentTemplate, newTemplate);

packages/@aws-cdk/cloudformation-diff/test/diff-template.test.ts

@@ -624,6 +624,19 @@ test('metadata changes are rendered in the diff', () => {
   expect(differences.resources.differenceCount).toBe(1);
 });
 
+test('diff complains if it receives an undefined template', async () => {
+  // GIVEN
+  const currentTemplate: any = undefined;
+
+  // WHEN
+  const newTemplate = {
+    Resources: {},
+  };
+
+  // THEN
+  expect(() => fullDiff(currentTemplate, newTemplate)).toThrow(/trying to diff a template that is not defined/);
+});
+
 describe('changeset', () => {
   test('changeset overrides spec replacements', () => {
     // GIVEN

packages/aws-cdk/lib/cdk-toolkit.ts

@@ -136,41 +136,10 @@ export class CdkToolkit {
         throw new Error(`There is no file at ${options.templatePath}`);
       }
 
-      let changeSet = undefined;
-
-      if (options.changeSet) {
-        let stackExists = false;
-        try {
-          stackExists = await this.props.deployments.stackExists({
-            stack: stacks.firstStack,
-            deployName: stacks.firstStack.stackName,
-            tryLookupRole: true,
-          });
-        } catch (e: any) {
-          debug(e.message);
-          stream.write('Checking if the stack exists before creating the changeset has failed, will base the diff on template differences (run again with -v to see the reason)\n');
-          stackExists = false;
-        }
-
-        if (stackExists) {
-          changeSet = await createDiffChangeSet({
-            stack: stacks.firstStack,
-            uuid: uuid.v4(),
-            deployments: this.props.deployments,
-            willExecute: false,
-            sdkProvider: this.props.sdkProvider,
-            parameters: Object.assign({}, parameterMap['*'], parameterMap[stacks.firstStack.stackName]),
-            stream,
-          });
-        } else {
-          debug(`the stack '${stacks.firstStack.stackName}' has not been deployed to CloudFormation or describeStacks call failed, skipping changeset creation.`);
-        }
-      }
-
       const template = deserializeStructure(await fs.readFile(options.templatePath, { encoding: 'UTF-8' }));
       diffs = options.securityOnly
-        ? numberFromBool(printSecurityDiff(template, stacks.firstStack, RequireApproval.Broadening, changeSet))
-        : printStackDiff(template, stacks.firstStack.template, strict, contextLines, quiet, changeSet, false, stream);
+        ? numberFromBool(printSecurityDiff(template, stacks.firstStack, RequireApproval.Broadening, undefined))
+        : printStackDiff(template, stacks.firstStack, strict, contextLines, quiet, undefined, false, stream);
     } else {
       // Compare N stacks against deployed templates
       for (const stack of stacks.stackArtifacts) {

packages/aws-cdk/test/diff.test.ts

@@ -14,6 +14,75 @@ let cloudExecutable: MockCloudExecutable;
 let cloudFormation: jest.Mocked<Deployments>;
 let toolkit: CdkToolkit;
 
+describe('fixed template', () => {
+  const templatePath = 'oldTemplate.json';
+  beforeEach(() => {
+    const oldTemplate = {
+      Resources: {
+        SomeResource: {
+          Type: 'AWS::SomeService::SomeResource',
+          Properties: {
+            Something: 'old-value',
+          },
+        },
+      },
+    };
+
+    cloudExecutable = new MockCloudExecutable({
+      stacks: [{
+        stackName: 'A',
+        template: {
+          Resources: {
+            SomeResource: {
+              Type: 'AWS::SomeService::SomeResource',
+              Properties: {
+                Something: 'new-value',
+              },
+            },
+          },
+        },
+      }],
+    });
+
+    toolkit = new CdkToolkit({
+      cloudExecutable,
+      deployments: cloudFormation,
+      configuration: cloudExecutable.configuration,
+      sdkProvider: cloudExecutable.sdkProvider,
+    });
+
+    fs.writeFileSync(templatePath, JSON.stringify(oldTemplate));
+  });
+
+  afterEach(() => fs.rmSync(templatePath));
+
+  test('fixed template with valid templates', async () => {
+    // GIVEN
+    const buffer = new StringWritable();
+
+    // WHEN
+    const exitCode = await toolkit.diff({
+      stackNames: ['A'],
+      stream: buffer,
+      changeSet: undefined,
+      templatePath,
+    });
+
+    // THEN
+    const plainTextOutput = buffer.data.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '');
+    expect(exitCode).toBe(0);
+    expect(plainTextOutput.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '')).toContain(`Resources
+[~] AWS::SomeService::SomeResource SomeResource 
+ └─ [~] Something
+     ├─ [-] old-value
+     └─ [+] new-value
+
+
+✨  Number of stacks with differences: 1
+`);
+  });
+});
+
 describe('imports', () => {
   beforeEach(() => {
     const outputToJson = {