aws-cdk
Version:
CDK Toolkit, the command line tool for CDK apps
172 lines • 23.7 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/* eslint-disable import/order */
const cx_api_1 = require("@aws-cdk/cx-api");
const mock_sdk_1 = require("./mock-sdk");
const cloudformation_1 = require("../../lib/api/util/cloudformation");
const PARAM = 'TheParameter';
const DEFAULT = 'TheDefault';
const OVERRIDE = 'TheOverride';
const USE_OVERRIDE = { ParameterKey: PARAM, ParameterValue: OVERRIDE };
const USE_PREVIOUS = { ParameterKey: PARAM, UsePreviousValue: true };
let sdkProvider;
let describeStackMock;
let getTemplateMock;
let cfnMocks;
let cfn;
beforeEach(async () => {
sdkProvider = new mock_sdk_1.MockSdkProvider();
describeStackMock = jest.fn();
getTemplateMock = jest.fn();
cfnMocks = {
describeStacks: describeStackMock,
getTemplate: getTemplateMock,
};
sdkProvider.stubCloudFormation(cfnMocks);
cfn = (await sdkProvider.forEnvironment()).sdk.cloudFormation();
});
test('A non-existent stack pretends to have an empty template', async () => {
// GIVEN
describeStackMock.mockImplementation(() => ({ Stacks: [] })); // No stacks exist
// WHEN
const stack = await cloudformation_1.CloudFormationStack.lookup(cfn, 'Dummy');
// THEN
expect(await stack.template()).toEqual({});
});
test("Retrieving a processed template passes 'Processed' to CloudFormation", async () => {
// GIVEN
describeStackMock.mockImplementation(() => ({
Stacks: [
{
StackName: 'Dummy',
},
],
}));
getTemplateMock.mockImplementation(() => ({
TemplateBody: '{}',
}));
// WHEN
const retrieveProcessedTemplate = true;
const cloudFormationStack = await cloudformation_1.CloudFormationStack.lookup(cfn, 'Dummy', retrieveProcessedTemplate);
await cloudFormationStack.template();
// THEN
expect(getTemplateMock).toHaveBeenCalledWith({
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 = cloudformation_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 = cloudformation_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 = cloudformation_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 = cloudformation_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 = cloudformation_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 = cloudformation_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":["/* eslint-disable import/order */\nimport { SSMPARAM_NO_INVALIDATE } from '@aws-cdk/cx-api';\nimport { MockedObject, MockSdkProvider, SyncHandlerSubsetOf } from './mock-sdk';\nimport { CloudFormationStack, TemplateParameters } from '../../lib/api/util/cloudformation';\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 sdkProvider: MockSdkProvider;\nlet describeStackMock: jest.Mock;\nlet getTemplateMock: jest.Mock;\nlet cfnMocks: MockedObject<SyncHandlerSubsetOf<AWS.CloudFormation>>;\nlet cfn: AWS.CloudFormation;\nbeforeEach(async () => {\n  sdkProvider = new MockSdkProvider();\n\n  describeStackMock = jest.fn();\n  getTemplateMock = jest.fn();\n  cfnMocks = {\n    describeStacks: describeStackMock,\n    getTemplate: getTemplateMock,\n  };\n  sdkProvider.stubCloudFormation(cfnMocks as any);\n  cfn = (await sdkProvider.forEnvironment()).sdk.cloudFormation();\n});\n\ntest('A non-existent stack pretends to have an empty template', async () => {\n  // GIVEN\n  describeStackMock.mockImplementation(() => ({ Stacks: [] })); // No stacks exist\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  describeStackMock.mockImplementation(() => ({\n    Stacks: [\n      {\n        StackName: 'Dummy',\n      },\n    ],\n  }));\n  getTemplateMock.mockImplementation(() => ({\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(getTemplateMock).toHaveBeenCalledWith({\n    StackName: 'Dummy',\n    TemplateStage: 'Processed',\n  });\n});\n\ntest.each([\n  [false, false],\n  [false, true],\n  [true, false],\n  [true, true],\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\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"]}