@aws-cdk-testing/cli-integ 3.1.0 → 3.1.2

package/lib/integ-test.ts

@@ -19,9 +19,10 @@ let failed = false;
 
 export interface TestContext {
   readonly randomString: string;
+  readonly name: string;
   readonly output: NodeJS.WritableStream;
   log(s: string): void;
-};
+}
 
 if (process.env.JEST_TEST_CONCURRENT === 'true') {
   process.stderr.write('ℹ️ JEST_TEST_CONCURRENT is true: tests will run concurrently and filters have no effect!\n0');
@@ -61,6 +62,7 @@ export function integTest(
       return await callback({
         output,
         randomString: randomString(),
+        name,
         log(s: string) {
           output.write(`${s}\n`);
         },
@@ -98,6 +100,7 @@ export function integTest(
       } else {
         // Use 'console.log' so the output is buffered by
         // jest and prints without a stack trace (if verbose: false).
+        // eslint-disable-next-line no-console
         console.log(output.buffer().toString());
       }
       throw e;

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

@@ -68,4 +68,4 @@ class ReleasePackageSource {
     }
 }
 exports.ReleasePackageSource = ReleasePackageSource;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -7,11 +7,12 @@ import { shell, rimraf, addToShellPath } from '../shell';
 
 export class ReleasePackageSourceSetup implements IPackageSourceSetup {
   readonly name = 'release';
-  readonly description = `release @ ${this.version}`;
+  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> {

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

@@ -19,10 +19,10 @@ export declare class RepoPackageSource implements IPackageSource {
     requestedAlphaVersion(): string;
 }
 /**
-  * Return a { name -> directory } packages found in a Yarn monorepo
-  *
-  * Cached in YARN_MONOREPO_CACHE.
-  */
+ * Return a { name -> directory } packages found in a Yarn monorepo
+ *
+ * Cached in YARN_MONOREPO_CACHE.
+ */
 export declare function findYarnPackages(root: string): Promise<Record<string, string>>;
 /**
  * Find the root directory of the repo from the current directory

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

@@ -64,10 +64,10 @@ async function writePackageMap(repoRoot) {
  */
 const YARN_MONOREPO_CACHE = {};
 /**
-  * Return a { name -> directory } packages found in a Yarn monorepo
-  *
-  * Cached in YARN_MONOREPO_CACHE.
-  */
+ * Return a { name -> directory } packages found in a Yarn monorepo
+ *
+ * Cached in YARN_MONOREPO_CACHE.
+ */
 async function findYarnPackages(root) {
     if (!(root in YARN_MONOREPO_CACHE)) {
         const outputDataString = JSON.parse(await (0, shell_1.shell)(['yarn', 'workspaces', '--json', 'info'], {
@@ -94,4 +94,4 @@ async function autoFindRoot() {
     }
     return path.dirname(found);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"repo-source.js","sourceRoot":"","sources":["repo-source.ts"],"names":[],"mappings":"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","sourcesContent":["import * as os from 'os';\nimport * as path from 'path';\nimport * as fs from 'fs-extra';\nimport { IPackageSourceSetup, IPackageSource } from './source';\nimport { findUp } from '../files';\nimport { shell, addToShellPath } from '../shell';\n\nexport class RepoPackageSourceSetup implements IPackageSourceSetup {\n  readonly name = 'repo';\n  readonly description = `repo(${this.repoRoot})`;\n\n  constructor(private readonly repoRoot: string) {\n  }\n\n  public async prepare(): Promise<void> {\n    if (!await fs.pathExists(path.join(this.repoRoot, 'package.json')) || !await fs.pathExists(path.join(this.repoRoot, 'yarn.lock'))) {\n      throw new Error(`${this.repoRoot}: does not look like the repository root`);\n    }\n\n    process.env.REPO_ROOT = this.repoRoot;\n    process.env.REPO_PACKAGE_MAP = await writePackageMap(this.repoRoot);\n    addToShellPath(path.resolve(__dirname, 'repo-tools'));\n  }\n\n  public async cleanup(): Promise<void> {\n  }\n}\n\nexport class RepoPackageSource implements IPackageSource {\n  private readonly repoRoot: string;\n\n  constructor() {\n    this.repoRoot = process.env.REPO_ROOT as string;\n  }\n\n  public async makeCliAvailable() {\n    addToShellPath(path.join(this.repoRoot, 'packages', 'aws-cdk', 'bin'));\n  }\n\n  public assertJsiiPackagesAvailable() {\n    throw new Error('jsii client packages are not available when using REPO source');\n  }\n\n  public async initializeDotnetPackages() {\n  }\n\n  public majorVersion() {\n    const releaseJson = fs.readJsonSync(path.resolve(this.repoRoot, 'release.json'));\n    return releaseJson.majorVersion;\n  }\n\n  public requestedCliVersion(): string {\n    return '*';\n  }\n\n  public requestedFrameworkVersion(): string {\n    return '*';\n  }\n\n  public requestedAlphaVersion(): string {\n    return '*';\n  }\n}\n\nasync function writePackageMap(repoRoot: string): Promise<string> {\n  const packages = await findYarnPackages(repoRoot);\n  const fileName = path.join(os.tmpdir(), 'package-map.json');\n  await fs.writeJson(fileName, packages);\n  return fileName;\n}\n\n/**\n * Cache monorepo discovery results, we only want to do this once per run\n */\nconst YARN_MONOREPO_CACHE: Record<string, any> = {};\n\n/**\n  * Return a { name -> directory } packages found in a Yarn monorepo\n  *\n  * Cached in YARN_MONOREPO_CACHE.\n  */\nexport async function findYarnPackages(root: string): Promise<Record<string, string>> {\n  if (!(root in YARN_MONOREPO_CACHE)) {\n    const outputDataString: string = JSON.parse(await shell(['yarn', 'workspaces', '--json', 'info'], {\n      captureStderr: false,\n      cwd: root,\n      show: 'error',\n    })).data;\n    const output: YarnWorkspacesOutput = JSON.parse(outputDataString);\n\n    const ret: Record<string, string> = {};\n    for (const [k, v] of Object.entries(output)) {\n      ret[k] = path.join(root, v.location);\n    }\n    YARN_MONOREPO_CACHE[root] = ret;\n  }\n  return YARN_MONOREPO_CACHE[root];\n}\n\n/**\n * Find the root directory of the repo from the current directory\n */\nexport async function autoFindRoot() {\n  const found = findUp('release.json');\n  if (!found) {\n    throw new Error(`Could not determine repository root: 'release.json' not found from ${process.cwd()}`);\n  }\n  return path.dirname(found);\n}\n\ntype YarnWorkspacesOutput = Record<string, { location: string }>;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"repo-source.js","sourceRoot":"","sources":["repo-source.ts"],"names":[],"mappings":";;;AAkFA,4CAgBC;AAKD,oCAMC;AA7GD,yBAAyB;AACzB,6BAA6B;AAC7B,+BAA+B;AAE/B,oCAAkC;AAClC,oCAAiD;AAEjD,MAAa,sBAAsB;IAIjC,YAA6B,QAAgB;QAAhB,aAAQ,GAAR,QAAQ,CAAQ;QAHpC,SAAI,GAAG,MAAM,CAAC;QAIrB,IAAI,CAAC,WAAW,GAAG,QAAQ,IAAI,CAAC,QAAQ,GAAG,CAAC;IAC9C,CAAC;IAEM,KAAK,CAAC,OAAO;QAClB,IAAI,CAAC,MAAM,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC;YAClI,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,CAAC,QAAQ,0CAA0C,CAAC,CAAC;QAC9E,CAAC;QAED,OAAO,CAAC,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC;QACtC,OAAO,CAAC,GAAG,CAAC,gBAAgB,GAAG,MAAM,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACpE,IAAA,sBAAc,EAAC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC;IACxD,CAAC;IAEM,KAAK,CAAC,OAAO;IACpB,CAAC;CACF;AApBD,wDAoBC;AAED,MAAa,iBAAiB;IAG5B;QACE,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,SAAmB,CAAC;IAClD,CAAC;IAEM,KAAK,CAAC,gBAAgB;QAC3B,IAAA,sBAAc,EAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC;IACzE,CAAC;IAEM,2BAA2B;QAChC,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAC;IACnF,CAAC;IAEM,KAAK,CAAC,wBAAwB;IACrC,CAAC;IAEM,YAAY;QACjB,MAAM,WAAW,GAAG,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC;QACjF,OAAO,WAAW,CAAC,YAAY,CAAC;IAClC,CAAC;IAEM,mBAAmB;QACxB,OAAO,GAAG,CAAC;IACb,CAAC;IAEM,yBAAyB;QAC9B,OAAO,GAAG,CAAC;IACb,CAAC;IAEM,qBAAqB;QAC1B,OAAO,GAAG,CAAC;IACb,CAAC;CACF;AAlCD,8CAkCC;AAED,KAAK,UAAU,eAAe,CAAC,QAAgB;IAC7C,MAAM,QAAQ,GAAG,MAAM,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IAClD,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,kBAAkB,CAAC,CAAC;IAC5D,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IACvC,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;GAEG;AACH,MAAM,mBAAmB,GAAwB,EAAE,CAAC;AAEpD;;;;GAIG;AACI,KAAK,UAAU,gBAAgB,CAAC,IAAY;IACjD,IAAI,CAAC,CAAC,IAAI,IAAI,mBAAmB,CAAC,EAAE,CAAC;QACnC,MAAM,gBAAgB,GAAW,IAAI,CAAC,KAAK,CAAC,MAAM,IAAA,aAAK,EAAC,CAAC,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE;YAChG,aAAa,EAAE,KAAK;YACpB,GAAG,EAAE,IAAI;YACT,IAAI,EAAE,OAAO;SACd,CAAC,CAAC,CAAC,IAAI,CAAC;QACT,MAAM,MAAM,GAAyB,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;QAElE,MAAM,GAAG,GAA2B,EAAE,CAAC;QACvC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YAC5C,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC;QACvC,CAAC;QACD,mBAAmB,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC;IAClC,CAAC;IACD,OAAO,mBAAmB,CAAC,IAAI,CAAC,CAAC;AACnC,CAAC;AAED;;GAEG;AACI,KAAK,UAAU,YAAY;IAChC,MAAM,KAAK,GAAG,IAAA,cAAM,EAAC,cAAc,CAAC,CAAC;IACrC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CAAC,sEAAsE,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;IACzG,CAAC;IACD,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC7B,CAAC","sourcesContent":["import * as os from 'os';\nimport * as path from 'path';\nimport * as fs from 'fs-extra';\nimport { IPackageSourceSetup, IPackageSource } from './source';\nimport { findUp } from '../files';\nimport { shell, addToShellPath } from '../shell';\n\nexport class RepoPackageSourceSetup implements IPackageSourceSetup {\n  readonly name = 'repo';\n  readonly description: string;\n\n  constructor(private readonly repoRoot: string) {\n    this.description = `repo(${this.repoRoot})`;\n  }\n\n  public async prepare(): Promise<void> {\n    if (!await fs.pathExists(path.join(this.repoRoot, 'package.json')) || !await fs.pathExists(path.join(this.repoRoot, 'yarn.lock'))) {\n      throw new Error(`${this.repoRoot}: does not look like the repository root`);\n    }\n\n    process.env.REPO_ROOT = this.repoRoot;\n    process.env.REPO_PACKAGE_MAP = await writePackageMap(this.repoRoot);\n    addToShellPath(path.resolve(__dirname, 'repo-tools'));\n  }\n\n  public async cleanup(): Promise<void> {\n  }\n}\n\nexport class RepoPackageSource implements IPackageSource {\n  private readonly repoRoot: string;\n\n  constructor() {\n    this.repoRoot = process.env.REPO_ROOT as string;\n  }\n\n  public async makeCliAvailable() {\n    addToShellPath(path.join(this.repoRoot, 'packages', 'aws-cdk', 'bin'));\n  }\n\n  public assertJsiiPackagesAvailable() {\n    throw new Error('jsii client packages are not available when using REPO source');\n  }\n\n  public async initializeDotnetPackages() {\n  }\n\n  public majorVersion() {\n    const releaseJson = fs.readJsonSync(path.resolve(this.repoRoot, 'release.json'));\n    return releaseJson.majorVersion;\n  }\n\n  public requestedCliVersion(): string {\n    return '*';\n  }\n\n  public requestedFrameworkVersion(): string {\n    return '*';\n  }\n\n  public requestedAlphaVersion(): string {\n    return '*';\n  }\n}\n\nasync function writePackageMap(repoRoot: string): Promise<string> {\n  const packages = await findYarnPackages(repoRoot);\n  const fileName = path.join(os.tmpdir(), 'package-map.json');\n  await fs.writeJson(fileName, packages);\n  return fileName;\n}\n\n/**\n * Cache monorepo discovery results, we only want to do this once per run\n */\nconst YARN_MONOREPO_CACHE: Record<string, any> = {};\n\n/**\n * Return a { name -> directory } packages found in a Yarn monorepo\n *\n * Cached in YARN_MONOREPO_CACHE.\n */\nexport async function findYarnPackages(root: string): Promise<Record<string, string>> {\n  if (!(root in YARN_MONOREPO_CACHE)) {\n    const outputDataString: string = JSON.parse(await shell(['yarn', 'workspaces', '--json', 'info'], {\n      captureStderr: false,\n      cwd: root,\n      show: 'error',\n    })).data;\n    const output: YarnWorkspacesOutput = JSON.parse(outputDataString);\n\n    const ret: Record<string, string> = {};\n    for (const [k, v] of Object.entries(output)) {\n      ret[k] = path.join(root, v.location);\n    }\n    YARN_MONOREPO_CACHE[root] = ret;\n  }\n  return YARN_MONOREPO_CACHE[root];\n}\n\n/**\n * Find the root directory of the repo from the current directory\n */\nexport async function autoFindRoot() {\n  const found = findUp('release.json');\n  if (!found) {\n    throw new Error(`Could not determine repository root: 'release.json' not found from ${process.cwd()}`);\n  }\n  return path.dirname(found);\n}\n\ntype YarnWorkspacesOutput = Record<string, { location: string }>;\n"]}

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

@@ -7,9 +7,10 @@ import { shell, addToShellPath } from '../shell';
 
 export class RepoPackageSourceSetup implements IPackageSourceSetup {
   readonly name = 'repo';
-  readonly description = `repo(${this.repoRoot})`;
+  readonly description: string;
 
   constructor(private readonly repoRoot: string) {
+    this.description = `repo(${this.repoRoot})`;
   }
 
   public async prepare(): Promise<void> {
@@ -75,10 +76,10 @@ async function writePackageMap(repoRoot: string): Promise<string> {
 const YARN_MONOREPO_CACHE: Record<string, any> = {};
 
 /**
-  * Return a { name -> directory } packages found in a Yarn monorepo
-  *
-  * Cached in YARN_MONOREPO_CACHE.
-  */
+ * 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'], {

package/lib/proxy.d.ts

@@ -0,0 +1,13 @@
+import * as mockttp from 'mockttp';
+import { CompletedRequest } from 'mockttp';
+export declare function startProxyServer(certDirRoot?: string): Promise<ProxyServer>;
+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 declare function awsActionsFromRequests(requests: CompletedRequest[]): string[];

package/lib/proxy.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startProxyServer = startProxyServer;
+exports.awsActionsFromRequests = awsActionsFromRequests;
+const fs_1 = require("fs");
+const querystring = require("node:querystring");
+const os = require("os");
+const path = require("path");
+const mockttp = require("mockttp");
+async function startProxyServer(certDirRoot) {
+    const certDir = await fs_1.promises.mkdtemp(path.join(certDirRoot !== null && certDirRoot !== void 0 ? 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_1.promises.writeFile(keyPath, key);
+    await fs_1.promises.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_1.promises.rm(certDir, { recursive: true, force: true });
+        },
+    };
+}
+function awsActionsFromRequests(requests) {
+    return [...new Set(requests
+            .map(req => req.body.buffer.toString('utf-8'))
+            .map(body => querystring.decode(body))
+            .map(x => x.Action)
+            .filter(action => action != null))];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/proxy.ts

@@ -0,0 +1,64 @@
+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/with-aws.d.ts

@@ -2,6 +2,9 @@ import { AwsClients } from './aws';
 import { TestContext } from './integ-test';
 import { ResourcePool } from './resource-pool';
 import { DisableBootstrapContext } from './with-cdk-app';
+export declare function atmosphereEnabled(): boolean;
+export declare function atmosphereEndpoint(): string;
+export declare function atmospherePool(): string;
 export type AwsContext = {
     readonly aws: AwsClients;
 };

package/lib/with-aws.js

@@ -1,20 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.atmosphereEnabled = atmosphereEnabled;
+exports.atmosphereEndpoint = atmosphereEndpoint;
+exports.atmospherePool = atmospherePool;
 exports.withAws = withAws;
 exports.regionPool = regionPool;
+const cdk_atmosphere_client_1 = require("@cdklabs/cdk-atmosphere-client");
 const aws_1 = require("./aws");
 const resource_pool_1 = require("./resource-pool");
+function atmosphereEnabled() {
+    const enabled = process.env.CDK_INTEG_ATMOSPHERE_ENABLED;
+    return enabled === 'true' || enabled === '1';
+}
+function atmosphereEndpoint() {
+    const value = process.env.CDK_INTEG_ATMOSPHERE_ENDPOINT;
+    if (!value) {
+        throw new Error('CDK_INTEG_ATMOSPHERE_ENDPOINT is not defined');
+    }
+    return value;
+}
+function atmospherePool() {
+    const value = process.env.CDK_INTEG_ATMOSPHERE_POOL;
+    if (!value) {
+        throw new Error('CDK_INTEG_ATMOSPHERE_POOL is not defined');
+    }
+    return value;
+}
 /**
  * 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 });
-    });
+    return async (context) => {
+        if (atmosphereEnabled()) {
+            const atmosphere = new cdk_atmosphere_client_1.AtmosphereClient(atmosphereEndpoint());
+            const allocation = await atmosphere.acquire({ pool: atmospherePool(), requester: context.name });
+            const aws = await aws_1.AwsClients.forIdentity(allocation.environment.region, {
+                accessKeyId: allocation.credentials.accessKeyId,
+                secretAccessKey: allocation.credentials.secretAccessKey,
+                sessionToken: allocation.credentials.sessionToken,
+                accountId: allocation.environment.account,
+            }, context.output);
+            await sanityCheck(aws);
+            let outcome = 'success';
+            try {
+                return await block({ ...context, disableBootstrap, aws });
+            }
+            catch (e) {
+                outcome = 'failure';
+                throw e;
+            }
+            finally {
+                await atmosphere.release(allocation.id, outcome);
+            }
+        }
+        else {
+            return 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() {
@@ -57,4 +105,4 @@ async function sanityCheck(aws) {
     }
 }
 let sanityChecked;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-aws.js","sourceRoot":"","sources":["with-aws.ts"],"names":[],"mappings":"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","sourcesContent":["import { AtmosphereClient } from '@cdklabs/cdk-atmosphere-client';\nimport { AwsClients } from './aws';\nimport { TestContext } from './integ-test';\nimport { ResourcePool } from './resource-pool';\nimport { DisableBootstrapContext } from './with-cdk-app';\n\nexport function atmosphereEnabled(): boolean {\n  const enabled = process.env.CDK_INTEG_ATMOSPHERE_ENABLED;\n  return enabled === 'true' || enabled === '1';\n}\n\nexport function atmosphereEndpoint(): string {\n  const value = process.env.CDK_INTEG_ATMOSPHERE_ENDPOINT;\n  if (!value) {\n    throw new Error('CDK_INTEG_ATMOSPHERE_ENDPOINT is not defined');\n  }\n  return value;\n}\n\nexport function atmospherePool() {\n  const value = process.env.CDK_INTEG_ATMOSPHERE_POOL;\n  if (!value) {\n    throw new Error('CDK_INTEG_ATMOSPHERE_POOL is not defined');\n  }\n  return value;\n}\n\nexport type AwsContext = { readonly aws: AwsClients };\n\n/**\n * Higher order function to execute a block with an AWS client setup\n *\n * Allocate the next region from the REGION pool and dispose it afterwards.\n */\nexport function withAws<A extends TestContext>(\n  block: (context: A & AwsContext & DisableBootstrapContext) => Promise<void>,\n  disableBootstrap: boolean = false,\n): (context: A) => Promise<void> {\n  return async (context: A) => {\n    if (atmosphereEnabled()) {\n      const atmosphere = new AtmosphereClient(atmosphereEndpoint());\n      const allocation = await atmosphere.acquire({ pool: atmospherePool(), requester: context.name });\n      const aws = await AwsClients.forIdentity(allocation.environment.region, {\n        accessKeyId: allocation.credentials.accessKeyId,\n        secretAccessKey: allocation.credentials.secretAccessKey,\n        sessionToken: allocation.credentials.sessionToken,\n        accountId: allocation.environment.account,\n      }, context.output);\n\n      await sanityCheck(aws);\n\n      let outcome = 'success';\n      try {\n        return await block({ ...context, disableBootstrap, aws });\n      } catch (e: any) {\n        outcome = 'failure';\n        throw e;\n      } finally {\n        await atmosphere.release(allocation.id, outcome);\n      }\n    } else {\n      return regionPool().using(async (region) => {\n        const aws = await AwsClients.forRegion(region, context.output);\n        await sanityCheck(aws);\n\n        return block({ ...context, disableBootstrap, aws });\n      });\n    }\n  };\n}\n\nlet _regionPool: undefined | ResourcePool;\nexport function regionPool(): ResourcePool {\n  if (_regionPool !== undefined) {\n    return _regionPool;\n  }\n\n  const REGIONS = process.env.AWS_REGIONS\n    ? process.env.AWS_REGIONS.split(',')\n    : [process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1'];\n\n  // eslint-disable-next-line no-console\n  console.log(`Using regions: ${REGIONS}\\n`);\n\n  _regionPool = ResourcePool.withResources('aws_regions', REGIONS);\n  return _regionPool;\n}\n\n/**\n * Perform a one-time quick sanity check that the AWS clients have properly configured credentials\n *\n * If we don't do this, calls are going to fail and they'll be retried and everything will take\n * forever before the user notices a simple misconfiguration.\n *\n * We can't check for the presence of environment variables since credentials could come from\n * anywhere, so do simple account retrieval.\n *\n * Only do it once per process.\n */\nasync function sanityCheck(aws: AwsClients) {\n  if (sanityChecked === undefined) {\n    try {\n      await aws.account();\n      sanityChecked = true;\n    } catch (e: any) {\n      sanityChecked = false;\n      throw new Error(`AWS credentials probably not configured, got error: ${e.message}`);\n    }\n  }\n  if (!sanityChecked) {\n    throw new Error('AWS credentials probably not configured, see previous error');\n  }\n}\nlet sanityChecked: boolean | undefined;\n"]}

package/lib/with-aws.ts

@@ -1,8 +1,30 @@
+import { AtmosphereClient } from '@cdklabs/cdk-atmosphere-client';
 import { AwsClients } from './aws';
 import { TestContext } from './integ-test';
 import { ResourcePool } from './resource-pool';
 import { DisableBootstrapContext } from './with-cdk-app';
 
+export function atmosphereEnabled(): boolean {
+  const enabled = process.env.CDK_INTEG_ATMOSPHERE_ENABLED;
+  return enabled === 'true' || enabled === '1';
+}
+
+export function atmosphereEndpoint(): string {
+  const value = process.env.CDK_INTEG_ATMOSPHERE_ENDPOINT;
+  if (!value) {
+    throw new Error('CDK_INTEG_ATMOSPHERE_ENDPOINT is not defined');
+  }
+  return value;
+}
+
+export function atmospherePool() {
+  const value = process.env.CDK_INTEG_ATMOSPHERE_POOL;
+  if (!value) {
+    throw new Error('CDK_INTEG_ATMOSPHERE_POOL is not defined');
+  }
+  return value;
+}
+
 export type AwsContext = { readonly aws: AwsClients };
 
 /**
@@ -14,12 +36,37 @@ 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 async (context: A) => {
+    if (atmosphereEnabled()) {
+      const atmosphere = new AtmosphereClient(atmosphereEndpoint());
+      const allocation = await atmosphere.acquire({ pool: atmospherePool(), requester: context.name });
+      const aws = await AwsClients.forIdentity(allocation.environment.region, {
+        accessKeyId: allocation.credentials.accessKeyId,
+        secretAccessKey: allocation.credentials.secretAccessKey,
+        sessionToken: allocation.credentials.sessionToken,
+        accountId: allocation.environment.account,
+      }, context.output);
+
+      await sanityCheck(aws);
 
-    return block({ ...context, disableBootstrap, aws });
-  });
+      let outcome = 'success';
+      try {
+        return await block({ ...context, disableBootstrap, aws });
+      } catch (e: any) {
+        outcome = 'failure';
+        throw e;
+      } finally {
+        await atmosphere.release(allocation.id, outcome);
+      }
+    } else {
+      return regionPool().using(async (region) => {
+        const aws = await AwsClients.forRegion(region, context.output);
+        await sanityCheck(aws);
+
+        return block({ ...context, disableBootstrap, aws });
+      });
+    }
+  };
 }
 
 let _regionPool: undefined | ResourcePool;

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

@@ -18,8 +18,7 @@ export declare function withSpecificCdkApp(appName: string, block: (context: Tes
  * 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>;
+export declare function withCdkMigrateApp(language: string, block: (context: TestFixture) => Promise<void>): (context: TestContext & AwsContext & DisableBootstrapContext) => Promise<void>;
 /**
  * Default test fixture for most (all?) integ tests
  *
@@ -125,6 +124,8 @@ export interface CdkModernBootstrapCommandOptions extends CommonCdkBootstrapComm
      * @default undefined
      */
     readonly usePreviousParameters?: boolean;
+    readonly trust?: string[];
+    readonly untrust?: string[];
 }
 export interface CdkGarbageCollectionCommandOptions {
     /**
@@ -159,6 +160,7 @@ export declare class TestFixture extends ShellHelper {
     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>;
+    cdkDeployCommandLine(stackNames: string | string[], options?: CdkCliOptions, skipStackRename?: boolean): string[];
     cdkSynth(options?: CdkCliOptions): Promise<string>;
     cdkDestroy(stackNames: string | string[], options?: CdkCliOptions): Promise<string>;
     cdkBootstrapLegacy(options: CdkLegacyBootstrapCommandOptions): Promise<string>;
@@ -166,6 +168,16 @@ export declare class TestFixture extends ShellHelper {
     cdkGarbageCollect(options: CdkGarbageCollectionCommandOptions): Promise<string>;
     cdkMigrate(language: string, stackName: string, inputPath?: string, options?: CdkCliOptions): Promise<string>;
     cdk(args: string[], options?: CdkCliOptions): Promise<string>;
+    /**
+     * Return the environment variables with which to execute CDK
+     */
+    cdkShellEnv(): {
+        AWS_REGION: string;
+        AWS_DEFAULT_REGION: string;
+        STACK_NAME_PREFIX: string;
+        PACKAGE_LAYOUT_VERSION: string;
+        CI: string;
+    };
     template(stackName: string): any;
     bootstrapRepoName(): Promise<string>;
     get bootstrapStackName(): string;
@@ -188,6 +200,13 @@ export declare class TestFixture extends ShellHelper {
     private deleteableStacks;
     private sortBootstrapStacksToTheEnd;
 }
+/**
+ * Make sure that the given environment is bootstrapped
+ *
+ * Since we go striping across regions, it's going to suck doing this
+ * by hand so let's just mass-automate it.
+ */
+export declare function ensureBootstrapped(fixture: TestFixture): Promise<void>;
 /**
  * Install the given NPM packages, identified by their names and versions
  *