@aws-cdk-testing/cli-integ 2.61.0

package/lib/with-cdk-app.js

@@ -0,0 +1,398 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installNpmPackages = exports.TestFixture = exports.cloneDirectory = exports.withDefaultFixture = exports.withMonolithicCfnIncludeCdkApp = exports.withCdkApp = void 0;
+/* eslint-disable no-console */
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const aws_1 = require("./aws");
+const subprocess_1 = require("./package-sources/subprocess");
+const resources_1 = require("./resources");
+const shell_1 = require("./shell");
+const with_aws_1 = require("./with-aws");
+/**
+ * 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 = context.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(resources_1.RESOURCES_DIR, 'cdk-apps', 'app'), integTestDir, context.output);
+        const fixture = new TestFixture(integTestDir, stackNamePrefix, context.output, context.aws, context.randomString);
+        let success = true;
+        try {
+            const installationVersion = fixture.packages.requestedFrameworkVersion();
+            if (fixture.packages.majorVersion() === '1') {
+                await installNpmPackages(fixture, {
+                    '@aws-cdk/core': installationVersion,
+                    '@aws-cdk/aws-sns': installationVersion,
+                    '@aws-cdk/aws-sqs': installationVersion,
+                    '@aws-cdk/aws-iam': installationVersion,
+                    '@aws-cdk/aws-lambda': installationVersion,
+                    '@aws-cdk/aws-ssm': installationVersion,
+                    '@aws-cdk/aws-ecr-assets': installationVersion,
+                    '@aws-cdk/aws-cloudformation': installationVersion,
+                    '@aws-cdk/aws-ec2': installationVersion,
+                    '@aws-cdk/aws-s3': installationVersion,
+                    'constructs': '^3',
+                });
+            }
+            else {
+                await installNpmPackages(fixture, {
+                    'aws-cdk-lib': installationVersion,
+                    'constructs': '^10',
+                });
+            }
+            await ensureBootstrapped(fixture);
+            await block(fixture);
+        }
+        catch (e) {
+            success = false;
+            throw e;
+        }
+        finally {
+            if (process.env.INTEG_NO_CLEAN) {
+                context.log(`Left test directory in '${integTestDir}' ($INTEG_NO_CLEAN)\n`);
+            }
+            else {
+                await fixture.dispose(success);
+            }
+        }
+    };
+}
+exports.withCdkApp = withCdkApp;
+function withMonolithicCfnIncludeCdkApp(block) {
+    return async (context) => {
+        const uberPackage = process.env.UBERPACKAGE;
+        if (!uberPackage) {
+            throw new Error('The UBERPACKAGE environment variable is required for running this test!');
+        }
+        const randy = context.randomString;
+        const stackNamePrefix = `cdk-uber-cfn-include-${randy}`;
+        const integTestDir = path.join(os.tmpdir(), `cdk-uber-cfn-include-${randy}`);
+        context.output.write(` Stack prefix:   ${stackNamePrefix}\n`);
+        context.output.write(` Test directory: ${integTestDir}\n`);
+        const awsClients = await aws_1.AwsClients.default(context.output);
+        await cloneDirectory(path.join(resources_1.RESOURCES_DIR, 'cdk-apps', 'cfn-include-app'), integTestDir, context.output);
+        const fixture = new TestFixture(integTestDir, stackNamePrefix, context.output, awsClients, context.randomString);
+        let success = true;
+        try {
+            await installNpmPackages(fixture, {
+                [uberPackage]: fixture.packages.requestedFrameworkVersion(),
+            });
+            await block(fixture);
+        }
+        catch (e) {
+            success = false;
+            throw e;
+        }
+        finally {
+            if (process.env.INTEG_NO_CLEAN) {
+                context.log(`Left test directory in '${integTestDir}' ($INTEG_NO_CLEAN)`);
+            }
+            else {
+                await fixture.dispose(success);
+            }
+        }
+    };
+}
+exports.withMonolithicCfnIncludeCdkApp = withMonolithicCfnIncludeCdkApp;
+/**
+ * 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 with_aws_1.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_1.shell(['rm', '-rf', target], { output });
+    await shell_1.shell(['mkdir', '-p', target], { output });
+    await shell_1.shell(['cp', '-R', source + '/*', target], { output });
+}
+exports.cloneDirectory = cloneDirectory;
+class TestFixture extends shell_1.ShellHelper {
+    constructor(integTestDir, stackNamePrefix, output, aws, randomString) {
+        super(integTestDir, output);
+        this.integTestDir = integTestDir;
+        this.stackNamePrefix = stackNamePrefix;
+        this.output = output;
+        this.aws = aws;
+        this.randomString = randomString;
+        this.qualifier = this.randomString.slice(0, 10);
+        this.bucketsToDelete = new Array();
+        this.packages = subprocess_1.packageSourceInSubprocess();
+    }
+    log(s) {
+        this.output.write(`${s}\n`);
+    }
+    async cdkDeploy(stackNames, options = {}) {
+        stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames;
+        const neverRequireApproval = options.neverRequireApproval ?? true;
+        return this.cdk(['deploy',
+            ...(neverRequireApproval ? ['--require-approval=never'] : []),
+            ...(options.options ?? []),
+            ...this.fullStackName(stackNames)], options);
+    }
+    async cdkSynth(options = {}) {
+        return this.cdk([
+            'synth',
+            ...(options.options ?? []),
+        ], options);
+    }
+    async cdkDestroy(stackNames, options = {}) {
+        stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames;
+        return this.cdk(['destroy',
+            '-f',
+            ...(options.options ?? []),
+            ...this.fullStackName(stackNames)], options);
+    }
+    async cdkBootstrapLegacy(options) {
+        const args = ['bootstrap'];
+        if (options.verbose) {
+            args.push('-v');
+        }
+        args.push('--toolkit-stack-name', options.toolkitStackName);
+        if (options.bootstrapBucketName) {
+            args.push('--bootstrap-bucket-name', options.bootstrapBucketName);
+        }
+        if (options.noExecute) {
+            args.push('--no-execute');
+        }
+        if (options.publicAccessBlockConfiguration !== undefined) {
+            args.push('--public-access-block-configuration', options.publicAccessBlockConfiguration.toString());
+        }
+        if (options.tags) {
+            args.push('--tags', options.tags);
+        }
+        return this.cdk(args, {
+            ...options.cliOptions,
+            modEnv: {
+                ...options.cliOptions?.modEnv,
+                // so that this works for V2,
+                // where the "new" bootstrap is the default
+                CDK_LEGACY_BOOTSTRAP: '1',
+            },
+        });
+    }
+    async cdkBootstrapModern(options) {
+        const args = ['bootstrap'];
+        if (options.verbose) {
+            args.push('-v');
+        }
+        if (options.showTemplate) {
+            args.push('--show-template');
+        }
+        if (options.template) {
+            args.push('--template', options.template);
+        }
+        args.push('--toolkit-stack-name', options.toolkitStackName);
+        if (options.bootstrapBucketName) {
+            args.push('--bootstrap-bucket-name', options.bootstrapBucketName);
+        }
+        args.push('--qualifier', this.qualifier);
+        if (options.cfnExecutionPolicy) {
+            args.push('--cloudformation-execution-policies', options.cfnExecutionPolicy);
+        }
+        if (options.terminationProtection !== undefined) {
+            args.push('--termination-protection', options.terminationProtection.toString());
+        }
+        if (options.force) {
+            args.push('--force');
+        }
+        if (options.tags) {
+            args.push('--tags', options.tags);
+        }
+        if (options.customPermissionsBoundary !== undefined) {
+            args.push('--custom-permissions-boundary', options.customPermissionsBoundary);
+        }
+        else if (options.examplePermissionsBoundary !== undefined) {
+            args.push('--example-permissions-boundary');
+        }
+        return this.cdk(args, {
+            ...options.cliOptions,
+            modEnv: {
+                ...options.cliOptions?.modEnv,
+                // so that this works for V1,
+                // where the "old" bootstrap is the default
+                CDK_NEW_BOOTSTRAP: '1',
+            },
+        });
+    }
+    async cdk(args, options = {}) {
+        const verbose = options.verbose ?? true;
+        await this.packages.makeCliAvailable();
+        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,
+                PACKAGE_LAYOUT_VERSION: this.packages.majorVersion(),
+                ...options.modEnv,
+            },
+        });
+    }
+    template(stackName) {
+        const fullStackName = this.fullStackName(stackName);
+        const templatePath = path.join(this.integTestDir, 'cdk.out', `${fullStackName}.template.json`);
+        return JSON.parse(fs.readFileSync(templatePath, { encoding: 'utf-8' }).toString());
+    }
+    get bootstrapStackName() {
+        return this.fullStackName('bootstrap-stack');
+    }
+    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);
+        this.sortBootstrapStacksToTheEnd(stacksToDelete);
+        // Bootstrap stacks have buckets that need to be cleaned
+        const bucketNames = stacksToDelete.map(stack => aws_1.outputFromStack('BucketName', stack)).filter(defined);
+        await Promise.all(bucketNames.map(b => this.aws.emptyBucket(b)));
+        // The bootstrap bucket has a removal policy of RETAIN by default, so add it to the buckets to be cleaned up.
+        this.bucketsToDelete.push(...bucketNames);
+        // Bootstrap stacks have ECR repositories with images which should be deleted
+        const imageRepositoryNames = stacksToDelete.map(stack => aws_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) {
+            shell_1.rimraf(this.integTestDir);
+        }
+    }
+    /**
+     * Return the stacks starting with our testing prefix that should be deleted
+     */
+    async deleteableStacks(prefix) {
+        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 (response.Stacks ?? [])
+            .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
+    }
+    sortBootstrapStacksToTheEnd(stacks) {
+        stacks.sort((a, b) => {
+            const aBs = a.StackName.startsWith(this.bootstrapStackName);
+            const bBs = b.StackName.startsWith(this.bootstrapStackName);
+            return aBs != bBs
+                // '+' converts a boolean to 0 or 1
+                ? (+aBs) - (+bBs)
+                : a.StackName.localeCompare(b.StackName);
+        });
+    }
+}
+exports.TestFixture = TestFixture;
+/**
+ * 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) {
+    // Always use the modern bootstrap stack, otherwise we may get the error
+    // "refusing to downgrade from version 7 to version 0" when bootstrapping with default
+    // settings using a v1 CLI.
+    //
+    // It doesn't matter for tests: when they want to test something about an actual legacy
+    // bootstrap stack, they'll create a bootstrap stack with a non-default name to test that exact property.
+    const envSpecifier = `aws://${await fixture.aws.account()}/${fixture.aws.region}`;
+    if (ALREADY_BOOTSTRAPPED_IN_THIS_RUN.has(envSpecifier)) {
+        return;
+    }
+    await fixture.cdk(['bootstrap', envSpecifier], {
+        modEnv: {
+            // Even for v1, use new bootstrap
+            CDK_NEW_BOOTSTRAP: '1',
+        },
+    });
+    ALREADY_BOOTSTRAPPED_IN_THIS_RUN.add(envSpecifier);
+}
+function defined(x) {
+    return x !== undefined;
+}
+/**
+ * Install the given NPM packages, identified by their names and versions
+ *
+ * Works by writing the packages to a `package.json` file, and
+ * then running NPM7's "install" on it. The use of NPM7 will automatically
+ * install required peerDependencies.
+ *
+ * If we're running in REPO mode and we find the package in the set of local
+ * packages in the repository, we'll write the directory name to `package.json`
+ * so that NPM will create a symlink (this allows running tests against
+ * built-but-unpackaged modules, and saves dev cycle time).
+ *
+ * Be aware you MUST install all the packages you directly depend upon! In the case
+ * of a repo/symlinking install, transitive dependencies WILL NOT be installed in the
+ * current directory's `node_modules` directory, because they will already have been
+ * symlinked from the TARGET directory's `node_modules` directory (which is sufficient
+ * for Node's dependency lookup mechanism).
+ */
+async function installNpmPackages(fixture, packages) {
+    fs.writeFileSync(path.join(fixture.integTestDir, 'package.json'), JSON.stringify({
+        name: 'cdk-integ-tests',
+        private: true,
+        version: '0.0.1',
+        devDependencies: packages,
+    }, undefined, 2), { encoding: 'utf-8' });
+    // Now install that `package.json` using NPM7
+    await fixture.shell(['node', require.resolve('npm'), 'install']);
+}
+exports.installNpmPackages = installNpmPackages;
+const ALREADY_BOOTSTRAPPED_IN_THIS_RUN = new Set();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-cdk-app.js","sourceRoot":"","sources":["with-cdk-app.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-console */\nimport * as fs from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { outputFromStack, AwsClients } from './aws';\nimport { TestContext } from './integ-test';\nimport { IPackageSource } from './package-sources/source';\nimport { packageSourceInSubprocess } from './package-sources/subprocess';\nimport { RESOURCES_DIR } from './resources';\nimport { shell, ShellOptions, ShellHelper, rimraf } from './shell';\nimport { AwsContext, withAws } from './with-aws';\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 = context.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(RESOURCES_DIR, 'cdk-apps', 'app'), integTestDir, context.output);\n    const fixture = new TestFixture(\n      integTestDir,\n      stackNamePrefix,\n      context.output,\n      context.aws,\n      context.randomString);\n\n    let success = true;\n    try {\n      const installationVersion = fixture.packages.requestedFrameworkVersion();\n\n      if (fixture.packages.majorVersion() === '1') {\n        await installNpmPackages(fixture, {\n          '@aws-cdk/core': installationVersion,\n          '@aws-cdk/aws-sns': installationVersion,\n          '@aws-cdk/aws-sqs': installationVersion,\n          '@aws-cdk/aws-iam': installationVersion,\n          '@aws-cdk/aws-lambda': installationVersion,\n          '@aws-cdk/aws-ssm': installationVersion,\n          '@aws-cdk/aws-ecr-assets': installationVersion,\n          '@aws-cdk/aws-cloudformation': installationVersion,\n          '@aws-cdk/aws-ec2': installationVersion,\n          '@aws-cdk/aws-s3': installationVersion,\n          'constructs': '^3',\n        });\n      } else {\n        await installNpmPackages(fixture, {\n          'aws-cdk-lib': installationVersion,\n          'constructs': '^10',\n        });\n      }\n\n      await ensureBootstrapped(fixture);\n\n      await block(fixture);\n    } catch (e) {\n      success = false;\n      throw e;\n    } finally {\n      if (process.env.INTEG_NO_CLEAN) {\n        context.log(`Left test directory in '${integTestDir}' ($INTEG_NO_CLEAN)\\n`);\n      } else {\n        await fixture.dispose(success);\n      }\n    }\n  };\n}\n\nexport function withMonolithicCfnIncludeCdkApp<A extends TestContext>(block: (context: TestFixture) => Promise<void>) {\n  return async (context: A) => {\n    const uberPackage = process.env.UBERPACKAGE;\n    if (!uberPackage) {\n      throw new Error('The UBERPACKAGE environment variable is required for running this test!');\n    }\n\n    const randy = context.randomString;\n    const stackNamePrefix = `cdk-uber-cfn-include-${randy}`;\n    const integTestDir = path.join(os.tmpdir(), `cdk-uber-cfn-include-${randy}`);\n\n    context.output.write(` Stack prefix:   ${stackNamePrefix}\\n`);\n    context.output.write(` Test directory: ${integTestDir}\\n`);\n\n    const awsClients = await AwsClients.default(context.output);\n    await cloneDirectory(path.join(RESOURCES_DIR, 'cdk-apps', 'cfn-include-app'), integTestDir, context.output);\n    const fixture = new TestFixture(\n      integTestDir,\n      stackNamePrefix,\n      context.output,\n      awsClients,\n      context.randomString,\n    );\n\n    let success = true;\n    try {\n      await installNpmPackages(fixture, {\n        [uberPackage]: fixture.packages.requestedFrameworkVersion(),\n      });\n\n      await block(fixture);\n    } catch (e) {\n      success = false;\n      throw e;\n    } finally {\n      if (process.env.INTEG_NO_CLEAN) {\n        context.log(`Left test directory in '${integTestDir}' ($INTEG_NO_CLEAN)`);\n      } else {\n        await fixture.dispose(success);\n      }\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 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\ninterface CommonCdkBootstrapCommandOptions {\n  readonly toolkitStackName: string;\n\n  /**\n   * @default false\n   */\n  readonly verbose?: boolean;\n\n  /**\n   * @default - auto-generated CloudFormation name\n   */\n  readonly bootstrapBucketName?: string;\n\n  readonly cliOptions?: CdkCliOptions;\n\n  /**\n   * @default - none\n   */\n  readonly tags?: string;\n}\n\nexport interface CdkLegacyBootstrapCommandOptions extends CommonCdkBootstrapCommandOptions {\n  /**\n   * @default false\n   */\n  readonly noExecute?: boolean;\n\n  /**\n   * @default true\n   */\n  readonly publicAccessBlockConfiguration?: boolean;\n}\n\nexport interface CdkModernBootstrapCommandOptions extends CommonCdkBootstrapCommandOptions {\n  /**\n   * @default false\n   */\n  readonly force?: boolean;\n\n  /**\n   * @default - none\n   */\n  readonly cfnExecutionPolicy?: string;\n\n  /**\n   * @default false\n   */\n  readonly showTemplate?: boolean;\n\n  readonly template?: string;\n\n  /**\n   * @default false\n   */\n  readonly terminationProtection?: boolean;\n\n  /**\n   * @default undefined\n   */\n  readonly examplePermissionsBoundary?: boolean;\n\n  /**\n   * @default undefined\n   */\n  readonly customPermissionsBoundary?: string;\n}\n\nexport class TestFixture extends ShellHelper {\n  public readonly qualifier = this.randomString.slice(0, 10);\n  private readonly bucketsToDelete = new Array<string>();\n  public readonly packages: IPackageSource;\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    public readonly randomString: string) {\n\n    super(integTestDir, output);\n\n    this.packages = packageSourceInSubprocess();\n  }\n\n  public log(s: string) {\n    this.output.write(`${s}\\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 cdkSynth(options: CdkCliOptions = {}) {\n    return this.cdk([\n      'synth',\n      ...(options.options ?? []),\n    ], 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 cdkBootstrapLegacy(options: CdkLegacyBootstrapCommandOptions): Promise<string> {\n    const args = ['bootstrap'];\n\n    if (options.verbose) {\n      args.push('-v');\n    }\n    args.push('--toolkit-stack-name', options.toolkitStackName);\n    if (options.bootstrapBucketName) {\n      args.push('--bootstrap-bucket-name', options.bootstrapBucketName);\n    }\n    if (options.noExecute) {\n      args.push('--no-execute');\n    }\n    if (options.publicAccessBlockConfiguration !== undefined) {\n      args.push('--public-access-block-configuration', options.publicAccessBlockConfiguration.toString());\n    }\n    if (options.tags) {\n      args.push('--tags', options.tags);\n    }\n\n    return this.cdk(args, {\n      ...options.cliOptions,\n      modEnv: {\n        ...options.cliOptions?.modEnv,\n        // so that this works for V2,\n        // where the \"new\" bootstrap is the default\n        CDK_LEGACY_BOOTSTRAP: '1',\n      },\n    });\n  }\n\n  public async cdkBootstrapModern(options: CdkModernBootstrapCommandOptions): Promise<string> {\n    const args = ['bootstrap'];\n\n    if (options.verbose) {\n      args.push('-v');\n    }\n    if (options.showTemplate) {\n      args.push('--show-template');\n    }\n    if (options.template) {\n      args.push('--template', options.template);\n    }\n    args.push('--toolkit-stack-name', options.toolkitStackName);\n    if (options.bootstrapBucketName) {\n      args.push('--bootstrap-bucket-name', options.bootstrapBucketName);\n    }\n    args.push('--qualifier', this.qualifier);\n    if (options.cfnExecutionPolicy) {\n      args.push('--cloudformation-execution-policies', options.cfnExecutionPolicy);\n    }\n    if (options.terminationProtection !== undefined) {\n      args.push('--termination-protection', options.terminationProtection.toString());\n    }\n    if (options.force) {\n      args.push('--force');\n    }\n    if (options.tags) {\n      args.push('--tags', options.tags);\n    }\n    if (options.customPermissionsBoundary !== undefined) {\n      args.push('--custom-permissions-boundary', options.customPermissionsBoundary);\n    } else if (options.examplePermissionsBoundary !== undefined) {\n      args.push('--example-permissions-boundary');\n    }\n\n    return this.cdk(args, {\n      ...options.cliOptions,\n      modEnv: {\n        ...options.cliOptions?.modEnv,\n        // so that this works for V1,\n        // where the \"old\" bootstrap is the default\n        CDK_NEW_BOOTSTRAP: '1',\n      },\n    });\n  }\n\n  public async cdk(args: string[], options: CdkCliOptions = {}) {\n    const verbose = options.verbose ?? true;\n\n    await this.packages.makeCliAvailable();\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        PACKAGE_LAYOUT_VERSION: this.packages.majorVersion(),\n        ...options.modEnv,\n      },\n    });\n  }\n\n  public template(stackName: string): any {\n    const fullStackName = this.fullStackName(stackName);\n    const templatePath = path.join(this.integTestDir, 'cdk.out', `${fullStackName}.template.json`);\n    return JSON.parse(fs.readFileSync(templatePath, { encoding: 'utf-8' }).toString());\n  }\n\n  public get bootstrapStackName() {\n    return this.fullStackName('bootstrap-stack');\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    this.sortBootstrapStacksToTheEnd(stacksToDelete);\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    // The bootstrap bucket has a removal policy of RETAIN by default, so add it to the buckets to be cleaned up.\n    this.bucketsToDelete.push(...bucketNames);\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  private sortBootstrapStacksToTheEnd(stacks: AWS.CloudFormation.Stack[]) {\n    stacks.sort((a, b) => {\n      const aBs = a.StackName.startsWith(this.bootstrapStackName);\n      const bBs = b.StackName.startsWith(this.bootstrapStackName);\n\n      return aBs != bBs\n        // '+' converts a boolean to 0 or 1\n        ? (+aBs) - (+bBs)\n        : a.StackName.localeCompare(b.StackName);\n    });\n  }\n}\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  // Always use the modern bootstrap stack, otherwise we may get the error\n  // \"refusing to downgrade from version 7 to version 0\" when bootstrapping with default\n  // settings using a v1 CLI.\n  //\n  // It doesn't matter for tests: when they want to test something about an actual legacy\n  // bootstrap stack, they'll create a bootstrap stack with a non-default name to test that exact property.\n  const envSpecifier = `aws://${await fixture.aws.account()}/${fixture.aws.region}`;\n  if (ALREADY_BOOTSTRAPPED_IN_THIS_RUN.has(envSpecifier)) { return; }\n\n  await fixture.cdk(['bootstrap', envSpecifier], {\n    modEnv: {\n      // Even for v1, use new bootstrap\n      CDK_NEW_BOOTSTRAP: '1',\n    },\n  });\n  ALREADY_BOOTSTRAPPED_IN_THIS_RUN.add(envSpecifier);\n}\n\nfunction defined<A>(x: A): x is NonNullable<A> {\n  return x !== undefined;\n}\n\n/**\n * Install the given NPM packages, identified by their names and versions\n *\n * Works by writing the packages to a `package.json` file, and\n * then running NPM7's \"install\" on it. The use of NPM7 will automatically\n * install required peerDependencies.\n *\n * If we're running in REPO mode and we find the package in the set of local\n * packages in the repository, we'll write the directory name to `package.json`\n * so that NPM will create a symlink (this allows running tests against\n * built-but-unpackaged modules, and saves dev cycle time).\n *\n * Be aware you MUST install all the packages you directly depend upon! In the case\n * of a repo/symlinking install, transitive dependencies WILL NOT be installed in the\n * current directory's `node_modules` directory, because they will already have been\n * symlinked from the TARGET directory's `node_modules` directory (which is sufficient\n * for Node's dependency lookup mechanism).\n */\nexport async function installNpmPackages(fixture: TestFixture, packages: Record<string, string>) {\n  fs.writeFileSync(path.join(fixture.integTestDir, 'package.json'), JSON.stringify({\n    name: 'cdk-integ-tests',\n    private: true,\n    version: '0.0.1',\n    devDependencies: packages,\n  }, undefined, 2), { encoding: 'utf-8' });\n\n  // Now install that `package.json` using NPM7\n  await fixture.shell(['node', require.resolve('npm'), 'install']);\n}\n\nconst ALREADY_BOOTSTRAPPED_IN_THIS_RUN = new Set();\n"]}

package/lib/with-packages.d.ts

@@ -0,0 +1,5 @@
+import { IPackageSource } from './package-sources/source';
+export interface PackageContext {
+    readonly packages: IPackageSource;
+}
+export declare function withPackages<A extends object>(block: (context: A & PackageContext) => Promise<void>): (context: A) => Promise<void>;

package/lib/with-packages.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withPackages = void 0;
+const subprocess_1 = require("./package-sources/subprocess");
+function withPackages(block) {
+    return async (context) => {
+        return block({
+            ...context,
+            packages: subprocess_1.packageSourceInSubprocess(),
+        });
+    };
+}
+exports.withPackages = withPackages;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aC1wYWNrYWdlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIndpdGgtcGFja2FnZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsNkRBQXlFO0FBTXpFLFNBQWdCLFlBQVksQ0FBbUIsS0FBcUQ7SUFDbEcsT0FBTyxLQUFLLEVBQUUsT0FBVSxFQUFFLEVBQUU7UUFDMUIsT0FBTyxLQUFLLENBQUM7WUFDWCxHQUFHLE9BQU87WUFDVixRQUFRLEVBQUUsc0NBQXlCLEVBQUU7U0FDdEMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQyxDQUFDO0FBQ0osQ0FBQztBQVBELG9DQU9DIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSVBhY2thZ2VTb3VyY2UgfSBmcm9tICcuL3BhY2thZ2Utc291cmNlcy9zb3VyY2UnO1xuaW1wb3J0IHsgcGFja2FnZVNvdXJjZUluU3VicHJvY2VzcyB9IGZyb20gJy4vcGFja2FnZS1zb3VyY2VzL3N1YnByb2Nlc3MnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFBhY2thZ2VDb250ZXh0IHtcbiAgcmVhZG9ubHkgcGFja2FnZXM6IElQYWNrYWdlU291cmNlO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gd2l0aFBhY2thZ2VzPEEgZXh0ZW5kcyBvYmplY3Q+KGJsb2NrOiAoY29udGV4dDogQSAmIFBhY2thZ2VDb250ZXh0KSA9PiBQcm9taXNlPHZvaWQ+KSB7XG4gIHJldHVybiBhc3luYyAoY29udGV4dDogQSkgPT4ge1xuICAgIHJldHVybiBibG9jayh7XG4gICAgICAuLi5jb250ZXh0LFxuICAgICAgcGFja2FnZXM6IHBhY2thZ2VTb3VyY2VJblN1YnByb2Nlc3MoKSxcbiAgICB9KTtcbiAgfTtcbn0iXX0=

package/lib/with-sam.d.ts

@@ -0,0 +1,33 @@
+import { TestContext } from './integ-test';
+import { ShellOptions } from './shell';
+import { AwsContext } from './with-aws';
+import { TestFixture } from './with-cdk-app';
+export interface ActionOutput {
+    actionSucceeded?: boolean;
+    actionOutput?: any;
+    shellOutput?: string;
+}
+/**
+ * Higher order function to execute a block with a SAM Integration CDK app fixture
+ */
+export declare function withSamIntegrationCdkApp<A extends TestContext & AwsContext>(block: (context: SamIntegrationTestFixture) => Promise<void>): (context: A) => Promise<void>;
+/**
+ * SAM Integration test fixture for CDK - SAM integration test cases
+ */
+export declare function withSamIntegrationFixture(block: (context: SamIntegrationTestFixture) => Promise<void>): (context: TestContext) => Promise<void>;
+export declare class SamIntegrationTestFixture extends TestFixture {
+    samShell(command: string[], filter?: string, action?: () => any, options?: Omit<ShellOptions, 'cwd' | 'output'>): Promise<ActionOutput>;
+    samBuild(stackName: string): Promise<ActionOutput>;
+    samLocalStartApi(stackName: string, isBuilt: boolean, port: number, apiPath: string): Promise<ActionOutput>;
+    /**
+     * Cleanup leftover stacks and buckets
+     */
+    dispose(success: boolean): Promise<void>;
+}
+export declare function randomInteger(min: number, max: number): number;
+/**
+ * A shell command that does what you want
+ *
+ * Is platform-aware, handles errors nicely.
+ */
+export declare function shellWithAction(command: string[], filter?: string, action?: () => Promise<any>, options?: ShellOptions): Promise<ActionOutput>;