@aws-cdk-testing/cli-integ 3.23.0 → 3.25.0

package/tests/cli-integ-tests/watch/watch-helpers.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Shared helper functions for watch integration tests.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForOutput = waitForOutput;
+exports.waitForCondition = waitForCondition;
+/**
+ * Poll a condition until we see it.
+ */
+async function poll(condition) {
+    return new Promise((resolve) => {
+        const check = () => {
+            if (condition())
+                return resolve();
+            setTimeout(check, 1000);
+        };
+        check();
+    });
+}
+/**
+ * Wait for a specific string to appear in the output.
+ */
+async function waitForOutput(getOutput, searchString) {
+    return poll(() => getOutput().includes(searchString));
+}
+/**
+ * Wait for a condition to become true.
+ */
+async function waitForCondition(condition) {
+    return poll(condition);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2F0Y2gtaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIndhdGNoLWhlbHBlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOztHQUVHOztBQWtCSCxzQ0FFQztBQUtELDRDQUVDO0FBekJEOztHQUVHO0FBQ0gsS0FBSyxVQUFVLElBQUksQ0FBQyxTQUF3QjtJQUMxQyxPQUFPLElBQUksT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUU7UUFDN0IsTUFBTSxLQUFLLEdBQUcsR0FBRyxFQUFFO1lBQ2pCLElBQUksU0FBUyxFQUFFO2dCQUFFLE9BQU8sT0FBTyxFQUFFLENBQUM7WUFDbEMsVUFBVSxDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQztRQUMxQixDQUFDLENBQUM7UUFDRixLQUFLLEVBQUUsQ0FBQztJQUNWLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQztBQUVEOztHQUVHO0FBQ0ksS0FBSyxVQUFVLGFBQWEsQ0FBQyxTQUF1QixFQUFFLFlBQW9CO0lBQy9FLE9BQU8sSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLFNBQVMsRUFBRSxDQUFDLFFBQVEsQ0FBQyxZQUFZLENBQUMsQ0FBQyxDQUFDO0FBQ3hELENBQUM7QUFFRDs7R0FFRztBQUNJLEtBQUssVUFBVSxnQkFBZ0IsQ0FBQyxTQUF3QjtJQUM3RCxPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztBQUN6QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBTaGFyZWQgaGVscGVyIGZ1bmN0aW9ucyBmb3Igd2F0Y2ggaW50ZWdyYXRpb24gdGVzdHMuXG4gKi9cblxuLyoqXG4gKiBQb2xsIGEgY29uZGl0aW9uIHVudGlsIHdlIHNlZSBpdC5cbiAqL1xuYXN5bmMgZnVuY3Rpb24gcG9sbChjb25kaXRpb246ICgpID0+IGJvb2xlYW4pOiBQcm9taXNlPHZvaWQ+IHtcbiAgcmV0dXJuIG5ldyBQcm9taXNlKChyZXNvbHZlKSA9PiB7XG4gICAgY29uc3QgY2hlY2sgPSAoKSA9PiB7XG4gICAgICBpZiAoY29uZGl0aW9uKCkpIHJldHVybiByZXNvbHZlKCk7XG4gICAgICBzZXRUaW1lb3V0KGNoZWNrLCAxMDAwKTtcbiAgICB9O1xuICAgIGNoZWNrKCk7XG4gIH0pO1xufVxuXG4vKipcbiAqIFdhaXQgZm9yIGEgc3BlY2lmaWMgc3RyaW5nIHRvIGFwcGVhciBpbiB0aGUgb3V0cHV0LlxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gd2FpdEZvck91dHB1dChnZXRPdXRwdXQ6ICgpID0+IHN0cmluZywgc2VhcmNoU3RyaW5nOiBzdHJpbmcpOiBQcm9taXNlPHZvaWQ+IHtcbiAgcmV0dXJuIHBvbGwoKCkgPT4gZ2V0T3V0cHV0KCkuaW5jbHVkZXMoc2VhcmNoU3RyaW5nKSk7XG59XG5cbi8qKlxuICogV2FpdCBmb3IgYSBjb25kaXRpb24gdG8gYmVjb21lIHRydWUuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiB3YWl0Rm9yQ29uZGl0aW9uKGNvbmRpdGlvbjogKCkgPT4gYm9vbGVhbik6IFByb21pc2U8dm9pZD4ge1xuICByZXR1cm4gcG9sbChjb25kaXRpb24pO1xufVxuIl19

package/tests/toolkit-lib-integ-tests/toolkit-deploy-stack-with-multiple-docker-assets.integtest.d.ts

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

package/tests/toolkit-lib-integ-tests/toolkit-deploy-stack-with-multiple-docker-assets.integtest.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+const toolkit = require("@aws-cdk/toolkit-lib");
+const toolkit_helpers_1 = require("./toolkit-helpers");
+const lib_1 = require("../../lib");
+jest.setTimeout(2 * 60 * 60_000); // Includes the time to acquire locks, worst-case single-threaded runtime
+(0, lib_1.integTest)('toolkit deploy stack with multiple docker assets', (0, lib_1.withDefaultFixture)(async (fixture) => {
+    const tk = (0, toolkit_helpers_1.toolkitFromFixture)(fixture);
+    const assembly = await (0, toolkit_helpers_1.assemblyFromCdkAppDir)(tk, fixture);
+    const stacks = {
+        strategy: toolkit.StackSelectionStrategy.PATTERN_MUST_MATCH_SINGLE,
+        patterns: [fixture.fullStackName('multiple-docker-assets')],
+    };
+    await tk.deploy(assembly, {
+        stacks,
+        assetParallelism: true,
+        assetBuildConcurrency: 3,
+    });
+    await tk.destroy(assembly, { stacks });
+}));
+//# sourceMappingURL=data:application/json;base64,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

package/tests/toolkit-lib-integ-tests/toolkit-watch-glob-negative.integtest.d.ts

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

package/tests/toolkit-lib-integ-tests/toolkit-watch-glob-negative.integtest.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+const toolkit = require("@aws-cdk/toolkit-lib");
+const toolkit_helpers_1 = require("./toolkit-helpers");
+const lib_1 = require("../../lib");
+/**
+ * Integration test for toolkit-lib watch with glob pattern matching.
+ *
+ * These tests verify that the chokidar v4 glob pattern fix does not
+ * detects file changes on files that are excluded via config.
+ */
+(0, lib_1.integTest)('toolkit watch excludes node_modules and dotfiles by default', (0, lib_1.withDefaultFixture)(async (fixture) => {
+    const tk = (0, toolkit_helpers_1.toolkitFromFixture)(fixture);
+    const assembly = await (0, toolkit_helpers_1.assemblyFromCdkAppDir)(tk, fixture);
+    // Track the exclude patterns that were configured
+    const configMessages = [];
+    // Create a custom IoHost to capture configuration messages
+    const customTk = new toolkit.Toolkit({
+        ioHost: {
+            notify: async (msg) => {
+                if (msg.code === 'CDK_TOOLKIT_I5310') {
+                    configMessages.push(msg.message);
+                }
+            },
+            requestResponse: async () => undefined,
+        },
+    });
+    // Start watching with default exclude patterns
+    const watcher = await customTk.watch(assembly, {
+        include: ['**'],
+        watchDir: fixture.integTestDir,
+        deploymentMethod: { method: 'hotswap' },
+    });
+    try {
+        // Wait for initialization
+        await new Promise(resolve => setTimeout(resolve, 500));
+        // Verify that default excludes are applied
+        const configMsg = configMessages.find(m => m.includes("'exclude' patterns"));
+        expect(configMsg).toBeDefined();
+        // Check that default excludes are present
+        expect(configMsg).toContain('node_modules');
+        expect(configMsg).toContain('.*');
+        fixture.log('✓ Toolkit watch applies default exclude patterns correctly');
+        fixture.log(`  Config: ${configMsg.substring(0, 200)}...`);
+    }
+    finally {
+        await watcher.dispose();
+        await new Promise(resolve => setTimeout(resolve, 1000)); // Allow async operations to complete
+    }
+}));
+//# sourceMappingURL=data:application/json;base64,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

package/tests/toolkit-lib-integ-tests/toolkit-watch-glob.integtest.d.ts

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

package/tests/toolkit-lib-integ-tests/toolkit-watch-glob.integtest.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+const fs = require("fs");
+const path = require("path");
+const toolkit = require("@aws-cdk/toolkit-lib");
+const toolkit_helpers_1 = require("./toolkit-helpers");
+const lib_1 = require("../../lib");
+/**
+ * Integration test for toolkit-lib watch with glob pattern matching.
+ *
+ * These tests verify that the chokidar v4 glob pattern fix detects file changes.
+ */
+(0, lib_1.integTest)('toolkit watch detects file changes with glob patterns', (0, lib_1.withDefaultFixture)(async (fixture) => {
+    const tk = (0, toolkit_helpers_1.toolkitFromFixture)(fixture);
+    const assembly = await (0, toolkit_helpers_1.assemblyFromCdkAppDir)(tk, fixture);
+    // Track events received from the watcher
+    const receivedEvents = [];
+    // Create a custom IoHost to capture watch events
+    const customTk = new toolkit.Toolkit({
+        ioHost: {
+            notify: async (msg) => {
+                receivedEvents.push({ code: msg.code, message: msg.message });
+            },
+            requestResponse: async () => undefined,
+        },
+    });
+    // Create a test file in the watch directory
+    const testFile = path.join(fixture.integTestDir, 'watch-test-file.ts');
+    // Start watching with specific include patterns
+    const watcher = await customTk.watch(assembly, {
+        include: ['**/*.ts'],
+        exclude: ['**/node_modules/**', '**/*.test.ts'],
+        watchDir: fixture.integTestDir,
+        // Use a deployment method that won't actually deploy (we just want to test file watching)
+        deploymentMethod: { method: 'hotswap' },
+    });
+    try {
+        // Wait a bit for the watcher to initialize
+        await (0, lib_1.sleep)(1000);
+        // Create a new .ts file - this should be detected
+        fs.writeFileSync(testFile, 'export const watchTest = true;');
+        // Wait for the file change to be detected
+        await (0, lib_1.sleep)(2000);
+        // Verify that the watcher detected the file
+        const observingEvents = receivedEvents.filter(e => e.code === 'CDK_TOOLKIT_I5311' || // observing file
+            e.code === 'CDK_TOOLKIT_I5312' || // detected change
+            e.code === 'CDK_TOOLKIT_I5314');
+        fixture.log(`Received ${observingEvents.length} watch-related events`);
+        for (const event of observingEvents) {
+            fixture.log(`  ${event.code}: ${event.message.substring(0, 100)}...`);
+        }
+        // The watcher should have received the ready event and started observing
+        const hasReadyOrObserving = receivedEvents.some(e => e.code === 'CDK_TOOLKIT_I5314' || // triggering initial deploy
+            e.code === 'CDK_TOOLKIT_I5311');
+        expect(hasReadyOrObserving).toBe(true);
+        fixture.log('✓ Toolkit watch successfully initialized and detected files');
+    }
+    finally {
+        // Clean up - dispose and wait for async operations to settle
+        await watcher.dispose();
+        await (0, lib_1.sleep)(1000); // Allow async operations to complete
+        if (fs.existsSync(testFile)) {
+            fs.unlinkSync(testFile);
+        }
+    }
+}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbGtpdC13YXRjaC1nbG9iLmludGVndGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInRvb2xraXQtd2F0Y2gtZ2xvYi5pbnRlZ3Rlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxzREFBc0Q7QUFDdEQseUJBQXlCO0FBQ3pCLDZCQUE2QjtBQUM3QixnREFBZ0Q7QUFDaEQsdURBQThFO0FBQzlFLG1DQUFpRTtBQUVqRTs7OztHQUlHO0FBRUgsSUFBQSxlQUFTLEVBQ1AsdURBQXVELEVBQ3ZELElBQUEsd0JBQWtCLEVBQUMsS0FBSyxFQUFFLE9BQU8sRUFBRSxFQUFFO0lBQ25DLE1BQU0sRUFBRSxHQUFHLElBQUEsb0NBQWtCLEVBQUMsT0FBTyxDQUFDLENBQUM7SUFDdkMsTUFBTSxRQUFRLEdBQUcsTUFBTSxJQUFBLHVDQUFxQixFQUFDLEVBQUUsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUUxRCx5Q0FBeUM7SUFDekMsTUFBTSxjQUFjLEdBQXlELEVBQUUsQ0FBQztJQUVoRixpREFBaUQ7SUFDakQsTUFBTSxRQUFRLEdBQUcsSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDO1FBQ25DLE1BQU0sRUFBRTtZQUNOLE1BQU0sRUFBRSxLQUFLLEVBQUUsR0FBRyxFQUFFLEVBQUU7Z0JBQ3BCLGNBQWMsQ0FBQyxJQUFJLENBQUMsRUFBRSxJQUFJLEVBQUUsR0FBRyxDQUFDLElBQUksRUFBRSxPQUFPLEVBQUUsR0FBRyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7WUFDaEUsQ0FBQztZQUNELGVBQWUsRUFBRSxLQUFLLElBQW1CLEVBQUUsQ0FBQyxTQUF5QjtTQUN0RTtLQUNGLENBQUMsQ0FBQztJQUVILDRDQUE0QztJQUM1QyxNQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxZQUFZLEVBQUUsb0JBQW9CLENBQUMsQ0FBQztJQUV2RSxnREFBZ0Q7SUFDaEQsTUFBTSxPQUFPLEdBQUcsTUFBTSxRQUFRLENBQUMsS0FBSyxDQUFDLFFBQVEsRUFBRTtRQUM3QyxPQUFPLEVBQUUsQ0FBQyxTQUFTLENBQUM7UUFDcEIsT0FBTyxFQUFFLENBQUMsb0JBQW9CLEVBQUUsY0FBYyxDQUFDO1FBQy9DLFFBQVEsRUFBRSxPQUFPLENBQUMsWUFBWTtRQUM5QiwwRkFBMEY7UUFDMUYsZ0JBQWdCLEVBQUUsRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUFFO0tBQ3hDLENBQUMsQ0FBQztJQUVILElBQUksQ0FBQztRQUNILDJDQUEyQztRQUMzQyxNQUFNLElBQUEsV0FBSyxFQUFDLElBQUksQ0FBQyxDQUFDO1FBRWxCLGtEQUFrRDtRQUNsRCxFQUFFLENBQUMsYUFBYSxDQUFDLFFBQVEsRUFBRSxnQ0FBZ0MsQ0FBQyxDQUFDO1FBRTdELDBDQUEwQztRQUMxQyxNQUFNLElBQUEsV0FBSyxFQUFDLElBQUksQ0FBQyxDQUFDO1FBRWxCLDRDQUE0QztRQUM1QyxNQUFNLGVBQWUsR0FBRyxjQUFjLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQ2hELENBQUMsQ0FBQyxJQUFJLEtBQUssbUJBQW1CLElBQUksaUJBQWlCO1lBQ25ELENBQUMsQ0FBQyxJQUFJLEtBQUssbUJBQW1CLElBQUksa0JBQWtCO1lBQ3BELENBQUMsQ0FBQyxJQUFJLEtBQUssbUJBQW1CLENBQy9CLENBQUM7UUFFRixPQUFPLENBQUMsR0FBRyxDQUFDLFlBQVksZUFBZSxDQUFDLE1BQU0sdUJBQXVCLENBQUMsQ0FBQztRQUN2RSxLQUFLLE1BQU0sS0FBSyxJQUFJLGVBQWUsRUFBRSxDQUFDO1lBQ3BDLE9BQU8sQ0FBQyxHQUFHLENBQUMsS0FBSyxLQUFLLENBQUMsSUFBSSxLQUFLLEtBQUssQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLENBQUMsRUFBRSxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDeEUsQ0FBQztRQUVELHlFQUF5RTtRQUN6RSxNQUFNLG1CQUFtQixHQUFHLGNBQWMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FDbEQsQ0FBQyxDQUFDLElBQUksS0FBSyxtQkFBbUIsSUFBSSw0QkFBNEI7WUFDOUQsQ0FBQyxDQUFDLElBQUksS0FBSyxtQkFBbUIsQ0FDL0IsQ0FBQztRQUNGLE1BQU0sQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUV2QyxPQUFPLENBQUMsR0FBRyxDQUFDLDZEQUE2RCxDQUFDLENBQUM7SUFDN0UsQ0FBQztZQUFTLENBQUM7UUFDVCw2REFBNkQ7UUFDN0QsTUFBTSxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDeEIsTUFBTSxJQUFBLFdBQUssRUFBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLHFDQUFxQztRQUN4RCxJQUFJLEVBQUUsQ0FBQyxVQUFVLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQztZQUM1QixFQUFFLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQzFCLENBQUM7SUFDSCxDQUFDO0FBQ0gsQ0FBQyxDQUFDLENBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIGltcG9ydC9uby1leHRyYW5lb3VzLWRlcGVuZGVuY2llcyAqL1xuaW1wb3J0ICogYXMgZnMgZnJvbSAnZnMnO1xuaW1wb3J0ICogYXMgcGF0aCBmcm9tICdwYXRoJztcbmltcG9ydCAqIGFzIHRvb2xraXQgZnJvbSAnQGF3cy1jZGsvdG9vbGtpdC1saWInO1xuaW1wb3J0IHsgYXNzZW1ibHlGcm9tQ2RrQXBwRGlyLCB0b29sa2l0RnJvbUZpeHR1cmUgfSBmcm9tICcuL3Rvb2xraXQtaGVscGVycyc7XG5pbXBvcnQgeyBpbnRlZ1Rlc3QsIHdpdGhEZWZhdWx0Rml4dHVyZSwgc2xlZXAgfSBmcm9tICcuLi8uLi9saWInO1xuXG4vKipcbiAqIEludGVncmF0aW9uIHRlc3QgZm9yIHRvb2xraXQtbGliIHdhdGNoIHdpdGggZ2xvYiBwYXR0ZXJuIG1hdGNoaW5nLlxuICpcbiAqIFRoZXNlIHRlc3RzIHZlcmlmeSB0aGF0IHRoZSBjaG9raWRhciB2NCBnbG9iIHBhdHRlcm4gZml4IGRldGVjdHMgZmlsZSBjaGFuZ2VzLlxuICovXG5cbmludGVnVGVzdChcbiAgJ3Rvb2xraXQgd2F0Y2ggZGV0ZWN0cyBmaWxlIGNoYW5nZXMgd2l0aCBnbG9iIHBhdHRlcm5zJyxcbiAgd2l0aERlZmF1bHRGaXh0dXJlKGFzeW5jIChmaXh0dXJlKSA9PiB7XG4gICAgY29uc3QgdGsgPSB0b29sa2l0RnJvbUZpeHR1cmUoZml4dHVyZSk7XG4gICAgY29uc3QgYXNzZW1ibHkgPSBhd2FpdCBhc3NlbWJseUZyb21DZGtBcHBEaXIodGssIGZpeHR1cmUpO1xuXG4gICAgLy8gVHJhY2sgZXZlbnRzIHJlY2VpdmVkIGZyb20gdGhlIHdhdGNoZXJcbiAgICBjb25zdCByZWNlaXZlZEV2ZW50czogQXJyYXk8eyBjb2RlOiBzdHJpbmcgfCB1bmRlZmluZWQ7IG1lc3NhZ2U6IHN0cmluZyB9PiA9IFtdO1xuXG4gICAgLy8gQ3JlYXRlIGEgY3VzdG9tIElvSG9zdCB0byBjYXB0dXJlIHdhdGNoIGV2ZW50c1xuICAgIGNvbnN0IGN1c3RvbVRrID0gbmV3IHRvb2xraXQuVG9vbGtpdCh7XG4gICAgICBpb0hvc3Q6IHtcbiAgICAgICAgbm90aWZ5OiBhc3luYyAobXNnKSA9PiB7XG4gICAgICAgICAgcmVjZWl2ZWRFdmVudHMucHVzaCh7IGNvZGU6IG1zZy5jb2RlLCBtZXNzYWdlOiBtc2cubWVzc2FnZSB9KTtcbiAgICAgICAgfSxcbiAgICAgICAgcmVxdWVzdFJlc3BvbnNlOiBhc3luYyA8VD4oKTogUHJvbWlzZTxUPiA9PiB1bmRlZmluZWQgYXMgdW5rbm93biBhcyBULFxuICAgICAgfSxcbiAgICB9KTtcblxuICAgIC8vIENyZWF0ZSBhIHRlc3QgZmlsZSBpbiB0aGUgd2F0Y2ggZGlyZWN0b3J5XG4gICAgY29uc3QgdGVzdEZpbGUgPSBwYXRoLmpvaW4oZml4dHVyZS5pbnRlZ1Rlc3REaXIsICd3YXRjaC10ZXN0LWZpbGUudHMnKTtcblxuICAgIC8vIFN0YXJ0IHdhdGNoaW5nIHdpdGggc3BlY2lmaWMgaW5jbHVkZSBwYXR0ZXJuc1xuICAgIGNvbnN0IHdhdGNoZXIgPSBhd2FpdCBjdXN0b21Uay53YXRjaChhc3NlbWJseSwge1xuICAgICAgaW5jbHVkZTogWycqKi8qLnRzJ10sXG4gICAgICBleGNsdWRlOiBbJyoqL25vZGVfbW9kdWxlcy8qKicsICcqKi8qLnRlc3QudHMnXSxcbiAgICAgIHdhdGNoRGlyOiBmaXh0dXJlLmludGVnVGVzdERpcixcbiAgICAgIC8vIFVzZSBhIGRlcGxveW1lbnQgbWV0aG9kIHRoYXQgd29uJ3QgYWN0dWFsbHkgZGVwbG95ICh3ZSBqdXN0IHdhbnQgdG8gdGVzdCBmaWxlIHdhdGNoaW5nKVxuICAgICAgZGVwbG95bWVudE1ldGhvZDogeyBtZXRob2Q6ICdob3Rzd2FwJyB9LFxuICAgIH0pO1xuXG4gICAgdHJ5IHtcbiAgICAgIC8vIFdhaXQgYSBiaXQgZm9yIHRoZSB3YXRjaGVyIHRvIGluaXRpYWxpemVcbiAgICAgIGF3YWl0IHNsZWVwKDEwMDApO1xuXG4gICAgICAvLyBDcmVhdGUgYSBuZXcgLnRzIGZpbGUgLSB0aGlzIHNob3VsZCBiZSBkZXRlY3RlZFxuICAgICAgZnMud3JpdGVGaWxlU3luYyh0ZXN0RmlsZSwgJ2V4cG9ydCBjb25zdCB3YXRjaFRlc3QgPSB0cnVlOycpO1xuXG4gICAgICAvLyBXYWl0IGZvciB0aGUgZmlsZSBjaGFuZ2UgdG8gYmUgZGV0ZWN0ZWRcbiAgICAgIGF3YWl0IHNsZWVwKDIwMDApO1xuXG4gICAgICAvLyBWZXJpZnkgdGhhdCB0aGUgd2F0Y2hlciBkZXRlY3RlZCB0aGUgZmlsZVxuICAgICAgY29uc3Qgb2JzZXJ2aW5nRXZlbnRzID0gcmVjZWl2ZWRFdmVudHMuZmlsdGVyKGUgPT5cbiAgICAgICAgZS5jb2RlID09PSAnQ0RLX1RPT0xLSVRfSTUzMTEnIHx8IC8vIG9ic2VydmluZyBmaWxlXG4gICAgICAgIGUuY29kZSA9PT0gJ0NES19UT09MS0lUX0k1MzEyJyB8fCAvLyBkZXRlY3RlZCBjaGFuZ2VcbiAgICAgICAgZS5jb2RlID09PSAnQ0RLX1RPT0xLSVRfSTUzMTQnLCAvLyB0cmlnZ2VyaW5nIGRlcGxveVxuICAgICAgKTtcblxuICAgICAgZml4dHVyZS5sb2coYFJlY2VpdmVkICR7b2JzZXJ2aW5nRXZlbnRzLmxlbmd0aH0gd2F0Y2gtcmVsYXRlZCBldmVudHNgKTtcbiAgICAgIGZvciAoY29uc3QgZXZlbnQgb2Ygb2JzZXJ2aW5nRXZlbnRzKSB7XG4gICAgICAgIGZpeHR1cmUubG9nKGAgICR7ZXZlbnQuY29kZX06ICR7ZXZlbnQubWVzc2FnZS5zdWJzdHJpbmcoMCwgMTAwKX0uLi5gKTtcbiAgICAgIH1cblxuICAgICAgLy8gVGhlIHdhdGNoZXIgc2hvdWxkIGhhdmUgcmVjZWl2ZWQgdGhlIHJlYWR5IGV2ZW50IGFuZCBzdGFydGVkIG9ic2VydmluZ1xuICAgICAgY29uc3QgaGFzUmVhZHlPck9ic2VydmluZyA9IHJlY2VpdmVkRXZlbnRzLnNvbWUoZSA9PlxuICAgICAgICBlLmNvZGUgPT09ICdDREtfVE9PTEtJVF9JNTMxNCcgfHwgLy8gdHJpZ2dlcmluZyBpbml0aWFsIGRlcGxveVxuICAgICAgICBlLmNvZGUgPT09ICdDREtfVE9PTEtJVF9JNTMxMScsIC8vIG9ic2VydmluZyBmaWxlc1xuICAgICAgKTtcbiAgICAgIGV4cGVjdChoYXNSZWFkeU9yT2JzZXJ2aW5nKS50b0JlKHRydWUpO1xuXG4gICAgICBmaXh0dXJlLmxvZygn4pyTIFRvb2xraXQgd2F0Y2ggc3VjY2Vzc2Z1bGx5IGluaXRpYWxpemVkIGFuZCBkZXRlY3RlZCBmaWxlcycpO1xuICAgIH0gZmluYWxseSB7XG4gICAgICAvLyBDbGVhbiB1cCAtIGRpc3Bvc2UgYW5kIHdhaXQgZm9yIGFzeW5jIG9wZXJhdGlvbnMgdG8gc2V0dGxlXG4gICAgICBhd2FpdCB3YXRjaGVyLmRpc3Bvc2UoKTtcbiAgICAgIGF3YWl0IHNsZWVwKDEwMDApOyAvLyBBbGxvdyBhc3luYyBvcGVyYXRpb25zIHRvIGNvbXBsZXRlXG4gICAgICBpZiAoZnMuZXhpc3RzU3luYyh0ZXN0RmlsZSkpIHtcbiAgICAgICAgZnMudW5saW5rU3luYyh0ZXN0RmlsZSk7XG4gICAgICB9XG4gICAgfVxuICB9KSxcbik7XG4iXX0=