1  "use strict";
  2  Object.defineProperty(exports, "__esModule", { value: true });
  3  const api_1 = require("../../lib/api");
  4  const util_1 = require("../util");
  5  const mock_sdk_1 = require("../util/mock-sdk");
  6  const FAKE_STACK = util_1.testStack({
  7      stackName: 'withouterrors',
  8  });
  9  const FAKE_STACK_WITH_PARAMETERS = util_1.testStack({
 10      stackName: 'withparameters',
 11      template: {
 12          Parameters: {
 13              HasValue: { Type: 'String' },
 14              HasDefault: { Type: 'String', Default: 'TheDefault' },
 15              OtherParameter: { Type: 'String' },
 16          },
 17      },
 18  });
 19  const FAKE_STACK_TERMINATION_PROTECTION = util_1.testStack({
 20      stackName: 'termination-protection',
 21      template: util_1.DEFAULT_FAKE_TEMPLATE,
 22      terminationProtection: true,
 23  });
 24  let sdk;
 25  let sdkProvider;
 26  let cfnMocks;
 27  beforeEach(() => {
 28      sdkProvider = new mock_sdk_1.MockSdkProvider();
 29      sdk = new mock_sdk_1.MockSdk();
 30      cfnMocks = {
 31          describeStackEvents: jest.fn().mockReturnValue({}),
 32          describeStacks: jest.fn()
 33              // First call, no stacks exist
 34              .mockImplementationOnce(() => ({ Stacks: [] }))
 35              // Second call, stack has been created
 36              .mockImplementationOnce(() => ({
 37              Stacks: [
 38                  {
 39                      StackStatus: 'CREATE_COMPLETE',
 40                      StackStatusReason: 'It is magic',
 41                      EnableTerminationProtection: false,
 42                  },
 43              ],
 44          })),
 45          createChangeSet: jest.fn((_o) => ({})),
 46          deleteChangeSet: jest.fn((_o) => ({})),
 47          describeChangeSet: jest.fn((_o) => ({
 48              Status: 'CREATE_COMPLETE',
 49              Changes: [],
 50          })),
 51          executeChangeSet: jest.fn((_o) => ({})),
 52          deleteStack: jest.fn((_o) => ({})),
 53          getTemplate: jest.fn((_o) => ({ TemplateBody: JSON.stringify(util_1.DEFAULT_FAKE_TEMPLATE) })),
 54          updateTerminationProtection: jest.fn((_o) => ({ StackId: 'stack-id' })),
 55      };
 56      sdk.stubCloudFormation(cfnMocks);
 57  });
 58  function standardDeployStackArguments() {
 59      return {
 60          stack: FAKE_STACK,
 61          sdk,
 62          sdkProvider,
 63          resolvedEnvironment: mock_sdk_1.mockResolvedEnvironment(),
 64          toolkitInfo: api_1.ToolkitInfo.bootstraplessDeploymentsOnly(sdk),
 65      };
 66  }
 67  test('do deploy executable change set with 0 changes', async () => {
 68      // WHEN
 69      const ret = await api_1.deployStack({
 70          ...standardDeployStackArguments(),
 71      });
 72      // THEN
 73      expect(ret.noOp).toBeFalsy();
 74      expect(cfnMocks.executeChangeSet).toHaveBeenCalled();
 75  });
 76  test('correctly passes CFN parameters, ignoring ones with empty values', async () => {
 77      // WHEN
 78      await api_1.deployStack({
 79          ...standardDeployStackArguments(),
 80          parameters: {
 81              A: 'A-value',
 82              B: 'B=value',
 83              C: undefined,
 84              D: '',
 85          },
 86      });
 87      // THEN
 88      expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({
 89          Parameters: [
 90              { ParameterKey: 'A', ParameterValue: 'A-value' },
 91              { ParameterKey: 'B', ParameterValue: 'B=value' },
 92          ],
 93      }));
 94  });
 95  test('reuse previous parameters if requested', async () => {
 96      // GIVEN
 97      givenStackExists({
 98          Parameters: [
 99              { ParameterKey: 'HasValue', ParameterValue: 'TheValue' },
100              { ParameterKey: 'HasDefault', ParameterValue: 'TheOldValue' },
101          ],
102      });
103      // WHEN
104      await api_1.deployStack({
105          ...standardDeployStackArguments(),
106          stack: FAKE_STACK_WITH_PARAMETERS,
107          parameters: {
108              OtherParameter: 'SomeValue',
109          },
110          usePreviousParameters: true,
111      });
112      // THEN
113      expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({
114          Parameters: [
115              { ParameterKey: 'HasValue', UsePreviousValue: true },
116              { ParameterKey: 'HasDefault', UsePreviousValue: true },
117              { ParameterKey: 'OtherParameter', ParameterValue: 'SomeValue' },
118          ],
119      }));
120  });
121  test('do not reuse previous parameters if not requested', async () => {
122      // GIVEN
123      givenStackExists({
124          Parameters: [
125              { ParameterKey: 'HasValue', ParameterValue: 'TheValue' },
126              { ParameterKey: 'HasDefault', ParameterValue: 'TheOldValue' },
127          ],
128      });
129      // WHEN
130      await api_1.deployStack({
131          ...standardDeployStackArguments(),
132          stack: FAKE_STACK_WITH_PARAMETERS,
133          parameters: {
134              HasValue: 'SomeValue',
135              OtherParameter: 'SomeValue',
136          },
137      });
138      // THEN
139      expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({
140          Parameters: [
141              { ParameterKey: 'HasValue', ParameterValue: 'SomeValue' },
142              { ParameterKey: 'OtherParameter', ParameterValue: 'SomeValue' },
143          ],
144      }));
145  });
146  test('throw exception if not enough parameters supplied', async () => {
147      // GIVEN
148      givenStackExists({
149          Parameters: [
150              { ParameterKey: 'HasValue', ParameterValue: 'TheValue' },
151              { ParameterKey: 'HasDefault', ParameterValue: 'TheOldValue' },
152          ],
153      });
154      // WHEN
155      await expect(api_1.deployStack({
156          ...standardDeployStackArguments(),
157          stack: FAKE_STACK_WITH_PARAMETERS,
158          parameters: {
159              OtherParameter: 'SomeValue',
160          },
161      })).rejects.toThrow(/CloudFormation Parameters are missing a value/);
162  });
163  test('deploy is skipped if template did not change', async () => {
164      // GIVEN
165      givenStackExists();
166      // WHEN
167      await api_1.deployStack({
168          ...standardDeployStackArguments(),
169      });
170      // THEN
171      expect(cfnMocks.executeChangeSet).not.toBeCalled();
172  });
173  test('deploy is skipped if parameters are the same', async () => {
174      // GIVEN
175      givenTemplateIs(FAKE_STACK_WITH_PARAMETERS.template);
176      givenStackExists({
177          Parameters: [
178              { ParameterKey: 'HasValue', ParameterValue: 'HasValue' },
179              { ParameterKey: 'HasDefault', ParameterValue: 'HasDefault' },
180              { ParameterKey: 'OtherParameter', ParameterValue: 'OtherParameter' },
181          ],
182      });
183      // WHEN
184      await api_1.deployStack({
185          ...standardDeployStackArguments(),
186          stack: FAKE_STACK_WITH_PARAMETERS,
187          parameters: {},
188          usePreviousParameters: true,
189      });
190      // THEN
191      expect(cfnMocks.createChangeSet).not.toHaveBeenCalled();
192  });
193  test('deploy is not skipped if parameters are different', async () => {
194      // GIVEN
195      givenTemplateIs(FAKE_STACK_WITH_PARAMETERS.template);
196      givenStackExists({
197          Parameters: [
198              { ParameterKey: 'HasValue', ParameterValue: 'HasValue' },
199              { ParameterKey: 'HasDefault', ParameterValue: 'HasDefault' },
200              { ParameterKey: 'OtherParameter', ParameterValue: 'OtherParameter' },
201          ],
202      });
203      // WHEN
204      await api_1.deployStack({
205          ...standardDeployStackArguments(),
206          stack: FAKE_STACK_WITH_PARAMETERS,
207          parameters: {
208              HasValue: 'NewValue',
209          },
210          usePreviousParameters: true,
211      });
212      // THEN
213      expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({
214          Parameters: [
215              { ParameterKey: 'HasValue', ParameterValue: 'NewValue' },
216              { ParameterKey: 'HasDefault', UsePreviousValue: true },
217              { ParameterKey: 'OtherParameter', UsePreviousValue: true },
218          ],
219      }));
220  });
221  test('if existing stack failed to create, it is deleted and recreated', async () => {
222      // GIVEN
223      givenStackExists({ StackStatus: 'ROLLBACK_COMPLETE' }, // This is for the initial check
224      { StackStatus: 'DELETE_COMPLETE' }, // Poll the successful deletion
225      { StackStatus: 'CREATE_COMPLETE' });
226      givenTemplateIs({
227          DifferentThan: 'TheDefault',
228      });
229      // WHEN
230      await api_1.deployStack({
231          ...standardDeployStackArguments(),
232      });
233      // THEN
234      expect(cfnMocks.deleteStack).toHaveBeenCalled();
235      expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({
236          ChangeSetType: 'CREATE',
237      }));
238  });
239  test('if existing stack failed to create, it is deleted and recreated even if the template did not change', async () => {
240      // GIVEN
241      givenStackExists({ StackStatus: 'ROLLBACK_COMPLETE' }, // This is for the initial check
242      { StackStatus: 'DELETE_COMPLETE' }, // Poll the successful deletion
243      { StackStatus: 'CREATE_COMPLETE' });
244      // WHEN
245      await api_1.deployStack({
246          ...standardDeployStackArguments(),
247      });
248      // THEN
249      expect(cfnMocks.deleteStack).toHaveBeenCalled();
250      expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({
251          ChangeSetType: 'CREATE',
252      }));
253  });
254  test('deploy not skipped if template did not change and --force is applied', async () => {
255      // GIVEN
256      givenStackExists();
257      // WHEN
258      await api_1.deployStack({
259          ...standardDeployStackArguments(),
260          force: true,
261      });
262      // THEN
263      expect(cfnMocks.executeChangeSet).toHaveBeenCalled();
264  });
265  test('deploy is skipped if template and tags did not change', async () => {
266      // GIVEN
267      givenStackExists({
268          Tags: [
269              { Key: 'Key1', Value: 'Value1' },
270              { Key: 'Key2', Value: 'Value2' },
271          ],
272      });
273      // WHEN
274      await api_1.deployStack({
275          ...standardDeployStackArguments(),
276          tags: [
277              { Key: 'Key1', Value: 'Value1' },
278              { Key: 'Key2', Value: 'Value2' },
279          ],
280      });
281      // THEN
282      expect(cfnMocks.createChangeSet).not.toBeCalled();
283      expect(cfnMocks.executeChangeSet).not.toBeCalled();
284      expect(cfnMocks.describeStacks).toHaveBeenCalledWith({ StackName: 'withouterrors' });
285      expect(cfnMocks.getTemplate).toHaveBeenCalledWith({ StackName: 'withouterrors', TemplateStage: 'Original' });
286  });
287  test('deploy not skipped if template did not change but tags changed', async () => {
288      // GIVEN
289      givenStackExists({
290          Tags: [
291              { Key: 'Key', Value: 'Value' },
292          ],
293      });
294      // WHEN
295      await api_1.deployStack({
296          stack: FAKE_STACK,
297          sdk,
298          sdkProvider,
299          resolvedEnvironment: mock_sdk_1.mockResolvedEnvironment(),
300          tags: [
301              {
302                  Key: 'Key',
303                  Value: 'NewValue',
304              },
305          ],
306          toolkitInfo: api_1.ToolkitInfo.bootstraplessDeploymentsOnly(sdk),
307      });
308      // THEN
309      expect(cfnMocks.createChangeSet).toHaveBeenCalled();
310      expect(cfnMocks.executeChangeSet).toHaveBeenCalled();
311      expect(cfnMocks.describeChangeSet).toHaveBeenCalled();
312      expect(cfnMocks.describeStacks).toHaveBeenCalledWith({ StackName: 'withouterrors' });
313      expect(cfnMocks.getTemplate).toHaveBeenCalledWith({ StackName: 'withouterrors', TemplateStage: 'Original' });
314  });
315  test('deployStack reports no change if describeChangeSet returns specific error', async () => {
316      var _a;
317      (_a = cfnMocks.describeChangeSet) === null || _a === void 0 ? void 0 : _a.mockImplementation(() => ({
318          Status: 'FAILED',
319          StatusReason: 'No updates are to be performed.',
320      }));
321      // WHEN
322      const deployResult = await api_1.deployStack({
323          ...standardDeployStackArguments(),
324      });
325      // THEN
326      expect(deployResult.noOp).toEqual(true);
327  });
328  test('deploy not skipped if template did not change but one tag removed', async () => {
329      // GIVEN
330      givenStackExists({
331          Tags: [
332              { Key: 'Key1', Value: 'Value1' },
333              { Key: 'Key2', Value: 'Value2' },
334          ],
335      });
336      // WHEN
337      await api_1.deployStack({
338          ...standardDeployStackArguments(),
339          tags: [
340              { Key: 'Key1', Value: 'Value1' },
341          ],
342      });
343      // THEN
344      expect(cfnMocks.createChangeSet).toHaveBeenCalled();
345      expect(cfnMocks.executeChangeSet).toHaveBeenCalled();
346      expect(cfnMocks.describeChangeSet).toHaveBeenCalled();
347      expect(cfnMocks.describeStacks).toHaveBeenCalledWith({ StackName: 'withouterrors' });
348      expect(cfnMocks.getTemplate).toHaveBeenCalledWith({ StackName: 'withouterrors', TemplateStage: 'Original' });
349  });
350  test('deploy is not skipped if stack is in a _FAILED state', async () => {
351      // GIVEN
352      givenStackExists({
353          StackStatus: 'DELETE_FAILED',
354      });
355      // WHEN
356      await api_1.deployStack({
357          ...standardDeployStackArguments(),
358          usePreviousParameters: true,
359      }).catch(() => { });
360      // THEN
361      expect(cfnMocks.createChangeSet).toHaveBeenCalled();
362  });
363  test('existing stack in UPDATE_ROLLBACK_COMPLETE state can be updated', async () => {
364      // GIVEN
365      givenStackExists({ StackStatus: 'UPDATE_ROLLBACK_COMPLETE' }, // This is for the initial check
366      { StackStatus: 'UPDATE_COMPLETE' });
367      givenTemplateIs({ changed: 123 });
368      // WHEN
369      await api_1.deployStack({
370          ...standardDeployStackArguments(),
371      });
372      // THEN
373      expect(cfnMocks.deleteStack).not.toHaveBeenCalled();
374      expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({
375          ChangeSetType: 'UPDATE',
376      }));
377  });
378  test('deploy not skipped if template changed', async () => {
379      // GIVEN
380      givenStackExists();
381      givenTemplateIs({ changed: 123 });
382      // WHEN
383      await api_1.deployStack({
384          ...standardDeployStackArguments(),
385      });
386      // THEN
387      expect(cfnMocks.executeChangeSet).toHaveBeenCalled();
388  });
389  test('not executed and no error if --no-execute is given', async () => {
390      // WHEN
391      await api_1.deployStack({
392          ...standardDeployStackArguments(),
393          execute: false,
394      });
395      // THEN
396      expect(cfnMocks.executeChangeSet).not.toHaveBeenCalled();
397  });
398  test('empty change set is deleted if --execute is given', async () => {
399      var _a;
400      (_a = cfnMocks.describeChangeSet) === null || _a === void 0 ? void 0 : _a.mockImplementation(() => ({
401          Status: 'FAILED',
402          StatusReason: 'No updates are to be performed.',
403      }));
404      // GIVEN
405      givenStackExists();
406      // WHEN
407      await api_1.deployStack({
408          ...standardDeployStackArguments(),
409          execute: true,
410          force: true,
411      });
412      // THEN
413      expect(cfnMocks.createChangeSet).toHaveBeenCalled();
414      expect(cfnMocks.executeChangeSet).not.toHaveBeenCalled();
415      //the first deletion is for any existing cdk change sets, the second is for the deleting the new empty change set
416      expect(cfnMocks.deleteChangeSet).toHaveBeenCalledTimes(2);
417  });
418  test('empty change set is not deleted if --no-execute is given', async () => {
419      var _a;
420      (_a = cfnMocks.describeChangeSet) === null || _a === void 0 ? void 0 : _a.mockImplementation(() => ({
421          Status: 'FAILED',
422          StatusReason: 'No updates are to be performed.',
423      }));
424      // GIVEN
425      givenStackExists();
426      // WHEN
427      await api_1.deployStack({
428          ...standardDeployStackArguments(),
429          execute: false,
430      });
431      // THEN
432      expect(cfnMocks.createChangeSet).toHaveBeenCalled();
433      expect(cfnMocks.executeChangeSet).not.toHaveBeenCalled();
434      //the first deletion is for any existing cdk change sets
435      expect(cfnMocks.deleteChangeSet).toHaveBeenCalledTimes(1);
436  });
437  test('use S3 url for stack deployment if present in Stack Artifact', async () => {
438      // WHEN
439      await api_1.deployStack({
440          ...standardDeployStackArguments(),
441          stack: util_1.testStack({
442              stackName: 'withouterrors',
443              properties: {
444                  stackTemplateAssetObjectUrl: 'https://use-me-use-me/',
445              },
446          }),
447      });
448      // THEN
449      expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({
450          TemplateURL: 'https://use-me-use-me/',
451      }));
452      expect(cfnMocks.executeChangeSet).toHaveBeenCalled();
453  });
454  test('use REST API S3 url with substituted placeholders if manifest url starts with s3://', async () => {
455      // WHEN
456      await api_1.deployStack({
457          ...standardDeployStackArguments(),
458          stack: util_1.testStack({
459              stackName: 'withouterrors',
460              properties: {
461                  stackTemplateAssetObjectUrl: 's3://use-me-use-me-${AWS::AccountId}/object',
462              },
463          }),
464      });
465      // THEN
466      expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({
467          TemplateURL: 'https://s3.bermuda-triangle-1337.amazonaws.com/use-me-use-me-123456789/object',
468      }));
469      expect(cfnMocks.executeChangeSet).toHaveBeenCalled();
470  });
471  test('changeset is created when stack exists in REVIEW_IN_PROGRESS status', async () => {
472      // GIVEN
473      givenStackExists({
474          StackStatus: 'REVIEW_IN_PROGRESS',
475          Tags: [
476              { Key: 'Key1', Value: 'Value1' },
477              { Key: 'Key2', Value: 'Value2' },
478          ],
479      });
480      // WHEN
481      await api_1.deployStack({
482          ...standardDeployStackArguments(),
483          execute: false,
484      });
485      // THEN
486      expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({
487          ChangeSetType: 'CREATE',
488          StackName: 'withouterrors',
489      }));
490      expect(cfnMocks.executeChangeSet).not.toHaveBeenCalled();
491  });
492  test('changeset is updated when stack exists in CREATE_COMPLETE status', async () => {
493      // GIVEN
494      givenStackExists({
495          Tags: [
496              { Key: 'Key1', Value: 'Value1' },
497              { Key: 'Key2', Value: 'Value2' },
498          ],
499      });
500      // WHEN
501      await api_1.deployStack({
502          ...standardDeployStackArguments(),
503          execute: false,
504      });
505      // THEN
506      expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({
507          ChangeSetType: 'UPDATE',
508          StackName: 'withouterrors',
509      }));
510      expect(cfnMocks.executeChangeSet).not.toHaveBeenCalled();
511  });
512  test('deploy with termination protection enabled', async () => {
513      // WHEN
514      await api_1.deployStack({
515          ...standardDeployStackArguments(),
516          stack: FAKE_STACK_TERMINATION_PROTECTION,
517      });
518      // THEN
519      expect(cfnMocks.updateTerminationProtection).toHaveBeenCalledWith(expect.objectContaining({
520          EnableTerminationProtection: true,
521      }));
522  });
523  test('updateTerminationProtection not called when termination protection is undefined', async () => {
524      // WHEN
525      await api_1.deployStack({
526          ...standardDeployStackArguments(),
527      });
528      // THEN
529      expect(cfnMocks.updateTerminationProtection).not.toHaveBeenCalled();
530  });
531  test('updateTerminationProtection called when termination protection is undefined and stack has termination protection', async () => {
532      // GIVEN
533      givenStackExists({
534          EnableTerminationProtection: true,
535      });
536      // WHEN
537      await api_1.deployStack({
538          ...standardDeployStackArguments(),
539      });
540      // THEN
541      expect(cfnMocks.updateTerminationProtection).toHaveBeenCalledWith(expect.objectContaining({
542          EnableTerminationProtection: false,
543      }));
544  });
545  describe('disable rollback', () => {
546      test('by default, we do not disable rollback (and also do not pass the flag)', async () => {
547          // WHEN
548          await api_1.deployStack({
549              ...standardDeployStackArguments(),
550          });
551          // THEN
552          expect(cfnMocks.executeChangeSet).toHaveBeenCalledTimes(1);
553          expect(cfnMocks.executeChangeSet).not.toHaveBeenCalledWith(expect.objectContaining({
554              DisableRollback: expect.anything(),
555          }));
556      });
557      test('rollback can be disabled by setting rollback: false', async () => {
558          // WHEN
559          await api_1.deployStack({
560              ...standardDeployStackArguments(),
561              rollback: false,
562          });
563          // THEN
564          expect(cfnMocks.executeChangeSet).toHaveBeenCalledWith(expect.objectContaining({
565              DisableRollback: true,
566          }));
567      });
568  });
569  /**
570   * Set up the mocks so that it looks like the stack exists to start with
571   *
572   * The last element of this array will be continuously repeated.
573   */
574  function givenStackExists(...overrides) {
575      cfnMocks.describeStacks.mockReset();
576      if (overrides.length === 0) {
577          overrides = [{}];
578      }
579      const baseResponse = {
580          StackName: 'mock-stack-name',
581          StackId: 'mock-stack-id',
582          CreationTime: new Date(),
583          StackStatus: 'CREATE_COMPLETE',
584          EnableTerminationProtection: false,
585      };
586      for (const override of overrides.slice(0, overrides.length - 1)) {
587          cfnMocks.describeStacks.mockImplementationOnce(() => ({
588              Stacks: [{ ...baseResponse, ...override }],
589          }));
590      }
591      cfnMocks.describeStacks.mockImplementation(() => ({
592          Stacks: [{ ...baseResponse, ...overrides[overrides.length - 1] }],
593      }));
594  }
595  function givenTemplateIs(template) {
596      cfnMocks.getTemplate.mockReset();
597      cfnMocks.getTemplate.mockReturnValue({
598          TemplateBody: JSON.stringify(template),
599      });
600  }
601  //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deploy-stack.test.js","sourceRoot":"","sources":["deploy-stack.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { deployStack, ToolkitInfo } from '../../lib/api';\nimport { DEFAULT_FAKE_TEMPLATE, testStack } from '../util';\nimport { MockedObject, mockResolvedEnvironment, MockSdk, MockSdkProvider, SyncHandlerSubsetOf } from '../util/mock-sdk';\n\nconst FAKE_STACK = testStack({\n  stackName: 'withouterrors',\n});\n\nconst FAKE_STACK_WITH_PARAMETERS = testStack({\n  stackName: 'withparameters',\n  template: {\n    Parameters: {\n      HasValue: { Type: 'String' },\n      HasDefault: { Type: 'String', Default: 'TheDefault' },\n      OtherParameter: { Type: 'String' },\n    },\n  },\n});\n\nconst FAKE_STACK_TERMINATION_PROTECTION = testStack({\n  stackName: 'termination-protection',\n  template: DEFAULT_FAKE_TEMPLATE,\n  terminationProtection: true,\n});\n\nlet sdk: MockSdk;\nlet sdkProvider: MockSdkProvider;\nlet cfnMocks: MockedObject<SyncHandlerSubsetOf<AWS.CloudFormation>>;\nbeforeEach(() => {\n  sdkProvider = new MockSdkProvider();\n  sdk = new MockSdk();\n\n  cfnMocks = {\n    describeStackEvents: jest.fn().mockReturnValue({}),\n    describeStacks: jest.fn()\n      // First call, no stacks exist\n      .mockImplementationOnce(() => ({ Stacks: [] }))\n      // Second call, stack has been created\n      .mockImplementationOnce(() => ({\n        Stacks: [\n          {\n            StackStatus: 'CREATE_COMPLETE',\n            StackStatusReason: 'It is magic',\n            EnableTerminationProtection: false,\n          },\n        ],\n      })),\n    createChangeSet: jest.fn((_o) => ({})),\n    deleteChangeSet: jest.fn((_o) => ({})),\n    describeChangeSet: jest.fn((_o) => ({\n      Status: 'CREATE_COMPLETE',\n      Changes: [],\n    })),\n    executeChangeSet: jest.fn((_o) => ({})),\n    deleteStack: jest.fn((_o) => ({})),\n    getTemplate: jest.fn((_o) => ({ TemplateBody: JSON.stringify(DEFAULT_FAKE_TEMPLATE) })),\n    updateTerminationProtection: jest.fn((_o) => ({ StackId: 'stack-id' })),\n  };\n  sdk.stubCloudFormation(cfnMocks as any);\n\n});\n\nfunction standardDeployStackArguments() {\n  return {\n    stack: FAKE_STACK,\n    sdk,\n    sdkProvider,\n    resolvedEnvironment: mockResolvedEnvironment(),\n    toolkitInfo: ToolkitInfo.bootstraplessDeploymentsOnly(sdk),\n  };\n}\n\ntest('do deploy executable change set with 0 changes', async () => {\n  // WHEN\n  const ret = await deployStack({\n    ...standardDeployStackArguments(),\n  });\n\n  // THEN\n  expect(ret.noOp).toBeFalsy();\n  expect(cfnMocks.executeChangeSet).toHaveBeenCalled();\n});\n\ntest('correctly passes CFN parameters, ignoring ones with empty values', async () => {\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n    parameters: {\n      A: 'A-value',\n      B: 'B=value',\n      C: undefined,\n      D: '',\n    },\n  });\n\n  // THEN\n  expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({\n    Parameters: [\n      { ParameterKey: 'A', ParameterValue: 'A-value' },\n      { ParameterKey: 'B', ParameterValue: 'B=value' },\n    ],\n  }));\n});\n\ntest('reuse previous parameters if requested', async () => {\n  // GIVEN\n  givenStackExists({\n    Parameters: [\n      { ParameterKey: 'HasValue', ParameterValue: 'TheValue' },\n      { ParameterKey: 'HasDefault', ParameterValue: 'TheOldValue' },\n    ],\n  });\n\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n    stack: FAKE_STACK_WITH_PARAMETERS,\n    parameters: {\n      OtherParameter: 'SomeValue',\n    },\n    usePreviousParameters: true,\n  });\n\n  // THEN\n  expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({\n    Parameters: [\n      { ParameterKey: 'HasValue', UsePreviousValue: true },\n      { ParameterKey: 'HasDefault', UsePreviousValue: true },\n      { ParameterKey: 'OtherParameter', ParameterValue: 'SomeValue' },\n    ],\n  }));\n});\n\ntest('do not reuse previous parameters if not requested', async () => {\n  // GIVEN\n  givenStackExists({\n    Parameters: [\n      { ParameterKey: 'HasValue', ParameterValue: 'TheValue' },\n      { ParameterKey: 'HasDefault', ParameterValue: 'TheOldValue' },\n    ],\n  });\n\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n    stack: FAKE_STACK_WITH_PARAMETERS,\n    parameters: {\n      HasValue: 'SomeValue',\n      OtherParameter: 'SomeValue',\n    },\n  });\n\n  // THEN\n  expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({\n    Parameters: [\n      { ParameterKey: 'HasValue', ParameterValue: 'SomeValue' },\n      { ParameterKey: 'OtherParameter', ParameterValue: 'SomeValue' },\n    ],\n  }));\n});\n\ntest('throw exception if not enough parameters supplied', async () => {\n  // GIVEN\n  givenStackExists({\n    Parameters: [\n      { ParameterKey: 'HasValue', ParameterValue: 'TheValue' },\n      { ParameterKey: 'HasDefault', ParameterValue: 'TheOldValue' },\n    ],\n  });\n\n  // WHEN\n  await expect(deployStack({\n    ...standardDeployStackArguments(),\n    stack: FAKE_STACK_WITH_PARAMETERS,\n    parameters: {\n      OtherParameter: 'SomeValue',\n    },\n  })).rejects.toThrow(/CloudFormation Parameters are missing a value/);\n});\n\ntest('deploy is skipped if template did not change', async () => {\n  // GIVEN\n  givenStackExists();\n\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n  });\n\n  // THEN\n  expect(cfnMocks.executeChangeSet).not.toBeCalled();\n});\n\ntest('deploy is skipped if parameters are the same', async () => {\n  // GIVEN\n  givenTemplateIs(FAKE_STACK_WITH_PARAMETERS.template);\n  givenStackExists({\n    Parameters: [\n      { ParameterKey: 'HasValue', ParameterValue: 'HasValue' },\n      { ParameterKey: 'HasDefault', ParameterValue: 'HasDefault' },\n      { ParameterKey: 'OtherParameter', ParameterValue: 'OtherParameter' },\n    ],\n  });\n\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n    stack: FAKE_STACK_WITH_PARAMETERS,\n    parameters: {},\n    usePreviousParameters: true,\n  });\n\n  // THEN\n  expect(cfnMocks.createChangeSet).not.toHaveBeenCalled();\n});\n\ntest('deploy is not skipped if parameters are different', async () => {\n  // GIVEN\n  givenTemplateIs(FAKE_STACK_WITH_PARAMETERS.template);\n  givenStackExists({\n    Parameters: [\n      { ParameterKey: 'HasValue', ParameterValue: 'HasValue' },\n      { ParameterKey: 'HasDefault', ParameterValue: 'HasDefault' },\n      { ParameterKey: 'OtherParameter', ParameterValue: 'OtherParameter' },\n    ],\n  });\n\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n    stack: FAKE_STACK_WITH_PARAMETERS,\n    parameters: {\n      HasValue: 'NewValue',\n    },\n    usePreviousParameters: true,\n  });\n\n  // THEN\n  expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({\n    Parameters: [\n      { ParameterKey: 'HasValue', ParameterValue: 'NewValue' },\n      { ParameterKey: 'HasDefault', UsePreviousValue: true },\n      { ParameterKey: 'OtherParameter', UsePreviousValue: true },\n    ],\n  }));\n});\n\ntest('if existing stack failed to create, it is deleted and recreated', async () => {\n  // GIVEN\n  givenStackExists(\n    { StackStatus: 'ROLLBACK_COMPLETE' }, // This is for the initial check\n    { StackStatus: 'DELETE_COMPLETE' }, // Poll the successful deletion\n    { StackStatus: 'CREATE_COMPLETE' }, // Poll the recreation\n  );\n  givenTemplateIs({\n    DifferentThan: 'TheDefault',\n  });\n\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n  });\n\n  // THEN\n  expect(cfnMocks.deleteStack).toHaveBeenCalled();\n  expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({\n    ChangeSetType: 'CREATE',\n  }));\n});\n\ntest('if existing stack failed to create, it is deleted and recreated even if the template did not change', async () => {\n  // GIVEN\n  givenStackExists(\n    { StackStatus: 'ROLLBACK_COMPLETE' }, // This is for the initial check\n    { StackStatus: 'DELETE_COMPLETE' }, // Poll the successful deletion\n    { StackStatus: 'CREATE_COMPLETE' }, // Poll the recreation\n  );\n\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n  });\n\n  // THEN\n  expect(cfnMocks.deleteStack).toHaveBeenCalled();\n  expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({\n    ChangeSetType: 'CREATE',\n  }));\n});\n\ntest('deploy not skipped if template did not change and --force is applied', async () => {\n  // GIVEN\n  givenStackExists();\n\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n    force: true,\n  });\n\n  // THEN\n  expect(cfnMocks.executeChangeSet).toHaveBeenCalled();\n});\n\ntest('deploy is skipped if template and tags did not change', async () => {\n  // GIVEN\n  givenStackExists({\n    Tags: [\n      { Key: 'Key1', Value: 'Value1' },\n      { Key: 'Key2', Value: 'Value2' },\n    ],\n  });\n\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n    tags: [\n      { Key: 'Key1', Value: 'Value1' },\n      { Key: 'Key2', Value: 'Value2' },\n    ],\n  });\n\n  // THEN\n  expect(cfnMocks.createChangeSet).not.toBeCalled();\n  expect(cfnMocks.executeChangeSet).not.toBeCalled();\n  expect(cfnMocks.describeStacks).toHaveBeenCalledWith({ StackName: 'withouterrors' });\n  expect(cfnMocks.getTemplate).toHaveBeenCalledWith({ StackName: 'withouterrors', TemplateStage: 'Original' });\n});\n\ntest('deploy not skipped if template did not change but tags changed', async () => {\n  // GIVEN\n  givenStackExists({\n    Tags: [\n      { Key: 'Key', Value: 'Value' },\n    ],\n  });\n\n  // WHEN\n  await deployStack({\n    stack: FAKE_STACK,\n    sdk,\n    sdkProvider,\n    resolvedEnvironment: mockResolvedEnvironment(),\n    tags: [\n      {\n        Key: 'Key',\n        Value: 'NewValue',\n      },\n    ],\n    toolkitInfo: ToolkitInfo.bootstraplessDeploymentsOnly(sdk),\n  });\n\n  // THEN\n  expect(cfnMocks.createChangeSet).toHaveBeenCalled();\n  expect(cfnMocks.executeChangeSet).toHaveBeenCalled();\n  expect(cfnMocks.describeChangeSet).toHaveBeenCalled();\n  expect(cfnMocks.describeStacks).toHaveBeenCalledWith({ StackName: 'withouterrors' });\n  expect(cfnMocks.getTemplate).toHaveBeenCalledWith({ StackName: 'withouterrors', TemplateStage: 'Original' });\n});\n\ntest('deployStack reports no change if describeChangeSet returns specific error', async () => {\n  cfnMocks.describeChangeSet?.mockImplementation(() => ({\n    Status: 'FAILED',\n    StatusReason: 'No updates are to be performed.',\n  }));\n\n  // WHEN\n  const deployResult = await deployStack({\n    ...standardDeployStackArguments(),\n  });\n\n  // THEN\n  expect(deployResult.noOp).toEqual(true);\n});\n\ntest('deploy not skipped if template did not change but one tag removed', async () => {\n  // GIVEN\n  givenStackExists({\n    Tags: [\n      { Key: 'Key1', Value: 'Value1' },\n      { Key: 'Key2', Value: 'Value2' },\n    ],\n  });\n\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n    tags: [\n      { Key: 'Key1', Value: 'Value1' },\n    ],\n  });\n\n  // THEN\n  expect(cfnMocks.createChangeSet).toHaveBeenCalled();\n  expect(cfnMocks.executeChangeSet).toHaveBeenCalled();\n  expect(cfnMocks.describeChangeSet).toHaveBeenCalled();\n  expect(cfnMocks.describeStacks).toHaveBeenCalledWith({ StackName: 'withouterrors' });\n  expect(cfnMocks.getTemplate).toHaveBeenCalledWith({ StackName: 'withouterrors', TemplateStage: 'Original' });\n});\n\ntest('deploy is not skipped if stack is in a _FAILED state', async () => {\n  // GIVEN\n  givenStackExists({\n    StackStatus: 'DELETE_FAILED',\n  });\n\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n    usePreviousParameters: true,\n  }).catch(() => {});\n\n  // THEN\n  expect(cfnMocks.createChangeSet).toHaveBeenCalled();\n});\n\ntest('existing stack in UPDATE_ROLLBACK_COMPLETE state can be updated', async () => {\n  // GIVEN\n  givenStackExists(\n    { StackStatus: 'UPDATE_ROLLBACK_COMPLETE' }, // This is for the initial check\n    { StackStatus: 'UPDATE_COMPLETE' }, // Poll the update\n  );\n  givenTemplateIs({ changed: 123 });\n\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n  });\n\n  // THEN\n  expect(cfnMocks.deleteStack).not.toHaveBeenCalled();\n  expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({\n    ChangeSetType: 'UPDATE',\n  }));\n});\n\ntest('deploy not skipped if template changed', async () => {\n  // GIVEN\n  givenStackExists();\n  givenTemplateIs({ changed: 123 });\n\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n  });\n\n  // THEN\n  expect(cfnMocks.executeChangeSet).toHaveBeenCalled();\n});\n\ntest('not executed and no error if --no-execute is given', async () => {\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n    execute: false,\n  });\n\n  // THEN\n  expect(cfnMocks.executeChangeSet).not.toHaveBeenCalled();\n});\n\ntest('empty change set is deleted if --execute is given', async () => {\n  cfnMocks.describeChangeSet?.mockImplementation(() => ({\n    Status: 'FAILED',\n    StatusReason: 'No updates are to be performed.',\n  }));\n\n  // GIVEN\n  givenStackExists();\n\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n    execute: true,\n    force: true, // Necessary to bypass \"skip deploy\"\n  });\n\n  // THEN\n  expect(cfnMocks.createChangeSet).toHaveBeenCalled();\n  expect(cfnMocks.executeChangeSet).not.toHaveBeenCalled();\n\n  //the first deletion is for any existing cdk change sets, the second is for the deleting the new empty change set\n  expect(cfnMocks.deleteChangeSet).toHaveBeenCalledTimes(2);\n});\n\ntest('empty change set is not deleted if --no-execute is given', async () => {\n  cfnMocks.describeChangeSet?.mockImplementation(() => ({\n    Status: 'FAILED',\n    StatusReason: 'No updates are to be performed.',\n  }));\n\n  // GIVEN\n  givenStackExists();\n\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n    execute: false,\n  });\n\n  // THEN\n  expect(cfnMocks.createChangeSet).toHaveBeenCalled();\n  expect(cfnMocks.executeChangeSet).not.toHaveBeenCalled();\n\n  //the first deletion is for any existing cdk change sets\n  expect(cfnMocks.deleteChangeSet).toHaveBeenCalledTimes(1);\n});\n\ntest('use S3 url for stack deployment if present in Stack Artifact', async () => {\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n    stack: testStack({\n      stackName: 'withouterrors',\n      properties: {\n        stackTemplateAssetObjectUrl: 'https://use-me-use-me/',\n      },\n    }),\n  });\n\n  // THEN\n  expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({\n    TemplateURL: 'https://use-me-use-me/',\n  }));\n  expect(cfnMocks.executeChangeSet).toHaveBeenCalled();\n});\n\ntest('use REST API S3 url with substituted placeholders if manifest url starts with s3://', async () => {\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n    stack: testStack({\n      stackName: 'withouterrors',\n      properties: {\n        stackTemplateAssetObjectUrl: 's3://use-me-use-me-${AWS::AccountId}/object',\n      },\n    }),\n  });\n\n  // THEN\n  expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(expect.objectContaining({\n    TemplateURL: 'https://s3.bermuda-triangle-1337.amazonaws.com/use-me-use-me-123456789/object',\n  }));\n  expect(cfnMocks.executeChangeSet).toHaveBeenCalled();\n});\n\ntest('changeset is created when stack exists in REVIEW_IN_PROGRESS status', async () => {\n  // GIVEN\n  givenStackExists({\n    StackStatus: 'REVIEW_IN_PROGRESS',\n    Tags: [\n      { Key: 'Key1', Value: 'Value1' },\n      { Key: 'Key2', Value: 'Value2' },\n    ],\n  });\n\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n    execute: false,\n  });\n\n  // THEN\n  expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(\n    expect.objectContaining({\n      ChangeSetType: 'CREATE',\n      StackName: 'withouterrors',\n    }),\n  );\n  expect(cfnMocks.executeChangeSet).not.toHaveBeenCalled();\n});\n\ntest('changeset is updated when stack exists in CREATE_COMPLETE status', async () => {\n  // GIVEN\n  givenStackExists({\n    Tags: [\n      { Key: 'Key1', Value: 'Value1' },\n      { Key: 'Key2', Value: 'Value2' },\n    ],\n  });\n\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n    execute: false,\n  });\n\n  // THEN\n  expect(cfnMocks.createChangeSet).toHaveBeenCalledWith(\n    expect.objectContaining({\n      ChangeSetType: 'UPDATE',\n      StackName: 'withouterrors',\n    }),\n  );\n  expect(cfnMocks.executeChangeSet).not.toHaveBeenCalled();\n});\n\ntest('deploy with termination protection enabled', async () => {\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n    stack: FAKE_STACK_TERMINATION_PROTECTION,\n  });\n\n  // THEN\n  expect(cfnMocks.updateTerminationProtection).toHaveBeenCalledWith(expect.objectContaining({\n    EnableTerminationProtection: true,\n  }));\n});\n\ntest('updateTerminationProtection not called when termination protection is undefined', async () => {\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n  });\n\n  // THEN\n  expect(cfnMocks.updateTerminationProtection).not.toHaveBeenCalled();\n});\n\ntest('updateTerminationProtection called when termination protection is undefined and stack has termination protection', async () => {\n  // GIVEN\n  givenStackExists({\n    EnableTerminationProtection: true,\n  });\n\n  // WHEN\n  await deployStack({\n    ...standardDeployStackArguments(),\n  });\n\n  // THEN\n  expect(cfnMocks.updateTerminationProtection).toHaveBeenCalledWith(expect.objectContaining({\n    EnableTerminationProtection: false,\n  }));\n});\n\ndescribe('disable rollback', () => {\n  test('by default, we do not disable rollback (and also do not pass the flag)', async () => {\n    // WHEN\n    await deployStack({\n      ...standardDeployStackArguments(),\n    });\n\n    // THEN\n    expect(cfnMocks.executeChangeSet).toHaveBeenCalledTimes(1);\n    expect(cfnMocks.executeChangeSet).not.toHaveBeenCalledWith(expect.objectContaining({\n      DisableRollback: expect.anything(),\n    }));\n  });\n\n  test('rollback can be disabled by setting rollback: false', async () => {\n    // WHEN\n    await deployStack({\n      ...standardDeployStackArguments(),\n      rollback: false,\n    });\n\n    // THEN\n    expect(cfnMocks.executeChangeSet).toHaveBeenCalledWith(expect.objectContaining({\n      DisableRollback: true,\n    }));\n  });\n\n});\n\n/**\n * Set up the mocks so that it looks like the stack exists to start with\n *\n * The last element of this array will be continuously repeated.\n */\nfunction givenStackExists(...overrides: Array<Partial<AWS.CloudFormation.Stack>>) {\n  cfnMocks.describeStacks!.mockReset();\n\n  if (overrides.length === 0) {\n    overrides = [{}];\n  }\n\n  const baseResponse = {\n    StackName: 'mock-stack-name',\n    StackId: 'mock-stack-id',\n    CreationTime: new Date(),\n    StackStatus: 'CREATE_COMPLETE',\n    EnableTerminationProtection: false,\n  };\n\n  for (const override of overrides.slice(0, overrides.length - 1)) {\n    cfnMocks.describeStacks!.mockImplementationOnce(() => ({\n      Stacks: [{ ...baseResponse, ...override }],\n    }));\n  }\n  cfnMocks.describeStacks!.mockImplementation(() => ({\n    Stacks: [{ ...baseResponse, ...overrides[overrides.length - 1] }],\n  }));\n}\n\nfunction givenTemplateIs(template: any) {\n  cfnMocks.getTemplate!.mockReset();\n  cfnMocks.getTemplate!.mockReturnValue({\n    TemplateBody: JSON.stringify(template),\n  });\n}"]}