diff --git a/.projenrc.ts b/.projenrc.ts index f6604eeb2..fbece9b4f 100644 --- a/.projenrc.ts +++ b/.projenrc.ts @@ -536,7 +536,7 @@ const cdkAssets = configureProject( description: 'CDK Asset Publishing Tool', srcdir: 'lib', deps: [ - cloudAssemblySchema, + cloudAssemblySchema.customizeReference({ versionType: 'exact' }), cxApi, 'archiver', 'glob', @@ -722,8 +722,8 @@ const cli = configureProject( 'xml-js', ], deps: [ - cloudAssemblySchema, - cloudFormationDiff, + cloudAssemblySchema.customizeReference({ versionType: 'exact' }), + cloudFormationDiff.customizeReference({ versionType: 'exact' }), cxApi, '@aws-cdk/region-info', 'archiver', @@ -962,7 +962,7 @@ const cliLib = configureProject( entrypoint: 'lib/main.js', // Bundled entrypoint description: 'AWS CDK Programmatic CLI library', srcdir: 'lib', - devDeps: ['aws-cdk-lib', cli, 'constructs'], + devDeps: ['aws-cdk-lib', cli.customizeReference({ versionType: 'exact' }), 'constructs'], disableTsconfig: true, nextVersionCommand: `tsx ../../../projenrc/next-version.ts copyVersion:../../../${cliPackageJson} append:-alpha.0`, releasableCommits: transitiveToolkitPackages('@aws-cdk/cli-lib-alpha'), @@ -1060,6 +1060,8 @@ const toolkitLib = configureProject( srcdir: 'lib', deps: [ cloudAssemblySchema, + // Purposely a ^ dependency so that clients selecting old toolkit library + // versions still might get upgrades to this dependency. cloudFormationDiff, cxApi, '@aws-cdk/region-info', @@ -1093,6 +1095,7 @@ const toolkitLib = configureProject( '@smithy/util-waiter', 'archiver', 'camelcase@^6', // Non-ESM + // Purposely a ^ dependency so that clients get upgrades to this library. cdkAssets, 'cdk-from-cfn', 'chalk@^4', @@ -1305,7 +1308,7 @@ const cdkAliasPackage = configureProject( name: 'cdk', description: 'AWS CDK Toolkit', srcdir: 'lib', - deps: [cli], + deps: [cli.customizeReference({ versionType: 'exact' })], nextVersionCommand: `tsx ../../projenrc/next-version.ts copyVersion:../../${cliPackageJson}`, releasableCommits: transitiveToolkitPackages('cdk'), }), diff --git a/package.json b/package.json index 76c3d1dd4..524d8ec12 100644 --- a/package.json +++ b/package.json @@ -29,7 +29,7 @@ "@types/node": "ts5.6", "@typescript-eslint/eslint-plugin": "^8", "@typescript-eslint/parser": "^8", - "cdklabs-projen-project-types": "^0.2.3", + "cdklabs-projen-project-types": "^0.2.8", "constructs": "^10.0.0", "eslint": "^9", "eslint-import-resolver-typescript": "^3.8.3", diff --git a/packages/@aws-cdk/cdk-cli-wrapper/.projen/tasks.json b/packages/@aws-cdk/cdk-cli-wrapper/.projen/tasks.json index f5f11d08d..2c37ef366 100644 --- a/packages/@aws-cdk/cdk-cli-wrapper/.projen/tasks.json +++ b/packages/@aws-cdk/cdk-cli-wrapper/.projen/tasks.json @@ -77,7 +77,7 @@ "name": "gather-versions", "steps": [ { - "exec": "node -e \"require(path.join(path.dirname(require.resolve('cdklabs-projen-project-types')), 'yarn', 'gather-versions.exec.js'))\" @aws-cdk/cdk-cli-wrapper MAJOR --deps aws-cdk", + "exec": "node -e \"require(require.resolve('cdklabs-projen-project-types/lib/yarn/gather-versions.exec.js')).cliMain()\" aws-cdk=exact", "receiveArgs": true } ] diff --git a/packages/@aws-cdk/cli-lib-alpha/.projen/tasks.json b/packages/@aws-cdk/cli-lib-alpha/.projen/tasks.json index 68719d7c5..d23b1e928 100644 --- a/packages/@aws-cdk/cli-lib-alpha/.projen/tasks.json +++ b/packages/@aws-cdk/cli-lib-alpha/.projen/tasks.json @@ -118,7 +118,7 @@ "name": "gather-versions", "steps": [ { - "exec": "node -e \"require(path.join(path.dirname(require.resolve('cdklabs-projen-project-types')), 'yarn', 'gather-versions.exec.js'))\" @aws-cdk/cli-lib-alpha MAJOR --deps aws-cdk", + "exec": "node -e \"require(require.resolve('cdklabs-projen-project-types/lib/yarn/gather-versions.exec.js')).cliMain()\" aws-cdk=exact", "receiveArgs": true } ] diff --git a/packages/@aws-cdk/cli-plugin-contract/.projen/tasks.json b/packages/@aws-cdk/cli-plugin-contract/.projen/tasks.json index ec9b1f0a8..c5b2af9fd 100644 --- a/packages/@aws-cdk/cli-plugin-contract/.projen/tasks.json +++ b/packages/@aws-cdk/cli-plugin-contract/.projen/tasks.json @@ -100,7 +100,7 @@ "name": "gather-versions", "steps": [ { - "exec": "node -e \"require(path.join(path.dirname(require.resolve('cdklabs-projen-project-types')), 'yarn', 'gather-versions.exec.js'))\" @aws-cdk/cli-plugin-contract MAJOR --deps ", + "exec": "node -e \"require(require.resolve('cdklabs-projen-project-types/lib/yarn/gather-versions.exec.js')).cliMain()\" ", "receiveArgs": true } ] diff --git a/packages/@aws-cdk/cloud-assembly-schema/.projen/tasks.json b/packages/@aws-cdk/cloud-assembly-schema/.projen/tasks.json index 3ba9086cb..e26c2b307 100644 --- a/packages/@aws-cdk/cloud-assembly-schema/.projen/tasks.json +++ b/packages/@aws-cdk/cloud-assembly-schema/.projen/tasks.json @@ -109,7 +109,7 @@ "name": "gather-versions", "steps": [ { - "exec": "node -e \"require(path.join(path.dirname(require.resolve('cdklabs-projen-project-types')), 'yarn', 'gather-versions.exec.js'))\" @aws-cdk/cloud-assembly-schema MAJOR --deps ", + "exec": "node -e \"require(require.resolve('cdklabs-projen-project-types/lib/yarn/gather-versions.exec.js')).cliMain()\" ", "receiveArgs": true } ] diff --git a/packages/@aws-cdk/cloudformation-diff/.projen/tasks.json b/packages/@aws-cdk/cloudformation-diff/.projen/tasks.json index 4293eb3c1..cc14b1d47 100644 --- a/packages/@aws-cdk/cloudformation-diff/.projen/tasks.json +++ b/packages/@aws-cdk/cloudformation-diff/.projen/tasks.json @@ -101,7 +101,7 @@ "name": "gather-versions", "steps": [ { - "exec": "node -e \"require(path.join(path.dirname(require.resolve('cdklabs-projen-project-types')), 'yarn', 'gather-versions.exec.js'))\" @aws-cdk/cloudformation-diff MAJOR --deps ", + "exec": "node -e \"require(require.resolve('cdklabs-projen-project-types/lib/yarn/gather-versions.exec.js')).cliMain()\" ", "receiveArgs": true } ] diff --git a/packages/@aws-cdk/integ-runner/lib/cli.d.ts b/packages/@aws-cdk/integ-runner/lib/cli.d.ts new file mode 100644 index 000000000..db5076a2d --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/cli.d.ts @@ -0,0 +1,25 @@ +export declare function parseCliArgs(args?: string[]): { + tests: string[] | undefined; + app: (string | undefined); + testRegex: string[] | undefined; + testRegions: string[]; + originalRegions: string[] | undefined; + 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; + language: string[] | undefined; + watch: boolean; +}; +export declare function main(args: string[]): Promise; +export declare function cli(args?: string[]): void; diff --git a/packages/@aws-cdk/integ-runner/lib/cli.js b/packages/@aws-cdk/integ-runner/lib/cli.js new file mode 100644 index 000000000..d8edf8a3b --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/cli.js @@ -0,0 +1,274 @@ +"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: '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)' }) + .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":"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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 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: '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('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"]} \ No newline at end of file diff --git a/packages/@aws-cdk/integ-runner/lib/index.d.ts b/packages/@aws-cdk/integ-runner/lib/index.d.ts new file mode 100644 index 000000000..e8523067d --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/index.d.ts @@ -0,0 +1 @@ +export { cli } from './cli'; diff --git a/packages/@aws-cdk/integ-runner/lib/index.js b/packages/@aws-cdk/integ-runner/lib/index.js new file mode 100644 index 000000000..8bd941e99 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/index.js @@ -0,0 +1,6 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.cli = void 0; +var cli_1 = require("./cli"); +Object.defineProperty(exports, "cli", { enumerable: true, get: function () { return cli_1.cli; } }); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSw2QkFBNEI7QUFBbkIsMEZBQUEsR0FBRyxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgY2xpIH0gZnJvbSAnLi9jbGknO1xuIl19 \ No newline at end of file diff --git a/packages/@aws-cdk/integ-runner/lib/logger.d.ts b/packages/@aws-cdk/integ-runner/lib/logger.d.ts new file mode 100644 index 000000000..66e88cc84 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/logger.d.ts @@ -0,0 +1,5 @@ +export declare const print: (fmt: string, ...args: any[]) => void; +export declare const error: (fmt: string, ...args: any[]) => void; +export declare const warning: (fmt: string, ...args: any[]) => void; +export declare const success: (fmt: string, ...args: any[]) => void; +export declare const highlight: (fmt: string, ...args: any[]) => void; diff --git a/packages/@aws-cdk/integ-runner/lib/logger.js b/packages/@aws-cdk/integ-runner/lib/logger.js new file mode 100644 index 000000000..e0e2bbfdc --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/logger.js @@ -0,0 +1,19 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.highlight = exports.success = exports.warning = exports.error = exports.print = void 0; +const util = require("util"); +const chalk = require("chalk"); +const { stderr } = process; +const logger = (stream, styles) => (fmt, ...args) => { + let str = util.format(fmt, ...args); + if (styles && styles.length) { + str = styles.reduce((a, style) => style(a), str); + } + stream.write(str + '\n'); +}; +exports.print = logger(stderr); +exports.error = logger(stderr, [chalk.red]); +exports.warning = logger(stderr, [chalk.yellow]); +exports.success = logger(stderr, [chalk.green]); +exports.highlight = logger(stderr, [chalk.bold]); +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/packages/@aws-cdk/integ-runner/lib/runner/index.d.ts b/packages/@aws-cdk/integ-runner/lib/runner/index.d.ts new file mode 100644 index 000000000..6445fb09b --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/runner/index.d.ts @@ -0,0 +1,5 @@ +export * from './runner-base'; +export * from './integ-test-suite'; +export * from './integ-test-runner'; +export * from './snapshot-test-runner'; +export * from './integration-tests'; diff --git a/packages/@aws-cdk/integ-runner/lib/runner/index.js b/packages/@aws-cdk/integ-runner/lib/runner/index.js new file mode 100644 index 000000000..6807d7860 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/runner/index.js @@ -0,0 +1,22 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(require("./runner-base"), exports); +__exportStar(require("./integ-test-suite"), exports); +__exportStar(require("./integ-test-runner"), exports); +__exportStar(require("./snapshot-test-runner"), exports); +__exportStar(require("./integration-tests"), exports); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsZ0RBQThCO0FBQzlCLHFEQUFtQztBQUNuQyxzREFBb0M7QUFDcEMseURBQXVDO0FBQ3ZDLHNEQUFvQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcnVubmVyLWJhc2UnO1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlZy10ZXN0LXN1aXRlJztcbmV4cG9ydCAqIGZyb20gJy4vaW50ZWctdGVzdC1ydW5uZXInO1xuZXhwb3J0ICogZnJvbSAnLi9zbmFwc2hvdC10ZXN0LXJ1bm5lcic7XG5leHBvcnQgKiBmcm9tICcuL2ludGVncmF0aW9uLXRlc3RzJztcbiJdfQ== \ No newline at end of file diff --git a/packages/@aws-cdk/integ-runner/lib/runner/integ-test-runner.d.ts b/packages/@aws-cdk/integ-runner/lib/runner/integ-test-runner.d.ts new file mode 100644 index 000000000..145c87e75 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/runner/integ-test-runner.d.ts @@ -0,0 +1,109 @@ +import type { IntegRunnerOptions } from './runner-base'; +import { IntegRunner } from './runner-base'; +import type { DestructiveChange, AssertionResults } from '../workers/common'; +export interface CommonOptions { + /** + * The name of the test case + */ + readonly testCaseName: string; + /** + * The level of verbosity for logging. + * + * @default 0 + */ + readonly verbosity?: number; +} +export interface WatchOptions extends CommonOptions { +} +/** + * Options for the integration test runner + */ +export interface RunOptions extends CommonOptions { + /** + * Whether or not to run `cdk destroy` and cleanup the + * integration test stacks. + * + * Set this to false if you need to perform any validation + * or troubleshooting after deployment. + * + * @default true + */ + readonly clean?: boolean; + /** + * If set to true, the integration test will not deploy + * anything and will simply update the snapshot. + * + * You should NOT use this method since you are essentially + * bypassing the integration test. + * + * @default false + */ + readonly dryRun?: boolean; + /** + * If this is set to false then the stack update workflow will + * not be run + * + * 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. + * + * @default true + */ + readonly updateWorkflow?: boolean; +} +/** + * An integration test runner that orchestrates executing + * integration tests + */ +export declare class IntegTestRunner extends IntegRunner { + constructor(options: IntegRunnerOptions, destructiveChanges?: DestructiveChange[]); + createCdkContextJson(): void; + /** + * When running integration tests with the update path workflow + * it is important that the snapshot that is deployed is the current snapshot + * from the upstream branch. In order to guarantee that, first checkout the latest + * (to the user) snapshot from upstream + * + * It is not straightforward to figure out what branch the current + * working branch was created from. This is a best effort attempt to do so. + * 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: ` + */ + private checkoutSnapshot; + /** + * Runs cdk deploy --watch for an integration test + * + * This is meant to be run on a single test and will not create a snapshot + */ + watchIntegTest(options: WatchOptions): Promise; + /** + * 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. + */ + runIntegTestCase(options: RunOptions): AssertionResults | undefined; + /** + * Perform a integ test case stack destruction + */ + private destroy; + private watch; + /** + * Perform a integ test case deployment, including + * peforming the update workflow + */ + private deploy; + /** + * Process the outputsFile which contains the assertions results as stack + * outputs + */ + private processAssertionResults; + /** + * Parses an error message returned from a CDK command + */ + private parseError; +} diff --git a/packages/@aws-cdk/integ-runner/lib/runner/integ-test-runner.js b/packages/@aws-cdk/integ-runner/lib/runner/integ-test-runner.js new file mode 100644 index 000000000..e720e247f --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/runner/integ-test-runner.js @@ -0,0 +1,487 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.IntegTestRunner = void 0; +const path = require("path"); +const cdk_cli_wrapper_1 = require("@aws-cdk/cdk-cli-wrapper"); +const cloud_assembly_schema_1 = require("@aws-cdk/cloud-assembly-schema"); +const chokidar = require("chokidar"); +const fs = require("fs-extra"); +const workerpool = require("workerpool"); +const runner_base_1 = require("./runner-base"); +const logger = require("../logger"); +const utils_1 = require("../utils"); +const common_1 = require("../workers/common"); +/** + * An integration test runner that orchestrates executing + * integration tests + */ +class IntegTestRunner extends runner_base_1.IntegRunner { + constructor(options, destructiveChanges) { + super(options); + this._destructiveChanges = destructiveChanges; + // 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.hasSnapshot() && this.isLegacyTest) { + throw new Error(`${this.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'); + } + } + createCdkContextJson() { + if (!fs.existsSync(this.cdkContextPath)) { + fs.writeFileSync(this.cdkContextPath, JSON.stringify({ + watch: {}, + }, undefined, 2)); + } + } + /** + * When running integration tests with the update path workflow + * it is important that the snapshot that is deployed is the current snapshot + * from the upstream branch. In order to guarantee that, first checkout the latest + * (to the user) snapshot from upstream + * + * It is not straightforward to figure out what branch the current + * working branch was created from. This is a best effort attempt to do so. + * 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() { + const cwd = this.directory; + // https://git-scm.com/docs/git-merge-base + let baseBranch = undefined; + // try to find the base branch that the working branch was created from + try { + const origin = (0, utils_1.exec)(['git', 'remote', 'show', 'origin'], { + cwd, + }); + const originLines = origin.split('\n'); + for (const line of originLines) { + if (line.trim().startsWith('HEAD branch: ')) { + baseBranch = line.trim().split('HEAD branch: ')[1]; + } + } + } + catch (e) { + logger.warning('%s\n%s', 'Could not determine git origin branch.', `You need to manually checkout the snapshot directory ${this.snapshotDir}` + + 'from the merge-base (https://git-scm.com/docs/git-merge-base)'); + logger.warning('error: %s', 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(this.directory, this.snapshotDir); + try { + const base = (0, utils_1.exec)(['git', 'merge-base', 'HEAD', baseBranch], { + cwd, + }); + (0, utils_1.exec)(['git', 'checkout', base, '--', relativeSnapshotDir], { + cwd, + }); + } + catch (e) { + logger.warning('%s\n%s', `Could not checkout snapshot directory '${this.snapshotDir}'. Please verify the following command completes correctly:`, `git checkout $(git merge-base HEAD ${baseBranch}) -- ${relativeSnapshotDir}`, ''); + logger.warning('error: %s', 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 actualTestCase = this.actualTestSuite.testSuite[options.testCaseName]; + if (!actualTestCase) { + throw new Error(`Did not find test case name '${options.testCaseName}' in '${Object.keys(this.actualTestSuite.testSuite)}'`); + } + const enableForVerbosityLevel = (needed = 1) => { + const verbosity = options.verbosity ?? 0; + return (verbosity >= needed) ? true : undefined; + }; + try { + await this.watch({ + ...this.defaultArgs, + progress: cdk_cli_wrapper_1.StackActivityProgress.BAR, + hotswap: cdk_cli_wrapper_1.HotswapMode.FALL_BACK, + deploymentMethod: 'direct', + profile: this.profile, + requireApproval: cloud_assembly_schema_1.RequireApproval.NEVER, + traceLogs: enableForVerbosityLevel(2) ?? false, + verbose: enableForVerbosityLevel(3), + debug: enableForVerbosityLevel(4), + watch: true, + }, 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. + */ + runIntegTestCase(options) { + let assertionResults; + const actualTestCase = this.actualTestSuite.testSuite[options.testCaseName]; + if (!actualTestCase) { + throw new Error(`Did not find test case name '${options.testCaseName}' in '${Object.keys(this.actualTestSuite.testSuite)}'`); + } + const clean = options.clean ?? true; + const updateWorkflowEnabled = (options.updateWorkflow ?? true) + && (actualTestCase.stackUpdateWorkflow ?? true); + const enableForVerbosityLevel = (needed = 1) => { + const verbosity = options.verbosity ?? 0; + return (verbosity >= needed) ? true : undefined; + }; + try { + if (!options.dryRun && (actualTestCase.cdkCommandOptions?.deploy?.enabled ?? true)) { + assertionResults = this.deploy({ + ...this.defaultArgs, + profile: this.profile, + requireApproval: cloud_assembly_schema_1.RequireApproval.NEVER, + verbose: enableForVerbosityLevel(3), + debug: enableForVerbosityLevel(4), + }, updateWorkflowEnabled, options.testCaseName); + } + else { + const env = { + ...runner_base_1.DEFAULT_SYNTH_OPTIONS.env, + CDK_CONTEXT_JSON: JSON.stringify(this.getContext({ + ...this.actualTestSuite.enableLookups ? runner_base_1.DEFAULT_SYNTH_OPTIONS.context : {}, + })), + }; + this.cdk.synthFast({ + execCmd: this.cdkApp.split(' '), + env, + output: path.relative(this.directory, this.cdkOutDir), + }); + } + // only create the snapshot if there are no failed assertion results + // (i.e. no failures) + if (!assertionResults || !Object.values(assertionResults).some(result => result.status === 'fail')) { + this.createSnapshot(); + } + } + catch (e) { + throw e; + } + finally { + if (!options.dryRun) { + if (clean && (actualTestCase.cdkCommandOptions?.destroy?.enabled ?? true)) { + this.destroy(options.testCaseName, { + ...this.defaultArgs, + profile: this.profile, + all: true, + force: true, + app: this.cdkApp, + output: path.relative(this.directory, this.cdkOutDir), + ...actualTestCase.cdkCommandOptions?.destroy?.args, + context: this.getContext(actualTestCase.cdkCommandOptions?.destroy?.args?.context), + verbose: enableForVerbosityLevel(3), + debug: enableForVerbosityLevel(4), + }); + } + } + this.cleanup(); + } + return assertionResults; + } + /** + * Perform a integ test case stack destruction + */ + destroy(testCaseName, destroyArgs) { + const actualTestCase = this.actualTestSuite.testSuite[testCaseName]; + try { + if (actualTestCase.hooks?.preDestroy) { + actualTestCase.hooks.preDestroy.forEach(cmd => { + (0, utils_1.exec)((0, utils_1.chunks)(cmd), { + cwd: path.dirname(this.snapshotDir), + }); + }); + } + this.cdk.destroy({ + ...destroyArgs, + }); + if (actualTestCase.hooks?.postDestroy) { + actualTestCase.hooks.postDestroy.forEach(cmd => { + (0, utils_1.exec)((0, utils_1.chunks)(cmd), { + cwd: path.dirname(this.snapshotDir), + }); + }); + } + } + catch (e) { + this.parseError(e, actualTestCase.cdkCommandOptions?.destroy?.expectError ?? false, actualTestCase.cdkCommandOptions?.destroy?.expectedMessage); + } + } + async watch(watchArgs, testCaseName, verbosity) { + const actualTestCase = this.actualTestSuite.testSuite[testCaseName]; + if (actualTestCase.hooks?.preDeploy) { + actualTestCase.hooks.preDeploy.forEach(cmd => { + (0, utils_1.exec)((0, utils_1.chunks)(cmd), { + cwd: path.dirname(this.snapshotDir), + }); + }); + } + const deployArgs = { + ...watchArgs, + lookups: this.actualTestSuite.enableLookups, + stacks: [ + ...actualTestCase.stacks, + ...actualTestCase.assertionStack ? [actualTestCase.assertionStack] : [], + ], + output: path.relative(this.directory, this.cdkOutDir), + outputsFile: path.relative(this.directory, path.join(this.cdkOutDir, 'assertion-results.json')), + ...actualTestCase?.cdkCommandOptions?.deploy?.args, + context: { + ...this.getContext(actualTestCase?.cdkCommandOptions?.deploy?.args?.context), + }, + app: this.cdkApp, + }; + const destroyMessage = { + additionalMessages: [ + 'After you are done you must manually destroy the deployed stacks', + ` ${[ + ...process.env.AWS_REGION ? [`AWS_REGION=${process.env.AWS_REGION}`] : [], + 'cdk destroy', + `-a '${this.cdkApp}'`, + deployArgs.stacks.join(' '), + `--profile ${deployArgs.profile}`, + ].join(' ')}`, + ], + }; + workerpool.workerEmit(destroyMessage); + if (watchArgs.verbose) { + // if `-vvv` (or above) is used then print out the command that was used + // this allows users to manually run the command + workerpool.workerEmit({ + additionalMessages: [ + 'Repro:', + ` ${[ + 'cdk synth', + `-a '${this.cdkApp}'`, + `-o '${this.cdkOutDir}'`, + ...Object.entries(this.getContext()).flatMap(([k, v]) => typeof v !== 'object' ? [`-c '${k}=${v}'`] : []), + deployArgs.stacks.join(' '), + `--outputs-file ${deployArgs.outputsFile}`, + `--profile ${deployArgs.profile}`, + '--hotswap-fallback', + ].join(' ')}`, + ], + }); + } + const assertionResults = path.join(this.cdkOutDir, 'assertion-results.json'); + const watcher = chokidar.watch([this.cdkOutDir], { + cwd: this.directory, + }); + watcher.on('all', (event, file) => { + // we only care about changes to the `assertion-results.json` file. If there + // are assertions then this will change on every deployment + if (assertionResults.endsWith(file) && (event === 'add' || event === 'change')) { + const start = Date.now(); + if (actualTestCase.hooks?.postDeploy) { + actualTestCase.hooks.postDeploy.forEach(cmd => { + (0, utils_1.exec)((0, utils_1.chunks)(cmd), { + cwd: path.dirname(this.snapshotDir), + }); + }); + } + if (actualTestCase.assertionStack && actualTestCase.assertionStackName) { + const res = this.processAssertionResults(assertionResults, actualTestCase.assertionStackName, actualTestCase.assertionStack); + if (res && Object.values(res).some(r => r.status === 'fail')) { + workerpool.workerEmit({ + reason: common_1.DiagnosticReason.ASSERTION_FAILED, + testName: `${testCaseName} (${watchArgs.profile}`, + message: (0, common_1.formatAssertionResults)(res), + duration: (Date.now() - start) / 1000, + }); + } + else { + workerpool.workerEmit({ + reason: common_1.DiagnosticReason.TEST_SUCCESS, + testName: `${testCaseName}`, + message: res ? (0, common_1.formatAssertionResults)(res) : 'NO ASSERTIONS', + duration: (Date.now() - start) / 1000, + }); + } + // emit the destroy message after every run + // so that it's visible to the user + workerpool.workerEmit(destroyMessage); + } + } + }); + await new Promise(resolve => { + watcher.on('ready', async () => { + resolve({}); + }); + }); + const child = this.cdk.watch(deployArgs); + // if `-v` (or above) is passed then stream the logs + child.stdout?.on('data', (message) => { + if (verbosity > 0) { + process.stdout.write(message); + } + }); + child.stderr?.on('data', (message) => { + if (verbosity > 0) { + process.stderr.write(message); + } + }); + await new Promise(resolve => { + child.on('close', async (code) => { + if (code !== 0) { + throw new Error('Watch exited with error'); + } + child.stdin?.end(); + await watcher.close(); + resolve(code); + }); + }); + } + /** + * Perform a integ test case deployment, including + * peforming the update workflow + */ + deploy(deployArgs, updateWorkflowEnabled, testCaseName) { + const actualTestCase = this.actualTestSuite.testSuite[testCaseName]; + try { + if (actualTestCase.hooks?.preDeploy) { + actualTestCase.hooks.preDeploy.forEach(cmd => { + (0, utils_1.exec)((0, utils_1.chunks)(cmd), { + cwd: path.dirname(this.snapshotDir), + }); + }); + } + // if the update workflow is not disabled, first + // perform a deployment with the exising snapshot + // then perform a deployment (which will be a stack update) + // with the current integration test + // We also only want to run the update workflow if there is an existing + // snapshot (otherwise there is nothing to update) + if (updateWorkflowEnabled && this.hasSnapshot() && + (this.expectedTestSuite && testCaseName in this.expectedTestSuite?.testSuite)) { + // make sure the snapshot is the latest from 'origin' + this.checkoutSnapshot(); + const expectedTestCase = this.expectedTestSuite.testSuite[testCaseName]; + this.cdk.deploy({ + ...deployArgs, + stacks: expectedTestCase.stacks, + ...expectedTestCase?.cdkCommandOptions?.deploy?.args, + context: this.getContext(expectedTestCase?.cdkCommandOptions?.deploy?.args?.context), + app: path.relative(this.directory, this.snapshotDir), + lookups: this.expectedTestSuite?.enableLookups, + }); + } + // now deploy the "actual" test. + this.cdk.deploy({ + ...deployArgs, + lookups: this.actualTestSuite.enableLookups, + stacks: [ + ...actualTestCase.stacks, + ], + output: path.relative(this.directory, this.cdkOutDir), + ...actualTestCase?.cdkCommandOptions?.deploy?.args, + context: this.getContext(actualTestCase?.cdkCommandOptions?.deploy?.args?.context), + app: this.cdkApp, + }); + // If there are any assertions + // deploy the assertion stack as well + // This is separate from the above deployment because we want to + // 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) { + this.cdk.deploy({ + ...deployArgs, + lookups: this.actualTestSuite.enableLookups, + stacks: [ + actualTestCase.assertionStack, + ], + rollback: false, + output: path.relative(this.directory, this.cdkOutDir), + ...actualTestCase?.cdkCommandOptions?.deploy?.args, + outputsFile: path.relative(this.directory, path.join(this.cdkOutDir, 'assertion-results.json')), + context: this.getContext(actualTestCase?.cdkCommandOptions?.deploy?.args?.context), + app: this.cdkApp, + }); + } + if (actualTestCase.hooks?.postDeploy) { + actualTestCase.hooks.postDeploy.forEach(cmd => { + (0, utils_1.exec)((0, utils_1.chunks)(cmd), { + cwd: path.dirname(this.snapshotDir), + }); + }); + } + if (actualTestCase.assertionStack && actualTestCase.assertionStackName) { + return this.processAssertionResults(path.join(this.cdkOutDir, 'assertion-results.json'), actualTestCase.assertionStackName, actualTestCase.assertionStack); + } + } + catch (e) { + this.parseError(e, actualTestCase.cdkCommandOptions?.deploy?.expectError ?? false, actualTestCase.cdkCommandOptions?.deploy?.expectedMessage); + } + return; + } + /** + * Process the outputsFile which contains the assertions results as stack + * outputs + */ + processAssertionResults(file, assertionStackName, assertionStackId) { + const results = {}; + if (fs.existsSync(file)) { + try { + const outputs = fs.readJSONSync(file); + if (assertionStackName in outputs) { + for (const [assertionId, result] of Object.entries(outputs[assertionStackName])) { + if (assertionId.startsWith('AssertionResults')) { + const assertionResult = JSON.parse(result.replace(/\n/g, '\\n')); + if (assertionResult.status === 'fail' || assertionResult.status === 'success') { + results[assertionId] = assertionResult; + } + } + } + } + } + catch (e) { + // if there are outputs, but they cannot be processed, then throw an error + // so that the test fails + results[assertionStackId] = { + status: 'fail', + message: `error processing assertion results: ${e}`, + }; + } + finally { + // remove the outputs file so it is not part of the snapshot + // it will contain env specific information from values + // resolved at deploy time + fs.unlinkSync(file); + } + } + return Object.keys(results).length > 0 ? results : undefined; + } + /** + * Parses an error message returned from a CDK command + */ + parseError(e, expectError, expectedMessage) { + if (expectError) { + if (expectedMessage) { + const message = e.message; + if (!message.match(expectedMessage)) { + throw (e); + } + } + } + else { + throw e; + } + } +} +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 { DeployOptions, DestroyOptions } from '@aws-cdk/cdk-cli-wrapper';\nimport { HotswapMode, StackActivityProgress } from '@aws-cdk/cdk-cli-wrapper';\nimport { RequireApproval } from '@aws-cdk/cloud-assembly-schema';\nimport * as chokidar from 'chokidar';\nimport * as fs from 'fs-extra';\nimport * as workerpool from 'workerpool';\nimport type { IntegRunnerOptions } from './runner-base';\nimport { IntegRunner, DEFAULT_SYNTH_OPTIONS } from './runner-base';\nimport * as logger from '../logger';\nimport { chunks, exec } from '../utils';\nimport type { DestructiveChange, AssertionResults, AssertionResult } from '../workers/common';\nimport { DiagnosticReason, formatAssertionResults } from '../workers/common';\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}\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/**\n * An integration test runner that orchestrates executing\n * integration tests\n */\nexport class IntegTestRunner extends IntegRunner {\n  constructor(options: IntegRunnerOptions, destructiveChanges?: DestructiveChange[]) {\n    super(options);\n    this._destructiveChanges = destructiveChanges;\n\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.hasSnapshot() && this.isLegacyTest) {\n      throw new Error(`${this.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\n  public createCdkContextJson(): void {\n    if (!fs.existsSync(this.cdkContextPath)) {\n      fs.writeFileSync(this.cdkContextPath, JSON.stringify({\n        watch: { },\n      }, undefined, 2));\n    }\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    const cwd = this.directory;\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        cwd,\n      });\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.snapshotDir}` +\n        'from the merge-base (https://git-scm.com/docs/git-merge-base)',\n      );\n      logger.warning('error: %s', 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(this.directory, this.snapshotDir);\n\n      try {\n        const base = exec(['git', 'merge-base', 'HEAD', baseBranch], {\n          cwd,\n        });\n        exec(['git', 'checkout', base, '--', relativeSnapshotDir], {\n          cwd,\n        });\n      } catch (e) {\n        logger.warning('%s\\n%s',\n          `Could not checkout snapshot directory '${this.snapshotDir}'. Please verify the following command completes correctly:`,\n          `git checkout $(git merge-base HEAD ${baseBranch}) -- ${relativeSnapshotDir}`,\n          '',\n        );\n        logger.warning('error: %s', 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 actualTestCase = this.actualTestSuite.testSuite[options.testCaseName];\n    if (!actualTestCase) {\n      throw new Error(`Did not find test case name '${options.testCaseName}' in '${Object.keys(this.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.defaultArgs,\n          progress: StackActivityProgress.BAR,\n          hotswap: HotswapMode.FALL_BACK,\n          deploymentMethod: 'direct',\n          profile: this.profile,\n          requireApproval: RequireApproval.NEVER,\n          traceLogs: enableForVerbosityLevel(2) ?? false,\n          verbose: enableForVerbosityLevel(3),\n          debug: enableForVerbosityLevel(4),\n          watch: true,\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 runIntegTestCase(options: RunOptions): AssertionResults | undefined {\n    let assertionResults: AssertionResults | undefined;\n    const actualTestCase = this.actualTestSuite.testSuite[options.testCaseName];\n    if (!actualTestCase) {\n      throw new Error(`Did not find test case name '${options.testCaseName}' in '${Object.keys(this.actualTestSuite.testSuite)}'`);\n    }\n    const clean = options.clean ?? true;\n    const updateWorkflowEnabled = (options.updateWorkflow ?? true)\n      && (actualTestCase.stackUpdateWorkflow ?? true);\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 = this.deploy(\n          {\n            ...this.defaultArgs,\n            profile: this.profile,\n            requireApproval: RequireApproval.NEVER,\n            verbose: enableForVerbosityLevel(3),\n            debug: enableForVerbosityLevel(4),\n          },\n          updateWorkflowEnabled,\n          options.testCaseName,\n        );\n      } else {\n        const env: Record<string, any> = {\n          ...DEFAULT_SYNTH_OPTIONS.env,\n          CDK_CONTEXT_JSON: JSON.stringify(this.getContext({\n            ...this.actualTestSuite.enableLookups ? DEFAULT_SYNTH_OPTIONS.context : {},\n          })),\n        };\n        this.cdk.synthFast({\n          execCmd: this.cdkApp.split(' '),\n          env,\n          output: path.relative(this.directory, this.cdkOutDir),\n        });\n      }\n      // only create the snapshot if there are no failed assertion results\n      // (i.e. no failures)\n      if (!assertionResults || !Object.values(assertionResults).some(result => result.status === 'fail')) {\n        this.createSnapshot();\n      }\n    } catch (e) {\n      throw e;\n    } finally {\n      if (!options.dryRun) {\n        if (clean && (actualTestCase.cdkCommandOptions?.destroy?.enabled ?? true)) {\n          this.destroy(options.testCaseName, {\n            ...this.defaultArgs,\n            profile: this.profile,\n            all: true,\n            force: true,\n            app: this.cdkApp,\n            output: path.relative(this.directory, this.cdkOutDir),\n            ...actualTestCase.cdkCommandOptions?.destroy?.args,\n            context: this.getContext(actualTestCase.cdkCommandOptions?.destroy?.args?.context),\n            verbose: enableForVerbosityLevel(3),\n            debug: enableForVerbosityLevel(4),\n          });\n        }\n      }\n      this.cleanup();\n    }\n    return assertionResults;\n  }\n\n  /**\n   * Perform a integ test case stack destruction\n   */\n  private destroy(testCaseName: string, destroyArgs: DestroyOptions) {\n    const actualTestCase = 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.snapshotDir),\n          });\n        });\n      }\n      this.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.snapshotDir),\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(watchArgs: DeployOptions, testCaseName: string, verbosity: number): Promise<void> {\n    const actualTestCase = this.actualTestSuite.testSuite[testCaseName];\n    if (actualTestCase.hooks?.preDeploy) {\n      actualTestCase.hooks.preDeploy.forEach(cmd => {\n        exec(chunks(cmd), {\n          cwd: path.dirname(this.snapshotDir),\n        });\n      });\n    }\n    const deployArgs = {\n      ...watchArgs,\n      lookups: this.actualTestSuite.enableLookups,\n      stacks: [\n        ...actualTestCase.stacks,\n        ...actualTestCase.assertionStack ? [actualTestCase.assertionStack] : [],\n      ],\n      output: path.relative(this.directory, this.cdkOutDir),\n      outputsFile: path.relative(this.directory, path.join(this.cdkOutDir, 'assertion-results.json')),\n      ...actualTestCase?.cdkCommandOptions?.deploy?.args,\n      context: {\n        ...this.getContext(actualTestCase?.cdkCommandOptions?.deploy?.args?.context),\n      },\n      app: this.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.cdkApp}'`,\n          deployArgs.stacks.join(' '),\n          `--profile ${deployArgs.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.cdkApp}'`,\n            `-o '${this.cdkOutDir}'`,\n            ...Object.entries(this.getContext()).flatMap(([k, v]) => typeof v !== 'object' ? [`-c '${k}=${v}'`] : []),\n            deployArgs.stacks.join(' '),\n            `--outputs-file ${deployArgs.outputsFile}`,\n            `--profile ${deployArgs.profile}`,\n            '--hotswap-fallback',\n          ].join(' ')}`,\n        ],\n      });\n    }\n\n    const assertionResults = path.join(this.cdkOutDir, 'assertion-results.json');\n    const watcher = chokidar.watch([this.cdkOutDir], {\n      cwd: this.directory,\n    });\n    watcher.on('all', (event: 'add' | 'change', file: string) => {\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.snapshotDir),\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 child = this.cdk.watch(deployArgs);\n    // if `-v` (or above) is passed then stream the logs\n    child.stdout?.on('data', (message) => {\n      if (verbosity > 0) {\n        process.stdout.write(message);\n      }\n    });\n    child.stderr?.on('data', (message) => {\n      if (verbosity > 0) {\n        process.stderr.write(message);\n      }\n    });\n\n    await new Promise(resolve => {\n      child.on('close', async (code) => {\n        if (code !== 0) {\n          throw new Error('Watch exited with error');\n        }\n        child.stdin?.end();\n        await watcher.close();\n        resolve(code);\n      });\n    });\n  }\n\n  /**\n   * Perform a integ test case deployment, including\n   * peforming the update workflow\n   */\n  private deploy(\n    deployArgs: DeployOptions,\n    updateWorkflowEnabled: boolean,\n    testCaseName: string,\n  ): AssertionResults | undefined {\n    const actualTestCase = 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.snapshotDir),\n          });\n        });\n      }\n      // if the update workflow is not disabled, first\n      // perform a deployment with the exising snapshot\n      // then perform a deployment (which will be a stack update)\n      // with the current integration test\n      // We also only want to run the update workflow if there is an existing\n      // snapshot (otherwise there is nothing to update)\n      if (updateWorkflowEnabled && this.hasSnapshot() &&\n        (this.expectedTestSuite && testCaseName in this.expectedTestSuite?.testSuite)) {\n        // make sure the snapshot is the latest from 'origin'\n        this.checkoutSnapshot();\n        const expectedTestCase = this.expectedTestSuite.testSuite[testCaseName];\n        this.cdk.deploy({\n          ...deployArgs,\n          stacks: expectedTestCase.stacks,\n          ...expectedTestCase?.cdkCommandOptions?.deploy?.args,\n          context: this.getContext(expectedTestCase?.cdkCommandOptions?.deploy?.args?.context),\n          app: path.relative(this.directory, this.snapshotDir),\n          lookups: this.expectedTestSuite?.enableLookups,\n        });\n      }\n      // now deploy the \"actual\" test.\n      this.cdk.deploy({\n        ...deployArgs,\n        lookups: this.actualTestSuite.enableLookups,\n        stacks: [\n          ...actualTestCase.stacks,\n        ],\n        output: path.relative(this.directory, this.cdkOutDir),\n        ...actualTestCase?.cdkCommandOptions?.deploy?.args,\n        context: this.getContext(actualTestCase?.cdkCommandOptions?.deploy?.args?.context),\n        app: this.cdkApp,\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        this.cdk.deploy({\n          ...deployArgs,\n          lookups: this.actualTestSuite.enableLookups,\n          stacks: [\n            actualTestCase.assertionStack,\n          ],\n          rollback: false,\n          output: path.relative(this.directory, this.cdkOutDir),\n          ...actualTestCase?.cdkCommandOptions?.deploy?.args,\n          outputsFile: path.relative(this.directory, path.join(this.cdkOutDir, 'assertion-results.json')),\n          context: this.getContext(actualTestCase?.cdkCommandOptions?.deploy?.args?.context),\n          app: this.cdkApp,\n        });\n      }\n\n      if (actualTestCase.hooks?.postDeploy) {\n        actualTestCase.hooks.postDeploy.forEach(cmd => {\n          exec(chunks(cmd), {\n            cwd: path.dirname(this.snapshotDir),\n          });\n        });\n      }\n\n      if (actualTestCase.assertionStack && actualTestCase.assertionStackName) {\n        return this.processAssertionResults(\n          path.join(this.cdkOutDir, '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"]} \ No newline at end of file diff --git a/packages/@aws-cdk/integ-runner/lib/runner/integ-test-suite.d.ts b/packages/@aws-cdk/integ-runner/lib/runner/integ-test-suite.d.ts new file mode 100644 index 000000000..b789c3895 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/runner/integ-test-suite.d.ts @@ -0,0 +1,127 @@ +import type { ICdk, ListOptions } from '@aws-cdk/cdk-cli-wrapper'; +import type { TestCase, TestOptions } from '@aws-cdk/cloud-assembly-schema'; +/** + * Represents an integration test + */ +export type TestSuite = { + [testName: string]: TestCase; +}; +export type TestSuiteType = 'test-suite' | 'legacy-test-suite'; +/** + * Helper class for working with Integration tests + * This requires an `integ.json` file in the snapshot + * directory. For legacy test cases use LegacyIntegTestCases + */ +export declare class IntegTestSuite { + readonly enableLookups: boolean; + readonly testSuite: TestSuite; + readonly synthContext?: { + [name: string]: string; + } | undefined; + /** + * Loads integ tests from a snapshot directory + */ + static fromPath(path: string): IntegTestSuite; + readonly type: TestSuiteType; + constructor(enableLookups: boolean, testSuite: TestSuite, synthContext?: { + [name: string]: string; + } | undefined); + /** + * Returns a list of stacks that have stackUpdateWorkflow disabled + */ + getStacksWithoutUpdateWorkflow(): string[]; + /** + * Returns test case options for a given stack + */ + getOptionsForStack(stackId: string): TestOptions | undefined; + /** + * Get a list of stacks in the test suite + */ + get stacks(): string[]; +} +/** + * Options for a reading a legacy test case manifest + */ +export interface LegacyTestCaseConfig { + /** + * The name of the test case + */ + readonly testName: string; + /** + * Options to use when performing `cdk list` + * This is used to determine the name of the stacks + * in the test case + */ + readonly listOptions: ListOptions; + /** + * An instance of the CDK CLI (e.g. CdkCliWrapper) + */ + readonly cdk: ICdk; + /** + * The path to the integration test file + * i.e. integ.test.js + */ + readonly integSourceFilePath: string; +} +/** + * Helper class for creating an integ manifest for legacy + * test cases, i.e. tests without a `integ.json`. + */ +export declare class LegacyIntegTestSuite extends IntegTestSuite { + readonly enableLookups: boolean; + readonly testSuite: TestSuite; + readonly synthContext?: { + [name: string]: string; + } | undefined; + /** + * Returns the single test stack to use. + * + * If the test has a single stack, it will be chosen. Otherwise a pragma is expected within the + * test file the name of the stack: + * + * @example + * + * /// !cdk-integ + * + */ + static fromLegacy(config: LegacyTestCaseConfig): LegacyIntegTestSuite; + static getPragmaContext(integSourceFilePath: string): Record; + /** + * Reads stack names from the "!cdk-integ" pragma. + * + * Every word that's NOT prefixed by "pragma:" is considered a stack name. + * + * @example + * + * /// !cdk-integ + */ + private static readStackPragma; + /** + * Read arbitrary cdk-integ pragma directives + * + * Reads the test source file and looks for the "!cdk-integ" pragma. If it exists, returns it's + * contents. This allows integ tests to supply custom command line arguments to "cdk deploy" and "cdk synth". + * + * @example + * + * /// !cdk-integ [...] + */ + private static readIntegPragma; + /** + * Return the non-stack pragmas + * + * These are all pragmas that start with "pragma:". + * + * For backwards compatibility reasons, all pragmas that DON'T start with this + * string are considered to be stack names. + */ + private static pragmas; + readonly type: TestSuiteType; + constructor(enableLookups: boolean, testSuite: TestSuite, synthContext?: { + [name: string]: string; + } | undefined); + /** + * Save the integ manifest to a directory + */ + saveManifest(directory: string, context?: Record): void; +} diff --git a/packages/@aws-cdk/integ-runner/lib/runner/integ-test-suite.js b/packages/@aws-cdk/integ-runner/lib/runner/integ-test-suite.js new file mode 100644 index 000000000..2cbc01e03 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/runner/integ-test-suite.js @@ -0,0 +1,198 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.LegacyIntegTestSuite = exports.IntegTestSuite = void 0; +const osPath = require("path"); +const cloud_assembly_schema_1 = require("@aws-cdk/cloud-assembly-schema"); +const fs = require("fs-extra"); +const integ_manifest_1 = require("./private/integ-manifest"); +const CDK_INTEG_STACK_PRAGMA = '/// !cdk-integ'; +const PRAGMA_PREFIX = 'pragma:'; +const SET_CONTEXT_PRAGMA_PREFIX = 'pragma:set-context:'; +const VERIFY_ASSET_HASHES = 'pragma:include-assets-hashes'; +const DISABLE_UPDATE_WORKFLOW = 'pragma:disable-update-workflow'; +const ENABLE_LOOKUPS_PRAGMA = 'pragma:enable-lookups'; +/** + * Helper class for working with Integration tests + * This requires an `integ.json` file in the snapshot + * directory. For legacy test cases use LegacyIntegTestCases + */ +class IntegTestSuite { + /** + * Loads integ tests from a snapshot directory + */ + static fromPath(path) { + const reader = integ_manifest_1.IntegManifestReader.fromPath(path); + return new IntegTestSuite(reader.tests.enableLookups, reader.tests.testCases, reader.tests.synthContext); + } + constructor(enableLookups, testSuite, synthContext) { + this.enableLookups = enableLookups; + this.testSuite = testSuite; + this.synthContext = synthContext; + this.type = 'test-suite'; + } + /** + * Returns a list of stacks that have stackUpdateWorkflow disabled + */ + getStacksWithoutUpdateWorkflow() { + return Object.values(this.testSuite) + .filter(testCase => !(testCase.stackUpdateWorkflow ?? true)) + .flatMap((testCase) => testCase.stacks); + } + /** + * Returns test case options for a given stack + */ + getOptionsForStack(stackId) { + for (const testCase of Object.values(this.testSuite ?? {})) { + if (testCase.stacks.includes(stackId)) { + return { + hooks: testCase.hooks, + regions: testCase.regions, + diffAssets: testCase.diffAssets ?? false, + allowDestroy: testCase.allowDestroy, + cdkCommandOptions: testCase.cdkCommandOptions, + stackUpdateWorkflow: testCase.stackUpdateWorkflow ?? true, + }; + } + } + return undefined; + } + /** + * Get a list of stacks in the test suite + */ + get stacks() { + return Object.values(this.testSuite).flatMap(testCase => testCase.stacks); + } +} +exports.IntegTestSuite = IntegTestSuite; +/** + * Helper class for creating an integ manifest for legacy + * test cases, i.e. tests without a `integ.json`. + */ +class LegacyIntegTestSuite extends IntegTestSuite { + /** + * Returns the single test stack to use. + * + * If the test has a single stack, it will be chosen. Otherwise a pragma is expected within the + * test file the name of the stack: + * + * @example + * + * /// !cdk-integ + * + */ + static fromLegacy(config) { + const pragmas = this.pragmas(config.integSourceFilePath); + const tests = { + stacks: [], + diffAssets: pragmas.includes(VERIFY_ASSET_HASHES), + stackUpdateWorkflow: !pragmas.includes(DISABLE_UPDATE_WORKFLOW), + }; + const pragma = this.readStackPragma(config.integSourceFilePath); + if (pragma.length > 0) { + tests.stacks.push(...pragma); + } + else { + const options = { + ...config.listOptions, + notices: false, + }; + const stacks = (config.cdk.list(options)).split('\n'); + if (stacks.length !== 1) { + throw new Error('"cdk-integ" can only operate on apps with a single stack.\n\n' + + ' If your app has multiple stacks, specify which stack to select by adding this to your test source:\n\n' + + ` ${CDK_INTEG_STACK_PRAGMA} STACK ...\n\n` + + ` Available stacks: ${stacks.join(' ')} (wildcards are also supported)\n`); + } + if (stacks.length === 1 && stacks[0] === '') { + throw new Error(`No stack found for test ${config.testName}`); + } + tests.stacks.push(...stacks); + } + return new LegacyIntegTestSuite(pragmas.includes(ENABLE_LOOKUPS_PRAGMA), { + [config.testName]: tests, + }, LegacyIntegTestSuite.getPragmaContext(config.integSourceFilePath)); + } + static getPragmaContext(integSourceFilePath) { + const ctxPragmaContext = {}; + // apply context from set-context pragma + // usage: pragma:set-context:key=value + const ctxPragmas = (this.pragmas(integSourceFilePath)).filter(p => p.startsWith(SET_CONTEXT_PRAGMA_PREFIX)); + for (const p of ctxPragmas) { + const instruction = p.substring(SET_CONTEXT_PRAGMA_PREFIX.length); + const [key, value] = instruction.split('='); + if (key == null || value == null) { + throw new Error(`invalid "set-context" pragma syntax. example: "pragma:set-context:@aws-cdk/core:newStyleStackSynthesis=true" got: ${p}`); + } + ctxPragmaContext[key] = value; + } + return { + ...ctxPragmaContext, + }; + } + /** + * Reads stack names from the "!cdk-integ" pragma. + * + * Every word that's NOT prefixed by "pragma:" is considered a stack name. + * + * @example + * + * /// !cdk-integ + */ + static readStackPragma(integSourceFilePath) { + return (this.readIntegPragma(integSourceFilePath)).filter(p => !p.startsWith(PRAGMA_PREFIX)); + } + /** + * Read arbitrary cdk-integ pragma directives + * + * Reads the test source file and looks for the "!cdk-integ" pragma. If it exists, returns it's + * contents. This allows integ tests to supply custom command line arguments to "cdk deploy" and "cdk synth". + * + * @example + * + * /// !cdk-integ [...] + */ + static readIntegPragma(integSourceFilePath) { + const source = fs.readFileSync(integSourceFilePath, { encoding: 'utf-8' }); + const pragmaLine = source.split('\n').find(x => x.startsWith(CDK_INTEG_STACK_PRAGMA + ' ')); + if (!pragmaLine) { + return []; + } + const args = pragmaLine.substring(CDK_INTEG_STACK_PRAGMA.length).trim().split(' '); + if (args.length === 0) { + throw new Error(`Invalid syntax for cdk-integ pragma. Usage: "${CDK_INTEG_STACK_PRAGMA} [STACK] [pragma:PRAGMA] [...]"`); + } + return args; + } + /** + * Return the non-stack pragmas + * + * These are all pragmas that start with "pragma:". + * + * For backwards compatibility reasons, all pragmas that DON'T start with this + * string are considered to be stack names. + */ + static pragmas(integSourceFilePath) { + return (this.readIntegPragma(integSourceFilePath)).filter(p => p.startsWith(PRAGMA_PREFIX)); + } + constructor(enableLookups, testSuite, synthContext) { + super(enableLookups, testSuite); + this.enableLookups = enableLookups; + this.testSuite = testSuite; + this.synthContext = synthContext; + this.type = 'legacy-test-suite'; + } + /** + * Save the integ manifest to a directory + */ + saveManifest(directory, context) { + const manifest = { + version: cloud_assembly_schema_1.Manifest.version(), + testCases: this.testSuite, + synthContext: context, + enableLookups: this.enableLookups, + }; + cloud_assembly_schema_1.Manifest.saveIntegManifest(manifest, osPath.join(directory, integ_manifest_1.IntegManifestReader.DEFAULT_FILENAME)); + } +} +exports.LegacyIntegTestSuite = LegacyIntegTestSuite; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"integ-test-suite.js","sourceRoot":"","sources":["integ-test-suite.ts"],"names":[],"mappings":"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","sourcesContent":["import * as osPath from 'path';\nimport type { ICdk, ListOptions } from '@aws-cdk/cdk-cli-wrapper';\nimport type { TestCase, TestOptions, IntegManifest } from '@aws-cdk/cloud-assembly-schema';\nimport { Manifest } from '@aws-cdk/cloud-assembly-schema';\nimport * as fs from 'fs-extra';\nimport { IntegManifestReader } from './private/integ-manifest';\n\nconst CDK_INTEG_STACK_PRAGMA = '/// !cdk-integ';\nconst PRAGMA_PREFIX = 'pragma:';\nconst SET_CONTEXT_PRAGMA_PREFIX = 'pragma:set-context:';\nconst VERIFY_ASSET_HASHES = 'pragma:include-assets-hashes';\nconst DISABLE_UPDATE_WORKFLOW = 'pragma:disable-update-workflow';\nconst ENABLE_LOOKUPS_PRAGMA = 'pragma:enable-lookups';\n\n/**\n * Represents an integration test\n */\nexport type TestSuite = { [testName: string]: TestCase };\n\nexport type TestSuiteType = 'test-suite' | 'legacy-test-suite';\n\n/**\n * Helper class for working with Integration tests\n * This requires an `integ.json` file in the snapshot\n * directory. For legacy test cases use LegacyIntegTestCases\n */\nexport class IntegTestSuite {\n  /**\n   * Loads integ tests from a snapshot directory\n   */\n  public static fromPath(path: string): IntegTestSuite {\n    const reader = IntegManifestReader.fromPath(path);\n    return new IntegTestSuite(\n      reader.tests.enableLookups,\n      reader.tests.testCases,\n      reader.tests.synthContext,\n    );\n  }\n\n  public readonly type: TestSuiteType = 'test-suite';\n\n  constructor(\n    public readonly enableLookups: boolean,\n    public readonly testSuite: TestSuite,\n    public readonly synthContext?: { [name: string]: string },\n  ) {\n  }\n\n  /**\n   * Returns a list of stacks that have stackUpdateWorkflow disabled\n   */\n  public getStacksWithoutUpdateWorkflow(): string[] {\n    return Object.values(this.testSuite)\n      .filter(testCase => !(testCase.stackUpdateWorkflow ?? true))\n      .flatMap((testCase: TestCase) => testCase.stacks);\n  }\n\n  /**\n   * Returns test case options for a given stack\n   */\n  public getOptionsForStack(stackId: string): TestOptions | undefined {\n    for (const testCase of Object.values(this.testSuite ?? {})) {\n      if (testCase.stacks.includes(stackId)) {\n        return {\n          hooks: testCase.hooks,\n          regions: testCase.regions,\n          diffAssets: testCase.diffAssets ?? false,\n          allowDestroy: testCase.allowDestroy,\n          cdkCommandOptions: testCase.cdkCommandOptions,\n          stackUpdateWorkflow: testCase.stackUpdateWorkflow ?? true,\n        };\n      }\n    }\n    return undefined;\n  }\n\n  /**\n   * Get a list of stacks in the test suite\n   */\n  public get stacks(): string[] {\n    return Object.values(this.testSuite).flatMap(testCase => testCase.stacks);\n  }\n}\n\n/**\n * Options for a reading a legacy test case manifest\n */\nexport interface LegacyTestCaseConfig {\n  /**\n   * The name of the test case\n   */\n  readonly testName: string;\n\n  /**\n   * Options to use when performing `cdk list`\n   * This is used to determine the name of the stacks\n   * in the test case\n   */\n  readonly listOptions: ListOptions;\n\n  /**\n   * An instance of the CDK CLI (e.g. CdkCliWrapper)\n   */\n  readonly cdk: ICdk;\n\n  /**\n   * The path to the integration test file\n   * i.e. integ.test.js\n   */\n  readonly integSourceFilePath: string;\n}\n\n/**\n * Helper class for creating an integ manifest for legacy\n * test cases, i.e. tests without a `integ.json`.\n */\nexport class LegacyIntegTestSuite extends IntegTestSuite {\n  /**\n   * Returns the single test stack to use.\n   *\n   * If the test has a single stack, it will be chosen. Otherwise a pragma is expected within the\n   * test file the name of the stack:\n   *\n   * @example\n   *\n   *    /// !cdk-integ <stack-name>\n   *\n   */\n  public static fromLegacy(config: LegacyTestCaseConfig): LegacyIntegTestSuite {\n    const pragmas = this.pragmas(config.integSourceFilePath);\n    const tests: TestCase = {\n      stacks: [],\n      diffAssets: pragmas.includes(VERIFY_ASSET_HASHES),\n      stackUpdateWorkflow: !pragmas.includes(DISABLE_UPDATE_WORKFLOW),\n    };\n    const pragma = this.readStackPragma(config.integSourceFilePath);\n    if (pragma.length > 0) {\n      tests.stacks.push(...pragma);\n    } else {\n      const options: ListOptions = {\n        ...config.listOptions,\n        notices: false,\n      };\n      const stacks = (config.cdk.list(options)).split('\\n');\n      if (stacks.length !== 1) {\n        throw new Error('\"cdk-integ\" can only operate on apps with a single stack.\\n\\n' +\n          '  If your app has multiple stacks, specify which stack to select by adding this to your test source:\\n\\n' +\n          `      ${CDK_INTEG_STACK_PRAGMA} STACK ...\\n\\n` +\n          `  Available stacks: ${stacks.join(' ')} (wildcards are also supported)\\n`);\n      }\n      if (stacks.length === 1 && stacks[0] === '') {\n        throw new Error(`No stack found for test ${config.testName}`);\n      }\n      tests.stacks.push(...stacks);\n    }\n\n    return new LegacyIntegTestSuite(\n      pragmas.includes(ENABLE_LOOKUPS_PRAGMA),\n      {\n        [config.testName]: tests,\n      },\n      LegacyIntegTestSuite.getPragmaContext(config.integSourceFilePath),\n    );\n  }\n\n  public static getPragmaContext(integSourceFilePath: string): Record<string, any> {\n    const ctxPragmaContext: Record<string, any> = {};\n\n    // apply context from set-context pragma\n    // usage: pragma:set-context:key=value\n    const ctxPragmas = (this.pragmas(integSourceFilePath)).filter(p => p.startsWith(SET_CONTEXT_PRAGMA_PREFIX));\n    for (const p of ctxPragmas) {\n      const instruction = p.substring(SET_CONTEXT_PRAGMA_PREFIX.length);\n      const [key, value] = instruction.split('=');\n      if (key == null || value == null) {\n        throw new Error(`invalid \"set-context\" pragma syntax. example: \"pragma:set-context:@aws-cdk/core:newStyleStackSynthesis=true\" got: ${p}`);\n      }\n\n      ctxPragmaContext[key] = value;\n    }\n    return {\n      ...ctxPragmaContext,\n    };\n  }\n\n  /**\n   * Reads stack names from the \"!cdk-integ\" pragma.\n   *\n   * Every word that's NOT prefixed by \"pragma:\" is considered a stack name.\n   *\n   * @example\n   *\n   *    /// !cdk-integ <stack-name>\n   */\n  private static readStackPragma(integSourceFilePath: string): string[] {\n    return (this.readIntegPragma(integSourceFilePath)).filter(p => !p.startsWith(PRAGMA_PREFIX));\n  }\n\n  /**\n   * Read arbitrary cdk-integ pragma directives\n   *\n   * Reads the test source file and looks for the \"!cdk-integ\" pragma. If it exists, returns it's\n   * contents. This allows integ tests to supply custom command line arguments to \"cdk deploy\" and \"cdk synth\".\n   *\n   * @example\n   *\n   *    /// !cdk-integ [...]\n   */\n  private static readIntegPragma(integSourceFilePath: string): string[] {\n    const source = fs.readFileSync(integSourceFilePath, { encoding: 'utf-8' });\n    const pragmaLine = source.split('\\n').find(x => x.startsWith(CDK_INTEG_STACK_PRAGMA + ' '));\n    if (!pragmaLine) {\n      return [];\n    }\n\n    const args = pragmaLine.substring(CDK_INTEG_STACK_PRAGMA.length).trim().split(' ');\n    if (args.length === 0) {\n      throw new Error(`Invalid syntax for cdk-integ pragma. Usage: \"${CDK_INTEG_STACK_PRAGMA} [STACK] [pragma:PRAGMA] [...]\"`);\n    }\n    return args;\n  }\n\n  /**\n   * Return the non-stack pragmas\n   *\n   * These are all pragmas that start with \"pragma:\".\n   *\n   * For backwards compatibility reasons, all pragmas that DON'T start with this\n   * string are considered to be stack names.\n   */\n  private static pragmas(integSourceFilePath: string): string[] {\n    return (this.readIntegPragma(integSourceFilePath)).filter(p => p.startsWith(PRAGMA_PREFIX));\n  }\n\n  public readonly type: TestSuiteType = 'legacy-test-suite';\n\n  constructor(\n    public readonly enableLookups: boolean,\n    public readonly testSuite: TestSuite,\n    public readonly synthContext?: { [name: string]: string },\n  ) {\n    super(enableLookups, testSuite);\n  }\n\n  /**\n   * Save the integ manifest to a directory\n   */\n  public saveManifest(directory: string, context?: Record<string, any>): void {\n    const manifest: IntegManifest = {\n      version: Manifest.version(),\n      testCases: this.testSuite,\n      synthContext: context,\n      enableLookups: this.enableLookups,\n    };\n    Manifest.saveIntegManifest(manifest, osPath.join(directory, IntegManifestReader.DEFAULT_FILENAME));\n  }\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/integ-runner/lib/runner/integration-tests.d.ts b/packages/@aws-cdk/integ-runner/lib/runner/integration-tests.d.ts new file mode 100644 index 000000000..71891221e --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/runner/integration-tests.d.ts @@ -0,0 +1,170 @@ +/** + * Represents a single integration test + * + * This type is a data-only structure, so it can trivially be passed to workers. + * Derived attributes are calculated using the `IntegTest` class. + */ +export interface IntegTestInfo { + /** + * Path to the file to run + * + * Path is relative to the current working directory. + */ + readonly fileName: string; + /** + * The root directory we discovered this test from + * + * Path is relative to the current working directory. + */ + readonly discoveryRoot: string; + /** + * The CLI command used to run this test. + * If it contains {filePath}, the test file names will be substituted at that place in the command for each run. + * + * @default - test run command will be `node {filePath}` + */ + readonly appCommand?: string; + /** + * true if this test is running in watch mode + * + * @default false + */ + readonly watch?: boolean; +} +/** + * Derived information for IntegTests + */ +export declare class IntegTest { + readonly info: IntegTestInfo; + /** + * The name of the file to run + * + * Path is relative to the current working directory. + */ + readonly fileName: string; + /** + * Relative path to the file to run + * + * Relative from the "discovery root". + */ + readonly discoveryRelativeFileName: string; + /** + * The absolute path to the file + */ + readonly absoluteFileName: string; + /** + * The normalized name of the test. This name + * will be the same regardless of what directory the tool + * is run from. + */ + readonly normalizedTestName: string; + /** + * Directory the test is in + */ + readonly directory: string; + /** + * Display name for the test + * + * Depends on the discovery directory. + * + * Looks like `integ.mytest` or `package/test/integ.mytest`. + */ + readonly testName: string; + /** + * Path of the snapshot directory for this test + */ + readonly snapshotDir: string; + /** + * Path to the temporary output directory for this test + */ + readonly temporaryOutputDir: string; + /** + * The CLI command used to run this test. + * If it contains {filePath}, the test file names will be substituted at that place in the command for each run. + * + * @default - test run command will be `node {filePath}` + */ + readonly appCommand: string; + constructor(info: IntegTestInfo); + /** + * Whether this test matches the user-given name + * + * We are very lenient here. A name matches if it matches: + * + * - The CWD-relative filename + * - The discovery root-relative filename + * - The suite name + * - The absolute filename + */ + matches(name: string): boolean; +} +/** + * Configuration options how integration test files are discovered + */ +export interface IntegrationTestsDiscoveryOptions { + /** + * If this is set to true then the list of tests + * provided will be excluded + * + * @default false + */ + readonly exclude?: boolean; + /** + * List of tests to include (or exclude if `exclude=true`) + * + * @default - all matched files + */ + readonly tests?: string[]; + /** + * A map of of the app commands to run integration tests with, + * and the regex patterns matching the integration test files each app command. + * + * If the app command contains {filePath}, the test file names will be substituted at that place in the command for each run. + */ + readonly testCases: { + [app: string]: string[]; + }; +} +/** + * Discover integration tests + */ +export declare class IntegrationTests { + private readonly directory; + constructor(directory: string); + /** + * Get integration tests discovery options from CLI options + */ + fromCliOptions(options: { + app?: string; + exclude?: boolean; + language?: string[]; + testRegex?: string[]; + tests?: string[]; + }): Promise; + /** + * Get the default configuration for a language + */ + private getLanguagePreset; + /** + * Get the config for all selected languages + */ + private getLanguagePresets; + /** + * If the user provides a list of tests, these can either be a list of tests to include or a list of tests to exclude. + * + * - If it is a list of tests to include then we discover all available tests and check whether they have provided valid tests. + * If they have provided a test name that we don't find, then we write out that error message. + * - If it is a list of tests to exclude, then we discover all available tests and filter out the tests that were provided by the user. + */ + private filterTests; + /** + * Takes an optional list of tests to look for, otherwise + * it will look for all tests from the directory + * + * @param tests Tests to include or exclude, undefined means include all tests. + * @param exclude Whether the 'tests' list is inclusive or exclusive (inclusive by default). + */ + private discover; + private filterUncompiledTypeScript; + private readTree; +} diff --git a/packages/@aws-cdk/integ-runner/lib/runner/integration-tests.js b/packages/@aws-cdk/integ-runner/lib/runner/integration-tests.js new file mode 100644 index 000000000..5ebe2fed8 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/runner/integration-tests.js @@ -0,0 +1,215 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.IntegrationTests = exports.IntegTest = void 0; +const path = require("path"); +const fs = require("fs-extra"); +const CDK_OUTDIR_PREFIX = 'cdk-integ.out'; +/** + * Derived information for IntegTests + */ +class IntegTest { + constructor(info) { + this.info = info; + this.appCommand = info.appCommand ?? 'node {filePath}'; + this.absoluteFileName = path.resolve(info.fileName); + this.fileName = path.relative(process.cwd(), info.fileName); + const parsed = path.parse(this.fileName); + this.discoveryRelativeFileName = path.relative(info.discoveryRoot, info.fileName); + // if `--watch` then we need the directory to be the cwd + this.directory = info.watch ? process.cwd() : parsed.dir; + // if we are running in a package directory then just use the fileName + // as the testname, but if we are running in a parent directory with + // multiple packages then use the directory/filename as the testname + // + // Looks either like `integ.mytest` or `package/test/integ.mytest`. + const relDiscoveryRoot = path.relative(process.cwd(), info.discoveryRoot); + this.testName = this.directory === path.join(relDiscoveryRoot, 'test') || this.directory === path.join(relDiscoveryRoot) + ? parsed.name + : path.join(path.relative(this.info.discoveryRoot, parsed.dir), parsed.name); + this.normalizedTestName = parsed.name; + this.snapshotDir = path.join(parsed.dir, `${parsed.base}.snapshot`); + this.temporaryOutputDir = path.join(parsed.dir, `${CDK_OUTDIR_PREFIX}.${parsed.base}.snapshot`); + } + /** + * Whether this test matches the user-given name + * + * We are very lenient here. A name matches if it matches: + * + * - The CWD-relative filename + * - The discovery root-relative filename + * - The suite name + * - The absolute filename + */ + matches(name) { + return [ + this.fileName, + this.discoveryRelativeFileName, + this.testName, + this.absoluteFileName, + ].includes(name); + } +} +exports.IntegTest = IntegTest; +/** + * Returns the name of the Python executable for the current OS + */ +function pythonExecutable() { + let python = 'python3'; + if (process.platform === 'win32') { + python = 'python'; + } + return python; +} +/** + * Discover integration tests + */ +class IntegrationTests { + constructor(directory) { + this.directory = directory; + } + /** + * Get integration tests discovery options from CLI options + */ + async fromCliOptions(options) { + const baseOptions = { + tests: options.tests, + exclude: options.exclude, + }; + // Explicitly set both, app and test-regex + if (options.app && options.testRegex) { + return this.discover({ + testCases: { + [options.app]: options.testRegex, + }, + ...baseOptions, + }); + } + // Use the selected presets + if (!options.app && !options.testRegex) { + // Only case with multiple languages, i.e. the only time we need to check the special case + const ignoreUncompiledTypeScript = options.language?.includes('javascript') && options.language?.includes('typescript'); + return this.discover({ + testCases: this.getLanguagePresets(options.language), + ...baseOptions, + }, ignoreUncompiledTypeScript); + } + // Only one of app or test-regex is set, with a single preset selected + // => override either app or test-regex + if (options.language?.length === 1) { + const [presetApp, presetTestRegex] = this.getLanguagePreset(options.language[0]); + return this.discover({ + testCases: { + [options.app ?? presetApp]: options.testRegex ?? presetTestRegex, + }, + ...baseOptions, + }); + } + // Only one of app or test-regex is set, with multiple presets + // => impossible to resolve + const option = options.app ? '--app' : '--test-regex'; + throw new Error(`Only a single "--language" can be used with "${option}". Alternatively provide both "--app" and "--test-regex" to fully customize the configuration.`); + } + /** + * Get the default configuration for a language + */ + getLanguagePreset(language) { + const languagePresets = { + javascript: ['node {filePath}', ['^integ\\..*\\.js$']], + typescript: ['node -r ts-node/register {filePath}', ['^integ\\.(?!.*\\.d\\.ts$).*\\.ts$']], + python: [`${pythonExecutable()} {filePath}`, ['^integ_.*\\.py$']], + go: ['go run {filePath}', ['^integ_.*\\.go$']], + }; + return languagePresets[language]; + } + /** + * Get the config for all selected languages + */ + getLanguagePresets(languages = []) { + return Object.fromEntries(languages + .map(language => this.getLanguagePreset(language)) + .filter(Boolean)); + } + /** + * If the user provides a list of tests, these can either be a list of tests to include or a list of tests to exclude. + * + * - If it is a list of tests to include then we discover all available tests and check whether they have provided valid tests. + * If they have provided a test name that we don't find, then we write out that error message. + * - If it is a list of tests to exclude, then we discover all available tests and filter out the tests that were provided by the user. + */ + filterTests(discoveredTests, requestedTests, exclude) { + if (!requestedTests) { + return discoveredTests; + } + const allTests = discoveredTests.filter(t => { + const matches = requestedTests.some(pattern => t.matches(pattern)); + return matches !== !!exclude; // Looks weird but is equal to (matches && !exclude) || (!matches && exclude) + }); + // If not excluding, all patterns must have matched at least one test + if (!exclude) { + const unmatchedPatterns = requestedTests.filter(pattern => !discoveredTests.some(t => t.matches(pattern))); + for (const unmatched of unmatchedPatterns) { + process.stderr.write(`No such integ test: ${unmatched}\n`); + } + if (unmatchedPatterns.length > 0) { + process.stderr.write(`Available tests: ${discoveredTests.map(t => t.discoveryRelativeFileName).join(' ')}\n`); + return []; + } + } + return allTests; + } + /** + * Takes an optional list of tests to look for, otherwise + * it will look for all tests from the directory + * + * @param tests Tests to include or exclude, undefined means include all tests. + * @param exclude Whether the 'tests' list is inclusive or exclusive (inclusive by default). + */ + async discover(options, ignoreUncompiledTypeScript = false) { + const files = await this.readTree(); + const testCases = Object.entries(options.testCases) + .flatMap(([appCommand, patterns]) => files + .filter(fileName => patterns.some((pattern) => { + const regex = new RegExp(pattern); + return regex.test(fileName) || regex.test(path.basename(fileName)); + })) + .map(fileName => new IntegTest({ + discoveryRoot: this.directory, + fileName, + appCommand, + }))); + const discoveredTests = ignoreUncompiledTypeScript ? this.filterUncompiledTypeScript(testCases) : testCases; + return this.filterTests(discoveredTests, options.tests, options.exclude); + } + filterUncompiledTypeScript(testCases) { + const jsTestCases = testCases.filter(t => t.fileName.endsWith('.js')); + return testCases + // Remove all TypeScript test cases (ending in .ts) + // for which a compiled version is present (same name, ending in .js) + .filter((tsCandidate) => { + if (!tsCandidate.fileName.endsWith('.ts')) { + return true; + } + return jsTestCases.findIndex(jsTest => jsTest.testName === tsCandidate.testName) === -1; + }); + } + async readTree() { + const ret = new Array(); + async function recurse(dir) { + const files = await fs.readdir(dir); + for (const file of files) { + const fullPath = path.join(dir, file); + const statf = await fs.stat(fullPath); + if (statf.isFile()) { + ret.push(fullPath); + } + if (statf.isDirectory()) { + await recurse(fullPath); + } + } + } + await recurse(this.directory); + return ret; + } +} +exports.IntegrationTests = IntegrationTests; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"integration-tests.js","sourceRoot":"","sources":["integration-tests.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as fs from 'fs-extra';\n\nconst CDK_OUTDIR_PREFIX = 'cdk-integ.out';\n\n/**\n * Represents a single integration test\n *\n * This type is a data-only structure, so it can trivially be passed to workers.\n * Derived attributes are calculated using the `IntegTest` class.\n */\nexport interface IntegTestInfo {\n  /**\n   * Path to the file to run\n   *\n   * Path is relative to the current working directory.\n   */\n  readonly fileName: string;\n\n  /**\n   * The root directory we discovered this test from\n   *\n   * Path is relative to the current working directory.\n   */\n  readonly discoveryRoot: string;\n\n  /**\n   * The CLI command used to run this test.\n   * If it contains {filePath}, the test file names will be substituted at that place in the command for each run.\n   *\n   * @default - test run command will be `node {filePath}`\n   */\n  readonly appCommand?: string;\n\n  /**\n   * true if this test is running in watch mode\n   *\n   * @default false\n   */\n  readonly watch?: boolean;\n}\n\n/**\n * Derived information for IntegTests\n */\nexport class IntegTest {\n  /**\n   * The name of the file to run\n   *\n   * Path is relative to the current working directory.\n   */\n  public readonly fileName: string;\n\n  /**\n   * Relative path to the file to run\n   *\n   * Relative from the \"discovery root\".\n   */\n  public readonly discoveryRelativeFileName: string;\n\n  /**\n   * The absolute path to the file\n   */\n  public readonly absoluteFileName: string;\n\n  /**\n   * The normalized name of the test. This name\n   * will be the same regardless of what directory the tool\n   * is run from.\n   */\n  public readonly normalizedTestName: string;\n\n  /**\n   * Directory the test is in\n   */\n  public readonly directory: string;\n\n  /**\n   * Display name for the test\n   *\n   * Depends on the discovery directory.\n   *\n   * Looks like `integ.mytest` or `package/test/integ.mytest`.\n   */\n  public readonly testName: string;\n\n  /**\n   * Path of the snapshot directory for this test\n   */\n  public readonly snapshotDir: string;\n\n  /**\n   * Path to the temporary output directory for this test\n   */\n  public readonly temporaryOutputDir: string;\n\n  /**\n   * The CLI command used to run this test.\n   * If it contains {filePath}, the test file names will be substituted at that place in the command for each run.\n   *\n   * @default - test run command will be `node {filePath}`\n   */\n  readonly appCommand: string;\n\n  constructor(public readonly info: IntegTestInfo) {\n    this.appCommand = info.appCommand ?? 'node {filePath}';\n    this.absoluteFileName = path.resolve(info.fileName);\n    this.fileName = path.relative(process.cwd(), info.fileName);\n\n    const parsed = path.parse(this.fileName);\n    this.discoveryRelativeFileName = path.relative(info.discoveryRoot, info.fileName);\n    // if `--watch` then we need the directory to be the cwd\n    this.directory = info.watch ? process.cwd() : parsed.dir;\n\n    // if we are running in a package directory then just use the fileName\n    // as the testname, but if we are running in a parent directory with\n    // multiple packages then use the directory/filename as the testname\n    //\n    // Looks either like `integ.mytest` or `package/test/integ.mytest`.\n    const relDiscoveryRoot = path.relative(process.cwd(), info.discoveryRoot);\n    this.testName = this.directory === path.join(relDiscoveryRoot, 'test') || this.directory === path.join(relDiscoveryRoot)\n      ? parsed.name\n      : path.join(path.relative(this.info.discoveryRoot, parsed.dir), parsed.name);\n\n    this.normalizedTestName = parsed.name;\n    this.snapshotDir = path.join(parsed.dir, `${parsed.base}.snapshot`);\n    this.temporaryOutputDir = path.join(parsed.dir, `${CDK_OUTDIR_PREFIX}.${parsed.base}.snapshot`);\n  }\n\n  /**\n   * Whether this test matches the user-given name\n   *\n   * We are very lenient here. A name matches if it matches:\n   *\n   * - The CWD-relative filename\n   * - The discovery root-relative filename\n   * - The suite name\n   * - The absolute filename\n   */\n  public matches(name: string) {\n    return [\n      this.fileName,\n      this.discoveryRelativeFileName,\n      this.testName,\n      this.absoluteFileName,\n    ].includes(name);\n  }\n}\n\n/**\n * Configuration options how integration test files are discovered\n */\nexport interface IntegrationTestsDiscoveryOptions {\n  /**\n   * If this is set to true then the list of tests\n   * provided will be excluded\n   *\n   * @default false\n   */\n  readonly exclude?: boolean;\n\n  /**\n   * List of tests to include (or exclude if `exclude=true`)\n   *\n   * @default - all matched files\n   */\n  readonly tests?: string[];\n\n  /**\n   * A map of of the app commands to run integration tests with,\n   * and the regex patterns matching the integration test files each app command.\n   *\n   * If the app command contains {filePath}, the test file names will be substituted at that place in the command for each run.\n   */\n  readonly testCases: {\n    [app: string]: string[];\n  };\n}\n\n/**\n * Returns the name of the Python executable for the current OS\n */\nfunction pythonExecutable() {\n  let python = 'python3';\n  if (process.platform === 'win32') {\n    python = 'python';\n  }\n  return python;\n}\n\n/**\n * Discover integration tests\n */\nexport class IntegrationTests {\n  constructor(private readonly directory: string) {\n  }\n\n  /**\n   * Get integration tests discovery options from CLI options\n   */\n  public async fromCliOptions(options: {\n    app?: string;\n    exclude?: boolean;\n    language?: string[];\n    testRegex?: string[];\n    tests?: string[];\n  }): Promise<IntegTest[]> {\n    const baseOptions = {\n      tests: options.tests,\n      exclude: options.exclude,\n    };\n\n    // Explicitly set both, app and test-regex\n    if (options.app && options.testRegex) {\n      return this.discover({\n        testCases: {\n          [options.app]: options.testRegex,\n        },\n        ...baseOptions,\n      });\n    }\n\n    // Use the selected presets\n    if (!options.app && !options.testRegex) {\n      // Only case with multiple languages, i.e. the only time we need to check the special case\n      const ignoreUncompiledTypeScript = options.language?.includes('javascript') && options.language?.includes('typescript');\n\n      return this.discover({\n        testCases: this.getLanguagePresets(options.language),\n        ...baseOptions,\n      }, ignoreUncompiledTypeScript);\n    }\n\n    // Only one of app or test-regex is set, with a single preset selected\n    // => override either app or test-regex\n    if (options.language?.length === 1) {\n      const [presetApp, presetTestRegex] = this.getLanguagePreset(options.language[0]);\n      return this.discover({\n        testCases: {\n          [options.app ?? presetApp]: options.testRegex ?? presetTestRegex,\n        },\n        ...baseOptions,\n      });\n    }\n\n    // Only one of app or test-regex is set, with multiple presets\n    // => impossible to resolve\n    const option = options.app ? '--app' : '--test-regex';\n    throw new Error(`Only a single \"--language\" can be used with \"${option}\". Alternatively provide both \"--app\" and \"--test-regex\" to fully customize the configuration.`);\n  }\n\n  /**\n   * Get the default configuration for a language\n   */\n  private getLanguagePreset(language: string) {\n    const languagePresets: {\n      [language: string]: [string, string[]];\n    } = {\n      javascript: ['node {filePath}', ['^integ\\\\..*\\\\.js$']],\n      typescript: ['node -r ts-node/register {filePath}', ['^integ\\\\.(?!.*\\\\.d\\\\.ts$).*\\\\.ts$']],\n      python: [`${pythonExecutable()} {filePath}`, ['^integ_.*\\\\.py$']],\n      go: ['go run {filePath}', ['^integ_.*\\\\.go$']],\n    };\n\n    return languagePresets[language];\n  }\n\n  /**\n   * Get the config for all selected languages\n   */\n  private getLanguagePresets(languages: string[] = []) {\n    return Object.fromEntries(\n      languages\n        .map(language => this.getLanguagePreset(language))\n        .filter(Boolean),\n    );\n  }\n\n  /**\n   * If the user provides a list of tests, these can either be a list of tests to include or a list of tests to exclude.\n   *\n   * - If it is a list of tests to include then we discover all available tests and check whether they have provided valid tests.\n   *   If they have provided a test name that we don't find, then we write out that error message.\n   * - If it is a list of tests to exclude, then we discover all available tests and filter out the tests that were provided by the user.\n   */\n  private filterTests(discoveredTests: IntegTest[], requestedTests?: string[], exclude?: boolean): IntegTest[] {\n    if (!requestedTests) {\n      return discoveredTests;\n    }\n\n    const allTests = discoveredTests.filter(t => {\n      const matches = requestedTests.some(pattern => t.matches(pattern));\n      return matches !== !!exclude; // Looks weird but is equal to (matches && !exclude) || (!matches && exclude)\n    });\n\n    // If not excluding, all patterns must have matched at least one test\n    if (!exclude) {\n      const unmatchedPatterns = requestedTests.filter(pattern => !discoveredTests.some(t => t.matches(pattern)));\n      for (const unmatched of unmatchedPatterns) {\n        process.stderr.write(`No such integ test: ${unmatched}\\n`);\n      }\n      if (unmatchedPatterns.length > 0) {\n        process.stderr.write(`Available tests: ${discoveredTests.map(t => t.discoveryRelativeFileName).join(' ')}\\n`);\n        return [];\n      }\n    }\n\n    return allTests;\n  }\n\n  /**\n   * Takes an optional list of tests to look for, otherwise\n   * it will look for all tests from the directory\n   *\n   * @param tests Tests to include or exclude, undefined means include all tests.\n   * @param exclude Whether the 'tests' list is inclusive or exclusive (inclusive by default).\n   */\n  private async discover(options: IntegrationTestsDiscoveryOptions, ignoreUncompiledTypeScript: boolean = false): Promise<IntegTest[]> {\n    const files = await this.readTree();\n\n    const testCases = Object.entries(options.testCases)\n      .flatMap(([appCommand, patterns]) => files\n        .filter(fileName => patterns.some((pattern) => {\n          const regex = new RegExp(pattern);\n          return regex.test(fileName) || regex.test(path.basename(fileName));\n        }))\n        .map(fileName => new IntegTest({\n          discoveryRoot: this.directory,\n          fileName,\n          appCommand,\n        })),\n      );\n\n    const discoveredTests = ignoreUncompiledTypeScript ? this.filterUncompiledTypeScript(testCases) : testCases;\n\n    return this.filterTests(discoveredTests, options.tests, options.exclude);\n  }\n\n  private filterUncompiledTypeScript(testCases: IntegTest[]): IntegTest[] {\n    const jsTestCases = testCases.filter(t => t.fileName.endsWith('.js'));\n\n    return testCases\n      // Remove all TypeScript test cases (ending in .ts)\n      // for which a compiled version is present (same name, ending in .js)\n      .filter((tsCandidate) => {\n        if (!tsCandidate.fileName.endsWith('.ts')) {\n          return true;\n        }\n        return jsTestCases.findIndex(jsTest => jsTest.testName === tsCandidate.testName) === -1;\n      });\n  }\n\n  private async readTree(): Promise<string[]> {\n    const ret = new Array<string>();\n\n    async function recurse(dir: string) {\n      const files = await fs.readdir(dir);\n      for (const file of files) {\n        const fullPath = path.join(dir, file);\n        const statf = await fs.stat(fullPath);\n        if (statf.isFile()) {\n          ret.push(fullPath);\n        }\n        if (statf.isDirectory()) {\n          await recurse(fullPath);\n        }\n      }\n    }\n\n    await recurse(this.directory);\n    return ret;\n  }\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/integ-runner/lib/runner/private/cloud-assembly.d.ts b/packages/@aws-cdk/integ-runner/lib/runner/private/cloud-assembly.d.ts new file mode 100644 index 000000000..25b4c86af --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/runner/private/cloud-assembly.d.ts @@ -0,0 +1,78 @@ +import type { AssemblyManifest } from '@aws-cdk/cloud-assembly-schema'; +import { AssetManifest } from 'cdk-assets/lib/asset-manifest'; +/** + * Trace information for stack + * map of resource logicalId to trace message + */ +export type StackTrace = Map; +/** + * Trace information for a assembly + * + * map of stackId to StackTrace + */ +export type ManifestTrace = Map; +/** + * Reads a Cloud Assembly manifest + */ +export declare class AssemblyManifestReader { + private readonly manifest; + private readonly manifestFileName; + static readonly DEFAULT_FILENAME = "manifest.json"; + /** + * Reads a Cloud Assembly manifest from a file + */ + static fromFile(fileName: string): AssemblyManifestReader; + /** + * Reads a Cloud Assembly manifest from a file or a directory + * If the given filePath is a directory then it will look for + * a file within the directory with the DEFAULT_FILENAME + */ + static fromPath(filePath: string): AssemblyManifestReader; + /** + * The directory where the manifest was found + */ + readonly directory: string; + constructor(directory: string, manifest: AssemblyManifest, manifestFileName: string); + /** + * Get the stacks from the manifest + * returns a map of artifactId to CloudFormation template + */ + get stacks(): Record; + /** + * Get the nested stacks for a given stack + * returns a map of artifactId to CloudFormation template + */ + getNestedStacksForStack(stackId: string): Record; + /** + * Write trace data to the assembly manifest metadata + */ + recordTrace(trace: ManifestTrace): void; + /** + * Return a list of assets for a given stack + */ + getAssetIdsForStack(stackId: string): string[]; + /** + * For a given stackId return a list of assets that belong to the stack + */ + getAssetLocationsForStack(stackId: string): string[]; + /** + * Return a list of asset artifacts for a given stack + */ + getAssetManifestsForStack(stackId: string): AssetManifest[]; + /** + * Get a list of assets from the assembly manifest + */ + private assetsFromAssemblyManifest; + /** + * Get a list of assets from the asset manifest + */ + private assetsFromAssetManifest; + /** + * Clean the manifest of any unneccesary data. Currently that includes + * the metadata trace information since this includes trace information like + * file system locations and file lines that will change depending on what machine the test is run on + */ + cleanManifest(): void; + private renderArtifactMetadata; + private renderArtifacts; +} diff --git a/packages/@aws-cdk/integ-runner/lib/runner/private/cloud-assembly.js b/packages/@aws-cdk/integ-runner/lib/runner/private/cloud-assembly.js new file mode 100644 index 000000000..893e6280d --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/runner/private/cloud-assembly.js @@ -0,0 +1,240 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.AssemblyManifestReader = void 0; +const path = require("path"); +const cloud_assembly_schema_1 = require("@aws-cdk/cloud-assembly-schema"); +const asset_manifest_1 = require("cdk-assets/lib/asset-manifest"); +const fs = require("fs-extra"); +/** + * Reads a Cloud Assembly manifest + */ +class AssemblyManifestReader { + /** + * Reads a Cloud Assembly manifest from a file + */ + static fromFile(fileName) { + try { + const obj = cloud_assembly_schema_1.Manifest.loadAssemblyManifest(fileName); + return new AssemblyManifestReader(path.dirname(fileName), obj, fileName); + } + catch (e) { + throw new Error(`Cannot read integ manifest '${fileName}': ${e.message}`); + } + } + /** + * Reads a Cloud Assembly manifest from a file or a directory + * If the given filePath is a directory then it will look for + * a file within the directory with the DEFAULT_FILENAME + */ + static fromPath(filePath) { + let st; + try { + st = fs.statSync(filePath); + } + catch (e) { + throw new Error(`Cannot read integ manifest at '${filePath}': ${e.message}`); + } + if (st.isDirectory()) { + return AssemblyManifestReader.fromFile(path.join(filePath, AssemblyManifestReader.DEFAULT_FILENAME)); + } + return AssemblyManifestReader.fromFile(filePath); + } + constructor(directory, manifest, manifestFileName) { + this.manifest = manifest; + this.manifestFileName = manifestFileName; + this.directory = directory; + } + /** + * Get the stacks from the manifest + * returns a map of artifactId to CloudFormation template + */ + get stacks() { + const stacks = {}; + for (const [artifactId, artifact] of Object.entries(this.manifest.artifacts ?? {})) { + if (artifact.type !== cloud_assembly_schema_1.ArtifactType.AWS_CLOUDFORMATION_STACK) { + continue; + } + const props = artifact.properties; + const template = fs.readJSONSync(path.resolve(this.directory, props.templateFile)); + stacks[artifactId] = template; + } + return stacks; + } + /** + * Get the nested stacks for a given stack + * returns a map of artifactId to CloudFormation template + */ + getNestedStacksForStack(stackId) { + const nestedTemplates = this.getAssetManifestsForStack(stackId).flatMap(manifest => manifest.files + .filter(asset => asset.source.path?.endsWith('.nested.template.json')) + .map(asset => asset.source.path)); + const nestedStacks = Object.fromEntries(nestedTemplates.map(templateFile => ([ + templateFile.split('.', 1)[0], + fs.readJSONSync(path.resolve(this.directory, templateFile)), + ]))); + return nestedStacks; + } + /** + * Write trace data to the assembly manifest metadata + */ + recordTrace(trace) { + const newManifest = { + ...this.manifest, + artifacts: this.renderArtifacts(trace), + }; + cloud_assembly_schema_1.Manifest.saveAssemblyManifest(newManifest, this.manifestFileName); + } + /** + * Return a list of assets for a given stack + */ + getAssetIdsForStack(stackId) { + const assets = []; + for (const artifact of Object.values(this.manifest.artifacts ?? {})) { + if (artifact.type === cloud_assembly_schema_1.ArtifactType.ASSET_MANIFEST && artifact.properties?.file === `${stackId}.assets.json`) { + assets.push(...this.assetsFromAssetManifest(artifact).map(asset => asset.id.assetId)); + } + else if (artifact.type === cloud_assembly_schema_1.ArtifactType.AWS_CLOUDFORMATION_STACK) { + assets.push(...this.assetsFromAssemblyManifest(artifact).map(asset => asset.id)); + } + } + return assets; + } + /** + * For a given stackId return a list of assets that belong to the stack + */ + getAssetLocationsForStack(stackId) { + const assets = []; + for (const artifact of Object.values(this.manifest.artifacts ?? {})) { + if (artifact.type === cloud_assembly_schema_1.ArtifactType.ASSET_MANIFEST && artifact.properties?.file === `${stackId}.assets.json`) { + assets.push(...this.assetsFromAssetManifest(artifact).flatMap(asset => { + if (asset.type === 'file' && !asset.source.path?.endsWith('nested.template.json')) { + return asset.source.path; + } + else if (asset.type !== 'file') { + return asset.source.directory; + } + return []; + })); + } + else if (artifact.type === cloud_assembly_schema_1.ArtifactType.AWS_CLOUDFORMATION_STACK) { + assets.push(...this.assetsFromAssemblyManifest(artifact).map(asset => asset.path)); + } + } + return assets; + } + /** + * Return a list of asset artifacts for a given stack + */ + getAssetManifestsForStack(stackId) { + return Object.values(this.manifest.artifacts ?? {}) + .filter(artifact => artifact.type === cloud_assembly_schema_1.ArtifactType.ASSET_MANIFEST && artifact.properties?.file === `${stackId}.assets.json`) + .map(artifact => { + const fileName = artifact.properties.file; + return asset_manifest_1.AssetManifest.fromFile(path.join(this.directory, fileName)); + }); + } + /** + * Get a list of assets from the assembly manifest + */ + assetsFromAssemblyManifest(artifact) { + const assets = []; + for (const metadata of Object.values(artifact.metadata ?? {})) { + metadata.forEach(data => { + if (data.type === cloud_assembly_schema_1.ArtifactMetadataEntryType.ASSET) { + const asset = data.data; + if (asset.path.startsWith('asset.')) { + assets.push(asset); + } + } + }); + } + return assets; + } + /** + * Get a list of assets from the asset manifest + */ + assetsFromAssetManifest(artifact) { + const assets = []; + const fileName = artifact.properties.file; + const assetManifest = asset_manifest_1.AssetManifest.fromFile(path.join(this.directory, fileName)); + assetManifest.entries.forEach(entry => { + if (entry.type === 'file') { + const source = entry.source; + if (source.path && (source.path.startsWith('asset.') || source.path.endsWith('nested.template.json'))) { + assets.push(entry); + } + } + else if (entry.type === 'docker-image') { + const source = entry.source; + if (source.directory && source.directory.startsWith('asset.')) { + assets.push(entry); + } + } + }); + return assets; + } + /** + * Clean the manifest of any unneccesary data. Currently that includes + * the metadata trace information since this includes trace information like + * file system locations and file lines that will change depending on what machine the test is run on + */ + cleanManifest() { + const newManifest = { + ...this.manifest, + artifacts: this.renderArtifacts(), + }; + cloud_assembly_schema_1.Manifest.saveAssemblyManifest(newManifest, this.manifestFileName); + } + renderArtifactMetadata(artifact, trace) { + const newMetadata = {}; + if (!artifact.metadata) + return artifact.metadata; + for (const [metadataId, metadataEntry] of Object.entries(artifact.metadata ?? {})) { + newMetadata[metadataId] = metadataEntry.map((meta) => { + if (meta.type === 'aws:cdk:logicalId' && trace && meta.data) { + const traceData = trace.get(meta.data.toString()); + if (traceData) { + trace.delete(meta.data.toString()); + return { + type: meta.type, + data: meta.data, + trace: [traceData], + }; + } + } + // return metadata without the trace data + return { + type: meta.type, + data: meta.data, + }; + }); + } + if (trace && trace.size > 0) { + for (const [id, data] of trace.entries()) { + newMetadata[id] = [{ + type: 'aws:cdk:logicalId', + data: id, + trace: [data], + }]; + } + } + return newMetadata; + } + renderArtifacts(trace) { + const newArtifacts = {}; + for (const [artifactId, artifact] of Object.entries(this.manifest.artifacts ?? {})) { + let stackTrace = undefined; + if (artifact.type === cloud_assembly_schema_1.ArtifactType.AWS_CLOUDFORMATION_STACK && trace) { + stackTrace = trace.get(artifactId); + } + newArtifacts[artifactId] = { + ...artifact, + metadata: this.renderArtifactMetadata(artifact, stackTrace), + }; + } + return newArtifacts; + } +} +exports.AssemblyManifestReader = AssemblyManifestReader; +AssemblyManifestReader.DEFAULT_FILENAME = 'manifest.json'; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloud-assembly.js","sourceRoot":"","sources":["cloud-assembly.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport type { AssemblyManifest, AwsCloudFormationStackProperties, ArtifactManifest, MetadataEntry, AssetManifestProperties, ContainerImageAssetMetadataEntry, FileAssetMetadataEntry } from '@aws-cdk/cloud-assembly-schema';\nimport { Manifest, ArtifactType, ArtifactMetadataEntryType } from '@aws-cdk/cloud-assembly-schema';\nimport type { FileManifestEntry, DockerImageManifestEntry } from 'cdk-assets/lib/asset-manifest';\nimport { AssetManifest } from 'cdk-assets/lib/asset-manifest';\nimport * as fs from 'fs-extra';\n\n/**\n * Trace information for stack\n * map of resource logicalId to trace message\n */\nexport type StackTrace = Map<string, string>;\n\n/**\n * Trace information for a assembly\n *\n * map of stackId to StackTrace\n */\nexport type ManifestTrace = Map<string, StackTrace>;\n\n/**\n * Reads a Cloud Assembly manifest\n */\nexport class AssemblyManifestReader {\n  public static readonly DEFAULT_FILENAME = 'manifest.json';\n\n  /**\n   * Reads a Cloud Assembly manifest from a file\n   */\n  public static fromFile(fileName: string): AssemblyManifestReader {\n    try {\n      const obj = Manifest.loadAssemblyManifest(fileName);\n      return new AssemblyManifestReader(path.dirname(fileName), obj, fileName);\n    } catch (e: any) {\n      throw new Error(`Cannot read integ manifest '${fileName}': ${e.message}`);\n    }\n  }\n\n  /**\n   * Reads a Cloud Assembly manifest from a file or a directory\n   * If the given filePath is a directory then it will look for\n   * a file within the directory with the DEFAULT_FILENAME\n   */\n  public static fromPath(filePath: string): AssemblyManifestReader {\n    let st;\n    try {\n      st = fs.statSync(filePath);\n    } catch (e: any) {\n      throw new Error(`Cannot read integ manifest at '${filePath}': ${e.message}`);\n    }\n    if (st.isDirectory()) {\n      return AssemblyManifestReader.fromFile(path.join(filePath, AssemblyManifestReader.DEFAULT_FILENAME));\n    }\n    return AssemblyManifestReader.fromFile(filePath);\n  }\n\n  /**\n   * The directory where the manifest was found\n   */\n  public readonly directory: string;\n\n  constructor(directory: string, private readonly manifest: AssemblyManifest, private readonly manifestFileName: string) {\n    this.directory = directory;\n  }\n\n  /**\n   * Get the stacks from the manifest\n   * returns a map of artifactId to CloudFormation template\n   */\n  public get stacks(): Record<string, any> {\n    const stacks: Record<string, any> = {};\n    for (const [artifactId, artifact] of Object.entries(this.manifest.artifacts ?? {})) {\n      if (artifact.type !== ArtifactType.AWS_CLOUDFORMATION_STACK) {\n        continue;\n      }\n      const props = artifact.properties as AwsCloudFormationStackProperties;\n\n      const template = fs.readJSONSync(path.resolve(this.directory, props.templateFile));\n      stacks[artifactId] = template;\n    }\n    return stacks;\n  }\n\n  /**\n   * Get the nested stacks for a given stack\n   * returns a map of artifactId to CloudFormation template\n   */\n  public getNestedStacksForStack(stackId: string): Record<string, any> {\n    const nestedTemplates: string[] = this.getAssetManifestsForStack(stackId).flatMap(\n      manifest => manifest.files\n        .filter(asset => asset.source.path?.endsWith('.nested.template.json'))\n        .map(asset => asset.source.path!),\n    );\n\n    const nestedStacks: Record<string, any> = Object.fromEntries(nestedTemplates.map(templateFile => ([\n      templateFile.split('.', 1)[0],\n      fs.readJSONSync(path.resolve(this.directory, templateFile)),\n    ])));\n\n    return nestedStacks;\n  }\n\n  /**\n   * Write trace data to the assembly manifest metadata\n   */\n  public recordTrace(trace: ManifestTrace): void {\n    const newManifest = {\n      ...this.manifest,\n      artifacts: this.renderArtifacts(trace),\n    };\n    Manifest.saveAssemblyManifest(newManifest, this.manifestFileName);\n  }\n\n  /**\n   * Return a list of assets for a given stack\n   */\n  public getAssetIdsForStack(stackId: string): string[] {\n    const assets: string[] = [];\n    for (const artifact of Object.values(this.manifest.artifacts ?? {})) {\n      if (artifact.type === ArtifactType.ASSET_MANIFEST && (artifact.properties as AssetManifestProperties)?.file === `${stackId}.assets.json`) {\n        assets.push(...this.assetsFromAssetManifest(artifact).map(asset => asset.id.assetId));\n      } else if (artifact.type === ArtifactType.AWS_CLOUDFORMATION_STACK) {\n        assets.push(...this.assetsFromAssemblyManifest(artifact).map(asset => asset.id));\n      }\n    }\n    return assets;\n  }\n\n  /**\n   * For a given stackId return a list of assets that belong to the stack\n   */\n  public getAssetLocationsForStack(stackId: string): string[] {\n    const assets: string[] = [];\n    for (const artifact of Object.values(this.manifest.artifacts ?? {})) {\n      if (artifact.type === ArtifactType.ASSET_MANIFEST && (artifact.properties as AssetManifestProperties)?.file === `${stackId}.assets.json`) {\n        assets.push(...this.assetsFromAssetManifest(artifact).flatMap(asset => {\n          if (asset.type === 'file' && !asset.source.path?.endsWith('nested.template.json')) {\n            return asset.source.path!;\n          } else if (asset.type !== 'file') {\n            return asset.source.directory!;\n          }\n          return [];\n        }));\n      } else if (artifact.type === ArtifactType.AWS_CLOUDFORMATION_STACK) {\n        assets.push(...this.assetsFromAssemblyManifest(artifact).map(asset => asset.path));\n      }\n    }\n    return assets;\n  }\n\n  /**\n   * Return a list of asset artifacts for a given stack\n   */\n  public getAssetManifestsForStack(stackId: string): AssetManifest[] {\n    return Object.values(this.manifest.artifacts ?? {})\n      .filter(artifact =>\n        artifact.type === ArtifactType.ASSET_MANIFEST && (artifact.properties as AssetManifestProperties)?.file === `${stackId}.assets.json`)\n      .map(artifact => {\n        const fileName = (artifact.properties as AssetManifestProperties).file;\n        return AssetManifest.fromFile(path.join(this.directory, fileName));\n      });\n  }\n\n  /**\n   * Get a list of assets from the assembly manifest\n   */\n  private assetsFromAssemblyManifest(artifact: ArtifactManifest): (ContainerImageAssetMetadataEntry | FileAssetMetadataEntry)[] {\n    const assets: (ContainerImageAssetMetadataEntry | FileAssetMetadataEntry)[] = [];\n    for (const metadata of Object.values(artifact.metadata ?? {})) {\n      metadata.forEach(data => {\n        if (data.type === ArtifactMetadataEntryType.ASSET) {\n          const asset = (data.data as ContainerImageAssetMetadataEntry | FileAssetMetadataEntry);\n          if (asset.path.startsWith('asset.')) {\n            assets.push(asset);\n          }\n        }\n      });\n    }\n    return assets;\n  }\n\n  /**\n   * Get a list of assets from the asset manifest\n   */\n  private assetsFromAssetManifest(artifact: ArtifactManifest): (FileManifestEntry | DockerImageManifestEntry)[] {\n    const assets: (FileManifestEntry | DockerImageManifestEntry)[] = [];\n    const fileName = (artifact.properties as AssetManifestProperties).file;\n    const assetManifest = AssetManifest.fromFile(path.join(this.directory, fileName));\n    assetManifest.entries.forEach(entry => {\n      if (entry.type === 'file') {\n        const source = (entry as FileManifestEntry).source;\n        if (source.path && (source.path.startsWith('asset.') || source.path.endsWith('nested.template.json'))) {\n          assets.push(entry as FileManifestEntry);\n        }\n      } else if (entry.type === 'docker-image') {\n        const source = (entry as DockerImageManifestEntry).source;\n        if (source.directory && source.directory.startsWith('asset.')) {\n          assets.push(entry as DockerImageManifestEntry);\n        }\n      }\n    });\n    return assets;\n  }\n\n  /**\n   * Clean the manifest of any unneccesary data. Currently that includes\n   * the metadata trace information since this includes trace information like\n   * file system locations and file lines that will change depending on what machine the test is run on\n   */\n  public cleanManifest(): void {\n    const newManifest = {\n      ...this.manifest,\n      artifacts: this.renderArtifacts(),\n    };\n    Manifest.saveAssemblyManifest(newManifest, this.manifestFileName);\n  }\n\n  private renderArtifactMetadata(artifact: ArtifactManifest, trace?: StackTrace): { [id: string]: MetadataEntry[] } | undefined {\n    const newMetadata: { [id: string]: MetadataEntry[] } = {};\n    if (!artifact.metadata) return artifact.metadata;\n    for (const [metadataId, metadataEntry] of Object.entries(artifact.metadata ?? {})) {\n      newMetadata[metadataId] = metadataEntry.map((meta: MetadataEntry) => {\n        if (meta.type === 'aws:cdk:logicalId' && trace && meta.data) {\n          const traceData = trace.get(meta.data.toString());\n          if (traceData) {\n            trace.delete(meta.data.toString());\n            return {\n              type: meta.type,\n              data: meta.data,\n              trace: [traceData],\n            };\n          }\n        }\n        // return metadata without the trace data\n        return {\n          type: meta.type,\n          data: meta.data,\n        };\n      });\n    }\n    if (trace && trace.size > 0) {\n      for (const [id, data] of trace.entries()) {\n        newMetadata[id] = [{\n          type: 'aws:cdk:logicalId',\n          data: id,\n          trace: [data],\n        }];\n      }\n    }\n    return newMetadata;\n  }\n\n  private renderArtifacts(trace?: ManifestTrace): { [id: string]: ArtifactManifest } | undefined {\n    const newArtifacts: { [id: string]: ArtifactManifest } = {};\n    for (const [artifactId, artifact] of Object.entries(this.manifest.artifacts ?? {})) {\n      let stackTrace: StackTrace | undefined = undefined;\n      if (artifact.type === ArtifactType.AWS_CLOUDFORMATION_STACK && trace) {\n        stackTrace = trace.get(artifactId);\n      }\n      newArtifacts[artifactId] = {\n        ...artifact,\n        metadata: this.renderArtifactMetadata(artifact, stackTrace),\n      };\n    }\n    return newArtifacts;\n  }\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/integ-runner/lib/runner/private/integ-manifest.d.ts b/packages/@aws-cdk/integ-runner/lib/runner/private/integ-manifest.d.ts new file mode 100644 index 000000000..752c9db5d --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/runner/private/integ-manifest.d.ts @@ -0,0 +1,54 @@ +import type { IntegManifest, TestCase } from '@aws-cdk/cloud-assembly-schema'; +/** + * Test case configuration read from the integ manifest + */ +export interface IntegTestConfig { + /** + * Test cases contained in this integration test + */ + readonly testCases: { + [testCaseName: string]: TestCase; + }; + /** + * Whether to enable lookups for this test + * + * @default false + */ + readonly enableLookups: boolean; + /** + * Additional context to use when performing + * a synth. Any context provided here will override + * any default context + * + * @default - no additional context + */ + readonly synthContext?: { + [name: string]: string; + }; +} +/** + * Reads an integration tests manifest + */ +export declare class IntegManifestReader { + private readonly manifest; + static readonly DEFAULT_FILENAME = "integ.json"; + /** + * Reads an integration test manifest from the specified file + */ + static fromFile(fileName: string): IntegManifestReader; + /** + * Reads a Integration test manifest from a file or a directory + * If the given filePath is a directory then it will look for + * a file within the directory with the DEFAULT_FILENAME + */ + static fromPath(filePath: string): IntegManifestReader; + /** + * The directory where the manifest was found + */ + readonly directory: string; + constructor(directory: string, manifest: IntegManifest); + /** + * List of integration tests in the manifest + */ + get tests(): IntegTestConfig; +} diff --git a/packages/@aws-cdk/integ-runner/lib/runner/private/integ-manifest.js b/packages/@aws-cdk/integ-runner/lib/runner/private/integ-manifest.js new file mode 100644 index 000000000..a2b8b5a18 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/runner/private/integ-manifest.js @@ -0,0 +1,58 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.IntegManifestReader = void 0; +const path = require("path"); +const cloud_assembly_schema_1 = require("@aws-cdk/cloud-assembly-schema"); +const fs = require("fs-extra"); +/** + * Reads an integration tests manifest + */ +class IntegManifestReader { + /** + * Reads an integration test manifest from the specified file + */ + static fromFile(fileName) { + try { + const obj = cloud_assembly_schema_1.Manifest.loadIntegManifest(fileName); + return new IntegManifestReader(path.dirname(fileName), obj); + } + catch (e) { + throw new Error(`Cannot read integ manifest '${fileName}': ${e.message}`); + } + } + /** + * Reads a Integration test manifest from a file or a directory + * If the given filePath is a directory then it will look for + * a file within the directory with the DEFAULT_FILENAME + */ + static fromPath(filePath) { + let st; + try { + st = fs.statSync(filePath); + } + catch (e) { + throw new Error(`Cannot read integ manifest at '${filePath}': ${e.message}`); + } + if (st.isDirectory()) { + return IntegManifestReader.fromFile(path.join(filePath, IntegManifestReader.DEFAULT_FILENAME)); + } + return IntegManifestReader.fromFile(filePath); + } + constructor(directory, manifest) { + this.manifest = manifest; + this.directory = directory; + } + /** + * List of integration tests in the manifest + */ + get tests() { + return { + testCases: this.manifest.testCases, + enableLookups: this.manifest.enableLookups ?? false, + synthContext: this.manifest.synthContext, + }; + } +} +exports.IntegManifestReader = IntegManifestReader; +IntegManifestReader.DEFAULT_FILENAME = 'integ.json'; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/packages/@aws-cdk/integ-runner/lib/runner/runner-base.d.ts b/packages/@aws-cdk/integ-runner/lib/runner/runner-base.d.ts new file mode 100644 index 000000000..d0b64d652 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/runner/runner-base.d.ts @@ -0,0 +1,285 @@ +import type { ICdk } from '@aws-cdk/cdk-cli-wrapper'; +import type { TestCase, DefaultCdkOptions } from '@aws-cdk/cloud-assembly-schema'; +import { IntegTestSuite, LegacyIntegTestSuite } from './integ-test-suite'; +import type { IntegTest } from './integration-tests'; +import type { DestructiveChange } from '../workers/common'; +/** + * Options for creating an integration test runner + */ +export interface IntegRunnerOptions { + /** + * Information about the test to run + */ + readonly test: IntegTest; + /** + * The AWS profile to use when invoking the CDK CLI + * + * @default - no profile is passed, the default profile is used + */ + readonly profile?: string; + /** + * Additional environment variables that will be available + * to the CDK CLI + * + * @default - no additional environment variables + */ + readonly env?: { + [name: string]: string; + }; + /** + * tmp cdk.out directory + * + * @default - directory will be `cdk-integ.out.${testName}` + */ + readonly integOutDir?: string; + /** + * Instance of the CDK CLI to use + * + * @default - CdkCliWrapper + */ + readonly cdk?: ICdk; + /** + * Show output from running integration tests + * + * @default false + */ + readonly showOutput?: boolean; +} +/** + * The different components of a test name + */ +/** + * Represents an Integration test runner + */ +export declare abstract class IntegRunner { + /** + * The directory where the snapshot will be stored + */ + readonly snapshotDir: string; + /** + * An instance of the CDK CLI + */ + readonly cdk: ICdk; + /** + * Pretty name of the test + */ + readonly testName: string; + /** + * The value used in the '--app' CLI parameter + * + * Path to the integ test source file, relative to `this.directory`. + */ + protected readonly cdkApp: string; + /** + * The path where the `cdk.context.json` file + * will be created + */ + protected readonly cdkContextPath: string; + /** + * The test suite from the existing snapshot + */ + protected readonly expectedTestSuite?: IntegTestSuite | LegacyIntegTestSuite; + /** + * The test suite from the new "actual" snapshot + */ + protected readonly actualTestSuite: IntegTestSuite | LegacyIntegTestSuite; + /** + * The working directory that the integration tests will be + * executed from + */ + protected readonly directory: string; + /** + * The test to run + */ + protected readonly test: IntegTest; + /** + * Default options to pass to the CDK CLI + */ + protected readonly defaultArgs: DefaultCdkOptions; + /** + * The directory where the CDK will be synthed to + * + * Relative to cwd. + */ + protected readonly cdkOutDir: string; + protected readonly profile?: string; + protected _destructiveChanges?: DestructiveChange[]; + private legacyContext?; + protected isLegacyTest?: boolean; + constructor(options: IntegRunnerOptions); + /** + * Return the list of expected (i.e. existing) test cases for this integration test + */ + expectedTests(): { + [testName: string]: TestCase; + } | undefined; + /** + * Return the list of actual (i.e. new) test cases for this integration test + */ + actualTests(): { + [testName: string]: TestCase; + } | undefined; + /** + * Generate a new "actual" snapshot which will be compared to the + * existing "expected" snapshot + * This will synth and then load the integration test manifest + */ + generateActualSnapshot(): IntegTestSuite | LegacyIntegTestSuite; + /** + * Returns true if a snapshot already exists for this test + */ + hasSnapshot(): boolean; + /** + * Load the integ manifest which contains information + * on how to execute the tests + * First we try and load the manifest from the integ manifest (i.e. integ.json) + * from the cloud assembly. If it doesn't exist, then we fallback to the + * "legacy mode" and create a manifest from pragma + */ + protected loadManifest(dir?: string): IntegTestSuite | LegacyIntegTestSuite; + protected cleanup(): void; + /** + * If there are any destructive changes to a stack then this will record + * those in the manifest.json file + */ + private renderTraceData; + /** + * In cases where we do not want to retain the assets, + * for example, if the assets are very large. + * + * Since it is possible to disable the update workflow for individual test + * cases, this needs to first get a list of stacks that have the update workflow + * disabled and then delete assets that relate to that stack. It does that + * by reading the asset manifest for the stack and deleting the asset source + */ + protected removeAssetsFromSnapshot(): void; + /** + * Remove the asset cache (.cache/) files from the snapshot. + * These are a cache of the asset zips, but we are fine with + * re-zipping on deploy + */ + protected removeAssetsCacheFromSnapshot(): void; + /** + * Create the new snapshot. + * + * If lookups are enabled, then we need create the snapshot by synthing again + * with the dummy context so that each time the test is run on different machines + * (and with different context/env) the diff will not change. + * + * If lookups are disabled (which means the stack is env agnostic) then just copy + * the assembly that was output by the deployment + */ + protected createSnapshot(): void; + /** + * Perform some cleanup steps after the snapshot is created + * Anytime the snapshot needs to be modified after creation + * the logic should live here. + */ + private cleanupSnapshot; + protected getContext(additionalContext?: Record): Record; +} +export declare const DEFAULT_SYNTH_OPTIONS: { + context: { + "aws:cdk:availability-zones:fallback": string[]; + 'availability-zones:account=12345678:region=test-region': string[]; + 'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn-ami-hvm-x86_64-gp2:region=test-region': string; + 'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2:region=test-region': string; + 'ssm:account=12345678:parameterName=/aws/service/ecs/optimized-ami/amazon-linux/recommended:region=test-region': string; + 'ami:account=12345678:filters.image-type.0=machine:filters.name.0=amzn-ami-vpc-nat-*:filters.state.0=available:owners.0=amazon:region=test-region': string; + 'vpc-provider:account=12345678:filter.isDefault=true:region=test-region:returnAsymmetricSubnets=true': { + vpcId: string; + subnetGroups: { + type: string; + name: string; + subnets: { + subnetId: string; + availabilityZone: string; + routeTableId: string; + }[]; + }[]; + }; + }; + env: { + CDK_INTEG_ACCOUNT: string; + CDK_INTEG_REGION: string; + CDK_INTEG_HOSTED_ZONE_ID: string; + CDK_INTEG_HOSTED_ZONE_NAME: string; + CDK_INTEG_DOMAIN_NAME: string; + CDK_INTEG_CERT_ARN: string; + CDK_INTEG_SUBNET_ID: string; + }; +}; +/** + * Return the currently recommended flags for `aws-cdk-lib`. + * + * These have been built into the CLI at build time. If this ever gets changed + * back to a dynamic load, remember that this source file may be bundled into + * a JavaScript bundle, and `__dirname` might not point where you think it does. + */ +export declare function currentlyRecommendedAwsCdkLibFlags(): { + "@aws-cdk/aws-lambda:recognizeLayerVersion": boolean; + "@aws-cdk/core:checkSecretUsage": boolean; + "@aws-cdk/core:target-partitions": string[]; + "@aws-cdk-containers/ecs-service-extensions:enableDefaultLogDriver": boolean; + "@aws-cdk/aws-ec2:uniqueImdsv2TemplateName": boolean; + "@aws-cdk/aws-ecs:arnFormatIncludesClusterName": boolean; + "@aws-cdk/aws-iam:minimizePolicies": boolean; + "@aws-cdk/core:validateSnapshotRemovalPolicy": boolean; + "@aws-cdk/aws-codepipeline:crossAccountKeyAliasStackSafeResourceName": boolean; + "@aws-cdk/aws-s3:createDefaultLoggingPolicy": boolean; + "@aws-cdk/aws-sns-subscriptions:restrictSqsDescryption": boolean; + "@aws-cdk/aws-apigateway:disableCloudWatchRole": boolean; + "@aws-cdk/core:enablePartitionLiterals": boolean; + "@aws-cdk/aws-events:eventsTargetQueueSameAccount": boolean; + "@aws-cdk/aws-ecs:disableExplicitDeploymentControllerForCircuitBreaker": boolean; + "@aws-cdk/aws-iam:importedRoleStackSafeDefaultPolicyName": boolean; + "@aws-cdk/aws-s3:serverAccessLogsUseBucketPolicy": boolean; + "@aws-cdk/aws-route53-patters:useCertificate": boolean; + "@aws-cdk/customresources:installLatestAwsSdkDefault": boolean; + "@aws-cdk/aws-rds:databaseProxyUniqueResourceName": boolean; + "@aws-cdk/aws-codedeploy:removeAlarmsFromDeploymentGroup": boolean; + "@aws-cdk/aws-apigateway:authorizerChangeDeploymentLogicalId": boolean; + "@aws-cdk/aws-ec2:launchTemplateDefaultUserData": boolean; + "@aws-cdk/aws-secretsmanager:useAttachedSecretResourcePolicyForSecretTargetAttachments": boolean; + "@aws-cdk/aws-redshift:columnId": boolean; + "@aws-cdk/aws-stepfunctions-tasks:enableEmrServicePolicyV2": boolean; + "@aws-cdk/aws-ec2:restrictDefaultSecurityGroup": boolean; + "@aws-cdk/aws-apigateway:requestValidatorUniqueId": boolean; + "@aws-cdk/aws-kms:aliasNameRef": boolean; + "@aws-cdk/aws-autoscaling:generateLaunchTemplateInsteadOfLaunchConfig": boolean; + "@aws-cdk/core:includePrefixInUniqueNameGeneration": boolean; + "@aws-cdk/aws-efs:denyAnonymousAccess": boolean; + "@aws-cdk/aws-opensearchservice:enableOpensearchMultiAzWithStandby": boolean; + "@aws-cdk/aws-lambda-nodejs:useLatestRuntimeVersion": boolean; + "@aws-cdk/aws-efs:mountTargetOrderInsensitiveLogicalId": boolean; + "@aws-cdk/aws-rds:auroraClusterChangeScopeOfInstanceParameterGroupWithEachParameters": boolean; + "@aws-cdk/aws-appsync:useArnForSourceApiAssociationIdentifier": boolean; + "@aws-cdk/aws-rds:preventRenderingDeprecatedCredentials": boolean; + "@aws-cdk/aws-codepipeline-actions:useNewDefaultBranchForCodeCommitSource": boolean; + "@aws-cdk/aws-cloudwatch-actions:changeLambdaPermissionLogicalIdForLambdaAction": boolean; + "@aws-cdk/aws-codepipeline:crossAccountKeysDefaultValueToFalse": boolean; + "@aws-cdk/aws-codepipeline:defaultPipelineTypeToV2": boolean; + "@aws-cdk/aws-kms:reduceCrossAccountRegionPolicyScope": boolean; + "@aws-cdk/aws-eks:nodegroupNameAttribute": boolean; + "@aws-cdk/aws-ec2:ebsDefaultGp3Volume": boolean; + "@aws-cdk/aws-ecs:removeDefaultDeploymentAlarm": boolean; + "@aws-cdk/custom-resources:logApiResponseDataPropertyTrueDefault": boolean; + "@aws-cdk/aws-s3:keepNotificationInImportedBucket": boolean; + "@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature": boolean; + "@aws-cdk/aws-ecs:disableEcsImdsBlocking": boolean; + "@aws-cdk/aws-ecs:reduceEc2FargateCloudWatchPermissions": boolean; + "@aws-cdk/aws-dynamodb:resourcePolicyPerReplica": boolean; + "@aws-cdk/aws-ec2:ec2SumTImeoutEnabled": boolean; + "@aws-cdk/aws-appsync:appSyncGraphQLAPIScopeLambdaPermission": boolean; + "@aws-cdk/aws-rds:setCorrectValueForDatabaseInstanceReadReplicaInstanceResourceId": boolean; + "@aws-cdk/core:cfnIncludeRejectComplexResourceUpdateCreatePolicyIntrinsics": boolean; + "@aws-cdk/aws-lambda-nodejs:sdkV3ExcludeSmithyPackages": boolean; + "@aws-cdk/aws-stepfunctions-tasks:fixRunEcsTaskPolicy": boolean; + "@aws-cdk/aws-ec2:bastionHostUseAmazonLinux2023ByDefault": boolean; + "@aws-cdk/aws-route53-targets:userPoolDomainNameMethodWithoutCustomResource": boolean; + "@aws-cdk/aws-elasticloadbalancingV2:albDualstackWithoutPublicIpv4SecurityGroupRulesDefault": boolean; + "@aws-cdk/aws-iam:oidcRejectUnauthorizedConnections": boolean; + "@aws-cdk/core:enableAdditionalMetadataCollection": boolean; + "@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy": boolean; + "@aws-cdk/aws-s3:setUniqueReplicationRoleName": boolean; +}; diff --git a/packages/@aws-cdk/integ-runner/lib/runner/runner-base.js b/packages/@aws-cdk/integ-runner/lib/runner/runner-base.js new file mode 100644 index 000000000..a4b298f33 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/runner/runner-base.js @@ -0,0 +1,319 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.DEFAULT_SYNTH_OPTIONS = exports.IntegRunner = void 0; +exports.currentlyRecommendedAwsCdkLibFlags = currentlyRecommendedAwsCdkLibFlags; +/* eslint-disable @cdklabs/no-literal-partition */ +const path = require("path"); +const cdk_cli_wrapper_1 = require("@aws-cdk/cdk-cli-wrapper"); +const cx_api_1 = require("@aws-cdk/cx-api"); +const fs = require("fs-extra"); +const integ_test_suite_1 = require("./integ-test-suite"); +const recommendedFlagsFile = require("../recommended-feature-flags.json"); +const utils_1 = require("../utils"); +const cloud_assembly_1 = require("./private/cloud-assembly"); +const DESTRUCTIVE_CHANGES = '!!DESTRUCTIVE_CHANGES:'; +/** + * The different components of a test name + */ +/** + * Represents an Integration test runner + */ +class IntegRunner { + constructor(options) { + /** + * Default options to pass to the CDK CLI + */ + this.defaultArgs = { + pathMetadata: false, + assetMetadata: false, + versionReporting: false, + }; + this.test = options.test; + this.directory = this.test.directory; + this.testName = this.test.testName; + this.snapshotDir = this.test.snapshotDir; + this.cdkContextPath = path.join(this.directory, 'cdk.context.json'); + this.cdk = options.cdk ?? new cdk_cli_wrapper_1.CdkCliWrapper({ + directory: this.directory, + showOutput: options.showOutput, + env: { + ...options.env, + }, + }); + this.cdkOutDir = options.integOutDir ?? this.test.temporaryOutputDir; + const testRunCommand = this.test.appCommand; + this.cdkApp = testRunCommand.replace('{filePath}', path.relative(this.directory, this.test.fileName)); + this.profile = options.profile; + if (this.hasSnapshot()) { + this.expectedTestSuite = this.loadManifest(); + } + this.actualTestSuite = this.generateActualSnapshot(); + } + /** + * Return the list of expected (i.e. existing) test cases for this integration test + */ + expectedTests() { + return this.expectedTestSuite?.testSuite; + } + /** + * Return the list of actual (i.e. new) test cases for this integration test + */ + actualTests() { + return this.actualTestSuite.testSuite; + } + /** + * Generate a new "actual" snapshot which will be compared to the + * existing "expected" snapshot + * This will synth and then load the integration test manifest + */ + generateActualSnapshot() { + this.cdk.synthFast({ + execCmd: this.cdkApp.split(' '), + env: { + ...exports.DEFAULT_SYNTH_OPTIONS.env, + // we don't know the "actual" context yet (this method is what generates it) so just + // use the "expected" context. This is only run in order to read the manifest + CDK_CONTEXT_JSON: JSON.stringify(this.getContext(this.expectedTestSuite?.synthContext)), + }, + output: path.relative(this.directory, this.cdkOutDir), + }); + const manifest = this.loadManifest(this.cdkOutDir); + // after we load the manifest remove the tmp snapshot + // so that it doesn't mess up the real snapshot created later + this.cleanup(); + return manifest; + } + /** + * Returns true if a snapshot already exists for this test + */ + hasSnapshot() { + return fs.existsSync(this.snapshotDir); + } + /** + * Load the integ manifest which contains information + * on how to execute the tests + * First we try and load the manifest from the integ manifest (i.e. integ.json) + * from the cloud assembly. If it doesn't exist, then we fallback to the + * "legacy mode" and create a manifest from pragma + */ + loadManifest(dir) { + try { + const testSuite = integ_test_suite_1.IntegTestSuite.fromPath(dir ?? this.snapshotDir); + return testSuite; + } + catch { + const testCases = integ_test_suite_1.LegacyIntegTestSuite.fromLegacy({ + cdk: this.cdk, + testName: this.test.normalizedTestName, + integSourceFilePath: this.test.fileName, + listOptions: { + ...this.defaultArgs, + all: true, + app: this.cdkApp, + profile: this.profile, + output: path.relative(this.directory, this.cdkOutDir), + }, + }); + this.legacyContext = integ_test_suite_1.LegacyIntegTestSuite.getPragmaContext(this.test.fileName); + this.isLegacyTest = true; + return testCases; + } + } + cleanup() { + const cdkOutPath = this.cdkOutDir; + if (fs.existsSync(cdkOutPath)) { + fs.removeSync(cdkOutPath); + } + } + /** + * If there are any destructive changes to a stack then this will record + * those in the manifest.json file + */ + renderTraceData() { + const traceData = new Map(); + const destructiveChanges = this._destructiveChanges ?? []; + destructiveChanges.forEach(change => { + const trace = traceData.get(change.stackName); + if (trace) { + trace.set(change.logicalId, `${DESTRUCTIVE_CHANGES} ${change.impact}`); + } + else { + traceData.set(change.stackName, new Map([ + [change.logicalId, `${DESTRUCTIVE_CHANGES} ${change.impact}`], + ])); + } + }); + return traceData; + } + /** + * In cases where we do not want to retain the assets, + * for example, if the assets are very large. + * + * Since it is possible to disable the update workflow for individual test + * cases, this needs to first get a list of stacks that have the update workflow + * disabled and then delete assets that relate to that stack. It does that + * by reading the asset manifest for the stack and deleting the asset source + */ + removeAssetsFromSnapshot() { + const stacks = this.actualTestSuite.getStacksWithoutUpdateWorkflow() ?? []; + const manifest = cloud_assembly_1.AssemblyManifestReader.fromPath(this.snapshotDir); + const assets = (0, utils_1.flatten)(stacks.map(stack => { + return manifest.getAssetLocationsForStack(stack) ?? []; + })); + assets.forEach(asset => { + const fileName = path.join(this.snapshotDir, asset); + if (fs.existsSync(fileName)) { + if (fs.lstatSync(fileName).isDirectory()) { + fs.removeSync(fileName); + } + else { + fs.unlinkSync(fileName); + } + } + }); + } + /** + * Remove the asset cache (.cache/) files from the snapshot. + * These are a cache of the asset zips, but we are fine with + * re-zipping on deploy + */ + removeAssetsCacheFromSnapshot() { + const files = fs.readdirSync(this.snapshotDir); + files.forEach(file => { + const fileName = path.join(this.snapshotDir, file); + if (fs.lstatSync(fileName).isDirectory() && file === '.cache') { + fs.emptyDirSync(fileName); + fs.rmdirSync(fileName); + } + }); + } + /** + * Create the new snapshot. + * + * If lookups are enabled, then we need create the snapshot by synthing again + * with the dummy context so that each time the test is run on different machines + * (and with different context/env) the diff will not change. + * + * If lookups are disabled (which means the stack is env agnostic) then just copy + * the assembly that was output by the deployment + */ + createSnapshot() { + if (fs.existsSync(this.snapshotDir)) { + fs.removeSync(this.snapshotDir); + } + // if lookups are enabled then we need to synth again + // using dummy context and save that as the snapshot + if (this.actualTestSuite.enableLookups) { + this.cdk.synthFast({ + execCmd: this.cdkApp.split(' '), + env: { + ...exports.DEFAULT_SYNTH_OPTIONS.env, + CDK_CONTEXT_JSON: JSON.stringify(this.getContext(exports.DEFAULT_SYNTH_OPTIONS.context)), + }, + output: path.relative(this.directory, this.snapshotDir), + }); + } + else { + fs.moveSync(this.cdkOutDir, this.snapshotDir, { overwrite: true }); + } + this.cleanupSnapshot(); + } + /** + * Perform some cleanup steps after the snapshot is created + * Anytime the snapshot needs to be modified after creation + * the logic should live here. + */ + cleanupSnapshot() { + if (fs.existsSync(this.snapshotDir)) { + this.removeAssetsFromSnapshot(); + this.removeAssetsCacheFromSnapshot(); + const assembly = cloud_assembly_1.AssemblyManifestReader.fromPath(this.snapshotDir); + assembly.cleanManifest(); + assembly.recordTrace(this.renderTraceData()); + } + // if this is a legacy test then create an integ manifest + // in the snapshot directory which can be used for the + // update workflow. Save any legacyContext as well so that it can be read + // the next time + if (this.actualTestSuite.type === 'legacy-test-suite') { + this.actualTestSuite.saveManifest(this.snapshotDir, this.legacyContext); + } + } + getContext(additionalContext) { + return { + ...currentlyRecommendedAwsCdkLibFlags(), + ...this.legacyContext, + ...additionalContext, + // We originally had PLANNED to set this to ['aws', 'aws-cn'], but due to a programming mistake + // it was set to everything. In this PR, set it to everything to not mess up all the snapshots. + [cx_api_1.TARGET_PARTITIONS]: undefined, + /* ---------------- THE FUTURE LIVES BELOW---------------------------- + // Restricting to these target partitions makes most service principals synthesize to + // `service.${URL_SUFFIX}`, which is technically *incorrect* (it's only `amazonaws.com` + // or `amazonaws.com.cn`, never UrlSuffix for any of the restricted regions) but it's what + // most existing integ tests contain, and we want to disturb as few as possible. + // [TARGET_PARTITIONS]: ['aws', 'aws-cn'], + /* ---------------- END OF THE FUTURE ------------------------------- */ + }; + } +} +exports.IntegRunner = IntegRunner; +// Default context we run all integ tests with, so they don't depend on the +// account of the exercising user. +exports.DEFAULT_SYNTH_OPTIONS = { + context: { + [cx_api_1.AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY]: ['test-region-1a', 'test-region-1b', 'test-region-1c'], + 'availability-zones:account=12345678:region=test-region': ['test-region-1a', 'test-region-1b', 'test-region-1c'], + 'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn-ami-hvm-x86_64-gp2:region=test-region': 'ami-1234', + 'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2:region=test-region': 'ami-1234', + 'ssm:account=12345678:parameterName=/aws/service/ecs/optimized-ami/amazon-linux/recommended:region=test-region': '{"image_id": "ami-1234"}', + // eslint-disable-next-line max-len + 'ami:account=12345678:filters.image-type.0=machine:filters.name.0=amzn-ami-vpc-nat-*:filters.state.0=available:owners.0=amazon:region=test-region': 'ami-1234', + 'vpc-provider:account=12345678:filter.isDefault=true:region=test-region:returnAsymmetricSubnets=true': { + vpcId: 'vpc-60900905', + subnetGroups: [ + { + type: 'Public', + name: 'Public', + subnets: [ + { + subnetId: 'subnet-e19455ca', + availabilityZone: 'us-east-1a', + routeTableId: 'rtb-e19455ca', + }, + { + subnetId: 'subnet-e0c24797', + availabilityZone: 'us-east-1b', + routeTableId: 'rtb-e0c24797', + }, + { + subnetId: 'subnet-ccd77395', + availabilityZone: 'us-east-1c', + routeTableId: 'rtb-ccd77395', + }, + ], + }, + ], + }, + }, + env: { + CDK_INTEG_ACCOUNT: '12345678', + CDK_INTEG_REGION: 'test-region', + CDK_INTEG_HOSTED_ZONE_ID: 'Z23ABC4XYZL05B', + CDK_INTEG_HOSTED_ZONE_NAME: 'example.com', + CDK_INTEG_DOMAIN_NAME: '*.example.com', + CDK_INTEG_CERT_ARN: 'arn:aws:acm:test-region:12345678:certificate/86468209-a272-595d-b831-0efb6421265z', + CDK_INTEG_SUBNET_ID: 'subnet-0dff1a399d8f6f92c', + }, +}; +/** + * Return the currently recommended flags for `aws-cdk-lib`. + * + * These have been built into the CLI at build time. If this ever gets changed + * back to a dynamic load, remember that this source file may be bundled into + * a JavaScript bundle, and `__dirname` might not point where you think it does. + */ +function currentlyRecommendedAwsCdkLibFlags() { + return recommendedFlagsFile; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runner-base.js","sourceRoot":"","sources":["runner-base.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @cdklabs/no-literal-partition */\nimport * as path from 'path';\nimport type { ICdk } from '@aws-cdk/cdk-cli-wrapper';\nimport { CdkCliWrapper } from '@aws-cdk/cdk-cli-wrapper';\nimport type { TestCase, DefaultCdkOptions } from '@aws-cdk/cloud-assembly-schema';\nimport { AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY, TARGET_PARTITIONS } from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport { IntegTestSuite, LegacyIntegTestSuite } from './integ-test-suite';\nimport type { IntegTest } from './integration-tests';\nimport * as recommendedFlagsFile from '../recommended-feature-flags.json';\nimport { flatten } from '../utils';\nimport type { ManifestTrace } from './private/cloud-assembly';\nimport { AssemblyManifestReader } from './private/cloud-assembly';\nimport type { DestructiveChange } from '../workers/common';\n\nconst DESTRUCTIVE_CHANGES = '!!DESTRUCTIVE_CHANGES:';\n\n/**\n * Options for creating an integration test runner\n */\nexport interface IntegRunnerOptions {\n  /**\n   * Information about the test to run\n   */\n  readonly test: IntegTest;\n\n  /**\n   * The AWS profile to use when invoking the CDK CLI\n   *\n   * @default - no profile is passed, the default profile is used\n   */\n  readonly profile?: string;\n\n  /**\n   * Additional environment variables that will be available\n   * to the CDK CLI\n   *\n   * @default - no additional environment variables\n   */\n  readonly env?: { [name: string]: string };\n\n  /**\n   * tmp cdk.out directory\n   *\n   * @default - directory will be `cdk-integ.out.${testName}`\n   */\n  readonly integOutDir?: string;\n\n  /**\n   * Instance of the CDK CLI to use\n   *\n   * @default - CdkCliWrapper\n   */\n  readonly cdk?: ICdk;\n\n  /**\n   * Show output from running integration tests\n   *\n   * @default false\n   */\n  readonly showOutput?: boolean;\n}\n\n/**\n * The different components of a test name\n */\n/**\n * Represents an Integration test runner\n */\nexport abstract class IntegRunner {\n  /**\n   * The directory where the snapshot will be stored\n   */\n  public readonly snapshotDir: string;\n\n  /**\n   * An instance of the CDK  CLI\n   */\n  public readonly cdk: ICdk;\n\n  /**\n   * Pretty name of the test\n   */\n  public readonly testName: string;\n\n  /**\n   * The value used in the '--app' CLI parameter\n   *\n   * Path to the integ test source file, relative to `this.directory`.\n   */\n  protected readonly cdkApp: string;\n\n  /**\n   * The path where the `cdk.context.json` file\n   * will be created\n   */\n  protected readonly cdkContextPath: string;\n\n  /**\n   * The test suite from the existing snapshot\n   */\n  protected readonly expectedTestSuite?: IntegTestSuite | LegacyIntegTestSuite;\n\n  /**\n   * The test suite from the new \"actual\" snapshot\n   */\n  protected readonly actualTestSuite: IntegTestSuite | LegacyIntegTestSuite;\n\n  /**\n   * The working directory that the integration tests will be\n   * executed from\n   */\n  protected readonly directory: string;\n\n  /**\n   * The test to run\n   */\n  protected readonly test: IntegTest;\n\n  /**\n   * Default options to pass to the CDK CLI\n   */\n  protected readonly defaultArgs: DefaultCdkOptions = {\n    pathMetadata: false,\n    assetMetadata: false,\n    versionReporting: false,\n  };\n\n  /**\n   * The directory where the CDK will be synthed to\n   *\n   * Relative to cwd.\n   */\n  protected readonly cdkOutDir: string;\n\n  protected readonly profile?: string;\n\n  protected _destructiveChanges?: DestructiveChange[];\n  private legacyContext?: Record<string, any>;\n  protected isLegacyTest?: boolean;\n\n  constructor(options: IntegRunnerOptions) {\n    this.test = options.test;\n    this.directory = this.test.directory;\n    this.testName = this.test.testName;\n    this.snapshotDir = this.test.snapshotDir;\n    this.cdkContextPath = path.join(this.directory, 'cdk.context.json');\n\n    this.cdk = options.cdk ?? new CdkCliWrapper({\n      directory: this.directory,\n      showOutput: options.showOutput,\n      env: {\n        ...options.env,\n      },\n    });\n    this.cdkOutDir = options.integOutDir ?? this.test.temporaryOutputDir;\n\n    const testRunCommand = this.test.appCommand;\n    this.cdkApp = testRunCommand.replace('{filePath}', path.relative(this.directory, this.test.fileName));\n\n    this.profile = options.profile;\n    if (this.hasSnapshot()) {\n      this.expectedTestSuite = this.loadManifest();\n    }\n    this.actualTestSuite = this.generateActualSnapshot();\n  }\n\n  /**\n   * Return the list of expected (i.e. existing) test cases for this integration test\n   */\n  public expectedTests(): { [testName: string]: TestCase } | undefined {\n    return this.expectedTestSuite?.testSuite;\n  }\n\n  /**\n   * Return the list of actual (i.e. new) test cases for this integration test\n   */\n  public actualTests(): { [testName: string]: TestCase } | undefined {\n    return this.actualTestSuite.testSuite;\n  }\n\n  /**\n   * Generate a new \"actual\" snapshot which will be compared to the\n   * existing \"expected\" snapshot\n   * This will synth and then load the integration test manifest\n   */\n  public generateActualSnapshot(): IntegTestSuite | LegacyIntegTestSuite {\n    this.cdk.synthFast({\n      execCmd: this.cdkApp.split(' '),\n      env: {\n        ...DEFAULT_SYNTH_OPTIONS.env,\n        // we don't know the \"actual\" context yet (this method is what generates it) so just\n        // use the \"expected\" context. This is only run in order to read the manifest\n        CDK_CONTEXT_JSON: JSON.stringify(this.getContext(this.expectedTestSuite?.synthContext)),\n      },\n      output: path.relative(this.directory, this.cdkOutDir),\n    });\n    const manifest = this.loadManifest(this.cdkOutDir);\n    // after we load the manifest remove the tmp snapshot\n    // so that it doesn't mess up the real snapshot created later\n    this.cleanup();\n    return manifest;\n  }\n\n  /**\n   * Returns true if a snapshot already exists for this test\n   */\n  public hasSnapshot(): boolean {\n    return fs.existsSync(this.snapshotDir);\n  }\n\n  /**\n   * Load the integ manifest which contains information\n   * on how to execute the tests\n   * First we try and load the manifest from the integ manifest (i.e. integ.json)\n   * from the cloud assembly. If it doesn't exist, then we fallback to the\n   * \"legacy mode\" and create a manifest from pragma\n   */\n  protected loadManifest(dir?: string): IntegTestSuite | LegacyIntegTestSuite {\n    try {\n      const testSuite = IntegTestSuite.fromPath(dir ?? this.snapshotDir);\n      return testSuite;\n    } catch {\n      const testCases = LegacyIntegTestSuite.fromLegacy({\n        cdk: this.cdk,\n        testName: this.test.normalizedTestName,\n        integSourceFilePath: this.test.fileName,\n        listOptions: {\n          ...this.defaultArgs,\n          all: true,\n          app: this.cdkApp,\n          profile: this.profile,\n          output: path.relative(this.directory, this.cdkOutDir),\n        },\n      });\n      this.legacyContext = LegacyIntegTestSuite.getPragmaContext(this.test.fileName);\n      this.isLegacyTest = true;\n      return testCases;\n    }\n  }\n\n  protected cleanup(): void {\n    const cdkOutPath = this.cdkOutDir;\n    if (fs.existsSync(cdkOutPath)) {\n      fs.removeSync(cdkOutPath);\n    }\n  }\n\n  /**\n   * If there are any destructive changes to a stack then this will record\n   * those in the manifest.json file\n   */\n  private renderTraceData(): ManifestTrace {\n    const traceData: ManifestTrace = new Map();\n    const destructiveChanges = this._destructiveChanges ?? [];\n    destructiveChanges.forEach(change => {\n      const trace = traceData.get(change.stackName);\n      if (trace) {\n        trace.set(change.logicalId, `${DESTRUCTIVE_CHANGES} ${change.impact}`);\n      } else {\n        traceData.set(change.stackName, new Map([\n          [change.logicalId, `${DESTRUCTIVE_CHANGES} ${change.impact}`],\n        ]));\n      }\n    });\n    return traceData;\n  }\n\n  /**\n   * In cases where we do not want to retain the assets,\n   * for example, if the assets are very large.\n   *\n   * Since it is possible to disable the update workflow for individual test\n   * cases, this needs to first get a list of stacks that have the update workflow\n   * disabled and then delete assets that relate to that stack. It does that\n   * by reading the asset manifest for the stack and deleting the asset source\n   */\n  protected removeAssetsFromSnapshot(): void {\n    const stacks = this.actualTestSuite.getStacksWithoutUpdateWorkflow() ?? [];\n    const manifest = AssemblyManifestReader.fromPath(this.snapshotDir);\n    const assets = flatten(stacks.map(stack => {\n      return manifest.getAssetLocationsForStack(stack) ?? [];\n    }));\n\n    assets.forEach(asset => {\n      const fileName = path.join(this.snapshotDir, asset);\n      if (fs.existsSync(fileName)) {\n        if (fs.lstatSync(fileName).isDirectory()) {\n          fs.removeSync(fileName);\n        } else {\n          fs.unlinkSync(fileName);\n        }\n      }\n    });\n  }\n\n  /**\n   * Remove the asset cache (.cache/) files from the snapshot.\n   * These are a cache of the asset zips, but we are fine with\n   * re-zipping on deploy\n   */\n  protected removeAssetsCacheFromSnapshot(): void {\n    const files = fs.readdirSync(this.snapshotDir);\n    files.forEach(file => {\n      const fileName = path.join(this.snapshotDir, file);\n      if (fs.lstatSync(fileName).isDirectory() && file === '.cache') {\n        fs.emptyDirSync(fileName);\n        fs.rmdirSync(fileName);\n      }\n    });\n  }\n\n  /**\n   * Create the new snapshot.\n   *\n   * If lookups are enabled, then we need create the snapshot by synthing again\n   * with the dummy context so that each time the test is run on different machines\n   * (and with different context/env) the diff will not change.\n   *\n   * If lookups are disabled (which means the stack is env agnostic) then just copy\n   * the assembly that was output by the deployment\n   */\n  protected createSnapshot(): void {\n    if (fs.existsSync(this.snapshotDir)) {\n      fs.removeSync(this.snapshotDir);\n    }\n\n    // if lookups are enabled then we need to synth again\n    // using dummy context and save that as the snapshot\n    if (this.actualTestSuite.enableLookups) {\n      this.cdk.synthFast({\n        execCmd: this.cdkApp.split(' '),\n        env: {\n          ...DEFAULT_SYNTH_OPTIONS.env,\n          CDK_CONTEXT_JSON: JSON.stringify(this.getContext(DEFAULT_SYNTH_OPTIONS.context)),\n        },\n        output: path.relative(this.directory, this.snapshotDir),\n      });\n    } else {\n      fs.moveSync(this.cdkOutDir, this.snapshotDir, { overwrite: true });\n    }\n\n    this.cleanupSnapshot();\n  }\n\n  /**\n   * Perform some cleanup steps after the snapshot is created\n   * Anytime the snapshot needs to be modified after creation\n   * the logic should live here.\n   */\n  private cleanupSnapshot(): void {\n    if (fs.existsSync(this.snapshotDir)) {\n      this.removeAssetsFromSnapshot();\n      this.removeAssetsCacheFromSnapshot();\n      const assembly = AssemblyManifestReader.fromPath(this.snapshotDir);\n      assembly.cleanManifest();\n      assembly.recordTrace(this.renderTraceData());\n    }\n\n    // if this is a legacy test then create an integ manifest\n    // in the snapshot directory which can be used for the\n    // update workflow. Save any legacyContext as well so that it can be read\n    // the next time\n    if (this.actualTestSuite.type === 'legacy-test-suite') {\n      (this.actualTestSuite as LegacyIntegTestSuite).saveManifest(this.snapshotDir, this.legacyContext);\n    }\n  }\n\n  protected getContext(additionalContext?: Record<string, any>): Record<string, any> {\n    return {\n      ...currentlyRecommendedAwsCdkLibFlags(),\n      ...this.legacyContext,\n      ...additionalContext,\n\n      // We originally had PLANNED to set this to ['aws', 'aws-cn'], but due to a programming mistake\n      // it was set to everything. In this PR, set it to everything to not mess up all the snapshots.\n      [TARGET_PARTITIONS]: undefined,\n\n      /* ---------------- THE FUTURE LIVES BELOW----------------------------\n      // Restricting to these target partitions makes most service principals synthesize to\n      // `service.${URL_SUFFIX}`, which is technically *incorrect* (it's only `amazonaws.com`\n      // or `amazonaws.com.cn`, never UrlSuffix for any of the restricted regions) but it's what\n      // most existing integ tests contain, and we want to disturb as few as possible.\n      // [TARGET_PARTITIONS]: ['aws', 'aws-cn'],\n      /* ---------------- END OF THE FUTURE ------------------------------- */\n    };\n  }\n}\n\n// Default context we run all integ tests with, so they don't depend on the\n// account of the exercising user.\nexport const DEFAULT_SYNTH_OPTIONS = {\n  context: {\n    [AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY]: ['test-region-1a', 'test-region-1b', 'test-region-1c'],\n    'availability-zones:account=12345678:region=test-region': ['test-region-1a', 'test-region-1b', 'test-region-1c'],\n    'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn-ami-hvm-x86_64-gp2:region=test-region': 'ami-1234',\n    'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2:region=test-region': 'ami-1234',\n    'ssm:account=12345678:parameterName=/aws/service/ecs/optimized-ami/amazon-linux/recommended:region=test-region': '{\"image_id\": \"ami-1234\"}',\n    // eslint-disable-next-line max-len\n    'ami:account=12345678:filters.image-type.0=machine:filters.name.0=amzn-ami-vpc-nat-*:filters.state.0=available:owners.0=amazon:region=test-region': 'ami-1234',\n    'vpc-provider:account=12345678:filter.isDefault=true:region=test-region:returnAsymmetricSubnets=true': {\n      vpcId: 'vpc-60900905',\n      subnetGroups: [\n        {\n          type: 'Public',\n          name: 'Public',\n          subnets: [\n            {\n              subnetId: 'subnet-e19455ca',\n              availabilityZone: 'us-east-1a',\n              routeTableId: 'rtb-e19455ca',\n            },\n            {\n              subnetId: 'subnet-e0c24797',\n              availabilityZone: 'us-east-1b',\n              routeTableId: 'rtb-e0c24797',\n            },\n            {\n              subnetId: 'subnet-ccd77395',\n              availabilityZone: 'us-east-1c',\n              routeTableId: 'rtb-ccd77395',\n            },\n          ],\n        },\n      ],\n    },\n  },\n  env: {\n    CDK_INTEG_ACCOUNT: '12345678',\n    CDK_INTEG_REGION: 'test-region',\n    CDK_INTEG_HOSTED_ZONE_ID: 'Z23ABC4XYZL05B',\n    CDK_INTEG_HOSTED_ZONE_NAME: 'example.com',\n    CDK_INTEG_DOMAIN_NAME: '*.example.com',\n    CDK_INTEG_CERT_ARN: 'arn:aws:acm:test-region:12345678:certificate/86468209-a272-595d-b831-0efb6421265z',\n    CDK_INTEG_SUBNET_ID: 'subnet-0dff1a399d8f6f92c',\n  },\n};\n\n/**\n * Return the currently recommended flags for `aws-cdk-lib`.\n *\n * These have been built into the CLI at build time. If this ever gets changed\n * back to a dynamic load, remember that this source file may be bundled into\n * a JavaScript bundle, and `__dirname` might not point where you think it does.\n */\nexport function currentlyRecommendedAwsCdkLibFlags() {\n  return recommendedFlagsFile;\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/integ-runner/lib/runner/snapshot-test-runner.d.ts b/packages/@aws-cdk/integ-runner/lib/runner/snapshot-test-runner.d.ts new file mode 100644 index 000000000..d2d733b82 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/runner/snapshot-test-runner.d.ts @@ -0,0 +1,53 @@ +import type { IntegRunnerOptions } from './runner-base'; +import { IntegRunner } from './runner-base'; +import type { Diagnostic, DestructiveChange, SnapshotVerificationOptions } from '../workers/common'; +/** + * Runner for snapshot tests. This handles orchestrating + * the validation of the integration test snapshots + */ +export declare class IntegSnapshotRunner extends IntegRunner { + constructor(options: IntegRunnerOptions); + /** + * Synth the integration tests and compare the templates + * to the existing snapshot. + * + * @returns any diagnostics and any destructive changes + */ + testSnapshot(options?: SnapshotVerificationOptions): { + diagnostics: Diagnostic[]; + destructiveChanges: DestructiveChange[]; + }; + /** + * For a given cloud assembly return a collection of all templates + * that should be part of the snapshot and any required meta data. + * + * @param cloudAssemblyDir The directory of the cloud assembly to look for snapshots + * @param pickStacks Pick only these stacks from the cloud assembly + * @returns A SnapshotAssembly, the collection of all templates in this snapshot and required meta data + */ + private getSnapshotAssembly; + /** + * For a given stack return all resource types that are allowed to be destroyed + * as part of a stack update + * + * @param stackId the stack id + * @returns a list of resource types or undefined if none are found + */ + private getAllowedDestroyTypesForStack; + /** + * Find any differences between the existing and expected snapshots + * + * @param existing - the existing (expected) snapshot + * @param actual - the new (actual) snapshot + * @returns any diagnostics and any destructive changes + */ + private diffAssembly; + private readAssembly; + /** + * Reduce template to a normal form where asset references have been normalized + * + * This makes it possible to compare templates if all that's different between + * them is the hashes of the asset values. + */ + private canonicalizeTemplate; +} diff --git a/packages/@aws-cdk/integ-runner/lib/runner/snapshot-test-runner.js b/packages/@aws-cdk/integ-runner/lib/runner/snapshot-test-runner.js new file mode 100644 index 000000000..f7728be43 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/runner/snapshot-test-runner.js @@ -0,0 +1,321 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.IntegSnapshotRunner = void 0; +const path = require("path"); +const stream_1 = require("stream"); +const string_decoder_1 = require("string_decoder"); +const cloudformation_diff_1 = require("@aws-cdk/cloudformation-diff"); +const cloud_assembly_1 = require("./private/cloud-assembly"); +const runner_base_1 = require("./runner-base"); +const common_1 = require("../workers/common"); +/** + * Runner for snapshot tests. This handles orchestrating + * the validation of the integration test snapshots + */ +class IntegSnapshotRunner extends runner_base_1.IntegRunner { + constructor(options) { + super(options); + } + /** + * Synth the integration tests and compare the templates + * to the existing snapshot. + * + * @returns any diagnostics and any destructive changes + */ + testSnapshot(options = {}) { + let doClean = true; + try { + const expectedSnapshotAssembly = this.getSnapshotAssembly(this.snapshotDir, this.expectedTestSuite?.stacks); + // synth the integration test + // FIXME: ideally we should not need to run this again if + // the cdkOutDir exists already, but for some reason generateActualSnapshot + // generates an incorrect snapshot and I have no idea why so synth again here + // to produce the "correct" snapshot + const env = { + ...runner_base_1.DEFAULT_SYNTH_OPTIONS.env, + CDK_CONTEXT_JSON: JSON.stringify(this.getContext({ + ...this.actualTestSuite.enableLookups ? runner_base_1.DEFAULT_SYNTH_OPTIONS.context : {}, + })), + }; + this.cdk.synthFast({ + execCmd: this.cdkApp.split(' '), + env, + output: path.relative(this.directory, this.cdkOutDir), + }); + // read the "actual" snapshot + const actualSnapshotAssembly = this.getSnapshotAssembly(this.cdkOutDir, this.actualTestSuite.stacks); + // diff the existing snapshot (expected) with the integration test (actual) + const diagnostics = this.diffAssembly(expectedSnapshotAssembly, actualSnapshotAssembly); + if (diagnostics.diagnostics.length) { + // Attach additional messages to the first diagnostic + const additionalMessages = []; + if (options.retain) { + additionalMessages.push(`(Failure retained) Expected: ${path.relative(process.cwd(), this.snapshotDir)}`, ` Actual: ${path.relative(process.cwd(), this.cdkOutDir)}`), + doClean = false; + } + if (options.verbose) { + // Show the command necessary to repro this + const envSet = Object.entries(env) + .filter(([k, _]) => k !== 'CDK_CONTEXT_JSON') + .map(([k, v]) => `${k}='${v}'`); + const envCmd = envSet.length > 0 ? ['env', ...envSet] : []; + additionalMessages.push('Repro:', ` ${[...envCmd, 'cdk synth', `-a '${this.cdkApp}'`, `-o '${this.cdkOutDir}'`, ...Object.entries(this.getContext()).flatMap(([k, v]) => typeof v !== 'object' ? [`-c '${k}=${v}'`] : [])].join(' ')}`); + } + diagnostics.diagnostics[0] = { + ...diagnostics.diagnostics[0], + additionalMessages, + }; + } + return diagnostics; + } + catch (e) { + throw e; + } + finally { + if (doClean) { + this.cleanup(); + } + } + } + /** + * For a given cloud assembly return a collection of all templates + * that should be part of the snapshot and any required meta data. + * + * @param cloudAssemblyDir The directory of the cloud assembly to look for snapshots + * @param pickStacks Pick only these stacks from the cloud assembly + * @returns A SnapshotAssembly, the collection of all templates in this snapshot and required meta data + */ + getSnapshotAssembly(cloudAssemblyDir, pickStacks = []) { + const assembly = this.readAssembly(cloudAssemblyDir); + const stacks = assembly.stacks; + const snapshots = {}; + for (const [stackName, stackTemplate] of Object.entries(stacks)) { + if (pickStacks.includes(stackName)) { + const manifest = cloud_assembly_1.AssemblyManifestReader.fromPath(cloudAssemblyDir); + const assets = manifest.getAssetIdsForStack(stackName); + snapshots[stackName] = { + templates: { + [stackName]: stackTemplate, + ...assembly.getNestedStacksForStack(stackName), + }, + assets, + }; + } + } + return snapshots; + } + /** + * For a given stack return all resource types that are allowed to be destroyed + * as part of a stack update + * + * @param stackId the stack id + * @returns a list of resource types or undefined if none are found + */ + getAllowedDestroyTypesForStack(stackId) { + for (const testCase of Object.values(this.actualTests() ?? {})) { + if (testCase.stacks.includes(stackId)) { + return testCase.allowDestroy; + } + } + return undefined; + } + /** + * Find any differences between the existing and expected snapshots + * + * @param existing - the existing (expected) snapshot + * @param actual - the new (actual) snapshot + * @returns any diagnostics and any destructive changes + */ + diffAssembly(expected, actual) { + const failures = []; + const destructiveChanges = []; + // check if there is a CFN template in the current snapshot + // that does not exist in the "actual" snapshot + for (const [stackId, stack] of Object.entries(expected)) { + for (const templateId of Object.keys(stack.templates)) { + if (!actual[stackId]?.templates[templateId]) { + failures.push({ + testName: this.testName, + stackName: templateId, + reason: common_1.DiagnosticReason.SNAPSHOT_FAILED, + message: `${templateId} exists in snapshot, but not in actual`, + }); + } + } + } + for (const [stackId, stack] of Object.entries(actual)) { + for (const templateId of Object.keys(stack.templates)) { + // check if there is a CFN template in the "actual" snapshot + // that does not exist in the current snapshot + if (!expected[stackId]?.templates[templateId]) { + failures.push({ + testName: this.testName, + stackName: templateId, + reason: common_1.DiagnosticReason.SNAPSHOT_FAILED, + message: `${templateId} does not exist in snapshot, but does in actual`, + }); + continue; + } + else { + const config = { + diffAssets: this.actualTestSuite.getOptionsForStack(stackId)?.diffAssets, + }; + let actualTemplate = actual[stackId].templates[templateId]; + let expectedTemplate = expected[stackId].templates[templateId]; + // if we are not verifying asset hashes then remove the specific + // asset hashes from the templates so they are not part of the diff + // comparison + if (!config.diffAssets) { + actualTemplate = this.canonicalizeTemplate(actualTemplate, actual[stackId].assets); + expectedTemplate = this.canonicalizeTemplate(expectedTemplate, expected[stackId].assets); + } + const templateDiff = (0, cloudformation_diff_1.fullDiff)(expectedTemplate, actualTemplate); + if (!templateDiff.isEmpty) { + const allowedDestroyTypes = this.getAllowedDestroyTypesForStack(stackId) ?? []; + // go through all the resource differences and check for any + // "destructive" changes + templateDiff.resources.forEachDifference((logicalId, change) => { + // if the change is a removal it will not show up as a 'changeImpact' + // so need to check for it separately, unless it is a resourceType that + // has been "allowed" to be destroyed + const resourceType = change.oldValue?.Type ?? change.newValue?.Type; + if (resourceType && allowedDestroyTypes.includes(resourceType)) { + return; + } + if (change.isRemoval) { + destructiveChanges.push({ + impact: cloudformation_diff_1.ResourceImpact.WILL_DESTROY, + logicalId, + stackName: templateId, + }); + } + else { + switch (change.changeImpact) { + case cloudformation_diff_1.ResourceImpact.MAY_REPLACE: + case cloudformation_diff_1.ResourceImpact.WILL_ORPHAN: + case cloudformation_diff_1.ResourceImpact.WILL_DESTROY: + case cloudformation_diff_1.ResourceImpact.WILL_REPLACE: + destructiveChanges.push({ + impact: change.changeImpact, + logicalId, + stackName: templateId, + }); + break; + } + } + }); + const writable = new StringWritable({}); + (0, cloudformation_diff_1.formatDifferences)(writable, templateDiff); + failures.push({ + reason: common_1.DiagnosticReason.SNAPSHOT_FAILED, + message: writable.data, + stackName: templateId, + testName: this.testName, + config, + }); + } + } + } + } + return { + diagnostics: failures, + destructiveChanges, + }; + } + readAssembly(dir) { + return cloud_assembly_1.AssemblyManifestReader.fromPath(dir); + } + /** + * Reduce template to a normal form where asset references have been normalized + * + * This makes it possible to compare templates if all that's different between + * them is the hashes of the asset values. + */ + canonicalizeTemplate(template, assets) { + const assetsSeen = new Set(); + const stringSubstitutions = new Array(); + // Find assets via parameters (for LegacyStackSynthesizer) + const paramRe = /^AssetParameters([a-zA-Z0-9]{64})(S3Bucket|S3VersionKey|ArtifactHash)([a-zA-Z0-9]{8})$/; + for (const paramName of Object.keys(template?.Parameters || {})) { + const m = paramRe.exec(paramName); + if (!m) { + continue; + } + if (assetsSeen.has(m[1])) { + continue; + } + assetsSeen.add(m[1]); + const ix = assetsSeen.size; + // Full parameter reference + stringSubstitutions.push([ + new RegExp(`AssetParameters${m[1]}(S3Bucket|S3VersionKey|ArtifactHash)([a-zA-Z0-9]{8})`), + `Asset${ix}$1`, + ]); + // Substring asset hash reference + stringSubstitutions.push([ + new RegExp(`${m[1]}`), + `Asset${ix}Hash`, + ]); + } + // find assets defined in the asset manifest + try { + assets.forEach(asset => { + if (!assetsSeen.has(asset)) { + assetsSeen.add(asset); + const ix = assetsSeen.size; + stringSubstitutions.push([ + new RegExp(asset), + `Asset${ix}$1`, + ]); + } + }); + } + catch { + // if there is no asset manifest that is fine. + } + // Substitute them out + return substitute(template); + function substitute(what) { + if (Array.isArray(what)) { + return what.map(substitute); + } + if (typeof what === 'object' && what !== null) { + const ret = {}; + for (const [k, v] of Object.entries(what)) { + ret[stringSub(k)] = substitute(v); + } + return ret; + } + if (typeof what === 'string') { + return stringSub(what); + } + return what; + } + function stringSub(x) { + for (const [re, replacement] of stringSubstitutions) { + x = x.replace(re, replacement); + } + return x; + } + } +} +exports.IntegSnapshotRunner = IntegSnapshotRunner; +class StringWritable extends stream_1.Writable { + constructor(options) { + super(options); + this._decoder = new string_decoder_1.StringDecoder(); + this.data = ''; + } + _write(chunk, encoding, callback) { + if (encoding === 'buffer') { + chunk = this._decoder.write(chunk); + } + this.data += chunk; + callback(); + } + _final(callback) { + this.data += this._decoder.end(); + callback(); + } +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"snapshot-test-runner.js","sourceRoot":"","sources":["snapshot-test-runner.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport type { WritableOptions } from 'stream';\nimport { Writable } from 'stream';\nimport { StringDecoder } from 'string_decoder';\nimport type { ResourceDifference } from '@aws-cdk/cloudformation-diff';\nimport { fullDiff, formatDifferences, ResourceImpact } from '@aws-cdk/cloudformation-diff';\nimport { AssemblyManifestReader } from './private/cloud-assembly';\nimport type { IntegRunnerOptions } from './runner-base';\nimport { IntegRunner, DEFAULT_SYNTH_OPTIONS } from './runner-base';\nimport type { Diagnostic, DestructiveChange, SnapshotVerificationOptions } from '../workers/common';\nimport { DiagnosticReason } from '../workers/common';\n\ninterface SnapshotAssembly {\n  /**\n   * Map of stacks that are part of this assembly\n   */\n  [stackName: string]: {\n    /**\n     * All templates for this stack, including nested stacks\n     */\n    templates: {\n      [templateId: string]: any;\n    };\n\n    /**\n     * List of asset Ids that are used by this assembly\n     */\n    assets: string[];\n  };\n}\n\n/**\n * Runner for snapshot tests. This handles orchestrating\n * the validation of the integration test snapshots\n */\nexport class IntegSnapshotRunner extends IntegRunner {\n  constructor(options: IntegRunnerOptions) {\n    super(options);\n  }\n\n  /**\n   * Synth the integration tests and compare the templates\n   * to the existing snapshot.\n   *\n   * @returns any diagnostics and any destructive changes\n   */\n  public testSnapshot(options: SnapshotVerificationOptions = {}): { diagnostics: Diagnostic[]; destructiveChanges: DestructiveChange[] } {\n    let doClean = true;\n    try {\n      const expectedSnapshotAssembly = this.getSnapshotAssembly(this.snapshotDir, this.expectedTestSuite?.stacks);\n\n      // synth the integration test\n      // FIXME: ideally we should not need to run this again if\n      // the cdkOutDir exists already, but for some reason generateActualSnapshot\n      // generates an incorrect snapshot and I have no idea why so synth again here\n      // to produce the \"correct\" snapshot\n      const env = {\n        ...DEFAULT_SYNTH_OPTIONS.env,\n        CDK_CONTEXT_JSON: JSON.stringify(this.getContext({\n          ...this.actualTestSuite.enableLookups ? DEFAULT_SYNTH_OPTIONS.context : {},\n        })),\n      };\n      this.cdk.synthFast({\n        execCmd: this.cdkApp.split(' '),\n        env,\n        output: path.relative(this.directory, this.cdkOutDir),\n      });\n\n      // read the \"actual\" snapshot\n      const actualSnapshotAssembly = this.getSnapshotAssembly(this.cdkOutDir, this.actualTestSuite.stacks);\n\n      // diff the existing snapshot (expected) with the integration test (actual)\n      const diagnostics = this.diffAssembly(expectedSnapshotAssembly, actualSnapshotAssembly);\n\n      if (diagnostics.diagnostics.length) {\n        // Attach additional messages to the first diagnostic\n        const additionalMessages: string[] = [];\n\n        if (options.retain) {\n          additionalMessages.push(\n            `(Failure retained) Expected: ${path.relative(process.cwd(), this.snapshotDir)}`,\n            `                   Actual:   ${path.relative(process.cwd(), this.cdkOutDir)}`,\n          ),\n          doClean = false;\n        }\n\n        if (options.verbose) {\n          // Show the command necessary to repro this\n          const envSet = Object.entries(env)\n            .filter(([k, _]) => k !== 'CDK_CONTEXT_JSON')\n            .map(([k, v]) => `${k}='${v}'`);\n          const envCmd = envSet.length > 0 ? ['env', ...envSet] : [];\n\n          additionalMessages.push(\n            'Repro:',\n            `  ${[...envCmd, 'cdk synth', `-a '${this.cdkApp}'`, `-o '${this.cdkOutDir}'`, ...Object.entries(this.getContext()).flatMap(([k, v]) => typeof v !== 'object' ? [`-c '${k}=${v}'`] : [])].join(' ')}`,\n\n          );\n        }\n\n        diagnostics.diagnostics[0] = {\n          ...diagnostics.diagnostics[0],\n          additionalMessages,\n        };\n      }\n\n      return diagnostics;\n    } catch (e) {\n      throw e;\n    } finally {\n      if (doClean) {\n        this.cleanup();\n      }\n    }\n  }\n\n  /**\n   * For a given cloud assembly return a collection of all templates\n   * that should be part of the snapshot and any required meta data.\n   *\n   * @param cloudAssemblyDir The directory of the cloud assembly to look for snapshots\n   * @param pickStacks Pick only these stacks from the cloud assembly\n   * @returns A SnapshotAssembly, the collection of all templates in this snapshot and required meta data\n   */\n  private getSnapshotAssembly(cloudAssemblyDir: string, pickStacks: string[] = []): SnapshotAssembly {\n    const assembly = this.readAssembly(cloudAssemblyDir);\n    const stacks = assembly.stacks;\n    const snapshots: SnapshotAssembly = {};\n    for (const [stackName, stackTemplate] of Object.entries(stacks)) {\n      if (pickStacks.includes(stackName)) {\n        const manifest = AssemblyManifestReader.fromPath(cloudAssemblyDir);\n        const assets = manifest.getAssetIdsForStack(stackName);\n\n        snapshots[stackName] = {\n          templates: {\n            [stackName]: stackTemplate,\n            ...assembly.getNestedStacksForStack(stackName),\n          },\n          assets,\n        };\n      }\n    }\n\n    return snapshots;\n  }\n\n  /**\n   * For a given stack return all resource types that are allowed to be destroyed\n   * as part of a stack update\n   *\n   * @param stackId the stack id\n   * @returns a list of resource types or undefined if none are found\n   */\n  private getAllowedDestroyTypesForStack(stackId: string): string[] | undefined {\n    for (const testCase of Object.values(this.actualTests() ?? {})) {\n      if (testCase.stacks.includes(stackId)) {\n        return testCase.allowDestroy;\n      }\n    }\n    return undefined;\n  }\n\n  /**\n   * Find any differences between the existing and expected snapshots\n   *\n   * @param existing - the existing (expected) snapshot\n   * @param actual - the new (actual) snapshot\n   * @returns any diagnostics and any destructive changes\n   */\n  private diffAssembly(\n    expected: SnapshotAssembly,\n    actual: SnapshotAssembly,\n  ): { diagnostics: Diagnostic[]; destructiveChanges: DestructiveChange[] } {\n    const failures: Diagnostic[] = [];\n    const destructiveChanges: DestructiveChange[] = [];\n\n    // check if there is a CFN template in the current snapshot\n    // that does not exist in the \"actual\" snapshot\n    for (const [stackId, stack] of Object.entries(expected)) {\n      for (const templateId of Object.keys(stack.templates)) {\n        if (!actual[stackId]?.templates[templateId]) {\n          failures.push({\n            testName: this.testName,\n            stackName: templateId,\n            reason: DiagnosticReason.SNAPSHOT_FAILED,\n            message: `${templateId} exists in snapshot, but not in actual`,\n          });\n        }\n      }\n    }\n\n    for (const [stackId, stack] of Object.entries(actual)) {\n      for (const templateId of Object.keys(stack.templates)) {\n      // check if there is a CFN template in the \"actual\" snapshot\n      // that does not exist in the current snapshot\n        if (!expected[stackId]?.templates[templateId]) {\n          failures.push({\n            testName: this.testName,\n            stackName: templateId,\n            reason: DiagnosticReason.SNAPSHOT_FAILED,\n            message: `${templateId} does not exist in snapshot, but does in actual`,\n          });\n          continue;\n        } else {\n          const config = {\n            diffAssets: this.actualTestSuite.getOptionsForStack(stackId)?.diffAssets,\n          };\n          let actualTemplate = actual[stackId].templates[templateId];\n          let expectedTemplate = expected[stackId].templates[templateId];\n\n          // if we are not verifying asset hashes then remove the specific\n          // asset hashes from the templates so they are not part of the diff\n          // comparison\n          if (!config.diffAssets) {\n            actualTemplate = this.canonicalizeTemplate(actualTemplate, actual[stackId].assets);\n            expectedTemplate = this.canonicalizeTemplate(expectedTemplate, expected[stackId].assets);\n          }\n          const templateDiff = fullDiff(expectedTemplate, actualTemplate);\n          if (!templateDiff.isEmpty) {\n            const allowedDestroyTypes = this.getAllowedDestroyTypesForStack(stackId) ?? [];\n\n            // go through all the resource differences and check for any\n            // \"destructive\" changes\n            templateDiff.resources.forEachDifference((logicalId: string, change: ResourceDifference) => {\n            // if the change is a removal it will not show up as a 'changeImpact'\n            // so need to check for it separately, unless it is a resourceType that\n            // has been \"allowed\" to be destroyed\n              const resourceType = change.oldValue?.Type ?? change.newValue?.Type;\n              if (resourceType && allowedDestroyTypes.includes(resourceType)) {\n                return;\n              }\n              if (change.isRemoval) {\n                destructiveChanges.push({\n                  impact: ResourceImpact.WILL_DESTROY,\n                  logicalId,\n                  stackName: templateId,\n                });\n              } else {\n                switch (change.changeImpact) {\n                  case ResourceImpact.MAY_REPLACE:\n                  case ResourceImpact.WILL_ORPHAN:\n                  case ResourceImpact.WILL_DESTROY:\n                  case ResourceImpact.WILL_REPLACE:\n                    destructiveChanges.push({\n                      impact: change.changeImpact,\n                      logicalId,\n                      stackName: templateId,\n                    });\n                    break;\n                }\n              }\n            });\n            const writable = new StringWritable({});\n            formatDifferences(writable, templateDiff);\n            failures.push({\n              reason: DiagnosticReason.SNAPSHOT_FAILED,\n              message: writable.data,\n              stackName: templateId,\n              testName: this.testName,\n              config,\n            });\n          }\n        }\n      }\n    }\n\n    return {\n      diagnostics: failures,\n      destructiveChanges,\n    };\n  }\n\n  private readAssembly(dir: string): AssemblyManifestReader {\n    return AssemblyManifestReader.fromPath(dir);\n  }\n\n  /**\n   * Reduce template to a normal form where asset references have been normalized\n   *\n   * This makes it possible to compare templates if all that's different between\n   * them is the hashes of the asset values.\n   */\n  private canonicalizeTemplate(template: any, assets: string[]): any {\n    const assetsSeen = new Set<string>();\n    const stringSubstitutions = new Array<[RegExp, string]>();\n\n    // Find assets via parameters (for LegacyStackSynthesizer)\n    const paramRe = /^AssetParameters([a-zA-Z0-9]{64})(S3Bucket|S3VersionKey|ArtifactHash)([a-zA-Z0-9]{8})$/;\n    for (const paramName of Object.keys(template?.Parameters || {})) {\n      const m = paramRe.exec(paramName);\n      if (!m) {\n        continue;\n      }\n      if (assetsSeen.has(m[1])) {\n        continue;\n      }\n\n      assetsSeen.add(m[1]);\n      const ix = assetsSeen.size;\n\n      // Full parameter reference\n      stringSubstitutions.push([\n        new RegExp(`AssetParameters${m[1]}(S3Bucket|S3VersionKey|ArtifactHash)([a-zA-Z0-9]{8})`),\n        `Asset${ix}$1`,\n      ]);\n      // Substring asset hash reference\n      stringSubstitutions.push([\n        new RegExp(`${m[1]}`),\n        `Asset${ix}Hash`,\n      ]);\n    }\n\n    // find assets defined in the asset manifest\n    try {\n      assets.forEach(asset => {\n        if (!assetsSeen.has(asset)) {\n          assetsSeen.add(asset);\n          const ix = assetsSeen.size;\n          stringSubstitutions.push([\n            new RegExp(asset),\n            `Asset${ix}$1`,\n          ]);\n        }\n      });\n    } catch {\n      // if there is no asset manifest that is fine.\n    }\n\n    // Substitute them out\n    return substitute(template);\n\n    function substitute(what: any): any {\n      if (Array.isArray(what)) {\n        return what.map(substitute);\n      }\n\n      if (typeof what === 'object' && what !== null) {\n        const ret: any = {};\n        for (const [k, v] of Object.entries(what)) {\n          ret[stringSub(k)] = substitute(v);\n        }\n        return ret;\n      }\n\n      if (typeof what === 'string') {\n        return stringSub(what);\n      }\n\n      return what;\n    }\n\n    function stringSub(x: string) {\n      for (const [re, replacement] of stringSubstitutions) {\n        x = x.replace(re, replacement);\n      }\n      return x;\n    }\n  }\n}\n\nclass StringWritable extends Writable {\n  public data: string;\n  private _decoder: StringDecoder;\n  constructor(options: WritableOptions) {\n    super(options);\n    this._decoder = new StringDecoder();\n    this.data = '';\n  }\n\n  _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void {\n    if (encoding === 'buffer') {\n      chunk = this._decoder.write(chunk);\n    }\n\n    this.data += chunk;\n    callback();\n  }\n\n  _final(callback: (error?: Error | null) => void): void {\n    this.data += this._decoder.end();\n    callback();\n  }\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/integ-runner/lib/utils.d.ts b/packages/@aws-cdk/integ-runner/lib/utils.d.ts new file mode 100644 index 000000000..0824dbce7 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/utils.d.ts @@ -0,0 +1,50 @@ +/** + * Our own execute function which doesn't use shells and strings. + */ +export declare function exec(commandLine: string[], options?: { + cwd?: string; + verbose?: boolean; + env?: any; +}): any; +/** + * Flatten a list of lists into a list of elements + */ +export declare function flatten(xs: T[][]): T[]; +/** + * Chain commands + */ +export declare function chain(commands: string[]): string; +/** + * Split command to chunks by space + */ +export declare function chunks(command: string): string[]; +/** + * A class holding a set of items which are being crossed off in time + * + * If it takes too long to cross off a new item, print the list. + */ +export declare class WorkList { + private readonly items; + private readonly options; + private readonly remaining; + private readonly timeout; + private timer?; + constructor(items: A[], options?: WorkListOptions); + crossOff(item: A): void; + done(): void; + private stopTimer; + private scheduleTimer; + private report; +} +export interface WorkListOptions { + /** + * When to reply with remaining items + * + * @default 60000 + */ + readonly timeout?: number; + /** + * Function to call when timeout hits + */ + readonly onTimeout?: (x: Set) => void; +} diff --git a/packages/@aws-cdk/integ-runner/lib/utils.js b/packages/@aws-cdk/integ-runner/lib/utils.js new file mode 100644 index 000000000..9f8743e44 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/utils.js @@ -0,0 +1,91 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.WorkList = void 0; +exports.exec = exec; +exports.flatten = flatten; +exports.chain = chain; +exports.chunks = chunks; +// Helper functions for CDK Exec +const child_process_1 = require("child_process"); +/** + * Our own execute function which doesn't use shells and strings. + */ +function exec(commandLine, options = {}) { + const proc = (0, child_process_1.spawnSync)(commandLine[0], commandLine.slice(1), { + stdio: ['ignore', 'pipe', options.verbose ? 'inherit' : 'pipe'], // inherit STDERR in verbose mode + env: { + ...process.env, + ...options.env, + }, + cwd: options.cwd, + }); + if (proc.error) { + throw proc.error; + } + if (proc.status !== 0) { + if (process.stderr) { // will be 'null' in verbose mode + process.stderr.write(proc.stderr); + } + throw new Error(`Command exited with ${proc.status ? `status ${proc.status}` : `signal ${proc.signal}`}`); + } + const output = proc.stdout.toString('utf-8').trim(); + return output; +} +/** + * Flatten a list of lists into a list of elements + */ +function flatten(xs) { + return Array.prototype.concat.apply([], xs); +} +/** + * Chain commands + */ +function chain(commands) { + return commands.filter(c => !!c).join(' && '); +} +/** + * Split command to chunks by space + */ +function chunks(command) { + const result = command.match(/(?:[^\s"]+|"[^"]*")+/g); + return result ?? []; +} +/** + * A class holding a set of items which are being crossed off in time + * + * If it takes too long to cross off a new item, print the list. + */ +class WorkList { + constructor(items, options = {}) { + this.items = items; + this.options = options; + this.remaining = new Set(this.items); + this.timeout = options.timeout ?? 60000; + this.scheduleTimer(); + } + crossOff(item) { + this.remaining.delete(item); + this.stopTimer(); + if (this.remaining.size > 0) { + this.scheduleTimer(); + } + } + done() { + this.remaining.clear(); + this.stopTimer(); + } + stopTimer() { + if (this.timer) { + clearTimeout(this.timer); + this.timer = undefined; + } + } + scheduleTimer() { + this.timer = setTimeout(() => this.report(), this.timeout); + } + report() { + this.options.onTimeout?.(this.remaining); + } +} +exports.WorkList = WorkList; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/packages/@aws-cdk/integ-runner/lib/workers/common.d.ts b/packages/@aws-cdk/integ-runner/lib/workers/common.d.ts new file mode 100644 index 000000000..68a54ef7c --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/workers/common.d.ts @@ -0,0 +1,235 @@ +import type { ResourceImpact } from '@aws-cdk/cloudformation-diff'; +import type { IntegTestInfo } from '../runner/integration-tests'; +/** + * The aggregate results from running assertions on a test case + */ +export type AssertionResults = { + [id: string]: AssertionResult; +}; +/** + * The result of an individual assertion + */ +export interface AssertionResult { + /** + * The assertion message. If the assertion failed, this will + * include the reason. + */ + readonly message: string; + /** + * Whether the assertion succeeded or failed + */ + readonly status: 'success' | 'fail'; +} +/** + * Config for an integration test + */ +export interface IntegTestWorkerConfig extends IntegTestInfo { + /** + * A list of any destructive changes + * + * @default [] + */ + readonly destructiveChanges?: DestructiveChange[]; +} +/** + * Information on any destructive changes + */ +export interface DestructiveChange { + /** + * The logicalId of the resource with a destructive change + */ + readonly logicalId: string; + /** + * The name of the stack that contains the destructive change + */ + readonly stackName: string; + /** + * The impact of the destructive change + */ + readonly impact: ResourceImpact; +} +/** + * Represents integration tests metrics for a given worker + */ +export interface IntegRunnerMetrics { + /** + * The region the test was run in + */ + readonly region: string; + /** + * The total duration of the worker. + * This will be the sum of all individual test durations + */ + readonly duration: number; + /** + * Contains the duration of individual tests that the + * worker executed. + * + * Map of testName to duration. + */ + readonly tests: { + [testName: string]: number; + }; + /** + * The profile that was used to run the test + * + * @default - default profile + */ + readonly profile?: string; +} +export interface SnapshotVerificationOptions { + /** + * Retain failed snapshot comparisons + * + * @default false + */ + readonly retain?: boolean; + /** + * Verbose mode + * + * @default false + */ + readonly verbose?: boolean; +} +/** + * Integration test results + */ +export interface IntegBatchResponse { + /** + * List of failed tests + */ + readonly failedTests: IntegTestInfo[]; + /** + * List of Integration test metrics. Each entry in the + * list represents metrics from a single worker (account + region). + */ + readonly metrics: IntegRunnerMetrics[]; +} +/** + * Common options for running integration tests + */ +export interface IntegTestOptions { + /** + * A list of integration tests to run + * in this batch + */ + readonly tests: IntegTestWorkerConfig[]; + /** + * Whether or not to destroy the stacks at the + * end of the test + * + * @default true + */ + readonly clean?: boolean; + /** + * When this is set to `true` the snapshot will + * be created _without_ running the integration test + * The resulting snapshot SHOULD NOT be checked in + * + * @default false + */ + readonly dryRun?: boolean; + /** + * The level of verbosity for logging. + * Higher number means more output. + * + * @default 0 + */ + readonly verbosity?: number; + /** + * If this is set to true then the stack update workflow will be disabled + * + * @default true + */ + readonly updateWorkflow?: boolean; + /** + * true if running in watch mode + * + * @default false + */ + readonly watch?: boolean; +} +/** + * Represents possible reasons for a diagnostic + */ +export declare enum DiagnosticReason { + /** + * The integration test failed because there + * is not existing snapshot + */ + NO_SNAPSHOT = "NO_SNAPSHOT", + /** + * The integration test failed + */ + TEST_FAILED = "TEST_FAILED", + /** + * There was an error running the integration test + */ + TEST_ERROR = "TEST_ERROR", + /** + * The snapshot test failed because the actual + * snapshot was different than the expected snapshot + */ + SNAPSHOT_FAILED = "SNAPSHOT_FAILED", + /** + * The snapshot test failed because there was an error executing it + */ + SNAPSHOT_ERROR = "SNAPSHOT_ERROR", + /** + * The snapshot test succeeded + */ + SNAPSHOT_SUCCESS = "SNAPSHOT_SUCCESS", + /** + * The integration test succeeded + */ + TEST_SUCCESS = "TEST_SUCCESS", + /** + * The assertion failed + */ + ASSERTION_FAILED = "ASSERTION_FAILED" +} +/** + * Integration test diagnostics + * This is used to report back the status of each test + */ +export interface Diagnostic { + /** + * The name of the test + */ + readonly testName: string; + /** + * The name of the stack + */ + readonly stackName: string; + /** + * The diagnostic message + */ + readonly message: string; + /** + * The time it took to run the test + */ + readonly duration?: number; + /** + * The reason for the diagnostic + */ + readonly reason: DiagnosticReason; + /** + * Additional messages to print + */ + readonly additionalMessages?: string[]; + /** + * Relevant config options that were used for the integ test + */ + readonly config?: Record; +} +export declare function printSummary(total: number, failed: number): void; +/** + * Format the assertion results so that the results can be + * printed + */ +export declare function formatAssertionResults(results: AssertionResults): string; +/** + * Print out the results from tests + */ +export declare function printResults(diagnostic: Diagnostic): void; +export declare function printLaggards(testNames: Set): void; diff --git a/packages/@aws-cdk/integ-runner/lib/workers/common.js b/packages/@aws-cdk/integ-runner/lib/workers/common.js new file mode 100644 index 000000000..48fbc7cb2 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/workers/common.js @@ -0,0 +1,108 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.DiagnosticReason = void 0; +exports.printSummary = printSummary; +exports.formatAssertionResults = formatAssertionResults; +exports.printResults = printResults; +exports.printLaggards = printLaggards; +const util_1 = require("util"); +const chalk = require("chalk"); +const logger = require("../logger"); +/** + * Represents possible reasons for a diagnostic + */ +var DiagnosticReason; +(function (DiagnosticReason) { + /** + * The integration test failed because there + * is not existing snapshot + */ + DiagnosticReason["NO_SNAPSHOT"] = "NO_SNAPSHOT"; + /** + * The integration test failed + */ + DiagnosticReason["TEST_FAILED"] = "TEST_FAILED"; + /** + * There was an error running the integration test + */ + DiagnosticReason["TEST_ERROR"] = "TEST_ERROR"; + /** + * The snapshot test failed because the actual + * snapshot was different than the expected snapshot + */ + DiagnosticReason["SNAPSHOT_FAILED"] = "SNAPSHOT_FAILED"; + /** + * The snapshot test failed because there was an error executing it + */ + DiagnosticReason["SNAPSHOT_ERROR"] = "SNAPSHOT_ERROR"; + /** + * The snapshot test succeeded + */ + DiagnosticReason["SNAPSHOT_SUCCESS"] = "SNAPSHOT_SUCCESS"; + /** + * The integration test succeeded + */ + DiagnosticReason["TEST_SUCCESS"] = "TEST_SUCCESS"; + /** + * The assertion failed + */ + DiagnosticReason["ASSERTION_FAILED"] = "ASSERTION_FAILED"; +})(DiagnosticReason || (exports.DiagnosticReason = DiagnosticReason = {})); +function printSummary(total, failed) { + if (failed > 0) { + logger.print('%s: %s %s, %s total', chalk.bold('Tests'), chalk.red(failed), chalk.red('failed'), total); + } + else { + logger.print('%s: %s %s, %s total', chalk.bold('Tests'), chalk.green(total), chalk.green('passed'), total); + } +} +/** + * Format the assertion results so that the results can be + * printed + */ +function formatAssertionResults(results) { + return Object.entries(results) + .map(([id, result]) => (0, util_1.format)('%s%s', id, result.status === 'success' ? ` - ${result.status}` : `\n${result.message}`)) + .join('\n '); +} +/** + * Print out the results from tests + */ +function printResults(diagnostic) { + switch (diagnostic.reason) { + case DiagnosticReason.SNAPSHOT_SUCCESS: + logger.success(' UNCHANGED %s %s', diagnostic.testName, chalk.gray(`${diagnostic.duration}s`)); + break; + case DiagnosticReason.TEST_SUCCESS: + logger.success(' SUCCESS %s %s\n ', diagnostic.testName, chalk.gray(`${diagnostic.duration}s`), diagnostic.message); + break; + case DiagnosticReason.NO_SNAPSHOT: + logger.error(' NEW %s %s', diagnostic.testName, chalk.gray(`${diagnostic.duration}s`)); + break; + case DiagnosticReason.SNAPSHOT_FAILED: + logger.error(' CHANGED %s %s\n %s', diagnostic.testName, chalk.gray(`${diagnostic.duration}s`), diagnostic.message); + break; + case DiagnosticReason.SNAPSHOT_ERROR: + case DiagnosticReason.TEST_ERROR: + logger.error(' ERROR %s %s\n %s', diagnostic.testName, chalk.gray(`${diagnostic.duration}s`), diagnostic.message); + break; + case DiagnosticReason.TEST_FAILED: + logger.error(' FAILED %s %s\n %s', diagnostic.testName, chalk.gray(`${diagnostic.duration}s`), diagnostic.message); + break; + case DiagnosticReason.ASSERTION_FAILED: + logger.error(' ASSERT %s %s\n %s', diagnostic.testName, chalk.gray(`${diagnostic.duration}s`), diagnostic.message); + break; + } + for (const addl of diagnostic.additionalMessages ?? []) { + logger.print(` ${addl}`); + } +} +function printLaggards(testNames) { + const parts = [ + ' ', + `Waiting for ${testNames.size} more`, + testNames.size < 10 ? ['(', Array.from(testNames).join(', '), ')'].join('') : '', + ]; + logger.print(chalk.grey(parts.filter(x => x).join(' '))); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["common.ts"],"names":[],"mappings":"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","sourcesContent":["import { format } from 'util';\nimport type { ResourceImpact } from '@aws-cdk/cloudformation-diff';\nimport * as chalk from 'chalk';\nimport * as logger from '../logger';\nimport type { IntegTestInfo } from '../runner/integration-tests';\n\n/**\n * The aggregate results from running assertions on a test case\n */\nexport type AssertionResults = { [id: string]: AssertionResult };\n\n/**\n * The result of an individual assertion\n */\nexport interface AssertionResult {\n  /**\n   * The assertion message. If the assertion failed, this will\n   * include the reason.\n   */\n  readonly message: string;\n\n  /**\n   * Whether the assertion succeeded or failed\n   */\n  readonly status: 'success' | 'fail';\n}\n\n/**\n * Config for an integration test\n */\nexport interface IntegTestWorkerConfig extends IntegTestInfo {\n  /**\n   * A list of any destructive changes\n   *\n   * @default []\n   */\n  readonly destructiveChanges?: DestructiveChange[];\n}\n\n/**\n * Information on any destructive changes\n */\nexport interface DestructiveChange {\n  /**\n   * The logicalId of the resource with a destructive change\n   */\n  readonly logicalId: string;\n\n  /**\n   * The name of the stack that contains the destructive change\n   */\n  readonly stackName: string;\n\n  /**\n   * The impact of the destructive change\n   */\n  readonly impact: ResourceImpact;\n}\n\n/**\n * Represents integration tests metrics for a given worker\n */\nexport interface IntegRunnerMetrics {\n  /**\n   * The region the test was run in\n   */\n  readonly region: string;\n\n  /**\n   * The total duration of the worker.\n   * This will be the sum of all individual test durations\n   */\n  readonly duration: number;\n\n  /**\n   * Contains the duration of individual tests that the\n   * worker executed.\n   *\n   * Map of testName to duration.\n   */\n  readonly tests: { [testName: string]: number };\n\n  /**\n   * The profile that was used to run the test\n   *\n   * @default - default profile\n   */\n  readonly profile?: string;\n}\n\nexport interface SnapshotVerificationOptions {\n  /**\n   * Retain failed snapshot comparisons\n   *\n   * @default false\n   */\n  readonly retain?: boolean;\n\n  /**\n   * Verbose mode\n   *\n   * @default false\n   */\n  readonly verbose?: boolean;\n}\n\n/**\n * Integration test results\n */\nexport interface IntegBatchResponse {\n  /**\n   * List of failed tests\n   */\n  readonly failedTests: IntegTestInfo[];\n\n  /**\n   * List of Integration test metrics. Each entry in the\n   * list represents metrics from a single worker (account + region).\n   */\n  readonly metrics: IntegRunnerMetrics[];\n}\n\n/**\n * Common options for running integration tests\n */\nexport interface IntegTestOptions {\n  /**\n   * A list of integration tests to run\n   * in this batch\n   */\n  readonly tests: IntegTestWorkerConfig[];\n\n  /**\n   * Whether or not to destroy the stacks at the\n   * end of the test\n   *\n   * @default true\n   */\n  readonly clean?: boolean;\n\n  /**\n   * When this is set to `true` the snapshot will\n   * be created _without_ running the integration test\n   * The resulting snapshot SHOULD NOT be checked in\n   *\n   * @default false\n   */\n  readonly dryRun?: boolean;\n\n  /**\n   * The level of verbosity for logging.\n   * Higher number means more output.\n   *\n   * @default 0\n   */\n  readonly verbosity?: number;\n\n  /**\n   * If this is set to true then the stack update workflow will be disabled\n   *\n   * @default true\n   */\n  readonly updateWorkflow?: boolean;\n\n  /**\n   * true if running in watch mode\n   *\n   * @default false\n   */\n  readonly watch?: boolean;\n}\n\n/**\n * Represents possible reasons for a diagnostic\n */\nexport enum DiagnosticReason {\n  /**\n   * The integration test failed because there\n   * is not existing snapshot\n   */\n  NO_SNAPSHOT = 'NO_SNAPSHOT',\n\n  /**\n   * The integration test failed\n   */\n  TEST_FAILED = 'TEST_FAILED',\n\n  /**\n   * There was an error running the integration test\n   */\n  TEST_ERROR = 'TEST_ERROR',\n\n  /**\n   * The snapshot test failed because the actual\n   * snapshot was different than the expected snapshot\n   */\n  SNAPSHOT_FAILED = 'SNAPSHOT_FAILED',\n\n  /**\n   * The snapshot test failed because there was an error executing it\n   */\n  SNAPSHOT_ERROR = 'SNAPSHOT_ERROR',\n\n  /**\n   * The snapshot test succeeded\n   */\n  SNAPSHOT_SUCCESS = 'SNAPSHOT_SUCCESS',\n\n  /**\n   * The integration test succeeded\n   */\n  TEST_SUCCESS = 'TEST_SUCCESS',\n\n  /**\n   * The assertion failed\n   */\n  ASSERTION_FAILED = 'ASSERTION_FAILED',\n}\n\n/**\n * Integration test diagnostics\n * This is used to report back the status of each test\n */\nexport interface Diagnostic {\n  /**\n   * The name of the test\n   */\n  readonly testName: string;\n\n  /**\n   * The name of the stack\n   */\n  readonly stackName: string;\n\n  /**\n   * The diagnostic message\n   */\n  readonly message: string;\n\n  /**\n   * The time it took to run the test\n   */\n  readonly duration?: number;\n\n  /**\n   * The reason for the diagnostic\n   */\n  readonly reason: DiagnosticReason;\n\n  /**\n   * Additional messages to print\n   */\n  readonly additionalMessages?: string[];\n\n  /**\n   * Relevant config options that were used for the integ test\n   */\n  readonly config?: Record<string, any>;\n}\n\nexport function printSummary(total: number, failed: number): void {\n  if (failed > 0) {\n    logger.print('%s:    %s %s, %s total', chalk.bold('Tests'), chalk.red(failed), chalk.red('failed'), total);\n  } else {\n    logger.print('%s:    %s %s, %s total', chalk.bold('Tests'), chalk.green(total), chalk.green('passed'), total);\n  }\n}\n\n/**\n * Format the assertion results so that the results can be\n * printed\n */\nexport function formatAssertionResults(results: AssertionResults): string {\n  return Object.entries(results)\n    .map(([id, result]) => format('%s%s', id, result.status === 'success' ? ` - ${result.status}` : `\\n${result.message}`))\n    .join('\\n      ');\n}\n\n/**\n * Print out the results from tests\n */\nexport function printResults(diagnostic: Diagnostic): void {\n  switch (diagnostic.reason) {\n    case DiagnosticReason.SNAPSHOT_SUCCESS:\n      logger.success('  UNCHANGED  %s %s', diagnostic.testName, chalk.gray(`${diagnostic.duration}s`));\n      break;\n    case DiagnosticReason.TEST_SUCCESS:\n      logger.success('  SUCCESS    %s %s\\n      ', diagnostic.testName, chalk.gray(`${diagnostic.duration}s`), diagnostic.message);\n      break;\n    case DiagnosticReason.NO_SNAPSHOT:\n      logger.error('  NEW        %s %s', diagnostic.testName, chalk.gray(`${diagnostic.duration}s`));\n      break;\n    case DiagnosticReason.SNAPSHOT_FAILED:\n      logger.error('  CHANGED    %s %s\\n      %s', diagnostic.testName, chalk.gray(`${diagnostic.duration}s`), diagnostic.message);\n      break;\n    case DiagnosticReason.SNAPSHOT_ERROR:\n    case DiagnosticReason.TEST_ERROR:\n      logger.error('  ERROR      %s %s\\n      %s', diagnostic.testName, chalk.gray(`${diagnostic.duration}s`), diagnostic.message);\n      break;\n    case DiagnosticReason.TEST_FAILED:\n      logger.error('  FAILED     %s %s\\n      %s', diagnostic.testName, chalk.gray(`${diagnostic.duration}s`), diagnostic.message);\n      break;\n    case DiagnosticReason.ASSERTION_FAILED:\n      logger.error('  ASSERT     %s %s\\n      %s', diagnostic.testName, chalk.gray(`${diagnostic.duration}s`), diagnostic.message);\n      break;\n  }\n  for (const addl of diagnostic.additionalMessages ?? []) {\n    logger.print(`      ${addl}`);\n  }\n}\n\nexport function printLaggards(testNames: Set<string>) {\n  const parts = [\n    '  ',\n    `Waiting for ${testNames.size} more`,\n    testNames.size < 10 ? ['(', Array.from(testNames).join(', '), ')'].join('') : '',\n  ];\n\n  logger.print(chalk.grey(parts.filter(x => x).join(' ')));\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/integ-runner/lib/workers/extract/extract_worker.d.ts b/packages/@aws-cdk/integ-runner/lib/workers/extract/extract_worker.d.ts new file mode 100644 index 000000000..3955a19d5 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/workers/extract/extract_worker.d.ts @@ -0,0 +1,21 @@ +import type { IntegTestInfo } from '../../runner/integration-tests'; +import type { IntegTestWorkerConfig, SnapshotVerificationOptions } from '../common'; +import type { IntegTestBatchRequest } from '../integ-test-worker'; +import type { IntegWatchOptions } from '../integ-watch-worker'; +/** + * Runs a single integration test batch request. + * If the test does not have an existing snapshot, + * this will first generate a snapshot and then execute + * the integration tests. + * + * If the tests succeed it will then save the snapshot + */ +export declare function integTestWorker(request: IntegTestBatchRequest): IntegTestWorkerConfig[]; +export declare function watchTestWorker(options: IntegWatchOptions): Promise; +/** + * Runs a single snapshot test batch request. + * For each integration test this will check to see + * if there is an existing snapshot, and if there is will + * check if there are any changes + */ +export declare function snapshotTestWorker(testInfo: IntegTestInfo, options?: SnapshotVerificationOptions): IntegTestWorkerConfig[]; diff --git a/packages/@aws-cdk/integ-runner/lib/workers/extract/extract_worker.js b/packages/@aws-cdk/integ-runner/lib/workers/extract/extract_worker.js new file mode 100644 index 000000000..b239d93f3 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/workers/extract/extract_worker.js @@ -0,0 +1,185 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.integTestWorker = integTestWorker; +exports.watchTestWorker = watchTestWorker; +exports.snapshotTestWorker = snapshotTestWorker; +const workerpool = require("workerpool"); +const runner_1 = require("../../runner"); +const integration_tests_1 = require("../../runner/integration-tests"); +const common_1 = require("../common"); +/** + * Runs a single integration test batch request. + * If the test does not have an existing snapshot, + * this will first generate a snapshot and then execute + * the integration tests. + * + * If the tests succeed it will then save the snapshot + */ +function integTestWorker(request) { + const failures = []; + const verbosity = request.verbosity ?? 0; + for (const testInfo of request.tests) { + const test = new integration_tests_1.IntegTest({ + ...testInfo, + watch: request.watch, + }); // Hydrate from data + const start = Date.now(); + try { + const runner = new runner_1.IntegTestRunner({ + test, + profile: request.profile, + env: { + AWS_REGION: request.region, + CDK_DOCKER: process.env.CDK_DOCKER ?? 'docker', + }, + showOutput: verbosity >= 2, + }, testInfo.destructiveChanges); + const tests = runner.actualTests(); + if (!tests || Object.keys(tests).length === 0) { + throw new Error(`No tests defined for ${runner.testName}`); + } + for (const testCaseName of Object.keys(tests)) { + try { + const results = runner.runIntegTestCase({ + testCaseName, + clean: request.clean, + dryRun: request.dryRun, + updateWorkflow: request.updateWorkflow, + verbosity, + }); + if (results && Object.values(results).some(result => result.status === 'fail')) { + failures.push(testInfo); + workerpool.workerEmit({ + reason: common_1.DiagnosticReason.ASSERTION_FAILED, + testName: `${runner.testName}-${testCaseName} (${request.profile}/${request.region})`, + message: (0, common_1.formatAssertionResults)(results), + duration: (Date.now() - start) / 1000, + }); + } + else { + workerpool.workerEmit({ + reason: common_1.DiagnosticReason.TEST_SUCCESS, + testName: `${runner.testName}-${testCaseName}`, + message: results ? (0, common_1.formatAssertionResults)(results) : 'NO ASSERTIONS', + duration: (Date.now() - start) / 1000, + }); + } + } + catch (e) { + failures.push(testInfo); + workerpool.workerEmit({ + reason: common_1.DiagnosticReason.TEST_FAILED, + testName: `${runner.testName}-${testCaseName} (${request.profile}/${request.region})`, + message: `Integration test failed: ${e}`, + duration: (Date.now() - start) / 1000, + }); + } + } + } + catch (e) { + failures.push(testInfo); + workerpool.workerEmit({ + reason: common_1.DiagnosticReason.TEST_ERROR, + testName: `${testInfo.fileName} (${request.profile}/${request.region})`, + message: `Error during integration test: ${e}`, + duration: (Date.now() - start) / 1000, + }); + } + } + return failures; +} +async function watchTestWorker(options) { + const verbosity = options.verbosity ?? 0; + const test = new integration_tests_1.IntegTest(options); + const runner = new runner_1.IntegTestRunner({ + test, + profile: options.profile, + env: { + AWS_REGION: options.region, + CDK_DOCKER: process.env.CDK_DOCKER ?? 'docker', + }, + showOutput: verbosity >= 2, + }); + runner.createCdkContextJson(); + const tests = runner.actualTests(); + if (!tests || Object.keys(tests).length === 0) { + throw new Error(`No tests defined for ${runner.testName}`); + } + for (const testCaseName of Object.keys(tests)) { + await runner.watchIntegTest({ + testCaseName, + verbosity, + }); + } +} +/** + * Runs a single snapshot test batch request. + * For each integration test this will check to see + * if there is an existing snapshot, and if there is will + * check if there are any changes + */ +function snapshotTestWorker(testInfo, options = {}) { + const failedTests = new Array(); + const start = Date.now(); + const test = new integration_tests_1.IntegTest(testInfo); // Hydrate the data record again + const timer = setTimeout(() => { + workerpool.workerEmit({ + reason: common_1.DiagnosticReason.SNAPSHOT_ERROR, + testName: test.testName, + message: 'Test is taking a very long time', + duration: (Date.now() - start) / 1000, + }); + }, 60000); + try { + const runner = new runner_1.IntegSnapshotRunner({ test }); + if (!runner.hasSnapshot()) { + workerpool.workerEmit({ + reason: common_1.DiagnosticReason.NO_SNAPSHOT, + testName: test.testName, + message: 'No Snapshot', + duration: (Date.now() - start) / 1000, + }); + failedTests.push(test.info); + } + else { + const { diagnostics, destructiveChanges } = runner.testSnapshot(options); + if (diagnostics.length > 0) { + diagnostics.forEach(diagnostic => workerpool.workerEmit({ + ...diagnostic, + duration: (Date.now() - start) / 1000, + })); + failedTests.push({ + ...test.info, + destructiveChanges, + }); + } + else { + workerpool.workerEmit({ + reason: common_1.DiagnosticReason.SNAPSHOT_SUCCESS, + testName: test.testName, + message: 'Success', + duration: (Date.now() - start) / 1000, + }); + } + } + } + catch (e) { + failedTests.push(test.info); + workerpool.workerEmit({ + message: e.message, + testName: test.testName, + reason: common_1.DiagnosticReason.SNAPSHOT_ERROR, + duration: (Date.now() - start) / 1000, + }); + } + finally { + clearTimeout(timer); + } + return failedTests; +} +workerpool.worker({ + snapshotTestWorker, + integTestWorker, + watchTestWorker, +}); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extract_worker.js","sourceRoot":"","sources":["extract_worker.ts"],"names":[],"mappings":"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","sourcesContent":["import * as workerpool from 'workerpool';\nimport { IntegSnapshotRunner, IntegTestRunner } from '../../runner';\nimport type { IntegTestInfo } from '../../runner/integration-tests';\nimport { IntegTest } from '../../runner/integration-tests';\nimport type { IntegTestWorkerConfig, SnapshotVerificationOptions, Diagnostic } from '../common';\nimport { DiagnosticReason, formatAssertionResults } from '../common';\nimport type { IntegTestBatchRequest } from '../integ-test-worker';\nimport type { IntegWatchOptions } from '../integ-watch-worker';\n\n/**\n * Runs a single integration test batch request.\n * If the test does not have an existing snapshot,\n * this will first generate a snapshot and then execute\n * the integration tests.\n *\n * If the tests succeed it will then save the snapshot\n */\nexport function integTestWorker(request: IntegTestBatchRequest): IntegTestWorkerConfig[] {\n  const failures: IntegTestInfo[] = [];\n  const verbosity = request.verbosity ?? 0;\n\n  for (const testInfo of request.tests) {\n    const test = new IntegTest({\n      ...testInfo,\n      watch: request.watch,\n    }); // Hydrate from data\n    const start = Date.now();\n\n    try {\n      const runner = new IntegTestRunner({\n        test,\n        profile: request.profile,\n        env: {\n          AWS_REGION: request.region,\n          CDK_DOCKER: process.env.CDK_DOCKER ?? 'docker',\n        },\n        showOutput: verbosity >= 2,\n      }, testInfo.destructiveChanges);\n\n      const tests = runner.actualTests();\n\n      if (!tests || Object.keys(tests).length === 0) {\n        throw new Error(`No tests defined for ${runner.testName}`);\n      }\n      for (const testCaseName of Object.keys(tests)) {\n        try {\n          const results = runner.runIntegTestCase({\n            testCaseName,\n            clean: request.clean,\n            dryRun: request.dryRun,\n            updateWorkflow: request.updateWorkflow,\n            verbosity,\n          });\n          if (results && Object.values(results).some(result => result.status === 'fail')) {\n            failures.push(testInfo);\n            workerpool.workerEmit({\n              reason: DiagnosticReason.ASSERTION_FAILED,\n              testName: `${runner.testName}-${testCaseName} (${request.profile}/${request.region})`,\n              message: formatAssertionResults(results),\n              duration: (Date.now() - start) / 1000,\n            });\n          } else {\n            workerpool.workerEmit({\n              reason: DiagnosticReason.TEST_SUCCESS,\n              testName: `${runner.testName}-${testCaseName}`,\n              message: results ? formatAssertionResults(results) : 'NO ASSERTIONS',\n              duration: (Date.now() - start) / 1000,\n            });\n          }\n        } catch (e) {\n          failures.push(testInfo);\n          workerpool.workerEmit({\n            reason: DiagnosticReason.TEST_FAILED,\n            testName: `${runner.testName}-${testCaseName} (${request.profile}/${request.region})`,\n            message: `Integration test failed: ${e}`,\n            duration: (Date.now() - start) / 1000,\n          });\n        }\n      }\n    } catch (e) {\n      failures.push(testInfo);\n      workerpool.workerEmit({\n        reason: DiagnosticReason.TEST_ERROR,\n        testName: `${testInfo.fileName} (${request.profile}/${request.region})`,\n        message: `Error during integration test: ${e}`,\n        duration: (Date.now() - start) / 1000,\n      });\n    }\n  }\n\n  return failures;\n}\n\nexport async function watchTestWorker(options: IntegWatchOptions) {\n  const verbosity = options.verbosity ?? 0;\n  const test = new IntegTest(options);\n  const runner = new IntegTestRunner({\n    test,\n    profile: options.profile,\n    env: {\n      AWS_REGION: options.region,\n      CDK_DOCKER: process.env.CDK_DOCKER ?? 'docker',\n    },\n    showOutput: verbosity >= 2,\n  });\n  runner.createCdkContextJson();\n  const tests = runner.actualTests();\n\n  if (!tests || Object.keys(tests).length === 0) {\n    throw new Error(`No tests defined for ${runner.testName}`);\n  }\n  for (const testCaseName of Object.keys(tests)) {\n    await runner.watchIntegTest({\n      testCaseName,\n      verbosity,\n    });\n  }\n}\n\n/**\n * Runs a single snapshot test batch request.\n * For each integration test this will check to see\n * if there is an existing snapshot, and if there is will\n * check if there are any changes\n */\nexport function snapshotTestWorker(testInfo: IntegTestInfo, options: SnapshotVerificationOptions = {}): IntegTestWorkerConfig[] {\n  const failedTests = new Array<IntegTestWorkerConfig>();\n  const start = Date.now();\n  const test = new IntegTest(testInfo); // Hydrate the data record again\n\n  const timer = setTimeout(() => {\n    workerpool.workerEmit({\n      reason: DiagnosticReason.SNAPSHOT_ERROR,\n      testName: test.testName,\n      message: 'Test is taking a very long time',\n      duration: (Date.now() - start) / 1000,\n    });\n  }, 60_000);\n\n  try {\n    const runner = new IntegSnapshotRunner({ test });\n    if (!runner.hasSnapshot()) {\n      workerpool.workerEmit({\n        reason: DiagnosticReason.NO_SNAPSHOT,\n        testName: test.testName,\n        message: 'No Snapshot',\n        duration: (Date.now() - start) / 1000,\n      });\n      failedTests.push(test.info);\n    } else {\n      const { diagnostics, destructiveChanges } = runner.testSnapshot(options);\n      if (diagnostics.length > 0) {\n        diagnostics.forEach(diagnostic => workerpool.workerEmit({\n          ...diagnostic,\n          duration: (Date.now() - start) / 1000,\n        } as Diagnostic));\n        failedTests.push({\n          ...test.info,\n          destructiveChanges,\n        });\n      } else {\n        workerpool.workerEmit({\n          reason: DiagnosticReason.SNAPSHOT_SUCCESS,\n          testName: test.testName,\n          message: 'Success',\n          duration: (Date.now() - start) / 1000,\n        } as Diagnostic);\n      }\n    }\n  } catch (e: any) {\n    failedTests.push(test.info);\n    workerpool.workerEmit({\n      message: e.message,\n      testName: test.testName,\n      reason: DiagnosticReason.SNAPSHOT_ERROR,\n      duration: (Date.now() - start) / 1000,\n    } as Diagnostic);\n  } finally {\n    clearTimeout(timer);\n  }\n\n  return failedTests;\n}\n\nworkerpool.worker({\n  snapshotTestWorker,\n  integTestWorker,\n  watchTestWorker,\n});\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/integ-runner/lib/workers/extract/index.d.ts b/packages/@aws-cdk/integ-runner/lib/workers/extract/index.d.ts new file mode 100644 index 000000000..f1a721136 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/workers/extract/index.d.ts @@ -0,0 +1 @@ +export * from './extract_worker'; diff --git a/packages/@aws-cdk/integ-runner/lib/workers/extract/index.js b/packages/@aws-cdk/integ-runner/lib/workers/extract/index.js new file mode 100644 index 000000000..e69900d9f --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/workers/extract/index.js @@ -0,0 +1,18 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(require("./extract_worker"), exports); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsbURBQWlDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9leHRyYWN0X3dvcmtlcic7XG4iXX0= \ No newline at end of file diff --git a/packages/@aws-cdk/integ-runner/lib/workers/index.d.ts b/packages/@aws-cdk/integ-runner/lib/workers/index.d.ts new file mode 100644 index 000000000..f42509004 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/workers/index.d.ts @@ -0,0 +1,3 @@ +export * from './common'; +export * from './integ-test-worker'; +export * from './integ-snapshot-worker'; diff --git a/packages/@aws-cdk/integ-runner/lib/workers/index.js b/packages/@aws-cdk/integ-runner/lib/workers/index.js new file mode 100644 index 000000000..d4c44d4c3 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/workers/index.js @@ -0,0 +1,20 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(require("./common"), exports); +__exportStar(require("./integ-test-worker"), exports); +__exportStar(require("./integ-snapshot-worker"), exports); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsMkNBQXlCO0FBQ3pCLHNEQUFvQztBQUNwQywwREFBd0MiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvbW1vbic7XG5leHBvcnQgKiBmcm9tICcuL2ludGVnLXRlc3Qtd29ya2VyJztcbmV4cG9ydCAqIGZyb20gJy4vaW50ZWctc25hcHNob3Qtd29ya2VyJztcbiJdfQ== \ No newline at end of file diff --git a/packages/@aws-cdk/integ-runner/lib/workers/integ-snapshot-worker.d.ts b/packages/@aws-cdk/integ-runner/lib/workers/integ-snapshot-worker.d.ts new file mode 100644 index 000000000..669fec4a3 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/workers/integ-snapshot-worker.d.ts @@ -0,0 +1,9 @@ +import type * as workerpool from 'workerpool'; +import type { IntegTestWorkerConfig, SnapshotVerificationOptions } from './common'; +import type { IntegTest } from '../runner/integration-tests'; +/** + * Run Snapshot tests + * First batch up the tests. By default there will be 3 tests per batch. + * Use a workerpool to run the batches in parallel. + */ +export declare function runSnapshotTests(pool: workerpool.WorkerPool, tests: IntegTest[], options: SnapshotVerificationOptions): Promise; diff --git a/packages/@aws-cdk/integ-runner/lib/workers/integ-snapshot-worker.js b/packages/@aws-cdk/integ-runner/lib/workers/integ-snapshot-worker.js new file mode 100644 index 000000000..f5ff691dc --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/workers/integ-snapshot-worker.js @@ -0,0 +1,31 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.runSnapshotTests = runSnapshotTests; +const common_1 = require("./common"); +const logger = require("../logger"); +const utils_1 = require("../utils"); +/** + * Run Snapshot tests + * First batch up the tests. By default there will be 3 tests per batch. + * Use a workerpool to run the batches in parallel. + */ +async function runSnapshotTests(pool, tests, options) { + logger.highlight('\nVerifying integration test snapshots...\n'); + const todo = new utils_1.WorkList(tests.map(t => t.testName), { + onTimeout: common_1.printLaggards, + }); + // The worker pool is already limited + // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism + const failedTests = await Promise.all(tests.map((test) => pool.exec('snapshotTestWorker', [test.info /* Dehydrate class -> data */, options], { + on: (x) => { + todo.crossOff(x.testName); + (0, common_1.printResults)(x); + }, + }))); + todo.done(); + const testsToRun = (0, utils_1.flatten)(failedTests); + logger.highlight('\nSnapshot Results: \n'); + (0, common_1.printSummary)(tests.length, testsToRun.length); + return testsToRun; +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/packages/@aws-cdk/integ-runner/lib/workers/integ-test-worker.d.ts b/packages/@aws-cdk/integ-runner/lib/workers/integ-test-worker.d.ts new file mode 100644 index 000000000..d2ccb77e3 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/workers/integ-test-worker.d.ts @@ -0,0 +1,47 @@ +import type * as workerpool from 'workerpool'; +import type { IntegBatchResponse, IntegTestOptions, IntegRunnerMetrics } from './common'; +/** + * Options for an integration test batch + */ +export interface IntegTestBatchRequest extends IntegTestOptions { + /** + * The AWS region to run this batch in + */ + readonly region: string; + /** + * The AWS profile to use when running this test + */ + readonly profile?: string; +} +/** + * Options for running all integration tests + */ +export interface IntegTestRunOptions extends IntegTestOptions { + /** + * The regions to run the integration tests across. + * This allows the runner to run integration tests in parallel + */ + readonly regions: string[]; + /** + * List of AWS profiles. This will be used in conjunction with `regions` + * to run tests in parallel across accounts + regions + */ + readonly profiles?: string[]; + /** + * The workerpool to use + */ + readonly pool: workerpool.WorkerPool; +} +/** + * Run Integration tests. + */ +export declare function runIntegrationTests(options: IntegTestRunOptions): Promise<{ + success: boolean; + metrics: IntegRunnerMetrics[]; +}>; +/** + * Runs a set of integration tests in parallel across a list of AWS regions. + * Only a single test can be run at a time in a given region. Once a region + * is done running a test, the next test will be pulled from the queue + */ +export declare function runIntegrationTestsInParallel(options: IntegTestRunOptions): Promise; diff --git a/packages/@aws-cdk/integ-runner/lib/workers/integ-test-worker.js b/packages/@aws-cdk/integ-runner/lib/workers/integ-test-worker.js new file mode 100644 index 000000000..a3a1ac83c --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/workers/integ-test-worker.js @@ -0,0 +1,99 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.runIntegrationTests = runIntegrationTests; +exports.runIntegrationTestsInParallel = runIntegrationTestsInParallel; +const common_1 = require("./common"); +const logger = require("../logger"); +const utils_1 = require("../utils"); +/** + * Run Integration tests. + */ +async function runIntegrationTests(options) { + logger.highlight('\nRunning integration tests for failed tests...\n'); + logger.print('Running in parallel across %sregions: %s', options.profiles ? `profiles ${options.profiles.join(', ')} and ` : '', options.regions.join(', ')); + const totalTests = options.tests.length; + const responses = await runIntegrationTestsInParallel(options); + logger.highlight('\nTest Results: \n'); + (0, common_1.printSummary)(totalTests, responses.failedTests.length); + return { + success: responses.failedTests.length === 0, + metrics: responses.metrics, + }; +} +/** + * Returns a list of AccountWorkers based on the list of regions and profiles + * given to the CLI. + */ +function getAccountWorkers(regions, profiles) { + const workers = []; + function pushWorker(profile) { + for (const region of regions) { + workers.push({ + region, + profile, + }); + } + } + if (profiles && profiles.length > 0) { + for (const profile of profiles ?? []) { + pushWorker(profile); + } + } + else { + pushWorker(); + } + return workers; +} +/** + * Runs a set of integration tests in parallel across a list of AWS regions. + * Only a single test can be run at a time in a given region. Once a region + * is done running a test, the next test will be pulled from the queue + */ +async function runIntegrationTestsInParallel(options) { + const queue = options.tests; + const results = { + metrics: [], + failedTests: [], + }; + const accountWorkers = getAccountWorkers(options.regions, options.profiles); + async function runTest(worker) { + const start = Date.now(); + const tests = {}; + do { + const test = queue.pop(); + if (!test) + break; + const testStart = Date.now(); + logger.highlight(`Running test ${test.fileName} in ${worker.profile ? worker.profile + '/' : ''}${worker.region}`); + const response = await options.pool.exec('integTestWorker', [{ + watch: options.watch, + region: worker.region, + profile: worker.profile, + tests: [test], + clean: options.clean, + dryRun: options.dryRun, + verbosity: options.verbosity, + updateWorkflow: options.updateWorkflow, + }], { + on: common_1.printResults, + }); + results.failedTests.push(...(0, utils_1.flatten)(response)); + tests[test.fileName] = (Date.now() - testStart) / 1000; + } while (queue.length > 0); + const metrics = { + region: worker.region, + profile: worker.profile, + duration: (Date.now() - start) / 1000, + tests, + }; + if (Object.keys(tests).length > 0) { + results.metrics.push(metrics); + } + } + const workers = accountWorkers.map((worker) => runTest(worker)); + // Workers are their own concurrency limits + // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism + await Promise.all(workers); + return results; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"integ-test-worker.js","sourceRoot":"","sources":["integ-test-worker.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as workerpool from 'workerpool';\nimport type { IntegBatchResponse, IntegTestOptions, IntegRunnerMetrics } from './common';\nimport { printResults, printSummary } from './common';\nimport * as logger from '../logger';\nimport type { IntegTestInfo } from '../runner/integration-tests';\nimport { flatten } from '../utils';\n\n/**\n * Options for an integration test batch\n */\nexport interface IntegTestBatchRequest extends IntegTestOptions {\n  /**\n   * The AWS region to run this batch in\n   */\n  readonly region: string;\n\n  /**\n   * The AWS profile to use when running this test\n   */\n  readonly profile?: string;\n}\n\n/**\n * Options for running all integration tests\n */\nexport interface IntegTestRunOptions extends IntegTestOptions {\n  /**\n   * The regions to run the integration tests across.\n   * This allows the runner to run integration tests in parallel\n   */\n  readonly regions: string[];\n\n  /**\n   * List of AWS profiles. This will be used in conjunction with `regions`\n   * to run tests in parallel across accounts + regions\n   */\n  readonly profiles?: string[];\n\n  /**\n   * The workerpool to use\n   */\n  readonly pool: workerpool.WorkerPool;\n}\n\n/**\n * Run Integration tests.\n */\nexport async function runIntegrationTests(options: IntegTestRunOptions): Promise<{ success: boolean; metrics: IntegRunnerMetrics[] }> {\n  logger.highlight('\\nRunning integration tests for failed tests...\\n');\n  logger.print(\n    'Running in parallel across %sregions: %s',\n    options.profiles ? `profiles ${options.profiles.join(', ')} and `: '',\n    options.regions.join(', '));\n  const totalTests = options.tests.length;\n\n  const responses = await runIntegrationTestsInParallel(options);\n  logger.highlight('\\nTest Results: \\n');\n  printSummary(totalTests, responses.failedTests.length);\n  return {\n    success: responses.failedTests.length === 0,\n    metrics: responses.metrics,\n  };\n}\n\n/**\n * Represents a worker for a single account + region\n */\ninterface AccountWorker {\n  /**\n   * The region the worker should run in\n   */\n  readonly region: string;\n\n  /**\n   * The AWS profile that the worker should use\n   * This will be passed as the '--profile' option to the CDK CLI\n   *\n   * @default - default profile\n   */\n  readonly profile?: string;\n}\n\n/**\n * Returns a list of AccountWorkers based on the list of regions and profiles\n * given to the CLI.\n */\nfunction getAccountWorkers(regions: string[], profiles?: string[]): AccountWorker[] {\n  const workers: AccountWorker[] = [];\n  function pushWorker(profile?: string) {\n    for (const region of regions) {\n      workers.push({\n        region,\n        profile,\n      });\n    }\n  }\n  if (profiles && profiles.length > 0) {\n    for (const profile of profiles ?? []) {\n      pushWorker(profile);\n    }\n  } else {\n    pushWorker();\n  }\n  return workers;\n}\n\n/**\n * Runs a set of integration tests in parallel across a list of AWS regions.\n * Only a single test can be run at a time in a given region. Once a region\n * is done running a test, the next test will be pulled from the queue\n */\nexport async function runIntegrationTestsInParallel(\n  options: IntegTestRunOptions,\n): Promise<IntegBatchResponse> {\n  const queue = options.tests;\n  const results: IntegBatchResponse = {\n    metrics: [],\n    failedTests: [],\n  };\n  const accountWorkers: AccountWorker[] = getAccountWorkers(options.regions, options.profiles);\n\n  async function runTest(worker: AccountWorker): Promise<void> {\n    const start = Date.now();\n    const tests: { [testName: string]: number } = {};\n    do {\n      const test = queue.pop();\n      if (!test) break;\n      const testStart = Date.now();\n      logger.highlight(`Running test ${test.fileName} in ${worker.profile ? worker.profile + '/' : ''}${worker.region}`);\n      const response: IntegTestInfo[][] = await options.pool.exec('integTestWorker', [{\n        watch: options.watch,\n        region: worker.region,\n        profile: worker.profile,\n        tests: [test],\n        clean: options.clean,\n        dryRun: options.dryRun,\n        verbosity: options.verbosity,\n        updateWorkflow: options.updateWorkflow,\n      }], {\n        on: printResults,\n      });\n\n      results.failedTests.push(...flatten(response));\n      tests[test.fileName] = (Date.now() - testStart) / 1000;\n    } while (queue.length > 0);\n    const metrics: IntegRunnerMetrics = {\n      region: worker.region,\n      profile: worker.profile,\n      duration: (Date.now() - start) / 1000,\n      tests,\n    };\n    if (Object.keys(tests).length > 0) {\n      results.metrics.push(metrics);\n    }\n  }\n\n  const workers = accountWorkers.map((worker) => runTest(worker));\n  // Workers are their own concurrency limits\n  // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism\n  await Promise.all(workers);\n  return results;\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/integ-runner/lib/workers/integ-watch-worker.d.ts b/packages/@aws-cdk/integ-runner/lib/workers/integ-watch-worker.d.ts new file mode 100644 index 000000000..15db87ff6 --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/workers/integ-watch-worker.d.ts @@ -0,0 +1,8 @@ +import type * as workerpool from 'workerpool'; +import type { IntegTestInfo } from '../runner'; +export interface IntegWatchOptions extends IntegTestInfo { + readonly region: string; + readonly profile?: string; + readonly verbosity?: number; +} +export declare function watchIntegrationTest(pool: workerpool.WorkerPool, options: IntegWatchOptions): Promise; diff --git a/packages/@aws-cdk/integ-runner/lib/workers/integ-watch-worker.js b/packages/@aws-cdk/integ-runner/lib/workers/integ-watch-worker.js new file mode 100644 index 000000000..0c344db1d --- /dev/null +++ b/packages/@aws-cdk/integ-runner/lib/workers/integ-watch-worker.js @@ -0,0 +1,10 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.watchIntegrationTest = watchIntegrationTest; +const common_1 = require("./common"); +async function watchIntegrationTest(pool, options) { + await pool.exec('watchTestWorker', [options], { + on: common_1.printResults, + }); +} +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZWctd2F0Y2gtd29ya2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiaW50ZWctd2F0Y2gtd29ya2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBU0Esb0RBSUM7QUFaRCxxQ0FBd0M7QUFRakMsS0FBSyxVQUFVLG9CQUFvQixDQUFDLElBQTJCLEVBQUUsT0FBMEI7SUFDaEcsTUFBTSxJQUFJLENBQUMsSUFBSSxDQUFDLGlCQUFpQixFQUFFLENBQUMsT0FBTyxDQUFDLEVBQUU7UUFDNUMsRUFBRSxFQUFFLHFCQUFZO0tBQ2pCLENBQUMsQ0FBQztBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSAqIGFzIHdvcmtlcnBvb2wgZnJvbSAnd29ya2VycG9vbCc7XG5pbXBvcnQgeyBwcmludFJlc3VsdHMgfSBmcm9tICcuL2NvbW1vbic7XG5pbXBvcnQgdHlwZSB7IEludGVnVGVzdEluZm8gfSBmcm9tICcuLi9ydW5uZXInO1xuXG5leHBvcnQgaW50ZXJmYWNlIEludGVnV2F0Y2hPcHRpb25zIGV4dGVuZHMgSW50ZWdUZXN0SW5mbyB7XG4gIHJlYWRvbmx5IHJlZ2lvbjogc3RyaW5nO1xuICByZWFkb25seSBwcm9maWxlPzogc3RyaW5nO1xuICByZWFkb25seSB2ZXJib3NpdHk/OiBudW1iZXI7XG59XG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gd2F0Y2hJbnRlZ3JhdGlvblRlc3QocG9vbDogd29ya2VycG9vbC5Xb3JrZXJQb29sLCBvcHRpb25zOiBJbnRlZ1dhdGNoT3B0aW9ucyk6IFByb21pc2U8dm9pZD4ge1xuICBhd2FpdCBwb29sLmV4ZWMoJ3dhdGNoVGVzdFdvcmtlcicsIFtvcHRpb25zXSwge1xuICAgIG9uOiBwcmludFJlc3VsdHMsXG4gIH0pO1xufVxuIl19 \ No newline at end of file diff --git a/packages/@aws-cdk/node-bundle/.projen/tasks.json b/packages/@aws-cdk/node-bundle/.projen/tasks.json index e9853b5c6..5f398a5b7 100644 --- a/packages/@aws-cdk/node-bundle/.projen/tasks.json +++ b/packages/@aws-cdk/node-bundle/.projen/tasks.json @@ -77,7 +77,7 @@ "name": "gather-versions", "steps": [ { - "exec": "node -e \"require(path.join(path.dirname(require.resolve('cdklabs-projen-project-types')), 'yarn', 'gather-versions.exec.js'))\" @aws-cdk/node-bundle MAJOR --deps ", + "exec": "node -e \"require(require.resolve('cdklabs-projen-project-types/lib/yarn/gather-versions.exec.js')).cliMain()\" ", "receiveArgs": true } ] diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/.projen/tasks.json b/packages/@aws-cdk/tmp-toolkit-helpers/.projen/tasks.json index 7a24858f6..231f40fad 100644 --- a/packages/@aws-cdk/tmp-toolkit-helpers/.projen/tasks.json +++ b/packages/@aws-cdk/tmp-toolkit-helpers/.projen/tasks.json @@ -77,7 +77,7 @@ "name": "gather-versions", "steps": [ { - "exec": "node -e \"require(path.join(path.dirname(require.resolve('cdklabs-projen-project-types')), 'yarn', 'gather-versions.exec.js'))\" @aws-cdk/tmp-toolkit-helpers MAJOR --deps @aws-cdk/cloud-assembly-schema", + "exec": "node -e \"require(require.resolve('cdklabs-projen-project-types/lib/yarn/gather-versions.exec.js')).cliMain()\" ", "receiveArgs": true } ] diff --git a/packages/@aws-cdk/toolkit-lib/.projen/tasks.json b/packages/@aws-cdk/toolkit-lib/.projen/tasks.json index 4ebb2b5ac..439009086 100644 --- a/packages/@aws-cdk/toolkit-lib/.projen/tasks.json +++ b/packages/@aws-cdk/toolkit-lib/.projen/tasks.json @@ -109,7 +109,7 @@ "name": "gather-versions", "steps": [ { - "exec": "node -e \"require(path.join(path.dirname(require.resolve('cdklabs-projen-project-types')), 'yarn', 'gather-versions.exec.js'))\" @aws-cdk/toolkit-lib MAJOR --deps @aws-cdk/cloud-assembly-schema @aws-cdk/cloudformation-diff cdk-assets @aws-cdk/tmp-toolkit-helpers aws-cdk", + "exec": "node -e \"require(require.resolve('cdklabs-projen-project-types/lib/yarn/gather-versions.exec.js')).cliMain()\" @aws-cdk/tmp-toolkit-helpers=exact aws-cdk=exact @aws-cdk/cloud-assembly-schema=major @aws-cdk/cloudformation-diff=major cdk-assets=major", "receiveArgs": true } ] diff --git a/packages/@aws-cdk/user-input-gen/.projen/tasks.json b/packages/@aws-cdk/user-input-gen/.projen/tasks.json index 662224a82..f63a20167 100644 --- a/packages/@aws-cdk/user-input-gen/.projen/tasks.json +++ b/packages/@aws-cdk/user-input-gen/.projen/tasks.json @@ -77,7 +77,7 @@ "name": "gather-versions", "steps": [ { - "exec": "node -e \"require(path.join(path.dirname(require.resolve('cdklabs-projen-project-types')), 'yarn', 'gather-versions.exec.js'))\" @aws-cdk/user-input-gen MAJOR --deps ", + "exec": "node -e \"require(require.resolve('cdklabs-projen-project-types/lib/yarn/gather-versions.exec.js')).cliMain()\" ", "receiveArgs": true } ] diff --git a/packages/aws-cdk/.projen/tasks.json b/packages/aws-cdk/.projen/tasks.json index a779c1065..4ae1c5a19 100644 --- a/packages/aws-cdk/.projen/tasks.json +++ b/packages/aws-cdk/.projen/tasks.json @@ -101,7 +101,7 @@ "name": "gather-versions", "steps": [ { - "exec": "node -e \"require(path.join(path.dirname(require.resolve('cdklabs-projen-project-types')), 'yarn', 'gather-versions.exec.js'))\" aws-cdk MAJOR --deps @aws-cdk/cloud-assembly-schema @aws-cdk/cloudformation-diff @aws-cdk/user-input-gen @aws-cdk/node-bundle @aws-cdk/cli-plugin-contract cdk-assets @aws-cdk/tmp-toolkit-helpers", + "exec": "node -e \"require(require.resolve('cdklabs-projen-project-types/lib/yarn/gather-versions.exec.js')).cliMain()\" @aws-cdk/cli-plugin-contract=exact @aws-cdk/node-bundle=exact @aws-cdk/tmp-toolkit-helpers=exact @aws-cdk/user-input-gen=exact @aws-cdk/cloud-assembly-schema=exact @aws-cdk/cloudformation-diff=exact cdk-assets=major", "receiveArgs": true } ] diff --git a/packages/cdk-assets/.projen/tasks.json b/packages/cdk-assets/.projen/tasks.json index 772de6d78..ad7bea1e9 100644 --- a/packages/cdk-assets/.projen/tasks.json +++ b/packages/cdk-assets/.projen/tasks.json @@ -102,7 +102,7 @@ "name": "gather-versions", "steps": [ { - "exec": "node -e \"require(path.join(path.dirname(require.resolve('cdklabs-projen-project-types')), 'yarn', 'gather-versions.exec.js'))\" cdk-assets MAJOR --deps @aws-cdk/cloud-assembly-schema", + "exec": "node -e \"require(require.resolve('cdklabs-projen-project-types/lib/yarn/gather-versions.exec.js')).cliMain()\" @aws-cdk/cloud-assembly-schema=exact", "receiveArgs": true } ] diff --git a/packages/cdk/.projen/tasks.json b/packages/cdk/.projen/tasks.json index 0d0cab3ee..1f70c84d5 100644 --- a/packages/cdk/.projen/tasks.json +++ b/packages/cdk/.projen/tasks.json @@ -101,7 +101,7 @@ "name": "gather-versions", "steps": [ { - "exec": "node -e \"require(path.join(path.dirname(require.resolve('cdklabs-projen-project-types')), 'yarn', 'gather-versions.exec.js'))\" cdk MAJOR --deps aws-cdk", + "exec": "node -e \"require(require.resolve('cdklabs-projen-project-types/lib/yarn/gather-versions.exec.js')).cliMain()\" aws-cdk=exact", "receiveArgs": true } ] diff --git a/yarn.lock b/yarn.lock index 7febadebf..9a4453d60 100644 --- a/yarn.lock +++ b/yarn.lock @@ -4546,10 +4546,10 @@ cdk-from-cfn@^0.193.0: resolved "https://registry.yarnpkg.com/cdk-from-cfn/-/cdk-from-cfn-0.193.0.tgz#048daca73be6dfd3ab3c104f67f2828587b1c761" integrity sha512-LBKqAnsg12RRhyz+zyByI3H6REiDVNm1vofhdnEXSAIGIBuO0H/cw4mbCpz0Qr9huZYssF9ozGsbwa1K3RF2Tg== -cdklabs-projen-project-types@^0.2.3: - version "0.2.3" - resolved "https://registry.yarnpkg.com/cdklabs-projen-project-types/-/cdklabs-projen-project-types-0.2.3.tgz#49a9248b04c4deaa0a1cba8ca80d0f00c4881562" - integrity sha512-emIW3suU3JwyvIAQsE01znIpkHKFc/7RTYP+OIvyxwhTJ0gjGSE63D9iXEx892sE0JaB9iIB1Or8qpzxNGcMcw== +cdklabs-projen-project-types@^0.2.8: + version "0.2.8" + resolved "https://registry.yarnpkg.com/cdklabs-projen-project-types/-/cdklabs-projen-project-types-0.2.8.tgz#67fc9094b490baf30392b180bdeac20160978f89" + integrity sha512-pEc2vcLvdhcnCY7iIWB4/YpDVprxpI8jjcAZaHtZr0eUTkQvP18CeVVgSzcQkPx5/21uTdK4BZQIicmwaXFrKw== dependencies: yaml "^2.7.0"