@aws-cdk/integ-runner 2.202.2 → 2.203.0

package/lib/runner/cdk-test-app.js

@@ -0,0 +1,584 @@
+"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_ARGS = exports.DEFAULT_SYNTH_OPTIONS = exports.CdkTestApp = 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 cloud_assembly_schema_1 = require("@aws-cdk/cloud-assembly-schema");
+const fs = __importStar(require("fs-extra"));
+const integ_test_suite_1 = require("./integ-test-suite");
+const logger = __importStar(require("../logger"));
+const recommendedFlagsFile = __importStar(require("../recommended-feature-flags.json"));
+const utils_1 = require("../utils");
+const cloud_assembly_1 = require("./private/cloud-assembly");
+const integ_manifest_1 = require("./private/integ-manifest");
+const test_specific_context_1 = require("./private/test-specific-context");
+const toolkit_lib_1 = require("../engines/toolkit-lib");
+const files_1 = require("../files");
+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 CdkTestApp {
+    options;
+    testSpecificContext;
+    static async forGoldenSnapshot(options) {
+        return CdkTestApp.create({
+            ...options,
+            outputDirectoryNameTemplate: '{testBaseName}.snapshot',
+        });
+    }
+    static async forComparison(options) {
+        return CdkTestApp.create({
+            ...options,
+            outputDirectoryNameTemplate: 'cdk-integ.out.{testBaseName}.snapshot',
+        });
+    }
+    static async forSpecificDirectory(options) {
+        return CdkTestApp.create(options);
+    }
+    static async forDeployment(options) {
+        return CdkTestApp.create({
+            ...options,
+            outputDirectoryNameTemplate: 'cdk-integ.out.deploy.{testBaseName}.snapshot',
+        });
+    }
+    static async create(options) {
+        const ctx = await (0, test_specific_context_1.findTestSpecificContext)(options.test.absoluteFileName);
+        const app = new CdkTestApp(options, ctx);
+        return app;
+    }
+    /**
+     * An instance of the CDK  CLI
+     */
+    cdk;
+    outputDirectory;
+    /**
+     * Default options to pass to the CDK CLI
+     */
+    defaultArgs = {
+        pathMetadata: false,
+        assetMetadata: false,
+        versionReporting: false,
+    };
+    /**
+     * The profile to use for the CDK CLI calls
+     */
+    profile;
+    /**
+     * Show output from the integ test run.
+     */
+    showOutput;
+    test;
+    synthReproCommand = '';
+    _destructiveChanges;
+    legacyContext;
+    _testSuite;
+    _legacyEnableLookups;
+    appCommand;
+    hasValidRegion;
+    constructor(options, testSpecificContext) {
+        this.options = options;
+        this.testSpecificContext = testSpecificContext;
+        this.hasValidRegion = options.region !== cloud_assembly_api_1.UNKNOWN_REGION;
+        this.test = options.test;
+        const outputDirectoryNameTemplate = options.outputDirectoryNameTemplate;
+        this.outputDirectory = (0, files_1.absAwareJoin)(this.test.testDirectory, this.test.specializeTemplate(outputDirectoryNameTemplate));
+        this.profile = options.profile;
+        this.showOutput = options.showOutput ?? false;
+        this.cdk = options.cdk ?? new toolkit_lib_1.ToolkitLibRunnerEngine({
+            workingDirectory: this.test.workingDirectory,
+            showOutput: options.showOutput,
+            env: options.env,
+            region: options.region,
+            profile: options.profile,
+            proxy: options.proxy,
+            caBundlePath: options.caBundlePath,
+        });
+        this.appCommand = this.test.specializeTemplate(this.test.appCommandTemplate);
+    }
+    /**
+     * Configure the legacy enableLookups value to use when generating the actual snapshot.
+     *
+     * Must be set before using snapshot methods.
+     */
+    configureLegacyEnableLookups(enableLookups) {
+        this._legacyEnableLookups = enableLookups;
+    }
+    async hasOutput() {
+        return (await fs.pathExists(this.outputDirectory)) && (await fs.pathExists(path.join(this.outputDirectory, 'manifest.json')));
+    }
+    /**
+     * Return the test cases inside the output
+     */
+    testCases() {
+        return this.testSuite.testSuite;
+    }
+    /**
+     * The test suite from the output
+     */
+    get testSuite() {
+        if (!this._testSuite) {
+            throw new Error('Synthesize first!');
+        }
+        return this._testSuite;
+    }
+    /**
+     * If the snapshot already exists, load it
+     */
+    async loadExistingSuite() {
+        if (this._testSuite) {
+            return this._testSuite;
+        }
+        if (await this.hasOutput()) {
+            this._testSuite = await this._loadManifest();
+            return this._testSuite;
+        }
+        if (this.options.TESTING_forceReadLegacyTestSuite) {
+            return this._loadLegacyTestSuite();
+        }
+        return undefined;
+    }
+    async synthForSnapshotComparison(enableLookupsGuess) {
+        this.configureLegacyEnableLookups(enableLookupsGuess);
+        const suite = await this.synth(this.getContext('snapshot'), exports.DEFAULT_SYNTH_OPTIONS.env);
+        // 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 = suite.enableLookups ?? false;
+        if (actualEnableLookups !== this._legacyEnableLookups && this._legacyEnableLookups !== 'dont-care') {
+            this.configureLegacyEnableLookups(actualEnableLookups);
+            return this.synth(this.getContext('snapshot'), exports.DEFAULT_SYNTH_OPTIONS.env);
+        }
+        return suite;
+    }
+    async synthForGoldenSnapshot(destructiveChanges, enableLookups) {
+        this.configureLegacyEnableLookups(enableLookups);
+        await this.synth(this.getContext('snapshot'), exports.DEFAULT_SYNTH_OPTIONS.env);
+        await this.cleanupGoldenSnapshot(destructiveChanges);
+        return this.testSuite;
+    }
+    async synthForDeployment() {
+        this.configureLegacyEnableLookups('dont-care');
+        await this.synth(this.getContext('deployment'), {});
+        return this.testSuite;
+    }
+    /**
+     * For a given cloud assembly return a collection of all templates
+     * that should be part of the snapshot and any required meta data.
+     *
+     * @param cloudAssemblyDir - The directory of the cloud assembly to look for snapshots
+     * @param pickStacks - Pick only these stacks from the cloud assembly
+     * @returns A SnapshotAssembly, the collection of all templates in this snapshot and required meta data
+     */
+    snapshotAssembly(pickStacks = []) {
+        const assembly = this.readAssembly(this.outputDirectory);
+        const stacks = assembly.stacks;
+        const snapshots = {};
+        for (const [stackName, stackTemplate] of Object.entries(stacks)) {
+            if (pickStacks.includes(stackName)) {
+                const manifest = cloud_assembly_1.AssemblyManifestReader.fromPath(this.outputDirectory);
+                const assets = manifest.getAssetIdsForStack(stackName);
+                snapshots[stackName] = {
+                    templates: {
+                        [stackName]: stackTemplate,
+                        ...assembly.getNestedStacksForStack(stackName),
+                    },
+                    assets,
+                };
+            }
+        }
+        return snapshots;
+    }
+    readAssembly(dir) {
+        return cloud_assembly_1.AssemblyManifestReader.fromPath(dir);
+    }
+    /**
+     * 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 synth(context, env) {
+        const output = this.outputDirectory;
+        // Remove the target directory, so that we don't have stale files from
+        // previous synths. Also, the runner will re-use a directory that already
+        // exists and we want force recreation (unless we are unit testing).
+        if (!this.options.TESTING_usingMocks) {
+            await fs.rm(output, { recursive: true, force: true });
+        }
+        await this.cdk.synth({
+            app: this.appCommand,
+            context,
+            env,
+            output,
+        });
+        this.setReproCommand(context, env);
+        this._testSuite = await this._loadManifest();
+        return this._testSuite;
+    }
+    async deploy(deployArgs) {
+        if (!this.hasValidRegion) {
+            throw new Error('CdkTestApp.deploy: not initialized with a valid region');
+        }
+        return this.cdk.deploy({
+            ...exports.DEFAULT_ARGS,
+            ...deployArgs,
+            output: this.outputDirectory,
+            profile: this.profile,
+            requireApproval: cloud_assembly_schema_1.RequireApproval.NEVER,
+            app: this.appCommand,
+            context: {
+                ...this.getContext('deployment'),
+                ...deployArgs?.context,
+            },
+        });
+    }
+    async destroy(destroyArgs) {
+        if (!this.hasValidRegion) {
+            throw new Error('CdkTestApp.destroy: not initialized with a valid region');
+        }
+        await this.cdk.destroy({
+            ...exports.DEFAULT_ARGS,
+            ...destroyArgs,
+            app: this.appCommand,
+            output: this.outputDirectory,
+            profile: this.profile,
+            force: true,
+            context: {
+                ...this.getContext('deployment'),
+                ...destroyArgs?.context,
+            },
+        });
+    }
+    async watch(watchArgs, watchEvents) {
+        if (!this.hasValidRegion) {
+            throw new Error('CdkTestApp.watch: not initialized with a valid region');
+        }
+        await this.cdk.watch({
+            ...exports.DEFAULT_ARGS,
+            ...watchArgs,
+            output: this.outputDirectory,
+            profile: this.profile,
+            requireApproval: cloud_assembly_schema_1.RequireApproval.NEVER,
+            app: this.appCommand,
+            context: {
+                ...this.getContext('deployment'),
+                ...watchArgs?.context,
+            },
+        }, watchEvents);
+    }
+    setReproCommand(context, env) {
+        // Show the command necessary to repro this
+        const envSet = Object.entries(env).map(([k, v]) => `${k}='${v}'`);
+        const envCmd = envSet.length > 0 ? ['env', ...envSet] : [];
+        this.synthReproCommand = [
+            ...envCmd,
+            'cdk',
+            'synth',
+            '-a',
+            `'${this.appCommand}'`,
+            '-o',
+            `'${this.outputDirectory}'`,
+            ...Object.entries(context).flatMap(([k, v]) => typeof v !== 'object' ? [`-c '${k}=${v}'`] : []),
+        ].join(' ');
+    }
+    /**
+     * 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
+     *
+     * @internal
+     */
+    async _loadManifest() {
+        if (!await this.hasOutput() && !this.options.TESTING_usingMocks) {
+            throw new Error(`Synth did not produce output directory: ${this.outputDirectory}`);
+        }
+        const manifestDir = this.outputDirectory;
+        try {
+            const testSuite = integ_test_suite_1.IntegTestSuite.fromPath(manifestDir);
+            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", manifestDir, modernError.message ?? String(modernError));
+            }
+            return this._loadLegacyTestSuite();
+        }
+    }
+    async _loadLegacyTestSuite() {
+        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.appCommand,
+                profile: this.profile,
+                output: this.outputDirectory,
+            },
+        });
+        this.legacyContext = integ_test_suite_1.LegacyIntegTestSuite.getPragmaContext(this.test.fileName);
+        return testCases;
+    }
+    cleanup() {
+        const cdkOutPath = this.outputDirectory;
+        if (fs.existsSync(cdkOutPath)) {
+            fs.removeSync(cdkOutPath);
+        }
+        // Clear cache
+        this._testSuite = undefined;
+    }
+    /**
+     * If there are any destructive changes to a stack then this will record
+     * those in the manifest.json file
+     */
+    renderTraceData(destructiveChanges) {
+        const traceData = new Map();
+        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 = this.testSuite.getStacksWithoutUpdateWorkflow() ?? [];
+        const manifest = cloud_assembly_1.AssemblyManifestReader.fromPath(this.outputDirectory);
+        const assets = (0, utils_1.flatten)(stacks.map(stack => {
+            return manifest.getAssetLocationsForStack(stack) ?? [];
+        }));
+        assets.forEach(asset => {
+            const fileName = path.join(this.outputDirectory, 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.outputDirectory);
+        files.forEach(file => {
+            const fileName = path.join(this.outputDirectory, file);
+            if (fs.lstatSync(fileName).isDirectory() && file === '.cache') {
+                fs.emptyDirSync(fileName);
+                fs.rmdirSync(fileName);
+            }
+        });
+    }
+    /**
+     * 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(destructiveChanges) {
+        if (!await this.hasOutput()) {
+            // This should not be possible, but a lot of the tests depend on this being a no-op
+            // if no output directory got produced.
+            return;
+        }
+        await this.removeAssetsFromSnapshot();
+        this.removeAssetsCacheFromSnapshot();
+        const assembly = cloud_assembly_1.AssemblyManifestReader.fromPath(this.outputDirectory);
+        assembly.cleanManifest();
+        assembly.recordTrace(this.renderTraceData(destructiveChanges));
+        // 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 = this.testSuite;
+        actualTestSuite.enableLookups = true;
+        if (actualTestSuite instanceof integ_test_suite_1.LegacyIntegTestSuite) {
+            actualTestSuite.saveManifest(this.outputDirectory, this.legacyContext);
+        }
+        else if (actualTestSuite instanceof integ_test_suite_1.IntegTestSuite) {
+            actualTestSuite.saveManifest(this.outputDirectory);
+        }
+    }
+    getContext(forSnapshot) {
+        if (this._legacyEnableLookups === undefined) {
+            throw new Error('Must call configureLegacyEnableLookups before synthing');
+        }
+        // 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.testSpecificContext ?? currentlyRecommendedAwsCdkLibFlags();
+        return {
+            ...featureFlags,
+            ...this.legacyContext,
+            // The _legacyEnableLookups flag is crazy but is only there to not disturb existing snapshots too much.
+            ...(forSnapshot === 'snapshot' && this._legacyEnableLookups !== false ? exports.DEFAULT_SYNTH_OPTIONS.context : {}),
+            // 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.CdkTestApp = CdkTestApp;
+// 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: {
+        // We have traditionally set this, but it's quite a bad idea. It makes region-agnostic stacks undeployable, and there's really no reason for that.
+        // However, if we unset this, we will break many existing snapshots so we keep it for now.
+        [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;
+}
+/**
+ * Default options to pass to the CDK CLI
+ */
+exports.DEFAULT_ARGS = {
+    pathMetadata: false,
+    assetMetadata: false,
+    versionReporting: false,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-test-app.js","sourceRoot":"","sources":["cdk-test-app.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, UNKNOWN_REGION } from '@aws-cdk/cloud-assembly-api';\nimport { type TestCase, type DefaultCdkOptions, RequireApproval } from '@aws-cdk/cloud-assembly-schema';\nimport * as fs from 'fs-extra';\nimport { IntegTestSuite, LegacyIntegTestSuite } from './integ-test-suite';\nimport type { DeployOptions, DestroyOptions, ICdk, WatchEvents } from '../engines/cdk-interface';\nimport * as logger from '../logger';\nimport * as recommendedFlagsFile from '../recommended-feature-flags.json';\nimport { flatten } from '../utils';\nimport type { IntegTest } from './integration-tests';\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 { findTestSpecificContext, type CdkContext } from './private/test-specific-context';\nimport { ToolkitLibRunnerEngine } from '../engines/toolkit-lib';\nimport { absAwareJoin } from '../files';\n\nconst DESTRUCTIVE_CHANGES = '!!DESTRUCTIVE_CHANGES:';\n\n/**\n * Options for creating a CDK Cloud Assembly\n */\nexport interface CdkTestAppOptions {\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   * Where we will write the output of the CDK CLI, including the cloud assembly and the snapshot\n   *\n   * Should be a string containing `{testName}`, will be used to generate a directory name in the same\n   * directory as the test itself.\n   *\n   * @default 'cdk-integ.out.{testName}.snapshot'\n   */\n  readonly outputDirectoryNameTemplate: 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   * In unit test mode, we are using mocks for a lot of calls\n   *\n   * Don't delete directories, and don't do checks whether files actually exist; the\n   * mocks will be there to produce the contents for files that are being read (although\n   * they are not there to pretend to have files themselves).\n   */\n  readonly TESTING_usingMocks?: boolean;\n\n  /**\n   * We will only read the legacy test information if the test actually produced an output directory.\n   *\n   * For historical reasons the tests have been written so that they will expect to read\n   * legacy test information always. Force that behavior back for tests.\n   */\n  readonly TESTING_forceReadLegacyTestSuite?: boolean;\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 CdkTestApp {\n  public static async forGoldenSnapshot(options: Omit<CdkTestAppOptions, 'outputDirectoryNameTemplate'>): Promise<CdkTestApp> {\n    return CdkTestApp.create({\n      ...options,\n      outputDirectoryNameTemplate: '{testBaseName}.snapshot',\n    });\n  }\n\n  public static async forComparison(options: Omit<CdkTestAppOptions, 'outputDirectoryNameTemplate'>): Promise<CdkTestApp> {\n    return CdkTestApp.create({\n      ...options,\n      outputDirectoryNameTemplate: 'cdk-integ.out.{testBaseName}.snapshot',\n    });\n  }\n\n  public static async forSpecificDirectory(options: CdkTestAppOptions): Promise<CdkTestApp> {\n    return CdkTestApp.create(options);\n  }\n\n  public static async forDeployment(options: Omit<CdkTestAppOptions, 'outputDirectoryNameTemplate'>): Promise<CdkTestApp> {\n    return CdkTestApp.create({\n      ...options,\n      outputDirectoryNameTemplate: 'cdk-integ.out.deploy.{testBaseName}.snapshot',\n    });\n  }\n\n  private static async create(options: CdkTestAppOptions): Promise<CdkTestApp> {\n    const ctx = await findTestSpecificContext(options.test.absoluteFileName);\n    const app = new CdkTestApp(options, ctx);\n    return app;\n  }\n\n  /**\n   * An instance of the CDK  CLI\n   */\n  private readonly cdk: ICdk;\n\n  public readonly outputDirectory: string;\n\n  /**\n   * Default options to pass to the CDK CLI\n   */\n  private readonly defaultArgs: DefaultCdkOptions = {\n    pathMetadata: false,\n    assetMetadata: false,\n    versionReporting: false,\n  };\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 readonly test: IntegTest;\n\n  public synthReproCommand: string = '';\n\n  public _destructiveChanges?: DestructiveChange[];\n  private legacyContext?: Record<string, any>;\n  private _testSuite?: IntegTestSuite | LegacyIntegTestSuite;\n  private _legacyEnableLookups?: LegacyEnableLookups;\n\n  public readonly appCommand: string;\n  private hasValidRegion: boolean;\n\n  private constructor(private readonly options: CdkTestAppOptions, private readonly testSpecificContext?: CdkContext) {\n    this.hasValidRegion = options.region !== UNKNOWN_REGION;\n\n    this.test = options.test;\n\n    const outputDirectoryNameTemplate = options.outputDirectoryNameTemplate;\n    this.outputDirectory = absAwareJoin(this.test.testDirectory, this.test.specializeTemplate(outputDirectoryNameTemplate));\n\n    this.profile = options.profile;\n    this.showOutput = options.showOutput ?? false;\n\n    this.cdk = options.cdk ?? new ToolkitLibRunnerEngine({\n      workingDirectory: this.test.workingDirectory,\n      showOutput: options.showOutput,\n      env: options.env,\n      region: options.region,\n      profile: options.profile,\n      proxy: options.proxy,\n      caBundlePath: options.caBundlePath,\n    });\n\n    this.appCommand = this.test.specializeTemplate(this.test.appCommandTemplate);\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  public async hasOutput() {\n    return (await fs.pathExists(this.outputDirectory)) && (await fs.pathExists(path.join(this.outputDirectory, 'manifest.json')));\n  }\n\n  /**\n   * Return the test cases inside the output\n   */\n  public testCases(): { [testName: string]: TestCase } {\n    return this.testSuite.testSuite;\n  }\n\n  /**\n   * The test suite from the output\n   */\n  public get testSuite(): IntegTestSuite | LegacyIntegTestSuite {\n    if (!this._testSuite) {\n      throw new Error('Synthesize first!');\n    }\n\n    return this._testSuite;\n  }\n\n  /**\n   * If the snapshot already exists, load it\n   */\n  public async loadExistingSuite(): Promise<IntegTestSuite | LegacyIntegTestSuite | undefined> {\n    if (this._testSuite) {\n      return this._testSuite;\n    }\n\n    if (await this.hasOutput()) {\n      this._testSuite = await this._loadManifest();\n      return this._testSuite;\n    }\n\n    if (this.options.TESTING_forceReadLegacyTestSuite) {\n      return this._loadLegacyTestSuite();\n    }\n\n    return undefined;\n  }\n\n  public async synthForSnapshotComparison(enableLookupsGuess: LegacyEnableLookups) {\n    this.configureLegacyEnableLookups(enableLookupsGuess);\n    const suite = await this.synth(this.getContext('snapshot'), DEFAULT_SYNTH_OPTIONS.env);\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 = suite.enableLookups ?? false;\n    if (actualEnableLookups !== this._legacyEnableLookups && this._legacyEnableLookups !== 'dont-care') {\n      this.configureLegacyEnableLookups(actualEnableLookups);\n      return this.synth(this.getContext('snapshot'), DEFAULT_SYNTH_OPTIONS.env);\n    }\n    return suite;\n  }\n\n  public async synthForGoldenSnapshot(destructiveChanges: DestructiveChange[], enableLookups: LegacyEnableLookups) {\n    this.configureLegacyEnableLookups(enableLookups);\n    await this.synth(this.getContext('snapshot'), DEFAULT_SYNTH_OPTIONS.env);\n    await this.cleanupGoldenSnapshot(destructiveChanges);\n    return this.testSuite;\n  }\n\n  public async synthForDeployment() {\n    this.configureLegacyEnableLookups('dont-care');\n    await this.synth(this.getContext('deployment'), {});\n    return this.testSuite;\n  }\n\n  /**\n   * For a given cloud assembly return a collection of all templates\n   * that should be part of the snapshot and any required meta data.\n   *\n   * @param cloudAssemblyDir - The directory of the cloud assembly to look for snapshots\n   * @param pickStacks - Pick only these stacks from the cloud assembly\n   * @returns A SnapshotAssembly, the collection of all templates in this snapshot and required meta data\n   */\n  public snapshotAssembly(pickStacks: string[] = []): SnapshotAssembly {\n    const assembly = this.readAssembly(this.outputDirectory);\n    const stacks = assembly.stacks;\n    const snapshots: SnapshotAssembly = {};\n    for (const [stackName, stackTemplate] of Object.entries(stacks)) {\n      if (pickStacks.includes(stackName)) {\n        const manifest = AssemblyManifestReader.fromPath(this.outputDirectory);\n        const assets = manifest.getAssetIdsForStack(stackName);\n\n        snapshots[stackName] = {\n          templates: {\n            [stackName]: stackTemplate,\n            ...assembly.getNestedStacksForStack(stackName),\n          },\n          assets,\n        };\n      }\n    }\n\n    return snapshots;\n  }\n\n  private readAssembly(dir: string): AssemblyManifestReader {\n    return AssemblyManifestReader.fromPath(dir);\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 synth(context: Record<string, any>, env: Record<string, string>): Promise<IntegTestSuite | LegacyIntegTestSuite> {\n    const output = this.outputDirectory;\n\n    // Remove the target directory, so that we don't have stale files from\n    // previous synths. Also, the runner will re-use a directory that already\n    // exists and we want force recreation (unless we are unit testing).\n    if (!this.options.TESTING_usingMocks) {\n      await fs.rm(output, { recursive: true, force: true });\n    }\n\n    await this.cdk.synth({\n      app: this.appCommand,\n      context,\n      env,\n      output,\n    });\n\n    this.setReproCommand(context, env);\n\n    this._testSuite = await this._loadManifest();\n    return this._testSuite;\n  }\n\n  public async deploy(deployArgs: Omit<DeployOptions, 'app' | 'requireApproval' | 'profile' | 'output' | 'lookups'>) {\n    if (!this.hasValidRegion) {\n      throw new Error('CdkTestApp.deploy: not initialized with a valid region');\n    }\n\n    return this.cdk.deploy({\n      ...DEFAULT_ARGS,\n      ...deployArgs,\n      output: this.outputDirectory,\n      profile: this.profile,\n      requireApproval: RequireApproval.NEVER,\n      app: this.appCommand,\n      context: {\n        ...this.getContext('deployment'),\n        ...deployArgs?.context,\n      },\n    });\n  }\n\n  public async destroy(destroyArgs: Omit<DestroyOptions, 'app' | 'force' | 'profile' | 'output'>) {\n    if (!this.hasValidRegion) {\n      throw new Error('CdkTestApp.destroy: not initialized with a valid region');\n    }\n\n    await this.cdk.destroy({\n      ...DEFAULT_ARGS,\n      ...destroyArgs,\n      app: this.appCommand,\n      output: this.outputDirectory,\n      profile: this.profile,\n      force: true,\n      context: {\n        ...this.getContext('deployment'),\n        ...destroyArgs?.context,\n      },\n    });\n  }\n\n  public async watch(watchArgs: Omit<DeployOptions, 'app' | 'requireApproval' | 'profile' | 'output' | 'lookups'>, watchEvents: WatchEvents) {\n    if (!this.hasValidRegion) {\n      throw new Error('CdkTestApp.watch: not initialized with a valid region');\n    }\n\n    await this.cdk.watch({\n      ...DEFAULT_ARGS,\n      ...watchArgs,\n      output: this.outputDirectory,\n      profile: this.profile,\n      requireApproval: RequireApproval.NEVER,\n      app: this.appCommand,\n      context: {\n        ...this.getContext('deployment'),\n        ...watchArgs?.context,\n      },\n    }, watchEvents);\n  }\n\n  private setReproCommand(context: Record<string, any>, env: Record<string, string>) {\n    // Show the command necessary to repro this\n    const envSet = Object.entries(env).map(([k, v]) => `${k}='${v}'`);\n    const envCmd = envSet.length > 0 ? ['env', ...envSet] : [];\n\n    this.synthReproCommand = [\n      ...envCmd,\n      'cdk',\n      'synth',\n      '-a',\n      `'${this.appCommand}'`,\n      '-o',\n      `'${this.outputDirectory}'`,\n      ...Object.entries(context).flatMap(([k, v]) => typeof v !== 'object' ? [`-c '${k}=${v}'`] : []),\n    ].join(' ');\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   * @internal\n   */\n  private async _loadManifest(): Promise<IntegTestSuite | LegacyIntegTestSuite> {\n    if (!await this.hasOutput() && !this.options.TESTING_usingMocks) {\n      throw new Error(`Synth did not produce output directory: ${this.outputDirectory}`);\n    }\n    const manifestDir = this.outputDirectory;\n    try {\n      const testSuite = IntegTestSuite.fromPath(manifestDir);\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          manifestDir,\n          modernError.message ?? String(modernError),\n        );\n      }\n\n      return this._loadLegacyTestSuite();\n    }\n  }\n\n  private async _loadLegacyTestSuite(): Promise<LegacyIntegTestSuite> {\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.appCommand,\n        profile: this.profile,\n        output: this.outputDirectory,\n      },\n    });\n    this.legacyContext = LegacyIntegTestSuite.getPragmaContext(this.test.fileName);\n    return testCases;\n  }\n\n  public cleanup(): void {\n    const cdkOutPath = this.outputDirectory;\n    if (fs.existsSync(cdkOutPath)) {\n      fs.removeSync(cdkOutPath);\n    }\n    // Clear cache\n    this._testSuite = 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(destructiveChanges: DestructiveChange[]): ManifestTrace {\n    const traceData: ManifestTrace = new Map();\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 = this.testSuite.getStacksWithoutUpdateWorkflow() ?? [];\n    const manifest = AssemblyManifestReader.fromPath(this.outputDirectory);\n    const assets = flatten(stacks.map(stack => {\n      return manifest.getAssetLocationsForStack(stack) ?? [];\n    }));\n\n    assets.forEach(asset => {\n      const fileName = path.join(this.outputDirectory, 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.outputDirectory);\n    files.forEach(file => {\n      const fileName = path.join(this.outputDirectory, file);\n      if (fs.lstatSync(fileName).isDirectory() && file === '.cache') {\n        fs.emptyDirSync(fileName);\n        fs.rmdirSync(fileName);\n      }\n    });\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(destructiveChanges: DestructiveChange[]): Promise<void> {\n    if (!await this.hasOutput()) {\n      // This should not be possible, but a lot of the tests depend on this being a no-op\n      // if no output directory got produced.\n      return;\n    }\n\n    await this.removeAssetsFromSnapshot();\n    this.removeAssetsCacheFromSnapshot();\n    const assembly = AssemblyManifestReader.fromPath(this.outputDirectory);\n    assembly.cleanManifest();\n    assembly.recordTrace(this.renderTraceData(destructiveChanges));\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 = this.testSuite;\n    actualTestSuite.enableLookups = true;\n\n    if (actualTestSuite instanceof LegacyIntegTestSuite) {\n      actualTestSuite.saveManifest(this.outputDirectory, this.legacyContext);\n    } else if (actualTestSuite instanceof IntegTestSuite) {\n      actualTestSuite.saveManifest(this.outputDirectory);\n    }\n  }\n\n  public getContext(forSnapshot: 'snapshot' | 'deployment'): Record<string, any> {\n    if (this._legacyEnableLookups === undefined) {\n      throw new Error('Must call configureLegacyEnableLookups before synthing');\n    }\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.testSpecificContext ?? currentlyRecommendedAwsCdkLibFlags();\n\n    return {\n      ...featureFlags,\n      ...this.legacyContext,\n\n      // The _legacyEnableLookups flag is crazy but is only there to not disturb existing snapshots too much.\n      ...(forSnapshot === 'snapshot' && this._legacyEnableLookups !== false ? DEFAULT_SYNTH_OPTIONS.context : {}),\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    // We have traditionally set this, but it's quite a bad idea. It makes region-agnostic stacks undeployable, and there's really no reason for that.\n    // However, if we unset this, we will break many existing snapshots so we keep it for now.\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 SnapshotAssembly {\n  /**\n   * Map of stacks that are part of this assembly\n   */\n  [stackName: string]: {\n    /**\n     * All templates for this stack, including nested stacks\n     */\n    templates: {\n      [templateId: string]: any;\n    };\n\n    /**\n     * List of asset Ids that are used by this assembly\n     */\n    assets: string[];\n  };\n}\n\n/**\n * Default options to pass to the CDK CLI\n */\nexport const DEFAULT_ARGS: DefaultCdkOptions = {\n  pathMetadata: false,\n  assetMetadata: false,\n  versionReporting: false,\n};\n"]}