@aws-cdk-testing/cli-integ 0.0.0

package/resources/cli-regression-patches/v1.44.0/bootstrapping.integtest.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const aws_helpers_1 = require("./aws-helpers");
+const cdk_helpers_1 = require("./cdk-helpers");
+jest.setTimeout(600000);
+const QUALIFIER = randomString();
+beforeAll(async () => {
+    await cdk_helpers_1.prepareAppFixture();
+});
+beforeEach(async () => {
+    await cdk_helpers_1.cleanup();
+});
+afterEach(async () => {
+    await cdk_helpers_1.cleanup();
+});
+test('can bootstrap without execution', async () => {
+    var _a;
+    const bootstrapStackName = cdk_helpers_1.fullStackName('bootstrap-stack');
+    await cdk_helpers_1.cdk(['bootstrap',
+        '--toolkit-stack-name', bootstrapStackName,
+        '--no-execute']);
+    const resp = await aws_helpers_1.cloudFormation('describeStacks', {
+        StackName: bootstrapStackName,
+    });
+    expect((_a = resp.Stacks) === null || _a === void 0 ? void 0 : _a[0].StackStatus).toEqual('REVIEW_IN_PROGRESS');
+});
+test('upgrade legacy bootstrap stack to new bootstrap stack while in use', async () => {
+    const bootstrapStackName = cdk_helpers_1.fullStackName('bootstrap-stack');
+    const legacyBootstrapBucketName = `aws-cdk-bootstrap-integ-test-legacy-bckt-${randomString()}`;
+    const newBootstrapBucketName = `aws-cdk-bootstrap-integ-test-v2-bckt-${randomString()}`;
+    cdk_helpers_1.rememberToDeleteBucket(legacyBootstrapBucketName); // This one will leak
+    cdk_helpers_1.rememberToDeleteBucket(newBootstrapBucketName); // This one shouldn't leak if the test succeeds, but let's be safe in case it doesn't
+    // Legacy bootstrap
+    await cdk_helpers_1.cdk(['bootstrap',
+        '--toolkit-stack-name', bootstrapStackName,
+        '--bootstrap-bucket-name', legacyBootstrapBucketName]);
+    // Deploy stack that uses file assets
+    await cdk_helpers_1.cdkDeploy('lambda', {
+        options: ['--toolkit-stack-name', bootstrapStackName],
+    });
+    // Upgrade bootstrap stack to "new" style
+    await cdk_helpers_1.cdk(['bootstrap',
+        '--toolkit-stack-name', bootstrapStackName,
+        '--bootstrap-bucket-name', newBootstrapBucketName,
+        '--qualifier', QUALIFIER], {
+        modEnv: {
+            CDK_NEW_BOOTSTRAP: '1',
+        },
+    });
+    // (Force) deploy stack again
+    // --force to bypass the check which says that the template hasn't changed.
+    await cdk_helpers_1.cdkDeploy('lambda', {
+        options: [
+            '--toolkit-stack-name', bootstrapStackName,
+            '--force',
+        ],
+    });
+});
+test.skip('deploy new style synthesis to new style bootstrap', async () => {
+    const bootstrapStackName = cdk_helpers_1.fullStackName('bootstrap-stack');
+    await cdk_helpers_1.cdk(['bootstrap',
+        '--toolkit-stack-name', bootstrapStackName,
+        '--qualifier', QUALIFIER,
+        '--cloudformation-execution-policies', 'arn:aws:iam::aws:policy/AdministratorAccess',
+    ], {
+        modEnv: {
+            CDK_NEW_BOOTSTRAP: '1',
+        },
+    });
+    // Deploy stack that uses file assets
+    await cdk_helpers_1.cdkDeploy('lambda', {
+        options: [
+            '--toolkit-stack-name', bootstrapStackName,
+            '--context', `@aws-cdk/core:bootstrapQualifier=${QUALIFIER}`,
+            '--context', '@aws-cdk/core:newStyleStackSynthesis=1',
+        ],
+    });
+});
+test('deploy old style synthesis to new style bootstrap', async () => {
+    const bootstrapStackName = cdk_helpers_1.fullStackName('bootstrap-stack');
+    await cdk_helpers_1.cdk(['bootstrap',
+        '--toolkit-stack-name', bootstrapStackName,
+        '--qualifier', QUALIFIER,
+        '--cloudformation-execution-policies', 'arn:aws:iam::aws:policy/AdministratorAccess',
+    ], {
+        modEnv: {
+            CDK_NEW_BOOTSTRAP: '1',
+        },
+    });
+    // Deploy stack that uses file assets
+    await cdk_helpers_1.cdkDeploy('lambda', {
+        options: [
+            '--toolkit-stack-name', bootstrapStackName,
+        ],
+    });
+});
+test('deploying new style synthesis to old style bootstrap fails', async () => {
+    const bootstrapStackName = cdk_helpers_1.fullStackName('bootstrap-stack');
+    await cdk_helpers_1.cdk(['bootstrap', '--toolkit-stack-name', bootstrapStackName]);
+    // Deploy stack that uses file assets, this fails because the bootstrap stack
+    // is version checked.
+    await expect(cdk_helpers_1.cdkDeploy('lambda', {
+        options: [
+            '--toolkit-stack-name', bootstrapStackName,
+            '--context', '@aws-cdk/core:newStyleStackSynthesis=1',
+        ],
+    })).rejects.toThrow('exited with error');
+});
+test('can create multiple legacy bootstrap stacks', async () => {
+    var _a;
+    const bootstrapStackName1 = cdk_helpers_1.fullStackName('bootstrap-stack-1');
+    const bootstrapStackName2 = cdk_helpers_1.fullStackName('bootstrap-stack-2');
+    // deploy two toolkit stacks into the same environment (see #1416)
+    // one with tags
+    await cdk_helpers_1.cdk(['bootstrap', '-v', '--toolkit-stack-name', bootstrapStackName1, '--tags', 'Foo=Bar']);
+    await cdk_helpers_1.cdk(['bootstrap', '-v', '--toolkit-stack-name', bootstrapStackName2]);
+    const response = await aws_helpers_1.cloudFormation('describeStacks', { StackName: bootstrapStackName1 });
+    expect((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].Tags).toEqual([
+        { Key: 'Foo', Value: 'Bar' },
+    ]);
+});
+function randomString() {
+    // Crazy
+    return Math.random().toString(36).replace(/[^a-z0-9]+/g, '');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bootstrapping.integtest.js","sourceRoot":"","sources":["bootstrapping.integtest.ts"],"names":[],"mappings":"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","sourcesContent":["import { cloudFormation } from './aws-helpers';\nimport { cdk, cdkDeploy, cleanup, fullStackName, prepareAppFixture, rememberToDeleteBucket } from './cdk-helpers';\n\njest.setTimeout(600_000);\n\nconst QUALIFIER = randomString();\n\nbeforeAll(async () => {\n  await prepareAppFixture();\n});\n\nbeforeEach(async () => {\n  await cleanup();\n});\n\nafterEach(async () => {\n  await cleanup();\n});\n\ntest('can bootstrap without execution', async () => {\n  const bootstrapStackName = fullStackName('bootstrap-stack');\n\n  await cdk(['bootstrap',\n    '--toolkit-stack-name', bootstrapStackName,\n    '--no-execute']);\n\n  const resp = await cloudFormation('describeStacks', {\n    StackName: bootstrapStackName,\n  });\n\n  expect(resp.Stacks?.[0].StackStatus).toEqual('REVIEW_IN_PROGRESS');\n});\n\ntest('upgrade legacy bootstrap stack to new bootstrap stack while in use', async () => {\n  const bootstrapStackName = fullStackName('bootstrap-stack');\n\n  const legacyBootstrapBucketName = `aws-cdk-bootstrap-integ-test-legacy-bckt-${randomString()}`;\n  const newBootstrapBucketName = `aws-cdk-bootstrap-integ-test-v2-bckt-${randomString()}`;\n  rememberToDeleteBucket(legacyBootstrapBucketName);  // This one will leak\n  rememberToDeleteBucket(newBootstrapBucketName);     // This one shouldn't leak if the test succeeds, but let's be safe in case it doesn't\n\n  // Legacy bootstrap\n  await cdk(['bootstrap',\n    '--toolkit-stack-name', bootstrapStackName,\n    '--bootstrap-bucket-name', legacyBootstrapBucketName]);\n\n  // Deploy stack that uses file assets\n  await cdkDeploy('lambda', {\n    options: ['--toolkit-stack-name', bootstrapStackName],\n  });\n\n  // Upgrade bootstrap stack to \"new\" style\n  await cdk(['bootstrap',\n    '--toolkit-stack-name', bootstrapStackName,\n    '--bootstrap-bucket-name', newBootstrapBucketName,\n    '--qualifier', QUALIFIER], {\n    modEnv: {\n      CDK_NEW_BOOTSTRAP: '1',\n    },\n  });\n\n  // (Force) deploy stack again\n  // --force to bypass the check which says that the template hasn't changed.\n  await cdkDeploy('lambda', {\n    options: [\n      '--toolkit-stack-name', bootstrapStackName,\n      '--force',\n    ],\n  });\n});\n\ntest('deploy new style synthesis to new style bootstrap', async () => {\n  const bootstrapStackName = fullStackName('bootstrap-stack');\n\n  await cdk(['bootstrap',\n    '--toolkit-stack-name', bootstrapStackName,\n    '--qualifier', QUALIFIER,\n    '--cloudformation-execution-policies', 'arn:aws:iam::aws:policy/AdministratorAccess',\n  ], {\n    modEnv: {\n      CDK_NEW_BOOTSTRAP: '1',\n    },\n  });\n\n  // Deploy stack that uses file assets\n  await cdkDeploy('lambda', {\n    options: [\n      '--toolkit-stack-name', bootstrapStackName,\n      '--context', `@aws-cdk/core:bootstrapQualifier=${QUALIFIER}`,\n      '--context', '@aws-cdk/core:newStyleStackSynthesis=1',\n    ],\n  });\n});\n\ntest('deploy old style synthesis to new style bootstrap', async () => {\n  const bootstrapStackName = fullStackName('bootstrap-stack');\n\n  await cdk(['bootstrap',\n    '--toolkit-stack-name', bootstrapStackName,\n    '--qualifier', QUALIFIER,\n    '--cloudformation-execution-policies', 'arn:aws:iam::aws:policy/AdministratorAccess',\n  ], {\n    modEnv: {\n      CDK_NEW_BOOTSTRAP: '1',\n    },\n  });\n\n  // Deploy stack that uses file assets\n  await cdkDeploy('lambda', {\n    options: [\n      '--toolkit-stack-name', bootstrapStackName,\n    ],\n  });\n});\n\ntest('deploying new style synthesis to old style bootstrap fails', async () => {\n  const bootstrapStackName = fullStackName('bootstrap-stack');\n\n  await cdk(['bootstrap', '--toolkit-stack-name', bootstrapStackName]);\n\n  // Deploy stack that uses file assets, this fails because the bootstrap stack\n  // is version checked.\n  await expect(cdkDeploy('lambda', {\n    options: [\n      '--toolkit-stack-name', bootstrapStackName,\n      '--context', '@aws-cdk/core:newStyleStackSynthesis=1',\n    ],\n  })).rejects.toThrow('exited with error');\n});\n\ntest('can create multiple legacy bootstrap stacks', async () => {\n  const bootstrapStackName1 = fullStackName('bootstrap-stack-1');\n  const bootstrapStackName2 = fullStackName('bootstrap-stack-2');\n\n  // deploy two toolkit stacks into the same environment (see #1416)\n  // one with tags\n  await cdk(['bootstrap', '-v', '--toolkit-stack-name', bootstrapStackName1, '--tags', 'Foo=Bar']);\n  await cdk(['bootstrap', '-v', '--toolkit-stack-name', bootstrapStackName2]);\n\n  const response = await cloudFormation('describeStacks', { StackName: bootstrapStackName1 });\n  expect(response.Stacks?.[0].Tags).toEqual([\n    { Key: 'Foo', Value: 'Bar' },\n  ]);\n});\n\nfunction randomString() {\n  // Crazy\n  return Math.random().toString(36).replace(/[^a-z0-9]+/g, '');\n}\n"]}

package/resources/cli-regression-patches/v1.44.0/test.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+set -euo pipefail
+scriptdir=$(cd $(dirname $0) && pwd)
+
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo 'CLI Integration Tests'
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+
+current_version=$(node -p "require('${scriptdir}/../../../package.json').version")
+
+# This allows injecting different versions, not just the current one.
+# Useful when testing.
+export VERSION_UNDER_TEST=${VERSION_UNDER_TEST:-${current_version}}
+
+cd $scriptdir
+
+# Install these dependencies that the tests (written in Jest) need.
+# Only if we're not running from the repo, because if we are the
+# dependencies have already been installed by the containing 'aws-cdk' package's
+# package.json.
+if ! npx --no-install jest --version; then
+  echo 'Looks like we need to install jest first. Hold on.' >& 2
+  npm install --prefix . jest aws-sdk
+fi
+
+npx jest --runInBand --verbose "$@"

package/resources/cli-regression-patches/v1.61.1/NOTES.md

@@ -0,0 +1,2 @@
+Introduced a limitation on bootstrapping qualifier length
+(max 10 chars) but old tests were using qualifiers of 12 chars.

package/resources/cli-regression-patches/v1.61.1/skip-tests.txt

@@ -0,0 +1,16 @@
+# This file is empty on purpose. Leave it here as documentation
+# and an example.
+#
+# Copy this file to cli-regression-patches/vX.Y.Z/skip-tests.txt
+# and edit it there if you want to exclude certain tests from running
+# when performing a certain version's regression tests.
+#
+# Put a test name on a line by itself to skip it.
+
+upgrade legacy bootstrap stack to new bootstrap stack while in use
+deploy new style synthesis to new style bootstrap
+deploy new style synthesis to new style bootstrap (with docker image)
+deploy old style synthesis to new style bootstrap
+can dump the template, modify and use it to deploy a custom bootstrap stack
+switch on termination protection, switch is left alone on re-bootstrap
+add tags, left alone on re-bootstrap

package/resources/cli-regression-patches/v1.62.0/NOTES.md

@@ -0,0 +1,2 @@
+Tests now take longer than hour and cause token expiration.
+Added creddentials refreshing in in aws-helper but the older tests don't have it.

package/resources/cli-regression-patches/v1.62.0/aws-helpers.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outputFromStack = exports.deleteBucket = exports.deleteImageRepository = exports.emptyBucket = exports.sleep = exports.retry = exports.isBucketMissingError = exports.isStackMissingError = exports.stackStatus = exports.deleteStacks = exports.sts = exports.lambda = exports.iam = exports.sns = exports.ecr = exports.s3 = exports.cloudFormation = exports.testEnv = void 0;
+const AWS = require("aws-sdk");
+const cdk_helpers_1 = require("./cdk-helpers");
+
+function chainableCredentials(region) {
+  const profileName = process.env.AWS_PROFILE;
+  if (process.env.CODEBUILD_BUILD_ARN && profileName) {
+      // in codebuild we must assume the role that the cdk uses
+      // otherwise credentials will just be picked up by the normal sdk
+      // heuristics and expire after an hour.
+      // can't use '~' since the SDK doesn't seem to expand it...?
+      const configPath = `${process.env.HOME}/.aws/config`;
+      const ini = new AWS.IniLoader().loadFrom({
+          filename: configPath,
+          isConfig: true,
+      });
+      const profile = ini[profileName];
+      if (!profile) {
+          throw new Error(`Profile '${profileName}' does not exist in config file (${configPath})`);
+      }
+      const arn = profile.role_arn;
+      const externalId = profile.external_id;
+      if (!arn) {
+          throw new Error(`role_arn does not exist in profile ${profileName}`);
+      }
+      if (!externalId) {
+          throw new Error(`external_id does not exist in profile ${externalId}`);
+      }
+      return new AWS.ChainableTemporaryCredentials({
+          params: {
+              RoleArn: arn,
+              ExternalId: externalId,
+              RoleSessionName: 'integ-tests',
+          },
+          stsConfig: {
+              region,
+          },
+          masterCredentials: new AWS.ECSCredentials(),
+      });
+  }
+  return undefined;
+}
+
+exports.testEnv = async () => {
+  var _a, _b;
+  const region = (_b = (_a = process.env.AWS_REGION) !== null && _a !== void 0 ? _a : process.env.AWS_DEFAULT_REGION) !== null && _b !== void 0 ? _b : 'us-east-1';
+  const sts = new AWS.STS({
+      region: region,
+      credentials: chainableCredentials(region),
+      maxRetries: 8,
+      retryDelayOptions: { base: 500 },
+  });
+  const response = await sts.getCallerIdentity().promise();
+  const ret = {
+      account: response.Account,
+      region,
+  };
+  exports.testEnv = () => Promise.resolve(ret);
+  return ret;
+};
+
+exports.cloudFormation = makeAwsCaller(AWS.CloudFormation);
+exports.s3 = makeAwsCaller(AWS.S3);
+exports.ecr = makeAwsCaller(AWS.ECR);
+exports.sns = makeAwsCaller(AWS.SNS);
+exports.iam = makeAwsCaller(AWS.IAM);
+exports.lambda = makeAwsCaller(AWS.Lambda);
+exports.sts = makeAwsCaller(AWS.STS);
+/**
+ * Perform an AWS call from nothing
+ *
+ * Create the correct client, do the call and resole the promise().
+ */
+async function awsCall(ctor, call, request) {
+    const env = await exports.testEnv();
+    const cfn = new ctor({
+        region: env.region,
+        credentials: chainableCredentials(env.region),
+        maxRetries: 6,
+        retryDelayOptions: {
+            base: 500,
+        },
+    });
+    const response = cfn[call](request);
+    try {
+        return await response.promise();
+    }
+    catch (e) {
+        const newErr = new Error(`${call}(${JSON.stringify(request)}): ${e.message}`);
+        newErr.code = e.code;
+        throw newErr;
+    }
+}
+/**
+ * Factory function to invoke 'awsCall' for specific services.
+ *
+ * Not strictly necessary but calling this replaces a whole bunch of annoying generics you otherwise have to type:
+ *
+ * ```ts
+ * export function cloudFormation<
+ *   C extends keyof ServiceCalls<AWS.CloudFormation>,
+ * >(call: C, request: First<ServiceCalls<AWS.CloudFormation>[C]>): Promise<Second<ServiceCalls<AWS.CloudFormation>[C]>> {
+ *   return awsCall(AWS.CloudFormation, call, request);
+ * }
+ * ```
+ */
+function makeAwsCaller(ctor) {
+    return (call, request) => {
+        return awsCall(ctor, call, request);
+    };
+}
+async function deleteStacks(...stackNames) {
+    if (stackNames.length === 0) {
+        return;
+    }
+    for (const stackName of stackNames) {
+        await exports.cloudFormation('updateTerminationProtection', {
+            EnableTerminationProtection: false,
+            StackName: stackName,
+        });
+        await exports.cloudFormation('deleteStack', {
+            StackName: stackName,
+        });
+    }
+    await retry(`Deleting ${stackNames}`, retry.forSeconds(600), async () => {
+        for (const stackName of stackNames) {
+            const status = await stackStatus(stackName);
+            if (status !== undefined && status.endsWith('_FAILED')) {
+                throw retry.abort(new Error(`'${stackName}' is in state '${status}'`));
+            }
+            if (status !== undefined) {
+                throw new Error(`Delete of '${stackName}' not complete yet`);
+            }
+        }
+    });
+}
+exports.deleteStacks = deleteStacks;
+async function stackStatus(stackName) {
+    var _a;
+    try {
+        return (_a = (await exports.cloudFormation('describeStacks', { StackName: stackName })).Stacks) === null || _a === void 0 ? void 0 : _a[0].StackStatus;
+    }
+    catch (e) {
+        if (isStackMissingError(e)) {
+            return undefined;
+        }
+        throw e;
+    }
+}
+exports.stackStatus = stackStatus;
+function isStackMissingError(e) {
+    return e.message.indexOf('does not exist') > -1;
+}
+exports.isStackMissingError = isStackMissingError;
+function isBucketMissingError(e) {
+    return e.message.indexOf('does not exist') > -1;
+}
+exports.isBucketMissingError = isBucketMissingError;
+/**
+ * Retry an async operation until a deadline is hit.
+ *
+ * Use `retry.forSeconds()` to construct a deadline relative to right now.
+ *
+ * Exceptions will cause the operation to retry. Use `retry.abort` to annotate an exception
+ * to stop the retry and end in a failure.
+ */
+async function retry(operation, deadline, block) {
+    let i = 0;
+    cdk_helpers_1.log(`💈 ${operation}`);
+    while (true) {
+        try {
+            i++;
+            const ret = await block();
+            cdk_helpers_1.log(`💈 ${operation}: succeeded after ${i} attempts`);
+            return ret;
+        }
+        catch (e) {
+            if (e.abort || Date.now() > deadline.getTime()) {
+                throw new Error(`${operation}: did not succeed after ${i} attempts: ${e}`);
+            }
+            cdk_helpers_1.log(`⏳ ${operation} (${e.message})`);
+            await sleep(5000);
+        }
+    }
+}
+exports.retry = retry;
+/**
+ * Make a deadline for the `retry` function relative to the current time.
+ */
+retry.forSeconds = (seconds) => {
+    return new Date(Date.now() + seconds * 1000);
+};
+/**
+ * Annotate an error to stop the retrying
+ */
+retry.abort = (e) => {
+    e.abort = true;
+    return e;
+};
+async function sleep(ms) {
+    return new Promise(ok => setTimeout(ok, ms));
+}
+exports.sleep = sleep;
+async function emptyBucket(bucketName) {
+    const objects = await exports.s3('listObjects', { Bucket: bucketName });
+    const deletes = (objects.Contents || []).map(obj => obj.Key || '').filter(d => !!d);
+    if (deletes.length === 0) {
+        return Promise.resolve();
+    }
+    return exports.s3('deleteObjects', {
+        Bucket: bucketName,
+        Delete: {
+            Objects: deletes.map(d => ({ Key: d })),
+            Quiet: false,
+        },
+    });
+}
+exports.emptyBucket = emptyBucket;
+async function deleteImageRepository(repositoryName) {
+    await exports.ecr('deleteRepository', { repositoryName, force: true });
+}
+exports.deleteImageRepository = deleteImageRepository;
+async function deleteBucket(bucketName) {
+    try {
+        await emptyBucket(bucketName);
+        await exports.s3('deleteBucket', {
+            Bucket: bucketName,
+        });
+    }
+    catch (e) {
+        if (isBucketMissingError(e)) {
+            return;
+        }
+        throw e;
+    }
+}
+exports.deleteBucket = deleteBucket;
+function outputFromStack(key, stack) {
+    var _a, _b;
+    return (_b = ((_a = stack.Outputs) !== null && _a !== void 0 ? _a : []).find(o => o.OutputKey === key)) === null || _b === void 0 ? void 0 : _b.OutputValue;
+}
+exports.outputFromStack = outputFromStack;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-helpers.js","sourceRoot":"","sources":["aws-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import * as AWS from 'aws-sdk';\nimport { log } from './cdk-helpers';\n\ninterface Env {\n  account: string;\n  region: string;\n}\n\nexport let testEnv = async (): Promise<Env> => {\n  const response = await new AWS.STS().getCallerIdentity().promise();\n\n  const ret: Env = {\n    account: response.Account!,\n    region: process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1',\n  };\n\n  testEnv = () => Promise.resolve(ret);\n  return ret;\n};\n\nexport const cloudFormation = makeAwsCaller(AWS.CloudFormation);\nexport const s3 = makeAwsCaller(AWS.S3);\nexport const ecr = makeAwsCaller(AWS.ECR);\nexport const sns = makeAwsCaller(AWS.SNS);\nexport const iam = makeAwsCaller(AWS.IAM);\nexport const lambda = makeAwsCaller(AWS.Lambda);\nexport const sts = makeAwsCaller(AWS.STS);\n\n/**\n * Perform an AWS call from nothing\n *\n * Create the correct client, do the call and resole the promise().\n */\nasync function awsCall<\n  A extends AWS.Service,\n  B extends keyof ServiceCalls<A>,\n>(ctor: new (config: any) => A, call: B, request: First<ServiceCalls<A>[B]>): Promise<Second<ServiceCalls<A>[B]>> {\n  const env = await testEnv();\n\n  const profileName = process.env.AWS_PROFILE;\n  let creds = undefined;\n  if (process.env.CODEBUILD_BUILD_ARN && profileName) {\n\n    // in codebuild we must assume the role that the cdk uses\n    // otherwise credentials will just be picked up by the normal sdk\n    // heuristics and expire after an hour.\n\n    // can't use '~' since the SDK doesn't seem to expand it...?\n    const configPath = `${process.env.HOME}/.aws/config`;\n    const ini = new AWS.IniLoader().loadFrom({\n      filename: configPath,\n      isConfig: true,\n    });\n\n    const profile = ini[profileName];\n\n    if (!profile) {\n      throw new Error(`Profile '${profileName}' does not exist in config file (${configPath})`);\n    }\n\n    const arn = profile.role_arn;\n    const externalId = profile.external_id;\n\n    if (!arn) {\n      throw new Error(`role_arn does not exist in profile ${profileName}`);\n    }\n\n    if (!externalId) {\n      throw new Error(`external_id does not exist in profile ${externalId}`);\n    }\n\n    creds = new AWS.ChainableTemporaryCredentials({\n      params: {\n        RoleArn: arn,\n        ExternalId: externalId,\n        RoleSessionName: 'integ-tests',\n      },\n      stsConfig: {\n        region: env.region,\n      },\n      masterCredentials: new AWS.ECSCredentials(),\n    });\n\n  }\n\n  const cfn = new ctor({\n    region: env.region,\n    credentials: creds,\n    maxRetries: 6,\n    retryDelayOptions: {\n      base: 500,\n    },\n  });\n\n  const response = cfn[call](request);\n  try {\n    return await response.promise();\n  } catch (e) {\n    const newErr = new Error(`${call}(${JSON.stringify(request)}): ${e.message}`);\n    (newErr as any).code = e.code;\n    throw newErr;\n  }\n}\n\n/**\n * Factory function to invoke 'awsCall' for specific services.\n *\n * Not strictly necessary but calling this replaces a whole bunch of annoying generics you otherwise have to type:\n *\n * ```ts\n * export function cloudFormation<\n *   C extends keyof ServiceCalls<AWS.CloudFormation>,\n * >(call: C, request: First<ServiceCalls<AWS.CloudFormation>[C]>): Promise<Second<ServiceCalls<AWS.CloudFormation>[C]>> {\n *   return awsCall(AWS.CloudFormation, call, request);\n * }\n * ```\n */\nfunction makeAwsCaller<A extends AWS.Service>(ctor: new (config: any) => A) {\n  return <B extends keyof ServiceCalls<A>>(call: B, request: First<ServiceCalls<A>[B]>): Promise<Second<ServiceCalls<A>[B]>> => {\n    return awsCall(ctor, call, request);\n  };\n}\n\ntype ServiceCalls<T> = NoNayNever<SimplifiedService<T>>;\n// Map ever member in the type to the important AWS call overload, or to 'never'\ntype SimplifiedService<T> = {[k in keyof T]: AwsCallIO<T[k]>};\n// Remove all 'never' types from an object type\ntype NoNayNever<T> = Pick<T, {[k in keyof T]: T[k] extends never ? never : k }[keyof T]>;\n\n// Because of the overloads an AWS handler type looks like this:\n//\n//   {\n//      (params: INPUTSTRUCT, callback?: ((err: AWSError, data: {}) => void) | undefined): Request<OUTPUT, ...>;\n//      (callback?: ((err: AWS.AWSError, data: {}) => void) | undefined): AWS.Request<...>;\n//   }\n//\n// Get the first overload and extract the input and output struct types\ntype AwsCallIO<T> =\n  T extends {\n    (args: infer INPUT, callback?: ((err: AWS.AWSError, data: any) => void) | undefined): AWS.Request<infer OUTPUT, AWS.AWSError>;\n    (callback?: ((err: AWS.AWSError, data: {}) => void) | undefined): AWS.Request<any, any>;\n  } ? [INPUT, OUTPUT] : never;\n\ntype First<T> = T extends [any, any] ? T[0] : never;\ntype Second<T> = T extends [any, any] ? T[1] : never;\n\nexport async function deleteStacks(...stackNames: string[]) {\n  if (stackNames.length === 0) { return; }\n\n  for (const stackName of stackNames) {\n    await cloudFormation('updateTerminationProtection', {\n      EnableTerminationProtection: false,\n      StackName: stackName,\n    });\n    await cloudFormation('deleteStack', {\n      StackName: stackName,\n    });\n  }\n\n  await retry(`Deleting ${stackNames}`, retry.forSeconds(600), async () => {\n    for (const stackName of stackNames) {\n      const status = await stackStatus(stackName);\n      if (status !== undefined && status.endsWith('_FAILED')) {\n        throw retry.abort(new Error(`'${stackName}' is in state '${status}'`));\n      }\n      if (status !== undefined) {\n        throw new Error(`Delete of '${stackName}' not complete yet`);\n      }\n    }\n  });\n}\n\nexport async function stackStatus(stackName: string): Promise<string | undefined> {\n  try {\n    return (await cloudFormation('describeStacks', { StackName: stackName })).Stacks?.[0].StackStatus;\n  } catch (e) {\n    if (isStackMissingError(e)) { return undefined; }\n    throw e;\n  }\n}\n\nexport function isStackMissingError(e: Error) {\n  return e.message.indexOf('does not exist') > -1;\n}\n\nexport function isBucketMissingError(e: Error) {\n  return e.message.indexOf('does not exist') > -1;\n}\n\n/**\n * Retry an async operation until a deadline is hit.\n *\n * Use `retry.forSeconds()` to construct a deadline relative to right now.\n *\n * Exceptions will cause the operation to retry. Use `retry.abort` to annotate an exception\n * to stop the retry and end in a failure.\n */\nexport async function retry<A>(operation: string, deadline: Date, block: () => Promise<A>): Promise<A> {\n  let i = 0;\n  log(`💈 ${operation}`);\n  while (true) {\n    try {\n      i++;\n      const ret = await block();\n      log(`💈 ${operation}: succeeded after ${i} attempts`);\n      return ret;\n    } catch (e) {\n      if (e.abort || Date.now() > deadline.getTime( )) {\n        throw new Error(`${operation}: did not succeed after ${i} attempts: ${e}`);\n      }\n      log(`⏳ ${operation} (${e.message})`);\n      await sleep(5000);\n    }\n  }\n}\n\n/**\n * Make a deadline for the `retry` function relative to the current time.\n */\nretry.forSeconds = (seconds: number): Date => {\n  return new Date(Date.now() + seconds * 1000);\n};\n\n/**\n * Annotate an error to stop the retrying\n */\nretry.abort = (e: Error): Error => {\n  (e as any).abort = true;\n  return e;\n};\n\nexport async function sleep(ms: number) {\n  return new Promise(ok => setTimeout(ok, ms));\n}\n\nexport async function emptyBucket(bucketName: string) {\n  const objects = await s3('listObjects', { Bucket: bucketName });\n  const deletes = (objects.Contents || []).map(obj => obj.Key || '').filter(d => !!d);\n  if (deletes.length === 0) {\n    return Promise.resolve();\n  }\n  return s3('deleteObjects', {\n    Bucket: bucketName,\n    Delete: {\n      Objects: deletes.map(d => ({ Key: d })),\n      Quiet: false,\n    },\n  });\n}\n\nexport async function deleteImageRepository(repositoryName: string) {\n  await ecr('deleteRepository', { repositoryName, force: true });\n}\n\nexport async function deleteBucket(bucketName: string) {\n  try {\n    await emptyBucket(bucketName);\n    await s3('deleteBucket', {\n      Bucket: bucketName,\n    });\n  } catch (e) {\n    if (isBucketMissingError(e)) { return; }\n    throw e;\n  }\n}\n\nexport function outputFromStack(key: string, stack: AWS.CloudFormation.Stack): string | undefined {\n  return (stack.Outputs ?? []).find(o => o.OutputKey === key)?.OutputValue;\n}\n"]}

package/resources/cli-regression-patches/v1.63.0/NOTES.md

@@ -0,0 +1 @@
+We made --cloudformation-execution-policies required, old tests don't pass it yet

package/resources/cli-regression-patches/v1.63.0/skip-tests.txt

@@ -0,0 +1,7 @@
+# We made --cloudformation-execution-policies required, old tests don't pass it yet
+
+upgrade legacy bootstrap stack to new bootstrap stack while in use
+deploy new style synthesis to new style bootstrap
+deploy new style synthesis to new style bootstrap (with docker image)
+switch on termination protection, switch is left alone on re-bootstrap
+add tags, left alone on re-bootstrap

package/resources/cli-regression-patches/v1.64.0/NOTES.md

@@ -0,0 +1,3 @@
+Added a `-v` switch to the cdk executions that also needs to be
+applied to the regression tests so we have a better chance
+of catching sporadically failing tests in the act.