@aws-cdk/integ-runner 2.50.0 → 2.51.1

package/README.md

@@ -38,7 +38,7 @@ integ-runner [ARGS] [TEST...]
 This will look for all files that match the naming convention of `/integ.*.js$/`. Each of these files will be expected
 to be a self contained CDK app. The runner will execute the following for each file (app):
 
-1. Check if a snapshot file exists (i.e. `/*.integ.snapshot$/`)
+1. Check if a snapshot file exists (i.e. `/*.snapshot$/`)
 2. If the snapshot does not exist
 	2a. Synth the integ app which will produce the `integ.json` file
 3. Read the `integ.json` file which contains instructions on what the runner should do.
@@ -68,7 +68,11 @@ to be a self contained CDK app. The runner will execute the following for each f
   Read the list of tests from this file
 - `--disable-update-workflow` (default=`false`)
   If this is set to `true` then the [update workflow](#update-workflow) will be disabled
-
+- `--app`
+  The custom CLI command that will be used to run the test files. You can include {filePath} to specify where in the command the test file path should be inserted. Example: --app="python3.8 {filePath}".
+- `--test-regex`
+  Detect integration test files matching this JavaScript regex pattern. If used multiple times, all files matching any one of the patterns are detected.
+  
 Example:
 
 ```bash
@@ -81,7 +85,7 @@ If you are providing a list of tests to execute, either as CLI arguments or from
 For example, if there is a test `aws-iam/test/integ.policy.js` and the current working directory is `aws-iam` you would provide `integ.policy.js`
 
 ```bash
-yarn integ integ.policy.js
+integ-runner integ.policy.js
 ```
 
 ### Common Workflow
@@ -117,7 +121,7 @@ Snapshot Results:
 
 Tests:    1 failed, 9 total
 Error: Some snapshot tests failed!
-To re-run failed tests run: yarn integ-runner --update-on-failed
+To re-run failed tests run: integ-runner --update-on-failed
     at main (packages/@aws-cdk/integ-runner/lib/cli.js:90:15)
 error Command failed with exit code 1. 
 ```
@@ -165,6 +169,8 @@ Test Results:
 Tests:    1 passed, 1 total
 ```
 
+Nested stack templates are also compared as part of the snapshot. However asset hashes are ignored by default. To enable diff for asset hashes, set `diffAssets: true` of `IntegTestProps`.
+
 #### Update Workflow
 
 By default, integration tests are run with the "update workflow" enabled. This can be disabled by using the `--disable-update-workflow` command line option.
@@ -191,7 +197,7 @@ If you are adding a new test which creates a new snapshot then you should run th
 For example, if you are working on a new test `integ.new-test.js` then you would run:
 
 ```bash
-yarn integ --update-on-failed --disable-update-workflow integ.new-test.js
+integ-runner --update-on-failed --disable-update-workflow integ.new-test.js
 ```
 
 This is because for a new test we do not need to test the update workflow (there is nothing to update).
@@ -204,3 +210,25 @@ See [@aws-cdk/cloud-assembly-schema/lib/integ-tests/schema.ts](../cloud-assembly
 
 See the `@aws-cdk/integ-tests` module for information on how to define
 integration tests for the runner to exercise.
+
+### Config file
+
+All options can be configured via the `integ.config.json` configuration file in the current working directory.
+
+```json
+{
+  "maxWorkers": 10,
+  "parallelRegions": [
+    "eu-west-1",
+    "ap-southeast-2"
+  ]
+}
+```
+
+Available options can be listed by running the following command:
+
+```sh
+integ-runner --help
+```
+
+To use a different config file, provide the `--config` command-line option.

package/THIRD_PARTY_LICENSES

@@ -1,6 +1,6 @@
 The @aws-cdk/integ-runner package includes the following third-party software/licensing:
 
-** ajv@8.11.0 - https://www.npmjs.com/package/ajv/v/8.11.0 | MIT
+** ajv@8.11.2 - https://www.npmjs.com/package/ajv/v/8.11.2 | MIT
 The MIT License (MIT)
 
 Copyright (c) 2015-2021 Evgeny Poberezkin
@@ -156,7 +156,7 @@ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH RE
 
 ----------------
 
-** aws-sdk@2.1240.0 - https://www.npmjs.com/package/aws-sdk/v/2.1240.0 | Apache-2.0
+** aws-sdk@2.1255.0 - https://www.npmjs.com/package/aws-sdk/v/2.1255.0 | Apache-2.0
 AWS SDK for JavaScript
 Copyright 2012-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 
@@ -2151,7 +2151,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 ----------------
 
-** table@6.8.0 - https://www.npmjs.com/package/table/v/6.8.0 | BSD-3-Clause
+** table@6.8.1 - https://www.npmjs.com/package/table/v/6.8.1 | BSD-3-Clause
 Copyright (c) 2018, Gajus Kuizinas (http://gajus.com/)
 All rights reserved.
 
@@ -2263,7 +2263,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 ----------------
 
-** workerpool@6.3.0 - https://www.npmjs.com/package/workerpool/v/6.3.0 | Apache-2.0
+** workerpool@6.3.1 - https://www.npmjs.com/package/workerpool/v/6.3.1 | Apache-2.0
 Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/

package/lib/cli.d.ts

@@ -1 +1,22 @@
-export declare function cli(): void;
+export declare function parseCliArgs(args?: string[]): {
+    tests: string[] | undefined;
+    app: string | undefined;
+    testRegex: string[] | undefined;
+    testRegions: string[];
+    profiles: string[] | undefined;
+    runUpdateOnFailed: boolean;
+    fromFile: string | undefined;
+    exclude: boolean;
+    maxWorkers: number;
+    list: boolean;
+    directory: string;
+    inspectFailures: boolean;
+    verbosity: number;
+    verbose: boolean;
+    clean: boolean;
+    force: boolean;
+    dryRun: boolean;
+    disableUpdateWorkflow: boolean;
+};
+export declare function main(args: string[]): Promise<void>;
+export declare function cli(args?: string[]): void;

package/lib/cli.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cli = void 0;
+exports.cli = exports.main = exports.parseCliArgs = void 0;
 // Exercise all integ stacks and if they deploy, update the expected synth files
-const fs_1 = require("fs");
+const fs = require("fs");
 const path = require("path");
 const chalk = require("chalk");
 const workerpool = require("workerpool");
@@ -13,10 +13,16 @@ const workers_1 = require("./workers");
 // https://github.com/evanw/esbuild/issues/1492
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const yargs = require('yargs');
-async function main() {
-    var _a, _b;
+function parseCliArgs(args = []) {
+    var _a;
     const argv = yargs
         .usage('Usage: integ-runner [TEST...]')
+        .option('config', {
+        config: true,
+        configParser: integration_tests_1.IntegrationTests.configFromFile,
+        default: 'integ.config.json',
+        desc: 'Load options from a JSON config file. Options provided as CLI arguments take precedent.',
+    })
         .option('list', { type: 'boolean', default: false, desc: 'List tests instead of running them' })
         .option('clean', { type: 'boolean', default: true, desc: 'Skips stack clean up after test is completed (use --no-clean to negate)' })
         .option('verbose', { type: 'boolean', default: false, alias: 'v', count: true, desc: 'Verbose logs and metrics on integration tests durations (specify multiple times to increase verbosity)' })
@@ -31,50 +37,83 @@ async function main() {
         .options('from-file', { type: 'string', desc: 'Read TEST names from a file (one TEST per line)' })
         .option('inspect-failures', { type: 'boolean', desc: 'Keep the integ test cloud assembly if a failure occurs for inspection', default: false })
         .option('disable-update-workflow', { type: 'boolean', default: false, desc: 'If this is "true" then the stack update workflow will be disabled' })
+        .option('app', { type: 'string', default: undefined, desc: 'The custom CLI command that will be used to run the test files. You can include {filePath} to specify where in the command the test file path should be inserted. Example: --app="python3.8 {filePath}".' })
+        .option('test-regex', { type: 'array', desc: 'Detect integration test files matching this JavaScript regex pattern. If used multiple times, all files matching any one of the patterns are detected.', default: [] })
         .strict()
-        .argv;
-    const pool = workerpool.pool(path.join(__dirname, '../lib/workers/extract/index.js'), {
-        maxWorkers: argv['max-workers'],
-    });
-    // list of integration tests that will be executed
-    const testsToRun = [];
-    const destructiveChanges = [];
-    const testsFromArgs = [];
+        .parse(args);
+    const tests = argv._;
     const parallelRegions = arrayFromYargs(argv['parallel-regions']);
     const testRegions = parallelRegions !== null && parallelRegions !== void 0 ? parallelRegions : ['us-east-1', 'us-east-2', 'us-west-2'];
     const profiles = arrayFromYargs(argv.profiles);
-    const runUpdateOnFailed = (_a = argv['update-on-failed']) !== null && _a !== void 0 ? _a : false;
     const fromFile = argv['from-file'];
-    const exclude = argv.exclude;
-    let failedSnapshots = [];
-    if (argv['max-workers'] < testRegions.length * (profiles !== null && profiles !== void 0 ? profiles : [1]).length) {
-        logger.warning('You are attempting to run %s tests in parallel, but only have %s workers. Not all of your profiles+regions will be utilized', argv.profiles * argv['parallel-regions'], argv['max-workers']);
+    const maxWorkers = argv['max-workers'];
+    const verbosity = argv.verbose;
+    const verbose = verbosity >= 1;
+    const numTests = testRegions.length * (profiles !== null && profiles !== void 0 ? profiles : [1]).length;
+    if (maxWorkers < numTests) {
+        logger.warning('You are attempting to run %s tests in parallel, but only have %s workers. Not all of your profiles+regions will be utilized', numTests, maxWorkers);
+    }
+    if (tests.length > 0 && fromFile) {
+        throw new Error('A list of tests cannot be provided if "--from-file" is provided');
+    }
+    const requestedTests = fromFile
+        ? (fs.readFileSync(fromFile, { encoding: 'utf8' })).split('\n').filter(x => x)
+        : (tests.length > 0 ? tests : undefined); // 'undefined' means no request
+    return {
+        tests: requestedTests,
+        app: argv.app,
+        testRegex: arrayFromYargs(argv['test-regex']),
+        testRegions,
+        profiles,
+        runUpdateOnFailed: ((_a = argv['update-on-failed']) !== null && _a !== void 0 ? _a : false),
+        fromFile,
+        exclude: argv.exclude,
+        maxWorkers,
+        list: argv.list,
+        directory: argv.directory,
+        inspectFailures: argv['inspect-failures'],
+        verbosity,
+        verbose,
+        clean: argv.clean,
+        force: argv.force,
+        dryRun: argv['dry-run'],
+        disableUpdateWorkflow: argv['disable-update-workflow'],
+    };
+}
+exports.parseCliArgs = parseCliArgs;
+async function main(args) {
+    var _a;
+    const options = parseCliArgs(args);
+    const testsFromArgs = await new integration_tests_1.IntegrationTests(path.resolve(options.directory)).fromCliArgs({
+        app: options.app,
+        testRegex: options.testRegex,
+        tests: options.tests,
+        exclude: options.exclude,
+    });
+    // List only prints the discoverd tests
+    if (options.list) {
+        process.stdout.write(testsFromArgs.map(t => t.discoveryRelativeFileName).join('\n') + '\n');
+        return;
     }
+    const pool = workerpool.pool(path.join(__dirname, '../lib/workers/extract/index.js'), {
+        maxWorkers: options.maxWorkers,
+    });
+    const testsToRun = [];
+    const destructiveChanges = [];
+    let failedSnapshots = [];
     let testsSucceeded = false;
     try {
-        if (argv.list) {
-            const tests = await new integration_tests_1.IntegrationTests(argv.directory).fromCliArgs();
-            process.stdout.write(tests.map(t => t.discoveryRelativeFileName).join('\n') + '\n');
-            return;
-        }
-        if (argv._.length > 0 && fromFile) {
-            throw new Error('A list of tests cannot be provided if "--from-file" is provided');
-        }
-        const requestedTests = fromFile
-            ? (await fs_1.promises.readFile(fromFile, { encoding: 'utf8' })).split('\n').filter(x => x)
-            : (argv._.length > 0 ? argv._ : undefined); // 'undefined' means no request
-        testsFromArgs.push(...(await new integration_tests_1.IntegrationTests(path.resolve(argv.directory)).fromCliArgs(requestedTests, exclude)));
         // always run snapshot tests, but if '--force' is passed then
         // run integration tests on all failed tests, not just those that
         // failed snapshot tests
         failedSnapshots = await workers_1.runSnapshotTests(pool, testsFromArgs, {
-            retain: argv['inspect-failures'],
-            verbose: Boolean(argv.verbose),
+            retain: options.inspectFailures,
+            verbose: options.verbose,
         });
         for (const failure of failedSnapshots) {
-            destructiveChanges.push(...(_b = failure.destructiveChanges) !== null && _b !== void 0 ? _b : []);
+            destructiveChanges.push(...(_a = failure.destructiveChanges) !== null && _a !== void 0 ? _a : []);
         }
-        if (!argv.force) {
+        if (!options.force) {
             testsToRun.push(...failedSnapshots);
         }
         else {
@@ -83,22 +122,22 @@ async function main() {
             testsToRun.push(...mergeTests(testsFromArgs.map(t => t.info), failedSnapshots));
         }
         // run integration tests if `--update-on-failed` OR `--force` is used
-        if (runUpdateOnFailed || argv.force) {
+        if (options.runUpdateOnFailed || options.force) {
             const { success, metrics } = await workers_1.runIntegrationTests({
                 pool,
                 tests: testsToRun,
-                regions: testRegions,
-                profiles,
-                clean: argv.clean,
-                dryRun: argv['dry-run'],
-                verbosity: argv.verbose,
-                updateWorkflow: !argv['disable-update-workflow'],
+                regions: options.testRegions,
+                profiles: options.profiles,
+                clean: options.clean,
+                dryRun: options.dryRun,
+                verbosity: options.verbosity,
+                updateWorkflow: !options.disableUpdateWorkflow,
             });
             testsSucceeded = success;
-            if (argv.clean === false) {
+            if (options.clean === false) {
                 logger.warning('Not cleaning up stacks since "--no-clean" was used');
             }
-            if (Boolean(argv.verbose)) {
+            if (Boolean(options.verbose)) {
                 printMetrics(metrics);
             }
             if (!success) {
@@ -115,14 +154,15 @@ async function main() {
     }
     if (failedSnapshots.length > 0) {
         let message = '';
-        if (!runUpdateOnFailed) {
-            message = 'To re-run failed tests run: yarn integ-runner --update-on-failed';
+        if (!options.runUpdateOnFailed) {
+            message = 'To re-run failed tests run: integ-runner --update-on-failed';
         }
         if (!testsSucceeded) {
             throw new Error(`Some tests failed!\n${message}`);
         }
     }
 }
+exports.main = main;
 function printDestructiveChanges(changes) {
     if (changes.length > 0) {
         logger.warning('!!! This test contains %s !!!', chalk.bold('destructive changes'));
@@ -167,11 +207,11 @@ function mergeTests(testFromArgs, failedSnapshotTests) {
     final.push(...testFromArgs.filter(test => !failedTestNames.has(test.fileName)));
     return final;
 }
-function cli() {
-    main().then().catch(err => {
+function cli(args = process.argv.slice(2)) {
+    main(args).then().catch(err => {
         logger.error(err);
         process.exitCode = 1;
     });
 }
 exports.cli = cli;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["cli.ts"],"names":[],"mappings":"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","sourcesContent":["// Exercise all integ stacks and if they deploy, update the expected synth files\nimport { promises as fs } from 'fs';\nimport * as path from 'path';\nimport * as chalk from 'chalk';\nimport * as workerpool from 'workerpool';\nimport * as logger from './logger';\nimport { IntegrationTests, IntegTestInfo, IntegTest } from './runner/integration-tests';\nimport { runSnapshotTests, runIntegrationTests, IntegRunnerMetrics, IntegTestWorkerConfig, DestructiveChange } from './workers';\n\n// https://github.com/yargs/yargs/issues/1929\n// https://github.com/evanw/esbuild/issues/1492\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nconst yargs = require('yargs');\n\n\nasync function main() {\n  const argv = yargs\n    .usage('Usage: integ-runner [TEST...]')\n    .option('list', { type: 'boolean', default: false, desc: 'List tests instead of running them' })\n    .option('clean', { type: 'boolean', default: true, desc: 'Skips stack clean up after test is completed (use --no-clean to negate)' })\n    .option('verbose', { type: 'boolean', default: false, alias: 'v', count: true, desc: 'Verbose logs and metrics on integration tests durations (specify multiple times to increase verbosity)' })\n    .option('dry-run', { type: 'boolean', default: false, desc: 'do not actually deploy the stack. just update the snapshot (not recommended!)' })\n    .option('update-on-failed', { type: 'boolean', default: false, desc: 'rerun integration tests and update snapshots for failed tests.' })\n    .option('force', { type: 'boolean', default: false, desc: 'Rerun all integration tests even if tests are passing' })\n    .option('parallel-regions', { type: 'array', desc: 'Tests are run in parallel across these regions. To prevent tests from running in parallel, provide only a single region', default: [] })\n    .options('directory', { type: 'string', default: 'test', desc: 'starting directory to discover integration tests. Tests will be discovered recursively from this directory' })\n    .options('profiles', { type: 'array', desc: 'list of AWS profiles to use. Tests will be run in parallel across each profile+regions', default: [] })\n    .options('max-workers', { type: 'number', desc: 'The max number of workerpool workers to use when running integration tests in parallel', default: 16 })\n    .options('exclude', { type: 'boolean', desc: 'Run all tests in the directory, except the specified TESTs', default: false })\n    .options('from-file', { type: 'string', desc: 'Read TEST names from a file (one TEST per line)' })\n    .option('inspect-failures', { type: 'boolean', desc: 'Keep the integ test cloud assembly if a failure occurs for inspection', default: false })\n    .option('disable-update-workflow', { type: 'boolean', default: false, desc: 'If this is \"true\" then the stack update workflow will be disabled' })\n    .strict()\n    .argv;\n\n  const pool = workerpool.pool(path.join(__dirname, '../lib/workers/extract/index.js'), {\n    maxWorkers: argv['max-workers'],\n  });\n\n  // list of integration tests that will be executed\n  const testsToRun: IntegTestWorkerConfig[] = [];\n  const destructiveChanges: DestructiveChange[] = [];\n  const testsFromArgs: IntegTest[] = [];\n  const parallelRegions = arrayFromYargs(argv['parallel-regions']);\n  const testRegions: string[] = parallelRegions ?? ['us-east-1', 'us-east-2', 'us-west-2'];\n  const profiles = arrayFromYargs(argv.profiles);\n  const runUpdateOnFailed = argv['update-on-failed'] ?? false;\n  const fromFile: string | undefined = argv['from-file'];\n  const exclude: boolean = argv.exclude;\n\n  let failedSnapshots: IntegTestWorkerConfig[] = [];\n  if (argv['max-workers'] < testRegions.length * (profiles ?? [1]).length) {\n    logger.warning('You are attempting to run %s tests in parallel, but only have %s workers. Not all of your profiles+regions will be utilized', argv.profiles * argv['parallel-regions'], argv['max-workers']);\n  }\n\n  let testsSucceeded = false;\n  try {\n    if (argv.list) {\n      const tests = await new IntegrationTests(argv.directory).fromCliArgs();\n      process.stdout.write(tests.map(t => t.discoveryRelativeFileName).join('\\n') + '\\n');\n      return;\n    }\n\n    if (argv._.length > 0 && fromFile) {\n      throw new Error('A list of tests cannot be provided if \"--from-file\" is provided');\n    }\n    const requestedTests = fromFile\n      ? (await fs.readFile(fromFile, { encoding: 'utf8' })).split('\\n').filter(x => x)\n      : (argv._.length > 0 ? argv._ : undefined); // 'undefined' means no request\n\n    testsFromArgs.push(...(await new IntegrationTests(path.resolve(argv.directory)).fromCliArgs(requestedTests, exclude)));\n\n    // always run snapshot tests, but if '--force' is passed then\n    // run integration tests on all failed tests, not just those that\n    // failed snapshot tests\n    failedSnapshots = await runSnapshotTests(pool, testsFromArgs, {\n      retain: argv['inspect-failures'],\n      verbose: Boolean(argv.verbose),\n    });\n    for (const failure of failedSnapshots) {\n      destructiveChanges.push(...failure.destructiveChanges ?? []);\n    }\n    if (!argv.force) {\n      testsToRun.push(...failedSnapshots);\n    } else {\n      // if any of the test failed snapshot tests, keep those results\n      // and merge with the rest of the tests from args\n      testsToRun.push(...mergeTests(testsFromArgs.map(t => t.info), failedSnapshots));\n    }\n\n    // run integration tests if `--update-on-failed` OR `--force` is used\n    if (runUpdateOnFailed || argv.force) {\n      const { success, metrics } = await runIntegrationTests({\n        pool,\n        tests: testsToRun,\n        regions: testRegions,\n        profiles,\n        clean: argv.clean,\n        dryRun: argv['dry-run'],\n        verbosity: argv.verbose,\n        updateWorkflow: !argv['disable-update-workflow'],\n      });\n      testsSucceeded = success;\n\n\n      if (argv.clean === false) {\n        logger.warning('Not cleaning up stacks since \"--no-clean\" was used');\n      }\n\n      if (Boolean(argv.verbose)) {\n        printMetrics(metrics);\n      }\n\n      if (!success) {\n        throw new Error('Some integration tests failed!');\n      }\n    }\n  } finally {\n    void pool.terminate();\n  }\n\n  if (destructiveChanges.length > 0) {\n    printDestructiveChanges(destructiveChanges);\n    throw new Error('Some changes were destructive!');\n  }\n  if (failedSnapshots.length > 0) {\n    let message = '';\n    if (!runUpdateOnFailed) {\n      message = 'To re-run failed tests run: yarn integ-runner --update-on-failed';\n    }\n    if (!testsSucceeded) {\n      throw new Error(`Some tests failed!\\n${message}`);\n    }\n  }\n\n}\n\nfunction printDestructiveChanges(changes: DestructiveChange[]): void {\n  if (changes.length > 0) {\n    logger.warning('!!! This test contains %s !!!', chalk.bold('destructive changes'));\n    changes.forEach(change => {\n      logger.warning('    Stack: %s - Resource: %s - Impact: %s', change.stackName, change.logicalId, change.impact);\n    });\n    logger.warning('!!! If these destructive changes are necessary, please indicate this on the PR !!!');\n  }\n}\n\nfunction printMetrics(metrics: IntegRunnerMetrics[]): void {\n  logger.highlight('   --- Integration test metrics ---');\n  const sortedMetrics = metrics.sort((a, b) => a.duration - b.duration);\n  sortedMetrics.forEach(metric => {\n    logger.print('Profile %s + Region %s total time: %s', metric.profile, metric.region, metric.duration);\n    const sortedTests = Object.entries(metric.tests).sort((a, b) => a[1] - b[1]);\n    sortedTests.forEach(test => logger.print('  %s: %s', test[0], test[1]));\n  });\n}\n\n/**\n * Translate a Yargs input array to something that makes more sense in a programming language\n * model (telling the difference between absence and an empty array)\n *\n * - An empty array is the default case, meaning the user didn't pass any arguments. We return\n *   undefined.\n * - If the user passed a single empty string, they did something like `--array=`, which we'll\n *   take to mean they passed an empty array.\n */\nfunction arrayFromYargs(xs: string[]): string[] | undefined {\n  if (xs.length === 0) { return undefined; }\n  return xs.filter(x => x !== '');\n}\n\n/**\n * Merge the tests we received from command line arguments with\n * tests that failed snapshot tests. The failed snapshot tests have additional\n * information that we want to keep so this should override any test from args\n */\nfunction mergeTests(testFromArgs: IntegTestInfo[], failedSnapshotTests: IntegTestWorkerConfig[]): IntegTestWorkerConfig[] {\n  const failedTestNames = new Set(failedSnapshotTests.map(test => test.fileName));\n  const final: IntegTestWorkerConfig[] = failedSnapshotTests;\n  final.push(...testFromArgs.filter(test => !failedTestNames.has(test.fileName)));\n  return final;\n}\n\nexport function cli() {\n  main().then().catch(err => {\n    logger.error(err);\n    process.exitCode = 1;\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["cli.ts"],"names":[],"mappings":"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","sourcesContent":["// Exercise all integ stacks and if they deploy, update the expected synth files\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport * as chalk from 'chalk';\nimport * as workerpool from 'workerpool';\nimport * as logger from './logger';\nimport { IntegrationTests, IntegTestInfo } from './runner/integration-tests';\nimport { runSnapshotTests, runIntegrationTests, IntegRunnerMetrics, IntegTestWorkerConfig, DestructiveChange } from './workers';\n\n// https://github.com/yargs/yargs/issues/1929\n// https://github.com/evanw/esbuild/issues/1492\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nconst yargs = require('yargs');\n\nexport function parseCliArgs(args: string[] = []) {\n  const argv = yargs\n    .usage('Usage: integ-runner [TEST...]')\n    .option('config', {\n      config: true,\n      configParser: IntegrationTests.configFromFile,\n      default: 'integ.config.json',\n      desc: 'Load options from a JSON config file. Options provided as CLI arguments take precedent.',\n    })\n    .option('list', { type: 'boolean', default: false, desc: 'List tests instead of running them' })\n    .option('clean', { type: 'boolean', default: true, desc: 'Skips stack clean up after test is completed (use --no-clean to negate)' })\n    .option('verbose', { type: 'boolean', default: false, alias: 'v', count: true, desc: 'Verbose logs and metrics on integration tests durations (specify multiple times to increase verbosity)' })\n    .option('dry-run', { type: 'boolean', default: false, desc: 'do not actually deploy the stack. just update the snapshot (not recommended!)' })\n    .option('update-on-failed', { type: 'boolean', default: false, desc: 'rerun integration tests and update snapshots for failed tests.' })\n    .option('force', { type: 'boolean', default: false, desc: 'Rerun all integration tests even if tests are passing' })\n    .option('parallel-regions', { type: 'array', desc: 'Tests are run in parallel across these regions. To prevent tests from running in parallel, provide only a single region', default: [] })\n    .options('directory', { type: 'string', default: 'test', desc: 'starting directory to discover integration tests. Tests will be discovered recursively from this directory' })\n    .options('profiles', { type: 'array', desc: 'list of AWS profiles to use. Tests will be run in parallel across each profile+regions', default: [] })\n    .options('max-workers', { type: 'number', desc: 'The max number of workerpool workers to use when running integration tests in parallel', default: 16 })\n    .options('exclude', { type: 'boolean', desc: 'Run all tests in the directory, except the specified TESTs', default: false })\n    .options('from-file', { type: 'string', desc: 'Read TEST names from a file (one TEST per line)' })\n    .option('inspect-failures', { type: 'boolean', desc: 'Keep the integ test cloud assembly if a failure occurs for inspection', default: false })\n    .option('disable-update-workflow', { type: 'boolean', default: false, desc: 'If this is \"true\" then the stack update workflow will be disabled' })\n    .option('app', { type: 'string', default: undefined, desc: 'The custom CLI command that will be used to run the test files. You can include {filePath} to specify where in the command the test file path should be inserted. Example: --app=\"python3.8 {filePath}\".' })\n    .option('test-regex', { type: 'array', desc: 'Detect integration test files matching this JavaScript regex pattern. If used multiple times, all files matching any one of the patterns are detected.', default: [] })\n    .strict()\n    .parse(args);\n\n  const tests: string[] = argv._;\n  const parallelRegions = arrayFromYargs(argv['parallel-regions']);\n  const testRegions: string[] = parallelRegions ?? ['us-east-1', 'us-east-2', 'us-west-2'];\n  const profiles = arrayFromYargs(argv.profiles);\n  const fromFile: string | undefined = argv['from-file'];\n  const maxWorkers: number = argv['max-workers'];\n  const verbosity: number = argv.verbose;\n  const verbose: boolean = verbosity >= 1;\n\n  const numTests = testRegions.length * (profiles ?? [1]).length;\n  if (maxWorkers < numTests) {\n    logger.warning('You are attempting to run %s tests in parallel, but only have %s workers. Not all of your profiles+regions will be utilized', numTests, maxWorkers);\n  }\n\n  if (tests.length > 0 && fromFile) {\n    throw new Error('A list of tests cannot be provided if \"--from-file\" is provided');\n  }\n  const requestedTests = fromFile\n    ? (fs.readFileSync(fromFile, { encoding: 'utf8' })).split('\\n').filter(x => x)\n    : (tests.length > 0 ? tests : undefined); // 'undefined' means no request\n\n  return {\n    tests: requestedTests,\n    app: argv.app as (string | undefined),\n    testRegex: arrayFromYargs(argv['test-regex']),\n    testRegions,\n    profiles,\n    runUpdateOnFailed: (argv['update-on-failed'] ?? false) as boolean,\n    fromFile,\n    exclude: argv.exclude as boolean,\n    maxWorkers,\n    list: argv.list as boolean,\n    directory: argv.directory as string,\n    inspectFailures: argv['inspect-failures'] as boolean,\n    verbosity,\n    verbose,\n    clean: argv.clean as boolean,\n    force: argv.force as boolean,\n    dryRun: argv['dry-run'] as boolean,\n    disableUpdateWorkflow: argv['disable-update-workflow'] as boolean,\n  };\n}\n\n\nexport async function main(args: string[]) {\n  const options = parseCliArgs(args);\n\n  const testsFromArgs = await new IntegrationTests(path.resolve(options.directory)).fromCliArgs({\n    app: options.app,\n    testRegex: options.testRegex,\n    tests: options.tests,\n    exclude: options.exclude,\n  });\n\n  // List only prints the discoverd tests\n  if (options.list) {\n    process.stdout.write(testsFromArgs.map(t => t.discoveryRelativeFileName).join('\\n') + '\\n');\n    return;\n  }\n\n  const pool = workerpool.pool(path.join(__dirname, '../lib/workers/extract/index.js'), {\n    maxWorkers: options.maxWorkers,\n  });\n\n  const testsToRun: IntegTestWorkerConfig[] = [];\n  const destructiveChanges: DestructiveChange[] = [];\n  let failedSnapshots: IntegTestWorkerConfig[] = [];\n  let testsSucceeded = false;\n\n  try {\n    // always run snapshot tests, but if '--force' is passed then\n    // run integration tests on all failed tests, not just those that\n    // failed snapshot tests\n    failedSnapshots = await runSnapshotTests(pool, testsFromArgs, {\n      retain: options.inspectFailures,\n      verbose: options.verbose,\n    });\n    for (const failure of failedSnapshots) {\n      destructiveChanges.push(...failure.destructiveChanges ?? []);\n    }\n    if (!options.force) {\n      testsToRun.push(...failedSnapshots);\n    } else {\n      // if any of the test failed snapshot tests, keep those results\n      // and merge with the rest of the tests from args\n      testsToRun.push(...mergeTests(testsFromArgs.map(t => t.info), failedSnapshots));\n    }\n\n    // run integration tests if `--update-on-failed` OR `--force` is used\n    if (options.runUpdateOnFailed || options.force) {\n      const { success, metrics } = await runIntegrationTests({\n        pool,\n        tests: testsToRun,\n        regions: options.testRegions,\n        profiles: options.profiles,\n        clean: options.clean,\n        dryRun: options.dryRun,\n        verbosity: options.verbosity,\n        updateWorkflow: !options.disableUpdateWorkflow,\n      });\n      testsSucceeded = success;\n\n\n      if (options.clean === false) {\n        logger.warning('Not cleaning up stacks since \"--no-clean\" was used');\n      }\n\n      if (Boolean(options.verbose)) {\n        printMetrics(metrics);\n      }\n\n      if (!success) {\n        throw new Error('Some integration tests failed!');\n      }\n    }\n  } finally {\n    void pool.terminate();\n  }\n\n  if (destructiveChanges.length > 0) {\n    printDestructiveChanges(destructiveChanges);\n    throw new Error('Some changes were destructive!');\n  }\n  if (failedSnapshots.length > 0) {\n    let message = '';\n    if (!options.runUpdateOnFailed) {\n      message = 'To re-run failed tests run: integ-runner --update-on-failed';\n    }\n    if (!testsSucceeded) {\n      throw new Error(`Some tests failed!\\n${message}`);\n    }\n  }\n\n}\n\nfunction printDestructiveChanges(changes: DestructiveChange[]): void {\n  if (changes.length > 0) {\n    logger.warning('!!! This test contains %s !!!', chalk.bold('destructive changes'));\n    changes.forEach(change => {\n      logger.warning('    Stack: %s - Resource: %s - Impact: %s', change.stackName, change.logicalId, change.impact);\n    });\n    logger.warning('!!! If these destructive changes are necessary, please indicate this on the PR !!!');\n  }\n}\n\nfunction printMetrics(metrics: IntegRunnerMetrics[]): void {\n  logger.highlight('   --- Integration test metrics ---');\n  const sortedMetrics = metrics.sort((a, b) => a.duration - b.duration);\n  sortedMetrics.forEach(metric => {\n    logger.print('Profile %s + Region %s total time: %s', metric.profile, metric.region, metric.duration);\n    const sortedTests = Object.entries(metric.tests).sort((a, b) => a[1] - b[1]);\n    sortedTests.forEach(test => logger.print('  %s: %s', test[0], test[1]));\n  });\n}\n\n/**\n * Translate a Yargs input array to something that makes more sense in a programming language\n * model (telling the difference between absence and an empty array)\n *\n * - An empty array is the default case, meaning the user didn't pass any arguments. We return\n *   undefined.\n * - If the user passed a single empty string, they did something like `--array=`, which we'll\n *   take to mean they passed an empty array.\n */\nfunction arrayFromYargs(xs: string[]): string[] | undefined {\n  if (xs.length === 0) { return undefined; }\n  return xs.filter(x => x !== '');\n}\n\n/**\n * Merge the tests we received from command line arguments with\n * tests that failed snapshot tests. The failed snapshot tests have additional\n * information that we want to keep so this should override any test from args\n */\nfunction mergeTests(testFromArgs: IntegTestInfo[], failedSnapshotTests: IntegTestWorkerConfig[]): IntegTestWorkerConfig[] {\n  const failedTestNames = new Set(failedSnapshotTests.map(test => test.fileName));\n  const final: IntegTestWorkerConfig[] = failedSnapshotTests;\n  final.push(...testFromArgs.filter(test => !failedTestNames.has(test.fileName)));\n  return final;\n}\n\nexport function cli(args: string[] = process.argv.slice(2)) {\n  main(args).then().catch(err => {\n    logger.error(err);\n    process.exitCode = 1;\n  });\n}\n"]}