@aws-cdk-testing/cli-integ 2.61.0

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

@@ -0,0 +1,2 @@
+Integration tests are now injected with environment variable that specifies which framework
+version they should install and use. This patch includes the cdk-helpers.js file that is responsible for that.

package/resources/cli-regression-patches/v1.67.0/cdk-helpers.js

@@ -0,0 +1,331 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomString = exports.rimraf = exports.shell = exports.TestFixture = exports.cloneDirectory = exports.withDefaultFixture = exports.withCdkApp = exports.withAws = void 0;
+const child_process = require("child_process");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const aws_helpers_1 = require("./aws-helpers");
+const resource_pool_1 = require("./resource-pool");
+const REGIONS = process.env.AWS_REGIONS
+    ? process.env.AWS_REGIONS.split(',')
+    : [(_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 FRAMEWORK_VERSION = process.env.FRAMEWORK_VERSION;
+process.stdout.write(`Using regions: ${REGIONS}\n`);
+process.stdout.write(`Using framework version: ${FRAMEWORK_VERSION}\n`);
+const REGION_POOL = new resource_pool_1.ResourcePool(REGIONS);
+/**
+ * Higher order function to execute a block with an AWS client setup
+ *
+ * Allocate the next region from the REGION pool and dispose it afterwards.
+ */
+function withAws(block) {
+    return (context) => REGION_POOL.using(async (region) => {
+        const aws = await aws_helpers_1.AwsClients.forRegion(region, context.output);
+        await sanityCheck(aws);
+        return block({ ...context, aws });
+    });
+}
+exports.withAws = withAws;
+/**
+ * Higher order function to execute a block with a CDK app fixture
+ *
+ * Requires an AWS client to be passed in.
+ *
+ * For backwards compatibility with existing tests (so we don't have to change
+ * too much) the inner block is expected to take a `TestFixture` object.
+ */
+function withCdkApp(block) {
+    return async (context) => {
+        const randy = randomString();
+        const stackNamePrefix = `cdktest-${randy}`;
+        const integTestDir = path.join(os.tmpdir(), `cdk-integ-${randy}`);
+        context.output.write(` Stack prefix:   ${stackNamePrefix}\n`);
+        context.output.write(` Test directory: ${integTestDir}\n`);
+        context.output.write(` Region:         ${context.aws.region}\n`);
+        await cloneDirectory(path.join(__dirname, 'app'), integTestDir, context.output);
+        const fixture = new TestFixture(integTestDir, stackNamePrefix, context.output, context.aws);
+        let success = true;
+        try {
+            let modules = [
+                '@aws-cdk/core',
+                '@aws-cdk/aws-sns',
+                '@aws-cdk/aws-iam',
+                '@aws-cdk/aws-lambda',
+                '@aws-cdk/aws-ssm',
+                '@aws-cdk/aws-ecr-assets',
+                '@aws-cdk/aws-cloudformation',
+                '@aws-cdk/aws-ec2',
+            ];
+            if (FRAMEWORK_VERSION) {
+                modules = modules.map(module => `${module}@${FRAMEWORK_VERSION}`);
+            }
+            await fixture.shell(['npm', 'install', ...modules]);
+            await ensureBootstrapped(fixture);
+            await block(fixture);
+        }
+        catch (e) {
+            success = false;
+            throw e;
+        }
+        finally {
+            await fixture.dispose(success);
+        }
+    };
+}
+exports.withCdkApp = withCdkApp;
+/**
+ * Default test fixture for most (all?) integ tests
+ *
+ * It's a composition of withAws/withCdkApp, expecting the test block to take a `TestFixture`
+ * object.
+ *
+ * We could have put `withAws(withCdkApp(fixture => { /... actual test here.../ }))` in every
+ * test declaration but centralizing it is going to make it convenient to modify in the future.
+ */
+function withDefaultFixture(block) {
+    return withAws(withCdkApp(block));
+    //              ^~~~~~ this is disappointing TypeScript! Feels like you should have been able to derive this.
+}
+exports.withDefaultFixture = withDefaultFixture;
+/**
+ * Prepare a target dir byreplicating a source directory
+ */
+async function cloneDirectory(source, target, output) {
+    await shell(['rm', '-rf', target], { output });
+    await shell(['mkdir', '-p', target], { output });
+    await shell(['cp', '-R', source + '/*', target], { output });
+}
+exports.cloneDirectory = cloneDirectory;
+class TestFixture {
+    constructor(integTestDir, stackNamePrefix, output, aws) {
+        this.integTestDir = integTestDir;
+        this.stackNamePrefix = stackNamePrefix;
+        this.output = output;
+        this.aws = aws;
+        this.qualifier = randomString().slice(0, 10);
+        this.bucketsToDelete = new Array();
+    }
+    log(s) {
+        this.output.write(`${s}\n`);
+    }
+    async shell(command, options = {}) {
+        return shell(command, {
+            output: this.output,
+            cwd: this.integTestDir,
+            ...options,
+        });
+    }
+    async cdkDeploy(stackNames, options = {}) {
+        var _a, _b;
+        stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames;
+        const neverRequireApproval = (_a = options.neverRequireApproval) !== null && _a !== void 0 ? _a : true;
+        return this.cdk(['deploy',
+            ...(neverRequireApproval ? ['--require-approval=never'] : []), // Default to no approval in an unattended test
+            ...((_b = options.options) !== null && _b !== void 0 ? _b : []), ...this.fullStackName(stackNames)], options);
+    }
+    async cdkDestroy(stackNames, options = {}) {
+        var _a;
+        stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames;
+        return this.cdk(['destroy',
+            '-f', // We never want a prompt in an unattended test
+            ...((_a = options.options) !== null && _a !== void 0 ? _a : []), ...this.fullStackName(stackNames)], options);
+    }
+    async cdk(args, options = {}) {
+        var _a;
+        const verbose = (_a = options.verbose) !== null && _a !== void 0 ? _a : true;
+        return this.shell(['cdk', ...(verbose ? ['-v'] : []), ...args], {
+            ...options,
+            modEnv: {
+                AWS_REGION: this.aws.region,
+                AWS_DEFAULT_REGION: this.aws.region,
+                STACK_NAME_PREFIX: this.stackNamePrefix,
+                ...options.modEnv,
+            },
+        });
+    }
+    fullStackName(stackNames) {
+        if (typeof stackNames === 'string') {
+            return `${this.stackNamePrefix}-${stackNames}`;
+        }
+        else {
+            return stackNames.map(s => `${this.stackNamePrefix}-${s}`);
+        }
+    }
+    /**
+     * Append this to the list of buckets to potentially delete
+     *
+     * At the end of a test, we clean up buckets that may not have gotten destroyed
+     * (for whatever reason).
+     */
+    rememberToDeleteBucket(bucketName) {
+        this.bucketsToDelete.push(bucketName);
+    }
+    /**
+     * Cleanup leftover stacks and buckets
+     */
+    async dispose(success) {
+        const stacksToDelete = await this.deleteableStacks(this.stackNamePrefix);
+        // Bootstrap stacks have buckets that need to be cleaned
+        const bucketNames = stacksToDelete.map(stack => aws_helpers_1.outputFromStack('BucketName', stack)).filter(defined);
+        await Promise.all(bucketNames.map(b => this.aws.emptyBucket(b)));
+        // Bootstrap stacks have ECR repositories with images which should be deleted
+        const imageRepositoryNames = stacksToDelete.map(stack => aws_helpers_1.outputFromStack('ImageRepositoryName', stack)).filter(defined);
+        await Promise.all(imageRepositoryNames.map(r => this.aws.deleteImageRepository(r)));
+        await this.aws.deleteStacks(...stacksToDelete.map(s => s.StackName));
+        // We might have leaked some buckets by upgrading the bootstrap stack. Be
+        // sure to clean everything.
+        for (const bucket of this.bucketsToDelete) {
+            await this.aws.deleteBucket(bucket);
+        }
+        // If the tests completed successfully, happily delete the fixture
+        // (otherwise leave it for humans to inspect)
+        if (success) {
+            rimraf(this.integTestDir);
+        }
+    }
+    /**
+     * Return the stacks starting with our testing prefix that should be deleted
+     */
+    async deleteableStacks(prefix) {
+        var _a;
+        const statusFilter = [
+            'CREATE_IN_PROGRESS', 'CREATE_FAILED', 'CREATE_COMPLETE',
+            'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'ROLLBACK_COMPLETE',
+            'DELETE_FAILED',
+            'UPDATE_IN_PROGRESS', 'UPDATE_COMPLETE_CLEANUP_IN_PROGRESS',
+            'UPDATE_COMPLETE', 'UPDATE_ROLLBACK_IN_PROGRESS',
+            'UPDATE_ROLLBACK_FAILED',
+            'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS',
+            'UPDATE_ROLLBACK_COMPLETE', 'REVIEW_IN_PROGRESS',
+            'IMPORT_IN_PROGRESS', 'IMPORT_COMPLETE',
+            'IMPORT_ROLLBACK_IN_PROGRESS', 'IMPORT_ROLLBACK_FAILED',
+            'IMPORT_ROLLBACK_COMPLETE',
+        ];
+        const response = await this.aws.cloudFormation('describeStacks', {});
+        return ((_a = response.Stacks) !== null && _a !== void 0 ? _a : [])
+            .filter(s => s.StackName.startsWith(prefix))
+            .filter(s => statusFilter.includes(s.StackStatus))
+            .filter(s => s.RootId === undefined); // Only delete parent stacks. Nested stacks are deleted in the process
+    }
+}
+exports.TestFixture = TestFixture;
+/**
+ * Perform a one-time quick sanity check that the AWS clients has properly configured credentials
+ *
+ * If we don't do this, calls are going to fail and they'll be retried and everything will take
+ * forever before the user notices a simple misconfiguration.
+ *
+ * We can't check for the presence of environment variables since credentials could come from
+ * anywhere, so do simple account retrieval.
+ *
+ * Only do it once per process.
+ */
+async function sanityCheck(aws) {
+    if (sanityChecked === undefined) {
+        try {
+            await aws.account();
+            sanityChecked = true;
+        }
+        catch (e) {
+            sanityChecked = false;
+            throw new Error(`AWS credentials probably not configured, got error: ${e.message}`);
+        }
+    }
+    if (!sanityChecked) {
+        throw new Error('AWS credentials probably not configured, see previous error');
+    }
+}
+let sanityChecked;
+/**
+ * Make sure that the given environment is bootstrapped
+ *
+ * Since we go striping across regions, it's going to suck doing this
+ * by hand so let's just mass-automate it.
+ */
+async function ensureBootstrapped(fixture) {
+    // Old-style bootstrap stack with default name
+    if (await fixture.aws.stackStatus('CDKToolkit') === undefined) {
+        await fixture.cdk(['bootstrap', `aws://${await fixture.aws.account()}/${fixture.aws.region}`]);
+    }
+}
+/**
+ * A shell command that does what you want
+ *
+ * Is platform-aware, handles errors nicely.
+ */
+async function shell(command, options = {}) {
+    var _a, _b;
+    if (options.modEnv && options.env) {
+        throw new Error('Use either env or modEnv but not both');
+    }
+    (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(`💻 ${command.join(' ')}\n`);
+    const env = (_b = options.env) !== null && _b !== void 0 ? _b : (options.modEnv ? { ...process.env, ...options.modEnv } : undefined);
+    const child = child_process.spawn(command[0], command.slice(1), {
+        ...options,
+        env,
+        // Need this for Windows where we want .cmd and .bat to be found as well.
+        shell: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return new Promise((resolve, reject) => {
+        const stdout = new Array();
+        const stderr = new Array();
+        child.stdout.on('data', chunk => {
+            var _a;
+            (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(chunk);
+            stdout.push(chunk);
+        });
+        child.stderr.on('data', chunk => {
+            var _a, _b;
+            (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(chunk);
+            if ((_b = options.captureStderr) !== null && _b !== void 0 ? _b : true) {
+                stderr.push(chunk);
+            }
+        });
+        child.once('error', reject);
+        child.once('close', code => {
+            if (code === 0 || options.allowErrExit) {
+                resolve((Buffer.concat(stdout).toString('utf-8') + Buffer.concat(stderr).toString('utf-8')).trim());
+            }
+            else {
+                reject(new Error(`'${command.join(' ')}' exited with error code ${code}`));
+            }
+        });
+    });
+}
+exports.shell = shell;
+function defined(x) {
+    return x !== undefined;
+}
+/**
+ * rm -rf reimplementation, don't want to depend on an NPM package for this
+ */
+function rimraf(fsPath) {
+    try {
+        const isDir = fs.lstatSync(fsPath).isDirectory();
+        if (isDir) {
+            for (const file of fs.readdirSync(fsPath)) {
+                rimraf(path.join(fsPath, file));
+            }
+            fs.rmdirSync(fsPath);
+        }
+        else {
+            fs.unlinkSync(fsPath);
+        }
+    }
+    catch (e) {
+        // We will survive ENOENT
+        if (e.code !== 'ENOENT') {
+            throw e;
+        }
+    }
+}
+exports.rimraf = rimraf;
+function randomString() {
+    // Crazy
+    return Math.random().toString(36).replace(/[^a-z0-9]+/g, '');
+}
+exports.randomString = randomString;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-helpers.js","sourceRoot":"","sources":["cdk-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import * as child_process from 'child_process';\nimport * as fs from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { outputFromStack, AwsClients } from './aws-helpers';\nimport { ResourcePool } from './resource-pool';\nimport { TestContext } from './test-helpers';\n\nconst REGIONS = process.env.AWS_REGIONS\n  ? process.env.AWS_REGIONS.split(',')\n  : [process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1'];\n\nconst FRAMEWORK_VERSION = process.env.FRAMEWORK_VERSION;\n\nprocess.stdout.write(`Using regions: ${REGIONS}\\n`);\nprocess.stdout.write(`Using framework version: ${FRAMEWORK_VERSION}\\n`);\n\nconst REGION_POOL = new ResourcePool(REGIONS);\n\n\nexport type AwsContext = { readonly aws: AwsClients };\n\n/**\n * Higher order function to execute a block with an AWS client setup\n *\n * Allocate the next region from the REGION pool and dispose it afterwards.\n */\nexport function withAws<A extends TestContext>(block: (context: A & AwsContext) => Promise<void>) {\n  return (context: A) => REGION_POOL.using(async (region) => {\n    const aws = await AwsClients.forRegion(region, context.output);\n    await sanityCheck(aws);\n\n    return block({ ...context, aws });\n  });\n}\n\n/**\n * Higher order function to execute a block with a CDK app fixture\n *\n * Requires an AWS client to be passed in.\n *\n * For backwards compatibility with existing tests (so we don't have to change\n * too much) the inner block is expected to take a `TestFixture` object.\n */\nexport function withCdkApp<A extends TestContext & AwsContext>(block: (context: TestFixture) => Promise<void>) {\n  return async (context: A) => {\n    const randy = randomString();\n    const stackNamePrefix = `cdktest-${randy}`;\n    const integTestDir = path.join(os.tmpdir(), `cdk-integ-${randy}`);\n\n    context.output.write(` Stack prefix:   ${stackNamePrefix}\\n`);\n    context.output.write(` Test directory: ${integTestDir}\\n`);\n    context.output.write(` Region:         ${context.aws.region}\\n`);\n\n    await cloneDirectory(path.join(__dirname, 'app'), integTestDir, context.output);\n    const fixture = new TestFixture(\n      integTestDir,\n      stackNamePrefix,\n      context.output,\n      context.aws);\n\n    let success = true;\n    try {\n      let modules = [\n        '@aws-cdk/core',\n        '@aws-cdk/aws-sns',\n        '@aws-cdk/aws-iam',\n        '@aws-cdk/aws-lambda',\n        '@aws-cdk/aws-ssm',\n        '@aws-cdk/aws-ecr-assets',\n        '@aws-cdk/aws-cloudformation',\n        '@aws-cdk/aws-ec2',\n      ];\n      if (FRAMEWORK_VERSION) {\n        modules = modules.map(module => `${module}@${FRAMEWORK_VERSION}`);\n      }\n      await fixture.shell(['npm', 'install', ...modules]);\n\n      await ensureBootstrapped(fixture);\n\n      await block(fixture);\n    } catch (e) {\n      success = false;\n      throw e;\n    } finally {\n      await fixture.dispose(success);\n    }\n  };\n}\n\n/**\n * Default test fixture for most (all?) integ tests\n *\n * It's a composition of withAws/withCdkApp, expecting the test block to take a `TestFixture`\n * object.\n *\n * We could have put `withAws(withCdkApp(fixture => { /... actual test here.../ }))` in every\n * test declaration but centralizing it is going to make it convenient to modify in the future.\n */\nexport function withDefaultFixture(block: (context: TestFixture) => Promise<void>) {\n  return withAws<TestContext>(withCdkApp(block));\n  //              ^~~~~~ this is disappointing TypeScript! Feels like you should have been able to derive this.\n}\n\nexport interface ShellOptions extends child_process.SpawnOptions {\n  /**\n   * Properties to add to 'env'\n   */\n  modEnv?: Record<string, string>;\n\n  /**\n   * Don't fail when exiting with an error\n   *\n   * @default false\n   */\n  allowErrExit?: boolean;\n\n  /**\n   * Whether to capture stderr\n   *\n   * @default true\n   */\n  captureStderr?: boolean;\n\n  /**\n   * Pass output here\n   */\n  output?: NodeJS.WritableStream;\n}\n\nexport interface CdkCliOptions extends ShellOptions {\n  options?: string[];\n  neverRequireApproval?: boolean;\n  verbose?: boolean;\n}\n\n/**\n * Prepare a target dir byreplicating a source directory\n */\nexport async function cloneDirectory(source: string, target: string, output?: NodeJS.WritableStream) {\n  await shell(['rm', '-rf', target], { output });\n  await shell(['mkdir', '-p', target], { output });\n  await shell(['cp', '-R', source + '/*', target], { output });\n}\n\nexport class TestFixture {\n  public readonly qualifier = randomString().substr(0, 10);\n  private readonly bucketsToDelete = new Array<string>();\n\n  constructor(\n    public readonly integTestDir: string,\n    public readonly stackNamePrefix: string,\n    public readonly output: NodeJS.WritableStream,\n    public readonly aws: AwsClients) {\n  }\n\n  public log(s: string) {\n    this.output.write(`${s}\\n`);\n  }\n\n  public async shell(command: string[], options: Omit<ShellOptions, 'cwd'|'output'> = {}): Promise<string> {\n    return shell(command, {\n      output: this.output,\n      cwd: this.integTestDir,\n      ...options,\n    });\n  }\n\n  public async cdkDeploy(stackNames: string | string[], options: CdkCliOptions = {}) {\n    stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames;\n\n    const neverRequireApproval = options.neverRequireApproval ?? true;\n\n    return this.cdk(['deploy',\n      ...(neverRequireApproval ? ['--require-approval=never'] : []), // Default to no approval in an unattended test\n      ...(options.options ?? []),\n      ...this.fullStackName(stackNames)], options);\n  }\n\n  public async cdkDestroy(stackNames: string | string[], options: CdkCliOptions = {}) {\n    stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames;\n\n    return this.cdk(['destroy',\n      '-f', // We never want a prompt in an unattended test\n      ...(options.options ?? []),\n      ...this.fullStackName(stackNames)], options);\n  }\n\n  public async cdk(args: string[], options: CdkCliOptions = {}) {\n    const verbose = options.verbose ?? true;\n\n    return this.shell(['cdk', ...(verbose ? ['-v'] : []), ...args], {\n      ...options,\n      modEnv: {\n        AWS_REGION: this.aws.region,\n        AWS_DEFAULT_REGION: this.aws.region,\n        STACK_NAME_PREFIX: this.stackNamePrefix,\n        ...options.modEnv,\n      },\n    });\n  }\n\n  public fullStackName(stackName: string): string;\n  public fullStackName(stackNames: string[]): string[];\n  public fullStackName(stackNames: string | string[]): string | string[] {\n    if (typeof stackNames === 'string') {\n      return `${this.stackNamePrefix}-${stackNames}`;\n    } else {\n      return stackNames.map(s => `${this.stackNamePrefix}-${s}`);\n    }\n  }\n\n  /**\n   * Append this to the list of buckets to potentially delete\n   *\n   * At the end of a test, we clean up buckets that may not have gotten destroyed\n   * (for whatever reason).\n   */\n  public rememberToDeleteBucket(bucketName: string) {\n    this.bucketsToDelete.push(bucketName);\n  }\n\n  /**\n   * Cleanup leftover stacks and buckets\n   */\n  public async dispose(success: boolean) {\n    const stacksToDelete = await this.deleteableStacks(this.stackNamePrefix);\n\n    // Bootstrap stacks have buckets that need to be cleaned\n    const bucketNames = stacksToDelete.map(stack => outputFromStack('BucketName', stack)).filter(defined);\n    await Promise.all(bucketNames.map(b => this.aws.emptyBucket(b)));\n\n    // Bootstrap stacks have ECR repositories with images which should be deleted\n    const imageRepositoryNames = stacksToDelete.map(stack => outputFromStack('ImageRepositoryName', stack)).filter(defined);\n    await Promise.all(imageRepositoryNames.map(r => this.aws.deleteImageRepository(r)));\n\n    await this.aws.deleteStacks(...stacksToDelete.map(s => s.StackName));\n\n    // We might have leaked some buckets by upgrading the bootstrap stack. Be\n    // sure to clean everything.\n    for (const bucket of this.bucketsToDelete) {\n      await this.aws.deleteBucket(bucket);\n    }\n\n    // If the tests completed successfully, happily delete the fixture\n    // (otherwise leave it for humans to inspect)\n    if (success) {\n      rimraf(this.integTestDir);\n    }\n  }\n\n  /**\n   * Return the stacks starting with our testing prefix that should be deleted\n   */\n  private async deleteableStacks(prefix: string): Promise<AWS.CloudFormation.Stack[]> {\n    const statusFilter = [\n      'CREATE_IN_PROGRESS', 'CREATE_FAILED', 'CREATE_COMPLETE',\n      'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'ROLLBACK_COMPLETE',\n      'DELETE_FAILED',\n      'UPDATE_IN_PROGRESS', 'UPDATE_COMPLETE_CLEANUP_IN_PROGRESS',\n      'UPDATE_COMPLETE', 'UPDATE_ROLLBACK_IN_PROGRESS',\n      'UPDATE_ROLLBACK_FAILED',\n      'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS',\n      'UPDATE_ROLLBACK_COMPLETE', 'REVIEW_IN_PROGRESS',\n      'IMPORT_IN_PROGRESS', 'IMPORT_COMPLETE',\n      'IMPORT_ROLLBACK_IN_PROGRESS', 'IMPORT_ROLLBACK_FAILED',\n      'IMPORT_ROLLBACK_COMPLETE',\n    ];\n\n    const response = await this.aws.cloudFormation('describeStacks', {});\n\n    return (response.Stacks ?? [])\n      .filter(s => s.StackName.startsWith(prefix))\n      .filter(s => statusFilter.includes(s.StackStatus))\n      .filter(s => s.RootId === undefined); // Only delete parent stacks. Nested stacks are deleted in the process\n  }\n}\n\n/**\n * Perform a one-time quick sanity check that the AWS clients has properly configured credentials\n *\n * If we don't do this, calls are going to fail and they'll be retried and everything will take\n * forever before the user notices a simple misconfiguration.\n *\n * We can't check for the presence of environment variables since credentials could come from\n * anywhere, so do simple account retrieval.\n *\n * Only do it once per process.\n */\nasync function sanityCheck(aws: AwsClients) {\n  if (sanityChecked === undefined) {\n    try {\n      await aws.account();\n      sanityChecked = true;\n    } catch (e) {\n      sanityChecked = false;\n      throw new Error(`AWS credentials probably not configured, got error: ${e.message}`);\n    }\n  }\n  if (!sanityChecked) {\n    throw new Error('AWS credentials probably not configured, see previous error');\n  }\n}\nlet sanityChecked: boolean | undefined;\n\n/**\n * Make sure that the given environment is bootstrapped\n *\n * Since we go striping across regions, it's going to suck doing this\n * by hand so let's just mass-automate it.\n */\nasync function ensureBootstrapped(fixture: TestFixture) {\n  // Old-style bootstrap stack with default name\n  if (await fixture.aws.stackStatus('CDKToolkit') === undefined) {\n    await fixture.cdk(['bootstrap', `aws://${await fixture.aws.account()}/${fixture.aws.region}`]);\n  }\n}\n\n/**\n * A shell command that does what you want\n *\n * Is platform-aware, handles errors nicely.\n */\nexport async function shell(command: string[], options: ShellOptions = {}): Promise<string> {\n  if (options.modEnv && options.env) {\n    throw new Error('Use either env or modEnv but not both');\n  }\n\n  options.output?.write(`💻 ${command.join(' ')}\\n`);\n\n  const env = options.env ?? (options.modEnv ? { ...process.env, ...options.modEnv } : undefined);\n\n  const child = child_process.spawn(command[0], command.slice(1), {\n    ...options,\n    env,\n    // Need this for Windows where we want .cmd and .bat to be found as well.\n    shell: true,\n    stdio: ['ignore', 'pipe', 'pipe'],\n  });\n\n  return new Promise<string>((resolve, reject) => {\n    const stdout = new Array<Buffer>();\n    const stderr = new Array<Buffer>();\n\n    child.stdout!.on('data', chunk => {\n      options.output?.write(chunk);\n      stdout.push(chunk);\n    });\n\n    child.stderr!.on('data', chunk => {\n      options.output?.write(chunk);\n      if (options.captureStderr ?? true) {\n        stderr.push(chunk);\n      }\n    });\n\n    child.once('error', reject);\n\n    child.once('close', code => {\n      if (code === 0 || options.allowErrExit) {\n        resolve((Buffer.concat(stdout).toString('utf-8') + Buffer.concat(stderr).toString('utf-8')).trim());\n      } else {\n        reject(new Error(`'${command.join(' ')}' exited with error code ${code}`));\n      }\n    });\n  });\n}\n\nfunction defined<A>(x: A): x is NonNullable<A> {\n  return x !== undefined;\n}\n\n/**\n * rm -rf reimplementation, don't want to depend on an NPM package for this\n */\nexport function rimraf(fsPath: string) {\n  try {\n    const isDir = fs.lstatSync(fsPath).isDirectory();\n\n    if (isDir) {\n      for (const file of fs.readdirSync(fsPath)) {\n        rimraf(path.join(fsPath, file));\n      }\n      fs.rmdirSync(fsPath);\n    } else {\n      fs.unlinkSync(fsPath);\n    }\n  } catch (e) {\n    // We will survive ENOENT\n    if (e.code !== 'ENOENT') { throw e; }\n  }\n}\n\nexport function randomString() {\n  // Crazy\n  return Math.random().toString(36).replace(/[^a-z0-9]+/g, '');\n}"]}

package/resources/cloud-assemblies/0.36.0/InitStack.template.json

@@ -0,0 +1 @@
+{}

package/resources/cloud-assemblies/0.36.0/manifest.json

@@ -0,0 +1,19 @@
+{
+  "version": "0.36.0",
+  "artifacts": {
+    "InitStack": {
+      "type": "aws:cloudformation:stack",
+      "environment": "aws://unknown-account/unknown-region",
+      "properties": {
+        "templateFile": "InitStack.template.json"
+      }
+    }
+  },
+  "runtime": {
+    "libraries": {
+      "@aws-cdk/core": "1.12.0",
+      "@aws-cdk/cx-api": "1.12.0",
+      "jsii-runtime": "node.js/v8.11.4"
+    }
+  }
+}

package/resources/cloud-assemblies/1.10.0-lookup-default-vpc/InitStack.template.json

@@ -0,0 +1,2 @@
+{
+}

package/resources/cloud-assemblies/1.10.0-lookup-default-vpc/manifest.json.js

@@ -0,0 +1,37 @@
+process.stdout.write(JSON.stringify({
+  "version": "1.10.0",
+  "artifacts": {
+    "InitStack": {
+      "type": "aws:cloudformation:stack",
+      "environment": `aws://${process.env.TEST_ACCOUNT}/${process.env.TEST_REGION}`,
+      "properties": {
+        "templateFile": "InitStack.template.json"
+      }
+    }
+  },
+  "runtime": {
+    "libraries": {
+      "@aws-cdk/core": "1.14.0",
+      "@aws-cdk/cx-api": "1.14.0",
+      "@aws-cdk/aws-ec2": "1.14.0",
+      "@aws-cdk/aws-iam": "1.14.0",
+      "@aws-cdk/region-info": "1.14.0",
+      "@aws-cdk/aws-ssm": "1.14.0",
+      "@aws-cdk/aws-cloudwatch": "1.14.0",
+      "jsii-runtime": "node.js/v8.11.4"
+    }
+  },
+  "missing": [
+    {
+      "key": `vpc-provider:account=${process.env.TEST_ACCOUNT}:filter.isDefault=true:region=${process.env.TEST_REGION}`,
+      "props": {
+        "account": process.env.TEST_ACCOUNT,
+        "region": process.env.TEST_REGION,
+        "filter": {
+          "isDefault": "true"
+        }
+      },
+      "provider": "vpc-provider"
+    }
+  ]
+}, undefined, 2));

package/resources/cloud-assemblies/1.10.0-request-azs/InitStack.template.json

@@ -0,0 +1,2 @@
+{
+}

package/resources/cloud-assemblies/1.10.0-request-azs/manifest.json.js

@@ -0,0 +1,34 @@
+process.stdout.write(JSON.stringify({
+  "version": "1.10.0",
+  "artifacts": {
+    "InitStack": {
+      "type": "aws:cloudformation:stack",
+      "environment": `aws://${process.env.TEST_ACCOUNT}/${process.env.TEST_REGION}`,
+      "properties": {
+        "templateFile": "InitStack.template.json"
+      }
+    }
+  },
+  "runtime": {
+    "libraries": {
+      "@aws-cdk/core": "1.14.0",
+      "@aws-cdk/cx-api": "1.14.0",
+      "@aws-cdk/aws-ec2": "1.14.0",
+      "@aws-cdk/aws-iam": "1.14.0",
+      "@aws-cdk/region-info": "1.14.0",
+      "@aws-cdk/aws-ssm": "1.14.0",
+      "@aws-cdk/aws-cloudwatch": "1.14.0",
+      "jsii-runtime": "node.js/v8.11.4"
+    }
+  },
+  "missing": [
+    {
+      "key": `availability-zones:account=${process.env.TEST_ACCOUNT}:region=${process.env.TEST_REGION}`,
+      "props": {
+        "account": process.env.TEST_ACCOUNT,
+        "region": process.env.TEST_REGION,
+      },
+      "provider": "availability-zones"
+    }
+  ]
+}, undefined, 2));

package/resources/integ.jest.config.js

@@ -0,0 +1,25 @@
+const path = require('path');
+
+const rootDir = path.resolve(__dirname, '..', 'tests', process.env.TEST_SUITE_NAME);
+
+if (rootDir.includes('node_modules')) {
+  // Jest < 28 under no circumstances supports loading test if there's node_modules anywhere in the path,
+  // and Jest >= 28 requires a newer TypeScript version than the one we support.
+  throw new Error(`This package must not be 'npm install'ed (found node_modules in dir: ${rootDir})`);
+}
+
+module.exports = {
+  rootDir,
+  testMatch: [`**/*.integtest.js`],
+  moduleFileExtensions: ["js"],
+
+  testEnvironment: "node",
+  testTimeout: 300000,
+
+  // Affects test.concurrent(), these are self-limiting anyway
+  maxConcurrency: 10,
+  reporters: [
+    "default",
+    [ "jest-junit", { suiteName: "jest tests", outputDirectory: "coverage" } ]
+  ]
+};

package/skip-tests.txt

@@ -0,0 +1,8 @@
+# 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.

package/tests/cli-integ-tests/README.md

@@ -0,0 +1,47 @@
+# CDK CLI Integration Tests
+
+These tests require AWS credentials, and exercise various aspects of the
+CLI on a simple JavaScript CDK app (stored in `app/`).
+
+## Entry point
+
+```
+../run-against-repo ./test.sh
+```
+
+Running against a failing dist build:
+
+```
+# Download and unpack the zip
+.../CMkBR4V$ tar xzvf js/aws-cdk-[0-9]*.tgz
+.../CMkBR4V$ package/test/integ/run-against-dist package/test/integ/cli/test.sh
+```
+
+## Adding tests
+
+Even though tests are now written in TypeScript, this does not
+conceptually change their SUT! They are still testing the CLI via
+running it as a subprocess, they are NOT reaching directly into the CLI
+code to test its private methods. It's just that setup/teardown/error
+handling/assertions/AWS calls are much more convenient to do in a real
+programming language.
+
+Compilation of the tests is done as part of the normal package build, at
+which point it is using the dependencies brought in by the containing
+`aws-cdk` package's `package.json`.
+
+When run in a non-development repo (as done during integ tests or canary runs),
+the required dependencies are brought in just-in-time via `test.sh`. Any
+new dependencies added for the tests should be added there as well. But, better
+yet, don't add any dependencies at all. You shouldn't need to, these tests
+are simple.
+
+## Configuration
+
+AWS credentials must be configured.
+
+Optional configuration:
+
+* `AWS_DEFAULT_REGION`, what region to deploy the stacks in.
+* `IS_CANARY`, true or false. Affects the default stack name prefix to make
+  integration test and canary runs unique.

package/tests/cli-integ-tests/bootstrapping.integtest.d.ts

@@ -0,0 +1 @@
+export {};