@aws-cdk-testing/cli-integ 3.5.0 → 3.6.0

package/lib/cli/stage-distribution.ts

@@ -1,262 +0,0 @@
-/* eslint-disable no-console */
-import * as path from 'path';
-import * as fs from 'fs-extra';
-import * as glob from 'glob';
-import * as yargs from 'yargs';
-import { shell } from '..';
-import { TestRepository } from '../staging/codeartifact';
-import { uploadJavaPackages, mavenLogin } from '../staging/maven';
-import { uploadNpmPackages, npmLogin } from '../staging/npm';
-import { uploadDotnetPackages, nugetLogin } from '../staging/nuget';
-import { uploadPythonPackages, pypiLogin } from '../staging/pypi';
-import { UsageDir } from '../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 ? TestRepository.newWithName(args.name) : TestRepository.newRandom());
-      const usageDir = 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 = TestRepository.existing(args.name);
-      const usageDir = 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 TestRepository.newRandom();
-      const usageDir = UsageDir.default();
-
-      await doLogin(repo, usageDir, args);
-      await publish(repo, usageDir, args);
-
-      try {
-        await usageDir.activateInCurrentProcess();
-
-        await 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 = 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 = TestRepository.existing(repositoryName);
-      await repo.delete();
-    })
-    .command('gc', 'Clean up day-old testing repositories', cmd => cmd, async () => {
-      await TestRepository.gc();
-    })
-    .demandCommand(1, 'You must supply a command')
-    .help()
-    .showHelpOnFail(false)
-    .parse();
-}
-
-async function validateDirectory(args: {
-  DIRECTORY: string;
-}) {
-  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: TestRepository, usageDir: UsageDir, args: {
-  npm?: boolean;
-  python?: boolean;
-  java?: boolean;
-  dotnet?: boolean;
-}) {
-  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(() => npmLogin(login, usageDir));
-  await doRepo.python(() => pypiLogin(login, usageDir));
-  await doRepo.java(() => mavenLogin(login, usageDir));
-  await doRepo.dotnet(() => nugetLogin(login, usageDir));
-}
-
-async function publish(repo: TestRepository, usageDir: UsageDir, args: {
-  DIRECTORY: string;
-  npm?: boolean;
-  python?: boolean;
-  java?: boolean;
-  dotnet?: boolean;
-  regression?: boolean;
-}) {
-  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 uploadNpmPackages(glob.sync(path.join(directory, 'js', '*.tgz')), login, usageDir);
-  });
-
-  await doRepo.python(async () => {
-    header('Python');
-    await uploadPythonPackages(glob.sync(path.join(directory, 'python', '*')), login);
-  });
-
-  await doRepo.java(async () => {
-    header('Java');
-    await uploadJavaPackages(glob.sync(path.join(directory, 'java', '**', '*.pom')), login, usageDir);
-  });
-
-  await doRepo.dotnet(async () => {
-    header('.NET');
-    await 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: {
-  npm?: boolean;
-  python?: boolean;
-  java?: boolean;
-  dotnet?: boolean;
-}) {
-  const all = args.npm === undefined && args.python === undefined && args.java === undefined && args.dotnet === undefined;
-
-  const invoke = (block: () => Promise<void>) => 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: string) {
-  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;
-});

package/lib/cli/test-root.ts

@@ -1,3 +0,0 @@
-import * as path from 'path';
-// eslint-disable-next-line no-console
-console.log(path.resolve(__dirname, '..', '..'));

package/lib/corking.ts

@@ -1,33 +0,0 @@
-/**
- * Routines for corking stdout and stderr
- */
-import * as stream from 'stream';
-
-export class MemoryStream extends stream.Writable {
-  private parts = new Array<Buffer>();
-
-  public _write(chunk: Buffer, _encoding: string, callback: (error?: Error | null) => void): void {
-    this.parts.push(chunk);
-    callback();
-  }
-
-  public buffer() {
-    return Buffer.concat(this.parts);
-  }
-
-  public clear() {
-    this.parts.splice(0, this.parts.length);
-  }
-
-  public async flushTo(strm: NodeJS.WritableStream): Promise<void> {
-    const flushed = strm.write(this.buffer());
-    if (!flushed) {
-      return new Promise(ok => strm.once('drain', ok));
-    }
-    return;
-  }
-
-  public toString() {
-    return this.buffer().toString();
-  }
-}

package/lib/eventually.ts

@@ -1,42 +0,0 @@
-/**
- * @param maxAttempts the maximum number of attempts
- * @param interval interval in milliseconds to observe between attempts
- */
-export type EventuallyOptions = {
-  maxAttempts?: number;
-  interval?: number;
-};
-
-const wait = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
-const DEFAULT_INTERVAL = 1000;
-const DEFAULT_MAX_ATTEMPTS = 10;
-
-/**
- * Runs a function on an interval until the maximum number of attempts has
- * been reached.
- *
- * Default interval = 1000 milliseconds
- * Default maxAttempts = 10
- *
- * @param fn function to run
- * @param options EventuallyOptions
- */
-const eventually = async <T>(call: () => Promise<T>, options?: EventuallyOptions): Promise<T> => {
-  const opts = {
-    interval: options?.interval ? options.interval : DEFAULT_INTERVAL,
-    maxAttempts: options?.maxAttempts ? options.maxAttempts : DEFAULT_MAX_ATTEMPTS,
-  };
-
-  while (opts.maxAttempts-- >= 0) {
-    try {
-      return await call();
-    } catch (err) {
-      if (opts.maxAttempts <= 0) throw err;
-    }
-    await wait(opts.interval);
-  }
-
-  throw new Error('An unexpected error has occurred.');
-};
-
-export default eventually;

package/lib/files.ts

@@ -1,80 +0,0 @@
-import * as os from 'os';
-import * as path from 'path';
-import * as fs from 'fs-extra';
-
-export async function rmFile(filename: string) {
-  if (await fs.pathExists(filename)) {
-    await fs.unlink(filename);
-  }
-}
-
-export async function addToFile(filename: string, line: string) {
-  let contents = await fs.pathExists(filename) ? await fs.readFile(filename, { encoding: 'utf-8' }) : '';
-  if (!contents.endsWith('\n')) {
-    contents += '\n';
-  }
-  contents += line + '\n';
-
-  await writeFile(filename, contents);
-}
-
-export async function writeFile(filename: string, contents: string) {
-  await fs.mkdirp(path.dirname(filename));
-  await fs.writeFile(filename, contents, { encoding: 'utf-8' });
-}
-
-export async function copyDirectoryContents(dir: string, target: string) {
-  for (const file of await fs.readdir(path.join(dir), { encoding: 'utf-8' })) {
-    await fs.copyFile(path.join(dir, file), path.join(target, file));
-  }
-}
-
-export function findUp(name: string, directory: string = process.cwd()): string | undefined {
-  const absoluteDirectory = path.resolve(directory);
-
-  const file = path.join(directory, name);
-  if (fs.existsSync(file)) {
-    return file;
-  }
-
-  const { root } = path.parse(absoluteDirectory);
-  if (absoluteDirectory == root) {
-    return undefined;
-  }
-
-  return findUp(name, path.dirname(absoluteDirectory));
-}
-
-/**
- * Docker-safe home directory
- */
-export function homeDir() {
-  return os.userInfo().homedir ?? os.homedir();
-}
-
-export async function loadLines(filename: string): Promise<string[]> {
-  return await fs.pathExists(filename) ? (await fs.readFile(filename, { encoding: 'utf-8' })).trim().split('\n') : [];
-}
-
-export async function writeLines(filename: string, lines: string[]) {
-  // Must end in a newline or our bash script won't read it properly
-  await fs.writeFile(filename, lines.join('\n') + '\n', { encoding: 'utf-8' });
-}
-
-/**
- * Update a spaceless ini file in place
- */
-export function updateIniKey(lines: string[], key: string, value: string) {
-  const prefix = `${key}=`;
-  let found = false;
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].startsWith(prefix)) {
-      lines[i] = prefix + value;
-      found = true;
-      break;
-    }
-  }
-  if (!found) {
-    lines.push(prefix + value);
-  }
-}

package/lib/github.ts

@@ -1,43 +0,0 @@
-import { Octokit } from '@octokit/rest';
-import * as semver from 'semver';
-
-export async function fetchPreviousVersion(token: string, options?: {
-  priorTo?: string;
-  majorVersion?: string;
-}) {
-  const github = new Octokit({ auth: token });
-  const releases = await github.repos.listReleases({
-    owner: 'aws',
-    repo: 'aws-cdk',
-  });
-
-  // this returns a list in descending order, newest releases first
-  // opts for same major version where possible, falling back otherwise
-  // to previous major versions.
-  let previousMVRelease = undefined;
-  for (const release of releases.data) {
-    const version = release.name?.replace('v', '');
-    if (!version) { continue; }
-
-    // Any old version is fine
-    if (!options?.majorVersion && !options?.priorTo) {
-      return version;
-    }
-
-    if (options?.majorVersion && `${semver.major(version)}` === options.majorVersion) {
-      return version;
-    }
-
-    if (options?.priorTo && semver.lt(version, options?.priorTo) && semver.major(version) === semver.major(options.priorTo)) {
-      return version;
-    }
-
-    // Otherwise return the most recent version that didn't match any
-    if (!previousMVRelease) {
-      previousMVRelease = version;
-    }
-  }
-  if (previousMVRelease) { return previousMVRelease; }
-
-  throw new Error(`Unable to find previous version given ${JSON.stringify(options)}`);
-}

package/lib/index.ts

@@ -1,13 +0,0 @@
-export * from './aws';
-export * from './corking';
-export * from './integ-test';
-export * from './memoize';
-export * from './resource-pool';
-export * from './with-cli-lib';
-export * from './with-sam';
-export * from './shell';
-export * from './with-aws';
-export * from './with-cdk-app';
-export * from './with-packages';
-export * from './with-temporary-directory';
-export * from './resources';

package/lib/integ-test.ts

@@ -1,110 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { MemoryStream } from './corking';
-
-const SKIP_TESTS = fs.readFileSync(path.join(__dirname, '..', 'skip-tests.txt'), { encoding: 'utf-8' })
-  .split('\n')
-  .map(x => x.trim())
-  .filter(x => x && !x.startsWith('#'));
-
-if (SKIP_TESTS.length > 0) {
-  process.stderr.write(`ℹ️ Skipping tests: ${JSON.stringify(SKIP_TESTS)}\n`);
-}
-
-// Whether we want to stop after the first failure, for quicker debugging (hopefully).
-const FAIL_FAST = process.env.FAIL_FAST === 'true';
-
-// Keep track of whether the suite has failed. If so, we stop running.
-let failed = false;
-
-export interface TestContext {
-  readonly randomString: string;
-  readonly name: string;
-  readonly output: NodeJS.WritableStream;
-  log(s: string): void;
-}
-
-/**
- * A wrapper for jest's 'test' which takes regression-disabled tests into account and prints a banner
- */
-export function integTest(
-  name: string,
-  callback: (context: TestContext) => Promise<void>,
-  timeoutMillis?: number,
-): void {
-  const runner = shouldSkip(name) ? test.skip : test;
-
-  runner(name, async () => {
-    const output = new MemoryStream();
-
-    output.write('================================================================\n');
-    output.write(`${name}\n`);
-    output.write('================================================================\n');
-
-    const now = Date.now();
-    process.stderr.write(`[INTEG TEST::${name}] Starting (pid ${process.pid})...\n`);
-    try {
-      if (FAIL_FAST && failed) {
-        throw new Error('FAIL_FAST requested and currently failing. Stopping test early.');
-      }
-
-      return await callback({
-        output,
-        randomString: randomString(),
-        name,
-        log(s: string) {
-          output.write(`${s}\n`);
-        },
-      });
-    } catch (e: any) {
-      failed = true;
-
-      // Print the buffered output, only if the test fails.
-      output.write(e.message);
-      output.write(e.stack);
-      process.stderr.write(`[INTEG TEST::${name}] Failed: ${e}\n`);
-
-      const isGitHub = !!process.env.GITHUB_RUN_ID;
-
-      if (isGitHub) {
-        // GitHub Actions compatible output formatting
-        // https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/workflow-commands-for-github-actions#setting-an-error-message
-        let written = process.stderr.write(`::error title=Failed ${name}::${e.message}\n`);
-        if (!written) {
-          // Wait for drain
-          await new Promise((ok) => process.stderr.once('drain', ok));
-        }
-
-        // Print output only if the test fails. Use 'console.log' so the output is buffered by
-        // jest and prints without a stack trace (if verbose: false).
-        written = process.stdout.write([
-          `::group::Failure details: ${name} (click to expand)\n`,
-          `${output.buffer().toString()}\n`,
-          '::endgroup::\n',
-        ].join(''));
-        if (!written) {
-          // Wait for drain
-          await new Promise((ok) => process.stdout.once('drain', ok));
-        }
-      } else {
-        // Use 'console.log' so the output is buffered by
-        // jest and prints without a stack trace (if verbose: false).
-        // eslint-disable-next-line no-console
-        console.log(output.buffer().toString());
-      }
-      throw e;
-    } finally {
-      const duration = Date.now() - now;
-      process.stderr.write(`[INTEG TEST::${name}] Done (${duration} ms).\n`);
-    }
-  }, timeoutMillis);
-}
-
-function shouldSkip(testName: string) {
-  return SKIP_TESTS.includes(testName);
-}
-
-export function randomString() {
-  // Crazy
-  return Math.random().toString(36).replace(/[^a-z0-9]+/g, '');
-}

package/lib/lists.ts

@@ -1,9 +0,0 @@
-export function chunk<A>(n: number, xs: A[]): A[][] {
-  const ret = new Array<A[]>();
-
-  for (let i = 0; i < xs.length; i += n) {
-    ret.push(xs.slice(i, i + n));
-  }
-
-  return ret;
-}

package/lib/memoize.ts

@@ -1,14 +0,0 @@
-/**
- * Return a memoized version of an function with 0 arguments.
- *
- * Async-safe.
- */
-export function memoize0<A>(fn: () => Promise<A>): () => Promise<A> {
-  let promise: Promise<A> | undefined;
-  return () => {
-    if (!promise) {
-      promise = fn();
-    }
-    return promise;
-  };
-}

package/lib/npm.ts

@@ -1,41 +0,0 @@
-import { spawnSync } from 'child_process';
-
-const MINIMUM_VERSION = '3.9';
-
-/**
- * Use NPM preinstalled on the machine to look up a list of TypeScript versions
- */
-export function typescriptVersionsSync(): string[] {
-  const { stdout } = spawnSync('npm', ['--silent', 'view', `typescript@>=${MINIMUM_VERSION}`, 'version', '--json'], { encoding: 'utf-8' });
-
-  const versions: string[] = JSON.parse(stdout);
-  return Array.from(new Set(versions.map(v => v.split('.').slice(0, 2).join('.'))));
-}
-
-/**
- * Use NPM preinstalled on the machine to query publish times of versions
- */
-export function typescriptVersionsYoungerThanDaysSync(days: number, versions: string[]): string[] {
-  const { stdout } = spawnSync('npm', ['--silent', 'view', 'typescript', 'time', '--json'], { encoding: 'utf-8' });
-  const versionTsMap: Record<string, string> = JSON.parse(stdout);
-
-  const cutoffDate = new Date(Date.now() - (days * 24 * 3600 * 1000));
-  const cutoffDateS = cutoffDate.toISOString();
-
-  const recentVersions = Object.entries(versionTsMap)
-    .filter(([_, dateS]) => dateS > cutoffDateS)
-    .map(([v]) => v);
-
-  // Input versions are of the form 3.9, 5.2, etc.
-  // Actual versions are of the form `3.9.15`, `5.3.0-dev.20511311`.
-  // Return only 2-digit versions for which there is a non-prerelease version in the set of recentVersions
-  // So a 2-digit versions that is followed by `.<digits>` until the end of the string.
-  return versions.filter((twoV) => {
-    const re = new RegExp(`^${reQuote(twoV)}\\.\\d+$`);
-    return recentVersions.some(fullV => fullV.match(re));
-  });
-}
-
-function reQuote(str: string): string {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}