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

package/lib/aws.ts

@@ -1,303 +0,0 @@
-import {
-  CloudFormationClient,
-  DeleteStackCommand,
-  DescribeStacksCommand,
-  UpdateTerminationProtectionCommand,
-  type Stack,
-} from '@aws-sdk/client-cloudformation';
-import { DeleteRepositoryCommand, ECRClient } from '@aws-sdk/client-ecr';
-import { ECRPUBLICClient } from '@aws-sdk/client-ecr-public';
-import { ECSClient } from '@aws-sdk/client-ecs';
-import { IAMClient } from '@aws-sdk/client-iam';
-import { LambdaClient } from '@aws-sdk/client-lambda';
-import {
-  S3Client,
-  DeleteObjectsCommand,
-  ListObjectVersionsCommand,
-  type ObjectIdentifier,
-  DeleteBucketCommand,
-} from '@aws-sdk/client-s3';
-import { SNSClient } from '@aws-sdk/client-sns';
-import { SSOClient } from '@aws-sdk/client-sso';
-import { STSClient, GetCallerIdentityCommand } from '@aws-sdk/client-sts';
-import { fromIni, fromNodeProviderChain } from '@aws-sdk/credential-providers';
-import type { AwsCredentialIdentity, AwsCredentialIdentityProvider } from '@smithy/types';
-import { ConfiguredRetryStrategy } from '@smithy/util-retry';
-interface ClientConfig {
-  readonly credentials: AwsCredentialIdentityProvider | AwsCredentialIdentity;
-  readonly region: string;
-  readonly retryStrategy: ConfiguredRetryStrategy;
-}
-
-export class AwsClients {
-  public static async forIdentity(region: string, identity: AwsCredentialIdentity, output: NodeJS.WritableStream) {
-    return new AwsClients(region, output, identity);
-  }
-
-  public static async forRegion(region: string, output: NodeJS.WritableStream) {
-    return new AwsClients(region, output);
-  }
-
-  private readonly config: ClientConfig;
-
-  public readonly cloudFormation: CloudFormationClient;
-  public readonly s3: S3Client;
-  public readonly ecr: ECRClient;
-  public readonly ecrPublic: ECRPUBLICClient;
-  public readonly ecs: ECSClient;
-  public readonly sso: SSOClient;
-  public readonly sns: SNSClient;
-  public readonly iam: IAMClient;
-  public readonly lambda: LambdaClient;
-  public readonly sts: STSClient;
-
-  constructor(
-    public readonly region: string,
-    private readonly output: NodeJS.WritableStream,
-    public readonly identity?: AwsCredentialIdentity) {
-    this.config = {
-      credentials: this.identity ?? chainableCredentials(this.region),
-      region: this.region,
-      retryStrategy: new ConfiguredRetryStrategy(9, (attempt: number) => attempt ** 500),
-    };
-    this.cloudFormation = new CloudFormationClient(this.config);
-    this.s3 = new S3Client(this.config);
-    this.ecr = new ECRClient(this.config);
-    this.ecrPublic = new ECRPUBLICClient({ ...this.config, region: 'us-east-1' /* public gallery is only available in us-east-1 */ });
-    this.ecs = new ECSClient(this.config);
-    this.sso = new SSOClient(this.config);
-    this.sns = new SNSClient(this.config);
-    this.iam = new IAMClient(this.config);
-    this.lambda = new LambdaClient(this.config);
-    this.sts = new STSClient(this.config);
-  }
-
-  public async account(): Promise<string> {
-    // Reduce # of retries, we use this as a circuit breaker for detecting no-config
-    const stsClient = new STSClient({
-      credentials: this.config.credentials,
-      region: this.config.region,
-      maxAttempts: 2,
-    });
-
-    return (await stsClient.send(new GetCallerIdentityCommand({}))).Account!;
-  }
-
-  /**
-   * If the clients already has an established identity (via atmosphere for example),
-   * return an environment variable map activating it.
-   *
-   * Otherwise, returns undefined.
-   */
-  public identityEnv(): Record<string, string> | undefined {
-    return this.identity ? {
-      AWS_ACCESS_KEY_ID: this.identity.accessKeyId,
-      AWS_SECRET_ACCESS_KEY: this.identity.secretAccessKey,
-      AWS_SESSION_TOKEN: this.identity.sessionToken!,
-
-      // unset any previously used profile because the SDK will prefer
-      // this over static env credentials. this is relevant for tests running on CodeBuild
-      // because we use a profile as our main credentials source.
-      AWS_PROFILE: '',
-    } : undefined;
-  }
-
-  /**
-   * Resolve the current identity or identity provider to credentials
-   */
-  public async credentials() {
-    const x = this.config.credentials;
-    if (isAwsCredentialIdentity(x)) {
-      return x;
-    }
-    return x();
-  }
-
-  public async deleteStacks(...stackNames: string[]) {
-    if (stackNames.length === 0) {
-      return;
-    }
-
-    // We purposely do all stacks serially, because they've been ordered
-    // to do the bootstrap stack last.
-    for (const stackName of stackNames) {
-      await this.cloudFormation.send(
-        new UpdateTerminationProtectionCommand({
-          EnableTerminationProtection: false,
-          StackName: stackName,
-        }),
-      );
-      await this.cloudFormation.send(
-        new DeleteStackCommand({
-          StackName: stackName,
-        }),
-      );
-
-      await retry(this.output, `Deleting ${stackName}`, retry.forSeconds(600), async () => {
-        const status = await this.stackStatus(stackName);
-        if (status !== undefined && status.endsWith('_FAILED')) {
-          throw retry.abort(new Error(`'${stackName}' is in state '${status}'`));
-        }
-        if (status !== undefined) {
-          throw new Error(`Delete of '${stackName}' not complete yet, status: '${status}'`);
-        }
-      });
-    }
-  }
-
-  public async stackStatus(stackName: string): Promise<string | undefined> {
-    try {
-      return (
-        await this.cloudFormation.send(
-          new DescribeStacksCommand({
-            StackName: stackName,
-          }),
-        )
-      ).Stacks?.[0].StackStatus;
-    } catch (e: any) {
-      if (isStackMissingError(e)) {
-        return undefined;
-      }
-      throw e;
-    }
-  }
-
-  public async emptyBucket(bucketName: string, options?: { bypassGovernance?: boolean }) {
-    const objects = await this.s3.send(
-      new ListObjectVersionsCommand({
-        Bucket: bucketName,
-      }),
-    );
-
-    const deletes = [...(objects.Versions || []), ...(objects.DeleteMarkers || [])].reduce((acc, obj) => {
-      if (typeof obj.VersionId !== 'undefined' && typeof obj.Key !== 'undefined') {
-        acc.push({ Key: obj.Key, VersionId: obj.VersionId });
-      } else if (typeof obj.Key !== 'undefined') {
-        acc.push({ Key: obj.Key });
-      }
-      return acc;
-    }, [] as ObjectIdentifier[]);
-
-    if (deletes.length === 0) {
-      return Promise.resolve();
-    }
-
-    return this.s3.send(
-      new DeleteObjectsCommand({
-        Bucket: bucketName,
-        Delete: {
-          Objects: deletes,
-          Quiet: false,
-        },
-        BypassGovernanceRetention: options?.bypassGovernance ? true : undefined,
-      }),
-    );
-  }
-
-  public async deleteImageRepository(repositoryName: string) {
-    await this.ecr.send(
-      new DeleteRepositoryCommand({
-        repositoryName: repositoryName,
-        force: true,
-      }),
-    );
-  }
-
-  public async deleteBucket(bucketName: string) {
-    try {
-      await this.emptyBucket(bucketName);
-
-      await this.s3.send(
-        new DeleteBucketCommand({
-          Bucket: bucketName,
-        }),
-      );
-    } catch (e: any) {
-      if (isBucketMissingError(e)) {
-        return;
-      }
-      throw e;
-    }
-  }
-}
-
-export function isStackMissingError(e: Error) {
-  return e.message.indexOf('does not exist') > -1;
-}
-
-export function isBucketMissingError(e: Error) {
-  return e.message.indexOf('does not exist') > -1;
-}
-
-/**
- * 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 async function retry<A>(
-  output: NodeJS.WritableStream,
-  operation: string,
-  deadline: Date,
-  block: () => Promise<A>,
-): Promise<A> {
-  let i = 0;
-  output.write(`💈 ${operation}\n`);
-  while (true) {
-    try {
-      i++;
-      const ret = await block();
-      output.write(`💈 ${operation}: succeeded after ${i} attempts\n`);
-      return ret;
-    } catch (e: any) {
-      if (e.abort || Date.now() > deadline.getTime()) {
-        throw new Error(`${operation}: did not succeed after ${i} attempts: ${e}`);
-      }
-      output.write(`⏳ ${operation} (${e.message})\n`);
-      await sleep(5000);
-    }
-  }
-}
-
-/**
- * Make a deadline for the `retry` function relative to the current time.
- */
-retry.forSeconds = (seconds: number): Date => {
-  return new Date(Date.now() + seconds * 1000);
-};
-
-/**
- * Annotate an error to stop the retrying
- */
-retry.abort = (e: Error): Error => {
-  (e as any).abort = true;
-  return e;
-};
-
-export function outputFromStack(key: string, stack: Stack): string | undefined {
-  return (stack.Outputs ?? []).find((o) => o.OutputKey === key)?.OutputValue;
-}
-
-export async function sleep(ms: number) {
-  return new Promise((ok) => setTimeout(ok, ms));
-}
-
-function chainableCredentials(region: string): AwsCredentialIdentityProvider {
-  if ((process.env.CODEBUILD_BUILD_ARN || process.env.GITHUB_RUN_ID) && process.env.AWS_PROFILE) {
-    // in codebuild we must assume the role that the cdk uses
-    // otherwise credentials will just be picked up by the normal sdk
-    // heuristics and expire after an hour.
-    return fromIni({
-      clientConfig: { region },
-    });
-  }
-
-  // Otherwise just get what's default
-  return fromNodeProviderChain({ clientConfig: { region } });
-}
-
-function isAwsCredentialIdentity(x: any): x is AwsCredentialIdentity {
-  return Boolean(x && typeof x === 'object' && x.accessKeyId);
-}

package/lib/cli/query-github.ts

@@ -1,56 +0,0 @@
-import * as yargs from 'yargs';
-import { fetchPreviousVersion } from '../github';
-
-async function main() {
-  const args = await yargs
-    .option('token', {
-      descripton: 'GitHub token (default: from environment GITHUB_TOKEN)',
-      alias: 't',
-      type: 'string',
-      requiresArg: true,
-    })
-    .command('last-release', 'Query the last release', cmd => cmd
-      .option('prior-to', {
-        description: 'Return the most recent release before the given version',
-        alias: 'p',
-        type: 'string',
-        requiresArg: true,
-      })
-      .option('major', {
-        description: 'Return the most recent release that matches',
-        alias: 'm',
-        type: 'string',
-        requiresArg: true,
-      }))
-    .demandCommand()
-    .help()
-    .showHelpOnFail(false)
-    .argv;
-
-  const command = args._[0];
-
-  const token = args.token ?? process.env.GITHUB_TOKEN;
-  if (!token) {
-    throw new Error('Either pass --token or set GITHUB_TOKEN.');
-  }
-
-  switch (command) {
-    case 'last-release':
-      if (args['prior-to'] && args.major) {
-        throw new Error('Cannot pass both `--prior-to and --major at the same time');
-      }
-
-      // eslint-disable-next-line no-console
-      console.log(await fetchPreviousVersion(token, {
-        priorTo: args['prior-to'],
-        majorVersion: args.major,
-      }));
-      break;
-  }
-}
-
-main().catch(e => {
-  // eslint-disable-next-line no-console
-  console.error(e);
-  process.exitCode = 1;
-});

package/lib/cli/run-suite.ts

@@ -1,153 +0,0 @@
-/* eslint-disable no-console */
-import * as path from 'path';
-import * as jest from 'jest';
-import * as yargs from 'yargs';
-import { ReleasePackageSourceSetup } from '../package-sources/release-source';
-import { RepoPackageSourceSetup, autoFindRoot } from '../package-sources/repo-source';
-import { IPackageSourceSetup } from '../package-sources/source';
-import { serializeForSubprocess } from '../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,
-    })
-    .options('maxWorkers', {
-      alias: 'w',
-      description: 'Specifies the maximum number of workers the worker-pool will spawn for running tests. We use a sensible default for running cli integ tests.',
-      type: 'string',
-      requiresArg: true,
-    })
-    .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}`);
-  console.log(`Test version:   ${thisPackageVersion()}`);
-
-  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([
-      '--randomize',
-      ...args.runInBand ? ['-i'] : [],
-      ...args.test ? ['-t', args.test] : [],
-      ...args.verbose ? ['--verbose'] : [],
-      ...args.maxWorkers ? [`--maxWorkers=${args.maxWorkers}`] : [],
-      ...passWithNoTests ? ['--passWithNoTests'] : [],
-      ...args['test-file'] ? [args['test-file']] : [],
-    ], path.resolve(__dirname, '..', '..', 'resources', 'integ.jest.config.js'));
-  } finally {
-    await packageSource.cleanup();
-  }
-}
-
-function thisPackageVersion(): string {
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  return require('../../package.json').version;
-}
-
-main().catch(e => {
-  // eslint-disable-next-line no-console
-  console.error(e);
-  process.exitCode = 1;
-});