aws-cdk
Version:
CDK Toolkit, the command line tool for CDK apps
493 lines • 60.6 kB
JavaScript
"use strict";
/* eslint-disable import/order */
Object.defineProperty(exports, "__esModule", { value: true });
const deployStack = require("../../lib/api/deployments/deploy-stack");
const client_iam_1 = require("@aws-sdk/client-iam");
const api_1 = require("../../lib/api");
const mock_sdk_1 = require("../util/mock-sdk");
const cli_io_host_1 = require("../../lib/toolkit/cli-io-host");
const mockDeployStack = jest.spyOn(deployStack, 'deployStack');
let bootstrapper;
let stderrMock;
beforeEach(() => {
cli_io_host_1.CliIoHost.instance().isCI = false;
bootstrapper = new api_1.Bootstrapper({ source: 'default' });
stderrMock = jest.spyOn(process.stderr, 'write').mockImplementation(() => {
return true;
});
});
afterEach(() => {
stderrMock.mockRestore();
});
function mockTheToolkitInfo(stackProps) {
api_1.ToolkitInfo.lookup = jest.fn().mockResolvedValue(api_1.ToolkitInfo.fromStack((0, mock_sdk_1.mockBootstrapStack)(stackProps)));
}
describe('Bootstrapping v2', () => {
const env = {
account: '123456789012',
region: 'us-east-1',
name: 'mock',
};
let sdk;
beforeEach(() => {
sdk = new mock_sdk_1.MockSdkProvider();
// By default, we'll return a non-found toolkit info
api_1.ToolkitInfo.lookup = jest.fn().mockResolvedValue(api_1.ToolkitInfo.bootstrapStackNotFoundInfo('BootstrapStack'));
const value = {
Policy: {
PolicyName: 'my-policy',
Arn: 'arn:aws:iam::0123456789012:policy/my-policy',
},
};
(0, mock_sdk_1.restoreSdkMocksToDefault)();
(0, mock_sdk_1.setDefaultSTSMocks)();
mock_sdk_1.mockIAMClient.on(client_iam_1.GetPolicyCommand).resolves(value);
mock_sdk_1.mockIAMClient.on(client_iam_1.CreatePolicyCommand).resolves(value);
mockDeployStack.mockResolvedValue({
type: 'did-deploy-stack',
noOp: false,
outputs: {},
stackArn: 'arn:stack',
});
});
afterEach(() => {
mockDeployStack.mockClear();
});
test('passes the bucket name as a CFN parameter', async () => {
await bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
bucketName: 'my-bucket-name',
cloudFormationExecutionPolicies: ['arn:policy'],
},
});
expect(mockDeployStack).toHaveBeenCalledWith(expect.objectContaining({
parameters: expect.objectContaining({
FileAssetsBucketName: 'my-bucket-name',
PublicAccessBlockConfiguration: 'true',
}),
}));
});
test('passes the KMS key ID as a CFN parameter', async () => {
await bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
cloudFormationExecutionPolicies: ['arn:policy'],
kmsKeyId: 'my-kms-key-id',
},
});
expect(mockDeployStack).toHaveBeenCalledWith(expect.objectContaining({
parameters: expect.objectContaining({
FileAssetsBucketKmsKeyId: 'my-kms-key-id',
PublicAccessBlockConfiguration: 'true',
}),
}));
});
test('passes false to PublicAccessBlockConfiguration', async () => {
await bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
cloudFormationExecutionPolicies: ['arn:policy'],
publicAccessBlockConfiguration: false,
},
});
expect(mockDeployStack).toHaveBeenCalledWith(expect.objectContaining({
parameters: expect.objectContaining({
PublicAccessBlockConfiguration: 'false',
}),
}));
});
test('passes true to PermissionsBoundary', async () => {
await bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
examplePermissionsBoundary: true,
},
});
expect(mockDeployStack).toHaveBeenCalledWith(expect.objectContaining({
parameters: expect.objectContaining({
InputPermissionsBoundary: 'cdk-hnb659fds-permissions-boundary',
}),
}));
});
test('passes value to PermissionsBoundary', async () => {
mockTheToolkitInfo({
Parameters: [
{
ParameterKey: 'InputPermissionsBoundary',
ParameterValue: 'existing-pb',
},
],
});
await bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
customPermissionsBoundary: 'permissions-boundary-name',
},
});
expect(mockDeployStack).toHaveBeenCalledWith(expect.objectContaining({
parameters: expect.objectContaining({
InputPermissionsBoundary: 'permissions-boundary-name',
}),
}));
expect(stderrMock.mock.calls).toEqual(expect.arrayContaining([
expect.arrayContaining([
expect.stringMatching(/Changing permissions boundary from existing-pb to permissions-boundary-name/),
]),
]));
});
test('permission boundary switch message does not appear', async () => {
mockTheToolkitInfo({
Parameters: [
{
ParameterKey: 'InputPermissionsBoundary',
ParameterValue: '',
},
],
});
await bootstrapper.bootstrapEnvironment(env, sdk);
expect(stderrMock.mock.calls).toEqual(expect.arrayContaining([expect.not.arrayContaining([expect.stringMatching(/Changing permissions boundary/)])]));
});
test('adding new permissions boundary', async () => {
mockTheToolkitInfo({
Parameters: [
{
ParameterKey: 'InputPermissionsBoundary',
ParameterValue: '',
},
],
});
await bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
customPermissionsBoundary: 'permissions-boundary-name',
},
});
expect(stderrMock.mock.calls).toEqual(expect.arrayContaining([
expect.arrayContaining([expect.stringMatching(/Adding new permissions boundary permissions-boundary-name/)]),
]));
});
test('removing existing permissions boundary', async () => {
mockTheToolkitInfo({
Parameters: [
{
ParameterKey: 'InputPermissionsBoundary',
ParameterValue: 'permissions-boundary-name',
},
],
});
await bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {},
});
expect(stderrMock.mock.calls).toEqual(expect.arrayContaining([
expect.arrayContaining([
expect.stringMatching(/Removing existing permissions boundary permissions-boundary-name/),
]),
]));
});
test('adding permission boundary with path in policy name', async () => {
mockTheToolkitInfo({
Parameters: [
{
ParameterKey: 'InputPermissionsBoundary',
ParameterValue: '',
},
],
});
await bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
customPermissionsBoundary: 'permissions-boundary-name/with/path',
},
});
expect(stderrMock.mock.calls).toEqual(expect.arrayContaining([
expect.arrayContaining([
expect.stringMatching(/Adding new permissions boundary permissions-boundary-name\/with\/path/),
]),
]));
});
test('passing trusted accounts without CFN managed policies results in an error', async () => {
await expect(bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
trustedAccounts: ['123456789012'],
},
})).rejects.toThrow(/--cloudformation-execution-policies/);
});
test('passing trusted accounts without CFN managed policies on the existing stack results in an error', async () => {
mockTheToolkitInfo({
Parameters: [
{
ParameterKey: 'CloudFormationExecutionPolicies',
ParameterValue: '',
},
],
});
await expect(bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
trustedAccounts: ['123456789012'],
},
})).rejects.toThrow(/--cloudformation-execution-policies/);
});
test('passing no CFN managed policies without trusted accounts is okay', async () => {
await bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {},
});
expect(mockDeployStack).toHaveBeenCalledWith(expect.objectContaining({
parameters: expect.objectContaining({
CloudFormationExecutionPolicies: '',
}),
}));
});
test('passing trusted accounts for lookup generates the correct stack parameter', async () => {
await bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
trustedAccountsForLookup: ['123456789012'],
cloudFormationExecutionPolicies: ['aws://foo'],
},
});
expect(mockDeployStack).toHaveBeenCalledWith(expect.objectContaining({
parameters: expect.objectContaining({
TrustedAccountsForLookup: '123456789012',
}),
}));
});
test('allow adding trusted account if there was already a policy on the stack', async () => {
// GIVEN
mockTheToolkitInfo({
Parameters: [
{
ParameterKey: 'CloudFormationExecutionPolicies',
ParameterValue: 'arn:aws:something',
},
],
});
await bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
trustedAccounts: ['123456789012'],
},
});
// Did not throw
});
test('removes trusted account when it is listed as untrusted', async () => {
// GIVEN
mockTheToolkitInfo({
Parameters: [
{
ParameterKey: 'CloudFormationExecutionPolicies',
ParameterValue: 'arn:aws:something',
},
{
ParameterKey: 'TrustedAccounts',
ParameterValue: '111111111111,222222222222',
},
],
});
await bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
untrustedAccounts: ['111111111111'],
},
});
expect(mockDeployStack).toHaveBeenCalledWith(expect.objectContaining({
parameters: expect.objectContaining({
TrustedAccounts: '222222222222',
}),
}));
});
test('removes trusted account for lookup when it is listed as untrusted', async () => {
// GIVEN
mockTheToolkitInfo({
Parameters: [
{
ParameterKey: 'CloudFormationExecutionPolicies',
ParameterValue: 'arn:aws:something',
},
{
ParameterKey: 'TrustedAccountsForLookup',
ParameterValue: '111111111111,222222222222',
},
],
});
await bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
untrustedAccounts: ['111111111111'],
},
});
expect(mockDeployStack).toHaveBeenCalledWith(expect.objectContaining({
parameters: expect.objectContaining({
TrustedAccountsForLookup: '222222222222',
}),
}));
});
test('do not allow accounts to be listed as both trusted and untrusted', async () => {
await expect(bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
trustedAccountsForLookup: ['123456789012'],
untrustedAccounts: ['123456789012'],
},
})).rejects.toThrow('Accounts cannot be both trusted and untrusted. Found: 123456789012');
});
test('Do not allow downgrading bootstrap stack version', async () => {
// GIVEN
mockTheToolkitInfo({
Outputs: [
{
OutputKey: 'BootstrapVersion',
OutputValue: '999',
},
],
});
await expect(bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
cloudFormationExecutionPolicies: ['arn:policy'],
},
})).resolves.toEqual(expect.objectContaining({ noOp: true }));
});
test('Do not allow overwriting bootstrap stack from a different vendor', async () => {
// GIVEN
mockTheToolkitInfo({
Parameters: [
{
ParameterKey: 'BootstrapVariant',
ParameterValue: 'JoeSchmoe',
},
],
});
await expect(bootstrapper.bootstrapEnvironment(env, sdk, {})).resolves.toEqual(expect.objectContaining({ noOp: true }));
});
test('bootstrap template has the right exports', async () => {
let template;
mockDeployStack.mockImplementation((args) => {
template = args.stack.template;
return Promise.resolve({
type: 'did-deploy-stack',
noOp: false,
outputs: {},
stackArn: 'arn:stack',
});
});
await bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
cloudFormationExecutionPolicies: ['arn:policy'],
},
});
const exports = Object.values(template.Outputs ?? {})
.filter((o) => o.Export !== undefined)
.map((o) => o.Export.Name);
expect(exports).toEqual([
// This used to be used by aws-s3-assets
{ 'Fn::Sub': 'CdkBootstrap-${Qualifier}-FileAssetKeyArn' },
]);
});
describe('termination protection', () => {
test('stack is not termination protected by default', async () => {
await bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
cloudFormationExecutionPolicies: ['arn:policy'],
},
});
expect(mockDeployStack).toHaveBeenCalledWith(expect.objectContaining({
stack: expect.objectContaining({
terminationProtection: false,
}),
}));
});
test('stack is termination protected when option is set', async () => {
await bootstrapper.bootstrapEnvironment(env, sdk, {
terminationProtection: true,
parameters: {
cloudFormationExecutionPolicies: ['arn:policy'],
},
});
expect(mockDeployStack).toHaveBeenCalledWith(expect.objectContaining({
stack: expect.objectContaining({
terminationProtection: true,
}),
}));
});
test('termination protection is left alone when option is not given', async () => {
mockTheToolkitInfo({
EnableTerminationProtection: true,
});
await bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
cloudFormationExecutionPolicies: ['arn:policy'],
},
});
expect(mockDeployStack).toHaveBeenCalledWith(expect.objectContaining({
stack: expect.objectContaining({
terminationProtection: true,
}),
}));
});
test('termination protection can be switched off', async () => {
mockTheToolkitInfo({
EnableTerminationProtection: true,
});
await bootstrapper.bootstrapEnvironment(env, sdk, {
terminationProtection: false,
parameters: {
cloudFormationExecutionPolicies: ['arn:policy'],
},
});
expect(mockDeployStack).toHaveBeenCalledWith(expect.objectContaining({
stack: expect.objectContaining({
terminationProtection: false,
}),
}));
});
});
describe('KMS key', () => {
test.each([
// Default case
[undefined, 'AWS_MANAGED_KEY'],
// Create a new key
[true, ''],
// Don't create a new key
[false, 'AWS_MANAGED_KEY'],
])('(new stack) createCustomerMasterKey=%p => parameter becomes %p ', async (createCustomerMasterKey, paramKeyId) => {
// GIVEN: no existing stack
// WHEN
await bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
createCustomerMasterKey,
cloudFormationExecutionPolicies: ['arn:booh'],
},
});
// THEN
expect(mockDeployStack).toHaveBeenCalledWith(expect.objectContaining({
parameters: expect.objectContaining({
FileAssetsBucketKmsKeyId: paramKeyId,
}),
}));
});
test.each([
// Old bootstrap stack being upgraded to new one
[undefined, undefined, 'AWS_MANAGED_KEY'],
// There is a value, user doesn't request a change
['arn:aws:key', undefined, undefined],
// Switch off existing key
['arn:aws:key', false, 'AWS_MANAGED_KEY'],
// Switch on existing key
['AWS_MANAGED_KEY', true, ''],
])('(upgrading) current param %p, createCustomerMasterKey=%p => parameter becomes %p ', async (currentKeyId, createCustomerMasterKey, paramKeyId) => {
// GIVEN
mockTheToolkitInfo({
Parameters: currentKeyId
? [
{
ParameterKey: 'FileAssetsBucketKmsKeyId',
ParameterValue: currentKeyId,
},
]
: undefined,
});
// WHEN
await bootstrapper.bootstrapEnvironment(env, sdk, {
parameters: {
createCustomerMasterKey,
cloudFormationExecutionPolicies: ['arn:booh'],
},
});
// THEN
expect(mockDeployStack).toHaveBeenCalledWith(expect.objectContaining({
parameters: expect.objectContaining({
FileAssetsBucketKmsKeyId: paramKeyId,
}),
}));
});
});
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bootstrap2.test.js","sourceRoot":"","sources":["bootstrap2.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/order */\n\nimport * as deployStack from '../../lib/api/deployments/deploy-stack';\nimport { Stack } from '@aws-sdk/client-cloudformation';\nimport { CreatePolicyCommand, GetPolicyCommand } from '@aws-sdk/client-iam';\nimport { Bootstrapper, ToolkitInfo } from '../../lib/api';\nimport {\n  mockBootstrapStack,\n  mockIAMClient,\n  MockSdkProvider,\n  restoreSdkMocksToDefault, setDefaultSTSMocks,\n} from '../util/mock-sdk';\nimport { CliIoHost } from '../../lib/toolkit/cli-io-host';\n\nconst mockDeployStack = jest.spyOn(deployStack, 'deployStack');\n\nlet bootstrapper: Bootstrapper;\nlet stderrMock: jest.SpyInstance;\n\nbeforeEach(() => {\n  CliIoHost.instance().isCI = false;\n  bootstrapper = new Bootstrapper({ source: 'default' });\n  stderrMock = jest.spyOn(process.stderr, 'write').mockImplementation(() => {\n    return true;\n  });\n});\n\nafterEach(() => {\n  stderrMock.mockRestore();\n});\n\nfunction mockTheToolkitInfo(stackProps: Partial<Stack>) {\n  (ToolkitInfo as any).lookup = jest.fn().mockResolvedValue(ToolkitInfo.fromStack(mockBootstrapStack(stackProps)));\n}\n\ndescribe('Bootstrapping v2', () => {\n  const env = {\n    account: '123456789012',\n    region: 'us-east-1',\n    name: 'mock',\n  };\n\n  let sdk: MockSdkProvider;\n  beforeEach(() => {\n    sdk = new MockSdkProvider();\n    // By default, we'll return a non-found toolkit info\n    (ToolkitInfo as any).lookup = jest.fn().mockResolvedValue(ToolkitInfo.bootstrapStackNotFoundInfo('BootstrapStack'));\n    const value = {\n      Policy: {\n        PolicyName: 'my-policy',\n        Arn: 'arn:aws:iam::0123456789012:policy/my-policy',\n      },\n    };\n    restoreSdkMocksToDefault();\n    setDefaultSTSMocks();\n    mockIAMClient.on(GetPolicyCommand).resolves(value);\n    mockIAMClient.on(CreatePolicyCommand).resolves(value);\n    mockDeployStack.mockResolvedValue({\n      type: 'did-deploy-stack',\n      noOp: false,\n      outputs: {},\n      stackArn: 'arn:stack',\n    });\n  });\n\n  afterEach(() => {\n    mockDeployStack.mockClear();\n  });\n\n  test('passes the bucket name as a CFN parameter', async () => {\n    await bootstrapper.bootstrapEnvironment(env, sdk, {\n      parameters: {\n        bucketName: 'my-bucket-name',\n        cloudFormationExecutionPolicies: ['arn:policy'],\n      },\n    });\n\n    expect(mockDeployStack).toHaveBeenCalledWith(\n      expect.objectContaining({\n        parameters: expect.objectContaining({\n          FileAssetsBucketName: 'my-bucket-name',\n          PublicAccessBlockConfiguration: 'true',\n        }),\n      }),\n    );\n  });\n\n  test('passes the KMS key ID as a CFN parameter', async () => {\n    await bootstrapper.bootstrapEnvironment(env, sdk, {\n      parameters: {\n        cloudFormationExecutionPolicies: ['arn:policy'],\n        kmsKeyId: 'my-kms-key-id',\n      },\n    });\n\n    expect(mockDeployStack).toHaveBeenCalledWith(\n      expect.objectContaining({\n        parameters: expect.objectContaining({\n          FileAssetsBucketKmsKeyId: 'my-kms-key-id',\n          PublicAccessBlockConfiguration: 'true',\n        }),\n      }),\n    );\n  });\n\n  test('passes false to PublicAccessBlockConfiguration', async () => {\n    await bootstrapper.bootstrapEnvironment(env, sdk, {\n      parameters: {\n        cloudFormationExecutionPolicies: ['arn:policy'],\n        publicAccessBlockConfiguration: false,\n      },\n    });\n\n    expect(mockDeployStack).toHaveBeenCalledWith(\n      expect.objectContaining({\n        parameters: expect.objectContaining({\n          PublicAccessBlockConfiguration: 'false',\n        }),\n      }),\n    );\n  });\n\n  test('passes true to PermissionsBoundary', async () => {\n    await bootstrapper.bootstrapEnvironment(env, sdk, {\n      parameters: {\n        examplePermissionsBoundary: true,\n      },\n    });\n\n    expect(mockDeployStack).toHaveBeenCalledWith(\n      expect.objectContaining({\n        parameters: expect.objectContaining({\n          InputPermissionsBoundary: 'cdk-hnb659fds-permissions-boundary',\n        }),\n      }),\n    );\n  });\n\n  test('passes value to PermissionsBoundary', async () => {\n    mockTheToolkitInfo({\n      Parameters: [\n        {\n          ParameterKey: 'InputPermissionsBoundary',\n          ParameterValue: 'existing-pb',\n        },\n      ],\n    });\n    await bootstrapper.bootstrapEnvironment(env, sdk, {\n      parameters: {\n        customPermissionsBoundary: 'permissions-boundary-name',\n      },\n    });\n\n    expect(mockDeployStack).toHaveBeenCalledWith(\n      expect.objectContaining({\n        parameters: expect.objectContaining({\n          InputPermissionsBoundary: 'permissions-boundary-name',\n        }),\n      }),\n    );\n    expect(stderrMock.mock.calls).toEqual(\n      expect.arrayContaining([\n        expect.arrayContaining([\n          expect.stringMatching(/Changing permissions boundary from existing-pb to permissions-boundary-name/),\n        ]),\n      ]),\n    );\n  });\n\n  test('permission boundary switch message does not appear', async () => {\n    mockTheToolkitInfo({\n      Parameters: [\n        {\n          ParameterKey: 'InputPermissionsBoundary',\n          ParameterValue: '',\n        },\n      ],\n    });\n    await bootstrapper.bootstrapEnvironment(env, sdk);\n\n    expect(stderrMock.mock.calls).toEqual(\n      expect.arrayContaining([expect.not.arrayContaining([expect.stringMatching(/Changing permissions boundary/)])]),\n    );\n  });\n\n  test('adding new permissions boundary', async () => {\n    mockTheToolkitInfo({\n      Parameters: [\n        {\n          ParameterKey: 'InputPermissionsBoundary',\n          ParameterValue: '',\n        },\n      ],\n    });\n    await bootstrapper.bootstrapEnvironment(env, sdk, {\n      parameters: {\n        customPermissionsBoundary: 'permissions-boundary-name',\n      },\n    });\n\n    expect(stderrMock.mock.calls).toEqual(\n      expect.arrayContaining([\n        expect.arrayContaining([expect.stringMatching(/Adding new permissions boundary permissions-boundary-name/)]),\n      ]),\n    );\n  });\n\n  test('removing existing permissions boundary', async () => {\n    mockTheToolkitInfo({\n      Parameters: [\n        {\n          ParameterKey: 'InputPermissionsBoundary',\n          ParameterValue: 'permissions-boundary-name',\n        },\n      ],\n    });\n    await bootstrapper.bootstrapEnvironment(env, sdk, {\n      parameters: {},\n    });\n\n    expect(stderrMock.mock.calls).toEqual(\n      expect.arrayContaining([\n        expect.arrayContaining([\n          expect.stringMatching(/Removing existing permissions boundary permissions-boundary-name/),\n        ]),\n      ]),\n    );\n  });\n\n  test('adding permission boundary with path in policy name', async () => {\n    mockTheToolkitInfo({\n      Parameters: [\n        {\n          ParameterKey: 'InputPermissionsBoundary',\n          ParameterValue: '',\n        },\n      ],\n    });\n    await bootstrapper.bootstrapEnvironment(env, sdk, {\n      parameters: {\n        customPermissionsBoundary: 'permissions-boundary-name/with/path',\n      },\n    });\n\n    expect(stderrMock.mock.calls).toEqual(\n      expect.arrayContaining([\n        expect.arrayContaining([\n          expect.stringMatching(/Adding new permissions boundary permissions-boundary-name\\/with\\/path/),\n        ]),\n      ]),\n    );\n  });\n\n  test('passing trusted accounts without CFN managed policies results in an error', async () => {\n    await expect(\n      bootstrapper.bootstrapEnvironment(env, sdk, {\n        parameters: {\n          trustedAccounts: ['123456789012'],\n        },\n      }),\n    ).rejects.toThrow(/--cloudformation-execution-policies/);\n  });\n\n  test('passing trusted accounts without CFN managed policies on the existing stack results in an error', async () => {\n    mockTheToolkitInfo({\n      Parameters: [\n        {\n          ParameterKey: 'CloudFormationExecutionPolicies',\n          ParameterValue: '',\n        },\n      ],\n    });\n\n    await expect(\n      bootstrapper.bootstrapEnvironment(env, sdk, {\n        parameters: {\n          trustedAccounts: ['123456789012'],\n        },\n      }),\n    ).rejects.toThrow(/--cloudformation-execution-policies/);\n  });\n\n  test('passing no CFN managed policies without trusted accounts is okay', async () => {\n    await bootstrapper.bootstrapEnvironment(env, sdk, {\n      parameters: {},\n    });\n\n    expect(mockDeployStack).toHaveBeenCalledWith(\n      expect.objectContaining({\n        parameters: expect.objectContaining({\n          CloudFormationExecutionPolicies: '',\n        }),\n      }),\n    );\n  });\n\n  test('passing trusted accounts for lookup generates the correct stack parameter', async () => {\n    await bootstrapper.bootstrapEnvironment(env, sdk, {\n      parameters: {\n        trustedAccountsForLookup: ['123456789012'],\n        cloudFormationExecutionPolicies: ['aws://foo'],\n      },\n    });\n\n    expect(mockDeployStack).toHaveBeenCalledWith(\n      expect.objectContaining({\n        parameters: expect.objectContaining({\n          TrustedAccountsForLookup: '123456789012',\n        }),\n      }),\n    );\n  });\n\n  test('allow adding trusted account if there was already a policy on the stack', async () => {\n    // GIVEN\n    mockTheToolkitInfo({\n      Parameters: [\n        {\n          ParameterKey: 'CloudFormationExecutionPolicies',\n          ParameterValue: 'arn:aws:something',\n        },\n      ],\n    });\n\n    await bootstrapper.bootstrapEnvironment(env, sdk, {\n      parameters: {\n        trustedAccounts: ['123456789012'],\n      },\n    });\n    // Did not throw\n  });\n\n  test('removes trusted account when it is listed as untrusted', async () => {\n    // GIVEN\n    mockTheToolkitInfo({\n      Parameters: [\n        {\n          ParameterKey: 'CloudFormationExecutionPolicies',\n          ParameterValue: 'a