@aws-cdk/integ-runner 2.200.1 → 2.201.0

package/lib/runner/cdk-integ-helper.js

@@ -0,0 +1,517 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SYNTH_OPTIONS = exports.CdkIntegHelper = void 0;
+exports.currentlyRecommendedAwsCdkLibFlags = currentlyRecommendedAwsCdkLibFlags;
+/* eslint-disable @cdklabs/no-literal-partition */
+const path = __importStar(require("path"));
+const cloud_assembly_api_1 = require("@aws-cdk/cloud-assembly-api");
+const fs = __importStar(require("fs-extra"));
+const integ_test_suite_1 = require("./integ-test-suite");
+const recommendedFlagsFile = __importStar(require("../recommended-feature-flags.json"));
+const utils_1 = require("../utils");
+const engine_1 = require("./engine");
+const logger = __importStar(require("../logger"));
+const cloud_assembly_1 = require("./private/cloud-assembly");
+const integ_manifest_1 = require("./private/integ-manifest");
+const DESTRUCTIVE_CHANGES = '!!DESTRUCTIVE_CHANGES:';
+/**
+ * Class with some helper routines for running CDK snapshots and integration tests.
+ *
+ * A "golden snapshot" is the snapshot that is stored permanently in version
+ * control, that new runs are compared against (stored in a directory named
+ * `<test-name>.snapshot`).
+ *
+ * This is as opposed to other snapshots, which can be generated for example
+ * temporarily in a temporary directory, to compare agains the golden snapshot.
+ */
+class CdkIntegHelper {
+    /**
+     * Factory method to create an instance of the CdkIntegHelper.
+     *
+     * Hiding the constructor to prevent inheritance.
+     */
+    static create(options) {
+        return new CdkIntegHelper(options);
+    }
+    /**
+     * The directory where the golden snapshot will be stored
+     */
+    goldenSnapshotDir;
+    /**
+     * An instance of the CDK  CLI
+     */
+    cdk;
+    /**
+     * Pretty name of the test
+     */
+    testName;
+    /**
+     * The value used in the '--app' CLI parameter
+     *
+     * Path to the integ test source file, relative to `this.directory`.
+     */
+    cdkApp;
+    /**
+     * The path where the `cdk.context.json` file
+     * will be created
+     */
+    cdkContextPath;
+    /**
+     * The working directory that the integration tests will be
+     * executed from
+     */
+    directory;
+    /**
+     * The test to run
+     */
+    test;
+    /**
+     * Default options to pass to the CDK CLI
+     */
+    defaultArgs = {
+        pathMetadata: false,
+        assetMetadata: false,
+        versionReporting: false,
+    };
+    /**
+     * The directory where the CDK will be synthed to
+     *
+     * Relative to cwd.
+     */
+    cdkOutDir;
+    /**
+     * The profile to use for the CDK CLI calls
+     */
+    profile;
+    /**
+     * Show output from the integ test run.
+     */
+    showOutput;
+    _destructiveChanges;
+    legacyContext;
+    _expectedTestSuite;
+    _actualSnapshot;
+    _legacyEnableLookups;
+    /**
+     * Fields that require an async context to initialize.
+     */
+    _asyncMembers;
+    /**
+     * Private constructor to prevent inheritance.
+     */
+    constructor(options) {
+        this.test = options.test;
+        this.directory = this.test.directory;
+        this.testName = this.test.testName;
+        this.goldenSnapshotDir = this.test.snapshotDir;
+        this.cdkContextPath = path.join(this.directory, 'cdk.context.json');
+        this.profile = options.profile;
+        this.showOutput = options.showOutput ?? false;
+        this.cdk = options.cdk ?? (0, engine_1.makeEngine)(options);
+        this.cdkOutDir = options.integOutDir ?? this.test.temporaryOutputDir;
+        const testRunCommand = this.test.appCommand;
+        this.cdkApp = testRunCommand.replace('{filePath}', path.relative(this.directory, this.test.fileName));
+    }
+    /**
+     * Async initialization; copy information from an async context into variables so we can access them synchronously later.
+     *
+     * We call this automatically in all public async members, but if a consumer wants to access this context synchronously
+     * without calling an async members first, it needs to call this.
+     */
+    async asyncInitialize() {
+        if (this._asyncMembers) {
+            return;
+        }
+        this._asyncMembers = {
+            testSpecificContext: await this.test.testSpecificContext(),
+        };
+    }
+    get asyncMembers() {
+        if (!this._asyncMembers) {
+            throw new Error('Async context not initialized. Call asyncInitialize() first.');
+        }
+        return this._asyncMembers;
+    }
+    /**
+     * Configure the legacy enableLookups value to use when generating the actual snapshot.
+     *
+     * Must be set before using snapshot methods.
+     */
+    configureLegacyEnableLookups(enableLookups) {
+        this._legacyEnableLookups = enableLookups;
+    }
+    /**
+     * Return the list of actual (i.e. new) test cases for this integration test
+     */
+    async actualTests() {
+        await this.asyncInitialize();
+        return (await this.actualTestSuite()).testSuite;
+    }
+    /**
+     * Generate a new "actual" snapshot which will be compared to the
+     * existing "expected" snapshot
+     * This will synth and then load the integration test manifest
+     */
+    async generateActualSnapshot() {
+        await this.synthActualSnapshot(this.cdkOutDir);
+        const manifest = await this.loadManifest(this.cdkOutDir);
+        return {
+            testDefinition: manifest,
+            snapshotDirectory: this.cdkOutDir,
+        };
+    }
+    /**
+     * Synth the actual application to the given directory, for purposes of generating/validating a snapshot
+     *
+     * `legacyEnableLookups` is to preserve historical behavior for a while:
+     * traditionally, the application would only be seeded with context if
+     * `enableLookups` was true, and this information would come from the test
+     * definition.
+     *
+     * - Since the test definition comes from inside the app, this requires a
+     *   synth just to get the test definition, and then another synth to generate
+     *   the actual snapshot with the correct context, which is time consuming.
+     * - Given that the context is fixed and fake, it could always have been passed.
+     *
+     * However, the snapshot contents themselves depend on the context flag, and changing
+     * this behavior now invalidates all snapshots everywhere, which is annoying for upgrading.
+     *
+     * So we will use the behavior from the GOLDEN SNAPSHOT's test definition to
+     * determine whether to pass the context, and if the new actual snapshot has a
+     * different value for `enableLookups`, we will throw away the old snapshot and synth again.
+     */
+    async synthActualSnapshot(outputDirectory) {
+        if (this._legacyEnableLookups === undefined) {
+            throw new Error('Must call configureLegacyEnableLookups before generating snapshots');
+        }
+        await this.cdk.synth({
+            app: this.cdkApp,
+            context: await this.getContext(this._legacyEnableLookups !== false ? exports.DEFAULT_SYNTH_OPTIONS.context : {}),
+            env: exports.DEFAULT_SYNTH_OPTIONS.env,
+            output: path.relative(this.directory, outputDirectory),
+        });
+    }
+    actualSynthReproCommand() {
+        // Show the command necessary to repro this
+        const envSet = Object.entries(exports.DEFAULT_SYNTH_OPTIONS.env).map(([k, v]) => `${k}='${v}'`);
+        const envCmd = envSet.length > 0 ? ['env', ...envSet] : [];
+        return [
+            ...envCmd,
+            'cdk',
+            'synth',
+            '-a',
+            `'${this.cdkApp}'`,
+            '-o',
+            `'${this.cdkOutDir}'`,
+            ...Object.entries(this.getContext(exports.DEFAULT_SYNTH_OPTIONS.context)).flatMap(([k, v]) => typeof v !== 'object' ? [`-c '${k}=${v}'`] : []),
+        ];
+    }
+    /**
+     * Returns true if a snapshot already exists for this test
+     */
+    hasSnapshot() {
+        return fs.existsSync(this.goldenSnapshotDir);
+    }
+    /**
+     * The test suite from the existing snapshot
+     */
+    async expectedTestSuite() {
+        await this.asyncInitialize();
+        if (!this._expectedTestSuite && this.hasSnapshot()) {
+            this._expectedTestSuite = await this.loadManifest();
+        }
+        return this._expectedTestSuite;
+    }
+    async actualSnapshot() {
+        await this.asyncInitialize();
+        if (!this._actualSnapshot) {
+            this._actualSnapshot = await this.generateActualSnapshot();
+            // Check if the enableLookups value has changed between the golden
+            // snapshot and the actual snapshot. If it has, we need to re-synth the
+            // actual snapshot with the new enableLookups value.
+            //
+            // See `synthActualSnapshot` for a description of why this is necessary.
+            const actualEnableLookups = this._actualSnapshot.testDefinition.enableLookups ?? false;
+            if (actualEnableLookups !== this._legacyEnableLookups && this._legacyEnableLookups !== 'dont-care') {
+                this.configureLegacyEnableLookups(actualEnableLookups);
+                this._actualSnapshot = await this.generateActualSnapshot();
+            }
+        }
+        return this._actualSnapshot;
+    }
+    /**
+     * The test suite from the new "actual" snapshot
+     */
+    async actualTestSuite() {
+        return (await this.actualSnapshot()).testDefinition;
+    }
+    /**
+     * Load the integ manifest which contains information
+     * on how to execute the tests
+     * First we try and load the manifest from the integ manifest (i.e. integ.json)
+     * from the cloud assembly. If it doesn't exist, then we fallback to the
+     * "legacy mode" and create a manifest from pragma
+     */
+    async loadManifest(dir) {
+        await this.asyncInitialize();
+        const manifest = dir ?? this.goldenSnapshotDir;
+        try {
+            const testSuite = integ_test_suite_1.IntegTestSuite.fromPath(manifest);
+            return testSuite;
+        }
+        catch (modernError) {
+            // Only attempt legacy test case if the integ test manifest was not found
+            // For any other errors, e.g. when parsing the manifest fails, we abort.
+            if (!(modernError instanceof integ_manifest_1.NoManifestError)) {
+                throw modernError;
+            }
+            if (this.showOutput) {
+                logger.trace("Failed to load integ test manifest for '%s'. Attempting as deprecated legacy test instead. Error was: %s", manifest, modernError.message ?? String(modernError));
+            }
+            const testCases = await integ_test_suite_1.LegacyIntegTestSuite.fromLegacy({
+                cdk: this.cdk,
+                testName: this.test.normalizedTestName,
+                integSourceFilePath: this.test.fileName,
+                listOptions: {
+                    ...this.defaultArgs,
+                    all: true,
+                    app: this.cdkApp,
+                    profile: this.profile,
+                    output: path.relative(this.directory, this.cdkOutDir),
+                },
+            });
+            this.legacyContext = integ_test_suite_1.LegacyIntegTestSuite.getPragmaContext(this.test.fileName);
+            return testCases;
+        }
+    }
+    cleanup() {
+        const cdkOutPath = this.cdkOutDir;
+        if (fs.existsSync(cdkOutPath)) {
+            fs.removeSync(cdkOutPath);
+        }
+        // Clear cache
+        this._actualSnapshot = undefined;
+    }
+    /**
+     * If there are any destructive changes to a stack then this will record
+     * those in the manifest.json file
+     */
+    renderTraceData() {
+        const traceData = new Map();
+        const destructiveChanges = this._destructiveChanges ?? [];
+        destructiveChanges.forEach(change => {
+            const trace = traceData.get(change.stackName);
+            if (trace) {
+                trace.set(change.logicalId, `${DESTRUCTIVE_CHANGES} ${change.impact}`);
+            }
+            else {
+                traceData.set(change.stackName, new Map([
+                    [change.logicalId, `${DESTRUCTIVE_CHANGES} ${change.impact}`],
+                ]));
+            }
+        });
+        return traceData;
+    }
+    /**
+     * In cases where we do not want to retain the assets,
+     * for example, if the assets are very large.
+     *
+     * Since it is possible to disable the update workflow for individual test
+     * cases, this needs to first get a list of stacks that have the update workflow
+     * disabled and then delete assets that relate to that stack. It does that
+     * by reading the asset manifest for the stack and deleting the asset source
+     */
+    async removeAssetsFromSnapshot() {
+        const stacks = (await this.actualTestSuite()).getStacksWithoutUpdateWorkflow() ?? [];
+        const manifest = cloud_assembly_1.AssemblyManifestReader.fromPath(this.goldenSnapshotDir);
+        const assets = (0, utils_1.flatten)(stacks.map(stack => {
+            return manifest.getAssetLocationsForStack(stack) ?? [];
+        }));
+        assets.forEach(asset => {
+            const fileName = path.join(this.goldenSnapshotDir, asset);
+            if (fs.existsSync(fileName)) {
+                if (fs.lstatSync(fileName).isDirectory()) {
+                    fs.removeSync(fileName);
+                }
+                else {
+                    fs.unlinkSync(fileName);
+                }
+            }
+        });
+    }
+    /**
+     * Remove the asset cache (.cache/) files from the snapshot.
+     * These are a cache of the asset zips, but we are fine with
+     * re-zipping on deploy
+     */
+    removeAssetsCacheFromSnapshot() {
+        const files = fs.readdirSync(this.goldenSnapshotDir);
+        files.forEach(file => {
+            const fileName = path.join(this.goldenSnapshotDir, file);
+            if (fs.lstatSync(fileName).isDirectory() && file === '.cache') {
+                fs.emptyDirSync(fileName);
+                fs.rmdirSync(fileName);
+            }
+        });
+    }
+    /**
+     * Create the new snapshot.
+     *
+     * If lookups are enabled, then we need create the snapshot by synth'ing again
+     * with the dummy context so that each time the test is run on different machines
+     * (and with different context/env) the diff will not change.
+     *
+     * If lookups are disabled (which means the stack is env agnostic) then just copy
+     * the assembly that was output by the deployment
+     */
+    async createSnapshot() {
+        await this.asyncInitialize();
+        if (fs.existsSync(this.goldenSnapshotDir)) {
+            fs.removeSync(this.goldenSnapshotDir);
+        }
+        // TODO: If we're clever, we should be able to reuse the snapshot that was
+        // generated during the test invalidation check and avoid the below synth.
+        // But that gets run in a completely different lifecycle and it might not
+        // exist. We're not dealing with that just yet.
+        await this.synthActualSnapshot(this.goldenSnapshotDir);
+        await this.cleanupGoldenSnapshot();
+    }
+    /**
+     * Perform some cleanup steps after the snapshot is created
+     * Anytime the snapshot needs to be modified after creation
+     * the logic should live here.
+     */
+    async cleanupGoldenSnapshot() {
+        if (fs.existsSync(this.goldenSnapshotDir)) {
+            await this.removeAssetsFromSnapshot();
+            this.removeAssetsCacheFromSnapshot();
+            const assembly = cloud_assembly_1.AssemblyManifestReader.fromPath(this.goldenSnapshotDir);
+            assembly.cleanManifest();
+            assembly.recordTrace(this.renderTraceData());
+        }
+        // if this is a legacy test then create an integ manifest
+        // in the snapshot directory which can be used for the
+        // update workflow. Save any legacyContext as well so that it can be read
+        // the next time
+        const actualTestSuite = await this.actualTestSuite();
+        if (actualTestSuite.type === 'legacy-test-suite') {
+            actualTestSuite.saveManifest(this.goldenSnapshotDir, this.legacyContext);
+        }
+    }
+    getContext(additionalContext) {
+        // Load the test-specific context (from `integ.context.json` or `cdk.json#context`), if any.
+        // If not found, use the built-in current feature flags (at the risk of newer feature flags changing
+        // the snapshots).
+        const featureFlags = this.asyncMembers.testSpecificContext ?? currentlyRecommendedAwsCdkLibFlags();
+        return {
+            ...featureFlags,
+            ...this.legacyContext,
+            ...additionalContext,
+            // Don't record creation stack traces in the snapshot, since they just take up space and are never deterministic.
+            'aws:cdk:disable-creation-stack-traces': true,
+            // We originally had PLANNED to set this to ['aws', 'aws-cn'], but due to a programming mistake
+            // it was set to everything. In this PR, set it to everything to not mess up all the snapshots.
+            '@aws-cdk/core:target-partitions': undefined,
+            /* ---------------- THE FUTURE LIVES BELOW----------------------------
+            // Restricting to these target partitions makes most service principals synthesize to
+            // `service.${URL_SUFFIX}`, which is technically *incorrect* (it's only `amazonaws.com`
+            // or `amazonaws.com.cn`, never UrlSuffix for any of the restricted regions) but it's what
+            // most existing integ tests contain, and we want to disturb as few as possible.
+            // [TARGET_PARTITIONS]: ['aws', 'aws-cn'],
+            /* ---------------- END OF THE FUTURE ------------------------------- */
+        };
+    }
+}
+exports.CdkIntegHelper = CdkIntegHelper;
+// Default context we run all integ tests with, so they don't depend on the
+// account of the exercising user.
+exports.DEFAULT_SYNTH_OPTIONS = {
+    context: {
+        [cloud_assembly_api_1.AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY]: ['test-region-1a', 'test-region-1b', 'test-region-1c'],
+        'availability-zones:account=12345678:region=test-region': ['test-region-1a', 'test-region-1b', 'test-region-1c'],
+        'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn-ami-hvm-x86_64-gp2:region=test-region': 'ami-1234',
+        'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2:region=test-region': 'ami-1234',
+        'ssm:account=12345678:parameterName=/aws/service/ecs/optimized-ami/amazon-linux/recommended:region=test-region': '{"image_id": "ami-1234"}',
+        // eslint-disable-next-line @stylistic/max-len
+        'ami:account=12345678:filters.image-type.0=machine:filters.name.0=amzn-ami-vpc-nat-*:filters.state.0=available:owners.0=amazon:region=test-region': 'ami-1234',
+        'vpc-provider:account=12345678:filter.isDefault=true:region=test-region:returnAsymmetricSubnets=true': {
+            vpcId: 'vpc-60900905',
+            subnetGroups: [
+                {
+                    type: 'Public',
+                    name: 'Public',
+                    subnets: [
+                        {
+                            subnetId: 'subnet-e19455ca',
+                            availabilityZone: 'us-east-1a',
+                            routeTableId: 'rtb-e19455ca',
+                        },
+                        {
+                            subnetId: 'subnet-e0c24797',
+                            availabilityZone: 'us-east-1b',
+                            routeTableId: 'rtb-e0c24797',
+                        },
+                        {
+                            subnetId: 'subnet-ccd77395',
+                            availabilityZone: 'us-east-1c',
+                            routeTableId: 'rtb-ccd77395',
+                        },
+                    ],
+                },
+            ],
+        },
+    },
+    env: {
+        CDK_INTEG_ACCOUNT: '12345678',
+        CDK_INTEG_REGION: 'test-region',
+        CDK_INTEG_HOSTED_ZONE_ID: 'Z23ABC4XYZL05B',
+        CDK_INTEG_HOSTED_ZONE_NAME: 'example.com',
+        CDK_INTEG_DOMAIN_NAME: '*.example.com',
+        CDK_INTEG_CERT_ARN: 'arn:aws:acm:test-region:12345678:certificate/86468209-a272-595d-b831-0efb6421265z',
+        CDK_INTEG_SUBNET_ID: 'subnet-0dff1a399d8f6f92c',
+    },
+};
+/**
+ * Return the currently recommended flags for `aws-cdk-lib`.
+ *
+ * These have been built into the CLI at build time. If this ever gets changed
+ * back to a dynamic load, remember that this source file may be bundled into
+ * a JavaScript bundle, and `__dirname` might not point where you think it does.
+ */
+function currentlyRecommendedAwsCdkLibFlags() {
+    return recommendedFlagsFile;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-integ-helper.js","sourceRoot":"","sources":["cdk-integ-helper.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @cdklabs/no-literal-partition */\nimport * as path from 'path';\nimport { AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY } from '@aws-cdk/cloud-assembly-api';\nimport type { TestCase, DefaultCdkOptions } from '@aws-cdk/cloud-assembly-schema';\nimport * as fs from 'fs-extra';\nimport { IntegTestSuite, LegacyIntegTestSuite } from './integ-test-suite';\nimport type { IntegTest } from './integration-tests';\nimport * as recommendedFlagsFile from '../recommended-feature-flags.json';\nimport { flatten } from '../utils';\nimport { makeEngine } from './engine';\nimport type { ICdk } from '../engines/cdk-interface';\nimport * as logger from '../logger';\nimport type { ManifestTrace } from './private/cloud-assembly';\nimport { AssemblyManifestReader } from './private/cloud-assembly';\nimport type { DestructiveChange } from '../workers/common';\nimport { NoManifestError } from './private/integ-manifest';\nimport type { CdkContext } from './private/test-specific-context';\n\nconst DESTRUCTIVE_CHANGES = '!!DESTRUCTIVE_CHANGES:';\n\n/**\n * Options for creating an integ helper\n */\nexport interface CdkIntegHelperOptions {\n  /**\n   * Information about the test to run\n   */\n  readonly test: IntegTest;\n\n  /**\n   * The region where the test should be deployed\n   */\n  readonly region: string;\n\n  /**\n   * The AWS profile to use when invoking the CDK CLI\n   *\n   * @default - no profile is passed, the default profile is used\n   */\n  readonly profile?: string;\n\n  /**\n   * Additional environment variables that will be available\n   * to the CDK CLI\n   *\n   * @default - no additional environment variables\n   */\n  readonly env?: { [name: string]: string };\n\n  /**\n   * tmp cdk.out directory\n   *\n   * @default - directory will be `cdk-integ.out.${testName}`\n   */\n  readonly integOutDir?: string;\n\n  /**\n   * Instance of the CDK Toolkit Engine to use\n   *\n   * @default - based on `engine` option\n   */\n  readonly cdk?: ICdk;\n\n  /**\n   * Show output from running integration tests\n   *\n   * @default false\n   */\n  readonly showOutput?: boolean;\n\n  /**\n   * Use the indicated proxy\n   *\n   * @default - no proxy\n   */\n  readonly proxy?: string;\n\n  /**\n   * Path to CA certificate to use when validating HTTPS requests\n   *\n   * @default - no additional CA bundle\n   */\n  readonly caBundlePath?: string;\n}\n\n/**\n * Whether to synthesize the actual snapshot with lookups enabled or not.\n *\n * If either `true` or `false`, we send context in or not while synthesizing,\n * and if the generated snapshot test definition requests a different value we\n * will synth again.\n *\n * For `dont-care`, we do send in the context but we never resynth.\n */\nexport type LegacyEnableLookups = true | false | 'dont-care';\n\n/**\n * Class with some helper routines for running CDK snapshots and integration tests.\n *\n * A \"golden snapshot\" is the snapshot that is stored permanently in version\n * control, that new runs are compared against (stored in a directory named\n * `<test-name>.snapshot`).\n *\n * This is as opposed to other snapshots, which can be generated for example\n * temporarily in a temporary directory, to compare agains the golden snapshot.\n */\nexport class CdkIntegHelper {\n  /**\n   * Factory method to create an instance of the CdkIntegHelper.\n   *\n   * Hiding the constructor to prevent inheritance.\n   */\n  public static create(options: CdkIntegHelperOptions) {\n    return new CdkIntegHelper(options);\n  }\n\n  /**\n   * The directory where the golden snapshot will be stored\n   */\n  public readonly goldenSnapshotDir: string;\n\n  /**\n   * An instance of the CDK  CLI\n   */\n  public readonly cdk: ICdk;\n\n  /**\n   * Pretty name of the test\n   */\n  public readonly testName: string;\n\n  /**\n   * The value used in the '--app' CLI parameter\n   *\n   * Path to the integ test source file, relative to `this.directory`.\n   */\n  public readonly cdkApp: string;\n\n  /**\n   * The path where the `cdk.context.json` file\n   * will be created\n   */\n  public readonly cdkContextPath: string;\n\n  /**\n   * The working directory that the integration tests will be\n   * executed from\n   */\n  public readonly directory: string;\n\n  /**\n   * The test to run\n   */\n  private readonly test: IntegTest;\n\n  /**\n   * Default options to pass to the CDK CLI\n   */\n  public readonly defaultArgs: DefaultCdkOptions = {\n    pathMetadata: false,\n    assetMetadata: false,\n    versionReporting: false,\n  };\n\n  /**\n   * The directory where the CDK will be synthed to\n   *\n   * Relative to cwd.\n   */\n  public readonly cdkOutDir: string;\n\n  /**\n   * The profile to use for the CDK CLI calls\n   */\n  public readonly profile?: string;\n\n  /**\n   * Show output from the integ test run.\n   */\n  private readonly showOutput: boolean;\n\n  public _destructiveChanges?: DestructiveChange[];\n  private legacyContext?: Record<string, any>;\n  private _expectedTestSuite?: IntegTestSuite | LegacyIntegTestSuite;\n  private _actualSnapshot?: SnapshotAndTestDefinition;\n  private _legacyEnableLookups?: LegacyEnableLookups;\n\n  /**\n   * Fields that require an async context to initialize.\n   */\n  private _asyncMembers?: {\n    testSpecificContext?: CdkContext;\n  };\n\n  /**\n   * Private constructor to prevent inheritance.\n   */\n  private constructor(options: CdkIntegHelperOptions) {\n    this.test = options.test;\n    this.directory = this.test.directory;\n    this.testName = this.test.testName;\n    this.goldenSnapshotDir = this.test.snapshotDir;\n    this.cdkContextPath = path.join(this.directory, 'cdk.context.json');\n    this.profile = options.profile;\n    this.showOutput = options.showOutput ?? false;\n\n    this.cdk = options.cdk ?? makeEngine(options);\n    this.cdkOutDir = options.integOutDir ?? this.test.temporaryOutputDir;\n\n    const testRunCommand = this.test.appCommand;\n    this.cdkApp = testRunCommand.replace('{filePath}', path.relative(this.directory, this.test.fileName));\n  }\n\n  /**\n   * Async initialization; copy information from an async context into variables so we can access them synchronously later.\n   *\n   * We call this automatically in all public async members, but if a consumer wants to access this context synchronously\n   * without calling an async members first, it needs to call this.\n   */\n  public async asyncInitialize(): Promise<void> {\n    if (this._asyncMembers) {\n      return;\n    }\n\n    this._asyncMembers = {\n      testSpecificContext: await this.test.testSpecificContext(),\n    };\n  }\n\n  private get asyncMembers(): NonNullable<CdkIntegHelper['_asyncMembers']> {\n    if (!this._asyncMembers) {\n      throw new Error('Async context not initialized. Call asyncInitialize() first.');\n    }\n    return this._asyncMembers;\n  }\n\n  /**\n   * Configure the legacy enableLookups value to use when generating the actual snapshot.\n   *\n   * Must be set before using snapshot methods.\n   */\n  public configureLegacyEnableLookups(enableLookups: LegacyEnableLookups): void {\n    this._legacyEnableLookups = enableLookups;\n  }\n\n  /**\n   * Return the list of actual (i.e. new) test cases for this integration test\n   */\n  public async actualTests(): Promise<{ [testName: string]: TestCase } | undefined> {\n    await this.asyncInitialize();\n    return (await this.actualTestSuite()).testSuite;\n  }\n\n  /**\n   * Generate a new \"actual\" snapshot which will be compared to the\n   * existing \"expected\" snapshot\n   * This will synth and then load the integration test manifest\n   */\n  private async generateActualSnapshot(): Promise<SnapshotAndTestDefinition> {\n    await this.synthActualSnapshot(this.cdkOutDir);\n    const manifest = await this.loadManifest(this.cdkOutDir);\n    return {\n      testDefinition: manifest,\n      snapshotDirectory: this.cdkOutDir,\n    };\n  }\n\n  /**\n   * Synth the actual application to the given directory, for purposes of generating/validating a snapshot\n   *\n   * `legacyEnableLookups` is to preserve historical behavior for a while:\n   * traditionally, the application would only be seeded with context if\n   * `enableLookups` was true, and this information would come from the test\n   * definition.\n   *\n   * - Since the test definition comes from inside the app, this requires a\n   *   synth just to get the test definition, and then another synth to generate\n   *   the actual snapshot with the correct context, which is time consuming.\n   * - Given that the context is fixed and fake, it could always have been passed.\n   *\n   * However, the snapshot contents themselves depend on the context flag, and changing\n   * this behavior now invalidates all snapshots everywhere, which is annoying for upgrading.\n   *\n   * So we will use the behavior from the GOLDEN SNAPSHOT's test definition to\n   * determine whether to pass the context, and if the new actual snapshot has a\n   * different value for `enableLookups`, we will throw away the old snapshot and synth again.\n   */\n  private async synthActualSnapshot(outputDirectory: string): Promise<void> {\n    if (this._legacyEnableLookups === undefined) {\n      throw new Error('Must call configureLegacyEnableLookups before generating snapshots');\n    }\n\n    await this.cdk.synth({\n      app: this.cdkApp,\n      context: await this.getContext(this._legacyEnableLookups !== false ? DEFAULT_SYNTH_OPTIONS.context : {}),\n      env: DEFAULT_SYNTH_OPTIONS.env,\n      output: path.relative(this.directory, outputDirectory),\n    });\n  }\n\n  public actualSynthReproCommand() {\n    // Show the command necessary to repro this\n    const envSet = Object.entries(DEFAULT_SYNTH_OPTIONS.env).map(([k, v]) => `${k}='${v}'`);\n    const envCmd = envSet.length > 0 ? ['env', ...envSet] : [];\n\n    return [\n      ...envCmd,\n      'cdk',\n      'synth',\n      '-a',\n      `'${this.cdkApp}'`,\n      '-o',\n      `'${this.cdkOutDir}'`,\n      ...Object.entries(this.getContext(DEFAULT_SYNTH_OPTIONS.context)).flatMap(([k, v]) => typeof v !== 'object' ? [`-c '${k}=${v}'`] : []),\n    ];\n  }\n\n  /**\n   * Returns true if a snapshot already exists for this test\n   */\n  public hasSnapshot(): boolean {\n    return fs.existsSync(this.goldenSnapshotDir);\n  }\n\n  /**\n   * The test suite from the existing snapshot\n   */\n  public async expectedTestSuite(): Promise<IntegTestSuite | LegacyIntegTestSuite | undefined> {\n    await this.asyncInitialize();\n    if (!this._expectedTestSuite && this.hasSnapshot()) {\n      this._expectedTestSuite = await this.loadManifest();\n    }\n    return this._expectedTestSuite;\n  }\n\n  public async actualSnapshot(): Promise<SnapshotAndTestDefinition> {\n    await this.asyncInitialize();\n    if (!this._actualSnapshot) {\n      this._actualSnapshot = await this.generateActualSnapshot();\n\n      // Check if the enableLookups value has changed between the golden\n      // snapshot and the actual snapshot. If it has, we need to re-synth the\n      // actual snapshot with the new enableLookups value.\n      //\n      // See `synthActualSnapshot` for a description of why this is necessary.\n      const actualEnableLookups = this._actualSnapshot.testDefinition.enableLookups ?? false;\n      if (actualEnableLookups !== this._legacyEnableLookups && this._legacyEnableLookups !== 'dont-care') {\n        this.configureLegacyEnableLookups(actualEnableLookups);\n        this._actualSnapshot = await this.generateActualSnapshot();\n      }\n    }\n    return this._actualSnapshot;\n  }\n\n  /**\n   * The test suite from the new \"actual\" snapshot\n   */\n  private async actualTestSuite(): Promise<IntegTestSuite | LegacyIntegTestSuite> {\n    return (await this.actualSnapshot()).testDefinition;\n  }\n\n  /**\n   * Load the integ manifest which contains information\n   * on how to execute the tests\n   * First we try and load the manifest from the integ manifest (i.e. integ.json)\n   * from the cloud assembly. If it doesn't exist, then we fallback to the\n   * \"legacy mode\" and create a manifest from pragma\n   */\n  public async loadManifest(dir?: string): Promise<IntegTestSuite | LegacyIntegTestSuite> {\n    await this.asyncInitialize();\n    const manifest = dir ?? this.goldenSnapshotDir;\n    try {\n      const testSuite = IntegTestSuite.fromPath(manifest);\n      return testSuite;\n    } catch (modernError: any) {\n      // Only attempt legacy test case if the integ test manifest was not found\n      // For any other errors, e.g. when parsing the manifest fails, we abort.\n      if (!(modernError instanceof NoManifestError)) {\n        throw modernError;\n      }\n\n      if (this.showOutput) {\n        logger.trace(\n          \"Failed to load integ test manifest for '%s'. Attempting as deprecated legacy test instead. Error was: %s\",\n          manifest,\n          modernError.message ?? String(modernError),\n        );\n      }\n\n      const testCases = await LegacyIntegTestSuite.fromLegacy({\n        cdk: this.cdk,\n        testName: this.test.normalizedTestName,\n        integSourceFilePath: this.test.fileName,\n        listOptions: {\n          ...this.defaultArgs,\n          all: true,\n          app: this.cdkApp,\n          profile: this.profile,\n          output: path.relative(this.directory, this.cdkOutDir),\n        },\n      });\n      this.legacyContext = LegacyIntegTestSuite.getPragmaContext(this.test.fileName);\n      return testCases;\n    }\n  }\n\n  public cleanup(): void {\n    const cdkOutPath = this.cdkOutDir;\n    if (fs.existsSync(cdkOutPath)) {\n      fs.removeSync(cdkOutPath);\n    }\n    // Clear cache\n    this._actualSnapshot = undefined;\n  }\n\n  /**\n   * If there are any destructive changes to a stack then this will record\n   * those in the manifest.json file\n   */\n  private renderTraceData(): ManifestTrace {\n    const traceData: ManifestTrace = new Map();\n    const destructiveChanges = this._destructiveChanges ?? [];\n    destructiveChanges.forEach(change => {\n      const trace = traceData.get(change.stackName);\n      if (trace) {\n        trace.set(change.logicalId, `${DESTRUCTIVE_CHANGES} ${change.impact}`);\n      } else {\n        traceData.set(change.stackName, new Map([\n          [change.logicalId, `${DESTRUCTIVE_CHANGES} ${change.impact}`],\n        ]));\n      }\n    });\n    return traceData;\n  }\n\n  /**\n   * In cases where we do not want to retain the assets,\n   * for example, if the assets are very large.\n   *\n   * Since it is possible to disable the update workflow for individual test\n   * cases, this needs to first get a list of stacks that have the update workflow\n   * disabled and then delete assets that relate to that stack. It does that\n   * by reading the asset manifest for the stack and deleting the asset source\n   */\n  private async removeAssetsFromSnapshot(): Promise<void> {\n    const stacks = (await this.actualTestSuite()).getStacksWithoutUpdateWorkflow() ?? [];\n    const manifest = AssemblyManifestReader.fromPath(this.goldenSnapshotDir);\n    const assets = flatten(stacks.map(stack => {\n      return manifest.getAssetLocationsForStack(stack) ?? [];\n    }));\n\n    assets.forEach(asset => {\n      const fileName = path.join(this.goldenSnapshotDir, asset);\n      if (fs.existsSync(fileName)) {\n        if (fs.lstatSync(fileName).isDirectory()) {\n          fs.removeSync(fileName);\n        } else {\n          fs.unlinkSync(fileName);\n        }\n      }\n    });\n  }\n\n  /**\n   * Remove the asset cache (.cache/) files from the snapshot.\n   * These are a cache of the asset zips, but we are fine with\n   * re-zipping on deploy\n   */\n  private removeAssetsCacheFromSnapshot(): void {\n    const files = fs.readdirSync(this.goldenSnapshotDir);\n    files.forEach(file => {\n      const fileName = path.join(this.goldenSnapshotDir, file);\n      if (fs.lstatSync(fileName).isDirectory() && file === '.cache') {\n        fs.emptyDirSync(fileName);\n        fs.rmdirSync(fileName);\n      }\n    });\n  }\n\n  /**\n   * Create the new snapshot.\n   *\n   * If lookups are enabled, then we need create the snapshot by synth'ing again\n   * with the dummy context so that each time the test is run on different machines\n   * (and with different context/env) the diff will not change.\n   *\n   * If lookups are disabled (which means the stack is env agnostic) then just copy\n   * the assembly that was output by the deployment\n   */\n  public async createSnapshot(): Promise<void> {\n    await this.asyncInitialize();\n    if (fs.existsSync(this.goldenSnapshotDir)) {\n      fs.removeSync(this.goldenSnapshotDir);\n    }\n\n    // TODO: If we're clever, we should be able to reuse the snapshot that was\n    // generated during the test invalidation check and avoid the below synth.\n    // But that gets run in a completely different lifecycle and it might not\n    // exist. We're not dealing with that just yet.\n    await this.synthActualSnapshot(this.goldenSnapshotDir);\n\n    await this.cleanupGoldenSnapshot();\n  }\n\n  /**\n   * Perform some cleanup steps after the snapshot is created\n   * Anytime the snapshot needs to be modified after creation\n   * the logic should live here.\n   */\n  private async cleanupGoldenSnapshot(): Promise<void> {\n    if (fs.existsSync(this.goldenSnapshotDir)) {\n      await this.removeAssetsFromSnapshot();\n      this.removeAssetsCacheFromSnapshot();\n      const assembly = AssemblyManifestReader.fromPath(this.goldenSnapshotDir);\n      assembly.cleanManifest();\n      assembly.recordTrace(this.renderTraceData());\n    }\n\n    // if this is a legacy test then create an integ manifest\n    // in the snapshot directory which can be used for the\n    // update workflow. Save any legacyContext as well so that it can be read\n    // the next time\n    const actualTestSuite = await this.actualTestSuite();\n    if (actualTestSuite.type === 'legacy-test-suite') {\n      (actualTestSuite as LegacyIntegTestSuite).saveManifest(this.goldenSnapshotDir, this.legacyContext);\n    }\n  }\n\n  public getContext(additionalContext?: Record<string, any>): Record<string, any> {\n    // Load the test-specific context (from `integ.context.json` or `cdk.json#context`), if any.\n    // If not found, use the built-in current feature flags (at the risk of newer feature flags changing\n    // the snapshots).\n    const featureFlags = this.asyncMembers.testSpecificContext ?? currentlyRecommendedAwsCdkLibFlags();\n\n    return {\n      ...featureFlags,\n      ...this.legacyContext,\n      ...additionalContext,\n\n      // Don't record creation stack traces in the snapshot, since they just take up space and are never deterministic.\n      'aws:cdk:disable-creation-stack-traces': true,\n\n      // We originally had PLANNED to set this to ['aws', 'aws-cn'], but due to a programming mistake\n      // it was set to everything. In this PR, set it to everything to not mess up all the snapshots.\n      '@aws-cdk/core:target-partitions': undefined,\n\n      /* ---------------- THE FUTURE LIVES BELOW----------------------------\n      // Restricting to these target partitions makes most service principals synthesize to\n      // `service.${URL_SUFFIX}`, which is technically *incorrect* (it's only `amazonaws.com`\n      // or `amazonaws.com.cn`, never UrlSuffix for any of the restricted regions) but it's what\n      // most existing integ tests contain, and we want to disturb as few as possible.\n      // [TARGET_PARTITIONS]: ['aws', 'aws-cn'],\n      /* ---------------- END OF THE FUTURE ------------------------------- */\n    };\n  }\n}\n\n// Default context we run all integ tests with, so they don't depend on the\n// account of the exercising user.\nexport const DEFAULT_SYNTH_OPTIONS = {\n  context: {\n    [AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY]: ['test-region-1a', 'test-region-1b', 'test-region-1c'],\n    'availability-zones:account=12345678:region=test-region': ['test-region-1a', 'test-region-1b', 'test-region-1c'],\n    'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn-ami-hvm-x86_64-gp2:region=test-region': 'ami-1234',\n    'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2:region=test-region': 'ami-1234',\n    'ssm:account=12345678:parameterName=/aws/service/ecs/optimized-ami/amazon-linux/recommended:region=test-region': '{\"image_id\": \"ami-1234\"}',\n    // eslint-disable-next-line @stylistic/max-len\n    'ami:account=12345678:filters.image-type.0=machine:filters.name.0=amzn-ami-vpc-nat-*:filters.state.0=available:owners.0=amazon:region=test-region': 'ami-1234',\n    'vpc-provider:account=12345678:filter.isDefault=true:region=test-region:returnAsymmetricSubnets=true': {\n      vpcId: 'vpc-60900905',\n      subnetGroups: [\n        {\n          type: 'Public',\n          name: 'Public',\n          subnets: [\n            {\n              subnetId: 'subnet-e19455ca',\n              availabilityZone: 'us-east-1a',\n              routeTableId: 'rtb-e19455ca',\n            },\n            {\n              subnetId: 'subnet-e0c24797',\n              availabilityZone: 'us-east-1b',\n              routeTableId: 'rtb-e0c24797',\n            },\n            {\n              subnetId: 'subnet-ccd77395',\n              availabilityZone: 'us-east-1c',\n              routeTableId: 'rtb-ccd77395',\n            },\n          ],\n        },\n      ],\n    },\n  },\n  env: {\n    CDK_INTEG_ACCOUNT: '12345678',\n    CDK_INTEG_REGION: 'test-region',\n    CDK_INTEG_HOSTED_ZONE_ID: 'Z23ABC4XYZL05B',\n    CDK_INTEG_HOSTED_ZONE_NAME: 'example.com',\n    CDK_INTEG_DOMAIN_NAME: '*.example.com',\n    CDK_INTEG_CERT_ARN: 'arn:aws:acm:test-region:12345678:certificate/86468209-a272-595d-b831-0efb6421265z',\n    CDK_INTEG_SUBNET_ID: 'subnet-0dff1a399d8f6f92c',\n  },\n};\n\n/**\n * Return the currently recommended flags for `aws-cdk-lib`.\n *\n * These have been built into the CLI at build time. If this ever gets changed\n * back to a dynamic load, remember that this source file may be bundled into\n * a JavaScript bundle, and `__dirname` might not point where you think it does.\n */\nexport function currentlyRecommendedAwsCdkLibFlags() {\n  return recommendedFlagsFile;\n}\n\nexport interface SnapshotAndTestDefinition {\n  readonly testDefinition: IntegTestSuite | LegacyIntegTestSuite;\n  readonly snapshotDirectory: string;\n}\n"]}

package/lib/runner/engine.d.ts

@@ -1,9 +1,10 @@
-import type { IntegRunnerOptions } from './runner-base';
+import type { CdkIntegHelperOptions } from './cdk-integ-helper';
 import { ToolkitLibRunnerEngine } from '../engines/toolkit-lib';
 /**
  * Creates the engine for running integration tests.
  *
  * Only the toolkit-lib engine is supported.
  */
-export declare function makeEngine(options: IntegRunnerOptions): ToolkitLibRunnerEngine;
+export declare function makeEngine(options: EngineOptions): ToolkitLibRunnerEngine;
+export type EngineOptions = Pick<CdkIntegHelperOptions, 'test' | 'showOutput' | 'env' | 'region' | 'profile' | 'proxy' | 'caBundlePath'>;
 //# sourceMappingURL=engine.d.ts.map

package/lib/runner/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,kBAAkB,GAAG,sBAAsB,CAU9E"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,aAAa,GAAG,sBAAsB,CAUzE;AAED,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,qBAAqB,EAAE,MAAM,GAAG,YAAY,GAAG,KAAK,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,cAAc,CAAC,CAAC"}

package/lib/runner/engine.js

@@ -18,4 +18,4 @@ function makeEngine(options) {
         caBundlePath: options.caBundlePath,
     });
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5naW5lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiZW5naW5lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBUUEsZ0NBVUM7QUFqQkQsd0RBQWdFO0FBRWhFOzs7O0dBSUc7QUFDSCxTQUFnQixVQUFVLENBQUMsT0FBMkI7SUFDcEQsT0FBTyxJQUFJLG9DQUFzQixDQUFDO1FBQ2hDLGdCQUFnQixFQUFFLE9BQU8sQ0FBQyxJQUFJLENBQUMsU0FBUztRQUN4QyxVQUFVLEVBQUUsT0FBTyxDQUFDLFVBQVU7UUFDOUIsR0FBRyxFQUFFLE9BQU8sQ0FBQyxHQUFHO1FBQ2hCLE1BQU0sRUFBRSxPQUFPLENBQUMsTUFBTTtRQUN0QixPQUFPLEVBQUUsT0FBTyxDQUFDLE9BQU87UUFDeEIsS0FBSyxFQUFFLE9BQU8sQ0FBQyxLQUFLO1FBQ3BCLFlBQVksRUFBRSxPQUFPLENBQUMsWUFBWTtLQUNuQyxDQUFDLENBQUM7QUFDTCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBJbnRlZ1J1bm5lck9wdGlvbnMgfSBmcm9tICcuL3J1bm5lci1iYXNlJztcbmltcG9ydCB7IFRvb2xraXRMaWJSdW5uZXJFbmdpbmUgfSBmcm9tICcuLi9lbmdpbmVzL3Rvb2xraXQtbGliJztcblxuLyoqXG4gKiBDcmVhdGVzIHRoZSBlbmdpbmUgZm9yIHJ1bm5pbmcgaW50ZWdyYXRpb24gdGVzdHMuXG4gKlxuICogT25seSB0aGUgdG9vbGtpdC1saWIgZW5naW5lIGlzIHN1cHBvcnRlZC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIG1ha2VFbmdpbmUob3B0aW9uczogSW50ZWdSdW5uZXJPcHRpb25zKTogVG9vbGtpdExpYlJ1bm5lckVuZ2luZSB7XG4gIHJldHVybiBuZXcgVG9vbGtpdExpYlJ1bm5lckVuZ2luZSh7XG4gICAgd29ya2luZ0RpcmVjdG9yeTogb3B0aW9ucy50ZXN0LmRpcmVjdG9yeSxcbiAgICBzaG93T3V0cHV0OiBvcHRpb25zLnNob3dPdXRwdXQsXG4gICAgZW52OiBvcHRpb25zLmVudixcbiAgICByZWdpb246IG9wdGlvbnMucmVnaW9uLFxuICAgIHByb2ZpbGU6IG9wdGlvbnMucHJvZmlsZSxcbiAgICBwcm94eTogb3B0aW9ucy5wcm94eSxcbiAgICBjYUJ1bmRsZVBhdGg6IG9wdGlvbnMuY2FCdW5kbGVQYXRoLFxuICB9KTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5naW5lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiZW5naW5lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBUUEsZ0NBVUM7QUFqQkQsd0RBQWdFO0FBRWhFOzs7O0dBSUc7QUFDSCxTQUFnQixVQUFVLENBQUMsT0FBc0I7SUFDL0MsT0FBTyxJQUFJLG9DQUFzQixDQUFDO1FBQ2hDLGdCQUFnQixFQUFFLE9BQU8sQ0FBQyxJQUFJLENBQUMsU0FBUztRQUN4QyxVQUFVLEVBQUUsT0FBTyxDQUFDLFVBQVU7UUFDOUIsR0FBRyxFQUFFLE9BQU8sQ0FBQyxHQUFHO1FBQ2hCLE1BQU0sRUFBRSxPQUFPLENBQUMsTUFBTTtRQUN0QixPQUFPLEVBQUUsT0FBTyxDQUFDLE9BQU87UUFDeEIsS0FBSyxFQUFFLE9BQU8sQ0FBQyxLQUFLO1FBQ3BCLFlBQVksRUFBRSxPQUFPLENBQUMsWUFBWTtLQUNuQyxDQUFDLENBQUM7QUFDTCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBDZGtJbnRlZ0hlbHBlck9wdGlvbnMgfSBmcm9tICcuL2Nkay1pbnRlZy1oZWxwZXInO1xuaW1wb3J0IHsgVG9vbGtpdExpYlJ1bm5lckVuZ2luZSB9IGZyb20gJy4uL2VuZ2luZXMvdG9vbGtpdC1saWInO1xuXG4vKipcbiAqIENyZWF0ZXMgdGhlIGVuZ2luZSBmb3IgcnVubmluZyBpbnRlZ3JhdGlvbiB0ZXN0cy5cbiAqXG4gKiBPbmx5IHRoZSB0b29sa2l0LWxpYiBlbmdpbmUgaXMgc3VwcG9ydGVkLlxuICovXG5leHBvcnQgZnVuY3Rpb24gbWFrZUVuZ2luZShvcHRpb25zOiBFbmdpbmVPcHRpb25zKTogVG9vbGtpdExpYlJ1bm5lckVuZ2luZSB7XG4gIHJldHVybiBuZXcgVG9vbGtpdExpYlJ1bm5lckVuZ2luZSh7XG4gICAgd29ya2luZ0RpcmVjdG9yeTogb3B0aW9ucy50ZXN0LmRpcmVjdG9yeSxcbiAgICBzaG93T3V0cHV0OiBvcHRpb25zLnNob3dPdXRwdXQsXG4gICAgZW52OiBvcHRpb25zLmVudixcbiAgICByZWdpb246IG9wdGlvbnMucmVnaW9uLFxuICAgIHByb2ZpbGU6IG9wdGlvbnMucHJvZmlsZSxcbiAgICBwcm94eTogb3B0aW9ucy5wcm94eSxcbiAgICBjYUJ1bmRsZVBhdGg6IG9wdGlvbnMuY2FCdW5kbGVQYXRoLFxuICB9KTtcbn1cblxuZXhwb3J0IHR5cGUgRW5naW5lT3B0aW9ucyA9IFBpY2s8Q2RrSW50ZWdIZWxwZXJPcHRpb25zLCAndGVzdCcgfCAnc2hvd091dHB1dCcgfCAnZW52JyB8ICdyZWdpb24nIHwgJ3Byb2ZpbGUnIHwgJ3Byb3h5JyB8ICdjYUJ1bmRsZVBhdGgnPjtcbiJdfQ==

package/lib/runner/index.d.ts

@@ -1,4 +1,4 @@
-export * from './runner-base';
+export * from './cdk-integ-helper';
 export * from './integ-test-suite';
 export * from './integ-test-runner';
 export * from './snapshot-test-runner';

package/lib/runner/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC"}