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

package/lib/package-sources/release-source.ts

@@ -1,82 +0,0 @@
-import * as os from 'os';
-import * as path from 'path';
-import * as fs from 'fs-extra';
-import { IPackageSourceSetup, IPackageSource } from './source';
-import { copyDirectoryContents } from '../files';
-import { shell, rimraf, addToShellPath } from '../shell';
-
-export class ReleasePackageSourceSetup implements IPackageSourceSetup {
-  readonly name = 'release';
-  readonly description: string;
-
-  private tempDir?: string;
-
-  constructor(private readonly version: string, private readonly frameworkVersion?: string) {
-    this.description = `release @ ${this.version}`;
-  }
-
-  public async prepare(): Promise<void> {
-    this.tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tmpcdk'));
-    fs.mkdirSync(this.tempDir, { recursive: true });
-
-    await shell(['node', require.resolve('npm'), 'install', `aws-cdk@${this.version}`], {
-      cwd: this.tempDir,
-    });
-
-    process.env.CDK_CLI_PATH = this.tempDir;
-    process.env.VERSION = this.version;
-    process.env.FRAMEWORK_VERSION = this.frameworkVersion ?? this.version;
-  }
-
-  public async cleanup(): Promise<void> {
-    if (this.tempDir) {
-      rimraf(this.tempDir);
-    }
-  }
-}
-
-export class ReleasePackageSource implements IPackageSource {
-  private readonly cliPath: string;
-  private readonly version: string;
-
-  constructor() {
-    this.cliPath = process.env.CDK_CLI_PATH!;
-    this.version = process.env.VERSION!;
-  }
-
-  public async makeCliAvailable() {
-    addToShellPath(path.join(this.cliPath, 'node_modules', '.bin'));
-  }
-
-  public assertJsiiPackagesAvailable() {
-  }
-
-  public async initializeDotnetPackages(currentDir: string) {
-    if (process.env.CWD_FILES_DIR) {
-      await copyDirectoryContents(process.env.CWD_FILES_DIR, currentDir);
-    }
-  }
-
-  public majorVersion() {
-    return this.version.split('.')[0] as string;
-  }
-
-  public requestedCliVersion() {
-    return this.version;
-  }
-
-  public requestedFrameworkVersion() {
-    return process.env.FRAMEWORK_VERSION!;
-  }
-
-  public requestedAlphaVersion(): string {
-    const frameworkVersion = this.requestedFrameworkVersion();
-    if (frameworkVersion.includes('-rc.')) {
-      // For a pipeline release
-      return frameworkVersion.replace(/-rc\.\d+$/, '-alpha.999');
-    } else {
-      // For a stable release
-      return `${frameworkVersion}-alpha.0`;
-    }
-  }
-}

package/lib/package-sources/repo-source.ts

@@ -1,112 +0,0 @@
-import * as os from 'os';
-import * as path from 'path';
-import * as fs from 'fs-extra';
-import { IPackageSourceSetup, IPackageSource } from './source';
-import { findUp } from '../files';
-import { shell, addToShellPath } from '../shell';
-
-export class RepoPackageSourceSetup implements IPackageSourceSetup {
-  readonly name = 'repo';
-  readonly description: string;
-
-  constructor(private readonly repoRoot: string) {
-    this.description = `repo(${this.repoRoot})`;
-  }
-
-  public async prepare(): Promise<void> {
-    if (!await fs.pathExists(path.join(this.repoRoot, 'package.json')) || !await fs.pathExists(path.join(this.repoRoot, 'yarn.lock'))) {
-      throw new Error(`${this.repoRoot}: does not look like the repository root`);
-    }
-
-    process.env.REPO_ROOT = this.repoRoot;
-    process.env.REPO_PACKAGE_MAP = await writePackageMap(this.repoRoot);
-    addToShellPath(path.resolve(__dirname, 'repo-tools'));
-  }
-
-  public async cleanup(): Promise<void> {
-  }
-}
-
-export class RepoPackageSource implements IPackageSource {
-  private readonly repoRoot: string;
-
-  constructor() {
-    this.repoRoot = process.env.REPO_ROOT as string;
-  }
-
-  public async makeCliAvailable() {
-    addToShellPath(path.join(this.repoRoot, 'packages', 'aws-cdk', 'bin'));
-  }
-
-  public assertJsiiPackagesAvailable() {
-    throw new Error('jsii client packages are not available when using REPO source');
-  }
-
-  public async initializeDotnetPackages() {
-  }
-
-  public majorVersion() {
-    const releaseJson = fs.readJsonSync(path.resolve(this.repoRoot, 'release.json'));
-    return releaseJson.majorVersion;
-  }
-
-  public requestedCliVersion(): string {
-    return '*';
-  }
-
-  public requestedFrameworkVersion(): string {
-    return '*';
-  }
-
-  public requestedAlphaVersion(): string {
-    return '*';
-  }
-}
-
-async function writePackageMap(repoRoot: string): Promise<string> {
-  const packages = await findYarnPackages(repoRoot);
-  const fileName = path.join(os.tmpdir(), 'package-map.json');
-  await fs.writeJson(fileName, packages);
-  return fileName;
-}
-
-/**
- * Cache monorepo discovery results, we only want to do this once per run
- */
-const YARN_MONOREPO_CACHE: Record<string, any> = {};
-
-/**
- * Return a { name -> directory } packages found in a Yarn monorepo
- *
- * Cached in YARN_MONOREPO_CACHE.
- */
-export async function findYarnPackages(root: string): Promise<Record<string, string>> {
-  if (!(root in YARN_MONOREPO_CACHE)) {
-    const outputDataString: string = JSON.parse(await shell(['yarn', 'workspaces', '--json', 'info'], {
-      captureStderr: false,
-      cwd: root,
-      show: 'error',
-    })).data;
-    const output: YarnWorkspacesOutput = JSON.parse(outputDataString);
-
-    const ret: Record<string, string> = {};
-    for (const [k, v] of Object.entries(output)) {
-      ret[k] = path.join(root, v.location);
-    }
-    YARN_MONOREPO_CACHE[root] = ret;
-  }
-  return YARN_MONOREPO_CACHE[root];
-}
-
-/**
- * Find the root directory of the repo from the current directory
- */
-export async function autoFindRoot() {
-  const found = findUp('release.json');
-  if (!found) {
-    throw new Error(`Could not determine repository root: 'release.json' not found from ${process.cwd()}`);
-  }
-  return path.dirname(found);
-}
-
-type YarnWorkspacesOutput = Record<string, { location: string }>;

package/lib/package-sources/repo-tools/npm.ts

@@ -1,48 +0,0 @@
-import * as child_process from 'child_process';
-import * as fs from 'fs-extra';
-
-let argv = process.argv.slice(2);
-
-// eslint-disable-next-line no-console
-console.log('fake npm');
-
-if (argv[0] === 'install') {
-  if (!process.env.REPO_PACKAGE_MAP) {
-    throw new Error('REPO_PACKAGE_MAP not set');
-  }
-  const repoPackageMap = fs.readJsonSync(process.env.REPO_PACKAGE_MAP, { encoding: 'utf-8' });
-
-  // Replace paths in the 'package.json' in the current directory
-  if (fs.pathExistsSync('package.json')) {
-    const packageJson = fs.readJsonSync('package.json', { encoding: 'utf-8' });
-    for (const deps of [packageJson.dependencies ?? {}, packageJson.devDependencies ?? {}]) {
-      for (const [name, version] of Object.entries(deps)) {
-        deps[name] = repoPackageMap[name] ?? version;
-      }
-    }
-    fs.writeJsonSync('package.json', packageJson, { encoding: 'utf-8' });
-  }
-
-  // Replace package names on the command line
-  argv = argv.map(x => repoPackageMap[x] ?? x);
-}
-
-////////////////////////////////////////////////////////////////////////
-//  Shell out to original npm
-
-const child = child_process.spawn('node', [require.resolve('npm'), ...argv], {
-  shell: false,
-  stdio: ['ignore', 'inherit', 'inherit'],
-});
-
-child.once('error', e => {
-  // eslint-disable-next-line no-console
-  console.error(e);
-  process.exitCode = 1;
-});
-
-child.once('close', code => {
-  if (code) {
-    process.exitCode = code;
-  }
-});

package/lib/package-sources/source.ts

@@ -1,35 +0,0 @@
-export interface IPackageSourceSetup {
-  readonly name: string;
-  readonly description: string;
-
-  prepare(): Promise<void>;
-  cleanup(): Promise<void>;
-}
-
-export interface IPackageSource {
-  makeCliAvailable(): Promise<void>;
-
-  assertJsiiPackagesAvailable(): void;
-  majorVersion(): string;
-
-  initializeDotnetPackages(targetDir: string): Promise<void>;
-
-  /**
-   * CLI version
-   */
-  requestedCliVersion(): string;
-
-  /**
-   * Framework version if it's different than the CLI version
-   *
-   * Not all tests will respect this.
-   */
-  requestedFrameworkVersion(): string;
-
-  /**
-   * Versions of alpha packages if different than the CLI version
-   *
-   * Not all tests will respect this.
-   */
-  requestedAlphaVersion(): string;
-}

package/lib/package-sources/subprocess.ts

@@ -1,15 +0,0 @@
-import { ReleasePackageSource } from './release-source';
-import { RepoPackageSource } from './repo-source';
-import { IPackageSourceSetup, IPackageSource } from './source';
-
-export function serializeForSubprocess(s: IPackageSourceSetup) {
-  process.env.PACKAGE_SOURCE = s.name;
-}
-
-export function packageSourceInSubprocess(): IPackageSource {
-  switch (process.env.PACKAGE_SOURCE) {
-    case 'repo': return new RepoPackageSource();
-    case 'release': return new ReleasePackageSource();
-    default: throw new Error(`Unrecognized package source: ${process.env.PACKAGE_SOURCE}`);
-  }
-}

package/lib/process.ts

@@ -1,154 +0,0 @@
-import * as child from 'child_process';
-import { Readable, Writable } from 'stream';
-import * as pty from 'node-pty';
-
-/**
- * IProcess provides an interface to work with a subprocess.
- */
-export interface IProcess {
-
-  /**
-   * Register a callback to be invoked when a chunk is written to stdout.
-   */
-  onStdout(callback: (chunk: Buffer) => void): void;
-
-  /**
-   * Register a callback to be invoked when a chunk is written to stderr.
-   */
-  onStderr(callback: (chunk: Buffer) => void): void;
-
-  /**
-   * Register a callback to be invoked when the process exists.
-   */
-  onExit(callback: (exitCode: number) => void): void;
-
-  /**
-   * Register a callback to be invoked if the process failed to start.
-   */
-  onError(callback: (error: Error) => void): void;
-
-  /**
-   * Write the process stdin stream.
-   */
-  writeStdin(data: string): void;
-
-  /**
-   * Singal that no more data will be written to stdin. In non tty process you must
-   * call this method to make sure the process exits.
-   *
-   * @param delay - optional delay in milliseconds before the signal is sent.
-   *
-   */
-  endStdin(delay?: number): void;
-
-};
-
-export class Process {
-
-  /**
-   * Spawn a process with a TTY attached.
-   */
-  public static spawnTTY(command: string, args: string[], options: pty.IPtyForkOptions | pty.IWindowsPtyForkOptions = {}): IProcess {
-
-    const process = pty.spawn(command, args, {
-      name: 'xterm-color',
-      ...options,
-    })
-    return new PtyProcess(process);
-
-  }
-
-  /**
-   * Spawn a process without a forcing a TTY.
-   */
-  public static spawn(command: string, args: string[], options: child.SpawnOptions = {}): IProcess {
-
-    const process = child.spawn(command, args, {
-      shell: true,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      ...options,
-    });
-    return new NonPtyProcess(process);
-
-  }
-
-}
-
-class PtyProcess implements IProcess {
-
-  public constructor(private readonly process: pty.IPty) {}
-
-  public endStdin(_?: number): void {
-    // not needed because all streams are the same in tty.
-  }
-
-  public onError(_: (error: Error) => void): void {
-    // not needed because the pty.spawn will simply fail in this case.
-  }
-
-  public onStdout(callback: (chunk: Buffer) => void): void {
-    this.process.onData((e) => callback(Buffer.from(e)));
-  }
-
-  public onStderr(_callback: (chunk: Buffer) => void): void {
-    // https://github.com/microsoft/node-pty/issues/71
-    throw new Error(`Cannot register callback for 'stderr'. A tty does not have separate output and error channels`);
-  }
-
-  public onExit(callback: (exitCode: number) => void): void {
-    this.process.onExit((e) => { callback(e.exitCode) });
-  }
-
-
-  public writeStdin(data: string): void {
-    // in a pty all streams are the same
-    this.process.write(data)
-  }
-
-};
-
-class NonPtyProcess implements IProcess {
-
-  public constructor(private readonly process: child.ChildProcess) {}
-
-  public onError(callback: (error: Error) => void): void {
-    this.process.once('error', callback);
-  }
-
-  public onStdout(callback: (chunk: Buffer) => void): void {
-    this.assertDefined('stdout', this.process.stdout);
-    this.process.stdout.on('data', callback);
-  }
-
-  public onStderr(callback: (chunk: Buffer) => void): void {
-    this.assertDefined('stderr', this.process.stderr);
-    this.process.stderr.on('data', callback);
-  }
-
-  public onExit(callback: (exitCode: number) => void): void {
-    this.process.on('close', callback);
-  }
-
-  public writeStdin(content: string): void {
-    this.assertDefined('stdin', this.process.stdin);
-    this.process.stdin.write(content);
-  }
-
-  public endStdin(delay?: number): void {
-    if (this.process.stdin == null) {
-      throw new Error('No stdin defined for process');
-    }
-    if (delay) {
-      setTimeout(() => this.process.stdin!.end(), delay);
-    } else {
-      this.process.stdin!.end();
-    }
-  }
-
-  public assertDefined(name: 'stdin' | 'stdout' | 'stderr', stream?: Readable | Writable | undefined | null): asserts stream {
-    if (stream == null) {
-      throw new Error(`No ${name} defined for child process`);
-    }
-  }
-
-};

package/lib/proxy.ts

@@ -1,64 +0,0 @@
-import { promises as fs } from 'fs';
-import * as querystring from 'node:querystring';
-import * as os from 'os';
-import * as path from 'path';
-import * as mockttp from 'mockttp';
-import { CompletedRequest } from 'mockttp';
-
-export async function startProxyServer(certDirRoot?: string): Promise<ProxyServer> {
-  const certDir = await fs.mkdtemp(path.join(certDirRoot ?? os.tmpdir(), 'cdk-'));
-  const certPath = path.join(certDir, 'cert.pem');
-  const keyPath = path.join(certDir, 'key.pem');
-
-  // Set up key and certificate
-  const { key, cert } = await mockttp.generateCACertificate();
-  await fs.writeFile(keyPath, key);
-  await fs.writeFile(certPath, cert);
-
-  const server = mockttp.getLocal({
-    https: { keyPath: keyPath, certPath: certPath },
-  });
-
-  // We don't need to modify any request, so the proxy
-  // passes through all requests to the target host.
-  const endpoint = await server
-    .forAnyRequest()
-    .thenPassThrough();
-
-  const port = 9000 + Math.floor(Math.random() * 10000);
-
-  // server.enableDebug();
-  await server.start(port);
-
-  return {
-    certPath,
-    keyPath,
-    server,
-    url: server.url,
-    port: server.port,
-    getSeenRequests: () => endpoint.getSeenRequests(),
-    async stop() {
-      await server.stop();
-      await fs.rm(certDir, { recursive: true, force: true });
-    },
-  };
-}
-
-export interface ProxyServer {
-  readonly certPath: string;
-  readonly keyPath: string;
-  readonly server: mockttp.Mockttp;
-  readonly url: string;
-  readonly port: number;
-
-  getSeenRequests(): Promise<CompletedRequest[]>;
-  stop(): Promise<void>;
-}
-
-export function awsActionsFromRequests(requests: CompletedRequest[]): string[] {
-  return [...new Set(requests
-    .map(req => req.body.buffer.toString('utf-8'))
-    .map(body => querystring.decode(body))
-    .map(x => x.Action as string)
-    .filter(action => action != null))];
-}

package/lib/resource-pool.ts

@@ -1,140 +0,0 @@
-import { ILock, XpMutex, XpMutexPool } from './xpmutex';
-
-/**
- * A class that holds a pool of resources and gives them out and returns them on-demand
- *
- * The resources will be given out front to back, when they are returned
- * the most recently returned version will be given out again (for best
- * cache coherency).
- *
- * If there are multiple consumers waiting for a resource, consumers are serviced
- * in FIFO order for most fairness.
- */
-export class ResourcePool<A extends string=string> {
-  public static withResources<A extends string>(name: string, resources: A[]) {
-    const pool = XpMutexPool.fromName(name);
-    return new ResourcePool(pool, resources);
-  }
-
-  private readonly resources: ReadonlyArray<A>;
-  private readonly mutexes: Record<string, XpMutex> = {};
-  private readonly locks: Record<string, ILock | undefined> = {};
-
-  private constructor(private readonly pool: XpMutexPool, resources: A[]) {
-    if (resources.length === 0) {
-      throw new Error('Must have at least one resource in the pool');
-    }
-
-    // Shuffle to reduce contention
-    resources = [...resources];
-    fisherYatesShuffle(resources);
-    this.resources = resources;
-
-    for (const res of resources) {
-      this.mutexes[res] = this.pool.mutex(res);
-    }
-  }
-
-  /**
-   * Take one value from the resource pool
-   *
-   * If no such value is currently available, wait until it is.
-   */
-  public async take(): Promise<ILease<A>> {
-    while (true) {
-      // Start a wait on the unlock now -- if the unlock signal comes after
-      // we try to acquire but before we start the wait, we might miss it.
-      //
-      // (The timeout is in case the unlock signal doesn't come for whatever reason).
-      const wait = this.pool.awaitUnlock(10_000);
-
-      // Try all mutexes, we might need to reacquire an expired lock
-      for (const res of this.resources) {
-        const lease = await this.tryObtainLease(res);
-        if (lease) {
-          // Ignore the wait (count as handled)
-          wait.then(() => {}, () => {});
-          return lease;
-        }
-      }
-
-      // None available, wait until one gets unlocked then try again
-      await wait;
-    }
-  }
-
-  /**
-   * Execute a block using a single resource from the pool
-   */
-  public async using<B>(block: (x: A) => B | Promise<B>): Promise<B> {
-    const lease = await this.take();
-    try {
-      return await block(lease.value);
-    } finally {
-      await lease.dispose();
-    }
-  }
-
-  private async tryObtainLease(value: A) {
-    const lock = await this.mutexes[value].tryAcquire();
-    if (!lock) {
-      return undefined;
-    }
-
-    this.locks[value] = lock;
-    return this.makeLease(value);
-  }
-
-  private makeLease(value: A): ILease<A> {
-    let disposed = false;
-    return {
-      value,
-      dispose: async () => {
-        if (disposed) {
-          throw new Error('Calling dispose() on an already-disposed lease.');
-        }
-        disposed = true;
-        return this.returnValue(value);
-      },
-    };
-  }
-
-  /**
-   * When a value is returned:
-   *
-   * - If someone's waiting for it, give it to them
-   * - Otherwise put it back into the pool
-   */
-  private async returnValue(value: string) {
-    const lock = this.locks[value];
-    delete this.locks[value];
-    await lock?.release();
-  }
-}
-
-/**
- * A single value taken from the pool
- */
-export interface ILease<A> {
-  /**
-   * The value obtained by the lease
-   */
-  readonly value: A;
-
-  /**
-   * Return the leased value to the pool
-   */
-  dispose(): Promise<void>;
-}
-
-/**
- * Shuffle an array in-place
- */
-function fisherYatesShuffle<A>(xs: A[]) {
-  for (let i = xs.length - 1; i >= 1; i--) {
-    const j = Math.floor(Math.random() * i);
-    const h = xs[j];
-    xs[j] = xs[i];
-    xs[i] = h;
-  }
-}

package/lib/resources.ts

@@ -1,4 +0,0 @@
-import * as path from 'path';
-
-export const RESOURCES_DIR = path.resolve(__dirname, '..', 'resources');
-