@aws-cdk/integ-runner 2.202.2 → 2.202.3

package/lib/runner/integ-test-runner.js

@@ -40,9 +40,9 @@ const chokidar = __importStar(require("chokidar"));
 const handler_js_1 = require("chokidar/handler.js");
 const fs = __importStar(require("fs-extra"));
 const workerpool = __importStar(require("workerpool"));
-const cdk_integ_helper_1 = require("./cdk-integ-helper");
 const logger = __importStar(require("../logger"));
 const utils_1 = require("../utils");
+const cdk_test_app_1 = require("./cdk-test-app");
 const common_1 = require("../workers/common");
 /**
  * File events that we care about from chokidar.
@@ -61,59 +61,123 @@ function isFileEvent(event) {
  * integration tests
  */
 class IntegTestRunner {
-    helper;
-    constructor(options, destructiveChanges) {
-        this.helper = cdk_integ_helper_1.CdkIntegHelper.create(options);
-        this.helper._destructiveChanges = destructiveChanges;
-        // We need to have given this a value, but we don't actually care about it initially,
-        // because we only synth to get the test definition.
-        // FIXME: This is unfortunate -- in order to start running the test "for real" we
-        // already have created a real snapshot with the real test definition, but we've thrown
-        // that away already. So we need to synth again just to get the test definition, AGAIN.
-        //
-        // We will rewrite this later when it comes time to generate the actual
-        // golden snapshot, to match the requested value in the test definition.
-        this.helper.configureLegacyEnableLookups('dont-care');
+    appOptions;
+    destructiveChanges;
+    test;
+    constructor(appOptions, destructiveChanges) {
+        this.appOptions = appOptions;
+        this.destructiveChanges = destructiveChanges;
+        this.test = appOptions.test;
     }
     /**
-     * Compatibility shim with old API
-     */
-    get testName() {
-        return this.helper.testName;
-    }
-    /**
-     * Compatibility shim with old API
+     * Orchestrates running integration tests. Currently this includes
+     *
+     * 1. (if update workflow is enabled) Deploying the snapshot test stacks
+     * 2. Deploying the integration test stacks
+     * 2. Saving the snapshot (if successful)
+     * 3. Destroying the integration test stacks (if clean=false)
+     *
+     * The update workflow exists to check for cases where a change would cause
+     * a failure to an existing stack, but not for a newly created stack.
      */
-    async actualTestSuite() {
-        return (await this.helper.actualSnapshot()).testDefinition;
-    }
-    async actualTests() {
-        const actualTestSuite = await this.actualTestSuite();
-        // We don't want new tests written in the legacy mode.
-        // If there is no existing snapshot _and_ this is a legacy
-        // test then point the user to the new `IntegTest` construct
-        if (!this.helper.hasSnapshot() && actualTestSuite.type === 'legacy-test-suite') {
-            throw new Error(`${this.helper.testName} is a new test. Please use the IntegTest construct ` +
+    async runIntegTestCase(runOptions) {
+        let assertionResults;
+        // Set up actual
+        let actual = await cdk_test_app_1.CdkTestApp.forDeployment(this.appOptions);
+        if (this.appOptions.TESTING_useComparisonOutputDirectory) {
+            actual = await cdk_test_app_1.CdkTestApp.forComparison(this.appOptions);
+        }
+        const previousVersion = await cdk_test_app_1.CdkTestApp.forGoldenSnapshot(this.appOptions);
+        const actualTestSuite = await actual.synthForDeployment();
+        if (actualTestSuite.type === 'legacy-test-suite' && !previousVersion.hasOutput()) {
+            throw new Error(`${this.test.testName} is a new test. Please use the IntegTest construct ` +
                 'to configure the test\n' +
                 'https://github.com/aws/aws-cdk/tree/main/packages/%40aws-cdk/integ-tests-alpha');
         }
-        return actualTestSuite.testSuite;
+        const clean = runOptions.clean ?? true;
+        try {
+            for (const [testCaseName, actualTestCase] of Object.entries(actualTestSuite.testSuite)) {
+                const updateWorkflowEnabled = (runOptions.updateWorkflow ?? false)
+                    && (actualTestCase.stackUpdateWorkflow ?? false);
+                const allowDeleteFailures = actualTestCase.allowDeleteFailures ?? runOptions.allowDeleteFailures ?? false;
+                const verbosity = analyzeVerbosity(runOptions.verbosity);
+                if (!runOptions.dryRun && (actualTestCase.cdkCommandOptions?.deploy?.enabled ?? true)) {
+                    try {
+                        assertionResults = await this.deployTestAndAssertions(actual, previousVersion, actualTestCase, {
+                            roleArn: runOptions.roleArn ?? actualTestCase.cdkCommandOptions?.deploy?.args?.roleArn,
+                            verbose: verbosity.verbose,
+                            debug: verbosity.debug,
+                        }, updateWorkflowEnabled, testCaseName, allowDeleteFailures, runOptions.updateFromTags);
+                    }
+                    finally {
+                        if (!runOptions.dryRun && clean && (actualTestCase.cdkCommandOptions?.destroy?.enabled ?? true)) {
+                            await this.destroyTestAndAssertions(actual, actualTestCase, {
+                                ...actualTestCase.cdkCommandOptions?.destroy?.args,
+                                roleArn: runOptions.roleArn ?? actualTestCase.cdkCommandOptions?.destroy?.args?.roleArn,
+                                verbose: verbosity.verbose,
+                                debug: verbosity.debug,
+                            });
+                        }
+                    }
+                }
+            }
+            // only create the snapshot if there are no failed assertion results
+            // (i.e. no failures)
+            if (!Object.values(assertionResults ?? {}).some(result => result.status === 'fail')) {
+                await this.createSnapshot(actualTestSuite.enableLookups);
+            }
+        }
+        finally {
+            actual.cleanup();
+        }
+        return assertionResults;
+    }
+    async createSnapshot(enableLookups) {
+        const expected = await cdk_test_app_1.CdkTestApp.forGoldenSnapshot(this.appOptions);
+        await expected.synthForGoldenSnapshot(this.destructiveChanges ?? [], enableLookups);
     }
-    createCdkContextJson() {
-        if (!fs.existsSync(this.helper.cdkContextPath)) {
-            fs.writeFileSync(this.helper.cdkContextPath, JSON.stringify({
-                watch: {},
-            }, undefined, 2));
+    /**
+     * Runs cdk deploy --watch for an integration test
+     *
+     * This is meant to be run on a single test and will not create a snapshot
+     */
+    async watchIntegTest(options) {
+        // Set up actual
+        const actual = await cdk_test_app_1.CdkTestApp.forDeployment(this.appOptions);
+        await actual.synthForDeployment();
+        // Just take the first test case, that's the one we watch.
+        // Not even sure how better behavior here is possible, but watch isn't used that often.
+        const firstTestCaseName = Object.keys(actual.testCases())[0];
+        const verbosity = analyzeVerbosity(options.verbosity);
+        try {
+            await this.watch(actual, firstTestCaseName, {
+                ...cdk_test_app_1.DEFAULT_ARGS,
+                deploymentMethod: {
+                    method: 'hotswap',
+                    fallback: {
+                        method: 'change-set',
+                    },
+                },
+                profile: this.appOptions.profile,
+                requireApproval: cloud_assembly_schema_1.RequireApproval.NEVER,
+                traceLogs: verbosity.traceLogs ?? false,
+                verbose: verbosity.verbose,
+                debug: verbosity.debug,
+                roleArn: options.roleArn,
+            }, options.verbosity ?? 0);
+        }
+        catch (e) {
+            throw e;
         }
     }
     /**
      * Checkout the snapshot directory at a specific git ref (tag, commit, branch).
      * Fails fast if the snapshot does not exist at the given ref.
      */
-    checkoutSnapshotAtRef(ref) {
-        const gitCwd = path.dirname(this.helper.goldenSnapshotDir);
+    checkoutSnapshotAtRef(snapshotApp, ref) {
+        const gitCwd = path.dirname(snapshotApp.outputDirectory);
         const git = ['git', '-C', gitCwd];
-        const relativeSnapshotDir = path.relative(gitCwd, this.helper.goldenSnapshotDir);
+        const relativeSnapshotDir = path.relative(gitCwd, snapshotApp.outputDirectory);
         try {
             (0, utils_1.exec)([...git, 'checkout', ref, '--', relativeSnapshotDir]);
         }
@@ -127,24 +191,22 @@ class IntegTestRunner {
      * Deploy the snapshot from each git tag in sequence, then let the caller
      * deploy the current code as the final update.
      */
-    async deployFromTags(deployArgs, testCaseName, tags, allowDeleteFailures) {
+    async deployFromTags(actualApp, deployArgs, testCaseName, tags, allowDeleteFailures) {
         const totalTags = tags.length;
         for (let i = 0; i < totalTags; i++) {
             const tag = tags[i];
-            logger.highlight(`${this.helper.testName}/${testCaseName}: deploying tag ${tag} (${i + 1}/${totalTags})`);
-            this.checkoutSnapshotAtRef(tag);
-            const expectedTestSuite = await this.helper.expectedTestSuite();
+            logger.highlight(`${this.test.testName}/${testCaseName}: deploying tag ${tag} (${i + 1}/${totalTags})`);
+            this.checkoutSnapshotAtRef(actualApp, tag);
+            const expectedTestSuite = actualApp.testSuite;
             if (!expectedTestSuite || !(testCaseName in expectedTestSuite.testSuite)) {
                 throw new Error(`Test case '${testCaseName}' does not exist in snapshot at tag '${tag}'`);
             }
             const expectedTestCase = expectedTestSuite.testSuite[testCaseName];
-            const deployResult = await this.helper.cdk.deploy({
+            const deployResult = await actualApp.deploy({
                 ...deployArgs,
                 stacks: expectedTestCase.stacks,
                 ...expectedTestCase?.cdkCommandOptions?.deploy?.args,
-                context: this.helper.getContext(expectedTestCase?.cdkCommandOptions?.deploy?.args?.context),
-                app: path.relative(this.helper.directory, this.helper.goldenSnapshotDir),
-                lookups: expectedTestSuite?.enableLookups,
+                context: expectedTestCase?.cdkCommandOptions?.deploy?.args?.context,
             });
             if (deployResult.deleteFailures.length > 0) {
                 const details = deployResult.deleteFailures
@@ -159,7 +221,7 @@ class IntegTestRunner {
                 }
             }
         }
-        logger.highlight(`${this.helper.testName}/${testCaseName}: deploying current branch (final)`);
+        logger.highlight(`${actualApp.test.testName}/${testCaseName}: deploying current branch (final)`);
     }
     /**
      * When running integration tests with the update path workflow
@@ -172,13 +234,13 @@ class IntegTestRunner {
      * This assumes that there is an 'origin'. `git remote show origin` returns a list of
      * all branches and we then search for one that starts with `HEAD branch: `
      */
-    checkoutSnapshot() {
+    checkoutSnapshot(actualApp) {
         // We use the directory that contains the snapshot to run git commands in
         // We don't change the cwd for executing git, but instead use the -C flag
         // @see https://git-scm.com/docs/git#Documentation/git.txt--Cltpathgt
         // This way we are guaranteed to operate under the correct git repo, even
         // when executing integ-runner from outside the repo under test.
-        const gitCwd = path.dirname(this.helper.goldenSnapshotDir);
+        const gitCwd = path.dirname(actualApp.outputDirectory);
         const git = ['git', '-C', gitCwd];
         // https://git-scm.com/docs/git-merge-base
         let baseBranch = undefined;
@@ -193,156 +255,47 @@ class IntegTestRunner {
             }
         }
         catch (e) {
-            logger.warning('%s\n%s', 'Could not determine git origin branch.', `You need to manually checkout the snapshot directory ${this.helper.goldenSnapshotDir}` +
+            logger.warning('%s\n%s', 'Could not determine git origin branch.', `You need to manually checkout the snapshot directory ${actualApp.outputDirectory}` +
                 'from the merge-base (https://git-scm.com/docs/git-merge-base)');
             logger.warning('error: %s', (0, common_1.formatError)(e));
         }
         // if we found the base branch then get the merge-base (most recent common commit)
         // and checkout the snapshot using that commit
         if (baseBranch) {
-            const relativeSnapshotDir = path.relative(gitCwd, this.helper.goldenSnapshotDir);
+            const relativeSnapshotDir = path.relative(gitCwd, actualApp.outputDirectory);
             const checkoutCommand = [...git, 'checkout', [...git, 'merge-base', 'HEAD', baseBranch], '--', relativeSnapshotDir];
             try {
                 (0, utils_1.execWithSubShell)(checkoutCommand);
             }
             catch (e) {
-                logger.warning('%s\n%s', `Could not checkout snapshot directory '${this.helper.goldenSnapshotDir}'. Please verify the following command completes correctly:`, (0, utils_1.renderCommand)(checkoutCommand), '');
+                logger.warning('%s\n%s', `Could not checkout snapshot directory '${actualApp.outputDirectory}'. Please verify the following command completes correctly:`, (0, utils_1.renderCommand)(checkoutCommand), '');
                 logger.warning('error: %s', (0, common_1.formatError)(e));
             }
         }
     }
-    /**
-     * Runs cdk deploy --watch for an integration test
-     *
-     * This is meant to be run on a single test and will not create a snapshot
-     */
-    async watchIntegTest(options) {
-        const actualTestSuite = await this.actualTestSuite();
-        const actualTestCase = actualTestSuite.testSuite[options.testCaseName];
-        if (!actualTestCase) {
-            throw new Error(`Did not find test case name '${options.testCaseName}' in '${Object.keys(actualTestSuite.testSuite)}'`);
-        }
-        const enableForVerbosityLevel = (needed = 1) => {
-            const verbosity = options.verbosity ?? 0;
-            return (verbosity >= needed) ? true : undefined;
-        };
-        try {
-            await this.watch({
-                ...this.helper.defaultArgs,
-                deploymentMethod: {
-                    method: 'hotswap',
-                    fallback: {
-                        method: 'change-set',
-                    },
-                },
-                profile: this.helper.profile,
-                requireApproval: cloud_assembly_schema_1.RequireApproval.NEVER,
-                traceLogs: enableForVerbosityLevel(2) ?? false,
-                verbose: enableForVerbosityLevel(3),
-                debug: enableForVerbosityLevel(4),
-                roleArn: options.roleArn,
-            }, options.testCaseName, options.verbosity ?? 0);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    /**
-     * Orchestrates running integration tests. Currently this includes
-     *
-     * 1. (if update workflow is enabled) Deploying the snapshot test stacks
-     * 2. Deploying the integration test stacks
-     * 2. Saving the snapshot (if successful)
-     * 3. Destroying the integration test stacks (if clean=false)
-     *
-     * The update workflow exists to check for cases where a change would cause
-     * a failure to an existing stack, but not for a newly created stack.
-     */
-    async runIntegTestCase(options) {
-        let assertionResults;
-        const actualTestSuite = await this.actualTestSuite();
-        const actualTestCase = actualTestSuite.testSuite[options.testCaseName];
-        if (!actualTestCase) {
-            throw new Error(`Did not find test case name '${options.testCaseName}' in '${Object.keys(actualTestSuite.testSuite)}'`);
-        }
-        // Ideally we would force `enableLookups` to `true`, always, because that's what we would like to converge on for the snapshots.
-        //
-        // HOWEVER!
-        //
-        // In order to do that, to validate the snapshot correctly we need to match what's in `integ.json`. In order to ratchet
-        // that value to `true`, we would need to rewrite `integ.json` to have `enableLookups: true`. We don't currently
-        // have code to reliably rewrite that file, so we just leave the value at whatever the test requested.
-        this.helper.configureLegacyEnableLookups(actualTestSuite.enableLookups ?? false);
-        const clean = options.clean ?? true;
-        const updateWorkflowEnabled = (options.updateWorkflow ?? true)
-            && (actualTestCase.stackUpdateWorkflow ?? true);
-        const allowDeleteFailures = actualTestCase.allowDeleteFailures ?? options.allowDeleteFailures ?? false;
-        const enableForVerbosityLevel = (needed = 1) => {
-            const verbosity = options.verbosity ?? 0;
-            return (verbosity >= needed) ? true : undefined;
-        };
-        try {
-            if (!options.dryRun && (actualTestCase.cdkCommandOptions?.deploy?.enabled ?? true)) {
-                assertionResults = await this.deploy({
-                    ...this.helper.defaultArgs,
-                    profile: this.helper.profile,
-                    requireApproval: cloud_assembly_schema_1.RequireApproval.NEVER,
-                    verbose: enableForVerbosityLevel(3),
-                    debug: enableForVerbosityLevel(4),
-                    roleArn: options.roleArn,
-                }, updateWorkflowEnabled, options.testCaseName, allowDeleteFailures, options.updateFromTags);
-            }
-            // only create the snapshot if there are no failed assertion results
-            // (i.e. no failures)
-            if (!Object.values(assertionResults ?? {}).some(result => result.status === 'fail')) {
-                await this.helper.createSnapshot();
-            }
-        }
-        catch (e) {
-            throw e;
-        }
-        finally {
-            if (!options.dryRun) {
-                if (clean && (actualTestCase.cdkCommandOptions?.destroy?.enabled ?? true)) {
-                    await this.destroy(options.testCaseName, {
-                        ...this.helper.defaultArgs,
-                        profile: this.helper.profile,
-                        all: true,
-                        force: true,
-                        app: this.helper.cdkApp,
-                        output: path.relative(this.helper.directory, this.helper.temporarySnapshotDir),
-                        ...actualTestCase.cdkCommandOptions?.destroy?.args,
-                        context: this.helper.getContext(actualTestCase.cdkCommandOptions?.destroy?.args?.context),
-                        roleArn: options.roleArn ?? actualTestCase.cdkCommandOptions?.destroy?.args?.roleArn,
-                        verbose: enableForVerbosityLevel(3),
-                        debug: enableForVerbosityLevel(4),
-                    });
-                }
-            }
-            this.helper.cleanup();
-        }
-        return assertionResults;
-    }
     /**
      * Perform a integ test case stack destruction
      */
-    async destroy(testCaseName, destroyArgs) {
-        const actualTestCase = (await this.actualTestSuite()).testSuite[testCaseName];
+    async destroyTestAndAssertions(actualApp, actualTestCase, destroyArgs) {
         try {
             if (actualTestCase.hooks?.preDestroy) {
                 actualTestCase.hooks.preDestroy.forEach(cmd => {
                     (0, utils_1.exec)((0, utils_1.chunks)(cmd), {
-                        cwd: path.dirname(this.helper.goldenSnapshotDir),
+                        cwd: path.dirname(actualApp.outputDirectory),
                     });
                 });
             }
-            await this.helper.cdk.destroy({
+            await actualApp.destroy({
+                stacks: [
+                    ...actualTestCase.stacks,
+                    ...(actualTestCase.assertionStack ? [actualTestCase.assertionStack] : []),
+                ],
                 ...destroyArgs,
             });
             if (actualTestCase.hooks?.postDestroy) {
                 actualTestCase.hooks.postDestroy.forEach(cmd => {
                     (0, utils_1.exec)((0, utils_1.chunks)(cmd), {
-                        cwd: path.dirname(this.helper.goldenSnapshotDir),
+                        cwd: path.dirname(actualApp.outputDirectory),
                     });
                 });
             }
@@ -351,13 +304,13 @@ class IntegTestRunner {
             this.parseError(e, actualTestCase.cdkCommandOptions?.destroy?.expectError ?? false, actualTestCase.cdkCommandOptions?.destroy?.expectedMessage);
         }
     }
-    async watch(options, testCaseName, verbosity) {
-        const actualTestSuite = await this.actualTestSuite();
-        const actualTestCase = actualTestSuite.testSuite[testCaseName];
+    async watch(actualApp, testCaseName, options, verbosity) {
+        const actualTestSuite = actualApp.testSuite;
+        const actualTestCase = actualApp.testCases()[testCaseName];
         if (actualTestCase.hooks?.preDeploy) {
             actualTestCase.hooks.preDeploy.forEach(cmd => {
                 (0, utils_1.exec)((0, utils_1.chunks)(cmd), {
-                    cwd: path.dirname(this.helper.goldenSnapshotDir),
+                    cwd: path.dirname(actualApp.outputDirectory),
                 });
             });
         }
@@ -368,13 +321,10 @@ class IntegTestRunner {
                 ...actualTestCase.stacks,
                 ...actualTestCase.assertionStack ? [actualTestCase.assertionStack] : [],
             ],
-            output: path.relative(this.helper.directory, this.helper.temporarySnapshotDir),
-            outputsFile: path.relative(this.helper.directory, path.join(this.helper.temporarySnapshotDir, 'assertion-results.json')),
+            output: actualApp.outputDirectory,
+            outputsFile: path.join(actualApp.outputDirectory, 'assertion-results.json'),
             ...actualTestCase?.cdkCommandOptions?.deploy?.args,
-            context: {
-                ...this.helper.getContext(actualTestCase?.cdkCommandOptions?.deploy?.args?.context),
-            },
-            app: this.helper.cdkApp,
+            context: actualTestCase?.cdkCommandOptions?.deploy?.args?.context,
         };
         const destroyMessage = {
             additionalMessages: [
@@ -382,7 +332,7 @@ class IntegTestRunner {
                 `  ${[
                     ...process.env.AWS_REGION ? [`AWS_REGION=${process.env.AWS_REGION}`] : [],
                     'cdk destroy',
-                    `-a '${this.helper.cdkApp}'`,
+                    `-a '${actualApp.appCommand}'`,
                     watchArgs.stacks.join(' '),
                     `--profile ${watchArgs.profile}`,
                 ].join(' ')}`,
@@ -395,22 +345,13 @@ class IntegTestRunner {
             workerpool.workerEmit({
                 additionalMessages: [
                     'Repro:',
-                    `  ${[
-                        'cdk synth',
-                        `-a '${this.helper.cdkApp}'`,
-                        `-o '${this.helper.temporarySnapshotDir}'`,
-                        ...Object.entries(this.helper.getContext()).flatMap(([k, v]) => typeof v !== 'object' ? [`-c '${k}=${v}'`] : []),
-                        watchArgs.stacks.join(' '),
-                        `--outputs-file ${watchArgs.outputsFile}`,
-                        `--profile ${watchArgs.profile}`,
-                        '--hotswap-fallback',
-                    ].join(' ')}`,
+                    `  ${actualApp.synthReproCommand}`,
                 ],
             });
         }
-        const assertionResults = path.join(this.helper.temporarySnapshotDir, 'assertion-results.json');
-        const watcher = chokidar.watch([this.helper.temporarySnapshotDir], {
-            cwd: this.helper.directory,
+        const assertionResults = path.join(actualApp.outputDirectory, 'assertion-results.json');
+        const watcher = chokidar.watch([actualApp.outputDirectory], {
+            cwd: actualApp.outputDirectory,
         });
         watcher.on('all', (event, file) => {
             if (!isFileEvent(event)) {
@@ -423,7 +364,7 @@ class IntegTestRunner {
                 if (actualTestCase.hooks?.postDeploy) {
                     actualTestCase.hooks.postDeploy.forEach(cmd => {
                         (0, utils_1.exec)((0, utils_1.chunks)(cmd), {
-                            cwd: path.dirname(this.helper.goldenSnapshotDir),
+                            cwd: path.dirname(actualApp.outputDirectory),
                         });
                     });
                 }
@@ -457,7 +398,7 @@ class IntegTestRunner {
             });
         });
         const { promise: waiter, resolve } = (0, utils_1.promiseWithResolvers)();
-        await this.helper.cdk.watch(watchArgs, {
+        await actualApp.watch(watchArgs, {
             // if `-v` (or above) is passed then stream the logs
             onStdout: (message) => {
                 if (verbosity > 0) {
@@ -484,48 +425,40 @@ class IntegTestRunner {
      * Perform a integ test case deployment, including
      * performing the update workflow
      */
-    async deploy(deployArgs, updateWorkflowEnabled, testCaseName, allowDeleteFailures, updateFromTags) {
-        const actualTestCase = (await this.actualTestSuite()).testSuite[testCaseName];
+    async deployTestAndAssertions(app, previousVersion, testCase, deployArgs, updateWorkflowEnabled, testCaseName, allowDeleteFailures, updateFromTags) {
         try {
-            if (actualTestCase.hooks?.preDeploy) {
-                actualTestCase.hooks.preDeploy.forEach(cmd => {
+            if (testCase.hooks?.preDeploy) {
+                testCase.hooks.preDeploy.forEach(cmd => {
                     (0, utils_1.exec)((0, utils_1.chunks)(cmd), {
-                        cwd: path.dirname(this.helper.goldenSnapshotDir),
+                        cwd: path.dirname(app.outputDirectory),
                     });
                 });
             }
             if (updateFromTags && updateFromTags.length > 0) {
                 // Tag-sequence update workflow: deploy each tag's snapshot in order
-                await this.deployFromTags(deployArgs, testCaseName, updateFromTags, allowDeleteFailures);
+                await this.deployFromTags(app, deployArgs, testCaseName, updateFromTags, allowDeleteFailures);
             }
-            else if (updateWorkflowEnabled && this.helper.hasSnapshot()) {
+            else if (updateWorkflowEnabled && await previousVersion.hasOutput()) {
                 // Normal merge-base update workflow
-                const expectedTestSuite = await this.helper.expectedTestSuite();
+                const expectedTestSuite = await previousVersion.loadExistingSuite();
                 if (expectedTestSuite && testCaseName in expectedTestSuite?.testSuite) {
-                    this.checkoutSnapshot();
+                    this.checkoutSnapshot(previousVersion);
                     const expectedTestCase = expectedTestSuite.testSuite[testCaseName];
-                    await this.helper.cdk.deploy({
+                    await previousVersion.deploy({
                         ...deployArgs,
                         stacks: expectedTestCase.stacks,
                         ...expectedTestCase?.cdkCommandOptions?.deploy?.args,
-                        context: this.helper.getContext(expectedTestCase?.cdkCommandOptions?.deploy?.args?.context),
-                        app: path.relative(this.helper.directory, this.helper.goldenSnapshotDir),
-                        lookups: expectedTestSuite?.enableLookups,
+                        context: expectedTestCase?.cdkCommandOptions?.deploy?.args?.context,
                     });
                 }
             }
             // now deploy the "actual" test.
             // This is the stack update if the update workflow ran above.
-            const actualDeployResult = await this.helper.cdk.deploy({
+            const actualDeployResult = await app.deploy({
                 ...deployArgs,
-                lookups: (await this.actualTestSuite()).enableLookups,
-                stacks: [
-                    ...actualTestCase.stacks,
-                ],
-                output: path.relative(this.helper.directory, this.helper.temporarySnapshotDir),
-                ...actualTestCase?.cdkCommandOptions?.deploy?.args,
-                context: this.helper.getContext(actualTestCase?.cdkCommandOptions?.deploy?.args?.context),
-                app: this.helper.cdkApp,
+                stacks: testCase.stacks,
+                ...testCase?.cdkCommandOptions?.deploy?.args,
+                context: testCase?.cdkCommandOptions?.deploy?.args?.context,
             });
             if (actualDeployResult.deleteFailures.length > 0) {
                 const details = actualDeployResult.deleteFailures
@@ -546,34 +479,31 @@ class IntegTestRunner {
             // set `rollback: false`. This allows the assertion stack to deploy all the
             // assertions instead of failing at the first failed assertion
             // combining it with the above deployment would prevent any replacement updates
-            if (actualTestCase.assertionStack) {
-                await this.helper.cdk.deploy({
+            if (testCase.assertionStack) {
+                await app.deploy({
                     ...deployArgs,
-                    lookups: (await this.actualTestSuite()).enableLookups,
                     stacks: [
-                        actualTestCase.assertionStack,
+                        testCase.assertionStack,
                     ],
                     rollback: false,
-                    output: path.relative(this.helper.directory, this.helper.temporarySnapshotDir),
-                    ...actualTestCase?.cdkCommandOptions?.deploy?.args,
-                    outputsFile: path.relative(this.helper.directory, path.join(this.helper.temporarySnapshotDir, 'assertion-results.json')),
-                    context: this.helper.getContext(actualTestCase?.cdkCommandOptions?.deploy?.args?.context),
-                    app: this.helper.cdkApp,
+                    ...testCase?.cdkCommandOptions?.deploy?.args,
+                    outputsFile: path.join(app.outputDirectory, 'assertion-results.json'),
+                    context: testCase?.cdkCommandOptions?.deploy?.args?.context,
                 });
             }
-            if (actualTestCase.hooks?.postDeploy) {
-                actualTestCase.hooks.postDeploy.forEach(cmd => {
+            if (testCase.hooks?.postDeploy) {
+                testCase.hooks.postDeploy.forEach(cmd => {
                     (0, utils_1.exec)((0, utils_1.chunks)(cmd), {
-                        cwd: path.dirname(this.helper.goldenSnapshotDir),
+                        cwd: path.dirname(app.outputDirectory),
                     });
                 });
             }
-            if (actualTestCase.assertionStack && actualTestCase.assertionStackName) {
-                return this.processAssertionResults(path.join(this.helper.temporarySnapshotDir, 'assertion-results.json'), actualTestCase.assertionStackName, actualTestCase.assertionStack);
+            if (testCase.assertionStack && testCase.assertionStackName) {
+                return this.processAssertionResults(path.join(app.outputDirectory, 'assertion-results.json'), testCase.assertionStackName, testCase.assertionStack);
             }
         }
         catch (e) {
-            this.parseError(e, actualTestCase.cdkCommandOptions?.deploy?.expectError ?? false, actualTestCase.cdkCommandOptions?.deploy?.expectedMessage);
+            this.parseError(e, testCase.cdkCommandOptions?.deploy?.expectError ?? false, testCase.cdkCommandOptions?.deploy?.expectedMessage);
         }
         return;
     }
@@ -632,4 +562,11 @@ class IntegTestRunner {
     }
 }
 exports.IntegTestRunner = IntegTestRunner;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"integ-test-runner.js","sourceRoot":"","sources":["integ-test-runner.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport type { DestroyOptions, TestCase } from '@aws-cdk/cloud-assembly-schema';\nimport { RequireApproval } from '@aws-cdk/cloud-assembly-schema';\nimport * as chokidar from 'chokidar';\nimport { type EventName, EVENTS } from 'chokidar/handler.js';\nimport * as fs from 'fs-extra';\nimport * as workerpool from 'workerpool';\nimport type { CdkIntegHelperOptions } from './cdk-integ-helper';\nimport { CdkIntegHelper } from './cdk-integ-helper';\nimport type * as cdk from '../engines/cdk-interface';\nimport * as logger from '../logger';\nimport { chunks, exec, execWithSubShell, promiseWithResolvers, renderCommand } from '../utils';\nimport type { DestructiveChange, AssertionResults, AssertionResult } from '../workers/common';\nimport { DiagnosticReason, formatAssertionResults, formatError } from '../workers/common';\n\n/**\n * File events that we care about from chokidar.\n * In chokidar v4, EventName includes additional events like 'error', 'raw', 'ready', 'all'\n * that we need to filter out in the 'all' handler.\n */\nconst FILE_EVENTS = [EVENTS.ADD, EVENTS.CHANGE] as const;\ntype FileEvent = typeof FILE_EVENTS[number];\n\n/**\n * Type guard to check if an event is a file event we should process.\n */\nfunction isFileEvent(event: EventName): event is FileEvent {\n  return (FILE_EVENTS as readonly string[]).includes(event);\n}\n\nexport interface CommonOptions {\n  /**\n   * The name of the test case\n   */\n  readonly testCaseName: string;\n\n  /**\n   * The level of verbosity for logging.\n   *\n   * @default 0\n   */\n  readonly verbosity?: number;\n}\n\nexport interface WatchOptions extends CommonOptions {\n  /**\n   * ARN of the IAM role for CloudFormation to assume during deploy/destroy\n   *\n   * @default - use the bootstrap cfn-exec role\n   */\n  readonly roleArn?: string;\n}\n\n/**\n * Options for the integration test runner\n */\nexport interface RunOptions extends CommonOptions {\n  /**\n   * Whether or not to run `cdk destroy` and cleanup the\n   * integration test stacks.\n   *\n   * Set this to false if you need to perform any validation\n   * or troubleshooting after deployment.\n   *\n   * @default true\n   */\n  readonly clean?: boolean;\n\n  /**\n   * If set to true, the integration test will not deploy\n   * anything and will simply update the snapshot.\n   *\n   * You should NOT use this method since you are essentially\n   * bypassing the integration test.\n   *\n   * @default false\n   */\n  readonly dryRun?: boolean;\n\n  /**\n   * If this is set to false then the stack update workflow will\n   * not be run\n   *\n   * The update workflow exists to check for cases where a change would cause\n   * a failure to an existing stack, but not for a newly created stack.\n   *\n   * @default true\n   */\n  readonly updateWorkflow?: boolean;\n\n  /**\n   * List of git tags to deploy in sequence before deploying the current code.\n   * When provided, replaces the normal merge-base update workflow.\n   *\n   * @default - use the normal update workflow\n   */\n  readonly updateFromTags?: string[];\n\n  /**\n   * ARN of the IAM role for CloudFormation to assume during deploy/destroy\n   *\n   * @default - use the bootstrap cfn-exec role\n   */\n  readonly roleArn?: string;\n\n  /**\n   * Whether to allow resources that fail to delete during a stack update.\n   *\n   * When false, the test will fail if CloudFormation skips deleting a resource\n   * during a stack update. When true, only a warning is printed.\n   *\n   * @default false\n   */\n  readonly allowDeleteFailures?: boolean;\n}\n\n/**\n * An integration test runner that orchestrates executing\n * integration tests\n */\nexport class IntegTestRunner {\n  private readonly helper: CdkIntegHelper;\n  constructor(options: CdkIntegHelperOptions, destructiveChanges?: DestructiveChange[]) {\n    this.helper = CdkIntegHelper.create(options);\n    this.helper._destructiveChanges = destructiveChanges;\n\n    // We need to have given this a value, but we don't actually care about it initially,\n    // because we only synth to get the test definition.\n    // FIXME: This is unfortunate -- in order to start running the test \"for real\" we\n    // already have created a real snapshot with the real test definition, but we've thrown\n    // that away already. So we need to synth again just to get the test definition, AGAIN.\n    //\n    // We will rewrite this later when it comes time to generate the actual\n    // golden snapshot, to match the requested value in the test definition.\n    this.helper.configureLegacyEnableLookups('dont-care');\n  }\n\n  /**\n   * Compatibility shim with old API\n   */\n  public get testName() {\n    return this.helper.testName;\n  }\n\n  /**\n   * Compatibility shim with old API\n   */\n  private async actualTestSuite() {\n    return (await this.helper.actualSnapshot()).testDefinition;\n  }\n\n  public async actualTests(): Promise<{ [testName: string]: TestCase } | undefined> {\n    const actualTestSuite = await this.actualTestSuite();\n    // We don't want new tests written in the legacy mode.\n    // If there is no existing snapshot _and_ this is a legacy\n    // test then point the user to the new `IntegTest` construct\n    if (!this.helper.hasSnapshot() && actualTestSuite.type === 'legacy-test-suite') {\n      throw new Error(`${this.helper.testName} is a new test. Please use the IntegTest construct ` +\n        'to configure the test\\n' +\n        'https://github.com/aws/aws-cdk/tree/main/packages/%40aws-cdk/integ-tests-alpha',\n      );\n    }\n\n    return actualTestSuite.testSuite;\n  }\n\n  public createCdkContextJson(): void {\n    if (!fs.existsSync(this.helper.cdkContextPath)) {\n      fs.writeFileSync(this.helper.cdkContextPath, JSON.stringify({\n        watch: { },\n      }, undefined, 2));\n    }\n  }\n\n  /**\n   * Checkout the snapshot directory at a specific git ref (tag, commit, branch).\n   * Fails fast if the snapshot does not exist at the given ref.\n   */\n  private checkoutSnapshotAtRef(ref: string): void {\n    const gitCwd = path.dirname(this.helper.goldenSnapshotDir);\n    const git = ['git', '-C', gitCwd];\n    const relativeSnapshotDir = path.relative(gitCwd, this.helper.goldenSnapshotDir);\n\n    try {\n      exec([...git, 'checkout', ref, '--', relativeSnapshotDir]);\n    } catch (e) {\n      throw new Error(\n        `Snapshot does not exist at tag '${ref}'. ` +\n        `Path: ${relativeSnapshotDir}\\n` +\n        `Underlying error: ${formatError(e)}`,\n      );\n    }\n  }\n\n  /**\n   * Deploy the snapshot from each git tag in sequence, then let the caller\n   * deploy the current code as the final update.\n   */\n  private async deployFromTags(\n    deployArgs: cdk.DeployOptions,\n    testCaseName: string,\n    tags: string[],\n    allowDeleteFailures: boolean,\n  ): Promise<void> {\n    const totalTags = tags.length;\n\n    for (let i = 0; i < totalTags; i++) {\n      const tag = tags[i];\n      logger.highlight(`${this.helper.testName}/${testCaseName}: deploying tag ${tag} (${i + 1}/${totalTags})`);\n\n      this.checkoutSnapshotAtRef(tag);\n\n      const expectedTestSuite = await this.helper.expectedTestSuite();\n      if (!expectedTestSuite || !(testCaseName in expectedTestSuite.testSuite)) {\n        throw new Error(\n          `Test case '${testCaseName}' does not exist in snapshot at tag '${tag}'`,\n        );\n      }\n\n      const expectedTestCase = expectedTestSuite.testSuite[testCaseName];\n      const deployResult = await this.helper.cdk.deploy({\n        ...deployArgs,\n        stacks: expectedTestCase.stacks,\n        ...expectedTestCase?.cdkCommandOptions?.deploy?.args,\n        context: this.helper.getContext(expectedTestCase?.cdkCommandOptions?.deploy?.args?.context),\n        app: path.relative(this.helper.directory, this.helper.goldenSnapshotDir),\n        lookups: expectedTestSuite?.enableLookups,\n      });\n\n      if (deployResult.deleteFailures.length > 0) {\n        const details = deployResult.deleteFailures\n          .map(f => `  - ${f.logicalResourceId} (${f.resourceType}): ${f.reason}`)\n          .join('\\n');\n        const message =\n          `Update from tag '${tag}': ${deployResult.deleteFailures.length} resource(s) failed to delete:\\n${details}`;\n        if (allowDeleteFailures) {\n          logger.warning(message);\n        } else {\n          throw new Error(message);\n        }\n      }\n    }\n\n    logger.highlight(`${this.helper.testName}/${testCaseName}: deploying current branch (final)`);\n  }\n\n  /**\n   * When running integration tests with the update path workflow\n   * it is important that the snapshot that is deployed is the current snapshot\n   * from the upstream branch. In order to guarantee that, first checkout the latest\n   * (to the user) snapshot from upstream\n   *\n   * It is not straightforward to figure out what branch the current\n   * working branch was created from. This is a best effort attempt to do so.\n   * This assumes that there is an 'origin'. `git remote show origin` returns a list of\n   * all branches and we then search for one that starts with `HEAD branch: `\n   */\n  private checkoutSnapshot(): void {\n    // We use the directory that contains the snapshot to run git commands in\n    // We don't change the cwd for executing git, but instead use the -C flag\n    // @see https://git-scm.com/docs/git#Documentation/git.txt--Cltpathgt\n    // This way we are guaranteed to operate under the correct git repo, even\n    // when executing integ-runner from outside the repo under test.\n    const gitCwd = path.dirname(this.helper.goldenSnapshotDir);\n    const git = ['git', '-C', gitCwd];\n\n    // https://git-scm.com/docs/git-merge-base\n    let baseBranch: string | undefined = undefined;\n    // try to find the base branch that the working branch was created from\n    try {\n      const origin: string = exec([...git, 'remote', 'show', 'origin']);\n      const originLines = origin.split('\\n');\n      for (const line of originLines) {\n        if (line.trim().startsWith('HEAD branch: ')) {\n          baseBranch = line.trim().split('HEAD branch: ')[1];\n        }\n      }\n    } catch (e) {\n      logger.warning('%s\\n%s',\n        'Could not determine git origin branch.',\n        `You need to manually checkout the snapshot directory ${this.helper.goldenSnapshotDir}` +\n        'from the merge-base (https://git-scm.com/docs/git-merge-base)',\n      );\n      logger.warning('error: %s', formatError(e));\n    }\n\n    // if we found the base branch then get the merge-base (most recent common commit)\n    // and checkout the snapshot using that commit\n    if (baseBranch) {\n      const relativeSnapshotDir = path.relative(gitCwd, this.helper.goldenSnapshotDir);\n\n      const checkoutCommand = [...git, 'checkout', [...git, 'merge-base', 'HEAD', baseBranch], '--', relativeSnapshotDir];\n      try {\n        execWithSubShell(checkoutCommand);\n      } catch (e) {\n        logger.warning('%s\\n%s',\n          `Could not checkout snapshot directory '${this.helper.goldenSnapshotDir}'. Please verify the following command completes correctly:`,\n          renderCommand(checkoutCommand),\n          '',\n        );\n        logger.warning('error: %s', formatError(e));\n      }\n    }\n  }\n\n  /**\n   * Runs cdk deploy --watch for an integration test\n   *\n   * This is meant to be run on a single test and will not create a snapshot\n   */\n  public async watchIntegTest(options: WatchOptions): Promise<void> {\n    const actualTestSuite = await this.actualTestSuite();\n    const actualTestCase = actualTestSuite.testSuite[options.testCaseName];\n    if (!actualTestCase) {\n      throw new Error(`Did not find test case name '${options.testCaseName}' in '${Object.keys(actualTestSuite.testSuite)}'`);\n    }\n    const enableForVerbosityLevel = (needed = 1) => {\n      const verbosity = options.verbosity ?? 0;\n      return (verbosity >= needed) ? true : undefined;\n    };\n    try {\n      await this.watch(\n        {\n          ...this.helper.defaultArgs,\n          deploymentMethod: {\n            method: 'hotswap',\n            fallback: {\n              method: 'change-set',\n            },\n          },\n          profile: this.helper.profile,\n          requireApproval: RequireApproval.NEVER,\n          traceLogs: enableForVerbosityLevel(2) ?? false,\n          verbose: enableForVerbosityLevel(3),\n          debug: enableForVerbosityLevel(4),\n          roleArn: options.roleArn,\n        },\n        options.testCaseName,\n        options.verbosity ?? 0,\n      );\n    } catch (e) {\n      throw e;\n    }\n  }\n\n  /**\n   * Orchestrates running integration tests. Currently this includes\n   *\n   * 1. (if update workflow is enabled) Deploying the snapshot test stacks\n   * 2. Deploying the integration test stacks\n   * 2. Saving the snapshot (if successful)\n   * 3. Destroying the integration test stacks (if clean=false)\n   *\n   * The update workflow exists to check for cases where a change would cause\n   * a failure to an existing stack, but not for a newly created stack.\n   */\n  public async runIntegTestCase(options: RunOptions): Promise<AssertionResults | undefined> {\n    let assertionResults: AssertionResults | undefined;\n    const actualTestSuite = await this.actualTestSuite();\n    const actualTestCase = actualTestSuite.testSuite[options.testCaseName];\n    if (!actualTestCase) {\n      throw new Error(`Did not find test case name '${options.testCaseName}' in '${Object.keys(actualTestSuite.testSuite)}'`);\n    }\n\n    // Ideally we would force `enableLookups` to `true`, always, because that's what we would like to converge on for the snapshots.\n    //\n    // HOWEVER!\n    //\n    // In order to do that, to validate the snapshot correctly we need to match what's in `integ.json`. In order to ratchet\n    // that value to `true`, we would need to rewrite `integ.json` to have `enableLookups: true`. We don't currently\n    // have code to reliably rewrite that file, so we just leave the value at whatever the test requested.\n    this.helper.configureLegacyEnableLookups(actualTestSuite.enableLookups ?? false);\n\n    const clean = options.clean ?? true;\n    const updateWorkflowEnabled = (options.updateWorkflow ?? true)\n      && (actualTestCase.stackUpdateWorkflow ?? true);\n    const allowDeleteFailures = actualTestCase.allowDeleteFailures ?? options.allowDeleteFailures ?? false;\n    const enableForVerbosityLevel = (needed = 1) => {\n      const verbosity = options.verbosity ?? 0;\n      return (verbosity >= needed) ? true : undefined;\n    };\n\n    try {\n      if (!options.dryRun && (actualTestCase.cdkCommandOptions?.deploy?.enabled ?? true)) {\n        assertionResults = await this.deploy(\n          {\n            ...this.helper.defaultArgs,\n            profile: this.helper.profile,\n            requireApproval: RequireApproval.NEVER,\n            verbose: enableForVerbosityLevel(3),\n            debug: enableForVerbosityLevel(4),\n            roleArn: options.roleArn,\n          },\n          updateWorkflowEnabled,\n          options.testCaseName,\n          allowDeleteFailures,\n          options.updateFromTags,\n        );\n      }\n\n      // only create the snapshot if there are no failed assertion results\n      // (i.e. no failures)\n      if (!Object.values(assertionResults ?? {}).some(result => result.status === 'fail')) {\n        await this.helper.createSnapshot();\n      }\n    } catch (e) {\n      throw e;\n    } finally {\n      if (!options.dryRun) {\n        if (clean && (actualTestCase.cdkCommandOptions?.destroy?.enabled ?? true)) {\n          await this.destroy(options.testCaseName, {\n            ...this.helper.defaultArgs,\n            profile: this.helper.profile,\n            all: true,\n            force: true,\n            app: this.helper.cdkApp,\n            output: path.relative(this.helper.directory, this.helper.temporarySnapshotDir),\n            ...actualTestCase.cdkCommandOptions?.destroy?.args,\n            context: this.helper.getContext(actualTestCase.cdkCommandOptions?.destroy?.args?.context),\n            roleArn: options.roleArn ?? actualTestCase.cdkCommandOptions?.destroy?.args?.roleArn,\n            verbose: enableForVerbosityLevel(3),\n            debug: enableForVerbosityLevel(4),\n          });\n        }\n      }\n      this.helper.cleanup();\n    }\n    return assertionResults;\n  }\n\n  /**\n   * Perform a integ test case stack destruction\n   */\n  private async destroy(testCaseName: string, destroyArgs: DestroyOptions) {\n    const actualTestCase = (await this.actualTestSuite()).testSuite[testCaseName];\n    try {\n      if (actualTestCase.hooks?.preDestroy) {\n        actualTestCase.hooks.preDestroy.forEach(cmd => {\n          exec(chunks(cmd), {\n            cwd: path.dirname(this.helper.goldenSnapshotDir),\n          });\n        });\n      }\n      await this.helper.cdk.destroy({\n        ...destroyArgs,\n      });\n\n      if (actualTestCase.hooks?.postDestroy) {\n        actualTestCase.hooks.postDestroy.forEach(cmd => {\n          exec(chunks(cmd), {\n            cwd: path.dirname(this.helper.goldenSnapshotDir),\n          });\n        });\n      }\n    } catch (e) {\n      this.parseError(e,\n        actualTestCase.cdkCommandOptions?.destroy?.expectError ?? false,\n        actualTestCase.cdkCommandOptions?.destroy?.expectedMessage,\n      );\n    }\n  }\n\n  private async watch(options: cdk.WatchOptions, testCaseName: string, verbosity: number): Promise<void> {\n    const actualTestSuite = await this.actualTestSuite();\n    const actualTestCase = actualTestSuite.testSuite[testCaseName];\n    if (actualTestCase.hooks?.preDeploy) {\n      actualTestCase.hooks.preDeploy.forEach(cmd => {\n        exec(chunks(cmd), {\n          cwd: path.dirname(this.helper.goldenSnapshotDir),\n        });\n      });\n    }\n    const watchArgs = {\n      ...options,\n      lookups: actualTestSuite.enableLookups,\n      stacks: [\n        ...actualTestCase.stacks,\n        ...actualTestCase.assertionStack ? [actualTestCase.assertionStack] : [],\n      ],\n      output: path.relative(this.helper.directory, this.helper.temporarySnapshotDir),\n      outputsFile: path.relative(this.helper.directory, path.join(this.helper.temporarySnapshotDir, 'assertion-results.json')),\n      ...actualTestCase?.cdkCommandOptions?.deploy?.args,\n      context: {\n        ...this.helper.getContext(actualTestCase?.cdkCommandOptions?.deploy?.args?.context),\n      },\n      app: this.helper.cdkApp,\n    };\n    const destroyMessage = {\n      additionalMessages: [\n        'After you are done you must manually destroy the deployed stacks',\n        `  ${[\n          ...process.env.AWS_REGION ? [`AWS_REGION=${process.env.AWS_REGION}`] : [],\n          'cdk destroy',\n          `-a '${this.helper.cdkApp}'`,\n          watchArgs.stacks.join(' '),\n          `--profile ${watchArgs.profile}`,\n        ].join(' ')}`,\n      ],\n    };\n    workerpool.workerEmit(destroyMessage);\n    if (watchArgs.verbose) {\n      // if `-vvv` (or above) is used then print out the command that was used\n      // this allows users to manually run the command\n      workerpool.workerEmit({\n        additionalMessages: [\n          'Repro:',\n          `  ${[\n            'cdk synth',\n            `-a '${this.helper.cdkApp}'`,\n            `-o '${this.helper.temporarySnapshotDir}'`,\n            ...Object.entries(this.helper.getContext()).flatMap(([k, v]) => typeof v !== 'object' ? [`-c '${k}=${v}'`] : []),\n            watchArgs.stacks.join(' '),\n            `--outputs-file ${watchArgs.outputsFile}`,\n            `--profile ${watchArgs.profile}`,\n            '--hotswap-fallback',\n          ].join(' ')}`,\n        ],\n      });\n    }\n\n    const assertionResults = path.join(this.helper.temporarySnapshotDir, 'assertion-results.json');\n    const watcher = chokidar.watch([this.helper.temporarySnapshotDir], {\n      cwd: this.helper.directory,\n    });\n    watcher.on('all', (event: EventName, file: string) => {\n      if (!isFileEvent(event)) {\n        return; // Ignore non-file events like 'error', 'raw', 'ready', 'all'\n      }\n      // we only care about changes to the `assertion-results.json` file. If there\n      // are assertions then this will change on every deployment\n      if (assertionResults.endsWith(file) && (event === 'add' || event === 'change')) {\n        const start = Date.now();\n        if (actualTestCase.hooks?.postDeploy) {\n          actualTestCase.hooks.postDeploy.forEach(cmd => {\n            exec(chunks(cmd), {\n              cwd: path.dirname(this.helper.goldenSnapshotDir),\n            });\n          });\n        }\n\n        if (actualTestCase.assertionStack && actualTestCase.assertionStackName) {\n          const res = this.processAssertionResults(\n            assertionResults,\n            actualTestCase.assertionStackName,\n            actualTestCase.assertionStack,\n          );\n          if (res && Object.values(res).some(r => r.status === 'fail')) {\n            workerpool.workerEmit({\n              reason: DiagnosticReason.ASSERTION_FAILED,\n              testName: `${testCaseName} (${watchArgs.profile}`,\n              message: formatAssertionResults(res),\n              duration: (Date.now() - start) / 1000,\n            });\n          } else {\n            workerpool.workerEmit({\n              reason: DiagnosticReason.TEST_SUCCESS,\n              testName: `${testCaseName}`,\n              message: res ? formatAssertionResults(res) : 'NO ASSERTIONS',\n              duration: (Date.now() - start) / 1000,\n            });\n          }\n          // emit the destroy message after every run\n          // so that it's visible to the user\n          workerpool.workerEmit(destroyMessage);\n        }\n      }\n    });\n    await new Promise(resolve => {\n      watcher.on('ready', async () => {\n        resolve({});\n      });\n    });\n\n    const { promise: waiter, resolve } = promiseWithResolvers<number | null>();\n\n    await this.helper.cdk.watch(watchArgs, {\n      // if `-v` (or above) is passed then stream the logs\n      onStdout: (message) => {\n        if (verbosity > 0) {\n          process.stdout.write(message);\n        }\n      },\n      // if `-v` (or above) is passed then stream the logs\n      onStderr: (message) => {\n        if (verbosity > 0) {\n          process.stderr.write(message);\n        }\n      },\n      onClose: async (code) => {\n        if (code !== 0) {\n          throw new Error('Watch exited with error');\n        }\n        await watcher.close();\n        resolve(code);\n      },\n    });\n\n    await waiter;\n  }\n\n  /**\n   * Perform a integ test case deployment, including\n   * performing the update workflow\n   */\n  private async deploy(\n    deployArgs: cdk.DeployOptions,\n    updateWorkflowEnabled: boolean,\n    testCaseName: string,\n    allowDeleteFailures: boolean,\n    updateFromTags?: string[],\n  ): Promise<AssertionResults | undefined> {\n    const actualTestCase = (await this.actualTestSuite()).testSuite[testCaseName];\n    try {\n      if (actualTestCase.hooks?.preDeploy) {\n        actualTestCase.hooks.preDeploy.forEach(cmd => {\n          exec(chunks(cmd), {\n            cwd: path.dirname(this.helper.goldenSnapshotDir),\n          });\n        });\n      }\n\n      if (updateFromTags && updateFromTags.length > 0) {\n        // Tag-sequence update workflow: deploy each tag's snapshot in order\n        await this.deployFromTags(deployArgs, testCaseName, updateFromTags, allowDeleteFailures);\n      } else if (updateWorkflowEnabled && this.helper.hasSnapshot()) {\n        // Normal merge-base update workflow\n        const expectedTestSuite = await this.helper.expectedTestSuite();\n        if (expectedTestSuite && testCaseName in expectedTestSuite?.testSuite) {\n          this.checkoutSnapshot();\n          const expectedTestCase = expectedTestSuite.testSuite[testCaseName];\n          await this.helper.cdk.deploy({\n            ...deployArgs,\n            stacks: expectedTestCase.stacks,\n            ...expectedTestCase?.cdkCommandOptions?.deploy?.args,\n            context: this.helper.getContext(expectedTestCase?.cdkCommandOptions?.deploy?.args?.context),\n            app: path.relative(this.helper.directory, this.helper.goldenSnapshotDir),\n            lookups: expectedTestSuite?.enableLookups,\n          });\n        }\n      }\n      // now deploy the \"actual\" test.\n      // This is the stack update if the update workflow ran above.\n      const actualDeployResult = await this.helper.cdk.deploy({\n        ...deployArgs,\n        lookups: (await this.actualTestSuite()).enableLookups,\n        stacks: [\n          ...actualTestCase.stacks,\n        ],\n        output: path.relative(this.helper.directory, this.helper.temporarySnapshotDir),\n        ...actualTestCase?.cdkCommandOptions?.deploy?.args,\n        context: this.helper.getContext(actualTestCase?.cdkCommandOptions?.deploy?.args?.context),\n        app: this.helper.cdkApp,\n      });\n\n      if (actualDeployResult.deleteFailures.length > 0) {\n        const details = actualDeployResult.deleteFailures\n          .map(f => `  - ${f.logicalResourceId} (${f.resourceType}): ${f.reason}`)\n          .join('\\n');\n        const message =\n          `${actualDeployResult.deleteFailures.length} resource(s) failed to delete during stack update:\\n${details}\\n` +\n          'These resources are no longer managed by CloudFormation but still exist and may incur charges.';\n        if (allowDeleteFailures) {\n          logger.warning(message);\n        } else {\n          throw new Error(message);\n        }\n      }\n\n      // If there are any assertions\n      // deploy the assertion stack as well\n      // This is separate from the above deployment because we want to\n      // set `rollback: false`. This allows the assertion stack to deploy all the\n      // assertions instead of failing at the first failed assertion\n      // combining it with the above deployment would prevent any replacement updates\n      if (actualTestCase.assertionStack) {\n        await this.helper.cdk.deploy({\n          ...deployArgs,\n          lookups: (await this.actualTestSuite()).enableLookups,\n          stacks: [\n            actualTestCase.assertionStack,\n          ],\n          rollback: false,\n          output: path.relative(this.helper.directory, this.helper.temporarySnapshotDir),\n          ...actualTestCase?.cdkCommandOptions?.deploy?.args,\n          outputsFile: path.relative(this.helper.directory, path.join(this.helper.temporarySnapshotDir, 'assertion-results.json')),\n          context: this.helper.getContext(actualTestCase?.cdkCommandOptions?.deploy?.args?.context),\n          app: this.helper.cdkApp,\n        });\n      }\n\n      if (actualTestCase.hooks?.postDeploy) {\n        actualTestCase.hooks.postDeploy.forEach(cmd => {\n          exec(chunks(cmd), {\n            cwd: path.dirname(this.helper.goldenSnapshotDir),\n          });\n        });\n      }\n\n      if (actualTestCase.assertionStack && actualTestCase.assertionStackName) {\n        return this.processAssertionResults(\n          path.join(this.helper.temporarySnapshotDir, 'assertion-results.json'),\n          actualTestCase.assertionStackName,\n          actualTestCase.assertionStack,\n        );\n      }\n    } catch (e) {\n      this.parseError(e,\n        actualTestCase.cdkCommandOptions?.deploy?.expectError ?? false,\n        actualTestCase.cdkCommandOptions?.deploy?.expectedMessage,\n      );\n    }\n    return;\n  }\n\n  /**\n   * Process the outputsFile which contains the assertions results as stack\n   * outputs\n   */\n  private processAssertionResults(file: string, assertionStackName: string, assertionStackId: string): AssertionResults | undefined {\n    const results: AssertionResults = {};\n    if (fs.existsSync(file)) {\n      try {\n        const outputs: { [key: string]: { [key: string]: string } } = fs.readJSONSync(file);\n\n        if (assertionStackName in outputs) {\n          for (const [assertionId, result] of Object.entries(outputs[assertionStackName])) {\n            if (assertionId.startsWith('AssertionResults')) {\n              const assertionResult: AssertionResult = JSON.parse(result.replace(/\\n/g, '\\\\n'));\n              if (assertionResult.status === 'fail' || assertionResult.status === 'success') {\n                results[assertionId] = assertionResult;\n              }\n            }\n          }\n        }\n      } catch (e) {\n        // if there are outputs, but they cannot be processed, then throw an error\n        // so that the test fails\n        results[assertionStackId] = {\n          status: 'fail',\n          message: `error processing assertion results: ${e}`,\n        };\n      } finally {\n        // remove the outputs file so it is not part of the snapshot\n        // it will contain env specific information from values\n        // resolved at deploy time\n        fs.unlinkSync(file);\n      }\n    }\n    return Object.keys(results).length > 0 ? results : undefined;\n  }\n\n  /**\n   * Parses an error message returned from a CDK command\n   */\n  private parseError(e: unknown, expectError: boolean, expectedMessage?: string) {\n    if (expectError) {\n      if (expectedMessage) {\n        const message = (e as Error).message;\n        if (!message.match(expectedMessage)) {\n          throw (e);\n        }\n      }\n    } else {\n      throw e;\n    }\n  }\n}\n"]}
+function analyzeVerbosity(verbosity = 0) {
+    return {
+        verbose: verbosity >= 3 ? true : undefined,
+        debug: verbosity >= 4 ? true : undefined,
+        traceLogs: verbosity >= 2 ? true : false,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"integ-test-runner.js","sourceRoot":"","sources":["integ-test-runner.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport type { DestroyOptions, TestCase } from '@aws-cdk/cloud-assembly-schema';\nimport { RequireApproval } from '@aws-cdk/cloud-assembly-schema';\nimport * as chokidar from 'chokidar';\nimport { type EventName, EVENTS } from 'chokidar/handler.js';\nimport * as fs from 'fs-extra';\nimport * as workerpool from 'workerpool';\nimport type * as cdk from '../engines/cdk-interface';\nimport * as logger from '../logger';\nimport { chunks, exec, execWithSubShell, promiseWithResolvers, renderCommand } from '../utils';\nimport type { CdkTestAppOptions, LegacyEnableLookups } from './cdk-test-app';\nimport { CdkTestApp, DEFAULT_ARGS } from './cdk-test-app';\nimport type { IntegTest } from './integration-tests';\nimport type { DestructiveChange, AssertionResults, AssertionResult } from '../workers/common';\nimport { DiagnosticReason, formatAssertionResults, formatError } from '../workers/common';\n\n/**\n * File events that we care about from chokidar.\n * In chokidar v4, EventName includes additional events like 'error', 'raw', 'ready', 'all'\n * that we need to filter out in the 'all' handler.\n */\nconst FILE_EVENTS = [EVENTS.ADD, EVENTS.CHANGE] as const;\ntype FileEvent = typeof FILE_EVENTS[number];\n\n/**\n * Type guard to check if an event is a file event we should process.\n */\nfunction isFileEvent(event: EventName): event is FileEvent {\n  return (FILE_EVENTS as readonly string[]).includes(event);\n}\n\nexport interface CommonOptions {\n  /**\n   * The level of verbosity for logging.\n   *\n   * @default 0\n   */\n  readonly verbosity?: number;\n}\n\nexport interface WatchOptions extends CommonOptions {\n  /**\n   * ARN of the IAM role for CloudFormation to assume during deploy/destroy\n   *\n   * @default - use the bootstrap cfn-exec role\n   */\n  readonly roleArn?: string;\n}\n\n/**\n * Options for the integration test runner\n */\nexport interface RunOptions extends CommonOptions {\n  /**\n   * Whether or not to run `cdk destroy` and cleanup the\n   * integration test stacks.\n   *\n   * Set this to false if you need to perform any validation\n   * or troubleshooting after deployment.\n   *\n   * @default true\n   */\n  readonly clean?: boolean;\n\n  /**\n   * If set to true, the integration test will not deploy\n   * anything and will simply update the snapshot.\n   *\n   * You should NOT use this method since you are essentially\n   * bypassing the integration test.\n   *\n   * @default false\n   */\n  readonly dryRun?: boolean;\n\n  /**\n   * If this is set to false then the stack update workflow will\n   * not be run\n   *\n   * The update workflow exists to check for cases where a change would cause\n   * a failure to an existing stack, but not for a newly created stack.\n   *\n   * @default true\n   */\n  readonly updateWorkflow?: boolean;\n\n  /**\n   * List of git tags to deploy in sequence before deploying the current code.\n   * When provided, replaces the normal merge-base update workflow.\n   *\n   * @default - use the normal update workflow\n   */\n  readonly updateFromTags?: string[];\n\n  /**\n   * ARN of the IAM role for CloudFormation to assume during deploy/destroy\n   *\n   * @default - use the bootstrap cfn-exec role\n   */\n  readonly roleArn?: string;\n\n  /**\n   * Whether to allow resources that fail to delete during a stack update.\n   *\n   * When false, the test will fail if CloudFormation skips deleting a resource\n   * during a stack update. When true, only a warning is printed.\n   *\n   * @default false\n   */\n  readonly allowDeleteFailures?: boolean;\n}\n\ntype RunnerOptions = Omit<CdkTestAppOptions, 'outputDirectoryNameTemplate'> & {\n  /**\n   * Just for testing\n   *\n   * Use the comparison output directory for deployments, instead of a separate output\n   * directory.\n   *\n   * Preferably, we synth into a separate directory so that snapshot comparison assembly and\n   * deployment assembly don't trample on each other, but the tests in this repository have\n   * been set up to use the same directory.\n   */\n  TESTING_useComparisonOutputDirectory?: boolean;\n};\n\n/**\n * An integration test runner that orchestrates executing\n * integration tests\n */\nexport class IntegTestRunner {\n  private readonly test: IntegTest;\n\n  constructor(private readonly appOptions: RunnerOptions, private readonly destructiveChanges?: DestructiveChange[]) {\n    this.test = appOptions.test;\n  }\n\n  /**\n   * Orchestrates running integration tests. Currently this includes\n   *\n   * 1. (if update workflow is enabled) Deploying the snapshot test stacks\n   * 2. Deploying the integration test stacks\n   * 2. Saving the snapshot (if successful)\n   * 3. Destroying the integration test stacks (if clean=false)\n   *\n   * The update workflow exists to check for cases where a change would cause\n   * a failure to an existing stack, but not for a newly created stack.\n   */\n  public async runIntegTestCase(runOptions: RunOptions): Promise<AssertionResults | undefined> {\n    let assertionResults: AssertionResults | undefined;\n\n    // Set up actual\n    let actual = await CdkTestApp.forDeployment(this.appOptions);\n    if (this.appOptions.TESTING_useComparisonOutputDirectory) {\n      actual = await CdkTestApp.forComparison(this.appOptions);\n    }\n\n    const previousVersion = await CdkTestApp.forGoldenSnapshot(this.appOptions);\n\n    const actualTestSuite = await actual.synthForDeployment();\n\n    if (actualTestSuite.type === 'legacy-test-suite' && !previousVersion.hasOutput()) {\n      throw new Error(`${this.test.testName} is a new test. Please use the IntegTest construct ` +\n        'to configure the test\\n' +\n        'https://github.com/aws/aws-cdk/tree/main/packages/%40aws-cdk/integ-tests-alpha',\n      );\n    }\n\n    const clean = runOptions.clean ?? true;\n    try {\n      for (const [testCaseName, actualTestCase] of Object.entries(actualTestSuite.testSuite)) {\n        const updateWorkflowEnabled = (runOptions.updateWorkflow ?? false)\n          && (actualTestCase.stackUpdateWorkflow ?? false);\n        const allowDeleteFailures = actualTestCase.allowDeleteFailures ?? runOptions.allowDeleteFailures ?? false;\n\n        const verbosity = analyzeVerbosity(runOptions.verbosity);\n\n        if (!runOptions.dryRun && (actualTestCase.cdkCommandOptions?.deploy?.enabled ?? true)) {\n          try {\n            assertionResults = await this.deployTestAndAssertions(\n              actual,\n              previousVersion,\n              actualTestCase,\n              {\n                roleArn: runOptions.roleArn ?? actualTestCase.cdkCommandOptions?.deploy?.args?.roleArn,\n                verbose: verbosity.verbose,\n                debug: verbosity.debug,\n              },\n              updateWorkflowEnabled,\n              testCaseName,\n              allowDeleteFailures,\n              runOptions.updateFromTags,\n            );\n          } finally {\n            if (!runOptions.dryRun && clean && (actualTestCase.cdkCommandOptions?.destroy?.enabled ?? true)) {\n              await this.destroyTestAndAssertions(actual, actualTestCase, {\n                ...actualTestCase.cdkCommandOptions?.destroy?.args,\n                roleArn: runOptions.roleArn ?? actualTestCase.cdkCommandOptions?.destroy?.args?.roleArn,\n                verbose: verbosity.verbose,\n                debug: verbosity.debug,\n              });\n            }\n          }\n        }\n      }\n\n      // only create the snapshot if there are no failed assertion results\n      // (i.e. no failures)\n      if (!Object.values(assertionResults ?? {}).some(result => result.status === 'fail')) {\n        await this.createSnapshot(actualTestSuite.enableLookups);\n      }\n    } finally {\n      actual.cleanup();\n    }\n\n    return assertionResults;\n  }\n\n  private async createSnapshot(enableLookups: LegacyEnableLookups) {\n    const expected = await CdkTestApp.forGoldenSnapshot(this.appOptions);\n    await expected.synthForGoldenSnapshot(this.destructiveChanges ?? [], enableLookups);\n  }\n\n  /**\n   * Runs cdk deploy --watch for an integration test\n   *\n   * This is meant to be run on a single test and will not create a snapshot\n   */\n  public async watchIntegTest(options: WatchOptions): Promise<void> {\n    // Set up actual\n    const actual = await CdkTestApp.forDeployment(this.appOptions);\n    await actual.synthForDeployment();\n\n    // Just take the first test case, that's the one we watch.\n    // Not even sure how better behavior here is possible, but watch isn't used that often.\n    const firstTestCaseName = Object.keys(actual.testCases())[0];\n\n    const verbosity = analyzeVerbosity(options.verbosity);\n    try {\n      await this.watch(\n        actual,\n        firstTestCaseName,\n        {\n          ...DEFAULT_ARGS,\n          deploymentMethod: {\n            method: 'hotswap',\n            fallback: {\n              method: 'change-set',\n            },\n          },\n          profile: this.appOptions.profile,\n          requireApproval: RequireApproval.NEVER,\n          traceLogs: verbosity.traceLogs ?? false,\n          verbose: verbosity.verbose,\n          debug: verbosity.debug,\n          roleArn: options.roleArn,\n        },\n        options.verbosity ?? 0,\n      );\n    } catch (e) {\n      throw e;\n    }\n  }\n\n  /**\n   * Checkout the snapshot directory at a specific git ref (tag, commit, branch).\n   * Fails fast if the snapshot does not exist at the given ref.\n   */\n  private checkoutSnapshotAtRef(snapshotApp: CdkTestApp, ref: string): void {\n    const gitCwd = path.dirname(snapshotApp.outputDirectory);\n    const git = ['git', '-C', gitCwd];\n    const relativeSnapshotDir = path.relative(gitCwd, snapshotApp.outputDirectory);\n\n    try {\n      exec([...git, 'checkout', ref, '--', relativeSnapshotDir]);\n    } catch (e) {\n      throw new Error(\n        `Snapshot does not exist at tag '${ref}'. ` +\n        `Path: ${relativeSnapshotDir}\\n` +\n        `Underlying error: ${formatError(e)}`,\n      );\n    }\n  }\n\n  /**\n   * Deploy the snapshot from each git tag in sequence, then let the caller\n   * deploy the current code as the final update.\n   */\n  private async deployFromTags(\n    actualApp: CdkTestApp,\n    deployArgs: cdk.DeployOptions,\n    testCaseName: string,\n    tags: string[],\n    allowDeleteFailures: boolean,\n  ): Promise<void> {\n    const totalTags = tags.length;\n\n    for (let i = 0; i < totalTags; i++) {\n      const tag = tags[i];\n      logger.highlight(`${this.test.testName}/${testCaseName}: deploying tag ${tag} (${i + 1}/${totalTags})`);\n\n      this.checkoutSnapshotAtRef(actualApp, tag);\n\n      const expectedTestSuite = actualApp.testSuite;\n      if (!expectedTestSuite || !(testCaseName in expectedTestSuite.testSuite)) {\n        throw new Error(\n          `Test case '${testCaseName}' does not exist in snapshot at tag '${tag}'`,\n        );\n      }\n\n      const expectedTestCase = expectedTestSuite.testSuite[testCaseName];\n      const deployResult = await actualApp.deploy({\n        ...deployArgs,\n        stacks: expectedTestCase.stacks,\n        ...expectedTestCase?.cdkCommandOptions?.deploy?.args,\n        context: expectedTestCase?.cdkCommandOptions?.deploy?.args?.context,\n      });\n\n      if (deployResult.deleteFailures.length > 0) {\n        const details = deployResult.deleteFailures\n          .map(f => `  - ${f.logicalResourceId} (${f.resourceType}): ${f.reason}`)\n          .join('\\n');\n        const message =\n          `Update from tag '${tag}': ${deployResult.deleteFailures.length} resource(s) failed to delete:\\n${details}`;\n        if (allowDeleteFailures) {\n          logger.warning(message);\n        } else {\n          throw new Error(message);\n        }\n      }\n    }\n\n    logger.highlight(`${actualApp.test.testName}/${testCaseName}: deploying current branch (final)`);\n  }\n\n  /**\n   * When running integration tests with the update path workflow\n   * it is important that the snapshot that is deployed is the current snapshot\n   * from the upstream branch. In order to guarantee that, first checkout the latest\n   * (to the user) snapshot from upstream\n   *\n   * It is not straightforward to figure out what branch the current\n   * working branch was created from. This is a best effort attempt to do so.\n   * This assumes that there is an 'origin'. `git remote show origin` returns a list of\n   * all branches and we then search for one that starts with `HEAD branch: `\n   */\n  private checkoutSnapshot(actualApp: CdkTestApp): void {\n    // We use the directory that contains the snapshot to run git commands in\n    // We don't change the cwd for executing git, but instead use the -C flag\n    // @see https://git-scm.com/docs/git#Documentation/git.txt--Cltpathgt\n    // This way we are guaranteed to operate under the correct git repo, even\n    // when executing integ-runner from outside the repo under test.\n    const gitCwd = path.dirname(actualApp.outputDirectory);\n    const git = ['git', '-C', gitCwd];\n\n    // https://git-scm.com/docs/git-merge-base\n    let baseBranch: string | undefined = undefined;\n    // try to find the base branch that the working branch was created from\n    try {\n      const origin: string = exec([...git, 'remote', 'show', 'origin']);\n      const originLines = origin.split('\\n');\n      for (const line of originLines) {\n        if (line.trim().startsWith('HEAD branch: ')) {\n          baseBranch = line.trim().split('HEAD branch: ')[1];\n        }\n      }\n    } catch (e) {\n      logger.warning('%s\\n%s',\n        'Could not determine git origin branch.',\n        `You need to manually checkout the snapshot directory ${actualApp.outputDirectory}` +\n        'from the merge-base (https://git-scm.com/docs/git-merge-base)',\n      );\n      logger.warning('error: %s', formatError(e));\n    }\n\n    // if we found the base branch then get the merge-base (most recent common commit)\n    // and checkout the snapshot using that commit\n    if (baseBranch) {\n      const relativeSnapshotDir = path.relative(gitCwd, actualApp.outputDirectory);\n\n      const checkoutCommand = [...git, 'checkout', [...git, 'merge-base', 'HEAD', baseBranch], '--', relativeSnapshotDir];\n      try {\n        execWithSubShell(checkoutCommand);\n      } catch (e) {\n        logger.warning('%s\\n%s',\n          `Could not checkout snapshot directory '${actualApp.outputDirectory}'. Please verify the following command completes correctly:`,\n          renderCommand(checkoutCommand),\n          '',\n        );\n        logger.warning('error: %s', formatError(e));\n      }\n    }\n  }\n\n  /**\n   * Perform a integ test case stack destruction\n   */\n  private async destroyTestAndAssertions(actualApp: CdkTestApp, actualTestCase: TestCase, destroyArgs: Partial<DestroyOptions>): Promise<void> {\n    try {\n      if (actualTestCase.hooks?.preDestroy) {\n        actualTestCase.hooks.preDestroy.forEach(cmd => {\n          exec(chunks(cmd), {\n            cwd: path.dirname(actualApp.outputDirectory),\n          });\n        });\n      }\n\n      await actualApp.destroy({\n        stacks: [\n          ...actualTestCase.stacks,\n          ...(actualTestCase.assertionStack ? [actualTestCase.assertionStack] : []),\n        ],\n        ...destroyArgs,\n      });\n\n      if (actualTestCase.hooks?.postDestroy) {\n        actualTestCase.hooks.postDestroy.forEach(cmd => {\n          exec(chunks(cmd), {\n            cwd: path.dirname(actualApp.outputDirectory),\n          });\n        });\n      }\n    } catch (e) {\n      this.parseError(e,\n        actualTestCase.cdkCommandOptions?.destroy?.expectError ?? false,\n        actualTestCase.cdkCommandOptions?.destroy?.expectedMessage,\n      );\n    }\n  }\n\n  private async watch(actualApp: CdkTestApp, testCaseName: string, options: cdk.WatchOptions, verbosity: number): Promise<void> {\n    const actualTestSuite = actualApp.testSuite;\n\n    const actualTestCase = actualApp.testCases()[testCaseName];\n\n    if (actualTestCase.hooks?.preDeploy) {\n      actualTestCase.hooks.preDeploy.forEach(cmd => {\n        exec(chunks(cmd), {\n          cwd: path.dirname(actualApp.outputDirectory),\n        });\n      });\n    }\n    const watchArgs = {\n      ...options,\n      lookups: actualTestSuite.enableLookups,\n      stacks: [\n        ...actualTestCase.stacks,\n        ...actualTestCase.assertionStack ? [actualTestCase.assertionStack] : [],\n      ],\n      output: actualApp.outputDirectory,\n      outputsFile: path.join(actualApp.outputDirectory, 'assertion-results.json'),\n      ...actualTestCase?.cdkCommandOptions?.deploy?.args,\n      context: actualTestCase?.cdkCommandOptions?.deploy?.args?.context,\n    };\n    const destroyMessage = {\n      additionalMessages: [\n        'After you are done you must manually destroy the deployed stacks',\n        `  ${[\n          ...process.env.AWS_REGION ? [`AWS_REGION=${process.env.AWS_REGION}`] : [],\n          'cdk destroy',\n          `-a '${actualApp.appCommand}'`,\n          watchArgs.stacks.join(' '),\n          `--profile ${watchArgs.profile}`,\n        ].join(' ')}`,\n      ],\n    };\n    workerpool.workerEmit(destroyMessage);\n    if (watchArgs.verbose) {\n      // if `-vvv` (or above) is used then print out the command that was used\n      // this allows users to manually run the command\n      workerpool.workerEmit({\n        additionalMessages: [\n          'Repro:',\n          `  ${actualApp.synthReproCommand}`,\n        ],\n      });\n    }\n\n    const assertionResults = path.join(actualApp.outputDirectory, 'assertion-results.json');\n    const watcher = chokidar.watch([actualApp.outputDirectory], {\n      cwd: actualApp.outputDirectory,\n    });\n    watcher.on('all', (event: EventName, file: string) => {\n      if (!isFileEvent(event)) {\n        return; // Ignore non-file events like 'error', 'raw', 'ready', 'all'\n      }\n      // we only care about changes to the `assertion-results.json` file. If there\n      // are assertions then this will change on every deployment\n      if (assertionResults.endsWith(file) && (event === 'add' || event === 'change')) {\n        const start = Date.now();\n        if (actualTestCase.hooks?.postDeploy) {\n          actualTestCase.hooks.postDeploy.forEach(cmd => {\n            exec(chunks(cmd), {\n              cwd: path.dirname(actualApp.outputDirectory),\n            });\n          });\n        }\n\n        if (actualTestCase.assertionStack && actualTestCase.assertionStackName) {\n          const res = this.processAssertionResults(\n            assertionResults,\n            actualTestCase.assertionStackName,\n            actualTestCase.assertionStack,\n          );\n          if (res && Object.values(res).some(r => r.status === 'fail')) {\n            workerpool.workerEmit({\n              reason: DiagnosticReason.ASSERTION_FAILED,\n              testName: `${testCaseName} (${watchArgs.profile}`,\n              message: formatAssertionResults(res),\n              duration: (Date.now() - start) / 1000,\n            });\n          } else {\n            workerpool.workerEmit({\n              reason: DiagnosticReason.TEST_SUCCESS,\n              testName: `${testCaseName}`,\n              message: res ? formatAssertionResults(res) : 'NO ASSERTIONS',\n              duration: (Date.now() - start) / 1000,\n            });\n          }\n          // emit the destroy message after every run\n          // so that it's visible to the user\n          workerpool.workerEmit(destroyMessage);\n        }\n      }\n    });\n    await new Promise(resolve => {\n      watcher.on('ready', async () => {\n        resolve({});\n      });\n    });\n\n    const { promise: waiter, resolve } = promiseWithResolvers<number | null>();\n\n    await actualApp.watch(watchArgs, {\n      // if `-v` (or above) is passed then stream the logs\n      onStdout: (message) => {\n        if (verbosity > 0) {\n          process.stdout.write(message);\n        }\n      },\n      // if `-v` (or above) is passed then stream the logs\n      onStderr: (message) => {\n        if (verbosity > 0) {\n          process.stderr.write(message);\n        }\n      },\n      onClose: async (code) => {\n        if (code !== 0) {\n          throw new Error('Watch exited with error');\n        }\n        await watcher.close();\n        resolve(code);\n      },\n    });\n\n    await waiter;\n  }\n\n  /**\n   * Perform a integ test case deployment, including\n   * performing the update workflow\n   */\n  private async deployTestAndAssertions(\n    app: CdkTestApp,\n    previousVersion: CdkTestApp,\n    testCase: TestCase,\n    deployArgs: cdk.DeployOptions,\n    updateWorkflowEnabled: boolean,\n    testCaseName: string,\n    allowDeleteFailures: boolean,\n    updateFromTags?: string[],\n  ): Promise<AssertionResults | undefined> {\n    try {\n      if (testCase.hooks?.preDeploy) {\n        testCase.hooks.preDeploy.forEach(cmd => {\n          exec(chunks(cmd), {\n            cwd: path.dirname(app.outputDirectory),\n          });\n        });\n      }\n      if (updateFromTags && updateFromTags.length > 0) {\n        // Tag-sequence update workflow: deploy each tag's snapshot in order\n        await this.deployFromTags(app, deployArgs, testCaseName, updateFromTags, allowDeleteFailures);\n      } else if (updateWorkflowEnabled && await previousVersion.hasOutput()) {\n        // Normal merge-base update workflow\n        const expectedTestSuite = await previousVersion.loadExistingSuite();\n        if (expectedTestSuite && testCaseName in expectedTestSuite?.testSuite) {\n          this.checkoutSnapshot(previousVersion);\n          const expectedTestCase = expectedTestSuite.testSuite[testCaseName];\n\n          await previousVersion.deploy({\n            ...deployArgs,\n            stacks: expectedTestCase.stacks,\n            ...expectedTestCase?.cdkCommandOptions?.deploy?.args,\n            context: expectedTestCase?.cdkCommandOptions?.deploy?.args?.context,\n          });\n        }\n      }\n\n      // now deploy the \"actual\" test.\n      // This is the stack update if the update workflow ran above.\n      const actualDeployResult = await app.deploy({\n        ...deployArgs,\n        stacks: testCase.stacks,\n        ...testCase?.cdkCommandOptions?.deploy?.args,\n        context: testCase?.cdkCommandOptions?.deploy?.args?.context,\n      });\n\n      if (actualDeployResult.deleteFailures.length > 0) {\n        const details = actualDeployResult.deleteFailures\n          .map(f => `  - ${f.logicalResourceId} (${f.resourceType}): ${f.reason}`)\n          .join('\\n');\n        const message =\n          `${actualDeployResult.deleteFailures.length} resource(s) failed to delete during stack update:\\n${details}\\n` +\n          'These resources are no longer managed by CloudFormation but still exist and may incur charges.';\n        if (allowDeleteFailures) {\n          logger.warning(message);\n        } else {\n          throw new Error(message);\n        }\n      }\n\n      // If there are any assertions\n      // deploy the assertion stack as well\n      // This is separate from the above deployment because we want to\n      // set `rollback: false`. This allows the assertion stack to deploy all the\n      // assertions instead of failing at the first failed assertion\n      // combining it with the above deployment would prevent any replacement updates\n      if (testCase.assertionStack) {\n        await app.deploy({\n          ...deployArgs,\n          stacks: [\n            testCase.assertionStack,\n          ],\n          rollback: false,\n          ...testCase?.cdkCommandOptions?.deploy?.args,\n          outputsFile: path.join(app.outputDirectory, 'assertion-results.json'),\n          context: testCase?.cdkCommandOptions?.deploy?.args?.context,\n        });\n      }\n\n      if (testCase.hooks?.postDeploy) {\n        testCase.hooks.postDeploy.forEach(cmd => {\n          exec(chunks(cmd), {\n            cwd: path.dirname(app.outputDirectory),\n          });\n        });\n      }\n\n      if (testCase.assertionStack && testCase.assertionStackName) {\n        return this.processAssertionResults(\n          path.join(app.outputDirectory, 'assertion-results.json'),\n          testCase.assertionStackName,\n          testCase.assertionStack,\n        );\n      }\n    } catch (e) {\n      this.parseError(e,\n        testCase.cdkCommandOptions?.deploy?.expectError ?? false,\n        testCase.cdkCommandOptions?.deploy?.expectedMessage,\n      );\n    }\n    return;\n  }\n\n  /**\n   * Process the outputsFile which contains the assertions results as stack\n   * outputs\n   */\n  private processAssertionResults(file: string, assertionStackName: string, assertionStackId: string): AssertionResults | undefined {\n    const results: AssertionResults = {};\n    if (fs.existsSync(file)) {\n      try {\n        const outputs: { [key: string]: { [key: string]: string } } = fs.readJSONSync(file);\n\n        if (assertionStackName in outputs) {\n          for (const [assertionId, result] of Object.entries(outputs[assertionStackName])) {\n            if (assertionId.startsWith('AssertionResults')) {\n              const assertionResult: AssertionResult = JSON.parse(result.replace(/\\n/g, '\\\\n'));\n              if (assertionResult.status === 'fail' || assertionResult.status === 'success') {\n                results[assertionId] = assertionResult;\n              }\n            }\n          }\n        }\n      } catch (e) {\n        // if there are outputs, but they cannot be processed, then throw an error\n        // so that the test fails\n        results[assertionStackId] = {\n          status: 'fail',\n          message: `error processing assertion results: ${e}`,\n        };\n      } finally {\n        // remove the outputs file so it is not part of the snapshot\n        // it will contain env specific information from values\n        // resolved at deploy time\n        fs.unlinkSync(file);\n      }\n    }\n    return Object.keys(results).length > 0 ? results : undefined;\n  }\n\n  /**\n   * Parses an error message returned from a CDK command\n   */\n  private parseError(e: unknown, expectError: boolean, expectedMessage?: string) {\n    if (expectError) {\n      if (expectedMessage) {\n        const message = (e as Error).message;\n        if (!message.match(expectedMessage)) {\n          throw (e);\n        }\n      }\n    } else {\n      throw e;\n    }\n  }\n}\n\nfunction analyzeVerbosity(verbosity: number = 0): { verbose?: boolean; debug?: boolean; traceLogs?: boolean } {\n  return {\n    verbose: verbosity >= 3 ? true : undefined,\n    debug: verbosity >= 4 ? true : undefined,\n    traceLogs: verbosity >= 2 ? true : false,\n  };\n}\n"]}