@aws-cdk-testing/cli-integ 3.5.0 → 3.7.0

package/lib/integ-test.js

@@ -28,11 +28,12 @@ function integTest(name, callback, timeoutMillis) {
         output.write('================================================================\n');
         const now = Date.now();
         process.stderr.write(`[INTEG TEST::${name}] Starting (pid ${process.pid})...\n`);
+        maybePrintMemoryUsage(name);
         try {
             if (FAIL_FAST && failed) {
                 throw new Error('FAIL_FAST requested and currently failing. Stopping test early.');
             }
-            return await callback({
+            const ret = await callback({
                 output,
                 randomString: randomString(),
                 name,
@@ -40,12 +41,15 @@ function integTest(name, callback, timeoutMillis) {
                     output.write(`${s}\n`);
                 },
             });
+            await writeLog(name, true, output.toString());
+            return ret;
         }
         catch (e) {
-            failed = true;
             // Print the buffered output, only if the test fails.
+            failed = true;
             output.write(e.message);
             output.write(e.stack);
+            await writeLog(name, false, output.toString());
             process.stderr.write(`[INTEG TEST::${name}] Failed: ${e}\n`);
             const isGitHub = !!process.env.GITHUB_RUN_ID;
             if (isGitHub) {
@@ -79,14 +83,65 @@ function integTest(name, callback, timeoutMillis) {
         finally {
             const duration = Date.now() - now;
             process.stderr.write(`[INTEG TEST::${name}] Done (${duration} ms).\n`);
+            maybePrintMemoryUsage(name);
         }
     }, timeoutMillis);
 }
 function shouldSkip(testName) {
     return SKIP_TESTS.includes(testName);
 }
+function maybePrintMemoryUsage(testName) {
+    if (process.env.INTEG_MEMORY_DEBUG !== 'true') {
+        return;
+    }
+    const memoryUsage = process.memoryUsage();
+    const report = {};
+    for (const [key, value] of Object.entries(memoryUsage)) {
+        report[key] = `${Math.round(value / 1024 / 1024)} MB`;
+    }
+    process.stderr.write(`[INTEG TEST::${testName}] Memory Usage: ${JSON.stringify(report)}`);
+}
 function randomString() {
     // Crazy
     return Math.random().toString(36).replace(/[^a-z0-9]+/g, '');
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"integ-test.js","sourceRoot":"","sources":["integ-test.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { MemoryStream } from './corking';\n\nconst SKIP_TESTS = fs.readFileSync(path.join(__dirname, '..', 'skip-tests.txt'), { encoding: 'utf-8' })\n  .split('\\n')\n  .map(x => x.trim())\n  .filter(x => x && !x.startsWith('#'));\n\nif (SKIP_TESTS.length > 0) {\n  process.stderr.write(`ℹ️ Skipping tests: ${JSON.stringify(SKIP_TESTS)}\\n`);\n}\n\n// Whether we want to stop after the first failure, for quicker debugging (hopefully).\nconst FAIL_FAST = process.env.FAIL_FAST === 'true';\n\n// Keep track of whether the suite has failed. If so, we stop running.\nlet failed = false;\n\nexport interface TestContext {\n  readonly randomString: string;\n  readonly name: string;\n  readonly output: NodeJS.WritableStream;\n  log(s: string): void;\n}\n\n/**\n * A wrapper for jest's 'test' which takes regression-disabled tests into account and prints a banner\n */\nexport function integTest(\n  name: string,\n  callback: (context: TestContext) => Promise<void>,\n  timeoutMillis?: number,\n): void {\n  const runner = shouldSkip(name) ? test.skip : test;\n\n  runner(name, async () => {\n    const output = new MemoryStream();\n\n    output.write('================================================================\\n');\n    output.write(`${name}\\n`);\n    output.write('================================================================\\n');\n\n    const now = Date.now();\n    process.stderr.write(`[INTEG TEST::${name}] Starting (pid ${process.pid})...\\n`);\n    try {\n      if (FAIL_FAST && failed) {\n        throw new Error('FAIL_FAST requested and currently failing. Stopping test early.');\n      }\n\n      return await callback({\n        output,\n        randomString: randomString(),\n        name,\n        log(s: string) {\n          output.write(`${s}\\n`);\n        },\n      });\n    } catch (e: any) {\n      failed = true;\n\n      // Print the buffered output, only if the test fails.\n      output.write(e.message);\n      output.write(e.stack);\n      process.stderr.write(`[INTEG TEST::${name}] Failed: ${e}\\n`);\n\n      const isGitHub = !!process.env.GITHUB_RUN_ID;\n\n      if (isGitHub) {\n        // GitHub Actions compatible output formatting\n        // https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/workflow-commands-for-github-actions#setting-an-error-message\n        let written = process.stderr.write(`::error title=Failed ${name}::${e.message}\\n`);\n        if (!written) {\n          // Wait for drain\n          await new Promise((ok) => process.stderr.once('drain', ok));\n        }\n\n        // Print output only if the test fails. Use 'console.log' so the output is buffered by\n        // jest and prints without a stack trace (if verbose: false).\n        written = process.stdout.write([\n          `::group::Failure details: ${name} (click to expand)\\n`,\n          `${output.buffer().toString()}\\n`,\n          '::endgroup::\\n',\n        ].join(''));\n        if (!written) {\n          // Wait for drain\n          await new Promise((ok) => process.stdout.once('drain', ok));\n        }\n      } else {\n        // Use 'console.log' so the output is buffered by\n        // jest and prints without a stack trace (if verbose: false).\n        // eslint-disable-next-line no-console\n        console.log(output.buffer().toString());\n      }\n      throw e;\n    } finally {\n      const duration = Date.now() - now;\n      process.stderr.write(`[INTEG TEST::${name}] Done (${duration} ms).\\n`);\n    }\n  }, timeoutMillis);\n}\n\nfunction shouldSkip(testName: string) {\n  return SKIP_TESTS.includes(testName);\n}\n\nexport function randomString() {\n  // Crazy\n  return Math.random().toString(36).replace(/[^a-z0-9]+/g, '');\n}\n"]}
+/**
+ * Write log files
+ *
+ * Write a text log to `${INTEG_LOGS}/[FAILED-]description-of-test.txt`, and a single
+ * line of a Markdown table to `${INTEG_LOGS}/md/1-description-of-test.md`.
+ *
+ * The latter are designed to be globcatted to $GITHUB_STEP_SUMMARY after tests
+ * (we don't write there directly to avoid concurrency issues with multiple processes
+ * reading and mutating the same file).
+ *
+ * We do use `atomicWrite` to write files -- it's only necessary for the header file,
+ * which gets overwritten by every test, just to make sure it properly exists (shouldn't
+ * end up empty or with interleaved contents). The other writes are not
+ * contended and don't need to be atomic, but the function is just ergonomic to use.
+ */
+async function writeLog(testName, success, output) {
+    if (process.env.INTEG_LOGS) {
+        const slug = slugify(testName);
+        const logFileName = `${process.env.INTEG_LOGS}/${success ? '' : 'FAILED-'}${slug}.txt`;
+        await atomicWrite(logFileName, output);
+        // Sort failures before successes, and the table header before all
+        await atomicWrite(`${process.env.INTEG_LOGS}/md/0-header.md`, [
+            '| Result | Test Name |',
+            '|--------|-----------|',
+        ].map(x => `${x}\n`).join(''));
+        const mdFileName = `${process.env.INTEG_LOGS}/md/${success ? '2' : '1'}-${slug}.md`;
+        const firstColumn = success ? 'pass ✅' : 'fail ❌';
+        await atomicWrite(mdFileName, `| ${firstColumn} | ${testName} |\n`);
+    }
+}
+function slugify(x) {
+    return x.replace(/[^a-zA-Z0-9_,]+/g, '-');
+}
+async function atomicWrite(fileName, contents) {
+    await fs.promises.mkdir(path.dirname(fileName), { recursive: true });
+    const tmp = `${fileName}.${process.pid}`;
+    await fs.promises.writeFile(tmp, contents);
+    await fs.promises.rename(tmp, fileName);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"integ-test.js","sourceRoot":"","sources":["integ-test.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { MemoryStream } from './corking';\n\nconst SKIP_TESTS = fs.readFileSync(path.join(__dirname, '..', 'skip-tests.txt'), { encoding: 'utf-8' })\n  .split('\\n')\n  .map(x => x.trim())\n  .filter(x => x && !x.startsWith('#'));\n\nif (SKIP_TESTS.length > 0) {\n  process.stderr.write(`ℹ️ Skipping tests: ${JSON.stringify(SKIP_TESTS)}\\n`);\n}\n\n// Whether we want to stop after the first failure, for quicker debugging (hopefully).\nconst FAIL_FAST = process.env.FAIL_FAST === 'true';\n\n// Keep track of whether the suite has failed. If so, we stop running.\nlet failed = false;\n\nexport interface TestContext {\n  readonly randomString: string;\n  readonly name: string;\n  readonly output: NodeJS.WritableStream;\n  log(s: string): void;\n}\n\n/**\n * A wrapper for jest's 'test' which takes regression-disabled tests into account and prints a banner\n */\nexport function integTest(\n  name: string,\n  callback: (context: TestContext) => Promise<void>,\n  timeoutMillis?: number,\n): void {\n  const runner = shouldSkip(name) ? test.skip : test;\n\n  runner(name, async () => {\n    const output = new MemoryStream();\n\n    output.write('================================================================\\n');\n    output.write(`${name}\\n`);\n    output.write('================================================================\\n');\n\n    const now = Date.now();\n    process.stderr.write(`[INTEG TEST::${name}] Starting (pid ${process.pid})...\\n`);\n    maybePrintMemoryUsage(name);\n    try {\n      if (FAIL_FAST && failed) {\n        throw new Error('FAIL_FAST requested and currently failing. Stopping test early.');\n      }\n\n      const ret = await callback({\n        output,\n        randomString: randomString(),\n        name,\n        log(s: string) {\n          output.write(`${s}\\n`);\n        },\n      });\n\n      await writeLog(name, true, output.toString());\n\n      return ret;\n    } catch (e: any) {\n      // Print the buffered output, only if the test fails.\n      failed = true;\n\n      output.write(e.message);\n      output.write(e.stack);\n\n      await writeLog(name, false, output.toString());\n      process.stderr.write(`[INTEG TEST::${name}] Failed: ${e}\\n`);\n\n      const isGitHub = !!process.env.GITHUB_RUN_ID;\n\n      if (isGitHub) {\n        // GitHub Actions compatible output formatting\n        // https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/workflow-commands-for-github-actions#setting-an-error-message\n        let written = process.stderr.write(`::error title=Failed ${name}::${e.message}\\n`);\n        if (!written) {\n          // Wait for drain\n          await new Promise((ok) => process.stderr.once('drain', ok));\n        }\n\n        // Print output only if the test fails. Use 'console.log' so the output is buffered by\n        // jest and prints without a stack trace (if verbose: false).\n        written = process.stdout.write([\n          `::group::Failure details: ${name} (click to expand)\\n`,\n          `${output.buffer().toString()}\\n`,\n          '::endgroup::\\n',\n        ].join(''));\n        if (!written) {\n          // Wait for drain\n          await new Promise((ok) => process.stdout.once('drain', ok));\n        }\n      } else {\n        // Use 'console.log' so the output is buffered by\n        // jest and prints without a stack trace (if verbose: false).\n        // eslint-disable-next-line no-console\n        console.log(output.buffer().toString());\n      }\n      throw e;\n    } finally {\n      const duration = Date.now() - now;\n      process.stderr.write(`[INTEG TEST::${name}] Done (${duration} ms).\\n`);\n      maybePrintMemoryUsage(name);\n    }\n  }, timeoutMillis);\n}\n\nfunction shouldSkip(testName: string) {\n  return SKIP_TESTS.includes(testName);\n}\n\nfunction maybePrintMemoryUsage(testName: string) {\n  if (process.env.INTEG_MEMORY_DEBUG !== 'true') {\n    return;\n  }\n  const memoryUsage = process.memoryUsage() as any;\n  const report: any = {};\n  for (const [key, value] of Object.entries(memoryUsage)) {\n    report[key] = `${Math.round(value as number / 1024 / 1024)} MB`;\n  }\n  process.stderr.write(`[INTEG TEST::${testName}] Memory Usage: ${JSON.stringify(report)}`);\n}\n\nexport function randomString() {\n  // Crazy\n  return Math.random().toString(36).replace(/[^a-z0-9]+/g, '');\n}\n\n/**\n * Write log files\n *\n * Write a text log to `${INTEG_LOGS}/[FAILED-]description-of-test.txt`, and a single\n * line of a Markdown table to `${INTEG_LOGS}/md/1-description-of-test.md`.\n *\n * The latter are designed to be globcatted to $GITHUB_STEP_SUMMARY after tests\n * (we don't write there directly to avoid concurrency issues with multiple processes\n * reading and mutating the same file).\n *\n * We do use `atomicWrite` to write files -- it's only necessary for the header file,\n * which gets overwritten by every test, just to make sure it properly exists (shouldn't\n * end up empty or with interleaved contents). The other writes are not\n * contended and don't need to be atomic, but the function is just ergonomic to use.\n */\nasync function writeLog(testName: string, success: boolean, output: string) {\n  if (process.env.INTEG_LOGS) {\n    const slug = slugify(testName);\n    const logFileName = `${process.env.INTEG_LOGS}/${success ? '' : 'FAILED-'}${slug}.txt`;\n    await atomicWrite(logFileName, output);\n\n    // Sort failures before successes, and the table header before all\n    await atomicWrite(`${process.env.INTEG_LOGS}/md/0-header.md`, [\n      '| Result | Test Name |',\n      '|--------|-----------|',\n    ].map(x => `${x}\\n`).join(''));\n\n    const mdFileName = `${process.env.INTEG_LOGS}/md/${success ? '2' : '1'}-${slug}.md`;\n    const firstColumn = success ? 'pass ✅' : 'fail ❌';\n    await atomicWrite(mdFileName, `| ${firstColumn} | ${testName} |\\n`);\n  }\n}\n\nfunction slugify(x: string) {\n  return x.replace(/[^a-zA-Z0-9_,]+/g, '-');\n}\n\nasync function atomicWrite(fileName: string, contents: string) {\n  await fs.promises.mkdir(path.dirname(fileName), { recursive: true });\n\n  const tmp = `${fileName}.${process.pid}`;\n  await fs.promises.writeFile(tmp, contents);\n  await fs.promises.rename(tmp, fileName);\n}\n"]}

package/lib/npm.d.ts

@@ -1,3 +1,5 @@
+export declare function npmMostRecentMatching(packageName: string, range: string): Promise<any>;
+export declare function npmQueryInstalledVersion(packageName: string, dir: string): Promise<any>;
 /**
  * Use NPM preinstalled on the machine to look up a list of TypeScript versions
  */

package/lib/npm.js

@@ -1,9 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.npmMostRecentMatching = npmMostRecentMatching;
+exports.npmQueryInstalledVersion = npmQueryInstalledVersion;
 exports.typescriptVersionsSync = typescriptVersionsSync;
 exports.typescriptVersionsYoungerThanDaysSync = typescriptVersionsYoungerThanDaysSync;
 const child_process_1 = require("child_process");
+const semver = require("semver");
+const shell_1 = require("./shell");
 const MINIMUM_VERSION = '3.9';
+async function npmMostRecentMatching(packageName, range) {
+    const output = JSON.parse(await (0, shell_1.shell)(['node', require.resolve('npm'), '--silent', 'view', `${packageName}@${range}`, 'version', '--json'], {
+        show: 'error',
+    }));
+    if (typeof output === 'string') {
+        return output;
+    }
+    if (!Array.isArray(output)) {
+        throw new Error(`Expected array from npm, got: ${JSON.stringify(output)}`);
+    }
+    if (output.length === 0) {
+        throw new Error(`Found no package matching ${packageName}@${range}`);
+    }
+    // Otherwise an array that may or may not be sorted. Sort it then get the top one.
+    output.sort((a, b) => semver.compare(a, b));
+    return output[output.length - 1];
+}
+async function npmQueryInstalledVersion(packageName, dir) {
+    const reportStr = await (0, shell_1.shell)(['node', require.resolve('npm'), 'list', '--json', '--depth', '0', packageName], {
+        cwd: dir,
+        show: 'error',
+    });
+    const report = JSON.parse(reportStr);
+    return report.dependencies[packageName].version;
+}
 /**
  * Use NPM preinstalled on the machine to look up a list of TypeScript versions
  */
@@ -35,4 +64,4 @@ function typescriptVersionsYoungerThanDaysSync(days, versions) {
 function reQuote(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,14 @@
+import type { IRunnerSource, ITestCliSource, IPreparedRunnerSource } from './source';
+export declare class RunnerCliNpmSource implements IRunnerSource<ITestCliSource> {
+    private readonly range;
+    readonly sourceDescription: string;
+    constructor(range: string);
+    runnerPrepare(): Promise<IPreparedRunnerSource<ITestCliSource>>;
+}
+export declare class TestCliNpmSource implements ITestCliSource {
+    private readonly installRoot;
+    private readonly range;
+    constructor(installRoot: string, range: string);
+    makeCliAvailable(): Promise<void>;
+    requestedVersion(): string;
+}

package/lib/package-sources/cli-npm-source.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestCliNpmSource = exports.RunnerCliNpmSource = void 0;
+const os = require("os");
+const path = require("path");
+const fs = require("fs-extra");
+const npm_1 = require("../npm");
+const shell_1 = require("../shell");
+class RunnerCliNpmSource {
+    range;
+    sourceDescription;
+    constructor(range) {
+        this.range = range;
+        this.sourceDescription = `${this.range} (npm)`;
+    }
+    async runnerPrepare() {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tmpcdk'));
+        fs.mkdirSync(tempDir, { recursive: true });
+        await (0, shell_1.shell)(['node', require.resolve('npm'), 'install', `aws-cdk@${this.range}`], {
+            cwd: tempDir,
+        });
+        const installedVersion = await (0, npm_1.npmQueryInstalledVersion)('aws-cdk', tempDir);
+        return {
+            version: installedVersion,
+            async dispose() {
+                (0, shell_1.rimraf)(tempDir);
+            },
+            serialize: () => {
+                return [TestCliNpmSource, [tempDir, this.range]];
+            },
+        };
+    }
+}
+exports.RunnerCliNpmSource = RunnerCliNpmSource;
+class TestCliNpmSource {
+    installRoot;
+    range;
+    constructor(installRoot, range) {
+        this.installRoot = installRoot;
+        this.range = range;
+    }
+    async makeCliAvailable() {
+        (0, shell_1.addToShellPath)(path.join(this.installRoot, 'node_modules', '.bin'));
+    }
+    requestedVersion() {
+        return this.range;
+    }
+}
+exports.TestCliNpmSource = TestCliNpmSource;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,19 @@
+import type { IRunnerSource, ITestCliSource, IPreparedRunnerSource } from './source';
+/**
+ * Repo source for the CLI
+ *
+ * Just puts the repo path on the $PATH. The CLI should already be compiled to be executable
+ */
+export declare class RunnerCliRepoSource implements IRunnerSource<ITestCliSource> {
+    private readonly repoRoot;
+    readonly sourceDescription: string;
+    private readonly cliBinPath;
+    constructor(repoRoot: string);
+    runnerPrepare(): Promise<IPreparedRunnerSource<ITestCliSource>>;
+}
+export declare class TestCliRepoSource implements ITestCliSource {
+    private readonly cliPath;
+    constructor(cliPath: string);
+    makeCliAvailable(): Promise<void>;
+    requestedVersion(): string;
+}

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestCliRepoSource = exports.RunnerCliRepoSource = void 0;
+const path = require("path");
+const fs = require("fs-extra");
+const shell_1 = require("../shell");
+/**
+ * Repo source for the CLI
+ *
+ * Just puts the repo path on the $PATH. The CLI should already be compiled to be executable
+ */
+class RunnerCliRepoSource {
+    repoRoot;
+    sourceDescription;
+    cliBinPath;
+    constructor(repoRoot) {
+        this.repoRoot = repoRoot;
+        this.cliBinPath = path.join(this.repoRoot, 'packages', 'aws-cdk', 'bin');
+        this.sourceDescription = this.cliBinPath;
+    }
+    async runnerPrepare() {
+        if (!await fs.pathExists(path.join(this.repoRoot, 'package.json')) || !await fs.pathExists(path.join(this.repoRoot, 'yarn.lock'))) {
+            throw new Error(`${this.repoRoot}: does not look like the repository root`);
+        }
+        const pj = JSON.parse(await fs.readFile(path.join(this.cliBinPath, '..', 'package.json'), 'utf-8'));
+        return {
+            version: pj.version,
+            dispose: () => Promise.resolve(),
+            serialize: () => {
+                return [TestCliRepoSource, [this.cliBinPath]];
+            },
+        };
+    }
+}
+exports.RunnerCliRepoSource = RunnerCliRepoSource;
+class TestCliRepoSource {
+    cliPath;
+    constructor(cliPath) {
+        this.cliPath = cliPath;
+    }
+    async makeCliAvailable() {
+        (0, shell_1.addToShellPath)(this.cliPath);
+    }
+    requestedVersion() {
+        return '*';
+    }
+}
+exports.TestCliRepoSource = TestCliRepoSource;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/package-sources/find-root.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Find the root directory of the repo from the current directory
+ *
+ * We look for a file that is present only in the root of our AWS CDK CLI repository.
+ */
+export declare function autoFindRepoRoot(): Promise<string>;

package/lib/package-sources/find-root.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoFindRepoRoot = autoFindRepoRoot;
+const path = require("path");
+const files_1 = require("../files");
+/**
+ * Find the root directory of the repo from the current directory
+ *
+ * We look for a file that is present only in the root of our AWS CDK CLI repository.
+ */
+async function autoFindRepoRoot() {
+    const found = (0, files_1.findUp)('yarn.lock');
+    if (!found) {
+        throw new Error(`Could not determine repository root: 'yarn.lock' not found from ${process.cwd()}`);
+    }
+    return path.dirname(found);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZC1yb290LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiZmluZC1yb290LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBUUEsNENBTUM7QUFkRCw2QkFBNkI7QUFDN0Isb0NBQWtDO0FBRWxDOzs7O0dBSUc7QUFDSSxLQUFLLFVBQVUsZ0JBQWdCO0lBQ3BDLE1BQU0sS0FBSyxHQUFHLElBQUEsY0FBTSxFQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQ2xDLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNYLE1BQU0sSUFBSSxLQUFLLENBQUMsbUVBQW1FLE9BQU8sQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDdEcsQ0FBQztJQUNELE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUM3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgcGF0aCBmcm9tICdwYXRoJztcbmltcG9ydCB7IGZpbmRVcCB9IGZyb20gJy4uL2ZpbGVzJztcblxuLyoqXG4gKiBGaW5kIHRoZSByb290IGRpcmVjdG9yeSBvZiB0aGUgcmVwbyBmcm9tIHRoZSBjdXJyZW50IGRpcmVjdG9yeVxuICpcbiAqIFdlIGxvb2sgZm9yIGEgZmlsZSB0aGF0IGlzIHByZXNlbnQgb25seSBpbiB0aGUgcm9vdCBvZiBvdXIgQVdTIENESyBDTEkgcmVwb3NpdG9yeS5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGF1dG9GaW5kUmVwb1Jvb3QoKSB7XG4gIGNvbnN0IGZvdW5kID0gZmluZFVwKCd5YXJuLmxvY2snKTtcbiAgaWYgKCFmb3VuZCkge1xuICAgIHRocm93IG5ldyBFcnJvcihgQ291bGQgbm90IGRldGVybWluZSByZXBvc2l0b3J5IHJvb3Q6ICd5YXJuLmxvY2snIG5vdCBmb3VuZCBmcm9tICR7cHJvY2Vzcy5jd2QoKX1gKTtcbiAgfVxuICByZXR1cm4gcGF0aC5kaXJuYW1lKGZvdW5kKTtcbn1cblxuIl19

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

@@ -0,0 +1,20 @@
+import type { IRunnerSource, IPreparedRunnerSource, ITestLibrarySource } from './source';
+/**
+ * A library dependency that cli-integ installs into its own `node_modules`.
+ */
+export declare class RunnerLibraryGlobalInstallSource implements IRunnerSource<ITestLibrarySource> {
+    private readonly packageName;
+    private readonly range;
+    readonly sourceDescription: string;
+    constructor(packageName: string, range: string);
+    runnerPrepare(): Promise<IPreparedRunnerSource<ITestLibrarySource>>;
+}
+export declare class TestLibraryGlobalInstallSource implements ITestLibrarySource {
+    readonly packageName: string;
+    private readonly version;
+    constructor(packageName: string, version: string);
+    requestedVersion(): string;
+    assertJsiiPackagesAvailable(): void;
+    initializeDotnetPackages(currentDir: string): Promise<void>;
+    requestedAlphaVersion(): string;
+}

package/lib/package-sources/library-globalinstall-source.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestLibraryGlobalInstallSource = exports.RunnerLibraryGlobalInstallSource = void 0;
+const fs_1 = require("fs");
+const os = require("os");
+const path = require("path");
+const files_1 = require("../files");
+const npm_1 = require("../npm");
+const shell_1 = require("../shell");
+/**
+ * A library dependency that cli-integ installs into its own `node_modules`.
+ */
+class RunnerLibraryGlobalInstallSource {
+    packageName;
+    range;
+    sourceDescription;
+    constructor(packageName, range) {
+        this.packageName = packageName;
+        this.range = range;
+        this.sourceDescription = `${this.packageName}@${this.range}`;
+    }
+    async runnerPrepare() {
+        // Create a tempdir where we install the requested package, then symlink into our `node_modules`
+        const tempDir = await fs_1.promises.mkdtemp(path.join(os.tmpdir(), 'tmpcdk'));
+        await fs_1.promises.mkdir(tempDir, { recursive: true });
+        await (0, shell_1.shell)(['node', require.resolve('npm'), 'install', `${this.packageName}@${this.range}`], {
+            cwd: tempDir,
+        });
+        const symlinkPath = path.join(__dirname, '..', '..', 'node_modules', this.packageName);
+        await fs_1.promises.mkdir(path.dirname(symlinkPath), { recursive: true });
+        await fs_1.promises.symlink(path.join(tempDir, 'node_modules', this.packageName), symlinkPath, 'junction');
+        const version = await (0, npm_1.npmQueryInstalledVersion)(this.packageName, tempDir);
+        return {
+            version,
+            async dispose() {
+                // Remove the symlink again
+                await fs_1.promises.rm(symlinkPath);
+            },
+            serialize: () => {
+                return [TestLibraryGlobalInstallSource, [this.packageName, version]];
+            },
+        };
+    }
+}
+exports.RunnerLibraryGlobalInstallSource = RunnerLibraryGlobalInstallSource;
+class TestLibraryGlobalInstallSource {
+    packageName;
+    version;
+    constructor(packageName, version) {
+        this.packageName = packageName;
+        this.version = version;
+    }
+    requestedVersion() {
+        return this.version;
+    }
+    assertJsiiPackagesAvailable() {
+        // FIXME: Always a no-op.
+    }
+    async initializeDotnetPackages(currentDir) {
+        // FIXME: this code has nothing to do with the package source, really, so shouldn't be here.
+        if (process.env.CWD_FILES_DIR) {
+            await (0, files_1.copyDirectoryContents)(process.env.CWD_FILES_DIR, currentDir);
+        }
+    }
+    requestedAlphaVersion() {
+        return this.version;
+    }
+}
+exports.TestLibraryGlobalInstallSource = TestLibraryGlobalInstallSource;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,17 @@
+import type { IRunnerSource, IPreparedRunnerSource, ITestLibrarySource } from './source';
+export declare class RunnerLibraryNpmSource implements IRunnerSource<ITestLibrarySource> {
+    private readonly packageName;
+    private readonly range;
+    readonly sourceDescription: string;
+    constructor(packageName: string, range: string);
+    runnerPrepare(): Promise<IPreparedRunnerSource<ITestLibrarySource>>;
+}
+export declare class TestLibraryNpmSource implements ITestLibrarySource {
+    readonly packageName: string;
+    readonly version: string;
+    constructor(packageName: string, version: string);
+    requestedVersion(): string;
+    assertJsiiPackagesAvailable(): void;
+    initializeDotnetPackages(currentDir: string): Promise<void>;
+    requestedAlphaVersion(): string;
+}

package/lib/package-sources/library-npm-source.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestLibraryNpmSource = exports.RunnerLibraryNpmSource = void 0;
+const files_1 = require("../files");
+const npm_1 = require("../npm");
+class RunnerLibraryNpmSource {
+    packageName;
+    range;
+    sourceDescription;
+    constructor(packageName, range) {
+        this.packageName = packageName;
+        this.range = range;
+        this.sourceDescription = `${this.packageName}@${this.range}`;
+    }
+    async runnerPrepare() {
+        const version = await (0, npm_1.npmMostRecentMatching)(this.packageName, this.range);
+        return {
+            version: version,
+            async dispose() {
+            },
+            serialize: () => {
+                return [TestLibraryNpmSource, [this.packageName, version]];
+            },
+        };
+    }
+}
+exports.RunnerLibraryNpmSource = RunnerLibraryNpmSource;
+class TestLibraryNpmSource {
+    packageName;
+    version;
+    constructor(packageName, version) {
+        this.packageName = packageName;
+        this.version = version;
+    }
+    requestedVersion() {
+        return this.version;
+    }
+    assertJsiiPackagesAvailable() {
+        // FIXME: This probably shouldn't be here. Always a no-op.
+    }
+    async initializeDotnetPackages(currentDir) {
+        // FIXME: this code has nothing to do with the package source, really, so shouldn't be here.
+        if (process.env.CWD_FILES_DIR) {
+            await (0, files_1.copyDirectoryContents)(process.env.CWD_FILES_DIR, currentDir);
+        }
+    }
+    requestedAlphaVersion() {
+        const frameworkVersion = this.requestedVersion();
+        if (frameworkVersion.includes('-rc.')) {
+            // For a pipeline release
+            return frameworkVersion.replace(/-rc\.\d+$/, '-alpha.999');
+        }
+        else {
+            // For a stable release
+            return `${frameworkVersion}-alpha.0`;
+        }
+    }
+}
+exports.TestLibraryNpmSource = TestLibraryNpmSource;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,21 @@
+import type { IRunnerSource, IPreparedRunnerSource, ITestLibrarySource } from './source';
+/**
+ * A library dependency that should already be installed via `cli-integ`'s dependencies.
+ */
+export declare class RunnerLibraryPreinstalledSource implements IRunnerSource<ITestLibrarySource> {
+    private readonly packageName;
+    static preinstalledVersion(packageName: string): Promise<string>;
+    static isPreinstalled(packageName: string): Promise<boolean>;
+    readonly sourceDescription: string;
+    constructor(packageName: string);
+    runnerPrepare(): Promise<IPreparedRunnerSource<ITestLibrarySource>>;
+}
+export declare class TestLibraryPreinstalledSource implements ITestLibrarySource {
+    readonly packageName: string;
+    private readonly version;
+    constructor(packageName: string, version: string);
+    requestedVersion(): string;
+    assertJsiiPackagesAvailable(): void;
+    initializeDotnetPackages(currentDir: string): Promise<void>;
+    requestedAlphaVersion(): string;
+}