@aws-cdk-testing/cli-integ 0.0.0

package/lib/staging/usage-dir.ts

@@ -0,0 +1,99 @@
+import * as path from 'path';
+import * as fs from 'fs-extra';
+import { copyDirectoryContents, homeDir, loadLines, updateIniKey, writeLines } from '../files';
+
+export const DEFAULT_USAGE_DIR = path.join(homeDir(), '.codeartifact/usage');
+
+/**
+ * The usage directory is where we write per-session config files to access the CodeArtifact repository.
+ *
+ * Some config files may be written in a system-global location, but they will not be active unless the
+ * contents of this directory have been sourced/copied into the current terminal.
+ *
+ * CONTRACT
+ *
+ * There are two special entries:
+ *
+ * - `env`, a file with `key=value` entries for environment variables to  set.
+ * - `cwd/`, a directory with files that need to be copied into the current directory before each command.
+ *
+ * Other than these, code may write tempfiles to this directory if it wants, but there is no meaning
+ * implied for other files.
+ */
+export class UsageDir {
+  public static default() {
+    return new UsageDir(DEFAULT_USAGE_DIR);
+  }
+
+  public readonly envFile: string;
+  public readonly cwdDir: string;
+
+  private constructor(public readonly directory: string) {
+    this.envFile = path.join(this.directory, 'env');
+    this.cwdDir = path.join(this.directory, 'cwd');
+  }
+
+  public async clean() {
+    await fs.rm(this.directory, { recursive: true, force: true });
+    await fs.mkdirp(path.join(this.directory, 'cwd'));
+    await fs.writeFile(path.join(this.directory, 'env'), '', { encoding: 'utf-8' });
+
+    await this.addToEnv({
+      CWD_FILES_DIR: path.join(this.directory, 'cwd'),
+    });
+
+    // Write a bash helper to load these settings
+    await fs.writeFile(path.join(this.directory, 'activate.bash'), [
+      `while read -u10 line; do [[ -z $line ]] || export "$line"; done 10<${this.directory}/env`,
+      'cp -R $CWD_FILES_DIR/ .', // Copy files from directory even if it is empty
+    ].join('\n'), { encoding: 'utf-8' });
+  }
+
+  public async addToEnv(settings: Record<string, string>) {
+    const lines = await loadLines(this.envFile);
+    for (const [k, v] of Object.entries(settings)) {
+      updateIniKey(lines, k, v);
+    }
+    await writeLines(this.envFile, lines);
+  }
+
+  public async currentEnv(): Promise<Record<string, string>> {
+    const lines = await loadLines(this.envFile);
+
+    const splitter = /^([a-zA-Z0-9_-]+)\s*=\s*(.*)$/;
+
+    const ret: Record<string, string> = {};
+    for (const line of lines) {
+      const m = line.match(splitter);
+      if (m) {
+        ret[m[1]] = m[2];
+      }
+    }
+    return ret;
+  }
+
+  public cwdFile(filename: string) {
+    return path.join(this.cwdDir, filename);
+  }
+
+  public async activateInCurrentProcess() {
+    for (const [k, v] of Object.entries(await this.currentEnv())) {
+      process.env[k] = v;
+    }
+
+    await copyDirectoryContents(this.cwdDir, '.');
+  }
+
+  public async copyCwdFileHere(...filenames: string[]) {
+    for (const file of filenames) {
+      await fs.copyFile(path.join(this.cwdDir, file), file);
+    }
+  }
+
+  public advertise() {
+    // eslint-disable-next-line no-console
+    console.log('To activate these settings in the current terminal:');
+    // eslint-disable-next-line no-console
+    console.log(`    source ${this.directory}/activate.bash`);
+  }
+}

package/lib/with-aws.d.ts

@@ -0,0 +1,14 @@
+import { AwsClients } from './aws';
+import { TestContext } from './integ-test';
+import { ResourcePool } from './resource-pool';
+import { DisableBootstrapContext } from './with-cdk-app';
+export type AwsContext = {
+    readonly aws: AwsClients;
+};
+/**
+ * Higher order function to execute a block with an AWS client setup
+ *
+ * Allocate the next region from the REGION pool and dispose it afterwards.
+ */
+export declare function withAws<A extends TestContext>(block: (context: A & AwsContext & DisableBootstrapContext) => Promise<void>, disableBootstrap?: boolean): (context: A) => Promise<void>;
+export declare function regionPool(): ResourcePool;

package/lib/with-aws.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAws = withAws;
+exports.regionPool = regionPool;
+const aws_1 = require("./aws");
+const resource_pool_1 = require("./resource-pool");
+/**
+ * Higher order function to execute a block with an AWS client setup
+ *
+ * Allocate the next region from the REGION pool and dispose it afterwards.
+ */
+function withAws(block, disableBootstrap = false) {
+    return (context) => regionPool().using(async (region) => {
+        const aws = await aws_1.AwsClients.forRegion(region, context.output);
+        await sanityCheck(aws);
+        return block({ ...context, disableBootstrap, aws });
+    });
+}
+let _regionPool;
+function regionPool() {
+    var _a, _b;
+    if (_regionPool !== undefined) {
+        return _regionPool;
+    }
+    const REGIONS = process.env.AWS_REGIONS
+        ? process.env.AWS_REGIONS.split(',')
+        : [(_b = (_a = process.env.AWS_REGION) !== null && _a !== void 0 ? _a : process.env.AWS_DEFAULT_REGION) !== null && _b !== void 0 ? _b : 'us-east-1'];
+    // eslint-disable-next-line no-console
+    console.log(`Using regions: ${REGIONS}\n`);
+    _regionPool = resource_pool_1.ResourcePool.withResources('aws_regions', REGIONS);
+    return _regionPool;
+}
+/**
+ * Perform a one-time quick sanity check that the AWS clients have properly configured credentials
+ *
+ * If we don't do this, calls are going to fail and they'll be retried and everything will take
+ * forever before the user notices a simple misconfiguration.
+ *
+ * We can't check for the presence of environment variables since credentials could come from
+ * anywhere, so do simple account retrieval.
+ *
+ * Only do it once per process.
+ */
+async function sanityCheck(aws) {
+    if (sanityChecked === undefined) {
+        try {
+            await aws.account();
+            sanityChecked = true;
+        }
+        catch (e) {
+            sanityChecked = false;
+            throw new Error(`AWS credentials probably not configured, got error: ${e.message}`);
+        }
+    }
+    if (!sanityChecked) {
+        throw new Error('AWS credentials probably not configured, see previous error');
+    }
+}
+let sanityChecked;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/with-aws.ts

@@ -0,0 +1,67 @@
+import { AwsClients } from './aws';
+import { TestContext } from './integ-test';
+import { ResourcePool } from './resource-pool';
+import { DisableBootstrapContext } from './with-cdk-app';
+
+export type AwsContext = { readonly aws: AwsClients };
+
+/**
+ * Higher order function to execute a block with an AWS client setup
+ *
+ * Allocate the next region from the REGION pool and dispose it afterwards.
+ */
+export function withAws<A extends TestContext>(
+  block: (context: A & AwsContext & DisableBootstrapContext) => Promise<void>,
+  disableBootstrap: boolean = false,
+): (context: A) => Promise<void> {
+  return (context: A) => regionPool().using(async (region) => {
+    const aws = await AwsClients.forRegion(region, context.output);
+    await sanityCheck(aws);
+
+    return block({ ...context, disableBootstrap, aws });
+  });
+}
+
+let _regionPool: undefined | ResourcePool;
+export function regionPool(): ResourcePool {
+  if (_regionPool !== undefined) {
+    return _regionPool;
+  }
+
+  const REGIONS = process.env.AWS_REGIONS
+    ? process.env.AWS_REGIONS.split(',')
+    : [process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1'];
+
+  // eslint-disable-next-line no-console
+  console.log(`Using regions: ${REGIONS}\n`);
+
+  _regionPool = ResourcePool.withResources('aws_regions', REGIONS);
+  return _regionPool;
+}
+
+/**
+ * Perform a one-time quick sanity check that the AWS clients have properly configured credentials
+ *
+ * If we don't do this, calls are going to fail and they'll be retried and everything will take
+ * forever before the user notices a simple misconfiguration.
+ *
+ * We can't check for the presence of environment variables since credentials could come from
+ * anywhere, so do simple account retrieval.
+ *
+ * Only do it once per process.
+ */
+async function sanityCheck(aws: AwsClients) {
+  if (sanityChecked === undefined) {
+    try {
+      await aws.account();
+      sanityChecked = true;
+    } catch (e: any) {
+      sanityChecked = false;
+      throw new Error(`AWS credentials probably not configured, got error: ${e.message}`);
+    }
+  }
+  if (!sanityChecked) {
+    throw new Error('AWS credentials probably not configured, see previous error');
+  }
+}
+let sanityChecked: boolean | undefined;

package/lib/with-cdk-app.d.ts

@@ -0,0 +1,210 @@
+import { AwsClients } from './aws';
+import { TestContext } from './integ-test';
+import { IPackageSource } from './package-sources/source';
+import { ShellOptions, ShellHelper } from './shell';
+import { AwsContext } from './with-aws';
+export declare const DEFAULT_TEST_TIMEOUT_S: number;
+export declare const EXTENDED_TEST_TIMEOUT_S: number;
+/**
+ * Higher order function to execute a block with a CDK app fixture
+ *
+ * Requires an AWS client to be passed in.
+ *
+ * For backwards compatibility with existing tests (so we don't have to change
+ * too much) the inner block is expected to take a `TestFixture` object.
+ */
+export declare function withSpecificCdkApp(appName: string, block: (context: TestFixture) => Promise<void>): (context: TestContext & AwsContext & DisableBootstrapContext) => Promise<void>;
+/**
+ * Like `withSpecificCdkApp`, but uses the default integration testing app with a million stacks in it
+ */
+export declare function withCdkApp(block: (context: TestFixture) => Promise<void>): (context: TestContext & AwsContext & DisableBootstrapContext) => Promise<void>;
+export declare function withCdkMigrateApp<A extends TestContext>(language: string, block: (context: TestFixture) => Promise<void>): (context: A) => Promise<void>;
+export declare function withMonolithicCfnIncludeCdkApp<A extends TestContext>(block: (context: TestFixture) => Promise<void>): (context: A) => Promise<void>;
+/**
+ * Default test fixture for most (all?) integ tests
+ *
+ * It's a composition of withAws/withCdkApp, expecting the test block to take a `TestFixture`
+ * object.
+ *
+ * We could have put `withAws(withCdkApp(fixture => { /... actual test here.../ }))` in every
+ * test declaration but centralizing it is going to make it convenient to modify in the future.
+ */
+export declare function withDefaultFixture(block: (context: TestFixture) => Promise<void>): (context: TestContext) => Promise<void>;
+export declare function withSpecificFixture(appName: string, block: (context: TestFixture) => Promise<void>): (context: TestContext) => Promise<void>;
+export declare function withExtendedTimeoutFixture(block: (context: TestFixture) => Promise<void>): (context: TestContext) => Promise<void>;
+export declare function withCDKMigrateFixture(language: string, block: (content: TestFixture) => Promise<void>): (context: TestContext) => Promise<void>;
+export interface DisableBootstrapContext {
+    /**
+     * Whether to disable creating the default bootstrap
+     * stack prior to running the test
+     *
+     * This should be set to true when running tests that
+     * explicitly create a bootstrap stack
+     *
+     * @default false
+     */
+    readonly disableBootstrap?: boolean;
+}
+/**
+ * To be used in place of `withDefaultFixture` when the test
+ * should not create the default bootstrap stack
+ */
+export declare function withoutBootstrap(block: (context: TestFixture) => Promise<void>): (context: TestContext) => Promise<void>;
+export interface CdkCliOptions extends ShellOptions {
+    options?: string[];
+    neverRequireApproval?: boolean;
+    verbose?: boolean;
+}
+/**
+ * Prepare a target dir byreplicating a source directory
+ */
+export declare function cloneDirectory(source: string, target: string, output?: NodeJS.WritableStream): Promise<void>;
+interface CommonCdkBootstrapCommandOptions {
+    /**
+     * Path to a custom bootstrap template.
+     *
+     * @default - the default CDK bootstrap template.
+     */
+    readonly bootstrapTemplate?: string;
+    readonly toolkitStackName: string;
+    /**
+     * @default false
+     */
+    readonly verbose?: boolean;
+    /**
+     * @default - auto-generated CloudFormation name
+     */
+    readonly bootstrapBucketName?: string;
+    readonly cliOptions?: CdkCliOptions;
+    /**
+     * @default - none
+     */
+    readonly tags?: string;
+    /**
+     * @default - the default CDK qualifier
+     */
+    readonly qualifier?: string;
+}
+export interface CdkLegacyBootstrapCommandOptions extends CommonCdkBootstrapCommandOptions {
+    /**
+     * @default false
+     */
+    readonly noExecute?: boolean;
+    /**
+     * @default true
+     */
+    readonly publicAccessBlockConfiguration?: boolean;
+}
+export interface CdkModernBootstrapCommandOptions extends CommonCdkBootstrapCommandOptions {
+    /**
+     * @default false
+     */
+    readonly force?: boolean;
+    /**
+     * @default - none
+     */
+    readonly cfnExecutionPolicy?: string;
+    /**
+     * @default false
+     */
+    readonly showTemplate?: boolean;
+    readonly template?: string;
+    /**
+     * @default false
+     */
+    readonly terminationProtection?: boolean;
+    /**
+     * @default undefined
+     */
+    readonly examplePermissionsBoundary?: boolean;
+    /**
+     * @default undefined
+     */
+    readonly customPermissionsBoundary?: string;
+    /**
+     * @default undefined
+     */
+    readonly usePreviousParameters?: boolean;
+}
+export interface CdkGarbageCollectionCommandOptions {
+    /**
+     * The amount of days an asset should stay isolated before deletion, to
+     * guard against some pipeline rollback scenarios
+     *
+     * @default 0
+     */
+    readonly rollbackBufferDays?: number;
+    /**
+     * The type of asset that is getting garbage collected.
+     *
+     * @default 'all'
+     */
+    readonly type?: 'ecr' | 's3' | 'all';
+    /**
+     * The name of the bootstrap stack
+     *
+     * @default 'CdkToolkit'
+     */
+    readonly bootstrapStackName?: string;
+}
+export declare class TestFixture extends ShellHelper {
+    readonly integTestDir: string;
+    readonly stackNamePrefix: string;
+    readonly output: NodeJS.WritableStream;
+    readonly aws: AwsClients;
+    readonly randomString: string;
+    readonly qualifier: string;
+    private readonly bucketsToDelete;
+    readonly packages: IPackageSource;
+    constructor(integTestDir: string, stackNamePrefix: string, output: NodeJS.WritableStream, aws: AwsClients, randomString: string);
+    log(s: string): void;
+    cdkDeploy(stackNames: string | string[], options?: CdkCliOptions, skipStackRename?: boolean): Promise<string>;
+    cdkSynth(options?: CdkCliOptions): Promise<string>;
+    cdkDestroy(stackNames: string | string[], options?: CdkCliOptions): Promise<string>;
+    cdkBootstrapLegacy(options: CdkLegacyBootstrapCommandOptions): Promise<string>;
+    cdkBootstrapModern(options: CdkModernBootstrapCommandOptions): Promise<string>;
+    cdkGarbageCollect(options: CdkGarbageCollectionCommandOptions): Promise<string>;
+    cdkMigrate(language: string, stackName: string, inputPath?: string, options?: CdkCliOptions): Promise<string>;
+    cdk(args: string[], options?: CdkCliOptions): Promise<string>;
+    template(stackName: string): any;
+    bootstrapRepoName(): Promise<string>;
+    get bootstrapStackName(): string;
+    fullStackName(stackName: string): string;
+    fullStackName(stackNames: string[]): string[];
+    /**
+     * Append this to the list of buckets to potentially delete
+     *
+     * At the end of a test, we clean up buckets that may not have gotten destroyed
+     * (for whatever reason).
+     */
+    rememberToDeleteBucket(bucketName: string): void;
+    /**
+     * Cleanup leftover stacks and bootstrapped resources
+     */
+    dispose(success: boolean): Promise<void>;
+    /**
+     * Return the stacks starting with our testing prefix that should be deleted
+     */
+    private deleteableStacks;
+    private sortBootstrapStacksToTheEnd;
+}
+/**
+ * Install the given NPM packages, identified by their names and versions
+ *
+ * Works by writing the packages to a `package.json` file, and
+ * then running NPM7's "install" on it. The use of NPM7 will automatically
+ * install required peerDependencies.
+ *
+ * If we're running in REPO mode and we find the package in the set of local
+ * packages in the repository, we'll write the directory name to `package.json`
+ * so that NPM will create a symlink (this allows running tests against
+ * built-but-unpackaged modules, and saves dev cycle time).
+ *
+ * Be aware you MUST install all the packages you directly depend upon! In the case
+ * of a repo/symlinking install, transitive dependencies WILL NOT be installed in the
+ * current directory's `node_modules` directory, because they will already have been
+ * symlinked from the TARGET directory's `node_modules` directory (which is sufficient
+ * for Node's dependency lookup mechanism).
+ */
+export declare function installNpmPackages(fixture: TestFixture, packages: Record<string, string>): Promise<void>;
+export {};