aws-cdk
Version:
CDK Toolkit, the command line tool for CDK apps
167 lines • 23 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const cx_api_1 = require("@aws-cdk/cx-api");
const client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
const mock_sdk_1 = require("./mock-sdk");
const deployments_1 = require("../../lib/api/deployments");
const PARAM = 'TheParameter';
const DEFAULT = 'TheDefault';
const OVERRIDE = 'TheOverride';
const USE_OVERRIDE = { ParameterKey: PARAM, ParameterValue: OVERRIDE };
const USE_PREVIOUS = { ParameterKey: PARAM, UsePreviousValue: true };
let cfn;
beforeEach(async () => {
cfn = new mock_sdk_1.MockSdk().cloudFormation();
});
test('A non-existent stack pretends to have an empty template', async () => {
// GIVEN
mock_sdk_1.mockCloudFormationClient.on(client_cloudformation_1.DescribeStacksCommand).resolves({
Stacks: [],
});
// WHEN
const stack = await deployments_1.CloudFormationStack.lookup(cfn, 'Dummy');
// THEN
expect(await stack.template()).toEqual({});
});
test("Retrieving a processed template passes 'Processed' to CloudFormation", async () => {
// GIVEN
mock_sdk_1.mockCloudFormationClient
.on(client_cloudformation_1.DescribeStacksCommand)
.resolves({
Stacks: [
{
StackName: 'Dummy',
StackStatus: client_cloudformation_1.StackStatus.CREATE_COMPLETE,
CreationTime: new Date(),
},
],
})
.on(client_cloudformation_1.GetTemplateCommand)
.resolves({
TemplateBody: '',
});
// WHEN
const retrieveProcessedTemplate = true;
const cloudFormationStack = await deployments_1.CloudFormationStack.lookup(cfn, 'Dummy', retrieveProcessedTemplate);
await cloudFormationStack.template();
// THEN
expect(mock_sdk_1.mockCloudFormationClient).toHaveReceivedCommandWith(client_cloudformation_1.GetTemplateCommand, {
StackName: 'Dummy',
TemplateStage: 'Processed',
});
});
test.each([
[false, false],
[false, true],
[true, false],
[true, true],
])('given override, always use the override (parameter has a default: %p, parameter previously supplied: %p)', (haveDefault, havePrevious) => {
expect(makeParams(haveDefault, havePrevious, true)).toEqual({
apiParameters: [USE_OVERRIDE],
changed: true,
});
});
test('no default, no prev, no override => error', () => {
expect(() => makeParams(false, false, false)).toThrow(/missing a value: TheParameter/);
});
test('no default, yes prev, no override => use previous', () => {
expect(makeParams(false, true, false)).toEqual({
apiParameters: [USE_PREVIOUS],
changed: false,
});
});
test('default, no prev, no override => empty param set (and obviously changes to be applied)', () => {
expect(makeParams(true, false, false)).toEqual({
apiParameters: [],
changed: true,
});
});
test('default, prev, no override => use previous', () => {
expect(makeParams(true, true, false)).toEqual({
apiParameters: [USE_PREVIOUS],
changed: false,
});
});
test('if a parameter is retrieved from SSM, the parameters always count as changed', () => {
const params = deployments_1.TemplateParameters.fromTemplate({
Parameters: {
Foo: {
Type: 'AWS::SSM::Parameter::Name',
Default: '/Some/Key',
},
},
});
const oldValues = { Foo: '/Some/Key' };
// If we don't pass a new value
expect(params.updateExisting({}, oldValues).hasChanges(oldValues)).toEqual('ssm');
// If we do pass a new value but it's the same as the old one
expect(params.updateExisting({ Foo: '/Some/Key' }, oldValues).hasChanges(oldValues)).toEqual('ssm');
});
test('if a parameter is retrieved from SSM, the parameters doesnt count as changed if it has the magic marker', () => {
const params = deployments_1.TemplateParameters.fromTemplate({
Parameters: {
Foo: {
Type: 'AWS::SSM::Parameter::Name',
Default: '/Some/Key',
Description: `blabla ${cx_api_1.SSMPARAM_NO_INVALIDATE}`,
},
},
});
const oldValues = { Foo: '/Some/Key' };
// If we don't pass a new value
expect(params.updateExisting({}, oldValues).hasChanges(oldValues)).toEqual(false);
// If we do pass a new value but it's the same as the old one
expect(params.updateExisting({ Foo: '/Some/Key' }, oldValues).hasChanges(oldValues)).toEqual(false);
// If we do pass a new value and it's different
expect(params.updateExisting({ Foo: '/OTHER/Key' }, oldValues).hasChanges(oldValues)).toEqual(true);
});
test('empty string is a valid update value', () => {
const params = deployments_1.TemplateParameters.fromTemplate({
Parameters: {
Foo: { Type: 'String', Default: 'Foo' },
},
});
expect(params.updateExisting({ Foo: '' }, { Foo: 'ThisIsOld' }).apiParameters).toEqual([
{ ParameterKey: 'Foo', ParameterValue: '' },
]);
});
test('unknown parameter in overrides, pass it anyway', () => {
// Not sure if we really want this. It seems like it would be nice
// to not pass parameters that aren't expected, given that CFN will
// just error out. But maybe we want to be warned of typos...
const params = deployments_1.TemplateParameters.fromTemplate({
Parameters: {
Foo: { Type: 'String', Default: 'Foo' },
},
});
expect(params.updateExisting({ Bar: 'Bar' }, {}).apiParameters).toEqual([
{ ParameterKey: 'Bar', ParameterValue: 'Bar' },
]);
});
test('if an unsupplied parameter reverts to its default, it can still be dirty', () => {
// GIVEN
const templateParams = deployments_1.TemplateParameters.fromTemplate({
Parameters: {
Foo: { Type: 'String', Default: 'Foo' },
},
});
// WHEN
const stackParams = templateParams.supplyAll({});
// THEN
expect(stackParams.hasChanges({ Foo: 'NonStandard' })).toEqual(true);
expect(stackParams.hasChanges({ Foo: 'Foo' })).toEqual(false);
});
function makeParams(defaultValue, hasPrevValue, override) {
const params = deployments_1.TemplateParameters.fromTemplate({
Parameters: {
[PARAM]: {
Type: 'String',
Default: defaultValue ? DEFAULT : undefined,
},
},
});
const prevParams = hasPrevValue ? { [PARAM]: 'Foo' } : {};
const stackParams = params.updateExisting({ [PARAM]: override ? OVERRIDE : undefined }, prevParams);
return { apiParameters: stackParams.apiParameters, changed: stackParams.hasChanges(prevParams) };
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloudformation.test.js","sourceRoot":"","sources":["cloudformation.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { SSMPARAM_NO_INVALIDATE } from '@aws-cdk/cx-api';\nimport { DescribeStacksCommand, GetTemplateCommand, StackStatus } from '@aws-sdk/client-cloudformation';\nimport { MockSdk, mockCloudFormationClient } from './mock-sdk';\nimport type { ICloudFormationClient } from '../../lib/api/aws-auth';\nimport { CloudFormationStack, TemplateParameters } from '../../lib/api/deployments';\n\nconst PARAM = 'TheParameter';\nconst DEFAULT = 'TheDefault';\nconst OVERRIDE = 'TheOverride';\n\nconst USE_OVERRIDE = { ParameterKey: PARAM, ParameterValue: OVERRIDE };\nconst USE_PREVIOUS = { ParameterKey: PARAM, UsePreviousValue: true };\n\nlet cfn: ICloudFormationClient;\n\nbeforeEach(async () => {\n  cfn = new MockSdk().cloudFormation();\n});\n\ntest('A non-existent stack pretends to have an empty template', async () => {\n  // GIVEN\n  mockCloudFormationClient.on(DescribeStacksCommand).resolves({\n    Stacks: [],\n  });\n\n  // WHEN\n  const stack = await CloudFormationStack.lookup(cfn, 'Dummy');\n\n  // THEN\n  expect(await stack.template()).toEqual({});\n});\n\ntest(\"Retrieving a processed template passes 'Processed' to CloudFormation\", async () => {\n  // GIVEN\n  mockCloudFormationClient\n    .on(DescribeStacksCommand)\n    .resolves({\n      Stacks: [\n        {\n          StackName: 'Dummy',\n          StackStatus: StackStatus.CREATE_COMPLETE,\n          CreationTime: new Date(),\n        },\n      ],\n    })\n    .on(GetTemplateCommand)\n    .resolves({\n      TemplateBody: '',\n    });\n\n  // WHEN\n  const retrieveProcessedTemplate = true;\n  const cloudFormationStack = await CloudFormationStack.lookup(cfn, 'Dummy', retrieveProcessedTemplate);\n  await cloudFormationStack.template();\n\n  // THEN\n  expect(mockCloudFormationClient).toHaveReceivedCommandWith(GetTemplateCommand, {\n    StackName: 'Dummy',\n    TemplateStage: 'Processed',\n  });\n});\n\ntest.each([\n  [false, false],\n  [false, true],\n  [true, false],\n  [true, true],\n])(\n  'given override, always use the override (parameter has a default: %p, parameter previously supplied: %p)',\n  (haveDefault, havePrevious) => {\n    expect(makeParams(haveDefault, havePrevious, true)).toEqual({\n      apiParameters: [USE_OVERRIDE],\n      changed: true,\n    });\n  },\n);\n\ntest('no default, no prev, no override => error', () => {\n  expect(() => makeParams(false, false, false)).toThrow(/missing a value: TheParameter/);\n});\n\ntest('no default, yes prev, no override => use previous', () => {\n  expect(makeParams(false, true, false)).toEqual({\n    apiParameters: [USE_PREVIOUS],\n    changed: false,\n  });\n});\n\ntest('default, no prev, no override => empty param set (and obviously changes to be applied)', () => {\n  expect(makeParams(true, false, false)).toEqual({\n    apiParameters: [],\n    changed: true,\n  });\n});\n\ntest('default, prev, no override => use previous', () => {\n  expect(makeParams(true, true, false)).toEqual({\n    apiParameters: [USE_PREVIOUS],\n    changed: false,\n  });\n});\n\ntest('if a parameter is retrieved from SSM, the parameters always count as changed', () => {\n  const params = TemplateParameters.fromTemplate({\n    Parameters: {\n      Foo: {\n        Type: 'AWS::SSM::Parameter::Name',\n        Default: '/Some/Key',\n      },\n    },\n  });\n  const oldValues = { Foo: '/Some/Key' };\n\n  // If we don't pass a new value\n  expect(params.updateExisting({}, oldValues).hasChanges(oldValues)).toEqual('ssm');\n\n  // If we do pass a new value but it's the same as the old one\n  expect(params.updateExisting({ Foo: '/Some/Key' }, oldValues).hasChanges(oldValues)).toEqual('ssm');\n});\n\ntest('if a parameter is retrieved from SSM, the parameters doesnt count as changed if it has the magic marker', () => {\n  const params = TemplateParameters.fromTemplate({\n    Parameters: {\n      Foo: {\n        Type: 'AWS::SSM::Parameter::Name',\n        Default: '/Some/Key',\n        Description: `blabla ${SSMPARAM_NO_INVALIDATE}`,\n      },\n    },\n  });\n  const oldValues = { Foo: '/Some/Key' };\n\n  // If we don't pass a new value\n  expect(params.updateExisting({}, oldValues).hasChanges(oldValues)).toEqual(false);\n\n  // If we do pass a new value but it's the same as the old one\n  expect(params.updateExisting({ Foo: '/Some/Key' }, oldValues).hasChanges(oldValues)).toEqual(false);\n\n  // If we do pass a new value and it's different\n  expect(params.updateExisting({ Foo: '/OTHER/Key' }, oldValues).hasChanges(oldValues)).toEqual(true);\n});\n\ntest('empty string is a valid update value', () => {\n  const params = TemplateParameters.fromTemplate({\n    Parameters: {\n      Foo: { Type: 'String', Default: 'Foo' },\n    },\n  });\n\n  expect(params.updateExisting({ Foo: '' }, { Foo: 'ThisIsOld' }).apiParameters).toEqual([\n    { ParameterKey: 'Foo', ParameterValue: '' },\n  ]);\n});\n\ntest('unknown parameter in overrides, pass it anyway', () => {\n  // Not sure if we really want this. It seems like it would be nice\n  // to not pass parameters that aren't expected, given that CFN will\n  // just error out. But maybe we want to be warned of typos...\n  const params = TemplateParameters.fromTemplate({\n    Parameters: {\n      Foo: { Type: 'String', Default: 'Foo' },\n    },\n  });\n\n  expect(params.updateExisting({ Bar: 'Bar' }, {}).apiParameters).toEqual([\n    { ParameterKey: 'Bar', ParameterValue: 'Bar' },\n  ]);\n});\n\ntest('if an unsupplied parameter reverts to its default, it can still be dirty', () => {\n  // GIVEN\n  const templateParams = TemplateParameters.fromTemplate({\n    Parameters: {\n      Foo: { Type: 'String', Default: 'Foo' },\n    },\n  });\n\n  // WHEN\n  const stackParams = templateParams.supplyAll({});\n\n  // THEN\n  expect(stackParams.hasChanges({ Foo: 'NonStandard' })).toEqual(true);\n  expect(stackParams.hasChanges({ Foo: 'Foo' })).toEqual(false);\n});\n\nfunction makeParams(defaultValue: boolean, hasPrevValue: boolean, override: boolean) {\n  const params = TemplateParameters.fromTemplate({\n    Parameters: {\n      [PARAM]: {\n        Type: 'String',\n        Default: defaultValue ? DEFAULT : undefined,\n      },\n    },\n  });\n  const prevParams: Record<string, string> = hasPrevValue ? { [PARAM]: 'Foo' } : {};\n  const stackParams = params.updateExisting({ [PARAM]: override ? OVERRIDE : undefined }, prevParams);\n\n  return { apiParameters: stackParams.apiParameters, changed: stackParams.hasChanges(prevParams) };\n}\n"]}