@aws-cdk-testing/cli-integ 0.0.0

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

@@ -0,0 +1,28 @@
+export interface IPackageSourceSetup {
+    readonly name: string;
+    readonly description: string;
+    prepare(): Promise<void>;
+    cleanup(): Promise<void>;
+}
+export interface IPackageSource {
+    makeCliAvailable(): Promise<void>;
+    assertJsiiPackagesAvailable(): void;
+    majorVersion(): string;
+    initializeDotnetPackages(targetDir: string): Promise<void>;
+    /**
+     * CLI version
+     */
+    requestedCliVersion(): string;
+    /**
+     * Framework version if it's different than the CLI version
+     *
+     * Not all tests will respect this.
+     */
+    requestedFrameworkVersion(): string;
+    /**
+     * Versions of alpha packages if different than the CLI version
+     *
+     * Not all tests will respect this.
+     */
+    requestedAlphaVersion(): string;
+}

package/lib/package-sources/source.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic291cmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsic291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIElQYWNrYWdlU291cmNlU2V0dXAge1xuICByZWFkb25seSBuYW1lOiBzdHJpbmc7XG4gIHJlYWRvbmx5IGRlc2NyaXB0aW9uOiBzdHJpbmc7XG5cbiAgcHJlcGFyZSgpOiBQcm9taXNlPHZvaWQ+O1xuICBjbGVhbnVwKCk6IFByb21pc2U8dm9pZD47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgSVBhY2thZ2VTb3VyY2Uge1xuICBtYWtlQ2xpQXZhaWxhYmxlKCk6IFByb21pc2U8dm9pZD47XG5cbiAgYXNzZXJ0SnNpaVBhY2thZ2VzQXZhaWxhYmxlKCk6IHZvaWQ7XG4gIG1ham9yVmVyc2lvbigpOiBzdHJpbmc7XG5cbiAgaW5pdGlhbGl6ZURvdG5ldFBhY2thZ2VzKHRhcmdldERpcjogc3RyaW5nKTogUHJvbWlzZTx2b2lkPjtcblxuICAvKipcbiAgICogQ0xJIHZlcnNpb25cbiAgICovXG4gIHJlcXVlc3RlZENsaVZlcnNpb24oKTogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBGcmFtZXdvcmsgdmVyc2lvbiBpZiBpdCdzIGRpZmZlcmVudCB0aGFuIHRoZSBDTEkgdmVyc2lvblxuICAgKlxuICAgKiBOb3QgYWxsIHRlc3RzIHdpbGwgcmVzcGVjdCB0aGlzLlxuICAgKi9cbiAgcmVxdWVzdGVkRnJhbWV3b3JrVmVyc2lvbigpOiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIFZlcnNpb25zIG9mIGFscGhhIHBhY2thZ2VzIGlmIGRpZmZlcmVudCB0aGFuIHRoZSBDTEkgdmVyc2lvblxuICAgKlxuICAgKiBOb3QgYWxsIHRlc3RzIHdpbGwgcmVzcGVjdCB0aGlzLlxuICAgKi9cbiAgcmVxdWVzdGVkQWxwaGFWZXJzaW9uKCk6IHN0cmluZztcbn1cbiJdfQ==

package/lib/package-sources/source.ts

@@ -0,0 +1,35 @@
+export interface IPackageSourceSetup {
+  readonly name: string;
+  readonly description: string;
+
+  prepare(): Promise<void>;
+  cleanup(): Promise<void>;
+}
+
+export interface IPackageSource {
+  makeCliAvailable(): Promise<void>;
+
+  assertJsiiPackagesAvailable(): void;
+  majorVersion(): string;
+
+  initializeDotnetPackages(targetDir: string): Promise<void>;
+
+  /**
+   * CLI version
+   */
+  requestedCliVersion(): string;
+
+  /**
+   * Framework version if it's different than the CLI version
+   *
+   * Not all tests will respect this.
+   */
+  requestedFrameworkVersion(): string;
+
+  /**
+   * Versions of alpha packages if different than the CLI version
+   *
+   * Not all tests will respect this.
+   */
+  requestedAlphaVersion(): string;
+}

package/lib/package-sources/subprocess.d.ts

@@ -0,0 +1,3 @@
+import { IPackageSourceSetup, IPackageSource } from './source';
+export declare function serializeForSubprocess(s: IPackageSourceSetup): void;
+export declare function packageSourceInSubprocess(): IPackageSource;

package/lib/package-sources/subprocess.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeForSubprocess = serializeForSubprocess;
+exports.packageSourceInSubprocess = packageSourceInSubprocess;
+const release_source_1 = require("./release-source");
+const repo_source_1 = require("./repo-source");
+function serializeForSubprocess(s) {
+    process.env.PACKAGE_SOURCE = s.name;
+}
+function packageSourceInSubprocess() {
+    switch (process.env.PACKAGE_SOURCE) {
+        case 'repo': return new repo_source_1.RepoPackageSource();
+        case 'release': return new release_source_1.ReleasePackageSource();
+        default: throw new Error(`Unrecognized package source: ${process.env.PACKAGE_SOURCE}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3VicHJvY2Vzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInN1YnByb2Nlc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFJQSx3REFFQztBQUVELDhEQU1DO0FBZEQscURBQXdEO0FBQ3hELCtDQUFrRDtBQUdsRCxTQUFnQixzQkFBc0IsQ0FBQyxDQUFzQjtJQUMzRCxPQUFPLENBQUMsR0FBRyxDQUFDLGNBQWMsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDO0FBQ3RDLENBQUM7QUFFRCxTQUFnQix5QkFBeUI7SUFDdkMsUUFBUSxPQUFPLENBQUMsR0FBRyxDQUFDLGNBQWMsRUFBRSxDQUFDO1FBQ25DLEtBQUssTUFBTSxDQUFDLENBQUMsT0FBTyxJQUFJLCtCQUFpQixFQUFFLENBQUM7UUFDNUMsS0FBSyxTQUFTLENBQUMsQ0FBQyxPQUFPLElBQUkscUNBQW9CLEVBQUUsQ0FBQztRQUNsRCxPQUFPLENBQUMsQ0FBQyxNQUFNLElBQUksS0FBSyxDQUFDLGdDQUFnQyxPQUFPLENBQUMsR0FBRyxDQUFDLGNBQWMsRUFBRSxDQUFDLENBQUM7SUFDekYsQ0FBQztBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZWxlYXNlUGFja2FnZVNvdXJjZSB9IGZyb20gJy4vcmVsZWFzZS1zb3VyY2UnO1xuaW1wb3J0IHsgUmVwb1BhY2thZ2VTb3VyY2UgfSBmcm9tICcuL3JlcG8tc291cmNlJztcbmltcG9ydCB7IElQYWNrYWdlU291cmNlU2V0dXAsIElQYWNrYWdlU291cmNlIH0gZnJvbSAnLi9zb3VyY2UnO1xuXG5leHBvcnQgZnVuY3Rpb24gc2VyaWFsaXplRm9yU3VicHJvY2VzcyhzOiBJUGFja2FnZVNvdXJjZVNldHVwKSB7XG4gIHByb2Nlc3MuZW52LlBBQ0tBR0VfU09VUkNFID0gcy5uYW1lO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gcGFja2FnZVNvdXJjZUluU3VicHJvY2VzcygpOiBJUGFja2FnZVNvdXJjZSB7XG4gIHN3aXRjaCAocHJvY2Vzcy5lbnYuUEFDS0FHRV9TT1VSQ0UpIHtcbiAgICBjYXNlICdyZXBvJzogcmV0dXJuIG5ldyBSZXBvUGFja2FnZVNvdXJjZSgpO1xuICAgIGNhc2UgJ3JlbGVhc2UnOiByZXR1cm4gbmV3IFJlbGVhc2VQYWNrYWdlU291cmNlKCk7XG4gICAgZGVmYXVsdDogdGhyb3cgbmV3IEVycm9yKGBVbnJlY29nbml6ZWQgcGFja2FnZSBzb3VyY2U6ICR7cHJvY2Vzcy5lbnYuUEFDS0FHRV9TT1VSQ0V9YCk7XG4gIH1cbn1cbiJdfQ==

package/lib/package-sources/subprocess.ts

@@ -0,0 +1,15 @@
+import { ReleasePackageSource } from './release-source';
+import { RepoPackageSource } from './repo-source';
+import { IPackageSourceSetup, IPackageSource } from './source';
+
+export function serializeForSubprocess(s: IPackageSourceSetup) {
+  process.env.PACKAGE_SOURCE = s.name;
+}
+
+export function packageSourceInSubprocess(): IPackageSource {
+  switch (process.env.PACKAGE_SOURCE) {
+    case 'repo': return new RepoPackageSource();
+    case 'release': return new ReleasePackageSource();
+    default: throw new Error(`Unrecognized package source: ${process.env.PACKAGE_SOURCE}`);
+  }
+}

package/lib/resource-pool.d.ts

@@ -0,0 +1,50 @@
+/**
+ * A class that holds a pool of resources and gives them out and returns them on-demand
+ *
+ * The resources will be given out front to back, when they are returned
+ * the most recently returned version will be given out again (for best
+ * cache coherency).
+ *
+ * If there are multiple consumers waiting for a resource, consumers are serviced
+ * in FIFO order for most fairness.
+ */
+export declare class ResourcePool<A extends string = string> {
+    private readonly pool;
+    static withResources<A extends string>(name: string, resources: A[]): ResourcePool<A>;
+    private readonly resources;
+    private readonly mutexes;
+    private readonly locks;
+    private constructor();
+    /**
+     * Take one value from the resource pool
+     *
+     * If no such value is currently available, wait until it is.
+     */
+    take(): Promise<ILease<A>>;
+    /**
+     * Execute a block using a single resource from the pool
+     */
+    using<B>(block: (x: A) => B | Promise<B>): Promise<B>;
+    private tryObtainLease;
+    private makeLease;
+    /**
+     * When a value is returned:
+     *
+     * - If someone's waiting for it, give it to them
+     * - Otherwise put it back into the pool
+     */
+    private returnValue;
+}
+/**
+ * A single value taken from the pool
+ */
+export interface ILease<A> {
+    /**
+     * The value obtained by the lease
+     */
+    readonly value: A;
+    /**
+     * Return the leased value to the pool
+     */
+    dispose(): Promise<void>;
+}

package/lib/resource-pool.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourcePool = void 0;
+const xpmutex_1 = require("./xpmutex");
+/**
+ * A class that holds a pool of resources and gives them out and returns them on-demand
+ *
+ * The resources will be given out front to back, when they are returned
+ * the most recently returned version will be given out again (for best
+ * cache coherency).
+ *
+ * If there are multiple consumers waiting for a resource, consumers are serviced
+ * in FIFO order for most fairness.
+ */
+class ResourcePool {
+    static withResources(name, resources) {
+        const pool = xpmutex_1.XpMutexPool.fromName(name);
+        return new ResourcePool(pool, resources);
+    }
+    constructor(pool, resources) {
+        this.pool = pool;
+        this.mutexes = {};
+        this.locks = {};
+        if (resources.length === 0) {
+            throw new Error('Must have at least one resource in the pool');
+        }
+        // Shuffle to reduce contention
+        resources = [...resources];
+        fisherYatesShuffle(resources);
+        this.resources = resources;
+        for (const res of resources) {
+            this.mutexes[res] = this.pool.mutex(res);
+        }
+    }
+    /**
+     * Take one value from the resource pool
+     *
+     * If no such value is currently available, wait until it is.
+     */
+    async take() {
+        while (true) {
+            // Start a wait on the unlock now -- if the unlock signal comes after
+            // we try to acquire but before we start the wait, we might miss it.
+            //
+            // (The timeout is in case the unlock signal doesn't come for whatever reason).
+            const wait = this.pool.awaitUnlock(10000);
+            // Try all mutexes, we might need to reacquire an expired lock
+            for (const res of this.resources) {
+                const lease = await this.tryObtainLease(res);
+                if (lease) {
+                    // Ignore the wait (count as handled)
+                    wait.then(() => { }, () => { });
+                    return lease;
+                }
+            }
+            // None available, wait until one gets unlocked then try again
+            await wait;
+        }
+    }
+    /**
+     * Execute a block using a single resource from the pool
+     */
+    async using(block) {
+        const lease = await this.take();
+        try {
+            return await block(lease.value);
+        }
+        finally {
+            await lease.dispose();
+        }
+    }
+    async tryObtainLease(value) {
+        const lock = await this.mutexes[value].tryAcquire();
+        if (!lock) {
+            return undefined;
+        }
+        this.locks[value] = lock;
+        return this.makeLease(value);
+    }
+    makeLease(value) {
+        let disposed = false;
+        return {
+            value,
+            dispose: async () => {
+                if (disposed) {
+                    throw new Error('Calling dispose() on an already-disposed lease.');
+                }
+                disposed = true;
+                return this.returnValue(value);
+            },
+        };
+    }
+    /**
+     * When a value is returned:
+     *
+     * - If someone's waiting for it, give it to them
+     * - Otherwise put it back into the pool
+     */
+    async returnValue(value) {
+        const lock = this.locks[value];
+        delete this.locks[value];
+        await (lock === null || lock === void 0 ? void 0 : lock.release());
+    }
+}
+exports.ResourcePool = ResourcePool;
+/**
+ * Shuffle an array in-place
+ */
+function fisherYatesShuffle(xs) {
+    for (let i = xs.length - 1; i >= 1; i--) {
+        const j = Math.floor(Math.random() * i);
+        const h = xs[j];
+        xs[j] = xs[i];
+        xs[i] = h;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource-pool.js","sourceRoot":"","sources":["resource-pool.ts"],"names":[],"mappings":"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","sourcesContent":["import { ILock, XpMutex, XpMutexPool } from './xpmutex';\n\n/**\n * A class that holds a pool of resources and gives them out and returns them on-demand\n *\n * The resources will be given out front to back, when they are returned\n * the most recently returned version will be given out again (for best\n * cache coherency).\n *\n * If there are multiple consumers waiting for a resource, consumers are serviced\n * in FIFO order for most fairness.\n */\nexport class ResourcePool<A extends string=string> {\n  public static withResources<A extends string>(name: string, resources: A[]) {\n    const pool = XpMutexPool.fromName(name);\n    return new ResourcePool(pool, resources);\n  }\n\n  private readonly resources: ReadonlyArray<A>;\n  private readonly mutexes: Record<string, XpMutex> = {};\n  private readonly locks: Record<string, ILock | undefined> = {};\n\n  private constructor(private readonly pool: XpMutexPool, resources: A[]) {\n    if (resources.length === 0) {\n      throw new Error('Must have at least one resource in the pool');\n    }\n\n    // Shuffle to reduce contention\n    resources = [...resources];\n    fisherYatesShuffle(resources);\n    this.resources = resources;\n\n    for (const res of resources) {\n      this.mutexes[res] = this.pool.mutex(res);\n    }\n  }\n\n  /**\n   * Take one value from the resource pool\n   *\n   * If no such value is currently available, wait until it is.\n   */\n  public async take(): Promise<ILease<A>> {\n    while (true) {\n      // Start a wait on the unlock now -- if the unlock signal comes after\n      // we try to acquire but before we start the wait, we might miss it.\n      //\n      // (The timeout is in case the unlock signal doesn't come for whatever reason).\n      const wait = this.pool.awaitUnlock(10_000);\n\n      // Try all mutexes, we might need to reacquire an expired lock\n      for (const res of this.resources) {\n        const lease = await this.tryObtainLease(res);\n        if (lease) {\n          // Ignore the wait (count as handled)\n          wait.then(() => {}, () => {});\n          return lease;\n        }\n      }\n\n      // None available, wait until one gets unlocked then try again\n      await wait;\n    }\n  }\n\n  /**\n   * Execute a block using a single resource from the pool\n   */\n  public async using<B>(block: (x: A) => B | Promise<B>): Promise<B> {\n    const lease = await this.take();\n    try {\n      return await block(lease.value);\n    } finally {\n      await lease.dispose();\n    }\n  }\n\n  private async tryObtainLease(value: A) {\n    const lock = await this.mutexes[value].tryAcquire();\n    if (!lock) {\n      return undefined;\n    }\n\n    this.locks[value] = lock;\n    return this.makeLease(value);\n  }\n\n  private makeLease(value: A): ILease<A> {\n    let disposed = false;\n    return {\n      value,\n      dispose: async () => {\n        if (disposed) {\n          throw new Error('Calling dispose() on an already-disposed lease.');\n        }\n        disposed = true;\n        return this.returnValue(value);\n      },\n    };\n  }\n\n  /**\n   * When a value is returned:\n   *\n   * - If someone's waiting for it, give it to them\n   * - Otherwise put it back into the pool\n   */\n  private async returnValue(value: string) {\n    const lock = this.locks[value];\n    delete this.locks[value];\n    await lock?.release();\n  }\n}\n\n/**\n * A single value taken from the pool\n */\nexport interface ILease<A> {\n  /**\n   * The value obtained by the lease\n   */\n  readonly value: A;\n\n  /**\n   * Return the leased value to the pool\n   */\n  dispose(): Promise<void>;\n}\n\n/**\n * Shuffle an array in-place\n */\nfunction fisherYatesShuffle<A>(xs: A[]) {\n  for (let i = xs.length - 1; i >= 1; i--) {\n    const j = Math.floor(Math.random() * i);\n    const h = xs[j];\n    xs[j] = xs[i];\n    xs[i] = h;\n  }\n}\n"]}

package/lib/resource-pool.ts

@@ -0,0 +1,140 @@
+import { ILock, XpMutex, XpMutexPool } from './xpmutex';
+
+/**
+ * A class that holds a pool of resources and gives them out and returns them on-demand
+ *
+ * The resources will be given out front to back, when they are returned
+ * the most recently returned version will be given out again (for best
+ * cache coherency).
+ *
+ * If there are multiple consumers waiting for a resource, consumers are serviced
+ * in FIFO order for most fairness.
+ */
+export class ResourcePool<A extends string=string> {
+  public static withResources<A extends string>(name: string, resources: A[]) {
+    const pool = XpMutexPool.fromName(name);
+    return new ResourcePool(pool, resources);
+  }
+
+  private readonly resources: ReadonlyArray<A>;
+  private readonly mutexes: Record<string, XpMutex> = {};
+  private readonly locks: Record<string, ILock | undefined> = {};
+
+  private constructor(private readonly pool: XpMutexPool, resources: A[]) {
+    if (resources.length === 0) {
+      throw new Error('Must have at least one resource in the pool');
+    }
+
+    // Shuffle to reduce contention
+    resources = [...resources];
+    fisherYatesShuffle(resources);
+    this.resources = resources;
+
+    for (const res of resources) {
+      this.mutexes[res] = this.pool.mutex(res);
+    }
+  }
+
+  /**
+   * Take one value from the resource pool
+   *
+   * If no such value is currently available, wait until it is.
+   */
+  public async take(): Promise<ILease<A>> {
+    while (true) {
+      // Start a wait on the unlock now -- if the unlock signal comes after
+      // we try to acquire but before we start the wait, we might miss it.
+      //
+      // (The timeout is in case the unlock signal doesn't come for whatever reason).
+      const wait = this.pool.awaitUnlock(10_000);
+
+      // Try all mutexes, we might need to reacquire an expired lock
+      for (const res of this.resources) {
+        const lease = await this.tryObtainLease(res);
+        if (lease) {
+          // Ignore the wait (count as handled)
+          wait.then(() => {}, () => {});
+          return lease;
+        }
+      }
+
+      // None available, wait until one gets unlocked then try again
+      await wait;
+    }
+  }
+
+  /**
+   * Execute a block using a single resource from the pool
+   */
+  public async using<B>(block: (x: A) => B | Promise<B>): Promise<B> {
+    const lease = await this.take();
+    try {
+      return await block(lease.value);
+    } finally {
+      await lease.dispose();
+    }
+  }
+
+  private async tryObtainLease(value: A) {
+    const lock = await this.mutexes[value].tryAcquire();
+    if (!lock) {
+      return undefined;
+    }
+
+    this.locks[value] = lock;
+    return this.makeLease(value);
+  }
+
+  private makeLease(value: A): ILease<A> {
+    let disposed = false;
+    return {
+      value,
+      dispose: async () => {
+        if (disposed) {
+          throw new Error('Calling dispose() on an already-disposed lease.');
+        }
+        disposed = true;
+        return this.returnValue(value);
+      },
+    };
+  }
+
+  /**
+   * When a value is returned:
+   *
+   * - If someone's waiting for it, give it to them
+   * - Otherwise put it back into the pool
+   */
+  private async returnValue(value: string) {
+    const lock = this.locks[value];
+    delete this.locks[value];
+    await lock?.release();
+  }
+}
+
+/**
+ * A single value taken from the pool
+ */
+export interface ILease<A> {
+  /**
+   * The value obtained by the lease
+   */
+  readonly value: A;
+
+  /**
+   * Return the leased value to the pool
+   */
+  dispose(): Promise<void>;
+}
+
+/**
+ * Shuffle an array in-place
+ */
+function fisherYatesShuffle<A>(xs: A[]) {
+  for (let i = xs.length - 1; i >= 1; i--) {
+    const j = Math.floor(Math.random() * i);
+    const h = xs[j];
+    xs[j] = xs[i];
+    xs[i] = h;
+  }
+}

package/lib/resources.d.ts

@@ -0,0 +1 @@
+export declare const RESOURCES_DIR: string;

package/lib/resources.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESOURCES_DIR = void 0;
+const path = require("path");
+exports.RESOURCES_DIR = path.resolve(__dirname, '..', 'resources');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb3VyY2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsicmVzb3VyY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDZCQUE2QjtBQUVoQixRQUFBLGFBQWEsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsRUFBRSxJQUFJLEVBQUUsV0FBVyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBwYXRoIGZyb20gJ3BhdGgnO1xuXG5leHBvcnQgY29uc3QgUkVTT1VSQ0VTX0RJUiA9IHBhdGgucmVzb2x2ZShfX2Rpcm5hbWUsICcuLicsICdyZXNvdXJjZXMnKTtcblxuIl19

package/lib/resources.ts

@@ -0,0 +1,4 @@
+import * as path from 'path';
+
+export const RESOURCES_DIR = path.resolve(__dirname, '..', 'resources');
+

package/lib/shell.d.ts

@@ -0,0 +1,56 @@
+import * as child_process from 'child_process';
+import { TestContext } from './integ-test';
+import { TemporaryDirectoryContext } from './with-temporary-directory';
+/**
+ * A shell command that does what you want
+ *
+ * Is platform-aware, handles errors nicely.
+ */
+export declare function shell(command: string[], options?: ShellOptions): Promise<string>;
+export interface ShellOptions extends child_process.SpawnOptions {
+    /**
+     * Properties to add to 'env'
+     */
+    readonly modEnv?: Record<string, string>;
+    /**
+     * Don't fail when exiting with an error
+     *
+     * @default false
+     */
+    readonly allowErrExit?: boolean;
+    /**
+     * Whether to capture stderr
+     *
+     * @default true
+     */
+    readonly captureStderr?: boolean;
+    /**
+     * Pass output here
+     */
+    readonly outputs?: NodeJS.WritableStream[];
+    /**
+     * Only return stderr. For example, this is used to validate
+     * that when CI=true, all logs are sent to stdout.
+     *
+     * @default false
+     */
+    readonly onlyStderr?: boolean;
+    /**
+     * Don't log to stdout
+     *
+     * @default always
+     */
+    readonly show?: 'always' | 'never' | 'error';
+}
+export declare class ShellHelper {
+    private readonly _cwd;
+    private readonly _output;
+    static fromContext(context: TestContext & TemporaryDirectoryContext): ShellHelper;
+    constructor(_cwd: string, _output: NodeJS.WritableStream);
+    shell(command: string[], options?: Omit<ShellOptions, 'cwd' | 'outputs'>): Promise<string>;
+}
+/**
+ * rm -rf reimplementation, don't want to depend on an NPM package for this
+ */
+export declare function rimraf(fsPath: string): void;
+export declare function addToShellPath(x: string): void;

package/lib/shell.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShellHelper = void 0;
+exports.shell = shell;
+exports.rimraf = rimraf;
+exports.addToShellPath = addToShellPath;
+const child_process = require("child_process");
+const fs = require("fs");
+const path = require("path");
+/**
+ * A shell command that does what you want
+ *
+ * Is platform-aware, handles errors nicely.
+ */
+async function shell(command, options = {}) {
+    var _a, _b;
+    if (options.modEnv && options.env) {
+        throw new Error('Use either env or modEnv but not both');
+    }
+    const outputs = new Set(options.outputs);
+    const writeToOutputs = (x) => {
+        for (const outputStream of outputs) {
+            outputStream.write(x);
+        }
+    };
+    // Always output the command
+    writeToOutputs(`💻 ${command.join(' ')}\n`);
+    const show = (_a = options.show) !== null && _a !== void 0 ? _a : 'always';
+    if (process.env.VERBOSE) {
+        outputs.add(process.stdout);
+    }
+    const env = (_b = options.env) !== null && _b !== void 0 ? _b : (options.modEnv ? { ...process.env, ...options.modEnv } : process.env);
+    const child = child_process.spawn(command[0], command.slice(1), {
+        ...options,
+        env,
+        // Need this for Windows where we want .cmd and .bat to be found as well.
+        shell: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return new Promise((resolve, reject) => {
+        const stdout = new Array();
+        const stderr = new Array();
+        child.stdout.on('data', chunk => {
+            if (show === 'always') {
+                writeToOutputs(chunk);
+            }
+            stdout.push(chunk);
+        });
+        child.stderr.on('data', chunk => {
+            var _a;
+            if (show === 'always') {
+                writeToOutputs(chunk);
+            }
+            if ((_a = options.captureStderr) !== null && _a !== void 0 ? _a : true) {
+                stderr.push(chunk);
+            }
+        });
+        child.once('error', reject);
+        child.once('close', code => {
+            const stderrOutput = Buffer.concat(stderr).toString('utf-8');
+            const stdoutOutput = Buffer.concat(stdout).toString('utf-8');
+            const out = (options.onlyStderr ? stderrOutput : stdoutOutput + stderrOutput).trim();
+            if (code === 0 || options.allowErrExit) {
+                resolve(out);
+            }
+            else {
+                if (show === 'error') {
+                    writeToOutputs(`${out}\n`);
+                }
+                reject(new Error(`'${command.join(' ')}' exited with error code ${code}.`));
+            }
+        });
+    });
+}
+class ShellHelper {
+    static fromContext(context) {
+        return new ShellHelper(context.integTestDir, context.output);
+    }
+    constructor(_cwd, _output) {
+        this._cwd = _cwd;
+        this._output = _output;
+    }
+    async shell(command, options = {}) {
+        return shell(command, {
+            outputs: [this._output],
+            cwd: this._cwd,
+            ...options,
+        });
+    }
+}
+exports.ShellHelper = ShellHelper;
+/**
+ * rm -rf reimplementation, don't want to depend on an NPM package for this
+ */
+function rimraf(fsPath) {
+    try {
+        const isDir = fs.lstatSync(fsPath).isDirectory();
+        if (isDir) {
+            for (const file of fs.readdirSync(fsPath)) {
+                rimraf(path.join(fsPath, file));
+            }
+            fs.rmdirSync(fsPath);
+        }
+        else {
+            fs.unlinkSync(fsPath);
+        }
+    }
+    catch (e) {
+        // We will survive ENOENT
+        if (e.code !== 'ENOENT') {
+            throw e;
+        }
+    }
+}
+function addToShellPath(x) {
+    var _a, _b;
+    const parts = (_b = (_a = process.env.PATH) === null || _a === void 0 ? void 0 : _a.split(':')) !== null && _b !== void 0 ? _b : [];
+    if (!parts.includes(x)) {
+        parts.unshift(x);
+    }
+    process.env.PATH = parts.join(':');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shell.js","sourceRoot":"","sources":["shell.ts"],"names":[],"mappings":"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","sourcesContent":["import * as child_process from 'child_process';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { TestContext } from './integ-test';\nimport { TemporaryDirectoryContext } from './with-temporary-directory';\n\n/**\n * A shell command that does what you want\n *\n * Is platform-aware, handles errors nicely.\n */\nexport async function shell(command: string[], options: ShellOptions = {}): Promise<string> {\n  if (options.modEnv && options.env) {\n    throw new Error('Use either env or modEnv but not both');\n  }\n\n  const outputs = new Set(options.outputs);\n  const writeToOutputs = (x: string) => {\n    for (const outputStream of outputs) {\n      outputStream.write(x);\n    }\n  };\n\n  // Always output the command\n  writeToOutputs(`💻 ${command.join(' ')}\\n`);\n  const show = options.show ?? 'always';\n\n  if (process.env.VERBOSE) {\n    outputs.add(process.stdout);\n  }\n\n  const env = options.env ?? (options.modEnv ? { ...process.env, ...options.modEnv } : process.env);\n\n  const child = child_process.spawn(command[0], command.slice(1), {\n    ...options,\n    env,\n    // Need this for Windows where we want .cmd and .bat to be found as well.\n    shell: true,\n    stdio: ['ignore', 'pipe', 'pipe'],\n  });\n\n  return new Promise<string>((resolve, reject) => {\n    const stdout = new Array<Buffer>();\n    const stderr = new Array<Buffer>();\n\n    child.stdout!.on('data', chunk => {\n      if (show === 'always') {\n        writeToOutputs(chunk);\n      }\n      stdout.push(chunk);\n    });\n\n    child.stderr!.on('data', chunk => {\n      if (show === 'always') {\n        writeToOutputs(chunk);\n      }\n      if (options.captureStderr ?? true) {\n        stderr.push(chunk);\n      }\n    });\n\n    child.once('error', reject);\n\n    child.once('close', code => {\n      const stderrOutput = Buffer.concat(stderr).toString('utf-8');\n      const stdoutOutput = Buffer.concat(stdout).toString('utf-8');\n      const out = (options.onlyStderr ? stderrOutput : stdoutOutput + stderrOutput).trim();\n      if (code === 0 || options.allowErrExit) {\n        resolve(out);\n      } else {\n        if (show === 'error') {\n          writeToOutputs(`${out}\\n`);\n        }\n        reject(new Error(`'${command.join(' ')}' exited with error code ${code}.`));\n      }\n    });\n  });\n}\n\nexport interface ShellOptions extends child_process.SpawnOptions {\n  /**\n   * Properties to add to 'env'\n   */\n  readonly modEnv?: Record<string, string>;\n\n  /**\n   * Don't fail when exiting with an error\n   *\n   * @default false\n   */\n  readonly allowErrExit?: boolean;\n\n  /**\n   * Whether to capture stderr\n   *\n   * @default true\n   */\n  readonly captureStderr?: boolean;\n\n  /**\n   * Pass output here\n   */\n  readonly outputs?: NodeJS.WritableStream[];\n\n  /**\n   * Only return stderr. For example, this is used to validate\n   * that when CI=true, all logs are sent to stdout.\n   *\n   * @default false\n   */\n  readonly onlyStderr?: boolean;\n\n  /**\n   * Don't log to stdout\n   *\n   * @default always\n   */\n  readonly show?: 'always' | 'never' | 'error';\n}\n\nexport class ShellHelper {\n  public static fromContext(context: TestContext & TemporaryDirectoryContext) {\n    return new ShellHelper(context.integTestDir, context.output);\n  }\n\n  constructor(\n    private readonly _cwd: string,\n    private readonly _output: NodeJS.WritableStream) { }\n\n  public async shell(command: string[], options: Omit<ShellOptions, 'cwd' | 'outputs'> = {}): Promise<string> {\n    return shell(command, {\n      outputs: [this._output],\n      cwd: this._cwd,\n      ...options,\n    });\n  }\n}\n\n/**\n * rm -rf reimplementation, don't want to depend on an NPM package for this\n */\nexport function rimraf(fsPath: string) {\n  try {\n    const isDir = fs.lstatSync(fsPath).isDirectory();\n\n    if (isDir) {\n      for (const file of fs.readdirSync(fsPath)) {\n        rimraf(path.join(fsPath, file));\n      }\n      fs.rmdirSync(fsPath);\n    } else {\n      fs.unlinkSync(fsPath);\n    }\n  } catch (e: any) {\n    // We will survive ENOENT\n    if (e.code !== 'ENOENT') { throw e; }\n  }\n}\n\nexport function addToShellPath(x: string) {\n  const parts = process.env.PATH?.split(':') ?? [];\n\n  if (!parts.includes(x)) {\n    parts.unshift(x);\n  }\n\n  process.env.PATH = parts.join(':');\n}\n"]}