@aws-cdk/integ-runner
Version:
CDK Integration Testing Tool
331 lines • 47.1 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DEFAULT_SYNTH_OPTIONS = exports.IntegRunner = void 0;
exports.currentlyRecommendedAwsCdkLibFlags = currentlyRecommendedAwsCdkLibFlags;
/* eslint-disable @cdklabs/no-literal-partition */
const path = require("path");
const cx_api_1 = require("@aws-cdk/cx-api");
const fs = require("fs-extra");
const integ_test_suite_1 = require("./integ-test-suite");
const recommendedFlagsFile = require("../recommended-feature-flags.json");
const utils_1 = require("../utils");
const engine_1 = require("./engine");
const logger = require("../logger");
const cloud_assembly_1 = require("./private/cloud-assembly");
const integ_manifest_1 = require("./private/integ-manifest");
const DESTRUCTIVE_CHANGES = '!!DESTRUCTIVE_CHANGES:';
/**
* The different components of a test name
*/
/**
* Represents an Integration test runner
*/
class IntegRunner {
constructor(options) {
/**
* Default options to pass to the CDK CLI
*/
this.defaultArgs = {
pathMetadata: false,
assetMetadata: false,
versionReporting: false,
};
this.test = options.test;
this.directory = this.test.directory;
this.testName = this.test.testName;
this.snapshotDir = 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));
}
/**
* Return the list of expected (i.e. existing) test cases for this integration test
*/
async expectedTests() {
return (await this.expectedTestSuite())?.testSuite;
}
/**
* Return the list of actual (i.e. new) test cases for this integration test
*/
async actualTests() {
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.cdk.synthFast({
execCmd: this.cdkApp.split(' '),
// we don't know the "actual" context yet (this method is what generates it) so just
// use the "expected" context. This is only run in order to read the manifest
context: this.getContext((await this.expectedTestSuite())?.synthContext),
env: exports.DEFAULT_SYNTH_OPTIONS.env,
output: path.relative(this.directory, this.cdkOutDir),
});
const manifest = await this.loadManifest(this.cdkOutDir);
// after we load the manifest remove the tmp snapshot
// so that it doesn't mess up the real snapshot created later
this.cleanup();
return manifest;
}
/**
* Returns true if a snapshot already exists for this test
*/
hasSnapshot() {
return fs.existsSync(this.snapshotDir);
}
/**
* The test suite from the existing snapshot
*/
async expectedTestSuite() {
if (!this._expectedTestSuite && this.hasSnapshot()) {
this._expectedTestSuite = await this.loadManifest();
}
return this._expectedTestSuite;
}
/**
* The test suite from the new "actual" snapshot
*/
async actualTestSuite() {
if (!this._actualTestSuite) {
this._actualTestSuite = await this.generateActualSnapshot();
}
return this._actualTestSuite;
}
/**
* 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) {
const manifest = dir ?? this.snapshotDir;
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);
}
}
/**
* 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.snapshotDir);
const assets = (0, utils_1.flatten)(stacks.map(stack => {
return manifest.getAssetLocationsForStack(stack) ?? [];
}));
assets.forEach(asset => {
const fileName = path.join(this.snapshotDir, 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.snapshotDir);
files.forEach(file => {
const fileName = path.join(this.snapshotDir, 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() {
if (fs.existsSync(this.snapshotDir)) {
fs.removeSync(this.snapshotDir);
}
const actualTestSuite = await this.actualTestSuite();
// if lookups are enabled then we need to synth again
// using dummy context and save that as the snapshot
await this.cdk.synthFast({
execCmd: this.cdkApp.split(' '),
context: this.getContext(actualTestSuite.enableLookups ? exports.DEFAULT_SYNTH_OPTIONS.context : {}),
env: exports.DEFAULT_SYNTH_OPTIONS.env,
output: path.relative(this.directory, this.snapshotDir),
});
await this.cleanupSnapshot();
}
/**
* Perform some cleanup steps after the snapshot is created
* Anytime the snapshot needs to be modified after creation
* the logic should live here.
*/
async cleanupSnapshot() {
if (fs.existsSync(this.snapshotDir)) {
await this.removeAssetsFromSnapshot();
this.removeAssetsCacheFromSnapshot();
const assembly = cloud_assembly_1.AssemblyManifestReader.fromPath(this.snapshotDir);
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.snapshotDir, this.legacyContext);
}
}
getContext(additionalContext) {
return {
...currentlyRecommendedAwsCdkLibFlags(),
...this.legacyContext,
...additionalContext,
// 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.
[cx_api_1.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.IntegRunner = IntegRunner;
// 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: {
[cx_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":"runner-base.js","sourceRoot":"","sources":["runner-base.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @cdklabs/no-literal-partition */\nimport * as path from 'path';\nimport type { ICdk } from '@aws-cdk/cdk-cli-wrapper';\nimport type { TestCase, DefaultCdkOptions } from '@aws-cdk/cloud-assembly-schema';\nimport { AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY, TARGET_PARTITIONS } from '@aws-cdk/cx-api';\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, type EngineOptions } from './engine';\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';\n\nconst DESTRUCTIVE_CHANGES = '!!DESTRUCTIVE_CHANGES:';\n\n/**\n * Options for creating an integration test runner\n */\nexport interface IntegRunnerOptions extends EngineOptions {\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/**\n * The different components of a test name\n */\n/**\n * Represents an Integration test runner\n */\nexport abstract class IntegRunner {\n  /**\n   * The directory where the snapshot will be stored\n   */\n  public readonly snapshotDir: 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  protected readonly cdkApp: string;\n\n  /**\n   * The path where the `cdk.context.json` file\n   * will be created\n   */\n  protected readonly cdkContextPath: string;\n\n  /**\n   * The working directory that the integration tests will be\n   * executed from\n   */\n  protected readonly directory: string;\n\n  /**\n   * The test to run\n   */\n  protected readonly test: IntegTest;\n\n  /**\n   * Default options to pass to the CDK CLI\n   */\n  protected 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  protected readonly cdkOutDir: string;\n\n  /**\n   * The profile to use for the CDK CLI calls\n   */\n  protected readonly profile?: string;\n\n  /**\n   * Show output from the integ test run.\n   */\n  protected readonly showOutput: boolean;\n\n  protected _destructiveChanges?: DestructiveChange[];\n  private legacyContext?: Record<string, any>;\n  private _expectedTestSuite?: IntegTestSuite | LegacyIntegTestSuite;\n  private _actualTestSuite?: IntegTestSuite | LegacyIntegTestSuite;\n\n  constructor(options: IntegRunnerOptions) {\n    this.test = options.test;\n    this.directory = this.test.directory;\n    this.testName = this.test.testName;\n    this.snapshotDir = 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   * Return the list of expected (i.e. existing) test cases for this integration test\n   */\n  public async expectedTests(): Promise<{ [testName: string]: TestCase } | undefined> {\n    return (await this.expectedTestSuite())?.testSuite;\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    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  public async generateActualSnapshot(): Promise<IntegTestSuite | LegacyIntegTestSuite> {\n    await this.cdk.synthFast({\n      execCmd: this.cdkApp.split(' '),\n      // we don't know the \"actual\" context yet (this method is what generates it) so just\n      // use the \"expected\" context. This is only run in order to read the manifest\n      context: this.getContext((await this.expectedTestSuite())?.synthContext),\n      env: DEFAULT_SYNTH_OPTIONS.env,\n      output: path.relative(this.directory, this.cdkOutDir),\n    });\n    const manifest = await this.loadManifest(this.cdkOutDir);\n    // after we load the manifest remove the tmp snapshot\n    // so that it doesn't mess up the real snapshot created later\n    this.cleanup();\n    return manifest;\n  }\n\n  /**\n   * Returns true if a snapshot already exists for this test\n   */\n  public hasSnapshot(): boolean {\n    return fs.existsSync(this.snapshotDir);\n  }\n\n  /**\n   * The test suite from the existing snapshot\n   */\n  protected async expectedTestSuite(): Promise<IntegTestSuite | LegacyIntegTestSuite | undefined> {\n    if (!this._expectedTestSuite && this.hasSnapshot()) {\n      this._expectedTestSuite = await this.loadManifest();\n    }\n    return this._expectedTestSuite;\n  }\n\n  /**\n   * The test suite from the new \"actual\" snapshot\n   */\n  protected async actualTestSuite(): Promise<IntegTestSuite | LegacyIntegTestSuite> {\n    if (!this._actualTestSuite) {\n      this._actualTestSuite = await this.generateActualSnapshot();\n    }\n    return this._actualTestSuite;\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  protected async loadManifest(dir?: string): Promise<IntegTestSuite | LegacyIntegTestSuite> {\n    const manifest = dir ?? this.snapshotDir;\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  protected cleanup(): void {\n    const cdkOutPath = this.cdkOutDir;\n    if (fs.existsSync(cdkOutPath)) {\n      fs.removeSync(cdkOutPath);\n    }\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  protected async removeAssetsFromSnapshot(): Promise<void> {\n    const stacks = (await this.actualTestSuite()).getStacksWithoutUpdateWorkflow() ?? [];\n    const manifest = AssemblyManifestReader.fromPath(this.snapshotDir);\n    const assets = flatten(stacks.map(stack => {\n      return manifest.getAssetLocationsForStack(stack) ?? [];\n    }));\n\n    assets.forEach(asset => {\n      const fileName = path.join(this.snapshotDir, 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  protected removeAssetsCacheFromSnapshot(): void {\n    const files = fs.readdirSync(this.snapshotDir);\n    files.forEach(file => {\n      const fileName = path.join(this.snapshotDir, 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  protected async createSnapshot(): Promise<void> {\n    if (fs.existsSync(this.snapshotDir)) {\n      fs.removeSync(this.snapshotDir);\n    }\n\n    const actualTestSuite = await this.actualTestSuite();\n\n    // if lookups are enabled then we need to synth again\n    // using dummy context and save that as the snapshot\n    await this.cdk.synthFast({\n      execCmd: this.cdkApp.split(' '),\n      context: this.getContext(actualTestSuite.enableLookups ? DEFAULT_SYNTH_OPTIONS.context : {}),\n      env: DEFAULT_SYNTH_OPTIONS.env,\n      output: path.relative(this.directory, this.snapshotDir),\n    });\n\n    await this.cleanupSnapshot();\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 cleanupSnapshot(): Promise<void> {\n    if (fs.existsSync(this.snapshotDir)) {\n      await this.removeAssetsFromSnapshot();\n      this.removeAssetsCacheFromSnapshot();\n      const assembly = AssemblyManifestReader.fromPath(this.snapshotDir);\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.snapshotDir, this.legacyContext);\n    }\n  }\n\n  protected getContext(additionalContext?: Record<string, any>): Record<string, any> {\n    return {\n      ...currentlyRecommendedAwsCdkLibFlags(),\n      ...this.legacyContext,\n      ...additionalContext,\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      [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"]}