Error message for destroy action on non-existent stack

packages/aws-cdk/lib/api/deploy-stack.ts

@@ -578,7 +578,7 @@ export async function destroyStack(options: DestroyStackOptions) {
 
   const currentStack = await CloudFormationStack.lookup(cfn, deployName);
   if (!currentStack.exists) {
-    return;
+    throw new StackNotFoundError(`Failed to destroy ${deployName}. The stack is not deployed.`);
   }
   const monitor = options.quiet ? undefined : StackActivityMonitor.withDefaultPrinter(cfn, deployName, options.stack, {
     ci: options.ci,
@@ -694,3 +694,9 @@ function suffixWithErrors(msg: string, errors?: string[]) {
     ? `${msg}: ${errors.join(', ')}`
     : msg;
 }
+
+export class StackNotFoundError extends Error {
+  constructor(message: string) {
+    super(message);
+  }
+}

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

@@ -6,7 +6,7 @@ import * as chokidar from 'chokidar';
 import * as fs from 'fs-extra';
 import * as promptly from 'promptly';
 import * as uuid from 'uuid';
-import { DeploymentMethod } from './api';
+import { DeploymentMethod, StackNotFoundError } from './api';
 import { SdkProvider } from './api/aws-auth';
 import { Bootstrapper, BootstrapEnvironmentOptions } from './api/bootstrap';
 import { CloudAssembly, DefaultSelection, ExtendedStackSelection, StackCollection, StackSelector } from './api/cxapp/cloud-assembly';
@@ -620,8 +620,12 @@ export class CdkToolkit {
         });
         success(`\n ✅  %s: ${action}ed`, chalk.blue(stack.displayName));
       } catch (e) {
-        error(`\n ❌  %s: ${action} failed`, chalk.blue(stack.displayName), e);
-        throw e;
+        if (e instanceof StackNotFoundError) {
+          error(`\n ❌  %s: ${action} skipped`, chalk.blue(stack.displayName), e);
+        } else {
+          error(`\n ❌  %s: ${action} failed`, chalk.blue(stack.displayName), e);
+          throw e;
+        }
       }
     }
   }
@@ -1525,4 +1529,4 @@ function buildParameterMap(parameters: {
   }
 
   return parameterMap;
-}
+}

packages/aws-cdk/test/api/deploy-stack.test.ts

@@ -1,5 +1,5 @@
 /* eslint-disable import/order */
-import { deployStack, DeployStackOptions } from '../../lib/api';
+import { deployStack, DeployStackOptions, destroyStack } from '../../lib/api';
 import { HotswapMode } from '../../lib/api/hotswap/common';
 import { tryHotswapDeployment } from '../../lib/api/hotswap-deployments';
 import { setCI } from '../../lib/logging';
@@ -630,6 +630,16 @@ test('deploy is not skipped if stack is in a _FAILED state', async () => {
   expect(cfnMocks.createChangeSet).toHaveBeenCalled();
 });
 
+test('destroy stack throws error if stack is not deployed', async () => {
+  await expect(destroyStack({
+    stack: FAKE_STACK,
+    sdk: sdk,
+    deployName: FAKE_STACK.stackName,
+  })).rejects.toThrow(`Failed to destroy ${FAKE_STACK.stackName}. The stack is not deployed.`);
+
+  expect(cfnMocks.deleteStack).not.toHaveBeenCalled();
+});
+
 test('existing stack in UPDATE_ROLLBACK_COMPLETE state can be updated', async () => {
   // GIVEN
   givenStackExists(
@@ -915,4 +925,4 @@ function givenTemplateIs(template: any) {
   cfnMocks.getTemplate!.mockReturnValue({
     TemplateBody: JSON.stringify(template),
   });
-}
+}

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

@@ -63,7 +63,7 @@ import * as fs from 'fs-extra';
 import { instanceMockFrom, MockCloudExecutable, TestStackArtifact } from './util';
 import { MockSdkProvider } from './util/mock-sdk';
 import { Bootstrapper } from '../lib/api/bootstrap';
-import { DeployStackResult } from '../lib/api/deploy-stack';
+import { DeployStackResult, StackNotFoundError } from '../lib/api/deploy-stack';
 import { Deployments, DeployStackOptions, DestroyStackOptions } from '../lib/api/deployments';
 import { HotswapMode } from '../lib/api/hotswap/common';
 import { Template } from '../lib/api/util/cloudformation';
@@ -591,14 +591,36 @@ describe('destroy', () => {
   test('destroy correct stack', async () => {
     const toolkit = defaultToolkitSetup();
 
-    await expect(() => {
-      return toolkit.destroy({
-        selector: { patterns: ['Test-Stack-A/Test-Stack-C'] },
-        exclusively: true,
-        force: true,
-        fromDeploy: true,
-      });
-    }).resolves;
+    expect(toolkit.destroy({
+      selector: { patterns: ['Test-Stack-A/Test-Stack-C'] },
+      exclusively: true,
+      force: true,
+      fromDeploy: true,
+    })).resolves;
+  });
+
+  test('destroy keeps running when one of the stacks is not deployed', async () => {
+    const toolkit = defaultToolkitSetup();
+    jest.spyOn(FakeCloudFormation.prototype, 'destroyStack').mockImplementationOnce(() => Promise.reject(new StackNotFoundError('')));
+
+    expect(toolkit.destroy({
+      selector: { patterns: ['Test-Stack-A', 'Test-Stack-B', 'Test-Stack-C'] },
+      exclusively: true,
+      force: true,
+      fromDeploy: true,
+    })).resolves;
+  });
+
+  test('destroy stops if actual error occurs', async () => {
+    const toolkit = defaultToolkitSetup();
+    jest.spyOn(FakeCloudFormation.prototype, 'destroyStack').mockImplementationOnce(() => Promise.reject(new Error('Some error')));
+
+    await expect(toolkit.destroy({
+      selector: { patterns: ['Test-Stack-A', 'Test-Stack-B'] },
+      exclusively: true,
+      force: true,
+      fromDeploy: true,
+    })).rejects.toThrow('Some error');
   });
 });