@aws-cdk-testing/cli-integ 0.0.0

package/bin/stage-distribution.ts

@@ -0,0 +1,267 @@
+/* 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 '../lib';
+import { TestRepository } from '../lib/staging/codeartifact';
+import { uploadJavaPackages, mavenLogin } from '../lib/staging/maven';
+import { uploadNpmPackages, npmLogin } from '../lib/staging/npm';
+import { uploadDotnetPackages, nugetLogin } from '../lib/staging/nuget';
+import { uploadPythonPackages, pypiLogin } from '../lib/staging/pypi';
+import { UsageDir } from '../lib/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/bin/test-root

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('./test-root.js');

package/bin/test-root.d.ts

@@ -0,0 +1 @@
+export {};

package/bin/test-root.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+// eslint-disable-next-line no-console
+console.log(path.resolve(__dirname, '..'));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC1yb290LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsidGVzdC1yb290LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsNkJBQTZCO0FBQzdCLHNDQUFzQztBQUN0QyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxFQUFFLElBQUksQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBwYXRoIGZyb20gJ3BhdGgnO1xuLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWNvbnNvbGVcbmNvbnNvbGUubG9nKHBhdGgucmVzb2x2ZShfX2Rpcm5hbWUsICcuLicpKTtcbiJdfQ==

package/bin/test-root.ts

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

package/entrypoints/test-cli-regression-against-current-code.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+#
+# Run our integration tests in regression mode against the
+# candidate version of the framework, which is the one we just packed.
+#
+set -euo pipefail
+integdir=$(cd $(dirname $0) && pwd)
+
+source ${integdir}/test-cli-regression.bash
+
+run_regression_against_framework_version CANDIDATE_VERSION

package/entrypoints/test-cli-regression-against-latest-release.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+#
+# Run our integration tests in regression mode against the
+# previous version of the framework, relative to the version being packed now.
+#
+set -euo pipefail
+integdir=$(cd $(dirname $0) && pwd)
+
+source ${integdir}/test-cli-regression.bash
+
+run_regression_against_framework_version PREVIOUS_VERSION

package/entrypoints/test-cli-regression.bash

@@ -0,0 +1,83 @@
+#!/bin/bash
+#
+# Helper functions for CLI regression tests.
+#
+set -euo pipefail
+integdir=$(cd $(dirname $0) && pwd)
+
+# Run our integration tests in regression mode.
+#
+#   1. Figure out what was the previous (relative to the current candidate) version we published.
+#   2. Download the integration tests artifact from that version.
+#   2. Copy its integration tests directory ((test/integ/cli)) here.
+#   3. Run the integration tests from the copied directory.
+#
+# Positional Arugments:
+#
+#   1) Framework version identifier. Which version of the framework should the tests run against. Options are:
+#
+#       - CANDIDATE_VERSION: Use the candidate code, i.e the one being built right now.
+#       - PREVIOUS_VERSION: Use the previous version code, i.e the published version prior to CANDIDATE_VERSION.
+#
+function run_regression_against_framework_version() {
+
+  TEST_RUNNER=${TEST_RUNNER:-""}
+  CANDIDATE_VERSION=${CANDIDATE_VERSION:-""}
+
+  if [ "${TEST_RUNNER}" != "dist" ]; then
+    echo "Unsupported runner: ${TEST_RUNNER}. Regression tests can only run with the 'dist' runner"
+    exit 1
+  fi
+
+  SUPPORTED_FRAMEWORK_VERSION_IDENTIFIERS=("CANDIDATE_VERSION PREVIOUS_VERSION")
+  FRAMEWORK_VERSION_IDENTIFIER=$1
+  if [[ ! " ${SUPPORTED_FRAMEWORK_VERSION_IDENTIFIERS[@]} " =~ " ${FRAMEWORK_VERSION_IDENTIFIER} " ]]; then
+      echo "Unsupported framework version identifier. Should be one of ${SUPPORTED_FRAMEWORK_VERSION_IDENTIFIERS}"
+      exit 1
+  fi
+
+  echo "Fetching previous version for candidate: ${CANDIDATE_VERSION}"
+
+  # we need to explicitly install these deps because this script is executed
+  # int the test phase, which means the cwd is the packaged dist directory,
+  # so it doesn't have the dependencies installed from the installation of the package.json
+  # in the build phase. maybe we should just run npm install on the package.json again?
+  npm install @octokit/rest@^18.0.6 semver@^7.3.2 make-runnable@^1.3.8
+  PREVIOUS_VERSION=$(node ${integdir}/github-helpers.js fetchPreviousVersion ${CANDIDATE_VERSION})
+
+  echo "Previous version is: ${PREVIOUS_VERSION}"
+
+  temp_dir=$(mktemp -d)
+  integ_under_test=${integdir}/cli-backwards-tests-${PREVIOUS_VERSION}
+
+  pushd ${temp_dir}
+
+  echo "Downloading aws-cdk ${PREVIOUS_VERSION} tarball from npm"
+  npm pack aws-cdk@${PREVIOUS_VERSION}
+  tar -zxf aws-cdk-${PREVIOUS_VERSION}.tgz
+
+  rm -rf ${integ_under_test}
+
+  echo "Copying integration tests of version ${PREVIOUS_VERSION} to ${integ_under_test} (dont worry, its gitignored)"
+  cp -r ${temp_dir}/package/test/integ/cli "${integ_under_test}"
+  cp -r ${temp_dir}/package/test/integ/helpers "${integ_under_test}"
+
+  patch_dir="${integdir}/cli-regression-patches/v${PREVIOUS_VERSION}"
+  # delete possibly stale junit.xml file
+  rm -f ${integ_under_test}/junit.xml
+  if [[ -d "$patch_dir" ]]; then
+      echo "Hotpatching the tests with files from $patch_dir" >&2
+      cp -r "$patch_dir"/* ${integ_under_test}
+  fi
+
+  popd
+
+  # the framework version to use is determined by the caller as the first argument.
+  # its a variable name indirection.
+  export FRAMEWORK_VERSION=${!FRAMEWORK_VERSION_IDENTIFIER}
+
+  # Show the versions we settled on
+  echo "♈️ Regression testing [cli $(cdk --version)] against [framework ${FRAMEWORK_VERSION}] using [tests ${PREVIOUS_VERSION}}]"
+
+  ${integ_under_test}/test.sh
+}

package/entrypoints/test.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+set -euo pipefail
+scriptdir=$(cd $(dirname $0) && pwd)
+
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+echo 'CLI Integration Tests'
+echo '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
+
+cd $scriptdir
+
+source ../common/jest-test.bash
+invokeJest "$@"

package/lib/aws.d.ts

@@ -0,0 +1,51 @@
+import { CloudFormationClient, type Stack } from '@aws-sdk/client-cloudformation';
+import { ECRClient } from '@aws-sdk/client-ecr';
+import { ECSClient } from '@aws-sdk/client-ecs';
+import { IAMClient } from '@aws-sdk/client-iam';
+import { LambdaClient } from '@aws-sdk/client-lambda';
+import { S3Client } from '@aws-sdk/client-s3';
+import { SNSClient } from '@aws-sdk/client-sns';
+import { SSOClient } from '@aws-sdk/client-sso';
+import { STSClient } from '@aws-sdk/client-sts';
+export declare class AwsClients {
+    readonly region: string;
+    private readonly output;
+    static default(output: NodeJS.WritableStream): Promise<AwsClients>;
+    static forRegion(region: string, output: NodeJS.WritableStream): Promise<AwsClients>;
+    private readonly config;
+    readonly cloudFormation: CloudFormationClient;
+    readonly s3: S3Client;
+    readonly ecr: ECRClient;
+    readonly ecs: ECSClient;
+    readonly sso: SSOClient;
+    readonly sns: SNSClient;
+    readonly iam: IAMClient;
+    readonly lambda: LambdaClient;
+    readonly sts: STSClient;
+    constructor(region: string, output: NodeJS.WritableStream);
+    account(): Promise<string>;
+    deleteStacks(...stackNames: string[]): Promise<void>;
+    stackStatus(stackName: string): Promise<string | undefined>;
+    emptyBucket(bucketName: string, options?: {
+        bypassGovernance?: boolean;
+    }): Promise<void | import("@aws-sdk/client-s3").DeleteObjectsCommandOutput>;
+    deleteImageRepository(repositoryName: string): Promise<void>;
+    deleteBucket(bucketName: string): Promise<void>;
+}
+export declare function isStackMissingError(e: Error): boolean;
+export declare function isBucketMissingError(e: Error): boolean;
+/**
+ * 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 declare function retry<A>(output: NodeJS.WritableStream, operation: string, deadline: Date, block: () => Promise<A>): Promise<A>;
+export declare namespace retry {
+    var forSeconds: (seconds: number) => Date;
+    var abort: (e: Error) => Error;
+}
+export declare function outputFromStack(key: string, stack: Stack): string | undefined;
+export declare function sleep(ms: number): Promise<unknown>;