@aws-cdk/integ-runner
Version:
CDK Integration Testing Tool
310 lines • 52.2 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 })
.option('strict', { type: 'boolean', default: false, desc: 'Fail if any specified tests are not found' })
.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: undefined, desc: 'DEPRECATED, use --[no]-update-workflow instead' })
.option('update-workflow', { type: 'boolean', default: undefined, desc: 'Deploys the committed snapshot before the updated application. Only works if snapshots are region-agnostic.' })
.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: [] })
.option('unstable', { type: 'array', desc: 'Opt-in to using unstable features. By using these flags you acknowledges that scope and APIs of unstable features may change without notice. Specify multiple times for each unstable feature you want to opt-in to.', nargs: 1, choices: ['toolkit-lib-engine', 'deprecated-cli-engine'], 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');
}
if (argv.strict && argv.exclude) {
throw new Error('Cannot use --strict with --exclude');
}
const requestedTests = fromFile
? (fs.readFileSync(fromFile, { encoding: 'utf8' })).split('\n').filter(x => x)
: (tests.length > 0 ? tests : undefined); // 'undefined' means no request
if (argv['disable-update-workflow'] !== undefined && argv['update-workflow'] !== undefined) {
throw new Error('--disable-update-workflow and --[no-]update-workflow cannot be used together');
}
let updateWorkflow = argv['update-workflow'] !== undefined ? !!argv['update-workflow'] : !argv['disable-update-workflow'];
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'],
updateWorkflow,
language: arrayFromYargs(argv.language),
watch: argv.watch,
strict: argv.strict,
unstable: arrayFromYargs(argv.unstable) ?? [],
};
}
async function main(args) {
let engineForError;
try {
const options = parseCliArgs(args);
const engine = engineFromOptions(options);
engineForError = engine.engine;
await run(options, engine);
}
catch (err) {
logger.error(err);
if (engineForError === 'toolkit-lib') {
logger.warning('\n[Notice] You are using the new default engine to run integration tests. If you think the above failure has been caused by the new engine, you may choose to temporarily revert to the old engine by adding the `--unstable=deprecated-cli-engine` option. Please note that this engine is deprecated and scheduled to be removed in January 2026.\n\nIf reverting to the old engine resolves an issue for you, please let us know so we can address this in the new engine. Report issues here: https://github.com/aws/aws-cdk-cli/issues/new/choose');
}
throw err;
}
}
async function run(options, { engine }) {
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,
engine,
});
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,
engine,
tests: testsToRun,
regions: options.testRegions,
profiles: options.profiles,
clean: options.clean,
dryRun: options.dryRun,
verbosity: options.verbosity,
updateWorkflow: options.updateWorkflow,
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,
engine,
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.updateWorkflow || args.force || args.dryRun) {
logger.warning('args `--update-on-failed`, `--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(() => {
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 {};
}
}
function engineFromOptions(options) {
if (options.unstable?.includes('deprecated-cli-engine')) {
logger.warning('[Deprecation Notice] You have opted-in to use the deprecated CLI engine which is scheduled to be removed in January 2026. If you have encountered blockers while using the new default engine, please let us know by opening an issue: https://github.com/aws/aws-cdk-cli/issues/new/choose\n\nTo use the new default engine, remove the `--unstable=deprecated-cli-engine` option.');
return { engine: 'cli-wrapper' };
}
return { engine: 'toolkit-lib' };
}
//# sourceMappingURL=data:application/json;base64,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