@aws-cdk-testing/cli-integ 0.0.0

package/bin/run-suite.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+const path = require("path");
+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() {
+    var _a;
+    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('test-file', {
+        description: 'The specific test file to run',
+        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()
+        .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 (0, 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();
+    (0, 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 = (_a = args.passWithNoTests) !== null && _a !== void 0 ? _a : !!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'] : [],
+            ...args['test-file'] ? [args['test-file']] : [],
+        ], 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';\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('test-file', {\n      description: 'The specific test file to run',\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    .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      ...args['test-file'] ? [args['test-file']] : [],\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/run-suite.ts

@@ -0,0 +1,140 @@
+/* eslint-disable no-console */
+import * as path from 'path';
+import * as jest from 'jest';
+import * as yargs from 'yargs';
+import { ReleasePackageSourceSetup } from '../lib/package-sources/release-source';
+import { RepoPackageSourceSetup, autoFindRoot } from '../lib/package-sources/repo-source';
+import { IPackageSourceSetup } from '../lib/package-sources/source';
+import { serializeForSubprocess } from '../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('test-file', {
+      description: 'The specific test file to run',
+      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()
+    .showHelpOnFail(false)
+    .argv;
+
+  const suiteName = args._[0] as string;
+  if (!suiteName) {
+    throw new Error('Usage: run-suite <SUITENAME>');
+  }
+
+  let packageSource: undefined | IPackageSourceSetup;
+  function usePackageSource(s: IPackageSourceSetup) {
+    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 autoFindRoot();
+
+    usePackageSource(new RepoPackageSourceSetup(root));
+  } else if (args['use-cli-release']) {
+    usePackageSource(new 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();
+  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'] : [],
+      ...args['test-file'] ? [args['test-file']] : [],
+    ], 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;
+});

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,217 @@
+"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,
+    })
+        .option('regression', {
+        description: 'Enable access to previous versions of the staged packages (this is expensive for CodeArtifact so we only do it when necessary)',
+        type: 'boolean',
+        requiresArg: false,
+        default: 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) => {
+        var _a;
+        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 (0, lib_1.shell)((_a = args.COMMAND) !== null && _a !== void 0 ? _a : [], {
+                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()
+        .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(() => (0, npm_1.npmLogin)(login, usageDir));
+    await doRepo.python(() => (0, pypi_1.pypiLogin)(login, usageDir));
+    await doRepo.java(() => (0, maven_1.mavenLogin)(login, usageDir));
+    await doRepo.dotnet(() => (0, 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 (0, npm_1.uploadNpmPackages)(glob.sync(path.join(directory, 'js', '*.tgz')), login, usageDir);
+    });
+    await doRepo.python(async () => {
+        header('Python');
+        await (0, pypi_1.uploadPythonPackages)(glob.sync(path.join(directory, 'python', '*')), login);
+    });
+    await doRepo.java(async () => {
+        header('Java');
+        await (0, maven_1.uploadJavaPackages)(glob.sync(path.join(directory, 'java', '**', '*.pom')), login, usageDir);
+    });
+    await doRepo.dotnet(async () => {
+        header('.NET');
+        await (0, nuget_1.uploadDotnetPackages)(glob.sync(path.join(directory, 'dotnet', '**', '*.nupkg')), usageDir);
+    });
+    if (args.regression) {
+        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    .option('regression', {\n      description: 'Enable access to previous versions of the staged packages (this is expensive for CodeArtifact so we only do it when necessary)',\n      type: 'boolean',\n      requiresArg: false,\n      default: 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    .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  regression?: 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  if (args.regression) {\n    console.log('🛍 Configuring packages for upstream versions');\n    await repo.markAllUpstreamAllow();\n  }\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"]}