@aws-cdk/integ-runner
Version:
CDK Integration Testing Tool
274 lines • 43.9 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseCliArgs = parseCliArgs;
exports.main = main;
exports.cli = cli;
// Exercise all integ stacks and if they deploy, update the expected synth files
const fs = require("fs");
const path = require("path");
const chalk = require("chalk");
const workerpool = require("workerpool");
const logger = require("./logger");
const integration_tests_1 = require("./runner/integration-tests");
const workers_1 = require("./workers");
const integ_watch_worker_1 = require("./workers/integ-watch-worker");
// https://github.com/yargs/yargs/issues/1929
// https://github.com/evanw/esbuild/issues/1492
// eslint-disable-next-line @typescript-eslint/no-require-imports
const yargs = require('yargs');
function parseCliArgs(args = []) {
const argv = yargs
.usage('Usage: integ-runner [TEST...]')
.option('config', {
config: true,
configParser: configFromFile,
default: 'integ.config.json',
desc: 'Load options from a JSON config file. Options provided as CLI arguments take precedent.',
})
.option('watch', { type: 'boolean', default: false, desc: 'Perform integ tests in watch mode' })
.option('list', { type: 'boolean', default: false, desc: 'List tests instead of running them' })
.option('clean', { type: 'boolean', default: true, desc: 'Clean up and delete stack 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)' })
.option('dry-run', { type: 'boolean', default: false, desc: 'do not actually deploy the stack. just update the snapshot (not recommended!)' })
.option('update-on-failed', { type: 'boolean', default: false, desc: 'rerun integration tests and update snapshots for failed tests.' })
.option('force', { type: 'boolean', default: false, desc: 'Rerun all integration tests even if tests are passing' })
.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: [] })
.options('directory', { type: 'string', default: 'test', desc: 'starting directory to discover integration tests. Tests will be discovered recursively from this directory' })
.options('profiles', { type: 'array', desc: 'list of AWS profiles to use. Tests will be run in parallel across each profile+regions', default: [] })
.options('max-workers', { type: 'number', desc: 'The max number of workerpool workers to use when running integration tests in parallel', default: 16 })
.options('exclude', { type: 'boolean', desc: 'Run all tests in the directory, except the specified TESTs', default: false })
.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('language', {
alias: 'l',
default: ['javascript', 'typescript', 'python', 'go'],
choices: ['javascript', 'typescript', 'python', 'go'],
type: 'array',
nargs: 1,
desc: 'Use these presets to run integration tests for the selected languages',
})
.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()
.parse(args);
const tests = argv._;
const parallelRegions = arrayFromYargs(argv['parallel-regions']);
const testRegions = parallelRegions ?? ['us-east-1', 'us-east-2', 'us-west-2'];
const profiles = arrayFromYargs(argv.profiles);
const fromFile = argv['from-file'];
const maxWorkers = argv['max-workers'];
const verbosity = argv.verbose;
const verbose = verbosity >= 1;
const numTests = testRegions.length * (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,
originalRegions: parallelRegions,
profiles,
runUpdateOnFailed: (argv['update-on-failed'] ?? 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'],
language: arrayFromYargs(argv.language),
watch: argv.watch,
};
}
async function main(args) {
const options = parseCliArgs(args);
const testsFromArgs = await new integration_tests_1.IntegrationTests(path.resolve(options.directory)).fromCliOptions(options);
// List only prints the discovered 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.watch ? 1 : options.maxWorkers,
});
const testsToRun = [];
let destructiveChanges = false;
let failedSnapshots = [];
let testsSucceeded = false;
validateWatchArgs({
...options,
testRegions: options.originalRegions,
tests: testsFromArgs,
});
try {
if (!options.watch) {
// 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 (0, workers_1.runSnapshotTests)(pool, testsFromArgs, {
retain: options.inspectFailures,
verbose: options.verbose,
});
for (const failure of failedSnapshots) {
logger.warning(`Failed: ${failure.fileName}`);
if (failure.destructiveChanges && failure.destructiveChanges.length > 0) {
printDestructiveChanges(failure.destructiveChanges);
destructiveChanges = true;
}
}
if (!options.force) {
testsToRun.push(...failedSnapshots);
}
else {
// if any of the test failed snapshot tests, keep those results
// and merge with the rest of the tests from args
testsToRun.push(...mergeTests(testsFromArgs.map(t => t.info), failedSnapshots));
}
}
else {
testsToRun.push(...testsFromArgs.map(t => t.info));
}
// run integration tests if `--update-on-failed` OR `--force` is used
if (options.runUpdateOnFailed || options.force) {
const { success, metrics } = await (0, workers_1.runIntegrationTests)({
pool,
tests: testsToRun,
regions: options.testRegions,
profiles: options.profiles,
clean: options.clean,
dryRun: options.dryRun,
verbosity: options.verbosity,
updateWorkflow: !options.disableUpdateWorkflow,
watch: options.watch,
});
testsSucceeded = success;
if (options.clean === false) {
logger.warning('Not cleaning up stacks since "--no-clean" was used');
}
if (Boolean(options.verbose)) {
printMetrics(metrics);
}
if (!success) {
throw new Error('Some integration tests failed!');
}
}
else if (options.watch) {
await (0, integ_watch_worker_1.watchIntegrationTest)(pool, {
watch: true,
verbosity: options.verbosity,
...testsToRun[0],
profile: options.profiles ? options.profiles[0] : undefined,
region: options.testRegions[0],
});
}
}
finally {
void pool.terminate();
}
if (destructiveChanges) {
throw new Error('Some changes were destructive!');
}
if (failedSnapshots.length > 0) {
let message = '';
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}`);
}
}
}
function validateWatchArgs(args) {
if (args.watch) {
if ((args.testRegions && args.testRegions.length > 1)
|| (args.profiles && args.profiles.length > 1)
|| args.tests.length > 1) {
throw new Error('Running with watch only supports a single test. Only provide a single option' +
'to `--profiles` `--parallel-regions` `--max-workers');
}
if (args.runUpdateOnFailed || args.disableUpdateWorkflow || args.force || args.dryRun) {
logger.warning('args `--update-on-failed`, `--disable-update-workflow`, `--force`, `--dry-run` have no effect when running with `--watch`');
}
}
}
function printDestructiveChanges(changes) {
if (changes.length > 0) {
logger.warning('!!! This test contains %s !!!', chalk.bold('destructive changes'));
changes.forEach(change => {
logger.warning(' Stack: %s - Resource: %s - Impact: %s', change.stackName, change.logicalId, change.impact);
});
logger.warning('!!! If these destructive changes are necessary, please indicate this on the PR !!!');
}
}
function printMetrics(metrics) {
logger.highlight(' --- Integration test metrics ---');
const sortedMetrics = metrics.sort((a, b) => a.duration - b.duration);
sortedMetrics.forEach(metric => {
logger.print('Profile %s + Region %s total time: %s', metric.profile, metric.region, metric.duration);
const sortedTests = Object.entries(metric.tests).sort((a, b) => a[1] - b[1]);
sortedTests.forEach(test => logger.print(' %s: %s', test[0], test[1]));
});
}
/**
* Translate a Yargs input array to something that makes more sense in a programming language
* model (telling the difference between absence and an empty array)
*
* - An empty array is the default case, meaning the user didn't pass any arguments. We return
* undefined.
* - If the user passed a single empty string, they did something like `--array=`, which we'll
* take to mean they passed an empty array.
*/
function arrayFromYargs(xs) {
if (xs.length === 0) {
return undefined;
}
return xs.filter(x => x !== '');
}
/**
* Merge the tests we received from command line arguments with
* tests that failed snapshot tests. The failed snapshot tests have additional
* information that we want to keep so this should override any test from args
*/
function mergeTests(testFromArgs, failedSnapshotTests) {
const failedTestNames = new Set(failedSnapshotTests.map(test => test.fileName));
const final = failedSnapshotTests;
final.push(...testFromArgs.filter(test => !failedTestNames.has(test.fileName)));
return final;
}
function cli(args = process.argv.slice(2)) {
main(args).then().catch(err => {
logger.error(err);
process.exitCode = 1;
});
}
/**
* Read CLI options from a config file if provided.
*
* @returns parsed CLI config options
*/
function configFromFile(fileName) {
if (!fileName) {
return {};
}
try {
return JSON.parse(fs.readFileSync(fileName, { encoding: 'utf-8' }));
}
catch {
return {};
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["cli.ts"],"names":[],"mappings":";;AAiBA,oCAiFC;AAED,oBAuGC;AA4ED,kBAKC;AA5RD,gFAAgF;AAChF,yBAAyB;AACzB,6BAA6B;AAC7B,+BAA+B;AAC/B,yCAAyC;AACzC,mCAAmC;AAEnC,kEAA8D;AAE9D,uCAAkE;AAClE,qEAAoE;AAEpE,6CAA6C;AAC7C,+CAA+C;AAC/C,iEAAiE;AACjE,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAE/B,SAAgB,YAAY,CAAC,OAAiB,EAAE;IAC9C,MAAM,IAAI,GAAG,KAAK;SACf,KAAK,CAAC,+BAA+B,CAAC;SACtC,MAAM,CAAC,QAAQ,EAAE;QAChB,MAAM,EAAE,IAAI;QACZ,YAAY,EAAE,cAAc;QAC5B,OAAO,EAAE,mBAAmB;QAC5B,IAAI,EAAE,yFAAyF;KAChG,CAAC;SACD,MAAM,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,mCAAmC,EAAE,CAAC;SAC/F,MAAM,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,oCAAoC,EAAE,CAAC;SAC/F,MAAM,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,8EAA8E,EAAE,CAAC;SACzI,MAAM,CAAC,SAAS,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,wGAAwG,EAAE,CAAC;SAC/L,MAAM,CAAC,SAAS,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,+EAA+E,EAAE,CAAC;SAC7I,MAAM,CAAC,kBAAkB,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,gEAAgE,EAAE,CAAC;SACvI,MAAM,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,uDAAuD,EAAE,CAAC;SACnH,MAAM,CAAC,kBAAkB,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,yHAAyH,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;SAC3L,OAAO,CAAC,WAAW,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,4GAA4G,EAAE,CAAC;SAC7K,OAAO,CAAC,UAAU,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,wFAAwF,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;SACnJ,OAAO,CAAC,aAAa,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,wFAAwF,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;SACvJ,OAAO,CAAC,SAAS,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,4DAA4D,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;SAC3H,OAAO,CAAC,WAAW,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,iDAAiD,EAAE,CAAC;SACjG,MAAM,CAAC,kBAAkB,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,uEAAuE,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;SAC9I,MAAM,CAAC,yBAAyB,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,mEAAmE,EAAE,CAAC;SACjJ,MAAM,CAAC,UAAU,EAAE;QAClB,KAAK,EAAE,GAAG;QACV,OAAO,EAAE,CAAC,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,IAAI,CAAC;QACrD,OAAO,EAAE,CAAC,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,IAAI,CAAC;QACrD,IAAI,EAAE,OAAO;QACb,KAAK,EAAE,CAAC;QACR,IAAI,EAAE,uEAAuE;KAC9E,CAAC;SACD,MAAM,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,0MAA0M,EAAE,CAAC;SACvQ,MAAM,CAAC,YAAY,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,wJAAwJ,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;SACpN,MAAM,EAAE;SACR,KAAK,CAAC,IAAI,CAAC,CAAC;IAEf,MAAM,KAAK,GAAa,IAAI,CAAC,CAAC,CAAC;IAC/B,MAAM,eAAe,GAAG,cAAc,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC;IACjE,MAAM,WAAW,GAAa,eAAe,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC;IACzF,MAAM,QAAQ,GAAG,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC/C,MAAM,QAAQ,GAAuB,IAAI,CAAC,WAAW,CAAC,CAAC;IACvD,MAAM,UAAU,GAAW,IAAI,CAAC,aAAa,CAAC,CAAC;IAC/C,MAAM,SAAS,GAAW,IAAI,CAAC,OAAO,CAAC;IACvC,MAAM,OAAO,GAAY,SAAS,IAAI,CAAC,CAAC;IAExC,MAAM,QAAQ,GAAG,WAAW,CAAC,MAAM,GAAG,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IAC/D,IAAI,UAAU,GAAG,QAAQ,EAAE,CAAC;QAC1B,MAAM,CAAC,OAAO,CAAC,6HAA6H,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;IACtK,CAAC;IAED,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,QAAQ,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CAAC,iEAAiE,CAAC,CAAC;IACrF,CAAC;IACD,MAAM,cAAc,GAAG,QAAQ;QAC7B,CAAC,CAAC,CAAC,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC9E,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,+BAA+B;IAE3E,OAAO;QACL,KAAK,EAAE,cAAc;QACrB,GAAG,EAAE,IAAI,CAAC,GAA2B;QACrC,SAAS,EAAE,cAAc,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC7C,WAAW;QACX,eAAe,EAAE,eAAe;QAChC,QAAQ;QACR,iBAAiB,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,KAAK,CAAY;QACjE,QAAQ;QACR,OAAO,EAAE,IAAI,CAAC,OAAkB;QAChC,UAAU;QACV,IAAI,EAAE,IAAI,CAAC,IAAe;QAC1B,SAAS,EAAE,IAAI,CAAC,SAAmB;QACnC,eAAe,EAAE,IAAI,CAAC,kBAAkB,CAAY;QACpD,SAAS;QACT,OAAO;QACP,KAAK,EAAE,IAAI,CAAC,KAAgB;QAC5B,KAAK,EAAE,IAAI,CAAC,KAAgB;QAC5B,MAAM,EAAE,IAAI,CAAC,SAAS,CAAY;QAClC,qBAAqB,EAAE,IAAI,CAAC,yBAAyB,CAAY;QACjE,QAAQ,EAAE,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC;QACvC,KAAK,EAAE,IAAI,CAAC,KAAgB;KAC7B,CAAC;AACJ,CAAC;AAEM,KAAK,UAAU,IAAI,CAAC,IAAc;IACvC,MAAM,OAAO,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;IAEnC,MAAM,aAAa,GAAG,MAAM,IAAI,oCAAgB,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;IAE1G,wCAAwC;IACxC,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;QACjB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,yBAAyB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QAC5F,OAAO;IACT,CAAC;IAED,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE;QAChG,UAAU,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU;KACnD,CAAC,CAAC;IAEH,MAAM,UAAU,GAA4B,EAAE,CAAC;IAC/C,IAAI,kBAAkB,GAAY,KAAK,CAAC;IACxC,IAAI,eAAe,GAA4B,EAAE,CAAC;IAClD,IAAI,cAAc,GAAG,KAAK,CAAC;IAC3B,iBAAiB,CAAC;QAChB,GAAG,OAAO;QACV,WAAW,EAAE,OAAO,CAAC,eAAe;QACpC,KAAK,EAAE,aAAa;KACrB,CAAC,CAAC;IAEH,IAAI,CAAC;QACH,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;YACnB,6DAA6D;YAC7D,iEAAiE;YACjE,wBAAwB;YACxB,eAAe,GAAG,MAAM,IAAA,0BAAgB,EAAC,IAAI,EAAE,aAAa,EAAE;gBAC5D,MAAM,EAAE,OAAO,CAAC,eAAe;gBAC/B,OAAO,EAAE,OAAO,CAAC,OAAO;aACzB,CAAC,CAAC;YACH,KAAK,MAAM,OAAO,IAAI,eAAe,EAAE,CAAC;gBACtC,MAAM,CAAC,OAAO,CAAC,WAAW,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAC9C,IAAI,OAAO,CAAC,kBAAkB,IAAI,OAAO,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACxE,uBAAuB,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC;oBACpD,kBAAkB,GAAG,IAAI,CAAC;gBAC5B,CAAC;YACH,CAAC;YACD,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;gBACnB,UAAU,CAAC,IAAI,CAAC,GAAG,eAAe,CAAC,CAAC;YACtC,CAAC;iBAAM,CAAC;gBACN,+DAA+D;gBAC/D,iDAAiD;gBACjD,UAAU,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC;YAClF,CAAC;QACH,CAAC;aAAM,CAAC;YACN,UAAU,CAAC,IAAI,CAAC,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QACrD,CAAC;QAED,qEAAqE;QACrE,IAAI,OAAO,CAAC,iBAAiB,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;YAC/C,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,MAAM,IAAA,6BAAmB,EAAC;gBACrD,IAAI;gBACJ,KAAK,EAAE,UAAU;gBACjB,OAAO,EAAE,OAAO,CAAC,WAAW;gBAC5B,QAAQ,EAAE,OAAO,CAAC,QAAQ;gBAC1B,KAAK,EAAE,OAAO,CAAC,KAAK;gBACpB,MAAM,EAAE,OAAO,CAAC,MAAM;gBACtB,SAAS,EAAE,OAAO,CAAC,SAAS;gBAC5B,cAAc,EAAE,CAAC,OAAO,CAAC,qBAAqB;gBAC9C,KAAK,EAAE,OAAO,CAAC,KAAK;aACrB,CAAC,CAAC;YACH,cAAc,GAAG,OAAO,CAAC;YAEzB,IAAI,OAAO,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;gBAC5B,MAAM,CAAC,OAAO,CAAC,oDAAoD,CAAC,CAAC;YACvE,CAAC;YAED,IAAI,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC7B,YAAY,CAAC,OAAO,CAAC,CAAC;YACxB,CAAC;YAED,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;YACpD,CAAC;QACH,CAAC;aAAM,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;YACzB,MAAM,IAAA,yCAAoB,EAAC,IAAI,EAAE;gBAC/B,KAAK,EAAE,IAAI;gBACX,SAAS,EAAE,OAAO,CAAC,SAAS;gBAC5B,GAAG,UAAU,CAAC,CAAC,CAAC;gBAChB,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS;gBAC3D,MAAM,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;aAC/B,CAAC,CAAC;QACL,CAAC;IACH,CAAC;YAAS,CAAC;QACT,KAAK,IAAI,CAAC,SAAS,EAAE,CAAC;IACxB,CAAC;IAED,IAAI,kBAAkB,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IACpD,CAAC;IACD,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC/B,IAAI,OAAO,GAAG,EAAE,CAAC;QACjB,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,CAAC;YAC/B,OAAO,GAAG,6DAA6D,CAAC;QAC1E,CAAC;QACD,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,uBAAuB,OAAO,EAAE,CAAC,CAAC;QACpD,CAAC;IACH,CAAC;AACH,CAAC;AAED,SAAS,iBAAiB,CAAC,IAU1B;IACC,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;QACf,IACE,CAAC,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC;eAC5C,CAAC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;eAC3C,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,8EAA8E;gBAC5F,qDAAqD,CAAC,CAAC;QAC3D,CAAC;QAED,IAAI,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,qBAAqB,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YACtF,MAAM,CAAC,OAAO,CAAC,2HAA2H,CAAC,CAAC;QAC9I,CAAC;IACH,CAAC;AACH,CAAC;AAED,SAAS,uBAAuB,CAAC,OAA4B;IAC3D,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,MAAM,CAAC,OAAO,CAAC,+BAA+B,EAAE,KAAK,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC;QACnF,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YACvB,MAAM,CAAC,OAAO,CAAC,2CAA2C,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;QACjH,CAAC,CAAC,CAAC;QACH,MAAM,CAAC,OAAO,CAAC,oFAAoF,CAAC,CAAC;IACvG,CAAC;AACH,CAAC;AAED,SAAS,YAAY,CAAC,OAA6B;IACjD,MAAM,CAAC,SAAS,CAAC,qCAAqC,CAAC,CAAC;IACxD,MAAM,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC;IACtE,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;QAC7B,MAAM,CAAC,KAAK,CAAC,uCAAuC,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;QACtG,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7E,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1E,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,cAAc,CAAC,EAAY;IAClC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACpB,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC;AAClC,CAAC;AAED;;;;GAIG;AACH,SAAS,UAAU,CAAC,YAA6B,EAAE,mBAA4C;IAC7F,MAAM,eAAe,GAAG,IAAI,GAAG,CAAC,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;IAChF,MAAM,KAAK,GAA4B,mBAAmB,CAAC;IAC3D,KAAK,CAAC,IAAI,CAAC,GAAG,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAChF,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAgB,GAAG,CAAC,OAAiB,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IACxD,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE;QAC5B,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAClB,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;IACvB,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;GAIG;AACH,SAAS,cAAc,CAAC,QAAiB;IACvC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;IACtE,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAC;IACZ,CAAC;AACH,CAAC","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 type { IntegTest, IntegTestInfo } from './runner/integration-tests';\nimport { IntegrationTests } from './runner/integration-tests';\nimport type { IntegRunnerMetrics, IntegTestWorkerConfig, DestructiveChange } from './workers';\nimport { runSnapshotTests, runIntegrationTests } from './workers';\nimport { watchIntegrationTest } from './workers/integ-watch-worker';\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: 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('watch', { type: 'boolean', default: false, desc: 'Perform integ tests in watch mode' })\n    .option('list', { type: 'boolean', default: false, desc: 'List tests instead of running them' })\n    .option('clean', { type: 'boolean', default: true, desc: 'Clean up and delete stack 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('language', {\n      alias: 'l',\n      default: ['javascript', 'typescript', 'python', 'go'],\n      choices: ['javascript', 'typescript', 'python', 'go'],\n      type: 'array',\n      nargs: 1,\n      desc: 'Use these presets to run integration tests for the selected languages',\n    })\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    originalRegions: parallelRegions,\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    language: arrayFromYargs(argv.language),\n    watch: argv.watch as boolean,\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)).fromCliOptions(options);\n\n  // List only prints the discovered 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.watch ? 1 : options.maxWorkers,\n  });\n\n  const testsToRun: IntegTestWorkerConfig[] = [];\n  let destructiveChanges: boolean = false;\n  let failedSnapshots: IntegTestWorkerConfig[] = [];\n  let testsSucceeded = false;\n  validateWatchArgs({\n    ...options,\n    testRegions: options.originalRegions,\n    tests: testsFromArgs,\n  });\n\n  try {\n    if (!options.watch) {\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        logger.warning(`Failed: ${failure.fileName}`);\n        if (failure.destructiveChanges && failure.destructiveChanges.length > 0) {\n          printDestructiveChanges(failure.destructiveChanges);\n          destructiveChanges = true;\n        }\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    } else {\n      testsToRun.push(...testsFromArgs.map(t => t.info));\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        watch: options.watch,\n      });\n      testsSucceeded = success;\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    } else if (options.watch) {\n      await watchIntegrationTest(pool, {\n        watch: true,\n        verbosity: options.verbosity,\n        ...testsToRun[0],\n        profile: options.profiles ? options.profiles[0] : undefined,\n        region: options.testRegions[0],\n      });\n    }\n  } finally {\n    void pool.terminate();\n  }\n\n  if (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\nfunction validateWatchArgs(args: {\n  tests: IntegTest[];\n  testRegions?: string[];\n  profiles?: string[];\n  maxWorkers: number;\n  force: boolean;\n  dryRun: boolean;\n  disableUpdateWorkflow: boolean;\n  runUpdateOnFailed: boolean;\n  watch: boolean;\n}) {\n  if (args.watch) {\n    if (\n      (args.testRegions && args.testRegions.length > 1)\n        || (args.profiles && args.profiles.length > 1)\n        || args.tests.length > 1) {\n      throw new Error('Running with watch only supports a single test. Only provide a single option'+\n        'to `--profiles` `--parallel-regions` `--max-workers');\n    }\n\n    if (args.runUpdateOnFailed || args.disableUpdateWorkflow || args.force || args.dryRun) {\n      logger.warning('args `--update-on-failed`, `--disable-update-workflow`, `--force`, `--dry-run` have no effect when running with `--watch`');\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) {\n    return undefined;\n  }\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\n/**\n * Read CLI options from a config file if provided.\n *\n * @returns parsed CLI config options\n */\nfunction configFromFile(fileName?: string): Record<string, any> {\n  if (!fileName) {\n    return {};\n  }\n\n  try {\n    return JSON.parse(fs.readFileSync(fileName, { encoding: 'utf-8' }));\n  } catch {\n    return {};\n  }\n}\n"]}