@aws-cdk-testing/cli-integ 2.61.0

package/bin/run-suite.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+const path = require("path");
+// eslint-disable-next-line jest/no-jest-import
+const jest = require("jest");
+const yargs = require("yargs");
+const release_source_1 = require("../lib/package-sources/release-source");
+const repo_source_1 = require("../lib/package-sources/repo-source");
+const subprocess_1 = require("../lib/package-sources/subprocess");
+async function main() {
+    const args = await yargs
+        .usage('$0 <SUITENAME>')
+        .positional('SUITENAME', {
+        descripton: 'Name of the test suite to run',
+        type: 'string',
+        demandOption: true,
+    })
+        .option('test', {
+        descripton: 'Test pattern to selectively run tests',
+        alias: 't',
+        type: 'string',
+        requiresArg: true,
+    })
+        .option('use-source', {
+        descripton: 'Use TypeScript packages from the given source repository (or "auto")',
+        alias: 's',
+        type: 'string',
+        requiresArg: true,
+    })
+        .option('use-cli-release', {
+        descripton: 'Run the current tests against the CLI at the given version',
+        alias: 'u',
+        type: 'string',
+        requiresArg: true,
+    })
+        .option('auto-source', {
+        alias: 'a',
+        description: 'Automatically find the source tree from the current working directory',
+        type: 'boolean',
+        requiresArg: false,
+    })
+        .option('runInBand', {
+        descripton: 'Run all tests in one Node process',
+        alias: 'i',
+        type: 'boolean',
+    })
+        .options('framework-version', {
+        description: 'Framework version to use, if different than the CLI version (not all suites respect this)',
+        alias: 'f',
+        type: 'string',
+    })
+        .options('verbose', {
+        alias: 'v',
+        description: 'Run in verbose mode',
+        type: 'boolean',
+        requiresArg: false,
+    })
+        .options('passWithNoTests', {
+        description: 'Allow passing if the test suite is not found (default true when IS_CANARY mode, false otherwise)',
+        type: 'boolean',
+        requiresArg: false,
+    })
+        .help()
+        .strictOptions()
+        .showHelpOnFail(false)
+        .argv;
+    const suiteName = args._[0];
+    if (!suiteName) {
+        throw new Error('Usage: run-suite <SUITENAME>');
+    }
+    let packageSource;
+    function usePackageSource(s) {
+        if (packageSource) {
+            throw new Error('Cannot specify two package sources');
+        }
+        packageSource = s;
+    }
+    if (args['use-source'] || args['auto-source']) {
+        if (args['framework-version']) {
+            throw new Error('Cannot use --framework-version with --use-source');
+        }
+        const root = args['use-source'] && args['use-source'] !== 'auto'
+            ? args['use-source']
+            : await repo_source_1.autoFindRoot();
+        usePackageSource(new repo_source_1.RepoPackageSourceSetup(root));
+    }
+    else if (args['use-cli-release']) {
+        usePackageSource(new release_source_1.ReleasePackageSourceSetup(args['use-cli-release'], args['framework-version']));
+    }
+    if (!packageSource) {
+        throw new Error('Specify either --use-source or --use-cli-release');
+    }
+    console.log(`Package source: ${packageSource.description}`);
+    console.log(`Test suite:     ${suiteName}`);
+    await packageSource.prepare();
+    subprocess_1.serializeForSubprocess(packageSource);
+    if (args.verbose) {
+        process.env.VERBOSE = '1';
+    }
+    // Motivation behind this behavior: when adding a new test suite to the pipeline, because of the way our
+    // Pipeline package works, the suite would be added to the pipeline AND as a canary immediately. The canary
+    // would fail until the package was actually released, so for canaries we make an exception so that the initial
+    // canary would succeed even if the suite wasn't yet available. The fact that the suite is not optional in
+    // the pipeline protects us from typos.
+    const passWithNoTests = args.passWithNoTests ?? !!process.env.IS_CANARY;
+    // Communicate with the config file (integ.jest.config.js)
+    process.env.TEST_SUITE_NAME = suiteName;
+    try {
+        await jest.run([
+            ...args.runInBand ? ['-i'] : [],
+            ...args.test ? ['-t', args.test] : [],
+            ...args.verbose ? ['--verbose'] : [],
+            ...passWithNoTests ? ['--passWithNoTests'] : [],
+        ], path.resolve(__dirname, '..', 'resources', 'integ.jest.config.js'));
+    }
+    finally {
+        await packageSource.cleanup();
+    }
+}
+main().catch(e => {
+    // eslint-disable-next-line no-console
+    console.error(e);
+    process.exitCode = 1;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"run-suite.js","sourceRoot":"","sources":["run-suite.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-console */\nimport * as path from 'path';\n// eslint-disable-next-line jest/no-jest-import\nimport * as jest from 'jest';\nimport * as yargs from 'yargs';\nimport { ReleasePackageSourceSetup } from '../lib/package-sources/release-source';\nimport { RepoPackageSourceSetup, autoFindRoot } from '../lib/package-sources/repo-source';\nimport { IPackageSourceSetup } from '../lib/package-sources/source';\nimport { serializeForSubprocess } from '../lib/package-sources/subprocess';\n\nasync function main() {\n  const args = await yargs\n    .usage('$0 <SUITENAME>')\n    .positional('SUITENAME', {\n      descripton: 'Name of the test suite to run',\n      type: 'string',\n      demandOption: true,\n    })\n    .option('test', {\n      descripton: 'Test pattern to selectively run tests',\n      alias: 't',\n      type: 'string',\n      requiresArg: true,\n    })\n    .option('use-source', {\n      descripton: 'Use TypeScript packages from the given source repository (or \"auto\")',\n      alias: 's',\n      type: 'string',\n      requiresArg: true,\n    })\n    .option('use-cli-release', {\n      descripton: 'Run the current tests against the CLI at the given version',\n      alias: 'u',\n      type: 'string',\n      requiresArg: true,\n    })\n    .option('auto-source', {\n      alias: 'a',\n      description: 'Automatically find the source tree from the current working directory',\n      type: 'boolean',\n      requiresArg: false,\n    })\n    .option('runInBand', {\n      descripton: 'Run all tests in one Node process',\n      alias: 'i',\n      type: 'boolean',\n    })\n    .options('framework-version', {\n      description: 'Framework version to use, if different than the CLI version (not all suites respect this)',\n      alias: 'f',\n      type: 'string',\n    })\n    .options('verbose', {\n      alias: 'v',\n      description: 'Run in verbose mode',\n      type: 'boolean',\n      requiresArg: false,\n    })\n    .options('passWithNoTests', {\n      description: 'Allow passing if the test suite is not found (default true when IS_CANARY mode, false otherwise)',\n      type: 'boolean',\n      requiresArg: false,\n    })\n    .help()\n    .strictOptions()\n    .showHelpOnFail(false)\n    .argv;\n\n  const suiteName = args._[0] as string;\n  if (!suiteName) {\n    throw new Error('Usage: run-suite <SUITENAME>');\n  }\n\n  let packageSource: undefined | IPackageSourceSetup;\n  function usePackageSource(s: IPackageSourceSetup) {\n    if (packageSource) {\n      throw new Error('Cannot specify two package sources');\n    }\n    packageSource = s;\n  }\n\n  if (args['use-source'] || args['auto-source']) {\n    if (args['framework-version']) {\n      throw new Error('Cannot use --framework-version with --use-source');\n    }\n\n    const root = args['use-source'] && args['use-source'] !== 'auto'\n      ? args['use-source']\n      : await autoFindRoot();\n\n    usePackageSource(new RepoPackageSourceSetup(root));\n  } else if (args['use-cli-release']) {\n    usePackageSource(new ReleasePackageSourceSetup(args['use-cli-release'], args['framework-version']));\n  }\n  if (!packageSource) {\n    throw new Error('Specify either --use-source or --use-cli-release');\n  }\n\n  console.log(`Package source: ${packageSource.description}`);\n  console.log(`Test suite:     ${suiteName}`);\n\n  await packageSource.prepare();\n  serializeForSubprocess(packageSource);\n\n  if (args.verbose) {\n    process.env.VERBOSE = '1';\n  }\n\n  // Motivation behind this behavior: when adding a new test suite to the pipeline, because of the way our\n  // Pipeline package works, the suite would be added to the pipeline AND as a canary immediately. The canary\n  // would fail until the package was actually released, so for canaries we make an exception so that the initial\n  // canary would succeed even if the suite wasn't yet available. The fact that the suite is not optional in\n  // the pipeline protects us from typos.\n  const passWithNoTests = args.passWithNoTests ?? !!process.env.IS_CANARY;\n\n  // Communicate with the config file (integ.jest.config.js)\n  process.env.TEST_SUITE_NAME = suiteName;\n\n  try {\n    await jest.run([\n      ...args.runInBand ? ['-i'] : [],\n      ...args.test ? ['-t', args.test] : [],\n      ...args.verbose ? ['--verbose'] : [],\n      ...passWithNoTests ? ['--passWithNoTests'] : [],\n    ], path.resolve(__dirname, '..', 'resources', 'integ.jest.config.js'));\n\n  } finally {\n    await packageSource.cleanup();\n  }\n}\n\nmain().catch(e => {\n  // eslint-disable-next-line no-console\n  console.error(e);\n  process.exitCode = 1;\n});\n"]}

package/bin/stage-distribution

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('./stage-distribution.js');

package/bin/stage-distribution.d.ts

@@ -0,0 +1 @@
+export {};

package/bin/stage-distribution.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+const path = require("path");
+const fs = require("fs-extra");
+const glob = require("glob");
+const yargs = require("yargs");
+const lib_1 = require("../lib");
+const codeartifact_1 = require("../lib/staging/codeartifact");
+const maven_1 = require("../lib/staging/maven");
+const npm_1 = require("../lib/staging/npm");
+const nuget_1 = require("../lib/staging/nuget");
+const pypi_1 = require("../lib/staging/pypi");
+const usage_dir_1 = require("../lib/staging/usage-dir");
+async function main() {
+    await yargs
+        .usage('$0 <command>')
+        .option('npm', {
+        description: 'Upload NPM packages only',
+        type: 'boolean',
+        requiresArg: false,
+    })
+        .option('python', {
+        description: 'Upload Python packages only',
+        type: 'boolean',
+        requiresArg: false,
+    })
+        .option('java', {
+        description: 'Upload Java packages only',
+        type: 'boolean',
+        requiresArg: false,
+    })
+        .option('dotnet', {
+        description: 'Upload Dotnet packages only',
+        type: 'boolean',
+        requiresArg: false,
+    })
+        .command('publish <DIRECTORY>', 'Publish a given directory', cmd => cmd
+        .positional('DIRECTORY', {
+        descripton: 'Directory distribution',
+        type: 'string',
+        demandOption: true,
+    })
+        .option('name', {
+        alias: 'n',
+        description: 'Name of the repository to create (default: generate unique name)',
+        type: 'string',
+        requiresArg: true,
+    }), async (args) => {
+        await validateDirectory(args);
+        const repo = await (args.name ? codeartifact_1.TestRepository.newWithName(args.name) : codeartifact_1.TestRepository.newRandom());
+        const usageDir = usage_dir_1.UsageDir.default();
+        await doLogin(repo, usageDir, args);
+        await publish(repo, usageDir, args);
+        header('Done');
+        usageDir.advertise();
+    })
+        .command('login', 'Login to a given repository', cmd => cmd
+        .option('name', {
+        alias: 'n',
+        description: 'Name of the repository to log in to',
+        type: 'string',
+        requiresArg: true,
+        demandOption: true,
+    }), async (args) => {
+        const repo = codeartifact_1.TestRepository.existing(args.name);
+        const usageDir = usage_dir_1.UsageDir.default();
+        await doLogin(repo, usageDir, args);
+        usageDir.advertise();
+    })
+        .command('run <DIRECTORY> <COMMAND..>', 'Publish and run a command', cmd => cmd
+        .positional('DIRECTORY', {
+        descripton: 'Directory distribution',
+        type: 'string',
+        demandOption: true,
+    })
+        .positional('COMMAND', {
+        alias: 'c',
+        description: 'Run the given command with the packages staged',
+        type: 'string',
+        array: true,
+        demandOption: true,
+    })
+        .option('cleanup', {
+        alias: 'C',
+        description: 'Cleanup the repository afterwards',
+        type: 'boolean',
+        default: true,
+        requiresArg: false,
+    }), async (args) => {
+        await validateDirectory(args);
+        const repo = await codeartifact_1.TestRepository.newRandom();
+        const usageDir = usage_dir_1.UsageDir.default();
+        await doLogin(repo, usageDir, args);
+        await publish(repo, usageDir, args);
+        try {
+            await usageDir.activateInCurrentProcess();
+            await lib_1.shell(args.COMMAND ?? [], {
+                shell: true,
+                show: 'always',
+            });
+        }
+        finally {
+            if (args.cleanup) {
+                await repo.delete();
+            }
+        }
+    })
+        .command('cleanup', 'Clean up testing repository', cmd => cmd
+        .option('name', {
+        alias: 'n',
+        description: 'Name of the repository to cleanup (default: most recent)',
+        type: 'string',
+        requiresArg: true,
+    }), async (args) => {
+        const usageDir = usage_dir_1.UsageDir.default();
+        let repositoryName = args.name;
+        if (!repositoryName) {
+            repositoryName = (await usageDir.currentEnv()).CODEARTIFACT_REPO;
+        }
+        if (!repositoryName) {
+            console.log(`No --name given and no $CODEARTIFACT_REPO found in ${usageDir.directory}, nothing cleaned up`);
+            return;
+        }
+        const repo = codeartifact_1.TestRepository.existing(repositoryName);
+        await repo.delete();
+    })
+        .command('gc', 'Clean up day-old testing repositories', cmd => cmd, async () => {
+        await codeartifact_1.TestRepository.gc();
+    })
+        .demandCommand(1, 'You must supply a command')
+        .help()
+        .strictOptions()
+        .showHelpOnFail(false)
+        .parse();
+}
+async function validateDirectory(args) {
+    if (!await fs.pathExists(path.join(args.DIRECTORY, 'build.json'))) {
+        throw new Error(`${args.DIRECTORY} does not look like a CDK dist directory (build.json missing)`);
+    }
+}
+async function doLogin(repo, usageDir, args) {
+    const login = await repo.loginInformation();
+    const oldEnv = await usageDir.currentEnv();
+    await usageDir.clean();
+    await usageDir.addToEnv({
+        CODEARTIFACT_REPO: login.repositoryName,
+    });
+    if (oldEnv.BUILD_VERSION) {
+        await usageDir.addToEnv({
+            BUILD_VERSION: oldEnv.BUILD_VERSION,
+        });
+    }
+    const doRepo = whichRepos(args);
+    await doRepo.npm(() => npm_1.npmLogin(login, usageDir));
+    await doRepo.python(() => pypi_1.pypiLogin(login, usageDir));
+    await doRepo.java(() => maven_1.mavenLogin(login, usageDir));
+    await doRepo.dotnet(() => nuget_1.nugetLogin(login, usageDir));
+}
+async function publish(repo, usageDir, args) {
+    const directory = `${args.DIRECTORY}`;
+    const login = await repo.loginInformation();
+    const doRepo = whichRepos(args);
+    const buildJson = await fs.readJson(path.join(directory, 'build.json'));
+    await usageDir.addToEnv({
+        BUILD_VERSION: buildJson.version,
+    });
+    await doRepo.npm(async () => {
+        header('NPM');
+        await npm_1.uploadNpmPackages(glob.sync(path.join(directory, 'js', '*.tgz')), login, usageDir);
+    });
+    await doRepo.python(async () => {
+        header('Python');
+        await pypi_1.uploadPythonPackages(glob.sync(path.join(directory, 'python', '*')), login);
+    });
+    await doRepo.java(async () => {
+        header('Java');
+        await maven_1.uploadJavaPackages(glob.sync(path.join(directory, 'java', '**', '*.pom')), login, usageDir);
+    });
+    await doRepo.dotnet(async () => {
+        header('.NET');
+        await nuget_1.uploadDotnetPackages(glob.sync(path.join(directory, 'dotnet', '**', '*.nupkg')), usageDir);
+    });
+    console.log('🛍 Configuring packages for upstream versions');
+    await repo.markAllUpstreamAllow();
+}
+function whichRepos(args) {
+    const all = args.npm === undefined && args.python === undefined && args.java === undefined && args.dotnet === undefined;
+    const invoke = (block) => block();
+    const skip = () => { };
+    return {
+        npm: args.npm || all ? invoke : skip,
+        python: args.python || all ? invoke : skip,
+        java: args.java || all ? invoke : skip,
+        dotnet: args.dotnet || all ? invoke : skip,
+    };
+}
+function header(caption) {
+    console.log('');
+    console.log('/'.repeat(70));
+    console.log(`//  ${caption}`);
+    console.log('');
+}
+main().catch(e => {
+    // eslint-disable-next-line no-console
+    console.error(e);
+    process.exitCode = 1;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stage-distribution.js","sourceRoot":"","sources":["stage-distribution.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-console */\nimport * as path from 'path';\nimport * as fs from 'fs-extra';\nimport * as glob from 'glob';\nimport * as yargs from 'yargs';\nimport { shell } from '../lib';\nimport { TestRepository } from '../lib/staging/codeartifact';\nimport { uploadJavaPackages, mavenLogin } from '../lib/staging/maven';\nimport { uploadNpmPackages, npmLogin } from '../lib/staging/npm';\nimport { uploadDotnetPackages, nugetLogin } from '../lib/staging/nuget';\nimport { uploadPythonPackages, pypiLogin } from '../lib/staging/pypi';\nimport { UsageDir } from '../lib/staging/usage-dir';\n\nasync function main() {\n  await yargs\n    .usage('$0 <command>')\n    .option('npm', {\n      description: 'Upload NPM packages only',\n      type: 'boolean',\n      requiresArg: false,\n    })\n    .option('python', {\n      description: 'Upload Python packages only',\n      type: 'boolean',\n      requiresArg: false,\n    })\n    .option('java', {\n      description: 'Upload Java packages only',\n      type: 'boolean',\n      requiresArg: false,\n    })\n    .option('dotnet', {\n      description: 'Upload Dotnet packages only',\n      type: 'boolean',\n      requiresArg: false,\n    })\n    .command('publish <DIRECTORY>', 'Publish a given directory', cmd => cmd\n      .positional('DIRECTORY', {\n        descripton: 'Directory distribution',\n        type: 'string',\n        demandOption: true,\n      })\n      .option('name', {\n        alias: 'n',\n        description: 'Name of the repository to create (default: generate unique name)',\n        type: 'string',\n        requiresArg: true,\n      }), async (args) => {\n\n      await validateDirectory(args);\n      const repo = await (args.name ? TestRepository.newWithName(args.name) : TestRepository.newRandom());\n      const usageDir = UsageDir.default();\n\n      await doLogin(repo, usageDir, args);\n      await publish(repo, usageDir, args);\n\n      header('Done');\n      usageDir.advertise();\n    })\n    .command('login', 'Login to a given repository', cmd => cmd\n      .option('name', {\n        alias: 'n',\n        description: 'Name of the repository to log in to',\n        type: 'string',\n        requiresArg: true,\n        demandOption: true,\n      }), async (args) => {\n\n      const repo = TestRepository.existing(args.name);\n      const usageDir = UsageDir.default();\n\n      await doLogin(repo, usageDir, args);\n\n      usageDir.advertise();\n    })\n    .command('run <DIRECTORY> <COMMAND..>', 'Publish and run a command', cmd => cmd\n      .positional('DIRECTORY', {\n        descripton: 'Directory distribution',\n        type: 'string',\n        demandOption: true,\n      })\n      .positional('COMMAND', {\n        alias: 'c',\n        description: 'Run the given command with the packages staged',\n        type: 'string',\n        array: true,\n        demandOption: true,\n      })\n      .option('cleanup', {\n        alias: 'C',\n        description: 'Cleanup the repository afterwards',\n        type: 'boolean',\n        default: true,\n        requiresArg: false,\n      }), async (args) => {\n\n      await validateDirectory(args);\n      const repo = await TestRepository.newRandom();\n      const usageDir = UsageDir.default();\n\n      await doLogin(repo, usageDir, args);\n      await publish(repo, usageDir, args);\n\n      try {\n        await usageDir.activateInCurrentProcess();\n\n        await shell(args.COMMAND ?? [], {\n          shell: true,\n          show: 'always',\n        });\n\n      } finally {\n        if (args.cleanup) {\n          await repo.delete();\n        }\n      }\n    })\n    .command('cleanup', 'Clean up testing repository', cmd => cmd\n      .option('name', {\n        alias: 'n',\n        description: 'Name of the repository to cleanup (default: most recent)',\n        type: 'string',\n        requiresArg: true,\n      }), async (args) => {\n\n      const usageDir = UsageDir.default();\n\n      let repositoryName = args.name;\n      if (!repositoryName) {\n        repositoryName = (await usageDir.currentEnv()).CODEARTIFACT_REPO;\n      }\n\n      if (!repositoryName) {\n        console.log(`No --name given and no $CODEARTIFACT_REPO found in ${usageDir.directory}, nothing cleaned up`);\n        return;\n      }\n\n      const repo = TestRepository.existing(repositoryName);\n      await repo.delete();\n    })\n    .command('gc', 'Clean up day-old testing repositories', cmd => cmd, async () => {\n      await TestRepository.gc();\n    })\n    .demandCommand(1, 'You must supply a command')\n    .help()\n    .strictOptions()\n    .showHelpOnFail(false)\n    .parse();\n}\n\nasync function validateDirectory(args: {\n  DIRECTORY: string,\n}) {\n  if (!await fs.pathExists(path.join(args.DIRECTORY, 'build.json'))) {\n    throw new Error(`${args.DIRECTORY} does not look like a CDK dist directory (build.json missing)`);\n  }\n}\n\nasync function doLogin(repo: TestRepository, usageDir: UsageDir, args: {\n  npm?: boolean;\n  python?: boolean;\n  java?: boolean;\n  dotnet?: boolean;\n}) {\n  const login = await repo.loginInformation();\n\n  const oldEnv = await usageDir.currentEnv();\n\n  await usageDir.clean();\n  await usageDir.addToEnv({\n    CODEARTIFACT_REPO: login.repositoryName,\n  });\n\n  if (oldEnv.BUILD_VERSION) {\n    await usageDir.addToEnv({\n      BUILD_VERSION: oldEnv.BUILD_VERSION,\n    });\n  }\n\n  const doRepo = whichRepos(args);\n\n  await doRepo.npm(() => npmLogin(login, usageDir));\n  await doRepo.python(() => pypiLogin(login, usageDir));\n  await doRepo.java(() => mavenLogin(login, usageDir));\n  await doRepo.dotnet(() => nugetLogin(login, usageDir));\n}\n\nasync function publish(repo: TestRepository, usageDir: UsageDir, args: {\n  DIRECTORY: string,\n  npm?: boolean;\n  python?: boolean;\n  java?: boolean;\n  dotnet?: boolean;\n}) {\n  const directory = `${args.DIRECTORY}`;\n  const login = await repo.loginInformation();\n\n  const doRepo = whichRepos(args);\n\n  const buildJson = await fs.readJson(path.join(directory, 'build.json'));\n  await usageDir.addToEnv({\n    BUILD_VERSION: buildJson.version,\n  });\n\n  await doRepo.npm(async () => {\n    header('NPM');\n    await uploadNpmPackages(glob.sync(path.join(directory, 'js', '*.tgz')), login, usageDir);\n  });\n\n  await doRepo.python(async () => {\n    header('Python');\n    await uploadPythonPackages(glob.sync(path.join(directory, 'python', '*')), login);\n  });\n\n  await doRepo.java(async () => {\n    header('Java');\n    await uploadJavaPackages(glob.sync(path.join(directory, 'java', '**', '*.pom')), login, usageDir);\n  });\n\n  await doRepo.dotnet(async () => {\n    header('.NET');\n    await uploadDotnetPackages(glob.sync(path.join(directory, 'dotnet', '**', '*.nupkg')), usageDir);\n  });\n\n  console.log('🛍 Configuring packages for upstream versions');\n  await repo.markAllUpstreamAllow();\n}\n\nfunction whichRepos(args: {\n  npm?: boolean;\n  python?: boolean;\n  java?: boolean;\n  dotnet?: boolean;\n}) {\n  const all = args.npm === undefined && args.python === undefined && args.java === undefined && args.dotnet === undefined;\n\n  const invoke = (block: () => Promise<void>) => block();\n  const skip = () => { };\n\n  return {\n    npm: args.npm || all ? invoke : skip,\n    python: args.python || all ? invoke : skip,\n    java: args.java || all ? invoke : skip,\n    dotnet: args.dotnet || all ? invoke : skip,\n  };\n}\n\nfunction header(caption: string) {\n  console.log('');\n  console.log('/'.repeat(70));\n  console.log(`//  ${caption}`);\n  console.log('');\n}\n\nmain().catch(e => {\n  // eslint-disable-next-line no-console\n  console.error(e);\n  process.exitCode = 1;\n});\n"]}

package/bin/test-root

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('./test-root.js');

package/bin/test-root.d.ts

@@ -0,0 +1 @@
+export {};

package/bin/test-root.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+// eslint-disable-next-line no-console
+console.log(path.resolve(__dirname, '..'));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC1yb290LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsidGVzdC1yb290LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsNkJBQTZCO0FBQzdCLHNDQUFzQztBQUN0QyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxFQUFFLElBQUksQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBwYXRoIGZyb20gJ3BhdGgnO1xuLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWNvbnNvbGVcbmNvbnNvbGUubG9nKHBhdGgucmVzb2x2ZShfX2Rpcm5hbWUsICcuLicpKTsiXX0=

package/entrypoints/test-cli-regression-against-current-code.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+#
+# Run our integration tests in regression mode against the
+# candidate version of the framework, which is the one we just packed.
+#
+set -euo pipefail
+integdir=$(cd $(dirname $0) && pwd)
+
+source ${integdir}/test-cli-regression.bash
+
+run_regression_against_framework_version CANDIDATE_VERSION

package/entrypoints/test-cli-regression-against-latest-release.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+#
+# Run our integration tests in regression mode against the
+# previous version of the framework, relative to the version being packed now.
+#
+set -euo pipefail
+integdir=$(cd $(dirname $0) && pwd)
+
+source ${integdir}/test-cli-regression.bash
+
+run_regression_against_framework_version PREVIOUS_VERSION

package/entrypoints/test-cli-regression.bash

@@ -0,0 +1,83 @@
+#!/bin/bash
+#
+# Helper functions for CLI regression tests.
+#
+set -euo pipefail
+integdir=$(cd $(dirname $0) && pwd)
+
+# Run our integration tests in regression mode.
+#
+#   1. Figure out what was the previous (relative to the current candidate) version we published.
+#   2. Download the integration tests artifact from that version.
+#   2. Copy its integration tests directory ((test/integ/cli)) here.
+#   3. Run the integration tests from the copied directory.
+#
+# Positional Arugments:
+#
+#   1) Framework version identifier. Which version of the framework should the tests run against. Options are:
+#
+#       - CANDIDATE_VERSION: Use the candidate code, i.e the one being built right now.
+#       - PREVIOUS_VERSION: Use the previous version code, i.e the published version prior to CANDIDATE_VERSION.
+#
+function run_regression_against_framework_version() {
+
+  TEST_RUNNER=${TEST_RUNNER:-""}
+  CANDIDATE_VERSION=${CANDIDATE_VERSION:-""}
+
+  if [ "${TEST_RUNNER}" != "dist" ]; then
+    echo "Unsupported runner: ${TEST_RUNNER}. Regression tests can only run with the 'dist' runner"
+    exit 1
+  fi
+
+  SUPPORTED_FRAMEWORK_VERSION_IDENTIFIERS=("CANDIDATE_VERSION PREVIOUS_VERSION")
+  FRAMEWORK_VERSION_IDENTIFIER=$1
+  if [[ ! " ${SUPPORTED_FRAMEWORK_VERSION_IDENTIFIERS[@]} " =~ " ${FRAMEWORK_VERSION_IDENTIFIER} " ]]; then
+      echo "Unsupported framework version identifier. Should be one of ${SUPPORTED_FRAMEWORK_VERSION_IDENTIFIERS}"
+      exit 1
+  fi
+
+  echo "Fetching previous version for candidate: ${CANDIDATE_VERSION}"
+
+  # we need to explicitly install these deps because this script is executed
+  # int the test phase, which means the cwd is the packaged dist directory,
+  # so it doesn't have the dependencies installed from the installation of the package.json
+  # in the build phase. maybe we should just run npm install on the package.json again?
+  npm install @octokit/rest@^18.0.6 semver@^7.3.2 make-runnable@^1.3.8
+  PREVIOUS_VERSION=$(node ${integdir}/github-helpers.js fetchPreviousVersion ${CANDIDATE_VERSION})
+
+  echo "Previous version is: ${PREVIOUS_VERSION}"
+
+  temp_dir=$(mktemp -d)
+  integ_under_test=${integdir}/cli-backwards-tests-${PREVIOUS_VERSION}
+
+  pushd ${temp_dir}
+
+  echo "Downloading aws-cdk ${PREVIOUS_VERSION} tarball from npm"
+  npm pack aws-cdk@${PREVIOUS_VERSION}
+  tar -zxf aws-cdk-${PREVIOUS_VERSION}.tgz
+
+  rm -rf ${integ_under_test}
+
+  echo "Copying integration tests of version ${PREVIOUS_VERSION} to ${integ_under_test} (dont worry, its gitignored)"
+  cp -r ${temp_dir}/package/test/integ/cli "${integ_under_test}"
+  cp -r ${temp_dir}/package/test/integ/helpers "${integ_under_test}"
+
+  patch_dir="${integdir}/cli-regression-patches/v${PREVIOUS_VERSION}"
+  # delete possibly stale junit.xml file
+  rm -f ${integ_under_test}/junit.xml
+  if [[ -d "$patch_dir" ]]; then
+      echo "Hotpatching the tests with files from $patch_dir" >&2
+      cp -r "$patch_dir"/* ${integ_under_test}
+  fi
+
+  popd
+
+  # the framework version to use is determined by the caller as the first argument.
+  # its a variable name indirection.
+  export FRAMEWORK_VERSION=${!FRAMEWORK_VERSION_IDENTIFIER}
+
+  # Show the versions we settled on
+  echo "♈️ Regression testing [cli $(cdk --version)] against [framework ${FRAMEWORK_VERSION}] using [tests ${PREVIOUS_VERSION}}]"
+
+  ${integ_under_test}/test.sh
+}

package/entrypoints/test.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+set -euo pipefail
+scriptdir=$(cd $(dirname $0) && pwd)
+
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo 'CLI Integration Tests'
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+
+cd $scriptdir
+
+source ../common/jest-test.bash
+invokeJest "$@"

package/lib/aws.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="node" />
+import * as AWS from 'aws-sdk';
+export declare class AwsClients {
+    readonly region: string;
+    private readonly output;
+    static default(output: NodeJS.WritableStream): Promise<AwsClients>;
+    static forRegion(region: string, output: NodeJS.WritableStream): Promise<AwsClients>;
+    private readonly config;
+    readonly cloudFormation: AwsCaller<AWS.CloudFormation>;
+    readonly s3: AwsCaller<AWS.S3>;
+    readonly ecr: AwsCaller<AWS.ECR>;
+    readonly sns: AwsCaller<AWS.SNS>;
+    readonly iam: AwsCaller<AWS.IAM>;
+    readonly lambda: AwsCaller<AWS.Lambda>;
+    readonly sts: AwsCaller<AWS.STS>;
+    constructor(region: string, output: NodeJS.WritableStream);
+    account(): Promise<string>;
+    deleteStacks(...stackNames: string[]): Promise<void>;
+    stackStatus(stackName: string): Promise<string | undefined>;
+    emptyBucket(bucketName: string): Promise<void | AWS.S3.DeleteObjectsOutput>;
+    deleteImageRepository(repositoryName: string): Promise<void>;
+    deleteBucket(bucketName: string): Promise<void>;
+}
+declare type AwsCaller<A> = <B extends keyof ServiceCalls<A>>(call: B, request: First<ServiceCalls<A>[B]>) => Promise<Second<ServiceCalls<A>[B]>>;
+declare type ServiceCalls<T> = NoNayNever<SimplifiedService<T>>;
+declare type SimplifiedService<T> = {
+    [k in keyof T]: AwsCallIO<T[k]>;
+};
+declare type NoNayNever<T> = Pick<T, {
+    [k in keyof T]: T[k] extends never ? never : k;
+}[keyof T]>;
+declare type AwsCallIO<T> = T extends {
+    (args: infer INPUT, callback?: ((err: AWS.AWSError, data: any) => void) | undefined): AWS.Request<infer OUTPUT, AWS.AWSError>;
+    (callback?: ((err: AWS.AWSError, data: {}) => void) | undefined): AWS.Request<any, any>;
+} ? [INPUT, OUTPUT] : never;
+declare type First<T> = T extends [any, any] ? T[0] : never;
+declare type Second<T> = T extends [any, any] ? T[1] : never;
+export declare function isStackMissingError(e: Error): boolean;
+export declare function isBucketMissingError(e: Error): boolean;
+/**
+ * Retry an async operation until a deadline is hit.
+ *
+ * Use `retry.forSeconds()` to construct a deadline relative to right now.
+ *
+ * Exceptions will cause the operation to retry. Use `retry.abort` to annotate an exception
+ * to stop the retry and end in a failure.
+ */
+export declare function retry<A>(output: NodeJS.WritableStream, operation: string, deadline: Date, block: () => Promise<A>): Promise<A>;
+export declare namespace retry {
+    var forSeconds: (seconds: number) => Date;
+    var abort: (e: Error) => Error;
+}
+export declare function outputFromStack(key: string, stack: AWS.CloudFormation.Stack): string | undefined;
+export declare function sleep(ms: number): Promise<unknown>;
+export {};