@aws-cdk-testing/cli-integ 2.61.0

package/lib/staging/npm.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadNpmPackages = exports.npmLogin = void 0;
+/* eslint-disable no-console */
+const path = require("path");
+const files_1 = require("../files");
+const shell_1 = require("../shell");
+const parallel_shell_1 = require("./parallel-shell");
+async function npmLogin(login, usageDir) {
+    // Creating an ~/.npmrc that references an envvar is what you're supposed to do. (https://docs.npmjs.com/private-modules/ci-server-config)
+    await writeNpmLoginToken(usageDir, login.npmEndpoint, '${NPM_TOKEN}');
+    // Add variables to env file
+    await usageDir.addToEnv(npmEnv(usageDir, login));
+}
+exports.npmLogin = npmLogin;
+function npmEnv(usageDir, login) {
+    return {
+        npm_config_userconfig: path.join(usageDir.directory, '.npmrc'),
+        npm_config_registry: login.npmEndpoint,
+        npm_config_always_auth: 'true',
+        NPM_TOKEN: login.authToken,
+    };
+}
+async function uploadNpmPackages(packages, login, usageDir) {
+    await parallel_shell_1.parallelShell(packages, async (pkg, output) => {
+        console.log(`⏳ ${pkg}`);
+        // path.resolve() is required -- if the filename ends up looking like `js/bla.tgz` then NPM thinks it's a short form GitHub name.
+        await shell_1.shell(['node', require.resolve('npm'), 'publish', path.resolve(pkg)], {
+            modEnv: npmEnv(usageDir, login),
+            show: 'error',
+            output,
+        });
+        console.log(`✅ ${pkg}`);
+    }, (pkg, output) => {
+        if (output.toString().includes('code EPUBLISHCONFLICT')) {
+            console.log(`❌ ${pkg}: already exists. Skipped.`);
+            return 'skip';
+        }
+        if (output.toString().includes('code EPRIVATE')) {
+            console.log(`❌ ${pkg}: is private. Skipped.`);
+            return 'skip';
+        }
+        return 'fail';
+    });
+}
+exports.uploadNpmPackages = uploadNpmPackages;
+async function writeNpmLoginToken(usageDir, endpoint, token) {
+    const rcFile = path.join(usageDir.directory, '.npmrc');
+    const lines = await files_1.loadLines(rcFile);
+    const key = `${endpoint.replace(/^https:/, '')}:_authToken`;
+    files_1.updateIniKey(lines, key, token);
+    await files_1.writeLines(rcFile, lines);
+    return rcFile;
+}
+// Environment variable, .npmrc in same directory as package.json or in home dir
+//# sourceMappingURL=data:application/json;base64,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

package/lib/staging/nuget.d.ts

@@ -0,0 +1,4 @@
+import { LoginInformation } from './codeartifact';
+import { UsageDir } from './usage-dir';
+export declare function nugetLogin(login: LoginInformation, usageDir: UsageDir): Promise<void>;
+export declare function uploadDotnetPackages(packages: string[], usageDir: UsageDir): Promise<void>;

package/lib/staging/nuget.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadDotnetPackages = exports.nugetLogin = void 0;
+/* eslint-disable no-console */
+const files_1 = require("../files");
+const shell_1 = require("../shell");
+const parallel_shell_1 = require("./parallel-shell");
+async function nugetLogin(login, usageDir) {
+    // NuGet.Config MUST live in the current directory or in the home directory, and there is no environment
+    // variable to configure its location.
+    await writeNuGetConfigFile(usageDir.cwdFile('NuGet.Config'), login);
+}
+exports.nugetLogin = nugetLogin;
+async function uploadDotnetPackages(packages, usageDir) {
+    await usageDir.copyCwdFileHere('NuGet.Config');
+    await parallel_shell_1.parallelShell(packages, async (pkg, output) => {
+        console.log(`⏳ ${pkg}`);
+        await shell_1.shell(['dotnet', 'nuget', 'push',
+            pkg,
+            '--source', 'CodeArtifact',
+            '--no-symbols',
+            '--force-english-output',
+            '--disable-buffering',
+            '--timeout', '600',
+            '--skip-duplicate'], {
+            output,
+        });
+        console.log(`✅ ${pkg}`);
+    }, (pkg, output) => {
+        if (output.toString().includes('Conflict')) {
+            console.log(`❌ ${pkg}: already exists. Skipped.`);
+            return 'skip';
+        }
+        if (output.includes('System.Threading.AbandonedMutexException')) {
+            console.log(`♻️ ${pkg}: AbandonedMutexException. Probably a sign of throttling, retrying.`);
+            return 'retry';
+        }
+        if (output.includes('Too Many Requests')) {
+            console.log(`♻️ ${pkg}: Too many requests. Retrying.`);
+            return 'retry';
+        }
+        if (output.includes('System.IO.IOException: The system cannot open the device or file specified.')) {
+            console.log(`♻️ ${pkg}: Some error that we've seen before as a result of throttling. Retrying.`);
+            return 'retry';
+        }
+        return 'fail';
+    });
+}
+exports.uploadDotnetPackages = uploadDotnetPackages;
+async function writeNuGetConfigFile(filename, login) {
+    // `dotnet nuget push` has an `--api-key` parameter, but CodeArtifact
+    // does not support that. We must authenticate with Basic auth.
+    await files_1.writeFile(filename, `<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSources>
+    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
+    <add key="CodeArtifact" value="${login.nugetEndpoint}v3/index.json" />
+  </packageSources>
+  <activePackageSource>
+    <add key="CodeArtifact" value="${login.nugetEndpoint}v3/index.json" />
+  </activePackageSource>
+  <packageSourceCredentials>
+    <CodeArtifact>
+        <add key="Username" value="aws" />
+        <add key="ClearTextPassword" value="${login.authToken}" />
+      </CodeArtifact>
+  </packageSourceCredentials>
+</configuration>`);
+}
+// NuGet.Config in current directory
+//# sourceMappingURL=data:application/json;base64,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

package/lib/staging/parallel-shell.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+export declare type ErrorResponse = 'fail' | 'skip' | 'retry';
+/**
+ * Run a function in parallel with cached output
+ */
+export declare function parallelShell<A>(inputs: A[], block: (x: A, output: NodeJS.WritableStream) => Promise<void>, swallowError?: (x: A, output: string) => ErrorResponse): Promise<void>;

package/lib/staging/parallel-shell.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parallelShell = void 0;
+const p_queue_1 = require("p-queue");
+const aws_1 = require("../aws");
+const corking_1 = require("../corking");
+/**
+ * Run a function in parallel with cached output
+ */
+async function parallelShell(inputs, block, swallowError) {
+    // Limit to 10 for now, too many instances of Maven exhaust the CodeBuild instance memory
+    const q = new p_queue_1.default({ concurrency: Number(process.env.CONCURRENCY) || 10 });
+    await q.addAll(inputs.map(input => async () => {
+        let attempts = 10;
+        let sleepMs = 500;
+        while (true) {
+            const output = new corking_1.MemoryStream();
+            try {
+                await block(input, output);
+                return;
+            }
+            catch (e) {
+                switch (swallowError?.(input, output.toString())) {
+                    case 'skip':
+                        return;
+                    case 'retry':
+                        if (--attempts > 0) {
+                            await aws_1.sleep(Math.floor(Math.random() * sleepMs));
+                            sleepMs *= 2;
+                            continue;
+                        }
+                        break;
+                    case 'fail':
+                    case undefined:
+                        break;
+                }
+                // eslint-disable-next-line no-console
+                console.error(output.toString());
+                throw e;
+            }
+        }
+    }));
+    await q.onEmpty();
+}
+exports.parallelShell = parallelShell;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/staging/pypi.d.ts

@@ -0,0 +1,4 @@
+import { LoginInformation } from './codeartifact';
+import { UsageDir } from './usage-dir';
+export declare function pypiLogin(login: LoginInformation, usageDir: UsageDir): Promise<void>;
+export declare function uploadPythonPackages(packages: string[], login: LoginInformation): Promise<void>;

package/lib/staging/pypi.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadPythonPackages = exports.pypiLogin = void 0;
+/* eslint-disable no-console */
+const path = require("path");
+const files_1 = require("../files");
+const shell_1 = require("../shell");
+const parallel_shell_1 = require("./parallel-shell");
+async function pypiLogin(login, usageDir) {
+    // Write pip config file and set environment var
+    await files_1.writeFile(path.join(usageDir.directory, 'pip.conf'), [
+        '[global]',
+        `index-url = https://aws:${login.authToken}@${login.pypiEndpoint.replace(/^https:\/\//, '')}simple/`,
+    ].join('\n'));
+    await usageDir.addToEnv({
+        PIP_CONFIG_FILE: `${usageDir.directory}/pip.conf`,
+    });
+}
+exports.pypiLogin = pypiLogin;
+async function uploadPythonPackages(packages, login) {
+    await shell_1.shell(['pip', 'install', 'twine'], { show: 'error' });
+    // Even though twine supports uploading all packages in one go, we have to upload them
+    // individually since CodeArtifact does not support Twine's `--skip-existing`. Fun beans.
+    await parallel_shell_1.parallelShell(packages, async (pkg, output) => {
+        console.log(`⏳ ${pkg}`);
+        await shell_1.shell(['twine', 'upload', '--verbose', pkg], {
+            modEnv: {
+                TWINE_USERNAME: 'aws',
+                TWINE_PASSWORD: login.authToken,
+                TWINE_REPOSITORY_URL: login.pypiEndpoint,
+            },
+            show: 'error',
+            output,
+        });
+        console.log(`✅ ${pkg}`);
+    }, (pkg, output) => {
+        if (output.toString().includes('This package is configured to block new versions') || output.toString().includes('409 Conflict')) {
+            console.log(`❌ ${pkg}: already exists. Skipped.`);
+            return 'skip';
+        }
+        if (output.includes('429 Too Many Requests ')) {
+            console.log(`♻️ ${pkg}: 429 Too Many Requests. Retrying.`);
+            return 'retry';
+        }
+        return 'fail';
+    });
+}
+exports.uploadPythonPackages = uploadPythonPackages;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/staging/usage-dir.d.ts

@@ -0,0 +1,31 @@
+export declare const DEFAULT_USAGE_DIR: string;
+/**
+ * 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 declare class UsageDir {
+    readonly directory: string;
+    static default(): UsageDir;
+    readonly envFile: string;
+    readonly cwdDir: string;
+    private constructor();
+    clean(): Promise<void>;
+    addToEnv(settings: Record<string, string>): Promise<void>;
+    currentEnv(): Promise<Record<string, string>>;
+    cwdFile(filename: string): string;
+    activateInCurrentProcess(): Promise<void>;
+    copyCwdFileHere(...filenames: string[]): Promise<void>;
+    advertise(): void;
+}

package/lib/staging/usage-dir.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsageDir = exports.DEFAULT_USAGE_DIR = void 0;
+const path = require("path");
+const fs = require("fs-extra");
+const files_1 = require("../files");
+exports.DEFAULT_USAGE_DIR = path.join(files_1.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.
+ */
+class UsageDir {
+    constructor(directory) {
+        this.directory = directory;
+        this.envFile = path.join(this.directory, 'env');
+        this.cwdDir = path.join(this.directory, 'cwd');
+    }
+    static default() {
+        return new UsageDir(exports.DEFAULT_USAGE_DIR);
+    }
+    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/ .',
+        ].join('\n'), { encoding: 'utf-8' });
+    }
+    async addToEnv(settings) {
+        const lines = await files_1.loadLines(this.envFile);
+        for (const [k, v] of Object.entries(settings)) {
+            files_1.updateIniKey(lines, k, v);
+        }
+        await files_1.writeLines(this.envFile, lines);
+    }
+    async currentEnv() {
+        const lines = await files_1.loadLines(this.envFile);
+        const splitter = /^([a-zA-Z0-9_-]+)\s*=\s*(.*)$/;
+        const ret = {};
+        for (const line of lines) {
+            const m = line.match(splitter);
+            if (m) {
+                ret[m[1]] = m[2];
+            }
+        }
+        return ret;
+    }
+    cwdFile(filename) {
+        return path.join(this.cwdDir, filename);
+    }
+    async activateInCurrentProcess() {
+        for (const [k, v] of Object.entries(await this.currentEnv())) {
+            process.env[k] = v;
+        }
+        await files_1.copyDirectoryContents(this.cwdDir, '.');
+    }
+    async copyCwdFileHere(...filenames) {
+        for (const file of filenames) {
+            await fs.copyFile(path.join(this.cwdDir, file), file);
+        }
+    }
+    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`);
+    }
+}
+exports.UsageDir = UsageDir;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/with-aws.d.ts

@@ -0,0 +1,13 @@
+import { AwsClients } from './aws';
+import { TestContext } from './integ-test';
+import { ResourcePool } from './resource-pool';
+export declare 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) => Promise<void>): (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.regionPool = exports.withAws = void 0;
+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) {
+    return (context) => regionPool().using(async (region) => {
+        const aws = await aws_1.AwsClients.forRegion(region, context.output);
+        await sanityCheck(aws);
+        return block({ ...context, aws });
+    });
+}
+exports.withAws = withAws;
+let _regionPool;
+function regionPool() {
+    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 = resource_pool_1.ResourcePool.withResources('aws_regions', REGIONS);
+    return _regionPool;
+}
+exports.regionPool = 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-cdk-app.d.ts

@@ -0,0 +1,146 @@
+/// <reference types="node" />
+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';
+/**
+ * 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 withCdkApp<A extends TestContext & AwsContext>(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 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 {
+    readonly toolkitStackName: string;
+    /**
+     * @default false
+     */
+    readonly verbose?: boolean;
+    /**
+     * @default - auto-generated CloudFormation name
+     */
+    readonly bootstrapBucketName?: string;
+    readonly cliOptions?: CdkCliOptions;
+    /**
+     * @default - none
+     */
+    readonly tags?: 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;
+}
+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): 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>;
+    cdk(args: string[], options?: CdkCliOptions): Promise<string>;
+    template(stackName: string): any;
+    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 buckets
+     */
+    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 {};